@aexhq/cli 0.25.1 → 0.26.0

package/scripts/finalize-bundle.mjs

@@ -1,72 +0,0 @@
-// Finalize the CLI bundle:
-//   1. esbuild bundles dist/cli.js (the tsc-built entrypoint) and its
-//      workspace deps into a single ESM file.
-//   2. Prepend the Node shebang.
-//   3. Write to dist/cli.mjs so the `bin` field works on Unix and the
-//      ESM extension is unambiguous.
-//   4. Compute a sha256 digest and write a sibling cli.mjs.sha256
-//      used by release/package integrity checks.
-//
-// The published SDK copies ONLY dist/cli.mjs as the user-facing `aex`
-// bin. Managed run internals use the separate runtime bridge artifact, so
-// this host-install bundle stays independent of platform injection.
-import { build } from "esbuild";
-import { readFile, writeFile, chmod } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const here = dirname(fileURLToPath(import.meta.url));
-const pkgRoot = resolve(here, "..");
-const distDir = resolve(pkgRoot, "dist");
-const inputPath = resolve(distDir, "cli.js");
-const outputPath = resolve(distDir, "cli.mjs");
-const digestPath = resolve(distDir, "cli.mjs.sha256");
-
-const result = await build({
-  entryPoints: [inputPath],
-  bundle: true,
-  platform: "node",
-  format: "esm",
-  target: "node20",
-  write: false,
-  // Mark node built-ins external; we only bundle our own + workspace deps.
-  external: [
-    "node:*",
-    "fs",
-    "fs/promises",
-    "path",
-    "url",
-    "crypto",
-    "buffer",
-    "stream",
-    "util"
-  ],
-  // The bundle is loaded as ESM at runtime; suppress sourcemaps so the
-  // shipped artifact stays minimal and free of file-path leakage.
-  sourcemap: false,
-  legalComments: "none",
-  minify: false
-});
-
-if (result.outputFiles.length !== 1) {
-  throw new Error(`unexpected esbuild output count: ${result.outputFiles.length}`);
-}
-const bundled = result.outputFiles[0].text;
-
-const shebang = "#!/usr/bin/env node\n";
-const final = shebang + bundled;
-await writeFile(outputPath, final, "utf8");
-
-try {
-  // mode 0755; harmless on Windows.
-  await chmod(outputPath, 0o755);
-} catch {
-  /* ignore */
-}
-
-const digest = createHash("sha256").update(final).digest("hex");
-await writeFile(digestPath, `${digest}  cli.mjs\n`, "utf8");
-
-console.log(`built ${outputPath} (${final.length} bytes)`);
-console.log(`sha256 ${digest}`);

package/src/cli.ts

@@ -1,51 +0,0 @@
-/**
- * aex CLI entrypoint. Wires the real IO surface and calls
- * {@link runCli}. The shipped bundle has a `#!/usr/bin/env node` line
- * prepended by `scripts/finalize-bundle.mjs`.
- *
- * NO `process.env.AEX_*` reads here — paths to the manifest and
- * token file are fixed constants in `internal.ts`. The mechanical
- * enforcement test in Phase 9 greps the built artifact to confirm.
- */
-import { readFile, writeFile, readdir, stat } from "node:fs/promises";
-import { resolve as resolvePath } from "node:path";
-import { runCli } from "./run.js";
-import type { CliIO, OutputsSyncFileEntry } from "./internal.js";
-
-async function walkDirectory(root: string): Promise<readonly OutputsSyncFileEntry[] | null> {
-  try {
-    const rootStat = await stat(root);
-    if (!rootStat.isDirectory()) return null;
-  } catch {
-    return null;
-  }
-  const out: OutputsSyncFileEntry[] = [];
-  async function visit(dir: string): Promise<void> {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = resolvePath(dir, entry.name);
-      if (entry.isDirectory()) {
-        await visit(full);
-      } else if (entry.isFile()) {
-        const s = await stat(full);
-        out.push({ path: full, sizeBytes: s.size });
-      }
-    }
-  }
-  await visit(root);
-  return out;
-}
-
-const io: CliIO = {
-  readFile: (path) => readFile(path, "utf8"),
-  writeFile: (path, data) => writeFile(path, data),
-  fetchImpl: fetch,
-  stdout: (chunk) => process.stdout.write(chunk),
-  stderr: (chunk) => process.stderr.write(chunk),
-  exit: (code) => process.exit(code),
-  argv: process.argv,
-  cwd: () => process.cwd(),
-  walkDirectory
-};
-
-await runCli(io);

