@lostgradient/weft 0.2.0

package/dist/cli/version-check.js

@@ -0,0 +1,16 @@
+import { resolve } from "node:path";
+export async function executeVersionCheck(options) {
+  if (!options.workflows)
+    return {
+      stdout: "",
+      stderr: "Error: --workflows flag is required for version:check",
+      exitCode: 1
+    };
+  const { runVersionCheck } = await import("../diagnostics/version-check.js"), { formatVersionCheckReport } = await import("../diagnostics/format.js"), { BunSQLiteStorage } = await import("../storage/bun-sql.js"), storage = new BunSQLiteStorage(options.database);
+  try {
+    const registrations = await import(resolve(process.cwd(), options.workflows)), report = await runVersionCheck(storage, registrations.default);
+    return { stdout: options.json ? JSON.stringify(report, null, 2) : formatVersionCheckReport(report), exitCode: 0 };
+  } finally {
+    storage[Symbol.dispose]();
+  }
+}

package/dist/cli/version.d.ts

@@ -0,0 +1,7 @@
+import type { CommandOutput } from './types.ts';
+/**
+ * Print the installed Weft version. Backs `weft --version`, `weft -v`, and the
+ * bare `weft version` subcommand. The output is the bare {@link VERSION} string
+ * so scripts can capture it without parsing decoration.
+ */
+export declare function executeVersion(): CommandOutput;

package/dist/cli/version.js

@@ -0,0 +1,4 @@
+import { VERSION } from "../version.js";
+export function executeVersion() {
+  return { stdout: VERSION, exitCode: 0 };
+}

package/dist/cli/workflow-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `weft workflow ls|get|events|start|cancel|signal` — the human-facing inspect
+ * and operate surface for workflows on a running server.
+ *
+ * Every action routes through the generated typed client via
+ * {@link callCatalogOperation}; the commands never build HTTP requests
+ * directly. Output follows the shared DX conventions: a human table or summary
+ * on a TTY, NDJSON (lists) or a single JSON object (`--json`) for machines, and
+ * a confirmation gate before the destructive `cancel`.
+ *
+ * @module cli/workflow-commands
+ */
+import type { CommandOutput, WorkflowCommand } from './types.ts';
+/** Execute any `weft workflow <action>` command against a server. */
+export declare function executeWorkflow(command: WorkflowCommand): Promise<CommandOutput>;

package/dist/cli/workflow-commands.js

