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

package/apps/cli/dist/commands/account.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleAccount({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/account.js

@@ -0,0 +1,52 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { configDir, configPath, generateAccountSecret, ok, parsePairingStartResponse, randomId, readRelayJson, requireRelayUrl, stopLocalDaemon, throwRelayHttpError, writeConfig } from "./lib/index.js";
+export async function handleAccount({ domain, action, flags }) {
+    if (domain === "account" && action === "create") {
+        const relayUrl = requireRelayUrl(flags);
+        const deviceId = typeof flags["device-id"] === "string" ? flags["device-id"] : randomId("dev");
+        const deviceName = typeof flags["device-name"] === "string" ? flags["device-name"] : os.hostname();
+        const accountSecret = generateAccountSecret();
+        const response = await fetch(`${relayUrl}/api/pairing/start`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ deviceId, deviceName }),
+        });
+        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,
+            controllerToken: paired.controllerToken,
+            accountSecret,
+        };
+        await writeConfig(config);
+        ok("account.create", {
+            accountId: paired.accountId,
+            configPath,
+            relayUrl,
+            deviceId,
+            controllerToken: paired.controllerToken,
+            accountSecret,
+            pairingCode: paired.pairingCode,
+            expiresAt: paired.expiresAt,
+        });
+        return true;
+    }
+    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 true;
+    }
+    return false;
+}
+//# sourceMappingURL=account.js.map

package/apps/cli/dist/commands/app.d.ts

@@ -0,0 +1,3 @@
+import { handleCliError } from "./lib/index.js";
+export { handleCliError };
+export declare function main(): Promise<void>;

package/apps/cli/dist/commands/app.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import { handleAccount } from "./account.js";
+import { handleCollect } from "./collect.js";
+import { handleConfig } from "./config.js";
+import { handleDaemon } from "./daemon.js";
+import { handleGateway } from "./gateway.js";
+import { handleLoop } from "./loop.js";
+import { handleMachine } from "./machine.js";
+import { handleMemory } from "./memory.js";
+import { handleRelay } from "./relay.js";
+import { handleSchedule } from "./schedule.js";
+import { handleRemote } from "./remote.js";
+import { handleSession } from "./session.js";
+import { handleToken } from "./token.js";
+import { handleTurn } from "./turn.js";
+import { handleWorkspace } from "./workspace.js";
+import { commandUsage, commandUsageText, handleCliError, parseCliFlags, skillText, startBootstrap, topLevelDoctor, topLevelStatus, usage, usageText } from "./lib/index.js";
+export { handleCliError };
+const domainHandlers = [
+    handleAccount,
+    handleConfig,
+    handleRemote,
+    handleToken,
+    handleGateway,
+    handleLoop,
+    handleDaemon,
+    handleRelay,
+    handleMachine,
+    handleMemory,
+    handleSchedule,
+    handleSession,
+    handleTurn,
+    handleWorkspace,
+    handleCollect,
+];
+export async function main() {
+    const argv = process.argv.slice(2);
+    const [domain] = argv;
+    if (!domain)
+        usage();
+    if (domain === "--skill" || domain === "skill") {
+        console.log(skillText());
+        return;
+    }
+    if (domain === "--help" || domain === "-h" || domain === "help") {
+        console.log(usageText());
+        return;
+    }
+    if (domain === "--version" || domain === "-v" || domain === "version") {
+        console.log(cliVersion());
+        return;
+    }
+    const topLevelHelpRequested = argv[1] === "help" || argv.slice(1).some((arg) => arg === "--help" || arg === "-h");
+    if (topLevelHelpRequested && commandUsageText(domain)) {
+        console.log(commandUsageText(domain));
+        return;
+    }
+    if (domain === "start") {
+        const { flags } = parseCliFlags(argv.slice(1));
+        await startBootstrap(flags);
+        return;
+    }
+    if (domain === "doctor") {
+        const { flags } = parseCliFlags(argv.slice(1));
+        await topLevelDoctor(flags);
+        return;
+    }
+    if (domain === "status") {
+        const { flags } = parseCliFlags(argv.slice(1));
+        await topLevelStatus(flags);
+        return;
+    }
+    const action = argv[1];
+    const rest = argv.slice(2);
+    if ((!action || action.startsWith("-")) && commandUsageText(domain)) {
+        commandUsage(domain);
+    }
+    const { positional, flags } = parseCliFlags(rest);
+    if (action === "--help" || action === "-h" || action === "help" || flags.help === true || flags.h === true) {
+        console.log(commandUsageText(domain) ?? usageText());
+        return;
+    }
+    const input = { domain, action, positional, flags };
+    for (const handle of domainHandlers) {
+        if (await handle(input))
+            return;
+    }
+    usage();
+}
+function cliVersion() {
+    for (const candidate of [
+        path.resolve(import.meta.dirname, "..", "..", "..", "..", "package.json"),
+        path.resolve(import.meta.dirname, "..", "..", "..", "package.json"),
+        path.resolve(import.meta.dirname, "..", "..", "package.json"),
+    ]) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+            if (typeof parsed.version === "string" && parsed.version.trim())
+                return parsed.version.trim();
+        }
+        catch {
+            // Try the next packaged/source layout.
+        }
+    }
+    return "0.1.0";
+}
+//# sourceMappingURL=app.js.map