package/src/host/cancel.ts

@@ -1,39 +0,0 @@
-/**
- * `aex cancel <run-id>` — POST /api/runs/{id}/cancel.
- */
-import { operations } from "@aexhq/contracts";
-import type { CliIO } from "../internal.js";
-import {
-  type CliExitCode,
-  SUCCESS,
-  USAGE_ERR,
-  emitJsonError,
-  makeHttpClient,
-  parseCommonHostFlags,
-  refuseInsideManagedRun
-} from "./common.js";
-
-export async function runCancelCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "cancel")) return USAGE_ERR;
-
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) {
-    io.stderr(`${common.reason}\n`);
-    return USAGE_ERR;
-  }
-  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
-  if (positional.length !== 1) {
-    io.stderr("usage: aex cancel <run-id> [common flags]\n");
-    return USAGE_ERR;
-  }
-  const runId = positional[0]!;
-
-  const http = makeHttpClient(io, common.flags);
-  try {
-    await operations.cancelRun(http, runId);
-    io.stdout(JSON.stringify({ runId, status: "cancel_requested" }) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "cancel_failed", (err as Error).message ?? "cancel failed", { runId });
-  }
-}

package/src/host/common.ts

@@ -1,329 +0,0 @@
-/**
- * Shared helpers for every host-side aex subcommand. Common flag
- * parsing, HttpClient construction, manifest detection so we can refuse
- * to run host commands inside a managed run container, and exit codes
- * shared with the in-container proxy command.
- */
-import { AEX_DEFAULT_BASE_URL, HttpClient, type FetchLike } from "@aexhq/contracts";
-import { AEX_INDEX_PATH, type CliIO } from "../internal.js";
-
-export interface CliExitCode {
-  readonly code: number;
-}
-
-export const SUCCESS: CliExitCode = { code: 0 };
-export const USAGE_ERR: CliExitCode = { code: 2 };
-export const RUNTIME_ERR: CliExitCode = { code: 1 };
-/**
- * Distinct exit code for "the wait/follow deadline elapsed before the
- * run reached a terminal status". Separated from RUNTIME_ERR (1) so a
- * script can tell a timeout apart from a run that finished non-succeeded
- * (which is also RUNTIME_ERR). Mirrors the SDK's `waitForRun` throwing a
- * dedicated timeout error.
- */
-export const TIMEOUT_ERR: CliExitCode = { code: 3 };
-
-export interface CommonHostFlags {
-  readonly apiToken: string;
-  readonly aexUrl: string;
-  /** `--debug`: print a redacted per-request trace to stderr. Uploads nothing. */
-  readonly debug: boolean;
-}
-
-export type ParseCommonResult =
-  | { readonly ok: true; readonly flags: CommonHostFlags; readonly rest: readonly string[] }
-  | { readonly ok: false; readonly reason: string };
-
-/**
- * Parse and remove the common flags every host-side subcommand needs,
- * leaving the rest for the caller.
- *
- * The CLI is `flags_only` — no `AEX_*` env reads. `--api-token` is
- * required; `--aex-url` defaults to `AEX_DEFAULT_BASE_URL`
- * (`https://api.aex.dev`) so SaaS users never need to supply it.
- *
- * There is no `--workspace` flag: workspace identity is derived
- * server-side from the API token.
- */
-export function parseCommonHostFlags(argv: readonly string[]): ParseCommonResult {
-  let apiToken: string | null = null;
-  let aexUrl: string | null = null;
-  let debug = false;
-  const rest: string[] = [];
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i]!;
-    if (arg === "--debug") {
-      debug = true;
-      continue;
-    }
-    if (arg === "--api-token") {
-      const v = argv[++i];
-      if (v === undefined) return { ok: false, reason: "--api-token requires a value" };
-      apiToken = v;
-      continue;
-    }
-    if (arg === "--aex-url") {
-      const v = argv[++i];
-      if (v === undefined) return { ok: false, reason: "--aex-url requires a value" };
-      aexUrl = v;
-      continue;
-    }
-    if (arg === "--workspace" || arg === "--workspace-id") {
-      // Removed in favor of server-side derivation from the API token.
-      // Bail out early with an actionable message instead of letting
-      // the flag fall through and produce a confusing positional-arg
-      // count error from the calling subcommand.
-      return {
-        ok: false,
-        reason: `unknown flag ${arg}: workspace is derived from --api-token on the server; drop this flag`
-      };
-    }
-    rest.push(arg);
-  }
-
-  if (!apiToken) return { ok: false, reason: "--api-token is required" };
-  return {
-    ok: true,
-    flags: { apiToken, aexUrl: aexUrl ?? AEX_DEFAULT_BASE_URL, debug },
-    rest
-  };
-}
-
-export function makeHttpClient(io: CliIO, flags: CommonHostFlags): HttpClient {
-  return new HttpClient({
-    baseUrl: flags.aexUrl,
-    apiToken: flags.apiToken,
-    fetch: io.fetchImpl as FetchLike,
-    // `--debug`: route the transport's redacted per-request traces to stderr.
-    ...(flags.debug ? { debug: (line: string) => io.stderr(`${line}\n`) } : {})
-  });
-}
-
-/**
- * Host subcommands refuse to run inside a managed run container. The
- * heuristic: presence of the per-run manifest at AEX_INDEX_PATH
- * (`/mnt/session/uploads/aex/index.json`) means we're inside a
- * run and should expose `proxy`, not the platform-management verbs.
- *
- * Fails *closed* on read errors that are not "file not found": if the
- * manifest exists but is unreadable for any other reason (permissions,
- * IO error, etc.) we refuse to run the host verb rather than risk
- * leaking workspace-management calls into a sandboxed container.
- */
-export async function refuseInsideManagedRun(io: CliIO, verb: string): Promise<boolean> {
-  try {
-    await io.readFile(AEX_INDEX_PATH);
-    io.stderr(
-      `\`aex ${verb}\` is a host command and cannot run inside a managed run container.\n` +
-      "Use `aex proxy ...` to call your declared upstream endpoints from inside the run.\n"
-    );
-    return true;
-  } catch (err) {
-    const code = (err as NodeJS.ErrnoException | undefined)?.code;
-    if (code === "ENOENT" || code === "ENOTDIR") {
-      // Manifest definitively absent; we are on a host. Allow the verb.
-      return false;
-    }
-    io.stderr(
-      `\`aex ${verb}\` could not determine whether it is running inside a managed run ` +
-      `container (error reading ${AEX_INDEX_PATH}: ${(err as Error).message ?? "unknown"}). ` +
-      `Refusing to proceed.\n`
-    );
-    return true;
-  }
-}
-
-/**
- * Emit a JSON error body and return RUNTIME_ERR. The shape mirrors the
- * in-container proxy error envelope so a script-shaped consumer can
- * parse both surfaces the same way.
- */
-export function emitJsonError(io: CliIO, code: string, message: string, extra: Record<string, unknown> = {}): CliExitCode {
-  io.stderr(JSON.stringify({ error: code, message, ...extra }) + "\n");
-  return RUNTIME_ERR;
-}
-
-/**
- * Repeatable `--var key=value` / `--mcp-secret name=value` /
- * `--proxy-auth name=value`-style flag parser. Returns the values in
- * insertion order (last-wins on duplicate keys).
- */
-export function collectRepeatedKv(rest: readonly string[], flag: string): {
-  readonly entries: Record<string, string>;
-  readonly remaining: readonly string[];
-  readonly error: string | null;
-} {
-  const entries: Record<string, string> = {};
-  const remaining: string[] = [];
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i]!;
-    if (arg === flag) {
-      const kv = rest[++i];
-      if (kv === undefined) {
-        return { entries, remaining, error: `${flag} requires a KEY=VALUE argument` };
-      }
-      const eq = kv.indexOf("=");
-      if (eq <= 0) {
-        return { entries, remaining, error: `${flag} must be in the form KEY=VALUE (got: ${kv})` };
-      }
-      entries[kv.slice(0, eq)] = kv.slice(eq + 1);
-      continue;
-    }
-    remaining.push(arg);
-  }
-  return { entries, remaining, error: null };
-}
-
-/**
- * Repeatable `--flag <value>` collector. Each occurrence consumes one
- * argv slot. Returns the collected values in insertion order alongside
- * the remaining argv.
- */
-export function collectRepeated(rest: readonly string[], flag: string): {
-  readonly values: readonly string[];
-  readonly remaining: readonly string[];
-  readonly error: string | null;
-} {
-  const values: string[] = [];
-  const remaining: string[] = [];
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i]!;
-    if (arg === flag) {
-      const v = rest[++i];
-      if (v === undefined) {
-        return { values, remaining, error: `${flag} requires a value` };
-      }
-      values.push(v);
-      continue;
-    }
-    remaining.push(arg);
-  }
-  return { values, remaining, error: null };
-}
-
-/**
- * Repeatable `--flag KEY=VALUE` collector that PRESERVES every
- * occurrence (no key-collision collapse). Use this when the same key
- * may legitimately appear multiple times — for example,
- * `--mcp-auth github=Authorization:Bearer t --mcp-auth github=X-Api-Key:k`
- * needs to register both headers, not just the last one.
- *
- * Returns `[key, value]` pairs in argv order alongside the remaining
- * argv with the consumed flags removed.
- */
-export function collectRepeatedKvList(rest: readonly string[], flag: string): {
-  readonly entries: ReadonlyArray<readonly [string, string]>;
-  readonly remaining: readonly string[];
-  readonly error: string | null;
-} {
-  const entries: Array<readonly [string, string]> = [];
-  const remaining: string[] = [];
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i]!;
-    if (arg === flag) {
-      const kv = rest[++i];
-      if (kv === undefined) {
-        return { entries, remaining, error: `${flag} requires a KEY=VALUE argument` };
-      }
-      const eq = kv.indexOf("=");
-      if (eq <= 0) {
-        return { entries, remaining, error: `${flag} must be in the form KEY=VALUE (got: ${kv})` };
-      }
-      entries.push([kv.slice(0, eq), kv.slice(eq + 1)] as const);
-      continue;
-    }
-    remaining.push(arg);
-  }
-  return { entries, remaining, error: null };
-}
-
-export function takeFlagValue(
-  rest: readonly string[],
-  flag: string
-): { value: string | null; remaining: readonly string[]; error: string | null } {
-  let value: string | null = null;
-  const remaining: string[] = [];
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i]!;
-    if (arg === flag) {
-      const v = rest[++i];
-      if (v === undefined) {
-        return { value, remaining, error: `${flag} requires a value` };
-      }
-      value = v;
-      continue;
-    }
-    remaining.push(arg);
-  }
-  return { value, remaining, error: null };
-}
-
-/**
- * Parse a human-friendly duration into milliseconds. Accepts a bare
- * integer (interpreted as milliseconds) or `<number><unit>` where unit
- * is one of `ms`, `s`, `m`, `h` — e.g. `500ms`, `30s`, `8m`, `1h`.
- *
- * Returns the millisecond count, or an `error` string describing the
- * malformed input (the value is never silently coerced to 0). Rejects
- * negatives and non-finite values so a `--timeout` can never disable the
- * deadline by accident.
- */
-export function parseDuration(input: string): { readonly ms: number | null; readonly error: string | null } {
-  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(input.trim());
-  if (!match) {
-    return { ms: null, error: `invalid duration "${input}" (expected e.g. 500ms, 30s, 8m, 1h, or a bare ms integer)` };
-  }
-  const value = Number(match[1]);
-  if (!Number.isFinite(value) || value < 0) {
-    return { ms: null, error: `invalid duration "${input}" (must be a non-negative number)` };
-  }
-  const unit = match[2] ?? "ms";
-  const factor = unit === "h" ? 3_600_000 : unit === "m" ? 60_000 : unit === "s" ? 1_000 : 1;
-  return { ms: Math.round(value * factor), error: null };
-}
-
-export function takeBooleanFlag(rest: readonly string[], flag: string): {
-  readonly present: boolean;
-  readonly remaining: readonly string[];
-} {
-  const remaining: string[] = [];
-  let present = false;
-  for (const arg of rest) {
-    if (arg === flag) {
-      present = true;
-      continue;
-    }
-    remaining.push(arg);
-  }
-  return { present, remaining };
-}
-
-/**
- * Take an option flag in either `--flag value` or `--flag=value` form.
- * Returns the trailing value (or undefined when the flag is absent)
- * plus the remaining args. Unlike `takeFlagValue`, this is permissive
- * about the `=` form which CLI users frequently expect.
- */
-export function takeOptionFlag(
-  rest: readonly string[],
-  flag: string
-): { readonly value: string | undefined; readonly remaining: readonly string[] } {
-  const remaining: string[] = [];
-  let value: string | undefined;
-  const prefix = `${flag}=`;
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i]!;
-    if (arg === flag) {
-      const next = rest[++i];
-      if (next !== undefined) value = next;
-      continue;
-    }
-    if (arg.startsWith(prefix)) {
-      value = arg.slice(prefix.length);
-      continue;
-    }
-    remaining.push(arg);
-  }
-  return { value, remaining };
-}

