@assemble-dev/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,2106 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { AppError } from "@assemble-dev/shared-utils";
+
+// src/commands/dev.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import { parseArgs as parseArgs2 } from "util";
+
+// src/output/cli-output.ts
+var ansiCodes = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  red: "\x1B[31m"
+};
+function resolveUseColor(environmentVariables) {
+  const noColorValue = environmentVariables.NO_COLOR;
+  return noColorValue === void 0 || noColorValue === "";
+}
+function createCliOutput(writeLine, useColor) {
+  return {
+    writeSuccessLine: (message) => {
+      writeLine(
+        useColor ? `${ansiCodes.green}\u2713${ansiCodes.reset} ${message}` : `\u2713 ${message}`
+      );
+    },
+    writeFailureLine: (message) => {
+      writeLine(
+        useColor ? `${ansiCodes.red}\u2717${ansiCodes.reset} ${message}` : `\u2717 ${message}`
+      );
+    },
+    writeInfoLine: (message) => {
+      writeLine(message);
+    }
+  };
+}
+
+// src/commands/dev-watcher.ts
+import { mkdirSync, statSync, watch, writeFileSync } from "fs";
+import { join } from "path";
+function createFileSystemWatcherFactory() {
+  return (watchedPaths, onFileSystemChange) => {
+    const watchers = watchedPaths.map(
+      (watchedPath) => watch(
+        watchedPath,
+        { recursive: statSync(watchedPath).isDirectory() },
+        () => {
+          onFileSystemChange();
+        }
+      )
+    );
+    return {
+      close: () => {
+        for (const watcher of watchers) {
+          watcher.close();
+        }
+      }
+    };
+  };
+}
+function createTimeoutDebounceScheduler() {
+  return (timerCallback, delayMs) => {
+    const timer = setTimeout(timerCallback, delayMs);
+    return () => {
+      clearTimeout(timer);
+    };
+  };
+}
+function createDebouncedWorkflowChangeQueue(debounceDelayMs, scheduleDebounceTimer) {
+  let cancelPendingDebounceTimer = null;
+  let hasBufferedChange = false;
+  let deliverChangeToWaiter = null;
+  const markWorkflowChangeReady = () => {
+    cancelPendingDebounceTimer = null;
+    if (deliverChangeToWaiter !== null) {
+      const deliverChange = deliverChangeToWaiter;
+      deliverChangeToWaiter = null;
+      deliverChange();
+      return;
+    }
+    hasBufferedChange = true;
+  };
+  return {
+    notifyWorkflowChange: () => {
+      if (cancelPendingDebounceTimer !== null) {
+        cancelPendingDebounceTimer();
+      }
+      cancelPendingDebounceTimer = scheduleDebounceTimer(
+        markWorkflowChangeReady,
+        debounceDelayMs
+      );
+    },
+    waitForWorkflowChangeOrStop: async (stopSignal) => {
+      if (hasBufferedChange) {
+        hasBufferedChange = false;
+        return "change";
+      }
+      if (stopSignal.aborted) {
+        return "stop";
+      }
+      return await new Promise(
+        (resolveWaitOutcome) => {
+          const resolveWithStop = () => {
+            deliverChangeToWaiter = null;
+            resolveWaitOutcome("stop");
+          };
+          stopSignal.addEventListener("abort", resolveWithStop, { once: true });
+          deliverChangeToWaiter = () => {
+            stopSignal.removeEventListener("abort", resolveWithStop);
+            resolveWaitOutcome("change");
+          };
+        }
+      );
+    }
+  };
+}
+var lastRunFileName = "last-run";
+function writeLastRunIdFile(lastRunDirectory, runId) {
+  mkdirSync(lastRunDirectory, { recursive: true });
+  writeFileSync(join(lastRunDirectory, lastRunFileName), `${runId}
+`, {
+    encoding: "utf8",
+    mode: 420
+  });
+}
+
+// src/commands/run-input.ts
+import { readFileSync } from "fs";
+import { JsonValueSchema } from "@assemble-dev/shared-types/json";
+function parseRunInputJsonText(jsonText, sourceLabel) {
+  try {
+    return {
+      outcome: "resolved",
+      inputValue: JsonValueSchema.parse(JSON.parse(jsonText))
+    };
+  } catch (caughtError) {
+    const reason = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    return {
+      outcome: "failed",
+      message: `Could not parse ${sourceLabel} as JSON: ${reason}`
+    };
+  }
+}
+function readRunInputFile(inputFilePath) {
+  try {
+    return parseRunInputJsonText(
+      readFileSync(inputFilePath, "utf8"),
+      `--input-file ${inputFilePath}`
+    );
+  } catch (caughtError) {
+    const reason = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    return {
+      outcome: "failed",
+      message: `Could not read --input-file ${inputFilePath}: ${reason}`
+    };
+  }
+}
+function resolveRunInputValue(input) {
+  if (input.inputJson !== void 0 && input.inputFilePath !== void 0) {
+    return {
+      outcome: "failed",
+      message: "Pass either --input or --input-file, not both."
+    };
+  }
+  if (input.inputJson !== void 0) {
+    return parseRunInputJsonText(input.inputJson, "--input");
+  }
+  if (input.inputFilePath !== void 0) {
+    return readRunInputFile(input.inputFilePath);
+  }
+  return { outcome: "resolved", inputValue: {} };
+}
+
+// src/commands/run-workflow-loader.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { createJiti } from "jiti";
+function isRunnableWorkflowDefinition(candidate) {
+  return typeof candidate === "object" && candidate !== null && typeof candidate.name === "string" && typeof candidate.run === "function";
+}
+function listModuleExportNames(loadedModule) {
+  const exportNames = Object.keys(loadedModule);
+  return exportNames.length === 0 ? "(none)" : exportNames.join(", ");
+}
+function listWorkflowExportNames(loadedModule) {
+  return Object.entries(loadedModule).filter(([, candidate]) => isRunnableWorkflowDefinition(candidate)).map(([exportName]) => exportName);
+}
+async function importWorkflowModule(absoluteFilePath, freshImport) {
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: false,
+    moduleCache: !freshImport
+  });
+  try {
+    return await jiti.import(absoluteFilePath);
+  } catch (caughtError) {
+    const reason = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    return `Could not load workflow file ${absoluteFilePath}: ${reason}`;
+  }
+}
+function resolveNamedWorkflowExport(loadedModule, exportName, absoluteFilePath) {
+  const candidate = loadedModule[exportName];
+  if (isRunnableWorkflowDefinition(candidate)) {
+    return { outcome: "loaded", workflowDefinition: candidate };
+  }
+  return {
+    outcome: "failed",
+    message: `Export "${exportName}" in ${absoluteFilePath} is not a workflow. Available exports: ${listModuleExportNames(loadedModule)}`
+  };
+}
+function resolveDiscoveredWorkflowExport(loadedModule, absoluteFilePath) {
+  const defaultExport = loadedModule.default;
+  if (isRunnableWorkflowDefinition(defaultExport)) {
+    return { outcome: "loaded", workflowDefinition: defaultExport };
+  }
+  const workflowExportNames = listWorkflowExportNames(loadedModule);
+  const singleWorkflowExportName = workflowExportNames[0];
+  if (workflowExportNames.length === 1 && singleWorkflowExportName !== void 0) {
+    return resolveNamedWorkflowExport(
+      loadedModule,
+      singleWorkflowExportName,
+      absoluteFilePath
+    );
+  }
+  if (workflowExportNames.length === 0) {
+    return {
+      outcome: "failed",
+      message: `No workflow export found in ${absoluteFilePath}. Available exports: ${listModuleExportNames(loadedModule)}. Export a workflow as the default export or pass --workflow <exportName>.`
+    };
+  }
+  return {
+    outcome: "failed",
+    message: `Multiple workflow exports found in ${absoluteFilePath}: ${workflowExportNames.join(", ")}. Pass --workflow <exportName> to choose one.`
+  };
+}
+async function loadWorkflowFromFile(input) {
+  const absoluteFilePath = resolve(input.filePath);
+  if (!existsSync(absoluteFilePath)) {
+    return {
+      outcome: "failed",
+      message: `Workflow file not found: ${absoluteFilePath}`
+    };
+  }
+  const importResult = await importWorkflowModule(
+    absoluteFilePath,
+    input.freshImport ?? false
+  );
+  if (typeof importResult === "string") {
+    return { outcome: "failed", message: importResult };
+  }
+  if (input.exportName !== void 0) {
+    return resolveNamedWorkflowExport(
+      importResult,
+      input.exportName,
+      absoluteFilePath
+    );
+  }
+  return resolveDiscoveredWorkflowExport(importResult, absoluteFilePath);
+}
+
+// src/commands/run.ts
+import { parseArgs } from "util";
+import {
+  buildHostedTraceUrl as buildHostedTraceUrl2,
+  buildMissingKeyMessage,
+  createConsoleSink,
+  createJsonlSink,
+  createPlatformTraceSink,
+  defaultTraceDirectory,
+  resolvePlatformConfig,
+  resolveTraceFilePath as resolveTraceFilePath2
+} from "@assemble-dev/sdk";
+import { generateRunId } from "@assemble-dev/shared-utils/ids";
+
+// src/commands/run-wait-approval.ts
+import {
+  buildHostedTraceUrl,
+  resolveTraceFilePath,
+  resumeRun
+} from "@assemble-dev/sdk";
+import { ApprovalStatusSchema } from "@assemble-dev/shared-types/runs";
+import { z } from "zod";
+var defaultWaitApprovalTimeoutSeconds = 300;
+var waitApprovalPollIntervalMs = 5e3;
+var ApprovalStatusPollResponseSchema = z.object({
+  approvalId: z.string(),
+  status: ApprovalStatusSchema,
+  decidedBy: z.string().nullable(),
+  reason: z.string().nullable(),
+  runId: z.string()
+});
+function extractWaitApprovalFlag(args) {
+  const remainingArgs = [];
+  let waitApprovalTimeoutSeconds = null;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === void 0) {
+      continue;
+    }
+    if (argument === "--wait-approval") {
+      const nextArgument = args[index + 1];
+      if (nextArgument !== void 0 && /^\d+$/.test(nextArgument)) {
+        waitApprovalTimeoutSeconds = Number(nextArgument);
+        index += 1;
+      } else {
+        waitApprovalTimeoutSeconds = defaultWaitApprovalTimeoutSeconds;
+      }
+      continue;
+    }
+    if (argument.startsWith("--wait-approval=")) {
+      const flagValue = argument.slice("--wait-approval=".length);
+      if (!/^\d+$/.test(flagValue)) {
+        return null;
+      }
+      waitApprovalTimeoutSeconds = Number(flagValue);
+      continue;
+    }
+    remainingArgs.push(argument);
+  }
+  return { remainingArgs, waitApprovalTimeoutSeconds };
+}
+function buildMissingKeyForApprovalWaitMessage() {
+  return "Waiting for a hosted approval needs a platform key. Run `asm login` or set ASSEMBLE_API_KEY, approve from the dashboard, and the run will resume.";
+}
+function writeTraceLocationLine(context) {
+  if (context.platformSink !== null) {
+    context.runtime.writeLine(
+      `Trace: ${buildHostedTraceUrl({
+        dashboardUrl: context.platformConfig.dashboardUrl,
+        runId: context.runId
+      })}`
+    );
+    return;
+  }
+  context.runtime.writeLine(
+    `Trace: ${resolveTraceFilePath(context.runId, context.traceDirectory)}`
+  );
+}
+async function fetchApprovalStatusOnce(context, apiKey) {
+  try {
+    const response = await context.runtime.fetchImplementation(
+      `${context.platformConfig.baseUrl}/v1/approvals/${context.approvalId}`,
+      { method: "GET", headers: { authorization: `Bearer ${apiKey}` } }
+    );
+    if (!response.ok) {
+      return null;
+    }
+    return ApprovalStatusPollResponseSchema.parse(
+      JSON.parse(await response.text())
+    );
+  } catch {
+    return null;
+  }
+}
+async function pollApprovalUntilDecidedOrTimeout(context, apiKey) {
+  const now = context.runtime.now ?? (() => /* @__PURE__ */ new Date());
+  const sleep = context.runtime.sleep ?? (async (milliseconds) => {
+    await new Promise((resolveSleep) => {
+      setTimeout(resolveSleep, milliseconds);
+    });
+  });
+  const deadlineMs = now().getTime() + context.timeoutSeconds * 1e3;
+  while (now().getTime() < deadlineMs) {
+    const approvalStatus = await fetchApprovalStatusOnce(context, apiKey);
+    if (approvalStatus !== null && approvalStatus.status !== "pending") {
+      return approvalStatus;
+    }
+    await sleep(waitApprovalPollIntervalMs);
+  }
+  return null;
+}
+function toResumableWorkflowDefinition(workflowDefinition) {
+  return workflowDefinition;
+}
+async function resumeRunWithDecision(context, decision) {
+  const result = await resumeRun({
+    definition: toResumableWorkflowDefinition(context.workflowDefinition),
+    runId: context.runId,
+    decision: {
+      approved: decision.status === "approved",
+      approvedBy: decision.decidedBy ?? "dashboard",
+      ...decision.reason === null ? {} : { reason: decision.reason }
+    },
+    options: {
+      sinks: context.sinks,
+      runStateDirectory: context.traceDirectory
+    }
+  });
+  if (context.platformSink !== null) {
+    await context.platformSink.flush();
+  }
+  return result;
+}
+function printResumedRunOutcome(context, result) {
+  context.runtime.writeLine("");
+  if (result.status === "completed") {
+    context.runtime.writeLine("Workflow completed after approval.");
+  }
+  if (result.status === "rejected") {
+    context.runtime.writeLine("Workflow rejected. The tool call did not run.");
+  }
+  if (result.status === "awaiting_approval") {
+    context.runtime.writeLine(
+      `Workflow paused again: another tool call needs approval (Approval ID: ${result.approvalId}).`
+    );
+  }
+  context.runtime.writeLine("");
+  context.runtime.writeLine(`Run ID: ${context.runId}`);
+  context.runtime.writeLine(`Status: ${result.status}`);
+  writeTraceLocationLine(context);
+  context.runtime.writeLine("");
+}
+function printWaitTimeoutNotice(context) {
+  context.runtime.writeLine("");
+  context.runtime.writeLine(
+    `No decision arrived within ${context.timeoutSeconds}s. The run stays paused \u2014 approve it from the dashboard and resume with resumeRun from @assemble-dev/sdk.`
+  );
+  context.runtime.writeLine(`Approval ID: ${context.approvalId}`);
+  context.runtime.writeLine("");
+}
+function printWaitingNotice(context) {
+  context.runtime.writeLine("");
+  context.runtime.writeLine("Workflow paused: a tool call needs approval.");
+  context.runtime.writeLine(`Run ID: ${context.runId}`);
+  context.runtime.writeLine(`Approval ID: ${context.approvalId}`);
+  context.runtime.writeLine(
+    `Waiting up to ${context.timeoutSeconds}s for a decision from the dashboard...`
+  );
+}
+async function waitForApprovalDecisionAndResume(context) {
+  if (context.platformConfig.apiKey === null) {
+    context.runtime.writeLine("");
+    context.runtime.writeLine(buildMissingKeyForApprovalWaitMessage());
+    context.runtime.writeLine(`Approval ID: ${context.approvalId}`);
+    context.runtime.writeLine("");
+    return 0;
+  }
+  printWaitingNotice(context);
+  const decision = await pollApprovalUntilDecidedOrTimeout(
+    context,
+    context.platformConfig.apiKey
+  );
+  if (decision === null) {
+    printWaitTimeoutNotice(context);
+    return 0;
+  }
+  context.runtime.writeLine(
+    `Decision received: ${decision.status} by ${decision.decidedBy ?? "dashboard"}. Resuming run locally...`
+  );
+  const result = await resumeRunWithDecision(context, decision);
+  printResumedRunOutcome(context, result);
+  return 0;
+}
+
+// src/commands/run.ts
+var runCommandUsage = "Usage: asm run <file> [--input <json>] [--input-file <path>] [--workflow <exportName>] [--trace-dir <dir>] [--no-upload] [--wait-approval [seconds]]";
+var inputValidationMarker = "input failed schema validation:";
+function parseRunFlags(args) {
+  const waitApprovalExtraction = extractWaitApprovalFlag(args);
+  if (waitApprovalExtraction === null) {
+    return null;
+  }
+  try {
+    const { values, positionals } = parseArgs({
+      args: waitApprovalExtraction.remainingArgs,
+      options: {
+        input: { type: "string" },
+        "input-file": { type: "string" },
+        workflow: { type: "string" },
+        "trace-dir": { type: "string" },
+        "no-upload": { type: "boolean" }
+      },
+      strict: true,
+      allowPositionals: true
+    });
+    const filePath = positionals[0];
+    if (filePath === void 0 || positionals.length > 1) {
+      return null;
+    }
+    return {
+      filePath,
+      inputJson: values.input,
+      inputFilePath: values["input-file"],
+      workflowExportName: values.workflow,
+      traceDirectory: values["trace-dir"],
+      noUpload: values["no-upload"] ?? false,
+      waitApprovalTimeoutSeconds: waitApprovalExtraction.waitApprovalTimeoutSeconds
+    };
+  } catch {
+    return null;
+  }
+}
+function buildWorkflowRunExecutionContext(runtime, output, flags, workflowDefinition, inputValue) {
+  const runId = generateRunId();
+  const traceDirectory = flags.traceDirectory ?? defaultTraceDirectory;
+  const platformConfig = resolvePlatformConfig({
+    homeDirectory: runtime.homeDir,
+    environmentVariables: runtime.env
+  });
+  const sinks = [
+    createConsoleSink({
+      writeLine: runtime.writeLine,
+      useColor: resolveUseColor(runtime.env)
+    }),
+    createJsonlSink({ runId, directory: traceDirectory })
+  ];
+  const platformSink = flags.noUpload || platformConfig.apiKey === null ? null : createPlatformTraceSink({
+    apiKey: platformConfig.apiKey,
+    baseUrl: platformConfig.baseUrl,
+    runId,
+    workflowName: workflowDefinition.name,
+    fetchImplementation: runtime.fetchImplementation
+  });
+  if (platformSink !== null) {
+    sinks.push(platformSink);
+  }
+  return {
+    runtime,
+    output,
+    workflowDefinition,
+    inputValue,
+    runId,
+    traceDirectory,
+    platformConfig,
+    platformSink,
+    sinks,
+    waitApprovalTimeoutSeconds: flags.waitApprovalTimeoutSeconds ?? null
+  };
+}
+function formatRunLatency(latencyMs) {
+  if (latencyMs >= 1e3) {
+    return `${(latencyMs / 1e3).toFixed(1)}s`;
+  }
+  return `${Math.round(latencyMs)}ms`;
+}
+function writeTraceLocationLines(context) {
+  if (context.platformSink !== null) {
+    context.runtime.writeLine(
+      `Trace: ${buildHostedTraceUrl2({
+        dashboardUrl: context.platformConfig.dashboardUrl,
+        runId: context.runId
+      })}`
+    );
+    return;
+  }
+  context.runtime.writeLine(
+    `Trace: ${resolveTraceFilePath2(context.runId, context.traceDirectory)}`
+  );
+  if (context.platformConfig.apiKey === null) {
+    context.runtime.writeLine(buildMissingKeyMessage());
+  }
+}
+function printCompletedWorkflowRunSummary(context, latencyMs) {
+  context.runtime.writeLine("");
+  context.runtime.writeLine("Workflow completed.");
+  context.runtime.writeLine("");
+  context.runtime.writeLine(`Run ID: ${context.runId}`);
+  context.runtime.writeLine("Status: completed");
+  context.runtime.writeLine(`Latency: ${formatRunLatency(latencyMs)}`);
+  writeTraceLocationLines(context);
+  context.runtime.writeLine("");
+}
+function printAwaitingApprovalWorkflowRunSummary(context, approvalId) {
+  context.runtime.writeLine("");
+  context.runtime.writeLine("Workflow paused: a tool call needs approval.");
+  context.runtime.writeLine("");
+  context.runtime.writeLine(`Run ID: ${context.runId}`);
+  context.runtime.writeLine("Status: awaiting_approval");
+  context.runtime.writeLine(`Approval ID: ${approvalId}`);
+  writeTraceLocationLines(context);
+  context.runtime.writeLine(
+    "Resume this run with resumeRun from @assemble-dev/sdk (asm resume is coming soon)."
+  );
+  context.runtime.writeLine("");
+}
+function printFailedWorkflowRun(context, runError) {
+  context.runtime.writeLine("");
+  const markerIndex = runError.message.indexOf(inputValidationMarker);
+  if (markerIndex >= 0) {
+    context.output.writeFailureLine(
+      "Workflow failed: the input didn't match the workflow's input schema."
+    );
+    context.runtime.writeLine(
+      runError.message.slice(markerIndex + inputValidationMarker.length).trim()
+    );
+    return 1;
+  }
+  context.output.writeFailureLine("Workflow failed.");
+  context.runtime.writeLine(runError.message);
+  context.runtime.writeLine(`Run ID: ${context.runId}`);
+  context.runtime.writeLine(
+    `Trace: ${resolveTraceFilePath2(context.runId, context.traceDirectory)}`
+  );
+  return 1;
+}
+async function flushPlatformTraceSink(context) {
+  if (context.platformSink !== null) {
+    await context.platformSink.flush();
+  }
+}
+function printSettledWorkflowRunSummary(context, result, latencyMs) {
+  if (result.status === "awaiting_approval") {
+    printAwaitingApprovalWorkflowRunSummary(context, result.approvalId);
+    return 0;
+  }
+  printCompletedWorkflowRunSummary(context, latencyMs);
+  return 0;
+}
+async function settleWorkflowRunResult(context, result, latencyMs) {
+  if (result.status === "awaiting_approval" && context.waitApprovalTimeoutSeconds !== null) {
+    return await waitForApprovalDecisionAndResume({
+      runtime: context.runtime,
+      workflowDefinition: context.workflowDefinition,
+      runId: context.runId,
+      approvalId: result.approvalId,
+      traceDirectory: context.traceDirectory,
+      platformConfig: context.platformConfig,
+      platformSink: context.platformSink,
+      sinks: context.sinks,
+      timeoutSeconds: context.waitApprovalTimeoutSeconds
+    });
+  }
+  return printSettledWorkflowRunSummary(context, result, latencyMs);
+}
+async function executeWorkflowRun(context) {
+  const now = context.runtime.now ?? (() => /* @__PURE__ */ new Date());
+  const startedAtMs = now().getTime();
+  try {
+    const result = await context.workflowDefinition.run(context.inputValue, {
+      sinks: context.sinks,
+      runId: context.runId,
+      runStateDirectory: context.traceDirectory
+    });
+    const latencyMs = now().getTime() - startedAtMs;
+    await flushPlatformTraceSink(context);
+    return await settleWorkflowRunResult(context, result, latencyMs);
+  } catch (caughtError) {
+    await flushPlatformTraceSink(context);
+    return printFailedWorkflowRun(
+      context,
+      caughtError instanceof Error ? caughtError : new Error(String(caughtError))
+    );
+  }
+}
+async function runRunCommand(args, runtime) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const flags = parseRunFlags(args);
+  if (flags === null) {
+    output.writeFailureLine(`Unrecognized run arguments. ${runCommandUsage}`);
+    return 1;
+  }
+  const inputResult = resolveRunInputValue({
+    inputJson: flags.inputJson,
+    inputFilePath: flags.inputFilePath
+  });
+  if (inputResult.outcome === "failed") {
+    output.writeFailureLine(inputResult.message);
+    return 1;
+  }
+  const loadResult = await loadWorkflowFromFile({
+    filePath: flags.filePath,
+    exportName: flags.workflowExportName
+  });
+  if (loadResult.outcome === "failed") {
+    output.writeFailureLine(loadResult.message);
+    return 1;
+  }
+  return await executeWorkflowRun(
+    buildWorkflowRunExecutionContext(
+      runtime,
+      output,
+      flags,
+      loadResult.workflowDefinition,
+      inputResult.inputValue
+    )
+  );
+}
+
+// src/commands/dev.ts
+var devCommandUsage = "Usage: asm dev <file> [--input <json>] [--input-file <path>] [--workflow <exportName>] [--trace-dir <dir>] [--watch-dir <dir>] [--no-upload]";
+var defaultDebounceDelayMs = 150;
+function parseDevFlags(args) {
+  try {
+    const { values, positionals } = parseArgs2({
+      args,
+      options: {
+        input: { type: "string" },
+        "input-file": { type: "string" },
+        workflow: { type: "string" },
+        "trace-dir": { type: "string" },
+        "watch-dir": { type: "string" },
+        "no-upload": { type: "boolean" }
+      },
+      strict: true,
+      allowPositionals: true
+    });
+    const filePath = positionals[0];
+    if (filePath === void 0 || positionals.length > 1) {
+      return null;
+    }
+    return {
+      filePath,
+      inputJson: values.input,
+      inputFilePath: values["input-file"],
+      workflowExportName: values.workflow,
+      traceDirectory: values["trace-dir"],
+      watchDirectory: values["watch-dir"],
+      noUpload: values["no-upload"] ?? false
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveWatchedPaths(flags) {
+  const watchedPaths = [resolve2(flags.filePath)];
+  if (flags.watchDirectory !== void 0) {
+    watchedPaths.push(resolve2(flags.watchDirectory));
+  }
+  return watchedPaths;
+}
+function findMissingWatchedPath(flags) {
+  return resolveWatchedPaths(flags).find((path) => !existsSync2(path)) ?? null;
+}
+function createSigintStopSignal() {
+  const sigintController = new AbortController();
+  process.once("SIGINT", () => {
+    sigintController.abort();
+  });
+  return sigintController.signal;
+}
+function printChangeDetectedSeparator(runtime, runNumber) {
+  runtime.writeLine("");
+  runtime.writeLine(`\u2500\u2500\u2500\u2500\u2500\u2500 change detected \xB7 run #${runNumber} \u2500\u2500\u2500\u2500\u2500\u2500`);
+  runtime.writeLine("");
+}
+async function executeDevWorkflowIteration(session) {
+  const loadResult = await loadWorkflowFromFile({
+    filePath: session.flags.filePath,
+    exportName: session.flags.workflowExportName,
+    freshImport: true
+  });
+  if (loadResult.outcome === "failed") {
+    session.output.writeFailureLine(loadResult.message);
+    return;
+  }
+  const executionContext = buildWorkflowRunExecutionContext(
+    session.runtime,
+    session.output,
+    session.flags,
+    loadResult.workflowDefinition,
+    session.inputValue
+  );
+  await executeWorkflowRun(executionContext);
+  writeLastRunIdFile(session.lastRunDirectory, executionContext.runId);
+  session.runtime.writeLine(`Last run: ${executionContext.runId}`);
+}
+async function watchAndRerunWorkflow(session) {
+  let runNumber = 1;
+  await executeDevWorkflowIteration(session);
+  session.runtime.writeLine("Watching for changes. Press Ctrl+C to stop.");
+  for (; ; ) {
+    const waitOutcome = await session.changeQueue.waitForWorkflowChangeOrStop(
+      session.stopSignal
+    );
+    if (waitOutcome === "stop") {
+      return;
+    }
+    runNumber += 1;
+    printChangeDetectedSeparator(session.runtime, runNumber);
+    await executeDevWorkflowIteration(session);
+    session.runtime.writeLine("Watching for changes. Press Ctrl+C to stop.");
+  }
+}
+async function runDevCommand(args, runtime, options = {}) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const flags = parseDevFlags(args);
+  if (flags === null) {
+    output.writeFailureLine(`Unrecognized dev arguments. ${devCommandUsage}`);
+    return 1;
+  }
+  const inputResult = resolveRunInputValue({
+    inputJson: flags.inputJson,
+    inputFilePath: flags.inputFilePath
+  });
+  if (inputResult.outcome === "failed") {
+    output.writeFailureLine(inputResult.message);
+    return 1;
+  }
+  const missingWatchedPath = findMissingWatchedPath(flags);
+  if (missingWatchedPath !== null) {
+    output.writeFailureLine(`Watched path not found: ${missingWatchedPath}`);
+    return 1;
+  }
+  return await startDevWatchSession(runtime, output, flags, inputResult.inputValue, options);
+}
+async function startDevWatchSession(runtime, output, flags, inputValue, options) {
+  const changeQueue = createDebouncedWorkflowChangeQueue(
+    options.debounceDelayMs ?? defaultDebounceDelayMs,
+    options.debounceScheduler ?? createTimeoutDebounceScheduler()
+  );
+  const watcherFactory = options.watcherFactory ?? createFileSystemWatcherFactory();
+  const watchHandle = watcherFactory(
+    resolveWatchedPaths(flags),
+    changeQueue.notifyWorkflowChange
+  );
+  try {
+    await watchAndRerunWorkflow({
+      runtime,
+      output,
+      flags,
+      inputValue,
+      lastRunDirectory: options.lastRunDirectory ?? join2(process.cwd(), ".assemble"),
+      changeQueue,
+      stopSignal: options.stopSignal ?? createSigintStopSignal()
+    });
+  } finally {
+    watchHandle.close();
+  }
+  runtime.writeLine("Stopped watching.");
+  return 0;
+}
+
+// src/commands/eval.ts
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { parseArgs as parseArgs3 } from "util";
+import { runEvalSuite } from "@assemble-dev/evals";
+import { resolvePlatformConfig as resolvePlatformConfig2 } from "@assemble-dev/sdk";
+
+// src/commands/eval-metric-table.ts
+function buildEvalMetricTableLines(input) {
+  return [
+    { tone: "info", text: "" },
+    { tone: "info", text: `Suite: ${input.suiteName}` },
+    { tone: "info", text: "" },
+    ...buildEvalCaseRows(input.caseResults),
+    { tone: "info", text: "" },
+    ...buildEvalSummaryLines(input.summary)
+  ];
+}
+function buildEvalCaseRows(caseResults) {
+  const caseNameWidth = Math.max(
+    ...caseResults.map((caseResult) => caseResult.caseName.length),
+    0
+  );
+  const lines = [];
+  for (const caseResult of caseResults) {
+    lines.push({
+      tone: caseResult.passed ? "success" : "failure",
+      text: `${caseResult.caseName.padEnd(caseNameWidth)}  ${formatMetricCells(caseResult.metrics)}`
+    });
+    if (!caseResult.passed) {
+      lines.push(...buildFailedMetricReasonLines(caseResult.metrics));
+    }
+  }
+  return lines;
+}
+function formatMetricCells(metrics) {
+  return metrics.map(
+    (metric) => metric.skipped ? `${metric.name}:skipped` : `${metric.name}:${metric.score.toFixed(2)}`
+  ).join("  ");
+}
+function buildFailedMetricReasonLines(metrics) {
+  return metrics.filter((metric) => !metric.skipped && !metric.passed).map((metric) => ({
+    tone: "info",
+    text: `    ${metric.name}: ${metric.reason}`
+  }));
+}
+function buildEvalSummaryLines(summary) {
+  const passRatePercent = (summary.passRate * 100).toFixed(1);
+  return [
+    {
+      tone: summary.failedCases === 0 ? "success" : "failure",
+      text: `Cases: ${summary.passedCases} passed, ${summary.failedCases} failed (${passRatePercent}% pass rate)`
+    },
+    { tone: "info", text: buildEvalLatencyLine(summary) },
+    { tone: "info", text: buildEvalTokenLine(summary.performance.tokenUsage) }
+  ];
+}
+function buildEvalLatencyLine(summary) {
+  const { totalLatencyMs, averageLatencyMs } = summary.performance;
+  if (totalLatencyMs === null || averageLatencyMs === null) {
+    return "Latency: n/a";
+  }
+  return `Latency: total ${formatEvalLatencyMs(totalLatencyMs)}, avg ${formatEvalLatencyMs(averageLatencyMs)}`;
+}
+function formatEvalLatencyMs(latencyMs) {
+  if (latencyMs >= 1e3) {
+    return `${(latencyMs / 1e3).toFixed(1)}s`;
+  }
+  return `${Math.round(latencyMs)}ms`;
+}
+function buildEvalTokenLine(tokenUsage) {
+  if (tokenUsage === null) {
+    return "Tokens: n/a";
+  }
+  return `Tokens: ${tokenUsage.totalTokens} total (${tokenUsage.inputTokens} in / ${tokenUsage.outputTokens} out)`;
+}
+
+// src/commands/eval-suite-loader.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+import { createJiti as createJiti2 } from "jiti";
+function isRunnableEvalSuiteDefinition(candidate) {
+  return typeof candidate === "object" && candidate !== null && typeof candidate.name === "string" && typeof candidate.workflow === "object" && candidate.workflow !== null && Array.isArray(candidate.cases);
+}
+function listEvalModuleExportNames(loadedModule) {
+  const exportNames = Object.keys(loadedModule);
+  return exportNames.length === 0 ? "(none)" : exportNames.join(", ");
+}
+function listEvalSuiteExportNames(loadedModule) {
+  return Object.entries(loadedModule).filter(([, candidate]) => isRunnableEvalSuiteDefinition(candidate)).map(([exportName]) => exportName);
+}
+async function importEvalSuiteModule(absoluteFilePath) {
+  const jiti = createJiti2(import.meta.url, { interopDefault: false });
+  try {
+    return await jiti.import(absoluteFilePath);
+  } catch (caughtError) {
+    const reason = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    return `Could not load eval suite file ${absoluteFilePath}: ${reason}`;
+  }
+}
+function resolveNamedEvalSuiteExport(loadedModule, exportName, absoluteFilePath) {
+  const candidate = loadedModule[exportName];
+  if (isRunnableEvalSuiteDefinition(candidate)) {
+    return { outcome: "loaded", suiteDefinition: candidate };
+  }
+  return {
+    outcome: "failed",
+    message: `Export "${exportName}" in ${absoluteFilePath} is not an eval suite. Available exports: ${listEvalModuleExportNames(loadedModule)}`
+  };
+}
+function resolveDiscoveredEvalSuiteExport(loadedModule, absoluteFilePath) {
+  const defaultExport = loadedModule.default;
+  if (isRunnableEvalSuiteDefinition(defaultExport)) {
+    return { outcome: "loaded", suiteDefinition: defaultExport };
+  }
+  const suiteExportNames = listEvalSuiteExportNames(loadedModule);
+  const singleSuiteExportName = suiteExportNames[0];
+  if (suiteExportNames.length === 1 && singleSuiteExportName !== void 0) {
+    return resolveNamedEvalSuiteExport(
+      loadedModule,
+      singleSuiteExportName,
+      absoluteFilePath
+    );
+  }
+  if (suiteExportNames.length === 0) {
+    return {
+      outcome: "failed",
+      message: `No eval suite export found in ${absoluteFilePath}. Available exports: ${listEvalModuleExportNames(loadedModule)}. Export a suite as the default export or pass --suite <exportName>.`
+    };
+  }
+  return {
+    outcome: "failed",
+    message: `Multiple eval suite exports found in ${absoluteFilePath}: ${suiteExportNames.join(", ")}. Pass --suite <exportName> to choose one.`
+  };
+}
+async function loadEvalSuiteFromFile(input) {
+  const absoluteFilePath = resolve3(input.filePath);
+  if (!existsSync3(absoluteFilePath)) {
+    return {
+      outcome: "failed",
+      message: `Eval suite file not found: ${absoluteFilePath}`
+    };
+  }
+  const importResult = await importEvalSuiteModule(absoluteFilePath);
+  if (typeof importResult === "string") {
+    return { outcome: "failed", message: importResult };
+  }
+  if (input.exportName !== void 0) {
+    return resolveNamedEvalSuiteExport(
+      importResult,
+      input.exportName,
+      absoluteFilePath
+    );
+  }
+  return resolveDiscoveredEvalSuiteExport(importResult, absoluteFilePath);
+}
+
+// src/commands/eval.ts
+var evalCommandUsage = "Usage: asm eval <suite-file> [--suite <exportName>] [--results-dir <dir>] [--no-upload]";
+function parseEvalFlags(args) {
+  try {
+    const { values, positionals } = parseArgs3({
+      args,
+      options: {
+        suite: { type: "string" },
+        "results-dir": { type: "string" },
+        "no-upload": { type: "boolean" }
+      },
+      strict: true,
+      allowPositionals: true
+    });
+    const filePath = positionals[0];
+    if (filePath === void 0 || positionals.length > 1) {
+      return null;
+    }
+    return {
+      filePath,
+      suiteExportName: values.suite,
+      resultsDirectory: values["results-dir"],
+      noUpload: values["no-upload"] ?? false
+    };
+  } catch {
+    return null;
+  }
+}
+function buildEvalPlatformOptions(runtime, noUpload) {
+  if (noUpload) {
+    return {
+      environmentVariables: {},
+      homeDirectory: join3(tmpdir(), "assemble-cli-no-upload-home")
+    };
+  }
+  return {
+    environmentVariables: runtime.env,
+    homeDirectory: runtime.homeDir,
+    fetchImplementation: runtime.fetchImplementation
+  };
+}
+function buildRunEvalSuiteOptions(runtime, flags) {
+  const options = {
+    platform: buildEvalPlatformOptions(runtime, flags.noUpload),
+    writeLine: flags.noUpload ? () => void 0 : runtime.writeLine
+  };
+  if (flags.resultsDirectory !== void 0) {
+    options.resultsDirectory = flags.resultsDirectory;
+  }
+  return options;
+}
+function writeEvalTableLines(runtime, output, lines) {
+  for (const line of lines) {
+    if (line.tone === "success") {
+      output.writeSuccessLine(line.text);
+    } else if (line.tone === "failure") {
+      output.writeFailureLine(line.text);
+    } else {
+      runtime.writeLine(line.text);
+    }
+  }
+}
+function writeEvalResultLocationLines(runtime, result) {
+  runtime.writeLine(`Results: ${result.resultsFilePath}`);
+  if (result.uploadStatus === "uploaded") {
+    const platformConfig = resolvePlatformConfig2({
+      homeDirectory: runtime.homeDir,
+      environmentVariables: runtime.env
+    });
+    runtime.writeLine(
+      `Eval: ${platformConfig.dashboardUrl}/app/evals/${result.evalRunId}`
+    );
+  }
+  if (result.uploadStatus === "failed") {
+    runtime.writeLine(
+      "Upload failed; the results file above is still saved locally."
+    );
+  }
+  runtime.writeLine("");
+}
+async function executeEvalSuiteRun(runtime, output, flags, suiteDefinition) {
+  try {
+    const result = await runEvalSuite({
+      suite: suiteDefinition,
+      options: buildRunEvalSuiteOptions(runtime, flags)
+    });
+    writeEvalTableLines(
+      runtime,
+      output,
+      buildEvalMetricTableLines({
+        suiteName: suiteDefinition.name,
+        caseResults: result.caseResults,
+        summary: result.summary
+      })
+    );
+    writeEvalResultLocationLines(runtime, result);
+    return result.summary.failedCases > 0 ? 1 : 0;
+  } catch (caughtError) {
+    const reason = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    output.writeFailureLine(`Eval run failed: ${reason}`);
+    return 1;
+  }
+}
+async function runEvalCommand(args, runtime) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const flags = parseEvalFlags(args);
+  if (flags === null) {
+    output.writeFailureLine(`Unrecognized eval arguments. ${evalCommandUsage}`);
+    return 1;
+  }
+  const loadResult = await loadEvalSuiteFromFile({
+    filePath: flags.filePath,
+    exportName: flags.suiteExportName
+  });
+  if (loadResult.outcome === "failed") {
+    output.writeFailureLine(loadResult.message);
+    return 1;
+  }
+  return await executeEvalSuiteRun(
+    runtime,
+    output,
+    flags,
+    loadResult.suiteDefinition
+  );
+}
+
+// src/commands/init.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname, join as join4, resolve as resolve4 } from "path";
+import { parseArgs as parseArgs4 } from "util";
+
+// src/templates/starter-template.ts
+var defaultStarterDirectoryName = "my-assemble-app";
+var starterPackageJson = {
+  name: "my-assemble-app",
+  version: "0.1.0",
+  private: true,
+  type: "module",
+  scripts: {
+    run: "asm run src/workflow.ts"
+  },
+  dependencies: {
+    "@assemble-dev/providers": "^0.0.0",
+    "@assemble-dev/sdk": "^0.0.0",
+    zod: "^4.1.13"
+  }
+};
+var starterTsconfig = {
+  compilerOptions: {
+    target: "ES2022",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    strict: true,
+    skipLibCheck: true,
+    noEmit: true
+  },
+  include: ["src"]
+};
+var starterEnvExampleContents = `# Provider API keys are optional for the starter workflow.
+# The sample workflow in src/workflow.ts uses mockModel() and needs no keys.
+# Add your own keys here when you switch an agent to a real model.
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+GOOGLE_API_KEY=
+ASSEMBLE_API_KEY=
+`;
+var starterGitignoreContents = `node_modules
+.env
+.assemble
+`;
+var starterWorkflowTemplateContents = `import { mockModel } from "@assemble-dev/providers";
+import { agent, workflow } from "@assemble-dev/sdk";
+import { z } from "zod";
+
+const StoryInputSchema = z.object({ topic: z.string().min(1) });
+
+const OutlineSchema = z.object({ outline: z.array(z.string()).min(1) });
+
+const StorySchema = z.object({ story: z.string().min(1) });
+
+const outlinerAgent = agent({
+  name: "outliner",
+  role: "Plans a short story outline",
+  model: mockModel({
+    scriptedResponses: [
+      '{"outline":["Introduce the hero","Resolve the quest"]}',
+    ],
+  }),
+  instructions: "Turn the topic into a two-beat story outline.",
+  outputSchema: OutlineSchema,
+});
+
+const writerAgent = agent({
+  name: "writer",
+  role: "Writes a short story from the outline",
+  model: mockModel({
+    scriptedResponses: [
+      '{"story":"The hero set out, faced the quest, and returned home changed."}',
+    ],
+  }),
+  instructions: "Write a short story that follows the outline.",
+  outputSchema: StorySchema,
+});
+
+export const starterWorkflow = workflow({
+  name: "starter-story",
+  inputSchema: StoryInputSchema,
+  outputSchema: StorySchema,
+  agents: [outlinerAgent, writerAgent],
+  topology: { kind: "pipeline" },
+});
+
+export default starterWorkflow;
+`;
+var starterTemplateFiles = [
+  {
+    relativePath: "package.json",
+    contents: `${JSON.stringify(starterPackageJson, null, 2)}
+`
+  },
+  {
+    relativePath: "tsconfig.json",
+    contents: `${JSON.stringify(starterTsconfig, null, 2)}
+`
+  },
+  {
+    relativePath: ".env.example",
+    contents: starterEnvExampleContents
+  },
+  {
+    relativePath: ".gitignore",
+    contents: starterGitignoreContents
+  },
+  {
+    relativePath: "src/workflow.ts",
+    contents: starterWorkflowTemplateContents
+  }
+];
+
+// src/commands/init.ts
+function parseInitFlags(args) {
+  try {
+    const { values, positionals } = parseArgs4({
+      args,
+      options: {
+        force: { type: "boolean", default: false }
+      },
+      strict: true,
+      allowPositionals: true
+    });
+    if (positionals.length > 1) {
+      return null;
+    }
+    return {
+      force: values.force,
+      targetDirectoryArg: positionals[0] ?? defaultStarterDirectoryName
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveTargetDirectoryState(targetDirectory) {
+  if (!existsSync4(targetDirectory)) {
+    return "available";
+  }
+  if (!statSync2(targetDirectory).isDirectory()) {
+    return "existing-file";
+  }
+  if (readdirSync(targetDirectory).length > 0) {
+    return "non-empty-directory";
+  }
+  return "available";
+}
+function writeStarterTemplateFiles(targetDirectory) {
+  for (const templateFile of starterTemplateFiles) {
+    const filePath = join4(targetDirectory, templateFile.relativePath);
+    mkdirSync2(dirname(filePath), { recursive: true });
+    writeFileSync2(filePath, templateFile.contents);
+  }
+}
+function writeInitSuccessOutput(output, targetDirectoryArg) {
+  output.writeSuccessLine(
+    `Scaffolded Assemble starter project in ${targetDirectoryArg}`
+  );
+  output.writeInfoLine("");
+  output.writeInfoLine("Created files:");
+  for (const templateFile of starterTemplateFiles) {
+    output.writeInfoLine(`  ${templateFile.relativePath}`);
+  }
+  output.writeInfoLine("");
+  output.writeInfoLine("Next steps:");
+  output.writeInfoLine(`  cd ${targetDirectoryArg}`);
+  output.writeInfoLine("  pnpm install");
+  output.writeInfoLine("  asm run src/workflow.ts");
+  output.writeInfoLine("");
+  output.writeInfoLine(
+    "The sample workflow runs on mockModel and needs no API keys. Copy .env.example to .env when you switch to real provider models."
+  );
+}
+function runInitCommand(args, runtime, options = {}) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const flags = parseInitFlags(args);
+  if (flags === null) {
+    output.writeFailureLine(
+      "Unrecognized init arguments. Usage: asm init [dir] [--force]"
+    );
+    return 1;
+  }
+  const workingDirectory = options.cwd ?? process.cwd();
+  const targetDirectory = resolve4(workingDirectory, flags.targetDirectoryArg);
+  const targetDirectoryState = resolveTargetDirectoryState(targetDirectory);
+  if (targetDirectoryState === "existing-file") {
+    output.writeFailureLine(
+      `${flags.targetDirectoryArg} already exists and is not a directory. Pick a different directory name.`
+    );
+    return 1;
+  }
+  if (targetDirectoryState === "non-empty-directory" && !flags.force) {
+    output.writeFailureLine(
+      `${flags.targetDirectoryArg} already exists and is not empty. Pass --force to write the starter files into it anyway.`
+    );
+    return 1;
+  }
+  writeStarterTemplateFiles(targetDirectory);
+  writeInitSuccessOutput(output, flags.targetDirectoryArg);
+  return 0;
+}
+
+// src/commands/login.ts
+import { parseArgs as parseArgs5 } from "util";
+
+// src/config/api-key-format.ts
+var rawApiKeyPattern = /^asm_(dev|prod|ci)_[0-9a-f]{32}_[0-9a-f]{64}$/;
+var expectedRawApiKeyFormat = "asm_<dev|prod|ci>_<32 hex characters>_<64 hex characters>";
+var maskedKeyLast4Length = 4;
+function validateRawApiKeyFormat(rawKey) {
+  return rawApiKeyPattern.test(rawKey);
+}
+function maskRawApiKey(rawKey) {
+  const last4 = rawKey.slice(-maskedKeyLast4Length);
+  const match = rawApiKeyPattern.exec(rawKey);
+  if (match === null) {
+    return `\u2026${last4}`;
+  }
+  const environment = match[1];
+  return `asm_${environment}_\u2026${last4}`;
+}
+
+// src/config/cli-config.ts
+import {
+  chmodSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { dirname as dirname2, join as join5 } from "path";
+import { z as z2 } from "zod";
+var defaultCliBaseUrl = "https://api.assemble.dev";
+var cliDashboardKeysUrl = "https://app.assemble.dev/app/keys";
+var CliConfigFileSchema = z2.object({
+  apiKey: z2.string().min(1).optional(),
+  baseUrl: z2.string().min(1).optional(),
+  workspaceId: z2.string().min(1).optional()
+});
+var configDirectoryMode = 448;
+var configFileMode = 384;
+function resolveCliConfigFilePath(homeDir) {
+  return join5(homeDir, ".assemble", "config.json");
+}
+function readCliConfigFile(homeDir) {
+  const configFilePath = resolveCliConfigFilePath(homeDir);
+  if (!existsSync5(configFilePath)) {
+    return { config: {}, warning: null };
+  }
+  try {
+    const rawContents = readFileSync2(configFilePath, "utf8");
+    return {
+      config: CliConfigFileSchema.parse(JSON.parse(rawContents)),
+      warning: null
+    };
+  } catch {
+    return {
+      config: {},
+      warning: `Warning: could not parse ${configFilePath}; treating it as empty.`
+    };
+  }
+}
+function writeCliConfigFile(homeDir, config) {
+  const configFilePath = resolveCliConfigFilePath(homeDir);
+  const configDirectoryPath = dirname2(configFilePath);
+  mkdirSync3(configDirectoryPath, {
+    recursive: true,
+    mode: configDirectoryMode
+  });
+  chmodSync(configDirectoryPath, configDirectoryMode);
+  writeFileSync3(configFilePath, `${JSON.stringify(config, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: configFileMode
+  });
+  chmodSync(configFilePath, configFileMode);
+  return configFilePath;
+}
+
+// src/config/cli-env.ts
+import { z as z3 } from "zod";
+var CliEnvSchema = z3.object({
+  ASSEMBLE_API_KEY: z3.string().min(1).optional(),
+  ASSEMBLE_BASE_URL: z3.string().min(1).optional(),
+  NO_COLOR: z3.string().optional()
+});
+function parseCliEnvironment(environmentVariables) {
+  const parsedEnvironment = CliEnvSchema.safeParse(environmentVariables);
+  if (parsedEnvironment.success) {
+    return parsedEnvironment.data;
+  }
+  return {};
+}
+
+// src/platform/auth-check.ts
+import { AppErrorCode } from "@assemble-dev/shared-types";
+import { z as z4 } from "zod";
+var AuthCheckResponseSchema = z4.object({
+  workspaceId: z4.string().min(1)
+});
+var AuthCheckErrorResponseSchema = z4.object({
+  error: z4.object({
+    code: z4.enum(AppErrorCode),
+    message: z4.string()
+  })
+});
+function resolveAuthCheckUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/v1/auth-check`;
+}
+function parseUnauthorizedServerMessage(rawBody) {
+  try {
+    const parsedBody = AuthCheckErrorResponseSchema.parse(JSON.parse(rawBody));
+    return parsedBody.error.message;
+  } catch {
+    return null;
+  }
+}
+async function checkApiKeyWithPlatform(input) {
+  try {
+    const response = await input.fetchImplementation(
+      resolveAuthCheckUrl(input.baseUrl),
+      {
+        method: "GET",
+        headers: { authorization: `Bearer ${input.rawKey}` }
+      }
+    );
+    if (response.status === 401) {
+      return {
+        outcome: "unauthorized",
+        serverMessage: parseUnauthorizedServerMessage(await response.text())
+      };
+    }
+    if (!response.ok) {
+      return {
+        outcome: "request-failed",
+        message: `the auth check returned status ${response.status}`
+      };
+    }
+    const responseBody = AuthCheckResponseSchema.parse(
+      JSON.parse(await response.text())
+    );
+    return { outcome: "authorized", workspaceId: responseBody.workspaceId };
+  } catch (caughtError) {
+    return {
+      outcome: "request-failed",
+      message: caughtError instanceof Error ? caughtError.message : String(caughtError)
+    };
+  }
+}
+
+// src/commands/login.ts
+function parseLoginFlags(args) {
+  try {
+    const { values } = parseArgs5({
+      args,
+      options: {
+        key: { type: "string" },
+        "base-url": { type: "string" }
+      },
+      strict: true,
+      allowPositionals: false
+    });
+    return { key: values.key, baseUrl: values["base-url"] };
+  } catch {
+    return null;
+  }
+}
+async function resolveLoginKey(flags, runtime) {
+  if (flags.key !== void 0) {
+    return flags.key.trim();
+  }
+  if (runtime.readLine !== void 0) {
+    const lineFromStdin = await runtime.readLine();
+    return lineFromStdin.trim();
+  }
+  return null;
+}
+function resolveLoginBaseUrl(flags, runtime, configFileResult) {
+  const environment = parseCliEnvironment(runtime.env);
+  return flags.baseUrl ?? environment.ASSEMBLE_BASE_URL ?? configFileResult.config.baseUrl ?? defaultCliBaseUrl;
+}
+async function validateAndSaveApiKey(rawKey, flags, runtime, output) {
+  const configFileResult = readCliConfigFile(runtime.homeDir);
+  if (configFileResult.warning !== null) {
+    output.writeInfoLine(configFileResult.warning);
+  }
+  const baseUrl = resolveLoginBaseUrl(flags, runtime, configFileResult);
+  const checkResult = await checkApiKeyWithPlatform({
+    baseUrl,
+    rawKey,
+    fetchImplementation: runtime.fetchImplementation
+  });
+  if (checkResult.outcome === "unauthorized") {
+    const rejectionDetail = checkResult.serverMessage === null ? "" : ` (${checkResult.serverMessage})`;
+    output.writeFailureLine(
+      `This API key was rejected${rejectionDetail}. It may have been revoked. Create a new key at ${cliDashboardKeysUrl}`
+    );
+    return 1;
+  }
+  if (checkResult.outcome === "request-failed") {
+    output.writeFailureLine(
+      `Could not reach ${baseUrl}: ${checkResult.message}. Check your network connection or pass a different --base-url.`
+    );
+    return 1;
+  }
+  const configFilePath = writeCliConfigFile(runtime.homeDir, {
+    ...configFileResult.config,
+    apiKey: rawKey,
+    workspaceId: checkResult.workspaceId,
+    ...flags.baseUrl === void 0 ? {} : { baseUrl: flags.baseUrl }
+  });
+  output.writeSuccessLine(
+    `Logged in to workspace ${checkResult.workspaceId} with key ${maskRawApiKey(rawKey)}`
+  );
+  output.writeInfoLine(`Credentials saved to ${configFilePath}`);
+  return 0;
+}
+async function runLoginCommand(args, runtime) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const flags = parseLoginFlags(args);
+  if (flags === null) {
+    output.writeFailureLine(
+      "Unrecognized login arguments. Usage: asm login --key <api-key> [--base-url <url>]"
+    );
+    return 1;
+  }
+  const rawKey = await resolveLoginKey(flags, runtime);
+  if (rawKey === null || rawKey === "") {
+    output.writeFailureLine(
+      "No API key provided. Pass one with --key <api-key> or pipe it on stdin."
+    );
+    return 1;
+  }
+  if (!validateRawApiKeyFormat(rawKey)) {
+    output.writeFailureLine(
+      `That does not look like an Assemble API key. Expected format: ${expectedRawApiKeyFormat}`
+    );
+    return 1;
+  }
+  return await validateAndSaveApiKey(rawKey, flags, runtime, output);
+}
+
+// src/commands/logout.ts
+function runLogoutCommand(runtime) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const configFileResult = readCliConfigFile(runtime.homeDir);
+  if (configFileResult.warning !== null) {
+    output.writeInfoLine(configFileResult.warning);
+  }
+  if (configFileResult.config.apiKey === void 0 && configFileResult.config.workspaceId === void 0) {
+    output.writeInfoLine("You are already logged out.");
+    return 0;
+  }
+  const remainingConfig = { ...configFileResult.config };
+  delete remainingConfig.apiKey;
+  delete remainingConfig.workspaceId;
+  const configFilePath = writeCliConfigFile(runtime.homeDir, remainingConfig);
+  output.writeSuccessLine(
+    `Logged out. Credentials removed from ${configFilePath}`
+  );
+  return 0;
+}
+
+// src/commands/replay.ts
+import { parseArgs as parseArgs6 } from "util";
+import {
+  compareRunToReplay,
+  defaultRunStateDirectory,
+  defaultTraceDirectory as defaultTraceDirectory2,
+  loadReplaySource,
+  replayRun
+} from "@assemble-dev/sdk";
+import { z as z5 } from "zod";
+
+// src/commands/replay-comparison-format.ts
+var maxPrintedReplayDiffRows = 10;
+var maxDiffCellLength = 48;
+function buildReplayComparisonLines(input) {
+  return [
+    { tone: "info", text: "" },
+    { tone: "info", text: `Replay of run ${input.sourceRunId} completed.` },
+    { tone: "info", text: "" },
+    { tone: "info", text: `Replay Run ID: ${input.replayRunId}` },
+    ...buildFromStepLines(input.fromStepIndex),
+    buildStatusLine(input.comparison),
+    ...buildOutputLines(input.comparison),
+    { tone: "info", text: buildLatencyLine(input.comparison) },
+    buildRoutingLine(input.comparison),
+    { tone: "info", text: "" }
+  ];
+}
+function buildFromStepLines(fromStepIndex) {
+  if (fromStepIndex === 0) {
+    return [];
+  }
+  return [{ tone: "info", text: `Replayed from step ${fromStepIndex}` }];
+}
+function buildStatusLine(comparison) {
+  return {
+    tone: comparison.statusMatches ? "success" : "failure",
+    text: `Status: ${comparison.originalStatus} (original) vs ${comparison.replayStatus} (replay)`
+  };
+}
+function buildOutputLines(comparison) {
+  if (comparison.outputMatches) {
+    return [{ tone: "success", text: "Output matches" }];
+  }
+  const differenceCount = comparison.outputDiff.length;
+  const printedDiffs = comparison.outputDiff.slice(0, maxPrintedReplayDiffRows);
+  const lines = [
+    {
+      tone: "failure",
+      text: `Output differs (${differenceCount} difference${differenceCount === 1 ? "" : "s"})`
+    },
+    ...buildAlignedDiffRows(printedDiffs)
+  ];
+  if (differenceCount > maxPrintedReplayDiffRows) {
+    lines.push({
+      tone: "info",
+      text: `  \u2026 and ${differenceCount - maxPrintedReplayDiffRows} more differences`
+    });
+  }
+  return lines;
+}
+function buildAlignedDiffRows(diffs) {
+  const rows = diffs.map((diff) => ({
+    path: diff.path,
+    original: formatDiffCellValue(diff.original),
+    replay: formatDiffCellValue(diff.replay)
+  }));
+  const pathWidth = Math.max(...rows.map((row) => row.path.length), 0);
+  const originalWidth = Math.max(...rows.map((row) => row.original.length), 0);
+  return rows.map((row) => ({
+    tone: "info",
+    text: `  ${row.path.padEnd(pathWidth)} | ${row.original.padEnd(originalWidth)} | ${row.replay}`
+  }));
+}
+function formatDiffCellValue(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized.length <= maxDiffCellLength) {
+    return serialized;
+  }
+  return `${serialized.slice(0, maxDiffCellLength - 1)}\u2026`;
+}
+function formatReplayLatencyMs(latencyMs) {
+  if (latencyMs === null) {
+    return "n/a";
+  }
+  if (Math.abs(latencyMs) >= 1e3) {
+    return `${(latencyMs / 1e3).toFixed(1)}s`;
+  }
+  return `${Math.round(latencyMs)}ms`;
+}
+function buildLatencyLine(comparison) {
+  const { originalMs, replayMs, deltaMs } = comparison.latency;
+  const baseText = `Latency: original ${formatReplayLatencyMs(originalMs)}, replay ${formatReplayLatencyMs(replayMs)}`;
+  if (deltaMs === null) {
+    return baseText;
+  }
+  const signedDelta = deltaMs >= 0 ? `+${formatReplayLatencyMs(deltaMs)}` : `-${formatReplayLatencyMs(Math.abs(deltaMs))}`;
+  return `${baseText} (delta ${signedDelta})`;
+}
+function buildRoutingLine(comparison) {
+  return {
+    tone: comparison.routingMatches ? "success" : "failure",
+    text: comparison.routingMatches ? "Routing matches" : "Routing differs"
+  };
+}
+
+// src/commands/replay-last-run.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
+var lastRunFileRelativePath = join6(".assemble", "last-run");
+function resolveLastRunFilePath(workingDirectory) {
+  return join6(workingDirectory, lastRunFileRelativePath);
+}
+function readLastRunIdFromFile(workingDirectory) {
+  const lastRunFilePath = resolveLastRunFilePath(workingDirectory);
+  if (!existsSync6(lastRunFilePath)) {
+    return null;
+  }
+  const fileContents = readFileSync3(lastRunFilePath, "utf8").trim();
+  return fileContents === "" ? null : fileContents;
+}
+
+// src/commands/replay-workflow-loader.ts
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve5 } from "path";
+import { createJiti as createJiti3 } from "jiti";
+function isReplayableWorkflowDefinition(candidate) {
+  return typeof candidate === "object" && candidate !== null && typeof candidate.name === "string" && typeof candidate.run === "function" && candidate.inputSchema !== void 0 && Array.isArray(candidate.agents);
+}
+function listReplayModuleExportNames(loadedModule) {
+  const exportNames = Object.keys(loadedModule);
+  return exportNames.length === 0 ? "(none)" : exportNames.join(", ");
+}
+function listReplayWorkflowExportNames(loadedModule) {
+  return Object.entries(loadedModule).filter(([, candidate]) => isReplayableWorkflowDefinition(candidate)).map(([exportName]) => exportName);
+}
+async function importReplayWorkflowModule(absoluteFilePath) {
+  const jiti = createJiti3(import.meta.url, { interopDefault: false });
+  try {
+    return await jiti.import(absoluteFilePath);
+  } catch (caughtError) {
+    const reason = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    return `Could not load workflow file ${absoluteFilePath}: ${reason}`;
+  }
+}
+function resolveNamedReplayWorkflowExport(loadedModule, exportName, absoluteFilePath) {
+  const candidate = loadedModule[exportName];
+  if (isReplayableWorkflowDefinition(candidate)) {
+    return { outcome: "loaded", workflowDefinition: candidate };
+  }
+  return {
+    outcome: "failed",
+    message: `Export "${exportName}" in ${absoluteFilePath} is not a workflow. Available exports: ${listReplayModuleExportNames(loadedModule)}`
+  };
+}
+function resolveDiscoveredReplayWorkflowExport(loadedModule, absoluteFilePath) {
+  const defaultExport = loadedModule.default;
+  if (isReplayableWorkflowDefinition(defaultExport)) {
+    return { outcome: "loaded", workflowDefinition: defaultExport };
+  }
+  const workflowExportNames = listReplayWorkflowExportNames(loadedModule);
+  const singleWorkflowExportName = workflowExportNames[0];
+  if (workflowExportNames.length === 1 && singleWorkflowExportName !== void 0) {
+    return resolveNamedReplayWorkflowExport(
+      loadedModule,
+      singleWorkflowExportName,
+      absoluteFilePath
+    );
+  }
+  if (workflowExportNames.length === 0) {
+    return {
+      outcome: "failed",
+      message: `No workflow export found in ${absoluteFilePath}. Available exports: ${listReplayModuleExportNames(loadedModule)}. Export a workflow as the default export or pass --workflow <exportName>.`
+    };
+  }
+  return {
+    outcome: "failed",
+    message: `Multiple workflow exports found in ${absoluteFilePath}: ${workflowExportNames.join(", ")}. Pass --workflow <exportName> to choose one.`
+  };
+}
+async function loadReplayWorkflowFromFile(input) {
+  const absoluteFilePath = resolve5(input.filePath);
+  if (!existsSync7(absoluteFilePath)) {
+    return {
+      outcome: "failed",
+      message: `Workflow file not found: ${absoluteFilePath}`
+    };
+  }
+  const importResult = await importReplayWorkflowModule(absoluteFilePath);
+  if (typeof importResult === "string") {
+    return { outcome: "failed", message: importResult };
+  }
+  if (input.exportName !== void 0) {
+    return resolveNamedReplayWorkflowExport(
+      importResult,
+      input.exportName,
+      absoluteFilePath
+    );
+  }
+  return resolveDiscoveredReplayWorkflowExport(importResult, absoluteFilePath);
+}
+
+// src/commands/replay.ts
+var replayCommandUsage = "Usage: asm replay [runId] --workflow-file <file> [--workflow <exportName>] [--from-step <n>] [--no-mock-tools] [--trace-dir <dir>] [--state-dir <dir>]";
+var FromStepSchema = z5.coerce.number().int().min(0);
+function parseReplayFlags(args) {
+  try {
+    const { values, positionals } = parseArgs6({
+      args,
+      options: {
+        "workflow-file": { type: "string" },
+        workflow: { type: "string" },
+        "from-step": { type: "string" },
+        "mock-tools": { type: "boolean" },
+        "no-mock-tools": { type: "boolean" },
+        "trace-dir": { type: "string" },
+        "state-dir": { type: "string" }
+      },
+      strict: true,
+      allowPositionals: true
+    });
+    if (positionals.length > 1) {
+      return null;
+    }
+    return {
+      runId: positionals[0],
+      workflowFilePath: values["workflow-file"],
+      workflowExportName: values.workflow,
+      fromStepRaw: values["from-step"],
+      mockTools: values["no-mock-tools"] === true ? false : true,
+      traceDirectory: values["trace-dir"] ?? defaultTraceDirectory2,
+      runStateDirectory: values["state-dir"] ?? defaultRunStateDirectory
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveReplaySourceRunId(positionalRunId) {
+  if (positionalRunId !== void 0) {
+    return { runId: positionalRunId };
+  }
+  const lastRunId = readLastRunIdFromFile(process.cwd());
+  if (lastRunId !== null) {
+    return { runId: lastRunId };
+  }
+  return {
+    message: `No run id given and no ${lastRunFileRelativePath} file found. Pass a run id (asm replay <runId>) or run a workflow first so ${lastRunFileRelativePath} exists.`
+  };
+}
+function resolveReplayFromStepIndex(fromStepRaw) {
+  if (fromStepRaw === void 0) {
+    return 0;
+  }
+  const parsedFromStep = FromStepSchema.safeParse(fromStepRaw);
+  return parsedFromStep.success ? parsedFromStep.data : null;
+}
+function writeReplayComparisonLines(runtime, output, lines) {
+  for (const line of lines) {
+    if (line.tone === "success") {
+      output.writeSuccessLine(line.text);
+    } else if (line.tone === "failure") {
+      output.writeFailureLine(line.text);
+    } else {
+      runtime.writeLine(line.text);
+    }
+  }
+}
+async function executeReplayComparison(input) {
+  const loadResult = await loadReplayWorkflowFromFile({
+    filePath: input.workflowFilePath,
+    exportName: input.flags.workflowExportName
+  });
+  if (loadResult.outcome === "failed") {
+    input.output.writeFailureLine(loadResult.message);
+    return 1;
+  }
+  try {
+    const replayResult = await replayRun({
+      definition: loadResult.workflowDefinition,
+      sourceRunId: input.sourceRunId,
+      options: {
+        fromStepIndex: input.fromStepIndex,
+        mockTools: input.flags.mockTools,
+        runStateDirectory: input.flags.runStateDirectory,
+        traceDirectory: input.flags.traceDirectory
+      }
+    });
+    const originalSource = loadReplaySource({
+      runId: input.sourceRunId,
+      runStateDirectory: input.flags.runStateDirectory,
+      traceDirectory: input.flags.traceDirectory
+    });
+    const comparison = compareRunToReplay({
+      original: originalSource.state,
+      replay: replayResult.state
+    });
+    writeReplayComparisonLines(
+      input.runtime,
+      input.output,
+      buildReplayComparisonLines({
+        sourceRunId: input.sourceRunId,
+        replayRunId: replayResult.runId,
+        fromStepIndex: input.fromStepIndex,
+        comparison
+      })
+    );
+    return 0;
+  } catch (caughtError) {
+    const reason = caughtError instanceof Error ? caughtError.message : String(caughtError);
+    input.output.writeFailureLine(`Replay failed: ${reason}`);
+    return 1;
+  }
+}
+async function runReplayCommand(args, runtime) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const flags = parseReplayFlags(args);
+  if (flags === null) {
+    output.writeFailureLine(`Unrecognized replay arguments. ${replayCommandUsage}`);
+    return 1;
+  }
+  if (flags.workflowFilePath === void 0) {
+    output.writeFailureLine(
+      `asm replay needs the workflow definition to re-run it. Pass --workflow-file <file> pointing at the workflow file used for the original run. ${replayCommandUsage}`
+    );
+    return 1;
+  }
+  const fromStepIndex = resolveReplayFromStepIndex(flags.fromStepRaw);
+  if (fromStepIndex === null) {
+    output.writeFailureLine("--from-step must be a non-negative integer.");
+    return 1;
+  }
+  const runIdResolution = resolveReplaySourceRunId(flags.runId);
+  if ("message" in runIdResolution) {
+    output.writeFailureLine(runIdResolution.message);
+    return 1;
+  }
+  return await executeReplayComparison({
+    runtime,
+    output,
+    flags,
+    workflowFilePath: flags.workflowFilePath,
+    sourceRunId: runIdResolution.runId,
+    fromStepIndex
+  });
+}
+
+// src/commands/whoami.ts
+function resolveWhoamiKey(environmentApiKey, configApiKey, homeDir) {
+  if (environmentApiKey !== void 0) {
+    return {
+      rawKey: environmentApiKey,
+      source: "the ASSEMBLE_API_KEY environment variable"
+    };
+  }
+  if (configApiKey !== void 0) {
+    return {
+      rawKey: configApiKey,
+      source: resolveCliConfigFilePath(homeDir)
+    };
+  }
+  return null;
+}
+async function reportWhoamiIdentity(resolvedKey, baseUrl, runtime, output) {
+  const checkResult = await checkApiKeyWithPlatform({
+    baseUrl,
+    rawKey: resolvedKey.rawKey,
+    fetchImplementation: runtime.fetchImplementation
+  });
+  if (checkResult.outcome === "unauthorized") {
+    output.writeFailureLine(
+      `Your API key (from ${resolvedKey.source}) is invalid or revoked. Create a new key at ${cliDashboardKeysUrl}`
+    );
+    return 1;
+  }
+  if (checkResult.outcome === "request-failed") {
+    output.writeFailureLine(
+      `Could not reach ${baseUrl}: ${checkResult.message}. Check your network connection and try again.`
+    );
+    return 1;
+  }
+  output.writeSuccessLine(`Workspace: ${checkResult.workspaceId}`);
+  output.writeInfoLine(
+    `API key: ${maskRawApiKey(resolvedKey.rawKey)} (from ${resolvedKey.source})`
+  );
+  return 0;
+}
+async function runWhoamiCommand(runtime) {
+  const output = createCliOutput(runtime.writeLine, resolveUseColor(runtime.env));
+  const environment = parseCliEnvironment(runtime.env);
+  const configFileResult = readCliConfigFile(runtime.homeDir);
+  if (configFileResult.warning !== null) {
+    output.writeInfoLine(configFileResult.warning);
+  }
+  const resolvedKey = resolveWhoamiKey(
+    environment.ASSEMBLE_API_KEY,
+    configFileResult.config.apiKey,
+    runtime.homeDir
+  );
+  if (resolvedKey === null) {
+    output.writeFailureLine(
+      "You are not logged in. Run `asm login --key <api-key>` to authenticate."
+    );
+    return 1;
+  }
+  const baseUrl = environment.ASSEMBLE_BASE_URL ?? configFileResult.config.baseUrl ?? defaultCliBaseUrl;
+  return await reportWhoamiIdentity(resolvedKey, baseUrl, runtime, output);
+}
+
+// src/cli.ts
+var usageLines = [
+  "asm \u2014 the Assemble CLI",
+  "",
+  "Usage:",
+  "  asm <command> [options]",
+  "",
+  "Commands:",
+  "  login     Authenticate with an Assemble API key",
+  "            (--key <api-key>, --base-url <url>, or pipe the key on stdin)",
+  "  logout    Remove saved credentials from ~/.assemble/config.json",
+  "  whoami    Show the workspace and masked key for the active credentials",
+  "  run       Execute a workflow file with live trace output",
+  "            (asm run <file> [--input <json>] [--input-file <path>]",
+  "             [--workflow <exportName>] [--trace-dir <dir>] [--no-upload])",
+  "  dev       Watch a workflow file, re-run it on change, and stream traces",
+  "            (asm dev <file> [--input <json>] [--input-file <path>]",
+  "             [--workflow <exportName>] [--trace-dir <dir>] [--watch-dir <dir>]",
+  "             [--no-upload])",
+  "  init      Scaffold a starter Assemble project into [dir]",
+  "            (asm init [dir], --force to write into a non-empty directory)",
+  "  eval      Run an eval suite file and print the metric table",
+  "            (asm eval <suite-file> [--suite <exportName>] [--results-dir <dir>]",
+  "             [--no-upload])",
+  "  replay    Re-run a recorded run and compare it to the original",
+  "            (asm replay [runId] --workflow-file <file> [--workflow <exportName>]",
+  "             [--from-step <n>] [--no-mock-tools] [--trace-dir <dir>] [--state-dir <dir>]",
+  "             --workflow-file is required; runId defaults to .assemble/last-run)",
+  "",
+  "Options:",
+  "  --help    Show this usage information"
+];
+function printCliUsage(runtime) {
+  for (const usageLine of usageLines) {
+    runtime.writeLine(usageLine);
+  }
+}
+async function runCli(argv, runtime) {
+  const commandName = argv[0];
+  const commandArgs = argv.slice(1);
+  if (commandName === void 0 || commandName === "--help" || commandName === "-h" || commandName === "help") {
+    printCliUsage(runtime);
+    return 0;
+  }
+  if (commandName === "login") {
+    return await runLoginCommand(commandArgs, runtime);
+  }
+  if (commandName === "logout") {
+    return runLogoutCommand(runtime);
+  }
+  if (commandName === "whoami") {
+    return await runWhoamiCommand(runtime);
+  }
+  if (commandName === "run") {
+    return await runRunCommand(commandArgs, runtime);
+  }
+  if (commandName === "dev") {
+    return await runDevCommand(commandArgs, runtime);
+  }
+  if (commandName === "init") {
+    return runInitCommand(commandArgs, runtime);
+  }
+  if (commandName === "eval") {
+    return await runEvalCommand(commandArgs, runtime);
+  }
+  if (commandName === "replay") {
+    return await runReplayCommand(commandArgs, runtime);
+  }
+  runtime.writeLine(`Unknown command: ${commandName}`);
+  runtime.writeLine("");
+  printCliUsage(runtime);
+  return 1;
+}
+
+// src/cli-runtime.ts
+import { homedir } from "os";
+import { createInterface } from "readline";
+async function readSingleLineFromStdin() {
+  const readlineInterface = createInterface({ input: process.stdin });
+  try {
+    for await (const line of readlineInterface) {
+      return line.trim();
+    }
+    return "";
+  } finally {
+    readlineInterface.close();
+  }
+}
+function createDefaultCliRuntime() {
+  return {
+    env: process.env,
+    homeDir: homedir(),
+    fetchImplementation: fetch,
+    writeLine: (line) => {
+      process.stdout.write(`${line}
+`);
+    },
+    readLine: process.stdin.isTTY === true ? void 0 : readSingleLineFromStdin,
+    now: () => /* @__PURE__ */ new Date(),
+    sleep: async (milliseconds) => {
+      await new Promise((resolveSleep) => {
+        setTimeout(resolveSleep, milliseconds);
+      });
+    }
+  };
+}
+
+// src/index.ts
+function writeProcessErrorLine(line) {
+  process.stderr.write(`${line}
+`);
+}
+async function runAsmCliProcess() {
+  try {
+    return await runCli(process.argv.slice(2), createDefaultCliRuntime());
+  } catch (caughtError) {
+    if (caughtError instanceof AppError) {
+      writeProcessErrorLine(`\u2717 ${caughtError.message}`);
+      return 1;
+    }
+    throw caughtError;
+  }
+}
+process.exitCode = await runAsmCliProcess();