@dreamlake/dreamlake-cli 0.2.0 → 0.9.2

package/dist/cli/workflow/index.js

@@ -1,627 +0,0 @@
-// `dreamlake workflow ...` — workflow management + run-trace push.
-//
-// Covers the workflow API endpoints:
-//   workflow list / create / show / update / delete
-//   workflow push-run / watch-run   (agent-side run-trace snapshots)
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { HttpError, requestJson } from "../client.js";
-import { resolveRemote, resolveToken, resolveNamespace } from "../config.js";
-import { emitJson, fail, ok, renderTable, splitCsv, warn } from "../helpers.js";
-import { confirm } from "../prompt.js";
-// ─── shared context resolution ────────────────────────────────────────────────
-async function ctx(nsFlag) {
-    const token = resolveToken();
-    if (!token) {
-        fail("not authenticated — run 'dreamlake login' first");
-        return null;
-    }
-    const remote = resolveRemote();
-    const ns = await resolveNamespace(nsFlag, { token, remote });
-    if (!ns) {
-        fail("could not resolve namespace — run 'dreamlake login' or pass --namespace");
-        return null;
-    }
-    return { token, remote, ns };
-}
-function readFile(filePath) {
-    try {
-        return readFileSync(resolve(filePath), "utf8");
-    }
-    catch {
-        throw new Error(`cannot read file: ${filePath}`);
-    }
-}
-// ─── run-file reduction (local wf_*.json → server trace contract) ─────────────
-//
-// The Claude Code Workflow tool writes wf_<runId>.json snapshots under the
-// session's workflows/ dir. `workflowProgress` interleaves `workflow_phase`
-// and `workflow_agent` entries; run totals live at the top level. The file
-// format drifts across CLI versions, so every field is optional — reduce
-// what's there, drop the rest.
-const AGENT_FIELDS = [
-    "index",
-    "label",
-    "phaseIndex",
-    "phaseTitle",
-    "agentId",
-    "model",
-    "state",
-    "queuedAt",
-    "startedAt",
-    "lastProgressAt",
-    "durationMs",
-    "attempt",
-    "tokens",
-    "toolCalls",
-    "lastToolName",
-    "lastToolSummary",
-    "promptPreview",
-    "resultPreview",
-];
-// ─── body-budget guardrails (bounded push size) ──────────────────────────────
-//
-// Every push-run / watch-run PUT must stay under the server's 5MB bodyLimit.
-// An oversized body 413s; for the *terminal* snapshot that means the server-side
-// run is never flipped out of 'running', so the web detail page polls it every
-// few seconds forever. We hold the serialized body under a 4MB budget (headroom
-// below the 5MB limit) and degrade deterministically — least-important data
-// first — rather than ever emit a body we know will be rejected:
-//
-//   1. always: cap each agent's free-text previews to AGENT_PREVIEW_CAP chars.
-//   2. always: keep only the newest log lines that fit LOGS_BUDGET_BYTES.
-//   3. if the whole body is still over budget: drop logs, then replace `result`
-//      with a size marker. status / trace skeleton (phases+agents) / totals
-//      always survive — they are what the detail page needs to render.
-/** Serialized-body ceiling. Below the server's 5MB bodyLimit, with headroom. */
-const BODY_BUDGET_BYTES = 4 * 1024 * 1024;
-/** Per-field cap for free-text agent previews. */
-const AGENT_PREVIEW_CAP = 2000;
-/** Combined byte budget for retained log lines (the newest are kept). */
-const LOGS_BUDGET_BYTES = 512 * 1024;
-/** Agent fields that are free-text and get length-capped. */
-const CAPPED_AGENT_FIELDS = new Set([
-    "promptPreview",
-    "resultPreview",
-    "lastToolSummary",
-]);
-function byteLength(v) {
-    return Buffer.byteLength(JSON.stringify(v), "utf8");
-}
-/** Cap a free-text field to `max` chars, appending an ellipsis when trimmed. */
-function capText(v, max) {
-    return typeof v === "string" && v.length > max ? v.slice(0, max) + "…" : v;
-}
-/**
- * Keep the LAST log lines that fit within `budget` bytes; when any are dropped
- * prepend a marker so the reader knows the head was elided. Always keeps at
- * least the most recent line (even if it alone exceeds the budget) so the tail
- * of the run is never lost. Returns the input untouched when nothing is dropped.
- */
-function capLogs(logs, budget) {
-    if (logs.length === 0)
-        return logs;
-    const kept = [];
-    let used = 0;
-    for (let i = logs.length - 1; i >= 0; i--) {
-        const line = logs[i];
-        const cost = Buffer.byteLength(line, "utf8") + 1; // + newline separator
-        if (kept.length > 0 && used + cost > budget)
-            break;
-        kept.push(line);
-        used += cost;
-    }
-    if (kept.length === logs.length)
-        return logs; // nothing dropped — keep as-is
-    kept.reverse();
-    kept.unshift(`[truncated ${logs.length - kept.length} earlier log lines]`);
-    return kept;
-}
-/**
- * Final guardrail: if the serialized body still exceeds BODY_BUDGET_BYTES after
- * the per-field/log caps (e.g. a huge `result` or thousands of agents), degrade
- * further — drop logs entirely, then replace `result` with a size marker. The
- * status, trace skeleton (phases + agents) and run totals are never touched.
- */
-function enforceBodyBudget(body, trace) {
-    if (byteLength(body) <= BODY_BUDGET_BYTES)
-        return;
-    // 1. Drop logs — the phase/agent skeleton is worth far more than log tail.
-    if (trace.logs.length > 0) {
-        trace.logs = [];
-        if (byteLength(body) <= BODY_BUDGET_BYTES)
-            return;
-    }
-    // 2. Replace the result payload with a marker of its original size.
-    if (body.result !== undefined) {
-        body.result = { truncated: true, originalBytes: byteLength(body.result) };
-    }
-    // If still over budget here, the agent/phase skeleton itself is oversized;
-    // that is the documented floor — those fields must survive intact even if
-    // the push risks a 413.
-}
-function asRecord(v) {
-    return v && typeof v === "object" && !Array.isArray(v)
-        ? v
-        : null;
-}
-/** Epoch-millis (number) or ISO string → ISO string; anything else → undefined. */
-function isoTime(v) {
-    if (typeof v === "number" && Number.isFinite(v))
-        return new Date(v).toISOString();
-    if (typeof v === "string" && v)
-        return v;
-    return undefined;
-}
-export function reduceRunFile(raw) {
-    const file = asRecord(raw) ?? {};
-    const progress = Array.isArray(file.workflowProgress) ? file.workflowProgress : [];
-    const phases = [];
-    const agents = [];
-    for (const entry of progress) {
-        const e = asRecord(entry);
-        if (!e)
-            continue;
-        if (e.type === "workflow_phase") {
-            const phase = {};
-            if (e.index !== undefined)
-                phase.index = e.index;
-            if (e.title !== undefined)
-                phase.title = e.title;
-            phases.push(phase);
-        }
-        else if (e.type === "workflow_agent") {
-            const agent = {};
-            for (const f of AGENT_FIELDS) {
-                if (e[f] === undefined)
-                    continue;
-                // Free-text previews are length-capped; everything else copied verbatim.
-                agent[f] = CAPPED_AGENT_FIELDS.has(f)
-                    ? capText(e[f], AGENT_PREVIEW_CAP)
-                    : e[f];
-            }
-            agents.push(agent);
-        }
-    }
-    // Before the first phase starts running, fall back to the declared meta
-    // phases so the graph still renders the skeleton.
-    if (phases.length === 0 && Array.isArray(file.phases)) {
-        file.phases.forEach((p, i) => {
-            const rec = asRecord(p);
-            if (rec?.title !== undefined)
-                phases.push({ index: i + 1, title: rec.title });
-        });
-    }
-    const trace = {
-        phases,
-        agents,
-        logs: capLogs(Array.isArray(file.logs)
-            ? file.logs.filter((l) => typeof l === "string")
-            : [], LOGS_BUDGET_BYTES),
-    };
-    if (typeof file.totalToolCalls === "number")
-        trace.totalToolCalls = file.totalToolCalls;
-    if (typeof file.defaultModel === "string")
-        trace.defaultModel = file.defaultModel;
-    const body = {
-        status: typeof file.status === "string" && file.status ? file.status : "running",
-        trace,
-    };
-    const startTime = isoTime(file.startTime);
-    if (startTime)
-        body.startTime = startTime;
-    if (typeof file.durationMs === "number")
-        body.durationMs = file.durationMs;
-    if (typeof file.agentCount === "number")
-        body.agentCount = file.agentCount;
-    if (typeof file.totalTokens === "number")
-        body.totalTokens = file.totalTokens;
-    if (typeof file.error === "string" && file.error)
-        body.error = file.error;
-    if (file.result !== undefined)
-        body.result = file.result;
-    // Guarantee the body fits under the server bodyLimit before it is ever sent.
-    enforceBodyBudget(body, trace);
-    return {
-        runId: typeof file.runId === "string" && file.runId ? file.runId : undefined,
-        body,
-    };
-}
-function readRunFile(filePath) {
-    const text = readFileSync(resolve(filePath), "utf8");
-    return reduceRunFile(JSON.parse(text));
-}
-// ─── workflow list ────────────────────────────────────────────────────────────
-export async function runWorkflowList(opts) {
-    const c = await ctx(opts.namespace);
-    if (!c)
-        return 1;
-    try {
-        const res = await requestJson(c.remote, `/namespaces/${c.ns}/workflows`, { token: c.token });
-        if (opts.json) {
-            emitJson(res.workflows);
-            return 0;
-        }
-        if (res.workflows.length === 0) {
-            process.stdout.write("No workflows found.\n");
-            return 0;
-        }
-        const rows = res.workflows.map((w) => ({
-            name: w.name,
-            hash: w.currentVersionHash ?? "—",
-            runs: String(w.runCount ?? 0),
-            lastRun: w.latestRun?.status ?? "—",
-            updatedAt: w.updatedAt.slice(0, 10),
-        }));
-        process.stdout.write(renderTable(rows, ["name", "hash", "runs", "lastRun", "updatedAt"]));
-        process.stdout.write(`\n  ${res.workflows.length} workflow(s)\n`);
-        return 0;
-    }
-    catch (err) {
-        fail(err.message);
-        return 1;
-    }
-}
-// ─── workflow create ──────────────────────────────────────────────────────────
-export async function runWorkflowCreate(name, opts) {
-    const c = await ctx(opts.namespace);
-    if (!c)
-        return 1;
-    try {
-        const body = { name };
-        if (opts.description)
-            body.description = opts.description;
-        if (opts.tags)
-            body.tags = splitCsv(opts.tags);
-        if (opts.file) {
-            body.script = readFile(opts.file);
-            if (opts.message)
-                body.versionMessage = opts.message;
-        }
-        const workflow = await requestJson(c.remote, `/namespaces/${c.ns}/workflows`, { method: "POST", token: c.token, json: body });
-        if (opts.json) {
-            emitJson(workflow);
-            return 0;
-        }
-        ok(`Created workflow: ${workflow.name}`);
-        if (workflow.currentVersionHash) {
-            process.stdout.write(`  version: ${workflow.currentVersionHash}\n`);
-            process.stdout.write(`  phases:  ${workflow.meta?.phases?.length ?? 0}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof HttpError && err.status === 409) {
-            fail(`workflow '${name}' already exists in namespace '${c.ns}'`);
-            return 1;
-        }
-        fail(err.message);
-        return 1;
-    }
-}
-// ─── workflow show ────────────────────────────────────────────────────────────
-export async function runWorkflowShow(name, opts) {
-    const c = await ctx(opts.namespace);
-    if (!c)
-        return 1;
-    try {
-        const workflow = await requestJson(c.remote, `/namespaces/${c.ns}/workflows/${name}`, { token: c.token });
-        if (opts.json) {
-            emitJson(workflow);
-            return 0;
-        }
-        process.stdout.write(`Workflow: ${workflow.name}\n`);
-        process.stdout.write(`  version:     ${workflow.currentVersionHash ?? "—"}\n`);
-        process.stdout.write(`  phases:      ${workflow.meta?.phases?.length ?? "—"}\n`);
-        if (workflow.description)
-            process.stdout.write(`  description: ${workflow.description}\n`);
-        if (workflow.tags.length)
-            process.stdout.write(`  tags:        ${workflow.tags.join(", ")}\n`);
-        process.stdout.write(`  created:     ${workflow.createdAt.slice(0, 10)}\n`);
-        process.stdout.write(`  updated:     ${workflow.updatedAt.slice(0, 10)}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof HttpError && err.status === 404) {
-            fail(`workflow '${name}' not found`);
-            return 1;
-        }
-        fail(err.message);
-        return 1;
-    }
-}
-// ─── workflow update ──────────────────────────────────────────────────────────
-export async function runWorkflowUpdate(name, opts) {
-    const c = await ctx(opts.namespace);
-    if (!c)
-        return 1;
-    const body = {};
-    if (opts.description !== undefined)
-        body.description = opts.description;
-    if (opts.tags !== undefined)
-        body.tags = splitCsv(opts.tags);
-    if (opts.file) {
-        try {
-            body.script = readFile(opts.file);
-        }
-        catch (err) {
-            fail(err.message);
-            return 1;
-        }
-        if (opts.message)
-            body.versionMessage = opts.message;
-    }
-    if (Object.keys(body).length === 0) {
-        fail("nothing to update — use --file, --description, or --tags");
-        return 1;
-    }
-    try {
-        const workflow = await requestJson(c.remote, `/namespaces/${c.ns}/workflows/${name}`, { method: "PATCH", token: c.token, json: body });
-        if (opts.json) {
-            emitJson(workflow);
-            return 0;
-        }
-        ok(`Updated workflow: ${workflow.name}`);
-        if (workflow.currentVersionHash) {
-            process.stdout.write(`  version: ${workflow.currentVersionHash}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof HttpError && err.status === 404) {
-            fail(`workflow '${name}' not found`);
-            return 1;
-        }
-        fail(err.message);
-        return 1;
-    }
-}
-// ─── workflow delete ──────────────────────────────────────────────────────────
-export async function runWorkflowDelete(name, opts) {
-    const c = await ctx(opts.namespace);
-    if (!c)
-        return 1;
-    if (!opts.yes) {
-        const proceed = await confirm(`Delete workflow '${name}'?`, false);
-        if (!proceed) {
-            process.stdout.write("Cancelled.\n");
-            return 0;
-        }
-    }
-    try {
-        await requestJson(c.remote, `/namespaces/${c.ns}/workflows/${name}`, { method: "DELETE", token: c.token });
-        ok(`Deleted workflow: ${name}`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof HttpError && err.status === 404) {
-            fail(`workflow '${name}' not found`);
-            return 1;
-        }
-        fail(err.message);
-        return 1;
-    }
-}
-// ─── workflow push-run ────────────────────────────────────────────────────────
-export async function runWorkflowPushRun(name, filePath, opts) {
-    const c = await ctx(opts.namespace);
-    if (!c)
-        return 1;
-    let reduced;
-    try {
-        reduced = readRunFile(filePath);
-    }
-    catch (err) {
-        fail(`cannot read run file ${filePath}: ${err.message}`);
-        return 1;
-    }
-    if (!reduced.runId) {
-        fail(`run file ${filePath} has no runId`);
-        return 1;
-    }
-    try {
-        const run = await requestJson(c.remote, `/namespaces/${c.ns}/workflows/${name}/runs/${reduced.runId}`, { method: "PUT", token: c.token, json: reduced.body });
-        if (opts.json) {
-            emitJson(run);
-            return 0;
-        }
-        ok(`Pushed run ${reduced.runId} → ${run.status ?? reduced.body.status}`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof HttpError && err.status === 404) {
-            fail(`workflow '${name}' not found`);
-            return 1;
-        }
-        fail(err.message);
-        return 1;
-    }
-}
-/**
- * Backoff schedule for the *terminal* push. A running snapshot that fails is
- * harmless — the next tick retries it — but the terminal snapshot is the one
- * that flips the server run to its final state, and there is no next tick. If
- * it is dropped on a transient error the server run is stranded as 'running'
- * and the detail page polls it forever, so it gets its own bounded retry.
- */
-const TERMINAL_RETRY_DELAYS_MS = [2000, 4000, 8000, 16000, 32000];
-/**
- * Cold-start grace window. The watcher is often launched *before* the Workflow
- * tool has written the first wf_*.json (slow orchestration). Until the first
- * successful read we tolerate a missing/unreadable file for this long, rather
- * than letting the mid-run 5-strike cap (~25s at --interval 5) kill the watcher
- * and leave the run with zero snapshots.
- */
-const STARTUP_GRACE_MS = 120_000;
-/**
- * Push the terminal snapshot, retrying transient failures with exponential
- * backoff. Returns 0 once accepted, 1 on a 404 (workflow gone) or after the
- * retry budget is exhausted.
- */
-async function pushTerminalSnapshot(c, name, reduced, status, sleep, delays) {
-    for (let attempt = 0;; attempt++) {
-        try {
-            await requestJson(c.remote, `/namespaces/${c.ns}/workflows/${name}/runs/${reduced.runId}`, { method: "PUT", token: c.token, json: reduced.body });
-            ok(`pushed ${reduced.runId} → ${status}`);
-            ok(`run ${reduced.runId} finished: ${status}`);
-            return 0;
-        }
-        catch (err) {
-            if (err instanceof HttpError && err.status === 404) {
-                fail(`workflow '${name}' not found`);
-                return 1;
-            }
-            if (attempt >= delays.length) {
-                fail(`final push failed after ${delays.length + 1} attempts: ${err.message}`);
-                return 1;
-            }
-            const delay = delays[attempt];
-            warn(`final push failed (${err.message}) — retry ${attempt + 1}/${delays.length} in ${delay / 1000}s`);
-            await sleep(delay);
-        }
-    }
-}
-export async function runWorkflowWatchRun(name, filePath, opts, deps = {}) {
-    const c = await ctx(opts.namespace);
-    if (!c)
-        return 1;
-    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-    const terminalDelays = deps.terminalRetryDelaysMs ?? TERMINAL_RETRY_DELAYS_MS;
-    const startupGraceMs = deps.startupGraceMs ?? STARTUP_GRACE_MS;
-    const parsed = Number(opts.interval);
-    const intervalMs = (Number.isFinite(parsed) && parsed > 0 ? parsed : 5) * 1000;
-    // Cold-start budget: how many read attempts fit in the grace window.
-    const startupAttempts = Math.max(1, Math.ceil(startupGraceMs / intervalMs));
-    let hasReadOnce = false; // has the run file ever been read successfully?
-    let readFailures = 0; //   consecutive failures AFTER the first success (mid-run)
-    let startupMisses = 0; //  consecutive misses BEFORE the first success (cold start)
-    for (;;) {
-        let reduced = null;
-        try {
-            reduced = readRunFile(filePath);
-            hasReadOnce = true;
-            readFailures = 0;
-        }
-        catch (err) {
-            if (!hasReadOnce) {
-                // Cold start: the Workflow tool may not have written the run file yet.
-                // Wait out the grace window instead of treating a not-yet-created file
-                // as fatal — otherwise a slow orchestrator start strands the run with
-                // zero snapshots. Log once, quietly, so we don't spam every tick.
-                startupMisses += 1;
-                if (startupMisses === 1)
-                    warn(`waiting for run file ${filePath} …`);
-                if (startupMisses >= startupAttempts) {
-                    fail(`run file ${filePath} did not appear within ${Math.round(startupGraceMs / 1000)}s — giving up: ${err.message}`);
-                    return 1;
-                }
-            }
-            else {
-                // Mid-run: the file existed and now can't be read (corrupt/deleted mid-
-                // write). Retry a few times, but don't spin forever.
-                readFailures += 1;
-                if (readFailures >= 5) {
-                    fail(`cannot read run file ${filePath}: ${err.message}`);
-                    return 1;
-                }
-                warn(`run file not readable (${err.message}) — retrying`);
-            }
-        }
-        if (reduced) {
-            if (!reduced.runId) {
-                fail(`run file ${filePath} has no runId`);
-                return 1;
-            }
-            const status = reduced.body.status;
-            if (status !== "running") {
-                // Terminal snapshot — retry with backoff so a transient failure can't
-                // strand the server run as 'running'.
-                return pushTerminalSnapshot(c, name, reduced, status, sleep, terminalDelays);
-            }
-            try {
-                await requestJson(c.remote, `/namespaces/${c.ns}/workflows/${name}/runs/${reduced.runId}`, { method: "PUT", token: c.token, json: reduced.body });
-                ok(`pushed ${reduced.runId} → ${status}`);
-            }
-            catch (err) {
-                if (err instanceof HttpError && err.status === 404) {
-                    fail(`workflow '${name}' not found`);
-                    return 1;
-                }
-                // A running snapshot is disposable — the next tick will retry it.
-                warn(`push failed (${err.message}) — retrying`);
-            }
-        }
-        await sleep(intervalMs);
-    }
-}
-// ─── registration ─────────────────────────────────────────────────────────────
-export function registerWorkflowCommand(program) {
-    const workflow = program
-        .command("workflow")
-        .description("manage workflows and push run traces");
-    // ── workflow list ──
-    workflow
-        .command("list")
-        .description("list workflows in a namespace")
-        .option("--namespace <slug>", "namespace slug (default: active login)")
-        .option("--json", "emit JSON")
-        .action(async (opts) => process.exit(await runWorkflowList(opts)));
-    // ── workflow create ──
-    workflow
-        .command("create")
-        .description("create a workflow (optionally with an initial version)")
-        .argument("<name>", "workflow name (unique within namespace)")
-        .option("--namespace <slug>", "namespace slug (default: active login)")
-        .option("--file <path>", "workflow JS script — meta is parsed and an initial version created")
-        .option("--description <text>", "description")
-        .option("--tags <csv>", "comma-separated tags")
-        .option("--message <text>", "version message (used with --file)")
-        .option("--json", "emit JSON")
-        .action(async (name, opts) => process.exit(await runWorkflowCreate(name, opts)));
-    // ── workflow show ──
-    workflow
-        .command("show")
-        .description("show workflow detail with current version meta")
-        .argument("<name>", "workflow name")
-        .option("--namespace <slug>", "namespace slug (default: active login)")
-        .option("--json", "emit JSON")
-        .action(async (name, opts) => process.exit(await runWorkflowShow(name, opts)));
-    // ── workflow update ──
-    workflow
-        .command("update")
-        .description("update metadata or upload a new version")
-        .argument("<name>", "workflow name")
-        .option("--namespace <slug>", "namespace slug (default: active login)")
-        .option("--file <path>", "new workflow JS script — creates a new version")
-        .option("--description <text>", "new description")
-        .option("--tags <csv>", "new tags (comma-separated, replaces existing)")
-        .option("--message <text>", "version message (used with --file)")
-        .option("--json", "emit JSON")
-        .action(async (name, opts) => process.exit(await runWorkflowUpdate(name, opts)));
-    // ── workflow delete ──
-    workflow
-        .command("delete")
-        .description("soft-delete a workflow (preserves version history)")
-        .argument("<name>", "workflow name")
-        .option("--namespace <slug>", "namespace slug (default: active login)")
-        .option("--yes", "skip confirmation prompt")
-        .action(async (name, opts) => process.exit(await runWorkflowDelete(name, opts)));
-    // ── workflow push-run ──
-    workflow
-        .command("push-run")
-        .description("push one run-trace snapshot from a local wf_*.json run file")
-        .argument("<name>", "workflow name")
-        .argument("<file>", "path to the local wf_*.json run file")
-        .option("--namespace <slug>", "namespace slug (default: active login)")
-        .option("--json", "emit JSON")
-        .action(async (name, file, opts) => process.exit(await runWorkflowPushRun(name, file, opts)));
-    // ── workflow watch-run ──
-    workflow
-        .command("watch-run")
-        .description("push snapshots until the run file leaves 'running', then a final push")
-        .argument("<name>", "workflow name")
-        .argument("<file>", "path to the local wf_*.json run file")
-        .option("--interval <seconds>", "seconds between pushes", "5")
-        .option("--namespace <slug>", "namespace slug (default: active login)")
-        .action(async (name, file, opts) => process.exit(await runWorkflowWatchRun(name, file, opts)));
-}