@@ -0,0 +1,195 @@
+import {
+  confirmDestructive,
+  formatTimestamp,
+  messageOf,
+  ndjson,
+  prettyJson,
+  truncateToWidth
+} from "./output.js";
+import { callCatalogOperation, failureExitCode } from "./server-client.js";
+export async function executeWorkflow(command) {
+  const connection = {
+    ...command.server === void 0 ? {} : { server: command.server },
+    ...command.token === void 0 ? {} : { token: command.token },
+    ...command.profile === void 0 ? {} : { profile: command.profile }
+  };
+  switch (command.action) {
+    case "ls":
+      return executeWorkflowList(command, connection);
+    case "get":
+      return executeWorkflowGet(command, connection);
+    case "events":
+      return executeWorkflowEvents(command, connection);
+    case "start":
+      return executeWorkflowStart(command, connection);
+    case "cancel":
+      return executeWorkflowCancel(command, connection);
+    case "signal":
+      return executeWorkflowSignal(command, connection);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toSummaryRow(value) {
+  if (!isRecord(value))
+    return;
+  const { id, type, status, createdAt, updatedAt } = value;
+  if (typeof id !== "string" || typeof type !== "string" || typeof status !== "string")
+    return;
+  return {
+    id,
+    type,
+    status,
+    createdAt: typeof createdAt === "number" ? createdAt : Number.NaN,
+    updatedAt: typeof updatedAt === "number" ? updatedAt : Number.NaN
+  };
+}
+function extractItems(output) {
+  if (isRecord(output) && Array.isArray(output.items))
+    return output.items;
+  return [];
+}
+async function executeWorkflowList(command, connection) {
+  const result = await callCatalogOperation(connection, "weft.workflows.list", {
+    ...command.type === void 0 ? {} : { type: command.type },
+    ...command.status === void 0 ? {} : { status: command.status },
+    ...command.limit === void 0 ? {} : { limit: command.limit }
+  });
+  if (!result.ok)
+    return failure(result);
+  const items = extractItems(result.value);
+  if (command.json)
+    return { stdout: ndjson(items), exitCode: 0 };
+  if (command.quiet)
+    return { stdout: items.map(toSummaryRow).filter((row) => row !== void 0).map((row) => row.id).join(`
+`), exitCode: 0 };
+  const rows = items.map(toSummaryRow).filter((row) => row !== void 0);
+  if (rows.length === 0)
+    return { stdout: "No workflows found.", exitCode: 0 };
+  return { stdout: [
+    ["ID".padEnd(36), "TYPE".padEnd(20), "STATUS".padEnd(12), "CREATED"].join("  "),
+    ...rows.map((row) => [
+      truncateToWidth(row.id, 36).padEnd(36),
+      truncateToWidth(row.type, 20).padEnd(20),
+      row.status.padEnd(12),
+      formatTimestamp(row.createdAt)
+    ].join("  "))
+  ].join(`
+`), exitCode: 0 };
+}
+async function executeWorkflowGet(command, connection) {
+  const result = await callCatalogOperation(connection, "weft.workflows.get", {
+    workflowId: command.workflowId
+  });
+  if (!result.ok)
+    return failure(result);
+  return { stdout: prettyJson(result.value), exitCode: 0 };
+}
+async function executeWorkflowEvents(command, connection) {
+  const result = await callCatalogOperation(connection, "weft.workflows.events.list", {
+    workflowId: command.workflowId
+  });
+  if (!result.ok)
+    return failure(result);
+  const events = Array.isArray(result.value) ? result.value : isRecord(result.value) && Array.isArray(result.value.events) ? result.value.events : extractItems(result.value);
+  if (command.json)
+    return { stdout: ndjson(events), exitCode: 0 };
+  if (events.length === 0)
+    return { stdout: "No events found.", exitCode: 0 };
+  return { stdout: events.map((event) => {
+    if (!isRecord(event))
+      return JSON.stringify(event);
+    const type = typeof event.type === "string" ? event.type : "event";
+    return `${formatTimestamp(event.timestamp)}  ${type}`;
+  }).join(`
+`), exitCode: 0 };
+}
+async function readInlineInput(input, inputFile) {
+  if (input !== void 0)
+    return parseJson(input);
+  if (inputFile !== void 0) {
+    if (inputFile === "-")
+      return parseJson(await Bun.stdin.text());
+    const file = Bun.file(inputFile);
+    if (!await file.exists())
+      return { ok: !1, message: `input file not found: ${inputFile}` };
+    return parseJson(await file.text());
+  }
+  return { ok: !0, value: void 0 };
+}
+function parseJson(source) {
+  try {
+    return { ok: !0, value: JSON.parse(source) };
+  } catch (error) {
+    return { ok: !1, message: `invalid JSON input: ${messageOf(error)}` };
+  }
+}
+async function executeWorkflowStart(command, connection) {
+  const parsed = await readInlineInput(command.input, command.inputFile);
+  if (!parsed.ok)
+    return { stdout: "", stderr: `workflow start: ${parsed.message}`, exitCode: 3 };
+  const result = await callCatalogOperation(connection, "weft.workflows.start", {
+    type: command.workflowType,
+    ...parsed.value === void 0 ? {} : { input: parsed.value },
+    ...command.id === void 0 ? {} : { id: command.id }
+  });
+  if (!result.ok)
+    return failure(result);
+  if (command.json)
+    return { stdout: prettyJson(result.value), exitCode: 0 };
+  const id = isRecord(result.value) && typeof result.value.id === "string" ? result.value.id : command.id ?? "";
+  return { stdout: command.quiet ? id : `Started workflow ${id}`, exitCode: 0 };
+}
+async function executeWorkflowCancel(command, connection) {
+  if (command.dryRun)
+    return { stdout: command.json ? prettyJson({ affected: 1, workflowId: command.workflowId }) : `Would cancel 1 workflow: ${command.workflowId}`, exitCode: 0 };
+  const decision = await confirmDestructive({
+    prompt: `Cancel workflow ${command.workflowId}?`,
+    assumeYes: command.yes
+  });
+  if (decision === "non-interactive")
+    return {
+      stdout: "",
+      stderr: `workflow cancel: refusing to cancel ${command.workflowId} without confirmation; pass --yes to proceed in a non-interactive shell`,
+      exitCode: 1
+    };
+  if (decision === "denied")
+    return { stdout: "Cancelled (no action taken).", exitCode: 1 };
+  const result = await callCatalogOperation(connection, "weft.workflows.cancel", {
+    workflowId: command.workflowId
+  });
+  if (!result.ok)
+    return failure(result);
+  if (command.json)
+    return { stdout: prettyJson(result.value), exitCode: 0 };
+  return {
+    stdout: command.quiet ? "" : `Cancelled workflow ${command.workflowId}`,
+    exitCode: 0
+  };
+}
+async function executeWorkflowSignal(command, connection) {
+  const parsed = await readInlineInput(command.input, command.inputFile);
+  if (!parsed.ok)
+    return { stdout: "", stderr: `workflow signal: ${parsed.message}`, exitCode: 3 };
+  const result = await callCatalogOperation(connection, "weft.workflows.signal", {
+    workflowId: command.workflowId,
+    signalName: command.signalName,
+    ...parsed.value === void 0 ? {} : { payload: parsed.value }
+  });
+  if (!result.ok)
+    return failure(result);
+  if (command.json)
+    return { stdout: prettyJson(result.value), exitCode: 0 };
+  return {
+    stdout: command.quiet ? "" : `Signalled ${command.signalName} to ${command.workflowId}`,
+    exitCode: 0
+  };
+}
+function failure(result) {
+  return {
+    stdout: "",
+    stderr: `${result.kind === "connection" ? "connection failed: " : ""}${result.message}`,
+    exitCode: failureExitCode(result.kind)
+  };
+}

package/dist/cli-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};