@cydm/happy-elves 0.1.0-beta.5 → 0.1.0-beta.500

package/README.md

@@ -2,14 +2,19 @@
 
 Public beta CLI for Happy Elves.
 
+## First-time hosted machine attach (Windows)
+
+Run once in the existing user account; it detects %USERPROFILE%\.happy-elves\hosted, keeps the current daemon and sessions running, installs the independent updater, and registers per-user startup.
+
+    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.500
+    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.500 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
+
+The same updater entrypoint works on macOS after selecting a permanent user prefix.
+
 ## Hosted relay
 
-```bash
-happy-elves account create --relay https://relay.happyelves.ai --device-name "CLI" --json
-```
+    happy-elves account create --relay https://relay.happyelves.ai --device-name CLI --json
 
 ## Self-host relay
 
-```bash
-happy-elves relay serve --host 0.0.0.0 --port 8787 --json
-```
+    happy-elves relay serve --host 0.0.0.0 --port 8787 --json

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,118 @@
+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 { handleDispatch } from "./dispatch.js";
+import { handleArtifact } from "./artifact.js";
+import { handleGateway } from "./gateway.js";
+import { handleLoop } from "./loop.js";
+import { handleMachine } from "./machine.js";
+import { handleMemory } from "./memory.js";
+import { handleQueue } from "./queue.js";
+import { handleRelay } from "./relay.js";
+import { handleRelease } from "./release.js";
+import { handleSchedule } from "./schedule.js";
+import { handleRemote } from "./remote.js";
+import { handleSession } from "./session.js";
+import { handleSidechat } from "./sidechat.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,
+    handleDispatch,
+    handleQueue,
+    handleArtifact,
+    handleSidechat,
+    handleDaemon,
+    handleRelay,
+    handleRelease,
+    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/artifact.d.ts

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

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

@@ -0,0 +1,97 @@
+import { CliError, ControllerClient, ok, readConfig, requirePositional, requireString, wantsJson, } from "./lib/index.js";
+export async function handleArtifact({ domain, action, positional, flags }) {
+    if (domain !== "artifact")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    if (action === "register") {
+        const machineId = requireString(flags, "machine");
+        const consumerSessionId = requireString(flags, "consumer-session");
+        const file = requireString(flags, "file");
+        const publish = typeof flags.publish === "string" ? flags.publish : undefined;
+        if (publish !== undefined && publish !== "relay") {
+            throw new CliError(`Unsupported --publish value: ${publish}`, "INVALID_ARGUMENT");
+        }
+        const result = await client.artifactRegister({
+            machineId,
+            consumerSessionId,
+            file,
+            ...(typeof flags["artifact-id"] === "string" ? { artifactId: flags["artifact-id"] } : {}),
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["crew-session"] === "string" ? { crewSessionId: flags["crew-session"] } : {}),
+            ...(typeof flags["turn-id"] === "string" ? { turnId: flags["turn-id"] } : {}),
+            ...(typeof flags.title === "string" ? { title: flags.title } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+            ...(publish === "relay" ? { publish: "relay" } : {}),
+        });
+        if (!wantsJson(flags)) {
+            console.log(`${result.artifactId}  rev:${result.revision}  ${result.admission}/${result.publishState}  ${result.url}`);
+            if (result.publishState === "failed")
+                process.exitCode = 1;
+            return true;
+        }
+        ok("artifact.register", result, { requestId: result.requestId, machineId }, result.publishState !== "failed");
+        if (result.publishState === "failed")
+            process.exitCode = 1;
+        return true;
+    }
+    if (action === "list") {
+        const machineId = requireString(flags, "machine");
+        const result = await client.artifactList({
+            machineId,
+            ...(typeof flags["consumer-session"] === "string" ? { consumerSessionId: flags["consumer-session"] } : {}),
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            if (result.records.length === 0)
+                console.log("No artifacts.");
+            else
+                for (const record of result.records) {
+                    console.log(`${record.artifactId}  rev:${record.revision}  ${record.publishState}  consumer:${record.consumerSessionId}  task:${record.taskId ?? "-"}`);
+                }
+            return true;
+        }
+        ok("artifact.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "status") {
+        const machineId = requireString(flags, "machine");
+        const artifactId = requirePositional(positional[0], "artifactId");
+        const result = await client.artifactStatus({
+            machineId,
+            artifactId,
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            const artifact = result.artifact;
+            console.log(artifact ? `${artifact.artifactId}  rev:${artifact.revision}  ${artifact.publishState}  feedback:${artifact.feedbackCursor ?? "-"}` : "Artifact not found.");
+            return true;
+        }
+        ok("artifact.status", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "feedback" && positional[0] === "list") {
+        const machineId = requireString(flags, "machine");
+        const artifactId = requirePositional(positional[1], "artifactId");
+        const result = await client.artifactFeedbackList({
+            machineId,
+            artifactId,
+            ...(typeof flags.after === "string" ? { after: flags.after } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            if (result.records.length === 0)
+                console.log("No feedback.");
+            else
+                for (const record of result.records) {
+                    console.log(`${record.feedbackCursor}  ${record.kind}  rev:${record.revision}  ${record.prompt}`);
+                }
+            return true;
+        }
+        ok("artifact.feedback.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=artifact.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>;