package/src/host/delete-asset.ts

@@ -1,43 +0,0 @@
-/**
- * `aex delete-asset <assetId|hash>` — DELETE /assets/{assetId}.
- *
- * Removes a workspace asset blob from the shared content-addressed store.
- * Runs that already snapshotted the asset into their own prefix are
- * unaffected. Accepts `sha256:<hex>` or a bare 64-hex digest.
- */
-import { operations } from "@aexhq/contracts";
-import type { CliIO } from "../internal.js";
-import {
-  type CliExitCode,
-  SUCCESS,
-  USAGE_ERR,
-  emitJsonError,
-  makeHttpClient,
-  parseCommonHostFlags,
-  refuseInsideManagedRun
-} from "./common.js";
-
-export async function runDeleteAssetCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "delete-asset")) return USAGE_ERR;
-
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) {
-    io.stderr(`${common.reason}\n`);
-    return USAGE_ERR;
-  }
-  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
-  if (positional.length !== 1) {
-    io.stderr("usage: aex delete-asset <hash> [common flags]\n");
-    return USAGE_ERR;
-  }
-  const hash = positional[0]!;
-
-  const http = makeHttpClient(io, common.flags);
-  try {
-    await operations.deleteWorkspaceAsset(http, hash);
-    io.stdout(JSON.stringify({ hash, deleted: true }) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "delete_asset_failed", (err as Error).message ?? "delete-asset failed", { hash });
-  }
-}

