@aexhq/cli 0.25.2 → 0.26.1

package/src/host/skills-cmd.ts

@@ -1,317 +0,0 @@
-/**
- * `aex skills <verb>` — workspace skill bundle management. Mirrors
- * the SDK's `client.skills` namespace 1:1 so SDK and CLI never drift.
- *
- * Verbs:
- *   aex skills upload --from-path <dir> --name <n>
- *   aex skills upload --file <path> [--file <path> ...] --name <n>
- *   aex skills list
- *   aex skills get <skill-id>
- *   aex skills delete <skill-id>
- *
- * `--file` stores each path verbatim (relative to cwd) under its
- * basename inside the bundle. For directory uploads, use `--from-path`.
- */
-import { readFile, readdir, stat } from "node:fs/promises";
-import { basename, join, posix, relative, resolve as resolvePath, sep } from "node:path";
-import { zipSync, type Zippable } from "fflate";
-import {
-  SKILL_BUNDLE_LIMITS,
-  operations,
-  validateSkillBundleEntry
-} from "@aexhq/contracts";
-import type { CliIO } from "../internal.js";
-import {
-  type CliExitCode,
-  RUNTIME_ERR,
-  SUCCESS,
-  USAGE_ERR,
-  collectRepeated,
-  emitJsonError,
-  makeHttpClient,
-  parseCommonHostFlags,
-  refuseInsideManagedRun,
-  takeFlagValue
-} from "./common.js";
-
-export async function runSkillsCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "skills")) return USAGE_ERR;
-  const [verb, ...rest] = argv;
-  if (!verb) {
-    io.stderr("usage: aex skills <upload|list|get|delete> [flags]\n");
-    return USAGE_ERR;
-  }
-  switch (verb) {
-    case "upload": return runSkillsUpload(io, rest);
-    case "list":   return runSkillsList(io, rest);
-    case "get":    return runSkillsGet(io, rest);
-    case "delete": return runSkillsDelete(io, rest);
-    default:
-      io.stderr(`unknown skills verb: ${verb}\n`);
-      return USAGE_ERR;
-  }
-}
-
-async function runSkillsUpload(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) { io.stderr(`${common.reason}\n`); return USAGE_ERR; }
-  let rest = common.rest;
-
-  const nameFlag = takeFlagValue(rest, "--name");
-  if (nameFlag.error) { io.stderr(`${nameFlag.error}\n`); return USAGE_ERR; }
-  rest = nameFlag.remaining;
-  if (!nameFlag.value) {
-    io.stderr("--name is required\n");
-    return USAGE_ERR;
-  }
-
-  const fromPath = takeFlagValue(rest, "--from-path");
-  if (fromPath.error) { io.stderr(`${fromPath.error}\n`); return USAGE_ERR; }
-  rest = fromPath.remaining;
-
-  const fileFlags = collectRepeated(rest, "--file");
-  if (fileFlags.error) { io.stderr(`${fileFlags.error}\n`); return USAGE_ERR; }
-  rest = fileFlags.remaining;
-
-  const unknown = rest.filter((a) => a.startsWith("--"));
-  if (unknown.length > 0) {
-    io.stderr(`unknown flag: ${unknown[0]}\n`);
-    return USAGE_ERR;
-  }
-
-  if ((fromPath.value && fileFlags.values.length > 0) || (!fromPath.value && fileFlags.values.length === 0)) {
-    io.stderr("aex skills upload requires exactly one of: --from-path <dir> | --file <path> [--file ...]\n");
-    return USAGE_ERR;
-  }
-
-  let built: SkillBundleBuild;
-  try {
-    if (fromPath.value) {
-      built = await zipDirectory(resolvePath(io.cwd(), fromPath.value));
-    } else {
-      built = await zipFiles(io.cwd(), fileFlags.values);
-    }
-  } catch (err) {
-    io.stderr(`failed to build skill bundle: ${(err as Error).message}\n`);
-    return USAGE_ERR;
-  }
-
-  const contentHash = `sha256:${await sha256Hex(built.zip)}`;
-  const http = makeHttpClient(io, common.flags);
-  try {
-    // Direct-to-storage upload (bytes bypass the hosted API); falls back to the
-    // buffered multipart path when object-store presign creds are unconfigured.
-    const skill = await operations.createSkillBundleDirect(http, io.fetchImpl as DirectPutFetch, {
-      name: nameFlag.value,
-      body: built.zip,
-      contentHash,
-      manifest: built.manifest,
-      contentType: "application/zip"
-    });
-    io.stdout(JSON.stringify(skill) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "skill_upload_failed", (err as Error).message ?? "upload failed");
-  }
-}
-
-/** Raw fetch shape the direct-to-storage PUT needs (a structural subset of fetch). */
-type DirectPutFetch = (input: string, init?: RequestInit) => Promise<{ ok: boolean; status: number; text(): Promise<string> }>;
-
-/** A built skill bundle: the zip bytes plus the client-computed manifest. */
-interface SkillBundleBuild {
-  readonly zip: Uint8Array;
-  readonly manifest: ReadonlyArray<{ readonly path: string; readonly size: number }>;
-}
-
-async function sha256Hex(bytes: Uint8Array): Promise<string> {
-  const subtle = (globalThis as { crypto?: { subtle?: SubtleCrypto } }).crypto?.subtle;
-  if (!subtle) throw new Error("aex skills upload: globalThis.crypto.subtle is required (Node 18+)");
-  const copy = new Uint8Array(bytes.byteLength);
-  copy.set(bytes);
-  const digest = await subtle.digest("SHA-256", copy.buffer);
-  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
-}
-
-async function runSkillsList(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) { io.stderr(`${common.reason}\n`); return USAGE_ERR; }
-  const positional = common.rest.filter((a) => !a.startsWith("--"));
-  const unknown = common.rest.filter((a) => a.startsWith("--"));
-  if (unknown.length > 0) {
-    io.stderr(`unknown flag: ${unknown[0]}\n`);
-    return USAGE_ERR;
-  }
-  if (positional.length > 0) {
-    io.stderr(`aex skills list takes no positional arguments\n`);
-    return USAGE_ERR;
-  }
-  const http = makeHttpClient(io, common.flags);
-  try {
-    const skills = await operations.listSkills(http);
-    for (const s of skills) io.stdout(JSON.stringify(s) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "skills_list_failed", (err as Error).message ?? "list failed");
-  }
-}
-
-async function runSkillsGet(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) { io.stderr(`${common.reason}\n`); return USAGE_ERR; }
-  const positional = common.rest.filter((a) => !a.startsWith("--"));
-  const unknown = common.rest.filter((a) => a.startsWith("--"));
-  if (unknown.length > 0) {
-    io.stderr(`unknown flag: ${unknown[0]}\n`);
-    return USAGE_ERR;
-  }
-  if (positional.length !== 1) {
-    io.stderr("usage: aex skills get <skill-id>\n");
-    return USAGE_ERR;
-  }
-  const skillId = positional[0]!;
-  const http = makeHttpClient(io, common.flags);
-  try {
-    const skill = await operations.getSkill(http, skillId);
-    io.stdout(JSON.stringify(skill) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "skill_get_failed", (err as Error).message ?? "get failed");
-  }
-}
-
-async function runSkillsDelete(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) { io.stderr(`${common.reason}\n`); return USAGE_ERR; }
-  const positional = common.rest.filter((a) => !a.startsWith("--"));
-  const unknown = common.rest.filter((a) => a.startsWith("--"));
-  if (unknown.length > 0) {
-    io.stderr(`unknown flag: ${unknown[0]}\n`);
-    return USAGE_ERR;
-  }
-  if (positional.length !== 1) {
-    io.stderr("usage: aex skills delete <skill-id>\n");
-    return USAGE_ERR;
-  }
-  const skillId = positional[0]!;
-  const http = makeHttpClient(io, common.flags);
-  try {
-    await operations.deleteSkill(http, skillId);
-    io.stdout(JSON.stringify({ skillId, deleted: true }) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "skill_delete_failed", (err as Error).message ?? "delete failed");
-  }
-}
-
-/* ---------- bundle building ---------- */
-
-/** Stable mtime for every zip entry — keeps the bundle byte-deterministic
- * across machines and re-runs so SDK/CLI hashes match the BFF's
- * canonical hash. ZIP's legacy DOS date encoding requires year >= 1980,
- * so we anchor to 1980-01-01 UTC rather than the unix epoch. */
-const ZIP_EPOCH = new Date(Date.UTC(1980, 0, 1));
-
-function zipEntryFor(bytes: Uint8Array): [Uint8Array, { mtime: Date }] {
-  return [bytes, { mtime: ZIP_EPOCH }];
-}
-
-async function zipDirectory(rootDir: string): Promise<SkillBundleBuild> {
-  const rootStat = await stat(rootDir);
-  if (!rootStat.isDirectory()) {
-    throw new Error(`${rootDir} is not a directory`);
-  }
-  const collected = new Map<string, Uint8Array>();
-  let totalDecompressed = 0;
-  let hasSkillMd = false;
-  await walk(rootDir, rootDir, async (relPathPosix, bytes) => {
-    const entry = validateSkillBundleEntry({ path: relPathPosix, size: bytes.byteLength });
-    if (entry.path === "SKILL.md") hasSkillMd = true;
-    totalDecompressed += bytes.byteLength;
-    if (totalDecompressed > SKILL_BUNDLE_LIMITS.maxDecompressedBytes) {
-      throw new Error(`skill bundle exceeds decompressed cap of ${SKILL_BUNDLE_LIMITS.maxDecompressedBytes} bytes`);
-    }
-    if (collected.has(entry.path)) {
-      throw new Error(`skill bundle contains duplicate path: ${entry.path}`);
-    }
-    if (collected.size >= SKILL_BUNDLE_LIMITS.maxFiles) {
-      throw new Error(`skill bundle exceeds ${SKILL_BUNDLE_LIMITS.maxFiles} file limit`);
-    }
-    collected.set(entry.path, bytes);
-  });
-  if (collected.size === 0) {
-    throw new Error(`${rootDir} contains no regular files`);
-  }
-  if (!hasSkillMd) {
-    throw new Error(
-      'skill bundle must contain a "SKILL.md" file at the root. ' +
-        "For AGENTS.md / generic files use the corresponding `aex agentsmd` / " +
-        "`aex files` commands instead."
-    );
-  }
-  // Sort entries for deterministic ordering (zipSync preserves insertion order).
-  const sorted = [...collected.entries()].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-  const zippable: Zippable = {};
-  for (const [path, bytes] of sorted) zippable[path] = zipEntryFor(bytes);
-  const out = zipSync(zippable, { level: 6 });
-  if (out.byteLength > SKILL_BUNDLE_LIMITS.maxCompressedBytes) {
-    throw new Error(`skill bundle exceeds compressed cap of ${SKILL_BUNDLE_LIMITS.maxCompressedBytes} bytes (got ${out.byteLength})`);
-  }
-  return { zip: out, manifest: sorted.map(([path, bytes]) => ({ path, size: bytes.byteLength })) };
-}
-
-async function zipFiles(cwd: string, paths: readonly string[]): Promise<SkillBundleBuild> {
-  if (paths.length > SKILL_BUNDLE_LIMITS.maxFiles) {
-    throw new Error(`skill bundle exceeds ${SKILL_BUNDLE_LIMITS.maxFiles} file limit`);
-  }
-  const collected = new Map<string, Uint8Array>();
-  let totalDecompressed = 0;
-  let hasSkillMd = false;
-  for (const p of paths) {
-    const abs = resolvePath(cwd, p);
-    const bytes = await readFile(abs);
-    const name = basename(p);
-    const entry = validateSkillBundleEntry({ path: name, size: bytes.byteLength });
-    if (entry.path === "SKILL.md") hasSkillMd = true;
-    totalDecompressed += bytes.byteLength;
-    if (totalDecompressed > SKILL_BUNDLE_LIMITS.maxDecompressedBytes) {
-      throw new Error(`skill bundle exceeds decompressed cap of ${SKILL_BUNDLE_LIMITS.maxDecompressedBytes} bytes`);
-    }
-    if (collected.has(entry.path)) {
-      throw new Error(`skill bundle contains duplicate path (basenames must be unique): ${entry.path}`);
-    }
-    collected.set(entry.path, bytes);
-  }
-  if (!hasSkillMd) {
-    throw new Error('skill bundle must contain a "SKILL.md" file at the root');
-  }
-  const sorted = [...collected.entries()].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-  const zippable: Zippable = {};
-  for (const [path, bytes] of sorted) zippable[path] = zipEntryFor(bytes);
-  const out = zipSync(zippable, { level: 6 });
-  if (out.byteLength > SKILL_BUNDLE_LIMITS.maxCompressedBytes) {
-    throw new Error(`skill bundle exceeds compressed cap of ${SKILL_BUNDLE_LIMITS.maxCompressedBytes} bytes`);
-  }
-  return { zip: out, manifest: sorted.map(([path, bytes]) => ({ path, size: bytes.byteLength })) };
-}
-
-async function walk(
-  rootDir: string,
-  currentDir: string,
-  visit: (relPathPosix: string, bytes: Uint8Array) => Promise<void>
-): Promise<void> {
-  const entries = await readdir(currentDir, { withFileTypes: true });
-  for (const dirent of entries) {
-    const full = join(currentDir, dirent.name);
-    if (dirent.isSymbolicLink()) continue;
-    if (dirent.isDirectory()) {
-      await walk(rootDir, full, visit);
-      continue;
-    }
-    if (!dirent.isFile()) continue;
-    const rel = relative(rootDir, full);
-    const posixPath = sep === "/" ? rel : rel.split(sep).join(posix.sep);
-    const bytes = await readFile(full);
-    await visit(posixPath, bytes);
-  }
-}

