@cydm/happy-elves 0.1.0-beta.1 → 0.1.0-beta.2

package/apps/cli/dist/index.js

@@ -8,6 +8,7 @@ import { generateAccountSecret, randomId, } from "../../../packages/shared/dist/
 const valueFlags = new Set([
     "agent",
     "code",
+    "controller",
     "cwd",
     "device-id",
     "device-name",
@@ -49,11 +50,19 @@ const configDir = process.env.HAPPY_ELVES_HOME
     ? path.resolve(process.env.HAPPY_ELVES_HOME)
     : path.join(os.homedir(), ".happy-elves");
 const configPath = path.join(configDir, "controller.json");
+const defaultHostedRelayUrl = process.env.HAPPY_ELVES_DEFAULT_RELAY_URL ?? "https://relay.happyelves.ai";
+const defaultHostedControllerUrl = process.env.HAPPY_ELVES_DEFAULT_CONTROLLER_URL ?? "https://happyelves.ai";
+const startDaemonTimeoutMs = 10_000;
 function usage() {
     writeError("USAGE", `happy-elves
 
+Start:
+  start [--relay <url>] [--controller <url>] [--cwd <path>] [--no-open] [--json]
+  doctor [--relay <url>] [--json]
+
 Config:
   account create --relay <url> [--device-id <id>] [--device-name <name>] --json
+  account reset --json
   config init --relay <url> --token <controller-token> --secret <account-secret> --json
   config show --json
   remote pairing new --json
@@ -609,6 +618,16 @@ function readProcessCommand(pid) {
         return undefined;
     }
 }
+function readProcessStartedAtMs(pid) {
+    try {
+        const text = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8" }).trim();
+        const startedAt = Date.parse(text);
+        return Number.isFinite(startedAt) ? startedAt : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function isManagedDaemonPid(pid) {
     const command = readProcessCommand(pid);
     const scriptPath = daemonCliPath();
@@ -634,9 +653,23 @@ async function localDaemonStatus() {
     const pid = await readDaemonPid();
     return { pidPath: daemonPidPath, pid, running: pid !== undefined && isPidAlive(pid) && isManagedDaemonPid(pid) };
 }
-function spawnDaemonStart(args) {
+async function daemonBinaryUpdatedAfterStart(status) {
+    if (!status.running || !status.pid)
+        return false;
+    const startedAt = readProcessStartedAtMs(status.pid);
+    if (!startedAt)
+        return false;
+    try {
+        const script = await fs.stat(daemonCliPath());
+        return script.mtimeMs > startedAt + 1000;
+    }
+    catch {
+        return false;
+    }
+}
+function spawnDaemonStart(args, cwd = process.cwd()) {
     const child = spawn(process.execPath, [daemonCliPath(), "start", ...args], {
-        cwd: path.resolve(import.meta.dirname, "../..", ".."),
+        cwd,
         env: { ...process.env, HAPPY_ELVES_HOME: configDir },
         detached: true,
         stdio: "ignore",
@@ -728,10 +761,373 @@ function parsePairingStartResponse(value) {
     }
     return { accountId, controllerToken, pairingCode, expiresAt };
 }
+async function readExistingControllerConfig() {
+    try {
+        return await readConfig({});
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === "CONFIG_MISSING")
+            return undefined;
+        throw error;
+    }
+}
+async function readExistingDaemonConfig() {
+    try {
+        return await readDaemonConfig();
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === "CONFIG_MISSING")
+            return undefined;
+        throw error;
+    }
+}
+function cliErrorFromFetch(error, code, message) {
+    if (error instanceof CliError)
+        return error;
+    const suffix = error instanceof Error ? `: ${error.message}` : "";
+    return new CliError(`${message}${suffix}`, code);
+}
+function backupTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+async function backupConfigFile(filePath, reason) {
+    const backupPath = `${filePath}.bak.${backupTimestamp()}`;
+    try {
+        await fs.rename(filePath, backupPath);
+        return { path: filePath, backupPath, reason };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new CliError(`Could not back up ${filePath}: ${error instanceof Error ? error.message : String(error)}`, "CONFIG_INVALID");
+    }
+}
+async function createControllerConfig(params) {
+    const accountSecret = generateAccountSecret();
+    let response;
+    try {
+        response = await fetch(`${params.relayUrl}/api/pairing/start`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ deviceId: randomId("dev"), deviceName: params.deviceName }),
+        });
+    }
+    catch (error) {
+        throw cliErrorFromFetch(error, "RELAY_UNREACHABLE", `Could not reach ${params.relayUrl}`);
+    }
+    if (!response.ok) {
+        await throwRelayHttpError(response, "Account creation failed");
+    }
+    const paired = parsePairingStartResponse(await readRelayJson(response, "Account creation response is not valid JSON"));
+    const config = {
+        relayUrl: params.relayUrl,
+        controllerToken: paired.controllerToken,
+        accountSecret,
+    };
+    await writeConfig(config);
+    return { config, accountId: paired.accountId };
+}
+async function ensureControllerConfig(params) {
+    let existing;
+    let backup;
+    try {
+        existing = await readExistingControllerConfig();
+    }
+    catch (error) {
+        if (!(error instanceof CliError) || error.code !== "CONFIG_INVALID")
+            throw error;
+        backup = await backupConfigFile(configPath, "invalid-controller-config");
+    }
+    if (existing) {
+        if (params.explicitRelay && existing.relayUrl !== params.relayUrl) {
+            backup = await backupConfigFile(configPath, "controller-relay-changed");
+        }
+        else {
+            return { config: existing, created: false, reconfigured: false };
+        }
+    }
+    const created = await createControllerConfig({ relayUrl: params.relayUrl, deviceName: params.deviceName });
+    return { config: created.config, created: true, accountId: created.accountId, backup, reconfigured: Boolean(backup) };
+}
+async function claimMachinePairing(params) {
+    let response;
+    try {
+        response = await fetch(`${params.relayUrl}/api/pairing/claim`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ code: params.pairingCode, machineId: params.machineId }),
+        });
+    }
+    catch (error) {
+        throw cliErrorFromFetch(error, "RELAY_UNREACHABLE", `Could not reach ${params.relayUrl}`);
+    }
+    if (!response.ok) {
+        await throwRelayHttpError(response, "Machine enrollment failed");
+    }
+    return parsePairingClaimResponse(await readRelayJson(response, "Machine enrollment response is not valid JSON"));
+}
+async function createDaemonConfig(config, machineName) {
+    const pairing = await new ControllerClient(config).createPairingCode();
+    const claimed = await claimMachinePairing({
+        relayUrl: config.relayUrl,
+        pairingCode: pairing.pairingCode,
+        machineId: randomId("mach"),
+    });
+    const daemonConfig = {
+        relayUrl: config.relayUrl,
+        accountId: claimed.accountId,
+        machineId: claimed.machineId,
+        machineName,
+        machineToken: claimed.machineToken,
+        accountSecret: config.accountSecret,
+    };
+    await writeDaemonConfig(daemonConfig);
+    return daemonConfig;
+}
+async function ensureDaemonPaired(config, machineName) {
+    const daemonConfigPath = path.join(configDir, "daemon.json");
+    let existing;
+    let backup;
+    try {
+        existing = await readExistingDaemonConfig();
+    }
+    catch (error) {
+        if (!(error instanceof CliError) || error.code !== "CONFIG_INVALID")
+            throw error;
+        backup = await backupConfigFile(daemonConfigPath, "invalid-daemon-config");
+    }
+    if (existing) {
+        if (existing.relayUrl !== config.relayUrl || existing.accountSecret !== config.accountSecret) {
+            backup = await backupConfigFile(daemonConfigPath, "daemon-account-changed");
+        }
+        else {
+            return { config: existing, created: false, reconfigured: false };
+        }
+    }
+    return { config: await createDaemonConfig(config, machineName), created: true, backup, reconfigured: Boolean(backup) };
+}
+async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
+    const current = await localDaemonStatus();
+    if (current.running) {
+        if (await daemonBinaryUpdatedAfterStart(current)) {
+            return await restartDaemonForNewConfig(relayUrl, cwd);
+        }
+        return { local: current, started: false };
+    }
+    await readDaemonConfig();
+    const startedPid = spawnDaemonStart(["--relay", relayUrl], cwd);
+    if (!startedPid)
+        throw new CliError("Daemon failed to start.", "DAEMON_START_FAILED");
+    const deadline = Date.now() + startDaemonTimeoutMs;
+    while (Date.now() < deadline) {
+        const local = await localDaemonStatus();
+        if (local.running)
+            return { local, started: true, startedPid };
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new CliError("Daemon did not become ready in time. Run happy-elves daemon doctor and happy-elves daemon logs.", "DAEMON_START_FAILED");
+}
+async function restartDaemonForNewConfig(relayUrl, cwd = process.cwd()) {
+    const stopped = await stopLocalDaemon();
+    if (stopped.running) {
+        throw new CliError("Daemon did not stop in time after local config changed. Run happy-elves daemon stop and retry happy-elves start.", "DAEMON_START_FAILED");
+    }
+    const started = await ensureDaemonRunning(relayUrl, cwd);
+    return { stopped, ...started };
+}
+async function waitForMachineProjection(client, machineId, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastSeen;
+    while (Date.now() <= deadline) {
+        const snapshot = await client.snapshot();
+        lastSeen = snapshot.machines.find((machine) => machine.id === machineId);
+        if (lastSeen?.online)
+            return lastSeen;
+        await new Promise((resolve) => setTimeout(resolve, 300));
+    }
+    return lastSeen;
+}
+function controllerBaseUrl(flags) {
+    const value = typeof flags.controller === "string" ? flags.controller : defaultHostedControllerUrl;
+    return value.replace(/\/+$/, "");
+}
+function startRelayUrl(flags, existing) {
+    if (typeof flags.relay === "string") {
+        return { relayUrl: requireRelayUrl(flags), explicit: true };
+    }
+    return { relayUrl: existing?.relayUrl ?? normalizeRelayUrl(defaultHostedRelayUrl), explicit: false };
+}
+function writeHumanStartOutput(data) {
+    console.log("Happy Elves is running.");
+    console.log("");
+    console.log("Workspace");
+    console.log(data.workspace);
+    console.log("");
+    console.log(data.opened ? "Opened controller" : "Controller");
+    console.log(data.controllerUrl);
+    if (data.openError) {
+        console.log(`Could not open automatically: ${data.openError}`);
+    }
+    console.log("");
+    console.log("Phone");
+    console.log("Open the same link on your phone.");
+    console.log("");
+    console.log("Machine");
+    console.log(`${data.machine.online ? "online" : "starting"}, ${data.machine.name}`);
+    console.log("");
+    console.log("Daemon");
+    console.log(`${data.daemon.pid ? `pid ${data.daemon.pid}` : "running"} via ${data.relayUrl}`);
+}
+function openUrl(url) {
+    try {
+        if (process.platform === "darwin") {
+            execFileSync("open", [url], { stdio: "ignore" });
+        }
+        else if (process.platform === "win32") {
+            execFileSync("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+        }
+        else {
+            execFileSync("xdg-open", [url], { stdio: "ignore" });
+        }
+        return { opened: true };
+    }
+    catch (error) {
+        return { opened: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function startBootstrap(flags) {
+    const existingController = await readExistingControllerConfig().catch((error) => {
+        if (error instanceof CliError && error.code === "CONFIG_INVALID")
+            return undefined;
+        throw error;
+    });
+    const relay = startRelayUrl(flags, existingController);
+    const cwd = typeof flags.cwd === "string" ? path.resolve(flags.cwd) : process.cwd();
+    const machineName = typeof flags.name === "string" ? flags.name : os.hostname();
+    const deviceName = typeof flags["device-name"] === "string" ? flags["device-name"] : os.hostname();
+    const controllerState = await ensureControllerConfig({
+        relayUrl: relay.relayUrl,
+        explicitRelay: relay.explicit,
+        deviceName,
+    });
+    const daemonBefore = await localDaemonStatus();
+    const daemonState = await ensureDaemonPaired(controllerState.config, machineName);
+    const daemon = daemonBefore.running && daemonState.reconfigured
+        ? await restartDaemonForNewConfig(controllerState.config.relayUrl, cwd)
+        : await ensureDaemonRunning(controllerState.config.relayUrl, cwd);
+    const client = new ControllerClient(controllerState.config);
+    const machine = await waitForMachineProjection(client, daemonState.config.machineId);
+    if (!machine?.online) {
+        throw new CliError("Daemon started, but this machine did not appear online in the relay snapshot. Run happy-elves doctor and happy-elves daemon logs.", "DAEMON_ONLINE_TIMEOUT");
+    }
+    const invite = await client.createControllerInvite({
+        deviceName: "Web controller",
+        ttlMs: 10 * 60_000,
+        joinUrlBase: controllerBaseUrl(flags),
+        relayUrl: controllerState.config.relayUrl,
+    }).catch((error) => {
+        throw cliErrorFromFetch(error, "INVITE_CREATE_FAILED", "Could not create controller invite");
+    });
+    const data = {
+        relayUrl: controllerState.config.relayUrl,
+        controllerUrl: invite.joinUrl,
+        workspace: cwd,
+        config: {
+            controllerPath: configPath,
+            daemonPath: path.join(configDir, "daemon.json"),
+            controllerCreated: controllerState.created,
+            controllerReconfigured: controllerState.reconfigured,
+            controllerBackupPath: controllerState.backup?.backupPath,
+            daemonPaired: daemonState.created,
+            daemonReconfigured: daemonState.reconfigured,
+            daemonBackupPath: daemonState.backup?.backupPath,
+        },
+        machine: {
+            id: daemonState.config.machineId,
+            name: machine.name ?? daemonState.config.machineName,
+            online: machine.online,
+            lastSeen: machine?.lastSeen,
+        },
+        daemon: {
+            status: daemon.local.running ? "online" : "starting",
+            pid: daemon.local.pid ?? daemon.startedPid,
+            pidPath: daemon.local.pidPath,
+            started: daemon.started,
+            alreadyRunning: daemonBefore.running,
+            restarted: daemonBefore.running && daemonState.reconfigured,
+        },
+        invite: {
+            id: invite.inviteCode,
+            expiresAt: invite.expiresAt,
+        },
+    };
+    if (flags.json === true) {
+        ok("start", data);
+        return;
+    }
+    const openResult = flags["no-open"] === true ? { opened: false } : openUrl(invite.joinUrl);
+    writeHumanStartOutput({
+        workspace: cwd,
+        controllerUrl: invite.joinUrl,
+        relayUrl: controllerState.config.relayUrl,
+        opened: openResult.opened,
+        openError: openResult.error,
+        machine: {
+            name: data.machine.name,
+            online: data.machine.online,
+        },
+        daemon: data.daemon,
+    });
+}
+async function topLevelDoctor(flags) {
+    const checks = [];
+    const existingController = await readExistingControllerConfig().catch((error) => {
+        checks.push({ name: "controller-config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        return undefined;
+    });
+    if (existingController) {
+        checks.push({ name: "controller-config", ok: true, message: configPath, details: redactedControllerConfig(existingController) });
+    }
+    const relay = startRelayUrl(flags, existingController);
+    try {
+        const health = await relayHealth(relay.relayUrl);
+        checks.push({
+            name: "relay",
+            ok: health.ok,
+            message: health.ok ? "reachable" : `HTTP ${health.status}`,
+            details: { relayUrl: relay.relayUrl, body: health.body },
+        });
+    }
+    catch (error) {
+        checks.push({ name: "relay", ok: false, message: error instanceof Error ? error.message : String(error), details: { relayUrl: relay.relayUrl } });
+    }
+    const existingDaemon = await readExistingDaemonConfig().catch((error) => {
+        checks.push({ name: "daemon-config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        return undefined;
+    });
+    if (existingDaemon) {
+        checks.push({ name: "daemon-config", ok: true, message: path.join(configDir, "daemon.json"), details: redactedDaemonConfig(existingDaemon) });
+    }
+    const local = await localDaemonStatus();
+    checks.push({ name: "daemon-process", ok: local.running, message: local.running ? "running" : "not running", details: local });
+    ok("doctor", { ok: checks.every((check) => check.ok), checks });
+}
 async function main() {
-    const [domain, action, ...rest] = process.argv.slice(2);
+    const argv = process.argv.slice(2);
+    const [domain] = argv;
     if (!domain)
         usage();
+    if (domain === "start") {
+        const { flags } = parseFlags(argv.slice(1));
+        await startBootstrap(flags);
+        return;
+    }
+    if (domain === "doctor") {
+        const { flags } = parseFlags(argv.slice(1));
+        await topLevelDoctor(flags);
+        return;
+    }
+    const [, action, ...rest] = argv;
     const { positional, flags } = parseFlags(rest);
     if (domain === "account" && action === "create") {
         const relayUrl = requireRelayUrl(flags);
@@ -764,6 +1160,18 @@ async function main() {
         });
         return;
     }
+    if (domain === "account" && action === "reset") {
+        const stop = await stopLocalDaemon().catch((error) => ({
+            error: error instanceof Error ? error.message : String(error),
+        }));
+        await fs.rm(configPath, { force: true });
+        await fs.rm(path.join(configDir, "daemon.json"), { force: true });
+        ok("account.reset", {
+            removed: [configPath, path.join(configDir, "daemon.json")],
+            stop,
+        });
+        return;
+    }
     if (domain === "config" && action === "init") {
         const config = {
             relayUrl: requireRelayUrl(flags),
@@ -1435,6 +1843,32 @@ async function main() {
 }
 main().catch((error) => {
     const enriched = error;
+    if (process.argv[2] === "start" && !process.argv.includes("--json")) {
+        const code = enriched.code ?? "COMMAND_FAILED";
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        console.error("");
+        if (code === "RELAY_UNREACHABLE") {
+            console.error("Try:");
+            console.error("  happy-elves start --relay <your-relay-url>");
+            console.error("  happy-elves doctor");
+        }
+        else if (code === "DAEMON_START_FAILED" || code === "DAEMON_ONLINE_TIMEOUT") {
+            console.error("Run:");
+            console.error("  happy-elves doctor");
+            console.error("  happy-elves daemon logs");
+        }
+        else if (code === "CONFIG_INVALID") {
+            console.error("Run:");
+            console.error("  happy-elves account reset");
+            console.error("  happy-elves start");
+        }
+        else {
+            console.error("Run:");
+            console.error("  happy-elves doctor");
+        }
+        process.exit(1);
+    }
     writeError(enriched.code ?? "COMMAND_FAILED", error instanceof Error ? error.message : String(error), { requestId: enriched.requestId }, enriched.capability);
     process.exit(1);
 });