@dreamlake/dreamlake-cli 0.1.0

package/dist/cli/pipeline/index.js

@@ -0,0 +1,481 @@
+// `dreamlake pipeline ...` — pipeline management.
+//
+// Covers all 10 pipeline API endpoints:
+//   pipeline list / create / show / update / delete
+//   pipeline version list / version show
+//   pipeline node list / node show / node state
+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 } 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}`);
+    }
+}
+/**
+ * Normalize --source for AI-generated code. Handles three formats:
+ *
+ *   1. Actual newlines (subprocess args / $'...' / heredoc) — pass through as-is.
+ *   2. JSON/shell escape sequences (\n \t \r) — unescape. Most AI agents produce
+ *      this when building a shell command string with the source embedded inline.
+ *   3. Double-escaped (\\n) — unescape one level so \n survives into Python source.
+ *
+ * Heuristic: if the string already contains a real newline it's already well-formed;
+ * only unescape when no real newlines are present (pure escape-sequence format).
+ */
+function unescapeSource(s) {
+    if (s.includes("\n"))
+        return s; // already has real newlines — trust as-is
+    return s
+        .replace(/\\n/g, "\n")
+        .replace(/\\t/g, "\t")
+        .replace(/\\r/g, "\r")
+        .replace(/\\'/g, "'")
+        .replace(/\\"/g, '"');
+}
+// ─── pipeline list ────────────────────────────────────────────────────────────
+export async function runPipelineList(opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    try {
+        const res = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines`, { token: c.token, query: { kind: opts.kind } });
+        if (opts.json) {
+            emitJson(res.pipelines);
+            return 0;
+        }
+        if (res.pipelines.length === 0) {
+            process.stdout.write("No pipelines found.\n");
+            return 0;
+        }
+        const rows = res.pipelines.map((p) => ({
+            name: p.name,
+            kind: p.kind,
+            hash: p.currentVersionHash ?? "—",
+            tags: p.tags.join(", "),
+            updatedAt: p.updatedAt.slice(0, 10),
+        }));
+        process.stdout.write(renderTable(rows, ["name", "kind", "hash", "tags", "updatedAt"]));
+        process.stdout.write(`\n  ${res.pipelines.length} pipeline(s)\n`);
+        return 0;
+    }
+    catch (err) {
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline create ──────────────────────────────────────────────────────────
+export async function runPipelineCreate(name, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    try {
+        const body = { name };
+        if (opts.kind)
+            body.kind = opts.kind;
+        if (opts.description)
+            body.description = opts.description;
+        if (opts.tags)
+            body.tags = splitCsv(opts.tags);
+        const sourceCode = opts.source ? unescapeSource(opts.source) : (opts.file ? readFile(opts.file) : undefined);
+        if (sourceCode) {
+            body.sourceCode = sourceCode;
+            if (opts.message)
+                body.versionMessage = opts.message;
+        }
+        const pipeline = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines`, { method: "POST", token: c.token, json: body });
+        if (opts.json) {
+            emitJson(pipeline);
+            return 0;
+        }
+        ok(`Created pipeline: ${pipeline.name}`);
+        if (pipeline.currentVersionHash) {
+            process.stdout.write(`  version: ${pipeline.currentVersionHash}\n`);
+            process.stdout.write(`  nodes:   ${pipeline.graph?.nodeCount ?? 0}\n`);
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 409) {
+            fail(`pipeline '${name}' already exists in namespace '${c.ns}'`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline show ────────────────────────────────────────────────────────────
+export async function runPipelineShow(name, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    try {
+        const pipeline = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}`, { token: c.token });
+        if (opts.json) {
+            emitJson(pipeline);
+            return 0;
+        }
+        process.stdout.write(`Pipeline: ${pipeline.name}\n`);
+        process.stdout.write(`  kind:        ${pipeline.kind}\n`);
+        process.stdout.write(`  version:     ${pipeline.currentVersionHash ?? "—"}\n`);
+        process.stdout.write(`  nodes:       ${pipeline.graph?.nodeCount ?? "—"}\n`);
+        if (pipeline.description)
+            process.stdout.write(`  description: ${pipeline.description}\n`);
+        if (pipeline.tags.length)
+            process.stdout.write(`  tags:        ${pipeline.tags.join(", ")}\n`);
+        process.stdout.write(`  created:     ${pipeline.createdAt.slice(0, 10)}\n`);
+        process.stdout.write(`  updated:     ${pipeline.updatedAt.slice(0, 10)}\n`);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`pipeline '${name}' not found`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline update ──────────────────────────────────────────────────────────
+export async function runPipelineUpdate(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);
+    const sourceCode = opts.source ?? (opts.file ? readFile(opts.file) : undefined);
+    if (sourceCode) {
+        body.sourceCode = sourceCode;
+        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 pipeline = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}`, { method: "PATCH", token: c.token, json: body });
+        if (opts.json) {
+            emitJson(pipeline);
+            return 0;
+        }
+        ok(`Updated pipeline: ${pipeline.name}`);
+        if (pipeline.currentVersionHash) {
+            process.stdout.write(`  version: ${pipeline.currentVersionHash}\n`);
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`pipeline '${name}' not found`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline delete ──────────────────────────────────────────────────────────
+export async function runPipelineDelete(name, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    if (!opts.yes) {
+        const proceed = await confirm(`Delete pipeline '${name}'?`, false);
+        if (!proceed) {
+            process.stdout.write("Cancelled.\n");
+            return 0;
+        }
+    }
+    try {
+        await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}`, { method: "DELETE", token: c.token });
+        ok(`Deleted pipeline: ${name}`);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`pipeline '${name}' not found`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline version list ────────────────────────────────────────────────────
+export async function runVersionList(name, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    try {
+        const res = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}/versions`, { token: c.token });
+        if (opts.json) {
+            emitJson(res.versions);
+            return 0;
+        }
+        if (res.versions.length === 0) {
+            process.stdout.write("No versions found.\n");
+            return 0;
+        }
+        const rows = res.versions.map((v) => ({
+            hash: v.hash,
+            nodes: String(v.nodeCount),
+            message: (v.message ?? "—").slice(0, 40),
+            createdAt: v.createdAt.slice(0, 10),
+        }));
+        process.stdout.write(renderTable(rows, ["hash", "nodes", "message", "createdAt"]));
+        process.stdout.write(`\n  ${res.versions.length} version(s)\n`);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`pipeline '${name}' not found`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline version show ────────────────────────────────────────────────────
+export async function runVersionShow(name, hash, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    try {
+        const version = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}/versions/${hash}`, { token: c.token });
+        emitJson(version);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`version '${hash}' not found for pipeline '${name}'`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline node list ───────────────────────────────────────────────────────
+export async function runNodeList(name, hash, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    try {
+        const res = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}/versions/${hash}/nodes`, { token: c.token });
+        if (opts.json) {
+            emitJson(res.nodes);
+            return 0;
+        }
+        const entries = Object.values(res.nodes);
+        if (entries.length === 0) {
+            process.stdout.write("No nodes found.\n");
+            return 0;
+        }
+        const rows = entries.map((n) => ({
+            id: n.id,
+            kind: n.kind ?? "—",
+            status: n.state?.status ?? "idle",
+            artifacts: n.state?.artifacts ? Object.keys(n.state.artifacts).join(", ") : "—",
+        }));
+        process.stdout.write(renderTable(rows, ["id", "kind", "status", "artifacts"]));
+        process.stdout.write(`\n  ${entries.length} node(s)\n`);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`pipeline '${name}' or version '${hash}' not found`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline node show ───────────────────────────────────────────────────────
+export async function runNodeShow(name, hash, nodeId, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    try {
+        const node = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}/versions/${hash}/nodes/${nodeId}`, { token: c.token });
+        emitJson(node);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`node '${nodeId}' not found`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── pipeline node state ──────────────────────────────────────────────────────
+export async function runNodeState(name, hash, nodeId, opts) {
+    const c = await ctx(opts.namespace);
+    if (!c)
+        return 1;
+    const body = { status: opts.status };
+    if (opts.error !== undefined)
+        body.error = opts.error;
+    if (opts.startedAt !== undefined)
+        body.startedAt = opts.startedAt;
+    if (opts.endedAt !== undefined)
+        body.endedAt = opts.endedAt;
+    if (opts.artifacts !== undefined) {
+        try {
+            body.artifacts = JSON.parse(opts.artifacts);
+        }
+        catch {
+            fail("--artifacts must be valid JSON, e.g. '{\"index_html\":\"https://...\"}'");
+            return 1;
+        }
+    }
+    try {
+        const state = await requestJson(c.remote, `/namespaces/${c.ns}/pipelines/${name}/versions/${hash}/nodes/${nodeId}/state`, { method: "PATCH", token: c.token, json: body });
+        ok(`Node state updated: ${nodeId} → ${state.status}`);
+        if (state.artifacts) {
+            process.stdout.write(`  artifacts: ${JSON.stringify(state.artifacts)}\n`);
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof HttpError && err.status === 404) {
+            fail(`node '${nodeId}' not found`);
+            return 1;
+        }
+        fail(err.message);
+        return 1;
+    }
+}
+// ─── registration ─────────────────────────────────────────────────────────────
+export function registerPipelineCommand(program) {
+    const pipeline = program
+        .command("pipeline")
+        .description("manage pipelines, versions, and node execution state");
+    // ── pipeline list ──
+    pipeline
+        .command("list")
+        .description("list pipelines in a namespace")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--kind <kind>", "filter by kind (e.g. python)")
+        .option("--json", "emit JSON")
+        .action(async (opts) => process.exit(await runPipelineList(opts)));
+    // ── pipeline create ──
+    pipeline
+        .command("create")
+        .description("create a pipeline (optionally with an initial version)")
+        .argument("<name>", "pipeline name (unique within namespace)")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--source <code>", "Python source code string — triggers parser and creates initial version")
+        .option("--file <path>", "Python source file (alternative to --source)")
+        .option("--description <text>", "description")
+        .option("--tags <csv>", "comma-separated tags")
+        .option("--message <text>", "version message (used with --source or --file)")
+        .option("--kind <kind>", "pipeline kind (default: python)")
+        .option("--json", "emit JSON")
+        .action(async (name, opts) => process.exit(await runPipelineCreate(name, opts)));
+    // ── pipeline show ──
+    pipeline
+        .command("show")
+        .description("show pipeline detail with current version graph")
+        .argument("<name>", "pipeline name")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--json", "emit JSON")
+        .action(async (name, opts) => process.exit(await runPipelineShow(name, opts)));
+    // ── pipeline update ──
+    pipeline
+        .command("update")
+        .description("update metadata or upload a new version")
+        .argument("<name>", "pipeline name")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--source <code>", "new Python source code string — triggers parser and creates a new version")
+        .option("--file <path>", "new Python source file (alternative to --source)")
+        .option("--description <text>", "new description")
+        .option("--tags <csv>", "new tags (comma-separated, replaces existing)")
+        .option("--message <text>", "version message (used with --source or --file)")
+        .option("--json", "emit JSON")
+        .action(async (name, opts) => process.exit(await runPipelineUpdate(name, opts)));
+    // ── pipeline delete ──
+    pipeline
+        .command("delete")
+        .description("soft-delete a pipeline (preserves version history)")
+        .argument("<name>", "pipeline name")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--yes", "skip confirmation prompt")
+        .action(async (name, opts) => process.exit(await runPipelineDelete(name, opts)));
+    // ── pipeline version ──
+    const version = pipeline
+        .command("version")
+        .description("manage pipeline versions");
+    version
+        .command("list")
+        .description("list versions of a pipeline (newest first)")
+        .argument("<name>", "pipeline name")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--json", "emit JSON")
+        .action(async (name, opts) => process.exit(await runVersionList(name, opts)));
+    version
+        .command("show")
+        .description("show full version data (sourceCode + graph)")
+        .argument("<name>", "pipeline name")
+        .argument("<hash>", "12-char version hash")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--json", "emit JSON (always, this command outputs JSON)")
+        .action(async (name, hash, opts) => process.exit(await runVersionShow(name, hash, opts)));
+    // ── pipeline node ──
+    const node = pipeline
+        .command("node")
+        .description("inspect node definitions and execution state");
+    node
+        .command("list")
+        .description("list all nodes in a version with their current state")
+        .argument("<name>", "pipeline name")
+        .argument("<hash>", "version hash")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--json", "emit JSON")
+        .action(async (name, hash, opts) => process.exit(await runNodeList(name, hash, opts)));
+    node
+        .command("show")
+        .description("show a single node with its current state")
+        .argument("<name>", "pipeline name")
+        .argument("<hash>", "version hash")
+        .argument("<nodeId>", "node ID (e.g. tr_source)")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .option("--json", "emit JSON (always, this command outputs JSON)")
+        .action(async (name, hash, nodeId, opts) => process.exit(await runNodeShow(name, hash, nodeId, opts)));
+    node
+        .command("state")
+        .description("write back node execution state (for execution engines)")
+        .argument("<name>", "pipeline name")
+        .argument("<hash>", "version hash")
+        .argument("<nodeId>", "node ID")
+        .requiredOption("--status <status>", "idle | queued | running | waiting | done | error | blocked")
+        .option("--error <message>", "error message (use with --status error)")
+        .option("--artifacts <json>", 'JSON object of artifact URLs, e.g. \'{"index_html":"https://..."}\'')
+        .option("--started-at <iso>", "ISO 8601 start time")
+        .option("--ended-at <iso>", "ISO 8601 end time")
+        .option("--namespace <slug>", "namespace slug (default: active login)")
+        .action(async (name, hash, nodeId, opts) => process.exit(await runNodeState(name, hash, nodeId, opts)));
+}

package/dist/cli/progress.js

@@ -0,0 +1,65 @@
+// Zero-dependency progress reporting, replacing dreamlake-py's use of
+// `rich.Progress`. Writes a single repainted line to stderr so stdout
+// stays clean for piping. Falls back to plain newline-terminated lines
+// when stderr is not a TTY (CI logs).
+const isTty = Boolean(process.stderr.isTTY);
+/** A simple "M/N parts" counter that repaints in place. */
+export class PartsProgress {
+    total;
+    label;
+    done = 0;
+    constructor(total, label) {
+        this.total = total;
+        this.label = label;
+    }
+    advance(n = 1) {
+        this.done += n;
+        this.render();
+    }
+    render() {
+        if (isTty) {
+            process.stderr.write(`\r  ${this.label} ${this.done}/${this.total} parts`);
+        }
+        else {
+            process.stderr.write(`  ${this.label} ${this.done}/${this.total} parts\n`);
+        }
+    }
+    done_() {
+        if (isTty)
+            process.stderr.write("\n");
+    }
+}
+/** A byte-oriented download progress line: "12.3/45.6 MB (27%)". */
+export class BytesProgress {
+    total;
+    downloaded = 0;
+    lastDecile = -1; // non-TTY: only log when crossing a 10% step
+    constructor(total) {
+        this.total = total;
+    }
+    advance(bytes) {
+        this.downloaded += bytes;
+        this.render();
+    }
+    render() {
+        const mb = (n) => (n / 1024 / 1024).toFixed(1);
+        const pctNum = this.total
+            ? Math.floor((this.downloaded / this.total) * 100)
+            : null;
+        const line = `  ${mb(this.downloaded)}${this.total ? `/${mb(this.total)}` : ""} MB${pctNum != null ? ` (${pctNum}%)` : ""}`;
+        if (isTty) {
+            process.stderr.write(`\r${line}`);
+            return;
+        }
+        // Non-TTY (logs/CI): one line per 10% step, not per chunk.
+        const decile = pctNum != null ? Math.floor(pctNum / 10) : 0;
+        if (decile > this.lastDecile) {
+            this.lastDecile = decile;
+            process.stderr.write(`${line}\n`);
+        }
+    }
+    finish() {
+        if (isTty)
+            process.stderr.write("\n");
+    }
+}

package/dist/cli/prompt.js

@@ -0,0 +1,17 @@
+// Interactive confirmation, replacing dreamlake-py's `input()` /
+// `rich.Confirm.ask`. Uses @inquirer/prompts (already a lakeshore dep).
+// Non-TTY stdin returns the default without prompting so scripted runs
+// don't hang.
+import { confirm as inquirerConfirm } from "@inquirer/prompts";
+export async function confirm(message, defaultValue = false) {
+    if (!process.stdin.isTTY) {
+        return defaultValue;
+    }
+    try {
+        return await inquirerConfirm({ message, default: defaultValue });
+    }
+    catch {
+        // Ctrl-C / closed stream → treat as "no".
+        return false;
+    }
+}