@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -44,11 +44,67 @@ function compactTurn(turn) {
     };
 }
 async function readTurnSummary(client, sessionId, turnId) {
-    return summarizeTurns(await client.history(sessionId, 1000)).find((turn) => turn.turnId === turnId);
+    rejectEventPrimitiveId(turnId);
+    return findTurnSummaryByAnyId(summarizeTurns(await client.history(sessionId, 1000)), turnId);
 }
 async function resolveTurnOrCheckpointId(client, sessionId, turnOrCheckpointId) {
+    rejectEventPrimitiveId(turnOrCheckpointId);
     const turn = await readTurnSummary(client, sessionId, turnOrCheckpointId);
-    return turn?.checkpointId ?? turn?.runtimeTurnId ?? turnOrCheckpointId;
+    if (!turn)
+        return turnOrCheckpointId;
+    if (turn.checkpointId && !turn.checkpointId.startsWith("event:"))
+        return turn.checkpointId;
+    if (turn.runtimeTurnId && !turn.runtimeTurnId.startsWith("event:"))
+        return turn.runtimeTurnId;
+    if (!turn.turnId.startsWith("event:"))
+        return turn.turnId;
+    throw new CliError("No provider-safe checkpoint or turn id is available for this turn.", "CHECKPOINT_UNAVAILABLE");
+}
+function rejectEventPrimitiveId(value) {
+    if (value.startsWith("event:")) {
+        throw new CliError("event:* ids are transcript implementation details, not turn/checkpoint/provider ids.", "INVALID_TURN_ID");
+    }
+}
+function findTurnSummaryByAnyId(turns, id) {
+    return turns.find((turn) => turn.turnId === id ||
+        turn.runtimeTurnId === id ||
+        turn.checkpointId === id);
+}
+function recoveryPromptWithContext(turns, inputTurnId, continuation) {
+    const chronological = [...turns].reverse();
+    const selected = [];
+    for (const turn of chronological) {
+        if (inputTurnId && (turn.turnId === inputTurnId || turn.runtimeTurnId === inputTurnId || turn.checkpointId === inputTurnId))
+            break;
+        if (turn.status === "running")
+            break;
+        selected.push(turn);
+    }
+    const blocks = selected.map((turn) => {
+        const lines = [`Turn ${turn.turnId} (${turn.status})`];
+        if (turn.prompt.trim())
+            lines.push(`User:\n${turn.prompt.trim()}`);
+        const output = (turn.output || turn.terminalText).trim();
+        if (output)
+            lines.push(`Assistant:\n${output}`);
+        return lines.join("\n");
+    });
+    const context = clampEnd(blocks.join("\n\n---\n\n"), 32 * 1024);
+    if (!context.trim())
+        return continuation;
+    return [
+        "Recovered context from the original Happy Elves session. The previous turn could not be confirmed, so do not assume it completed and do not replay its original prompt.",
+        "",
+        context,
+        "",
+        "User continuation:",
+        continuation,
+    ].join("\n");
+}
+function clampEnd(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return value.slice(value.length - maxChars);
 }
 async function waitForTurn(client, sessionId, turnId, timeoutMs) {
     const startedAt = Date.now();
@@ -104,7 +160,125 @@ export async function handleTurn({ domain, action, positional, flags }) {
         const turn = await readTurnSummary(client, sessionId, turnId);
         if (!turn)
             throw new CliError(`Turn not found: ${turnId}`, "TURN_NOT_FOUND");
-        ok("turn.status", wantsVerbose(flags) ? { sessionId, turn } : { sessionId, ...compactTurn(turn) }, { sessionId, turnId });
+        const compact = compactTurn(turn);
+        const structured = structuredOutputForTurn(sessionId, turn);
+        ok("turn.status", wantsVerbose(flags)
+            ? { ...structured, inputTurnId: turnId, ...compact, turn }
+            : { ...structured, inputTurnId: turnId, ...compact }, { sessionId, turnId: turn.turnId });
+        return true;
+    }
+    if (action === "reconcile") {
+        const sessionId = requirePositional(positional[0], "sessionId");
+        const turnId = positional[1] ?? (typeof flags.turn === "string" ? flags.turn : undefined);
+        if (turnId)
+            rejectEventPrimitiveId(turnId);
+        const result = await client.reconcileTurn(sessionId, turnId);
+        if (wantsJson(flags)) {
+            ok("turn.reconcile", result, { requestId: result.requestId, sessionId, turnId: result.turnId ?? turnId });
+        }
+        else {
+            console.log(`Reconcile: ${result.status}${result.terminalStatus ? ` (${result.terminalStatus})` : ""}`);
+            if (result.turnId)
+                console.log(`Turn: ${result.turnId}`);
+            if (result.providerTurnId)
+                console.log(`Provider turn: ${result.providerTurnId}`);
+            if (result.reason)
+                console.log(`Reason: ${result.reason}`);
+            if (result.status !== "terminal" && result.status !== "active") {
+                console.log("Unable to confirm whether the previous execution finished. Use turn recover with --confirm-risk before sending a continuation.");
+            }
+        }
+        return true;
+    }
+    if (action === "recover") {
+        const sessionId = requirePositional(positional[0], "sessionId");
+        const inputTurnId = positional[1] ?? (typeof flags.turn === "string" ? flags.turn : undefined);
+        if (inputTurnId)
+            rejectEventPrimitiveId(inputTurnId);
+        if (flags["confirm-risk"] !== true) {
+            throw new CliError("Recovery can duplicate external side effects if the original turn later completes. Re-run with --confirm-risk to create a Recovery Session.", "RECOVERY_CONFIRMATION_REQUIRED");
+        }
+        const continuation = typeof flags.text === "string"
+            ? flags.text
+            : typeof flags["text-file"] === "string"
+                ? await readPromptTextFile(flags["text-file"])
+                : "";
+        if (!continuation.trim())
+            throw new CliError("Missing --text or --text-file", "MISSING_ARGUMENT");
+        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const model = typeof flags.model === "string" && flags.model.trim() ? flags.model.trim() : undefined;
+        const sourceSession = await requireProjectedSession(client, sessionId, "turn.recover");
+        const sourceMetadata = await client.decodeSessionMetadata(sourceSession);
+        const sourceName = sourceMetadata.name ?? sourceSession.name;
+        const recoveryName = `${sourceName} Recovery`;
+        const turns = summarizeTurns(await client.history(sessionId, 1000));
+        const targetTurn = inputTurnId ? findTurnSummaryByAnyId(turns, inputTurnId) : turns[0];
+        let recoverySessionId;
+        let recoveryMode = "new-session-context";
+        let forkError;
+        const checkpoint = targetTurn?.checkpointId && !targetTurn.checkpointId.startsWith("event:") ? targetTurn.checkpointId : undefined;
+        if (checkpoint) {
+            try {
+                const fork = await client.fork(sessionId, { from: checkpoint, name: recoveryName });
+                recoverySessionId = fork.sessionId;
+                recoveryMode = "checkpoint-fork";
+            }
+            catch (error) {
+                forkError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        let promptText = continuation;
+        if (!recoverySessionId) {
+            const created = await client.createSession({
+                machineId: sourceSession.machineId,
+                agent: sourceMetadata.agent ?? sourceSession.agent,
+                cwd: sourceMetadata.cwd ?? sourceSession.cwd,
+                name: recoveryName,
+                createdFrom: "turn.recover",
+                permissionMode,
+                model,
+            });
+            if (!created.sessionId)
+                throw new CliError("Recovery session create was acknowledged without sessionId", "RELAY_RESPONSE_INVALID");
+            recoverySessionId = created.sessionId;
+            promptText = recoveryPromptWithContext(turns, inputTurnId, continuation);
+        }
+        await client.wait(recoverySessionId, { timeoutMs: 120_000 });
+        const wait = flags.detach !== true && flags["no-wait"] !== true;
+        const memoryMode = parseMemoryModeFlag(flags["memory-mode"] ?? flags.memory) ?? "readonly";
+        const recoverySession = await client.getSession(recoverySessionId);
+        const memoryProject = typeof flags["memory-project"] === "string"
+            ? flags["memory-project"]
+            : recoverySession
+                ? `${recoverySession.machineId}:${recoverySession.cwd}`
+                : undefined;
+        const result = await client.run(recoverySessionId, promptText, {
+            wait,
+            permissionMode,
+            memoryMode,
+            model,
+            ...(memoryProject ? { memoryProjectKey: memoryProject } : {}),
+            memoryTopN: 3,
+            waitTimeoutMs: parseDurationMs(flags.timeout, DEFAULT_COMMAND_TIMEOUT_MS),
+            ackTimeoutMs: 15_000,
+        });
+        if (wantsJson(flags)) {
+            ok("turn.recover", {
+                sourceSessionId: sessionId,
+                sourceTurnId: targetTurn?.turnId ?? inputTurnId,
+                recoverySessionId,
+                recoveryTurnId: result.turnId,
+                recoveryMode,
+                ...(forkError ? { forkError } : {}),
+            }, { requestId: result.requestId, sessionId: recoverySessionId, turnId: result.turnId });
+        }
+        else {
+            console.log(`Recovery session: ${recoverySessionId}`);
+            console.log(`Recovery mode: ${recoveryMode}`);
+            if (forkError)
+                console.log(`Checkpoint fork fallback: ${forkError}`);
+            console.log(`Turn: ${result.turnId}`);
+        }
         return true;
     }
     if (action === "run") {
@@ -120,8 +294,29 @@ export async function handleTurn({ domain, action, positional, flags }) {
         const wait = flags.detach !== true && flags["no-wait"] !== true;
         const watchTimeoutMs = parseDurationMs(flags.timeout, DEFAULT_COMMAND_TIMEOUT_MS);
         const ackTimeoutMs = 15_000;
-        const runtimeTimeoutMs = parseDurationMs(flags["runtime-timeout"], DEFAULT_COMMAND_TIMEOUT_MS);
-        const result = await client.run(sessionId, text, { wait, permissionMode, waitTimeoutMs: watchTimeoutMs, ackTimeoutMs, runtimeTimeoutMs });
+        const inactivityTimeoutMs = parseDurationMs(flags["inactivity-timeout"] ?? flags["runtime-timeout"], DEFAULT_COMMAND_TIMEOUT_MS);
+        const memoryMode = parseMemoryModeFlag(flags["memory-mode"] ?? flags.memory) ?? "readonly";
+        const model = typeof flags.model === "string" && flags.model.trim() ? flags.model.trim() : undefined;
+        const session = await client.getSession(sessionId);
+        const memoryProject = typeof flags["memory-project"] === "string"
+            ? flags["memory-project"]
+            : session
+                ? `${session.machineId}:${session.cwd}`
+                : undefined;
+        const memoryTopN = typeof flags["memory-top-n"] === "string" ? Number(flags["memory-top-n"]) : 3;
+        if (!Number.isInteger(memoryTopN) || memoryTopN <= 0)
+            throw new CliError("Invalid --memory-top-n", "INVALID_ARGUMENT");
+        const result = await client.run(sessionId, text, {
+            wait,
+            permissionMode,
+            memoryMode,
+            model,
+            ...(memoryProject ? { memoryProjectKey: memoryProject } : {}),
+            memoryTopN,
+            waitTimeoutMs: watchTimeoutMs,
+            ackTimeoutMs,
+            inactivityTimeoutMs,
+        });
         const events = await client.decodeEvents(result.events);
         const output = wait && result.turnId ? await writeTurnOutput(sessionId, result.turnId, events) : undefined;
         if (wantsJson(flags)) {
@@ -132,10 +327,14 @@ export async function handleTurn({ domain, action, positional, flags }) {
                     : { state: "accepted", sessionId };
             ok("turn.run", {
                 ...structured,
+                memoryMode,
+                ...(memoryProject ? { memoryProjectKey: memoryProject } : {}),
                 ...(wantsVerbose(flags) ? { events, output } : {}),
             }, { requestId: result.requestId, sessionId, turnId: result.turnId });
         }
         else if (wait) {
+            if (memoryMode !== "off")
+                console.log(`Memory mode: ${memoryMode}${memoryProject ? ` (${memoryProject})` : ""}`);
             printConciseEvents(events);
             if (output) {
                 const label = output.status === "completed" ? "Completed" : output.status[0]?.toUpperCase() + output.status.slice(1);
@@ -145,6 +344,8 @@ export async function handleTurn({ domain, action, positional, flags }) {
             }
         }
         else {
+            if (memoryMode !== "off")
+                console.log(`Memory mode: ${memoryMode}${memoryProject ? ` (${memoryProject})` : ""}`);
             console.log(`Turn started: ${result.turnId}`);
         }
         return true;
@@ -158,7 +359,7 @@ export async function handleTurn({ domain, action, positional, flags }) {
                 ...structuredOutputForTurn(sessionId, turn),
                 until: "turn",
                 ...(wantsVerbose(flags) ? { turn } : {}),
-            }, { sessionId, turnId });
+            }, { sessionId, turnId: turn.turnId });
         }
         else {
             console.log(`Turn ${turn.turnId} ${turn.status}`);
@@ -167,8 +368,11 @@ export async function handleTurn({ domain, action, positional, flags }) {
     }
     if (action === "result") {
         const sessionId = requirePositional(positional[0], "sessionId");
-        const turnId = positional[1] ?? (typeof flags.turn === "string" ? flags.turn : undefined);
-        const result = await rebuildTurnOutput(client, sessionId, turnId);
+        const inputTurnId = positional[1] ?? (typeof flags.turn === "string" ? flags.turn : undefined);
+        const turn = inputTurnId ? await readTurnSummary(client, sessionId, inputTurnId) : undefined;
+        if (inputTurnId && !turn)
+            throw new CliError(`Turn not found: ${inputTurnId}`, "TURN_NOT_FOUND");
+        const result = await rebuildTurnOutput(client, sessionId, turn?.turnId);
         if (wantsJson(flags)) {
             ok("turn.result", {
                 ...structuredOutputForStoredTurn(result),
@@ -225,7 +429,10 @@ export async function handleTurn({ domain, action, positional, flags }) {
         const inputTarget = requirePositional(positional[1], "turnOrCheckpointId");
         const from = await resolveTurnOrCheckpointId(client, sessionId, inputTarget);
         const name = requireString(flags, "name");
-        const result = await client.fork(sessionId, { from, name });
+        const sourceTags = flags["copy-tags"] === true
+            ? (await client.decodeSessionMetadata(await requireProjectedSession(client, sessionId, "turn.fork"))).tags
+            : undefined;
+        const result = await client.fork(sessionId, { from, name, tags: sourceTags });
         if (!result.sessionId) {
             throw new CliError("turn.fork was acknowledged without a target session id", "RELAY_RESPONSE_INVALID");
         }
@@ -239,9 +446,18 @@ export async function handleTurn({ domain, action, positional, flags }) {
             currentHead: forkedSession?.currentHead,
             sourceCheckpointId: forkedSession?.sourceCheckpointId,
             name: forkedMetadata.name ?? forkedSession?.name,
+            ...(sourceTags && sourceTags.length > 0 ? { copiedTags: sourceTags } : {}),
         }, { requestId: result.requestId, sessionId: result.sessionId });
         return true;
     }
     return false;
 }
+function parseMemoryModeFlag(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/-/g, "");
+    if (normalized === "off" || normalized === "readonly" || normalized === "readwrite")
+        return normalized;
+    throw new CliError("Invalid --memory-mode; expected off|readonly|readwrite|read-only|read-write", "INVALID_ARGUMENT");
+}
 //# sourceMappingURL=turn.js.map

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

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

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

@@ -0,0 +1,68 @@
+import { CliError, ControllerClient, ok, readConfig, requirePositional, requireString, wantsJson } from "./lib/index.js";
+export async function handleWorkspace({ domain, action, positional, flags }) {
+    if (domain !== "workspace")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    if (action === "state") {
+        const state = await client.workspaceSync();
+        if (!wantsJson(flags)) {
+            console.log(`Stars: ${state.stars.length}`);
+            console.log(`Recent sessions: ${state.recentSessions.length}`);
+            console.log(`Pinned workspaces: ${state.cwdPins.length}`);
+            console.log(`Project preferences: ${state.projectPreferences.length}`);
+            return true;
+        }
+        ok("workspace.state", state);
+        return true;
+    }
+    if (action === "star") {
+        const sessionId = requirePositional(positional[0], "sessionId");
+        ok("workspace.star", await client.starSession(sessionId));
+        return true;
+    }
+    if (action === "unstar") {
+        const sessionId = requirePositional(positional[0], "sessionId");
+        ok("workspace.unstar", await client.unstarSession(sessionId));
+        return true;
+    }
+    if (action === "recent") {
+        const sessionId = requirePositional(positional[0], "sessionId");
+        ok("workspace.recent", await client.markSessionRecent(sessionId));
+        return true;
+    }
+    if (action === "pin-cwd") {
+        const machineId = requireString(flags, "machine");
+        const cwd = requireString(flags, "cwd");
+        const label = typeof flags.label === "string" ? flags.label : undefined;
+        ok("workspace.pin-cwd", await client.pinWorkspaceCwd({ machineId, cwd, label }));
+        return true;
+    }
+    if (action === "unpin-cwd") {
+        const machineId = requireString(flags, "machine");
+        const cwd = requireString(flags, "cwd");
+        ok("workspace.unpin-cwd", await client.unpinWorkspaceCwd({ machineId, cwd }));
+        return true;
+    }
+    if (action === "prefer") {
+        const projectKey = requireString(flags, "project");
+        const machineId = typeof flags.machine === "string" ? flags.machine : undefined;
+        const cwd = typeof flags.cwd === "string" ? flags.cwd : undefined;
+        const agent = typeof flags.agent === "string" ? flags.agent : undefined;
+        const memoryMode = parseMemoryMode(flags["memory-mode"] ?? flags.memory);
+        ok("workspace.prefer", await client.setWorkspaceProjectPreference({ projectKey, machineId, cwd, agent, ...(memoryMode ? { memoryMode } : {}) }));
+        return true;
+    }
+    return false;
+}
+function parseMemoryMode(value) {
+    if (value === undefined || value === false)
+        return undefined;
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/-/g, "");
+    if (normalized === "off" || normalized === "readonly" || normalized === "readwrite")
+        return normalized;
+    throw new CliError("Invalid --memory-mode; expected off|readonly|readwrite|read-only|read-write", "INVALID_ARGUMENT");
+}
+//# sourceMappingURL=workspace.js.map

package/apps/cli/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cydm/happy-elves-cli",
+  "version": "0.1.0-beta.310",
+  "private": true,
+  "type": "module"
+}

package/apps/daemon/dist/gateway/adapters.d.ts

@@ -0,0 +1,38 @@
+import type { GatewayDestination, GatewayEventPayload } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+import type { GatewayChannelConfig } from "./store.js";
+export type GatewayDeliveryInput = {
+    deliveryId: string;
+    destination: GatewayDestination;
+    payload: GatewayEventPayload;
+};
+export type GatewayDeliveryResult = {
+    platformMessageId?: string;
+};
+export type GatewayInboundResult = {
+    accepted: boolean;
+    duplicate?: boolean;
+    queued?: boolean;
+};
+type GatewayInboundSender = (input: {
+    gatewayId: string;
+    platform: "feishu" | "fake";
+    platformEventId: string;
+    platformMessageId: string;
+    senderPlatformUserId: string;
+    senderDisplayName?: string;
+    destination: GatewayDestination;
+    text: string;
+}) => Promise<GatewayInboundResult>;
+export type GatewayAdapter = {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(input: GatewayDeliveryInput): Promise<GatewayDeliveryResult>;
+};
+export type GatewayAdapterContext = {
+    config: DaemonConfig;
+    channel: GatewayChannelConfig;
+    readChannel: () => Promise<GatewayChannelConfig | undefined>;
+    sendInbound: GatewayInboundSender;
+};
+export {};

package/apps/daemon/dist/gateway/adapters.js

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

package/apps/daemon/dist/gateway/feishu.d.ts

@@ -0,0 +1,65 @@
+import type { GatewayDestination } from "../../../../packages/shared/dist/index.js";
+import type { GatewayAdapter, GatewayAdapterContext, GatewayInboundResult } from "./adapters.js";
+type LarkClient = {
+    request?: (input: unknown) => Promise<unknown>;
+    im?: {
+        v1?: {
+            message?: {
+                create?: (input: unknown) => Promise<unknown>;
+                reply?: (input: unknown) => Promise<unknown>;
+            };
+            messageReaction?: {
+                create?: (input: unknown) => Promise<unknown>;
+                delete?: (input: unknown) => Promise<unknown>;
+            };
+            message_reaction?: {
+                create?: (input: unknown) => Promise<unknown>;
+                delete?: (input: unknown) => Promise<unknown>;
+            };
+        };
+        message?: {
+            create?: (input: unknown) => Promise<unknown>;
+            reply?: (input: unknown) => Promise<unknown>;
+        };
+    };
+};
+type FeishuMention = {
+    key?: string;
+    openId?: string;
+    userId?: string;
+    unionId?: string;
+    appId?: string;
+    name?: string;
+    isBot?: boolean;
+};
+type FeishuBotIdentity = {
+    openId?: string;
+    userId?: string;
+    unionId?: string;
+    appId?: string;
+};
+type NormalizedFeishuInbound = Omit<Parameters<GatewayAdapterContext["sendInbound"]>[0], "gatewayId" | "platform"> & {
+    chatType?: string;
+    mentions: FeishuMention[];
+};
+export declare function createFeishuGatewayAdapter(context: GatewayAdapterContext): Promise<GatewayAdapter>;
+export declare function shouldCompleteProcessingReaction(result: GatewayInboundResult, input?: {
+    startedReaction?: boolean;
+}): boolean;
+export declare function createFeishuProcessingReactionTracker(client: LarkClient, input?: {
+    emojiType?: string;
+    maxTracked?: number;
+    now?: () => number;
+}): {
+    start(messageId: string): Promise<boolean>;
+    complete(messageId: string): Promise<void>;
+    clear(): Promise<void>;
+    pendingCount(): number;
+};
+export declare function normalizeFeishuMessage(data: unknown): NormalizedFeishuInbound | undefined;
+export declare function shouldHandleFeishuInbound(profile: {
+    inboundMode: "mention" | "all";
+}, inbound: Pick<NormalizedFeishuInbound, "chatType" | "mentions">, botIdentity: string | FeishuBotIdentity | undefined): boolean;
+export declare function sendFeishuText(client: LarkClient, destination: GatewayDestination, text: string, deliveryId?: string): Promise<unknown>;
+export declare function stripFeishuBotMention(text: string, mentions: FeishuMention[], botIdentity: string | FeishuBotIdentity | undefined): string;
+export {};