package/src/host/delete.ts

@@ -1,39 +0,0 @@
-/**
- * `aex delete <run-id>` — DELETE /api/runs/{id}.
- */
-import { operations } from "@aexhq/contracts";
-import type { CliIO } from "../internal.js";
-import {
-  type CliExitCode,
-  SUCCESS,
-  USAGE_ERR,
-  emitJsonError,
-  makeHttpClient,
-  parseCommonHostFlags,
-  refuseInsideManagedRun
-} from "./common.js";
-
-export async function runDeleteCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "delete")) return USAGE_ERR;
-
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) {
-    io.stderr(`${common.reason}\n`);
-    return USAGE_ERR;
-  }
-  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
-  if (positional.length !== 1) {
-    io.stderr("usage: aex delete <run-id> [common flags]\n");
-    return USAGE_ERR;
-  }
-  const runId = positional[0]!;
-
-  const http = makeHttpClient(io, common.flags);
-  try {
-    await operations.deleteRun(http, runId);
-    io.stdout(JSON.stringify({ runId, deleted: true }) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "delete_failed", (err as Error).message ?? "delete failed", { runId });
-  }
-}

package/src/host/download.ts

@@ -1,97 +0,0 @@
-/**
- * `aex download <run-id> [--only namespace] [--out path]` — download
- * a run's content as a zip, assembled client-side from the public read
- * endpoints (no per-output id required).
- *
- * Without `--only`, downloads everything public — organised into
- * `metadata/run.json`, typed `events/events.jsonl`, `outputs/<rel>`
- * (deliverables), plus `manifest.json`.
- *
- * `--only outputs|events|metadata` downloads just that one
- * namespace (files at the zip root).
- *
- * `--out` resolves relative to the host CWD; if omitted the file is
- * written to `aex-run-<run-id>[-<namespace>].zip` in the current
- * directory.
- */
-import { resolve as resolvePath } from "node:path";
-import { operations } from "@aexhq/contracts";
-import type { CliIO } from "../internal.js";
-import {
-  type CliExitCode,
-  SUCCESS,
-  USAGE_ERR,
-  emitJsonError,
-  makeHttpClient,
-  parseCommonHostFlags,
-  refuseInsideManagedRun,
-  takeFlagValue
-} from "./common.js";
-
-type Namespace = "outputs" | "events" | "metadata";
-
-const NAMESPACE_DOWNLOADERS = {
-  outputs: operations.downloadOutputs,
-  events: operations.downloadEvents,
-  metadata: operations.downloadMetadata
-} satisfies Record<Namespace, typeof operations.download>;
-
-export async function runDownloadCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "download")) return USAGE_ERR;
-
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) {
-    io.stderr(`${common.reason}\n`);
-    return USAGE_ERR;
-  }
-  const outFlag = takeFlagValue(common.rest, "--out");
-  if (outFlag.error) {
-    io.stderr(`${outFlag.error}\n`);
-    return USAGE_ERR;
-  }
-  const onlyFlag = takeFlagValue(outFlag.remaining, "--only");
-  if (onlyFlag.error) {
-    io.stderr(`${onlyFlag.error}\n`);
-    return USAGE_ERR;
-  }
-  if (onlyFlag.value !== null && !(onlyFlag.value in NAMESPACE_DOWNLOADERS)) {
-    io.stderr(`--only must be one of: ${Object.keys(NAMESPACE_DOWNLOADERS).join(", ")}\n`);
-    return USAGE_ERR;
-  }
-  const namespace = onlyFlag.value as Namespace | null;
-
-  const positional = onlyFlag.remaining.filter((arg) => !arg.startsWith("--"));
-  if (positional.length !== 1) {
-    io.stderr("usage: aex download <run-id> [--only outputs|events|metadata] [--out path] [common flags]\n");
-    return USAGE_ERR;
-  }
-  const runId = positional[0]!;
-
-  const http = makeHttpClient(io, common.flags);
-  const downloader = namespace ? NAMESPACE_DOWNLOADERS[namespace] : operations.download;
-
-  let bytes: Uint8Array;
-  try {
-    bytes = await downloader(http, runId);
-  } catch (err) {
-    return emitJsonError(io, "download_failed", (err as Error).message ?? "download failed", { runId });
-  }
-
-  const destination = resolveDestination(io, outFlag.value, runId, namespace);
-  try {
-    await io.writeFile(destination, bytes);
-  } catch (err) {
-    return emitJsonError(io, "write_failed", `failed to write archive: ${(err as Error).message}`, { destination });
-  }
-
-  io.stdout(JSON.stringify({ runId, namespace: namespace ?? "all", path: destination, bytes: bytes.byteLength }) + "\n");
-  return SUCCESS;
-}
-
-function resolveDestination(io: CliIO, out: string | null, runId: string, namespace: Namespace | null): string {
-  if (out) {
-    return resolvePath(io.cwd(), out);
-  }
-  const suffix = namespace ? `-${namespace}` : "";
-  return resolvePath(io.cwd(), `aex-run-${runId}${suffix}.zip`);
-}