package/apps/cli/dist/commands/collect.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleCollect({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/collect.js

@@ -0,0 +1,31 @@
+import { CliError, ControllerClient, conciseEvents, ok, parseEventCursor, printConciseEvents, readConfig, requirePositional, wantsJson, wantsVerbose } from "./lib/index.js";
+export async function handleCollect({ domain, action, flags }) {
+    if (domain !== "collect")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    const sessionId = requirePositional(action, "sessionId");
+    const since = parseEventCursor(flags.since);
+    const limit = typeof flags.limit === "string" ? Number(flags.limit) : undefined;
+    if (limit !== undefined && (!Number.isInteger(limit) || limit <= 0)) {
+        throw new CliError(`Invalid --limit: ${flags.limit}`, "INVALID_ARGUMENT");
+    }
+    const events = await client.collect(sessionId, { since, limit });
+    const lastEventId = events.at(-1)?.id;
+    const nextSince = lastEventId === undefined ? (since ?? null) : `cursor_${lastEventId}`;
+    if (wantsJson(flags) || wantsVerbose(flags)) {
+        ok("session.collect", {
+            sessionId,
+            debugOnly: true,
+            cursor: nextSince,
+            nextSince,
+            ...(wantsVerbose(flags) ? { events } : { events: conciseEvents(events) }),
+        }, { sessionId });
+    }
+    else {
+        printConciseEvents(events);
+        console.log(`nextSince: ${nextSince ?? "none"}`);
+    }
+    return true;
+}
+//# sourceMappingURL=collect.js.map

package/apps/cli/dist/commands/command.d.ts

@@ -0,0 +1,6 @@
+export type CommandInput = {
+    domain: string;
+    action: string | undefined;
+    positional: string[];
+    flags: Record<string, string | boolean>;
+};

package/apps/cli/dist/commands/command.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=command.js.map

package/apps/cli/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleConfig({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/config.js

@@ -0,0 +1,31 @@
+import { configPath, ok, readConfig, redactedControllerConfig, requireRelayUrl, requireString, wantsJson, writeConfig } from "./lib/index.js";
+export async function handleConfig({ domain, action, flags }) {
+    if (domain === "config" && action === "init") {
+        const config = {
+            relayUrl: requireRelayUrl(flags),
+            controllerToken: requireString(flags, "token"),
+            accountSecret: requireString(flags, "secret"),
+        };
+        await writeConfig(config);
+        ok("config.init", { path: configPath, relayUrl: config.relayUrl });
+        return true;
+    }
+    if (domain === "config" && action === "show") {
+        const config = await readConfig(flags);
+        if (!wantsJson(flags)) {
+            const redacted = redactedControllerConfig(config);
+            console.log(`Config: ${configPath}`);
+            console.log(`Relay: ${redacted.relayUrl}`);
+            console.log(`Controller token: ${redacted.hasControllerToken ? "configured" : "missing"}`);
+            console.log(`Account secret: ${redacted.hasAccountSecret ? "configured" : "missing"}`);
+            return true;
+        }
+        ok("config.show", {
+            path: configPath,
+            config: redactedControllerConfig(config),
+        });
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=config.js.map

package/apps/cli/dist/commands/daemon.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleDaemon({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/daemon.js

@@ -0,0 +1,307 @@
+import os from "node:os";
+import path from "node:path";
+import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, ensureDaemonRunning, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForNewConfig, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, waitForMachineProjection, wantsJson, writeDaemonConfig } from "./lib/index.js";
+export async function handleDaemon({ domain, action, flags }) {
+    if (domain === "daemon" && action === "pair") {
+        const relayUrl = requireRelayUrl(flags);
+        const code = requireString(flags, "code");
+        const accountSecret = requireString(flags, "secret");
+        const machineName = typeof flags.name === "string" && flags.name.trim() ? flags.name.trim() : os.hostname();
+        const machineId = typeof flags["machine-id"] === "string" ? flags["machine-id"] : randomId("mach");
+        const response = await fetch(`${relayUrl}/api/pairing/claim`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ code, machineId }),
+        });
+        if (!response.ok) {
+            await throwRelayHttpError(response, "Pairing failed");
+        }
+        const claimed = parsePairingClaimResponse(await readRelayJson(response, "Pairing response is not valid JSON"));
+        const daemonConfig = {
+            relayUrl,
+            accountId: claimed.accountId,
+            machineId: claimed.machineId,
+            machineName,
+            machineToken: claimed.machineToken,
+            accountSecret,
+        };
+        const localBefore = await localDaemonStatus();
+        const daemonConfigPath = await writeDaemonConfig(daemonConfig);
+        let daemonStart = { skipped: true, reason: "not requested" };
+        let projection = { checked: false, reason: "not checked" };
+        let startError;
+        if (flags["no-start"] === true) {
+            daemonStart = { skipped: true, reason: "--no-start" };
+            projection = { checked: false, reason: "--no-start" };
+        }
+        else {
+            try {
+                const startResult = localBefore.running
+                    ? await restartDaemonForNewConfig(relayUrl)
+                    : await ensureDaemonRunning(relayUrl);
+                daemonStart = {
+                    skipped: false,
+                    restarted: localBefore.running,
+                    local: startResult.local,
+                    started: startResult.started,
+                    ...(startResult.startedPid ? { startedPid: startResult.startedPid } : {}),
+                    ...("stopped" in startResult ? { stop: startResult.stopped } : {}),
+                };
+                try {
+                    const controllerConfig = await readConfig({ relay: relayUrl });
+                    const machine = await waitForMachineProjection(new ControllerClient(controllerConfig), claimed.machineId, 10_000);
+                    projection = {
+                        checked: true,
+                        online: machine?.online === true,
+                        machineId: claimed.machineId,
+                        ...(machine?.lastSeen ? { lastSeen: machine.lastSeen } : {}),
+                    };
+                }
+                catch (error) {
+                    projection = {
+                        checked: false,
+                        reason: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            catch (error) {
+                const code = error instanceof CliError ? error.code : "DAEMON_START_FAILED";
+                startError = { code, message: error instanceof Error ? error.message : String(error) };
+                process.exitCode = 1;
+                daemonStart = { skipped: true, reason: "start failed" };
+                projection = { checked: false, reason: "daemon did not start" };
+            }
+        }
+        const data = {
+            path: daemonConfigPath,
+            config: redactedDaemonConfig(daemonConfig),
+            daemon: daemonStart,
+            projection,
+            ...(startError ? { error: startError } : {}),
+        };
+        const commandOk = !startError && !(projection.checked && !projection.online);
+        if (!commandOk)
+            process.exitCode = 1;
+        if (!wantsJson(flags)) {
+            console.log(`Paired ${machineName} with ${relayUrl}`);
+            console.log(`Config: ${daemonConfigPath}`);
+            if (startError) {
+                console.error(`Daemon start failed: ${startError.message}`);
+            }
+            else if (daemonStart.skipped) {
+                console.log(`Daemon start: skipped (${daemonStart.reason})`);
+            }
+            else {
+                console.log(`${daemonStart.restarted ? "Restarted" : "Started"} daemon${daemonStart.startedPid ? ` pid ${daemonStart.startedPid}` : ""}`);
+            }
+            if (projection.checked) {
+                console.log(`Relay projection: ${projection.online ? "online" : "offline"} (${projection.machineId})`);
+                if (!projection.online) {
+                    console.log("If this stays offline, run happy-elves daemon logs --tail 100 and happy-elves daemon status --local.");
+                }
+            }
+            else {
+                console.log(`Relay projection: not checked (${projection.reason})`);
+            }
+            return true;
+        }
+        ok("daemon.pair", data, { machineId: claimed.machineId }, commandOk);
+        return true;
+    }
+    if (domain === "daemon" && action === "doctor") {
+        const checks = [];
+        let config;
+        try {
+            config = await readConfig(flags);
+            checks.push({ name: "config", ok: true, message: configPath });
+        }
+        catch (error) {
+            checks.push({ name: "config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        }
+        if (config) {
+            try {
+                const response = await fetch(`${config.relayUrl}/health`);
+                checks.push({ name: "relay", ok: response.ok, message: response.ok ? "reachable" : await response.text() });
+            }
+            catch (error) {
+                checks.push({ name: "relay", ok: false, message: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        const data = { ok: checks.every((check) => check.ok), checks };
+        if (!wantsJson(flags)) {
+            console.log(`Daemon doctor: ${data.ok ? "ok" : "issues found"}`);
+            for (const check of checks) {
+                console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
+            }
+            if (!data.ok)
+                process.exitCode = 1;
+            return true;
+        }
+        if (!data.ok)
+            process.exitCode = 1;
+        ok("daemon.doctor", data, {}, data.ok);
+        return true;
+    }
+    if (domain === "daemon" && action === "config") {
+        const daemonConfig = await readDaemonConfig();
+        const redacted = redactedDaemonConfig(daemonConfig);
+        if (!wantsJson(flags)) {
+            console.log(`Config: ${path.join(configDir, "daemon.json")}`);
+            console.log(`Relay: ${redacted.relayUrl}`);
+            console.log(`Account: ${redacted.accountId}`);
+            console.log(`Machine: ${redacted.machineName} (${redacted.machineId})`);
+            console.log(`Machine token: ${redacted.hasMachineToken ? "configured" : "missing"}`);
+            console.log(`Account secret: ${redacted.hasAccountSecret ? "configured" : "missing"}`);
+            return true;
+        }
+        ok("daemon.config", {
+            path: path.join(configDir, "daemon.json"),
+            config: redacted,
+        });
+        return true;
+    }
+    if (domain === "daemon" && action === "logs") {
+        const tail = typeof flags.tail === "string" ? Number(flags.tail) : 100;
+        if (!Number.isInteger(tail) || tail <= 0) {
+            throw new CliError(`Invalid --tail: ${flags.tail}`, "INVALID_ARGUMENT");
+        }
+        const entries = await readLocalAuditLog(tail);
+        if (!wantsJson(flags)) {
+            if (entries.length === 0) {
+                console.log("No daemon audit log entries.");
+                return true;
+            }
+            for (const entry of entries) {
+                const record = entry;
+                const createdAt = typeof record.createdAt === "string" ? record.createdAt : "-";
+                const action = typeof record.action === "string" ? record.action : "unknown";
+                const actor = typeof record.actor === "string" ? record.actor : "unknown";
+                const sessionId = typeof record.sessionId === "string" ? record.sessionId : undefined;
+                const summary = typeof record.summary === "string" ? record.summary : JSON.stringify(record);
+                console.log(`${createdAt}  ${action}  ${actor}`);
+                if (sessionId)
+                    console.log(`  session: ${sessionId}`);
+                console.log(`  ${compactText(summary, 160)}`);
+            }
+            return true;
+        }
+        ok("daemon.logs", {
+            path: path.join(configDir, "audit.jsonl"),
+            entries,
+        });
+        return true;
+    }
+    if (domain === "daemon" && action === "start") {
+        const status = await localDaemonStatus();
+        if (status.running) {
+            const existingConfig = await readDaemonConfig();
+            if (typeof flags.relay === "string")
+                existingConfig.relayUrl = requireRelayUrl(flags);
+            const restarted = await ensureDaemonRunning(existingConfig.relayUrl);
+            if (restarted.started) {
+                ok("daemon.start", { ...restarted.local, started: true, startedPid: restarted.startedPid, restartedForChangedConfig: true });
+                return true;
+            }
+            ok("daemon.start", { ...status, started: false });
+            return true;
+        }
+        await readDaemonConfig();
+        const startArgs = typeof flags.relay === "string" ? ["--relay", flags.relay] : [];
+        const pid = spawnDaemonStart(startArgs);
+        ok("daemon.start", { pid, pidPath: daemonPidPath, started: true });
+        return true;
+    }
+    if (domain === "daemon" && action === "stop") {
+        ok("daemon.stop", await stopLocalDaemon());
+        return true;
+    }
+    if (domain === "daemon" && action === "restart") {
+        await readDaemonConfig();
+        const stop = await stopLocalDaemon();
+        const startArgs = typeof flags.relay === "string" ? ["--relay", flags.relay] : [];
+        const pid = spawnDaemonStart(startArgs);
+        ok("daemon.restart", { stop, startedPid: pid, pidPath: daemonPidPath });
+        return true;
+    }
+    if (domain === "daemon" && action === "status" && flags.local === true) {
+        const local = await localDaemonStatus();
+        if (!wantsJson(flags)) {
+            console.log(local.running ? `Daemon: running${local.pid ? ` pid ${local.pid}` : ""}` : "Daemon: stopped");
+            console.log(`Pid file: ${local.pidPath}`);
+            return true;
+        }
+        ok("daemon.status", { local });
+        return true;
+    }
+    if (domain === "daemon" && action === "status") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const local = await localDaemonStatus();
+        const response = await fetch(`${config.relayUrl}/health`);
+        const snapshot = await client.snapshot();
+        const machineFilter = flags.machine === true ? requirePositional(undefined, "machineId") : typeof flags.machine === "string" ? flags.machine : undefined;
+        const machines = machineFilter
+            ? snapshot.machines.filter((machine) => machine.id === machineFilter)
+            : snapshot.machines;
+        if (machineFilter && machines.length === 0)
+            throw new CliError("Machine not found", "MACHINE_NOT_FOUND");
+        const machineIds = new Set(machines.map((machine) => machine.id));
+        const sessions = snapshot.sessions.filter((session) => machineIds.has(session.machineId));
+        const projectedMachines = await Promise.all(machines.map((machine) => showMachine(client, machine)));
+        const projectedSessions = await Promise.all(sessions.map(async (session) => ({
+            sessionId: session.id,
+            machineId: session.machineId,
+            agent: session.agent,
+            status: session.status,
+            orchestration: deriveOrchestration(session, await client.history(session.id, 20)),
+            updatedAt: session.updatedAt,
+            capabilities: session.capabilities,
+        })));
+        const data = {
+            configPath,
+            local,
+            relayUrl: config.relayUrl,
+            relayReachable: response.ok,
+            relay: response.ok ? await response.json() : await response.text(),
+            machines: projectedMachines.map((machine) => ({
+                machineId: machine.id,
+                name: machine.metadata.name ?? machine.name,
+                online: machine.online,
+                lastSeen: machine.lastSeen,
+                defaultCwd: machine.defaultCwd,
+                daemonVersion: machine.capabilities.daemonVersion,
+                acpxVersion: machine.capabilities.acpxVersion,
+                sessionPrimitives: machine.capabilities.sessionPrimitives,
+                agents: machine.capabilities.agents,
+                metadata: machine.metadata,
+            })),
+            sessions: projectedSessions,
+            summary: {
+                machineCount: machines.length,
+                onlineMachineCount: machines.filter((machine) => machine.online).length,
+                sessionCount: projectedSessions.length,
+                runningSessionCount: projectedSessions.filter((session) => session.status === "running").length,
+                idleSessionCount: projectedSessions.filter((session) => idleSessionStatuses.includes(session.status)).length,
+                blockedSessionCount: projectedSessions.filter((session) => session.orchestration.blocked).length,
+                activeSessionCount: projectedSessions.filter((session) => session.orchestration.state === "active").length,
+                completedSessionCount: projectedSessions.filter((session) => session.orchestration.completed).length,
+                needsUserSessionCount: projectedSessions.filter((session) => session.orchestration.needsUser).length,
+            },
+        };
+        if (!wantsJson(flags)) {
+            console.log(`Relay: ${data.relayUrl} ${data.relayReachable ? "ok" : "unreachable"}`);
+            console.log(data.local.running ? `Local daemon: running${data.local.pid ? ` pid ${data.local.pid}` : ""}` : "Local daemon: stopped");
+            console.log(`Machines: ${data.summary.onlineMachineCount}/${data.summary.machineCount} online`);
+            console.log(`Sessions: ${data.summary.sessionCount} total, ${data.summary.runningSessionCount} running, ${data.summary.needsUserSessionCount} needs user`);
+            for (const machine of data.machines) {
+                console.log(`- ${machine.name} (${machine.machineId}) ${machine.online ? "online" : "offline"}`);
+                console.log(`  cwd: ${machine.defaultCwd ?? "-"}`);
+            }
+            return true;
+        }
+        ok("daemon.status", data, machineFilter ? { machineId: machineFilter } : {});
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=daemon.js.map

package/apps/cli/dist/commands/gateway.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleGateway({ domain, action, positional, flags }: CommandInput): Promise<boolean>;