Files

308 lines
12 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* oxlint-disable hanzo/no-global-process-runtime -- Standalone setup must run before workspace dependencies are installed. */
// @effect-diagnostics nodeBuiltinImport:off - standalone bootstrap also runs before dependencies are installed.
// @effect-diagnostics globalConsole:off globalFetch:off globalDate:off - interactive setup and endpoint verification.
import * as NodeCrypto from "node:crypto";
import * as NodeFSP from "node:fs/promises";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeURL from "node:url";
import * as NodeReadlinePromises from "node:readline/promises";
import { patchNativeCli } from "../src/nativeHook.js";
const home = NodeOS.homedir();
const root = NodePath.resolve(import.meta.dirname, "../../..");
const state = NodePath.join(home, ".config/hanzo-task-cache");
const nonInteractive = process.argv.includes("--non-interactive");
const installed = NodePath.join(home, ".local/share/hanzo-task-cache");
const hookConfig = NodePath.join(home, ".config/vite-plus/run-hook.json");
const legacySourceLine = '. "$HOME/.config/hanzo-task-cache/env"';
const sourceLine =
'[ ! -r "$HOME/.config/hanzo-task-cache/env" ] || . "$HOME/.config/hanzo-task-cache/env"';
const profiles = [".profile", ".bashrc", ".bash_profile", ".bash_login", ".zshenv", ".zshrc"];
if (process.argv.includes("--uninstall")) {
for (const file of profiles) {
const path = NodePath.join(home, file);
try {
const original = await NodeFSP.readFile(path, "utf8");
const next = original
.split("\n")
.filter((line) => line !== sourceLine && line !== legacySourceLine)
.join("\n");
if (next !== original) {
if (!next.trim() && (file === ".bash_profile" || file === ".bash_login"))
await NodeFSP.unlink(path);
else await NodeFSP.writeFile(path, next);
}
} catch (error) {
if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
}
}
try {
const config = JSON.parse(await NodeFSP.readFile(hookConfig, "utf8"));
if (config.module === NodePath.join(installed, "runHook.ts")) await NodeFSP.unlink(hookConfig);
} catch (error) {
if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
}
await NodeFSP.rm(NodePath.join(state, "credentials.json"), { force: true });
await NodeFSP.rm(NodePath.join(state, "env"), { force: true });
await NodeFSP.rm(NodePath.join(home, ".cache/hanzo-task-cache/telemetry"), {
recursive: true,
force: true,
});
// Existing shells still import this path until restarted; leave a harmless loader for them.
await NodeFSP.mkdir(installed, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(installed, "preload.mjs"),
"// Task cache uninstalled. Safe for shells opened before uninstall.\n",
);
for (const file of await NodeFSP.readdir(installed)) {
if (file !== "preload.mjs")
await NodeFSP.rm(NodePath.join(installed, file), { recursive: true, force: true });
}
console.log(
"Task cache uninstalled. Restart existing shells and agents to clear their inherited preload.",
);
process.exit(0);
}
const { endpoint: defaultEndpoint } = JSON.parse(
await NodeFSP.readFile(NodePath.join(root, ".task-cache.json"), "utf8"),
);
let credentials: Record<string, { name: string; token: string }> = {};
try {
credentials = JSON.parse(
await NodeFSP.readFile(NodePath.join(state, "credentials.json"), "utf8"),
);
} catch (error) {
if (
!(error instanceof SyntaxError) &&
!(error instanceof Error && "code" in error && error.code === "ENOENT")
)
throw error;
}
const prompt = NodeReadlinePromises.createInterface({
input: process.stdin,
output: process.stdout,
});
let endpoint = process.env.HANZO_CACHE_SETUP_URL || defaultEndpoint;
let name = process.env.HANZO_CACHE_SETUP_NAME || credentials[endpoint]?.name;
let token = process.env.HANZO_CACHE_SETUP_TOKEN || credentials[endpoint]?.token;
const initialEndpoint = endpoint;
const initialName = name;
try {
if (!nonInteractive) {
endpoint = (await prompt.question(`Cache URL [${endpoint}]: `)).trim() || endpoint;
name = (await prompt.question(`Developer name${name ? ` [${name}]` : ""}: `)).trim() || name;
prompt.close();
if (process.stdin.isTTY || !token || endpoint !== initialEndpoint || name !== initialName) {
const savedToken = endpoint === initialEndpoint && name === initialName ? token : undefined;
if (!process.stdin.isTTY)
throw new Error("Use HANZO_CACHE_SETUP_TOKEN for non-interactive setup.");
process.stdout.write(
`Credential token (hidden)${savedToken ? " [Enter keeps saved token]" : ""}: `,
);
process.stdin.setRawMode(true);
process.stdin.resume();
token =
(await new Promise<string>((resolve, reject) => {
let value = "";
const data = (chunk: Buffer) => {
for (const character of chunk.toString()) {
if (character === "\u0003") {
cleanup();
reject(new Error("Cancelled"));
return;
}
if (character === "\r" || character === "\n") {
cleanup();
resolve(value);
return;
}
if (character === "\u007f") value = value.slice(0, -1);
else value += character;
}
};
const cleanup = () => {
process.stdin.off("data", data);
process.stdin.setRawMode(false);
process.stdin.pause();
process.stdout.write("\n");
};
process.stdin.on("data", data);
})) || savedToken;
}
}
} finally {
prompt.close();
}
if (!name || !token || !/^[a-z0-9-]{1,64}$/.test(name) || token.length < 32)
throw new Error("A valid developer name and credential token are required.");
const url = new URL(endpoint);
if (
(url.protocol !== "https:" &&
!(
url.protocol === "http:" &&
(url.hostname === "localhost" ||
/^127(?:\.\d{1,3}){3}$/.test(url.hostname) ||
url.hostname === "[::1]")
)) ||
url.username ||
url.password ||
url.search ||
url.hash
)
throw new Error(
"Use an HTTPS cache endpoint without embedded credentials, query, or fragment (HTTP is only allowed on loopback).",
);
endpoint = url.href.replace(/\/$/, "");
const response = await fetch(`${endpoint}/telemetry`, {
method: "POST",
headers: {
Authorization: `Basic ${Buffer.from(`${name}:${token}`).toString("base64")}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
id: NodeCrypto.randomBytes(32).toString("hex"),
recordedAt: Date.now(),
host: NodeOS.hostname(),
platform: NodeOS.platform(),
arch: NodeOS.arch(),
ci: false,
runId: "setup",
tasks: [],
}),
signal: AbortSignal.timeout(10_000),
});
await response.body?.cancel();
if (!response.ok)
throw new Error(`Credential verification failed (${response.status}); nothing was installed.`);
const candidates = [NodePath.join(root, "node_modules/vite-plus/dist/bin.js")];
for (const directory of [
process.env.VITE_PLUS_HOME,
NodePath.join(home, ".vite-plus/current"),
NodePath.join(home, ".local/share/vite-plus/current"),
]) {
if (directory) candidates.push(NodePath.join(directory, "node_modules/vite-plus/dist/bin.js"));
}
for (let index = 0; index < process.argv.length; index++) {
if (process.argv[index] === "--entrypoint") {
const entrypoint = process.argv[++index];
if (!entrypoint) throw new Error("Missing --entrypoint path");
candidates.push(entrypoint);
}
}
const targets = new Map<string, { original: string; patched: string }>();
for (const candidate of candidates) {
try {
const path = await NodeFSP.realpath(candidate);
const original = await NodeFSP.readFile(path, "utf8");
const backup = await NodeFSP.readFile(`${path}.before-task-cache`, "utf8").catch(
(error: NodeJS.ErrnoException) => {
if (error.code === "ENOENT") return undefined;
throw error;
},
);
if (backup && (original === backup || original === patchNativeCli(backup)))
targets.set(path, { original: backup, patched: original });
} catch (error) {
if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
}
}
await NodeFSP.mkdir(installed, { recursive: true });
await NodeFSP.writeFile(NodePath.join(installed, "package.json"), '{"type":"module"}\n');
for (const file of [
"runHook.ts",
"remoteCache.ts",
"flush.ts",
"telemetry.ts",
"nativeHook.js",
"nativeRunHook.js",
"preload.mjs",
]) {
const destination = NodePath.join(installed, file);
const temporary = `${destination}.${NodeCrypto.randomUUID()}.tmp`;
try {
await NodeFSP.copyFile(NodePath.join(import.meta.dirname, "../src", file), temporary);
await NodeFSP.rename(temporary, destination);
} finally {
await NodeFSP.rm(temporary, { force: true });
}
}
await NodeFSP.mkdir(NodePath.dirname(hookConfig), { recursive: true });
await NodeFSP.writeFile(
hookConfig,
JSON.stringify({
rootMarker: ".task-cache.json",
module: NodePath.join(installed, "runHook.ts"),
}),
);
for (const [path, { original }] of targets) {
await NodeFSP.writeFile(path, original);
await NodeFSP.rm(`${path}.before-task-cache`, { force: true });
await NodeFSP.rm(NodePath.join(NodePath.dirname(path), "run-hook.js"), { force: true });
}
for (const file of [
"nativeHook.ts",
"launcher-telemetry.ts",
"launcherTelemetry.ts",
"vp.ts",
"bin",
])
await NodeFSP.rm(NodePath.join(installed, file), { recursive: true, force: true });
await NodeFSP.mkdir(state, { recursive: true, mode: 0o700 });
credentials[endpoint] = { name, token };
const temporaryCredentials = NodePath.join(state, `.credentials-${NodeCrypto.randomUUID()}.tmp`);
try {
await NodeFSP.writeFile(temporaryCredentials, JSON.stringify(credentials), { mode: 0o600 });
await NodeFSP.rename(temporaryCredentials, NodePath.join(state, "credentials.json"));
} finally {
await NodeFSP.rm(temporaryCredentials, { force: true });
}
const environmentFile = NodePath.join(state, "env");
const preload = NodeURL.pathToFileURL(NodePath.join(installed, "preload.mjs")).href;
await NodeFSP.writeFile(
environmentFile,
[
`if [ -r "${NodePath.join(installed, "preload.mjs")}" ]; then`,
`case " \${NODE_OPTIONS-} " in`,
` *" --import=${preload} "*) ;;`,
` *) export NODE_OPTIONS="\${NODE_OPTIONS:+$NODE_OPTIONS }--import=${preload}" ;;`,
`esac`,
`fi`,
"",
].join("\n"),
{ mode: 0o600 },
);
for (const file of profiles) {
const path = NodePath.join(home, file);
let original = "";
try {
original = await NodeFSP.readFile(path, "utf8");
} catch (error) {
if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
}
if (file === ".bash_profile" || file === ".bash_login") {
if (!original) continue;
// Earlier installers created a profile that masks the user’s existing login profile.
if (file === ".bash_profile" && [sourceLine, legacySourceLine].includes(original.trim())) {
await NodeFSP.unlink(path);
continue;
}
}
if (original.split("\n").includes(legacySourceLine)) {
original = original
.split("\n")
.filter((line) => line !== legacySourceLine)
.join("\n");
await NodeFSP.writeFile(path, original);
}
if (!original.split("\n").includes(sourceLine))
await NodeFSP.appendFile(path, `\n${sourceLine}\n`);
}
console.log(
"Verified credentials and installed the machine-wide Vite+ hook. Open a fresh shell to enable it in all worktrees. Executables and PATH are unchanged.",
);