@smithers-orchestrator/cli 0.16.0

package/src/format.js

@@ -0,0 +1,272 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./FormatEventLineOptions.ts").FormatEventLineOptions} FormatEventLineOptions */
+// @smithers-type-exports-end
+
+import pc from "picocolors";
+import { eventCategoryForType } from "./event-categories.js";
+function cliColors() {
+    return pc.createColors(true);
+}
+/**
+ * Format a timestamp as relative age: "2m ago", "1h ago", "3d ago"
+ */
+export function formatAge(ms) {
+    const now = Date.now();
+    const diff = now - ms;
+    if (diff < 0)
+        return "just now";
+    const seconds = Math.floor(diff / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+/**
+ * Format elapsed time compactly: "5m 23s", "1h 2m", "45s"
+ */
+export function formatElapsedCompact(startMs, endMs) {
+    const elapsed = (endMs ?? Date.now()) - startMs;
+    const seconds = Math.floor(elapsed / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}
+/**
+ * Format an elapsed time as HH:MM:SS from a base timestamp.
+ */
+export function formatTimestamp(baseMs, eventMs) {
+    const elapsed = eventMs - baseMs;
+    const secs = Math.floor(elapsed / 1000);
+    const mins = Math.floor(secs / 60);
+    const hrs = Math.floor(mins / 60);
+    /**
+   * @param {number} n
+   */
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${pad(hrs)}:${pad(mins % 60)}:${pad(secs % 60)}`;
+}
+/**
+ * Format an elapsed time as a signed relative offset:
+ * +MM:SS.mmm (or +HH:MM:SS.mmm when hours > 0).
+ */
+export function formatRelativeOffset(baseMs, eventMs) {
+    const elapsed = Math.max(0, eventMs - baseMs);
+    const totalSeconds = Math.floor(elapsed / 1000);
+    const millis = elapsed % 1000;
+    const seconds = totalSeconds % 60;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    const minutes = totalMinutes % 60;
+    const hours = Math.floor(totalMinutes / 60);
+    /**
+   * @param {number} n
+   */
+    const pad2 = (n) => String(n).padStart(2, "0");
+    /**
+   * @param {number} n
+   */
+    const pad3 = (n) => String(n).padStart(3, "0");
+    if (hours > 0) {
+        return `+${pad2(hours)}:${pad2(minutes)}:${pad2(seconds)}.${pad3(millis)}`;
+    }
+    return `+${pad2(minutes)}:${pad2(seconds)}.${pad3(millis)}`;
+}
+/**
+ * @param {string} type
+ * @param {string} text
+ * @returns {string}
+ */
+export function colorizeEventText(type, text) {
+    const color = cliColors();
+    if (type.endsWith("Failed") ||
+        type.endsWith("Denied") ||
+        type.endsWith("Error") ||
+        type === "RunCancelled" ||
+        type === "NodeCancelled") {
+        return color.red(text);
+    }
+    if (type.endsWith("Finished") ||
+        type === "ApprovalGranted" ||
+        type === "RunAutoResumed") {
+        return color.green(text);
+    }
+    if (eventCategoryForType(type) === "approval") {
+        return color.yellow(text);
+    }
+    if (eventCategoryForType(type) === "tool-call" ||
+        eventCategoryForType(type) === "openapi") {
+        return color.blue(text);
+    }
+    if (type.endsWith("Started")) {
+        return color.cyan(text);
+    }
+    return text;
+}
+/**
+ * @param {string} value
+ * @param {number} maxLength
+ * @returns {string}
+ */
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+/**
+ * @param {unknown} payload
+ * @param {string} rawPayloadJson
+ * @param {number} maxLength
+ * @returns {string}
+ */
+function summarizePayload(payload, rawPayloadJson, maxLength) {
+    const value = payload === undefined
+        ? rawPayloadJson
+        : typeof payload === "string"
+            ? payload
+            : JSON.stringify(payload);
+    if (!value)
+        return "";
+    return truncateText(value, maxLength);
+}
+/**
+ * Format a single event from _smithers_events into a log line.
+ */
+export function formatEventLine(event, baseMs, options) {
+    const ts = formatTimestamp(baseMs, event.timestampMs);
+    const prefix = options?.includeTimestamp === false ? "" : `[${ts}] `;
+    const truncatePayloadAt = options?.truncatePayloadAt ?? 240;
+    let payload;
+    try {
+        payload = JSON.parse(event.payloadJson);
+    }
+    catch {
+        payload = undefined;
+    }
+    switch (event.type) {
+        case "RunStarted":
+            return `${prefix}▶ Run started`;
+        case "RunStatusChanged":
+            return `${prefix}↺ Run status: ${payload?.status ?? "unknown"}`;
+        case "RunFinished":
+            return `${prefix}✓ Run finished`;
+        case "RunFailed":
+            return `${prefix}✗ Run failed: ${truncateText(String(payload?.error ?? "unknown"), truncatePayloadAt)}`;
+        case "RunCancelled":
+            return `${prefix}⊘ Run cancelled`;
+        case "RunContinuedAsNew":
+            return `${prefix}⇢ Continued as new: ${payload?.newRunId ?? "?"} (iteration ${payload?.iteration ?? 0})`;
+        case "RunHijackRequested":
+            return `${prefix}⇢ Hijack requested`;
+        case "RunHijacked":
+            return payload?.mode === "conversation"
+                ? `${prefix}⇢ Hijacked ${payload?.engine ?? "agent"} conversation`
+                : `${prefix}⇢ Hijacked ${payload?.engine ?? "agent"} session ${payload?.resume ?? ""}`.trim();
+        case "SandboxCreated":
+            return `${prefix}🧪 Sandbox created: ${payload?.sandboxId ?? "?"} (${payload?.runtime ?? "bubblewrap"})`;
+        case "SandboxShipped":
+            return `${prefix}📦 Sandbox shipped: ${payload?.sandboxId ?? "?"} (${payload?.bundleSizeBytes ?? 0} bytes)`;
+        case "SandboxHeartbeat":
+            return `${prefix}💓 Sandbox heartbeat: ${payload?.sandboxId ?? "?"}`;
+        case "SandboxBundleReceived":
+            return `${prefix}📥 Sandbox bundle received: ${payload?.sandboxId ?? "?"} (${payload?.patchCount ?? 0} patches)`;
+        case "SandboxCompleted":
+            return `${prefix}✅ Sandbox completed: ${payload?.sandboxId ?? "?"} (${payload?.status ?? "finished"})`;
+        case "SandboxFailed":
+            return `${prefix}❌ Sandbox failed: ${payload?.sandboxId ?? "?"}`;
+        case "SandboxDiffReviewRequested":
+            return `${prefix}📝 Sandbox diff review requested: ${payload?.sandboxId ?? "?"}`;
+        case "SandboxDiffAccepted":
+            return `${prefix}👍 Sandbox diffs accepted: ${payload?.sandboxId ?? "?"}`;
+        case "SandboxDiffRejected":
+            return `${prefix}👎 Sandbox diffs rejected: ${payload?.sandboxId ?? "?"}`;
+        case "NodePending":
+            return `${prefix}… ${payload?.nodeId ?? "?"} pending (iteration ${payload?.iteration ?? 0})`;
+        case "NodeStarted":
+            return `${prefix}→ ${payload?.nodeId ?? "?"} (attempt ${payload?.attempt ?? 1}, iteration ${payload?.iteration ?? 0})`;
+        case "TaskHeartbeat":
+            return `${prefix}💓 ${payload?.nodeId ?? "?"} heartbeat (${payload?.dataSizeBytes ?? 0} bytes)`;
+        case "TaskHeartbeatTimeout":
+            return `${prefix}⏲ ${payload?.nodeId ?? "?"} heartbeat timeout (${payload?.timeoutMs ?? 0}ms)`;
+        case "NodeFinished":
+            return `${prefix}✓ ${payload?.nodeId ?? "?"} (attempt ${payload?.attempt ?? 1})`;
+        case "NodeFailed":
+            return `${prefix}✗ ${payload?.nodeId ?? "?"} (attempt ${payload?.attempt ?? 1}): ${truncateText(String(payload?.error ?? "failed"), truncatePayloadAt)}`;
+        case "NodeCancelled":
+            return `${prefix}⊘ ${payload?.nodeId ?? "?"} cancelled`;
+        case "NodeSkipped":
+            return `${prefix}↷ ${payload?.nodeId ?? "?"} skipped`;
+        case "NodeRetrying":
+            return `${prefix}↻ ${payload?.nodeId ?? "?"} retrying (attempt ${payload?.attempt ?? 1})`;
+        case "NodeWaitingApproval":
+            return `${prefix}⏸ ${payload?.nodeId ?? "?"} waiting for approval`;
+        case "NodeWaitingTimer":
+            return `${prefix}⏱ Waiting for timer: ${payload?.nodeId ?? "?"}`;
+        case "ApprovalRequested":
+            return `${prefix}⏸ Approval requested: ${payload?.nodeId ?? "?"}`;
+        case "ApprovalGranted":
+            return `${prefix}✓ Approved: ${payload?.nodeId ?? "?"}`;
+        case "ApprovalAutoApproved":
+            return `${prefix}✓ Auto-approved: ${payload?.nodeId ?? "?"}`;
+        case "ApprovalDenied":
+            return `${prefix}✗ Denied: ${payload?.nodeId ?? "?"}`;
+        case "ToolCallStarted":
+            return `${prefix}🔧 ${payload?.nodeId ?? "?"} → ${payload?.toolName ?? "tool"} (attempt ${payload?.attempt ?? 1})`;
+        case "ToolCallFinished":
+            return `${prefix}🔧 ${payload?.nodeId ?? "?"} ← ${payload?.toolName ?? "tool"} (${payload?.status ?? "done"})`;
+        case "ScorerStarted":
+            return `${prefix}📊 ${payload?.nodeId ?? "?"} scorer ${payload?.scorerName ?? payload?.scorerId ?? "?"} started`;
+        case "ScorerFinished":
+            return `${prefix}📊 ${payload?.nodeId ?? "?"} scorer ${payload?.scorerName ?? payload?.scorerId ?? "?"} = ${payload?.score ?? "?"}`;
+        case "ScorerFailed":
+            return `${prefix}📊 ${payload?.nodeId ?? "?"} scorer ${payload?.scorerName ?? payload?.scorerId ?? "?"} failed`;
+        case "TokenUsageReported":
+            return `${prefix}🧮 ${payload?.nodeId ?? "?"} ${payload?.model ?? "model"} in=${payload?.inputTokens ?? 0} out=${payload?.outputTokens ?? 0}`;
+        case "TimerCreated":
+            return `${prefix}⏱ Timer created: ${payload?.timerId ?? "?"} (fires ${new Date(payload?.firesAtMs ?? 0).toISOString()})`;
+        case "TimerFired":
+            return `${prefix}🔔 Timer fired: ${payload?.timerId ?? "?"} (delay ${payload?.delayMs ?? 0}ms)`;
+        case "TimerCancelled":
+            return `${prefix}⊘ Timer cancelled: ${payload?.timerId ?? "?"}`;
+        case "WorkflowReloadDetected":
+            return `${prefix}⟳ File change detected`;
+        case "WorkflowReloaded":
+            return `${prefix}⟳ Workflow reloaded`;
+        case "WorkflowReloadFailed":
+            return `${prefix}⟳ Workflow reload failed`;
+        case "WorkflowReloadUnsafe":
+            return `${prefix}⟳ Workflow reload skipped: unsafe`;
+        case "AgentEvent":
+            return `${prefix}${payload?.engine ?? "agent"}: ${payload?.event?.type ?? "event"}`;
+        case "FrameCommitted":
+            return `${prefix}🖼 Frame ${payload?.frameNo ?? "?"} committed`;
+        case "SnapshotCaptured":
+            return `${prefix}📸 Snapshot ${payload?.frameNo ?? "?"} captured`;
+        case "RevertStarted":
+            return `${prefix}↩ Revert started on ${payload?.nodeId ?? "?"}`;
+        case "RevertFinished":
+            return `${prefix}${payload?.success ? "✓" : "✗"} Revert ${payload?.success ? "finished" : "failed"} on ${payload?.nodeId ?? "?"}`;
+        case "TimeTravelStarted":
+            return `${prefix}↺ Time travel started on ${payload?.nodeId ?? "?"}`;
+        case "TimeTravelFinished":
+            return `${prefix}${payload?.success ? "✓" : "✗"} Time travel ${payload?.success ? "finished" : "failed"} on ${payload?.nodeId ?? "?"}`;
+        case "OpenApiToolCalled":
+            return `${prefix}🌐 ${payload?.method ?? "?"} ${payload?.path ?? payload?.operationId ?? "?"} (${payload?.status ?? "unknown"})`;
+        case "MemoryFactSet":
+            return `${prefix}🧠 Memory set ${payload?.namespace ?? "default"}/${payload?.key ?? "?"}`;
+        case "MemoryRecalled":
+            return `${prefix}🧠 Memory recalled ${payload?.resultCount ?? 0} results`;
+        case "MemoryMessageSaved":
+            return `${prefix}🧠 Message saved to thread ${payload?.threadId ?? "?"}`;
+        default:
+            return `${prefix}${event.type} ${summarizePayload(payload, event.payloadJson, truncatePayloadAt)}`.trim();
+    }
+}

package/src/hijack-session.js

@@ -0,0 +1,207 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout, stderr } from "node:process";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { SmithersCtx } from "@smithers-orchestrator/driver";
+import { loadInput, loadOutputs } from "@smithers-orchestrator/db/snapshot";
+import { renderFrame, resolveSchema } from "@smithers-orchestrator/engine";
+import { mdxPlugin } from "smithers-orchestrator/mdx-plugin";
+import { SmithersError } from "@smithers-orchestrator/errors";
+import { Effect } from "effect";
+/** @typedef {import("./HijackCandidate.ts").HijackCandidate} HijackCandidate */
+/** @typedef {import("@smithers-orchestrator/db/adapter").SmithersDb} SmithersDb */
+
+/**
+ * @template T
+ * @param {T} value
+ * @returns {T | undefined}
+ */
+function cloneJsonValue(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * @param {string | null} [metaJson]
+ * @returns {Record<string, unknown>}
+ */
+function parseAttemptMeta(metaJson) {
+    if (!metaJson)
+        return {};
+    try {
+        const parsed = JSON.parse(metaJson);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * @param {string} workflowPath
+ * @returns {Promise<SmithersWorkflow<any>>}
+ */
+async function loadWorkflow(workflowPath) {
+    const abs = resolve(process.cwd(), workflowPath);
+    mdxPlugin();
+    const mod = await import(pathToFileURL(abs).href);
+    if (!mod.default) {
+        throw new SmithersError("WORKFLOW_MISSING_DEFAULT", `Workflow ${workflowPath} must export default`);
+    }
+    return mod.default;
+}
+/**
+ * @param {SmithersDb} adapter
+ * @param {HijackCandidate & { mode: "conversation"; messages: unknown[] }} candidate
+ */
+async function resolveConversationAgent(adapter, candidate) {
+    const run = await adapter.getRun(candidate.runId);
+    const workflowPath = run?.workflowPath;
+    if (!workflowPath) {
+        throw new SmithersError("HIJACK_WORKFLOW_PATH", `Run ${candidate.runId} does not have a workflowPath; cannot reconstruct agent`);
+    }
+    const workflow = await loadWorkflow(workflowPath);
+    const schema = resolveSchema(workflow.db);
+    const inputTable = schema.input;
+    const inputRow = inputTable
+        ? ((await loadInput(workflow.db, inputTable, candidate.runId)) ?? {})
+        : {};
+    const outputs = await loadOutputs(workflow.db, schema, candidate.runId);
+    const ctx = new SmithersCtx({
+        runId: candidate.runId,
+        iteration: candidate.iteration,
+        input: inputRow ?? {},
+        outputs,
+        zodToKeyName: workflow.zodToKeyName,
+    });
+    const baseRootDir = dirname(resolve(workflowPath));
+    const snap = await Effect.runPromise(renderFrame(workflow, ctx, {
+        baseRootDir,
+        workflowPath,
+    }));
+    const task = snap.tasks.find((entry) => entry.nodeId === candidate.nodeId &&
+        (entry.iteration ?? 0) === candidate.iteration) ?? snap.tasks.find((entry) => entry.nodeId === candidate.nodeId);
+    if (!task?.agent) {
+        throw new SmithersError("HIJACK_AGENT_NOT_FOUND", `Could not find agent-backed task ${candidate.nodeId} in ${workflowPath}`);
+    }
+    const allAgents = Array.isArray(task.agent) ? task.agent : [task.agent];
+    const effectiveAgent = allAgents[Math.min(candidate.attempt - 1, allAgents.length - 1)];
+    if (!effectiveAgent) {
+        throw new SmithersError("HIJACK_AGENT_EMPTY", `Task ${candidate.nodeId} does not have a usable agent to hijack`);
+    }
+    return {
+        workflowPath,
+        agent: effectiveAgent,
+    };
+}
+/**
+ * @param {SmithersDb} adapter
+ * @param {HijackCandidate} candidate
+ * @param {unknown[]} messages
+ */
+export async function persistConversationHijackHandoff(adapter, candidate, messages) {
+    const attempt = await adapter.getAttempt(candidate.runId, candidate.nodeId, candidate.iteration, candidate.attempt);
+    if (!attempt) {
+        throw new SmithersError("HIJACK_ATTEMPT_NOT_FOUND", `Attempt ${candidate.nodeId}#${candidate.attempt} no longer exists`);
+    }
+    const clonedMessages = cloneJsonValue(messages) ?? messages;
+    const meta = parseAttemptMeta(attempt.metaJson);
+    meta.agentConversation = clonedMessages;
+    meta.hijackHandoff = {
+        engine: candidate.engine,
+        mode: "conversation",
+        messages: clonedMessages,
+        requestedAtMs: Date.now(),
+        cwd: candidate.cwd,
+        nodeId: candidate.nodeId,
+        iteration: candidate.iteration,
+        attempt: candidate.attempt,
+    };
+    await adapter.updateAttempt(candidate.runId, candidate.nodeId, candidate.iteration, candidate.attempt, {
+        metaJson: JSON.stringify(meta),
+    });
+}
+/**
+ * @param {SmithersDb} adapter
+ * @param {HijackCandidate & { mode: "conversation"; messages: unknown[] }} candidate
+ * @returns {Promise<{ code: number; messages: unknown[] }>}
+ */
+export async function launchConversationHijackSession(adapter, candidate) {
+    const { agent } = await resolveConversationAgent(adapter, candidate);
+    const rl = createInterface({
+        input: stdin,
+        output: stdout,
+        terminal: true,
+    });
+    let messages = cloneJsonValue(candidate.messages) ?? candidate.messages;
+    stderr.write(`[smithers] hijacking ${candidate.engine} conversation from ${candidate.nodeId}#${candidate.attempt}\n`);
+    stderr.write("[smithers] enter /exit to return control to Smithers\n");
+    try {
+        while (true) {
+            const line = (await rl.question("> ")).trim();
+            if (!line)
+                continue;
+            if (line === "/exit" || line === "/quit") {
+                break;
+            }
+            if (line === "/help") {
+                stdout.write("/exit  return control to Smithers\n/help  show this message\n");
+                continue;
+            }
+            const nextMessages = [
+                ...messages,
+                { role: "user", content: line },
+            ];
+            try {
+                const stepMessages = [];
+                let streamedAny = false;
+                const result = await agent.generate({
+                    options: undefined,
+                    messages: nextMessages,
+                    onStdout: (chunk) => {
+                        streamedAny = true;
+                        stdout.write(chunk);
+                    },
+                    onStderr: (chunk) => stderr.write(chunk),
+                    onStepFinish: (step) => {
+                        const responseMessages = Array.isArray(step?.response?.messages)
+                            ? (cloneJsonValue(step.response.messages) ?? step.response.messages)
+                            : [];
+                        if (responseMessages.length > 0) {
+                            stepMessages.push(...responseMessages);
+                        }
+                    },
+                });
+                if (!streamedAny && typeof result?.text === "string" && result.text) {
+                    stdout.write(result.text);
+                }
+                stdout.write("\n");
+                const responseMessages = stepMessages.length > 0
+                    ? stepMessages
+                    : Array.isArray(result?.response?.messages)
+                        ? (cloneJsonValue(result.response.messages) ?? result.response.messages)
+                        : [{ role: "assistant", content: result?.text ?? "" }];
+                messages = [
+                    ...nextMessages,
+                    ...responseMessages,
+                ];
+            }
+            catch (err) {
+                stderr.write(`[smithers] hijack agent error: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    return {
+        code: 0,
+        messages,
+    };
+}