package/src/host/status.ts

@@ -1,40 +0,0 @@
-/**
- * `aex status <run-id>` — fetch a single run record via GET
- * /api/runs/{id} and print it as JSON.
- */
-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 runStatusCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "status")) 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 status <run-id> [common flags]\n");
-    return USAGE_ERR;
-  }
-  const runId = positional[0]!;
-
-  const http = makeHttpClient(io, common.flags);
-  try {
-    const run = await operations.getRun(http, runId);
-    io.stdout(JSON.stringify(run) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "status_failed", (err as Error).message ?? "status fetch failed", { runId });
-  }
-}

package/src/host/wait.ts

@@ -1,110 +0,0 @@
-/**
- * `aex wait <run-id> [--timeout <dur>] [--interval <dur>]`
- *
- * Block until the run reaches a terminal status (the host-side mirror of
- * the SDK's `client.waitForRun` / `client.wait`), then print the final
- * `Run` record as JSON. Exits 0 when the run `succeeded`, RUNTIME_ERR
- * when it reached a non-succeeded terminal status, and TIMEOUT_ERR when
- * the `--timeout` deadline elapsed first.
- *
- * Where `events --follow` streams the event log, `wait` is the quiet
- * "tell me when it's done and what the outcome was" verb — one final
- * line of JSON, script-friendly exit code.
- */
-import { operations, TERMINAL_RUN_STATUSES } from "@aexhq/contracts";
-import type { CliIO } from "../internal.js";
-import {
-  type CliExitCode,
-  SUCCESS,
-  RUNTIME_ERR,
-  TIMEOUT_ERR,
-  USAGE_ERR,
-  emitJsonError,
-  makeHttpClient,
-  parseCommonHostFlags,
-  parseDuration,
-  refuseInsideManagedRun,
-  takeOptionFlag
-} from "./common.js";
-
-// Membership-tested against the loose `string` run status from the BFF, so we
-// back it with the canonical terminal set rather than a drift-prone local list.
-const TERMINAL_STATUSES = new Set<string>(TERMINAL_RUN_STATUSES);
-
-const DEFAULT_INTERVAL_MS = 2_000;
-
-export async function runWaitCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "wait")) return USAGE_ERR;
-
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) {
-    io.stderr(`${common.reason}\n`);
-    return USAGE_ERR;
-  }
-
-  const timeoutFlag = takeOptionFlag(common.rest, "--timeout");
-  const intervalFlag = takeOptionFlag(timeoutFlag.remaining, "--interval");
-
-  let timeoutMs: number | null = null;
-  if (timeoutFlag.value !== undefined) {
-    const parsed = parseDuration(timeoutFlag.value);
-    if (parsed.error) {
-      io.stderr(`--timeout: ${parsed.error}\n`);
-      return USAGE_ERR;
-    }
-    timeoutMs = parsed.ms;
-  }
-
-  let intervalMs = DEFAULT_INTERVAL_MS;
-  if (intervalFlag.value !== undefined) {
-    const parsed = parseDuration(intervalFlag.value);
-    if (parsed.error) {
-      io.stderr(`--interval: ${parsed.error}\n`);
-      return USAGE_ERR;
-    }
-    intervalMs = parsed.ms!;
-  }
-
-  const positional = intervalFlag.remaining.filter((arg) => !arg.startsWith("--"));
-  if (positional.length !== 1) {
-    io.stderr("usage: aex wait <run-id> [--timeout <dur>] [--interval <dur>] [common flags]\n");
-    return USAGE_ERR;
-  }
-  const runId = positional[0]!;
-
-  const http = makeHttpClient(io, common.flags);
-  const deadline = timeoutMs === null ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
-
-  // Emit the timeout JSON error body (via emitJsonError's side effect)
-  // but return the dedicated TIMEOUT_ERR code rather than its RUNTIME_ERR.
-  const timeout = (extra: Record<string, unknown>): CliExitCode => {
-    emitJsonError(io, "wait_timeout", `timed out after ${timeoutMs}ms waiting for run to finish`, { runId, ...extra });
-    return TIMEOUT_ERR;
-  };
-
-  while (true) {
-    let run;
-    try {
-      run = await operations.getRun(http, runId);
-    } catch (err) {
-      // Transient read failures are non-fatal until the deadline — a slow
-      // BFF or a brief network blip shouldn't abort a multi-minute wait.
-      io.stderr(`(transient) status poll failed: ${(err as Error).message}\n`);
-      if (Date.now() >= deadline) return timeout({});
-      await sleep(intervalMs);
-      continue;
-    }
-
-    if (TERMINAL_STATUSES.has(run.status)) {
-      io.stdout(JSON.stringify(run) + "\n");
-      return run.status === "succeeded" ? SUCCESS : RUNTIME_ERR;
-    }
-
-    if (Date.now() >= deadline) return timeout({ lastStatus: run.status });
-    await sleep(intervalMs);
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/host/whoami.ts

@@ -1,42 +0,0 @@
-/**
- * `aex whoami` — GET /api/whoami. Lets agents confirm the token
- * resolves to a workspace + scopes before submitting a real run.
- *
- * `--workspace` is NOT required: the whoami endpoint resolves the
- * principal by the bearer alone and tells the caller which workspace
- * the token belongs to.
- */
-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 runWhoamiCmd(io: CliIO, argv: readonly string[]): Promise<CliExitCode> {
-  if (await refuseInsideManagedRun(io, "whoami")) return USAGE_ERR;
-
-  const common = parseCommonHostFlags(argv);
-  if (!common.ok) {
-    io.stderr(`${common.reason}\n`);
-    return USAGE_ERR;
-  }
-  if (common.rest.length > 0) {
-    io.stderr(`unexpected arguments: ${common.rest.join(" ")}\n`);
-    return USAGE_ERR;
-  }
-
-  const http = makeHttpClient(io, common.flags);
-  try {
-    const me = await operations.whoami(http);
-    io.stdout(JSON.stringify(me) + "\n");
-    return SUCCESS;
-  } catch (err) {
-    return emitJsonError(io, "whoami_failed", (err as Error).message ?? "whoami failed");
-  }
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-/**
- * Public exports for the `@aexhq/cli` package. Tests and the SDK bundle
- * import from here.
- */
-export { runCli } from "./run.js";
-export { AEX_INDEX_PATH, AEX_RUN_TOKEN_PATH } from "./internal.js";
-export type { CliIO } from "./internal.js";

package/src/internal.ts

@@ -1,63 +0,0 @@
-/**
- * aex CLI — internal IO surface.
- *
- * This module exports the dependency-injection types and a thin
- * `createCli()` factory that the entrypoint (`cli.ts`) calls with real
- * IO. Tests import this module directly and inject fakes — there are
- * NO `process.env.AEX_*` reads in the production code paths
- * (mechanical test in Phase 9 enforces this against the built bundle).
- */
-import type {
-  ProxyIndexFile,
-  ProxyIndexEntry,
-  ProxyMethod,
-  ProxyResponseMode
-} from "@aexhq/contracts";
-
-/**
- * Manifest file path inside the run container (always present).
- *
- * The runner writes the manifest to this fixed path before invoking
- * in-container `aex` commands.
- */
-export const AEX_INDEX_PATH = "/mnt/session/uploads/aex/index.json";
-
-/** Per-run bearer file path (only present when proxyEndpoints declared). */
-export const AEX_RUN_TOKEN_PATH = "/mnt/session/uploads/aex/run-token";
-
-/**
- * IO surface the CLI depends on. The production entrypoint passes real
- * implementations; tests pass fakes. New IO methods must be additive
- * and orthogonal: a fake that lacks a method should still satisfy the
- * subset of subcommands that don't touch that method.
- */
-export interface CliIO {
-  readonly readFile: (path: string) => Promise<string>;
-  readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
-  readonly fetchImpl: typeof fetch;
-  readonly stdout: (chunk: string) => void;
-  readonly stderr: (chunk: string) => void;
-  readonly exit: (code: number) => void;
-  readonly argv: readonly string[];
-  /** Current working directory; used to resolve relative `--out` paths. */
-  readonly cwd: () => string;
-  /**
-   * Walk a directory and return every regular-file entry beneath it
-   * (recursive). Used only by the internal `outputs sync` subcommand
-   * that the worker invokes from inside a managed run container at
-   * session terminal. Returns `null` (not throws) when the directory
-   * does not exist or is unreadable — `outputs sync` records the
-   * miss in its structured output and continues to the next dir.
-   */
-  readonly walkDirectory?: (root: string) => Promise<readonly OutputsSyncFileEntry[] | null>;
-}
-
-export interface OutputsSyncFileEntry {
-  /** Absolute path inside the container. */
-  readonly path: string;
-  /** File size in bytes. */
-  readonly sizeBytes: number;
-}
-
-/** Re-exported helpers used by CLI consumers. */
-export type { ProxyIndexFile, ProxyIndexEntry, ProxyMethod, ProxyResponseMode };

package/src/outputs-sync.ts

@@ -1,76 +0,0 @@
-/**
- * aex outputs sync — IN-CONTAINER ONLY internal subcommand.
- *
- * This is NOT a user-facing verb. It is a legacy/internal directory walker:
- * callers pass explicit absolute directories, and the command emits a
- * structured JSON line per file to stdout. Managed runs now capture output by
- * filesystem baseline/delta; there is no default output directory and no
- * synthetic terminal agent turn.
- *
- * The subcommand:
- *  - REFUSES to run outside a managed run (no AEX_INDEX_PATH file).
- *  - Walks each provided directory recursively.
- *  - Emits one JSON line per file to stdout:
- *      {"dir":"/workspace/reports","path":"/workspace/reports/x.txt","sizeBytes":42}
- *  - Reports missing dirs via stderr (non-fatal). Exits 0 if at least
- *    one dir contained at least one file; 0 also when ALL dirs were
- *    empty (best-effort semantics — the worker still records the
- *    capture attempt either way).
- *
- * No flags. Each positional argument is one directory to walk.
- */
-import { AEX_INDEX_PATH, type CliIO } from "./internal.js";
-import { RUNTIME_ERR, SUCCESS, USAGE_ERR, type CliExitCode } from "./host/common.js";
-
-export async function runOutputsSyncCmd(io: CliIO, dirs: readonly string[]): Promise<CliExitCode> {
-  if (dirs.length === 0) {
-    io.stderr("usage: aex outputs sync <dir> [<dir> ...]\n");
-    return USAGE_ERR;
-  }
-  try {
-    await io.readFile(AEX_INDEX_PATH);
-  } catch {
-    io.stderr(
-      "`aex outputs sync` is an in-container internal command and cannot run on the host.\n"
-    );
-    return USAGE_ERR;
-  }
-  if (!io.walkDirectory) {
-    io.stderr("aex outputs sync: walkDirectory IO is not available\n");
-    return RUNTIME_ERR;
-  }
-
-  let scanned = 0;
-  let missing = 0;
-  for (const dir of dirs) {
-    if (!dir.startsWith("/")) {
-      io.stderr(
-        JSON.stringify({ dir, error: "non_absolute_path", message: "skipping non-absolute output dir" }) + "\n"
-      );
-      missing++;
-      continue;
-    }
-    let entries;
-    try {
-      entries = await io.walkDirectory(dir);
-    } catch (err) {
-      io.stderr(
-        JSON.stringify({ dir, error: "walk_failed", message: (err as Error).message ?? "walk failed" }) + "\n"
-      );
-      missing++;
-      continue;
-    }
-    if (entries === null) {
-      io.stderr(JSON.stringify({ dir, error: "missing_or_unreadable" }) + "\n");
-      missing++;
-      continue;
-    }
-    for (const entry of entries) {
-      io.stdout(JSON.stringify({ dir, path: entry.path, sizeBytes: entry.sizeBytes }) + "\n");
-      scanned++;
-    }
-  }
-
-  io.stdout(JSON.stringify({ summary: { dirs: dirs.length, files: scanned, missing } }) + "\n");
-  return SUCCESS;
-}