antpath 0.2.0 → 0.3.1

package/dist/cli.mjs

@@ -0,0 +1,1537 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// dist/cli.js
+import { readFile, writeFile } from "node:fs/promises";
+
+// ../shared/dist/config.js
+var DEFAULT_CAPS = {
+  maxRunDurationMs: 5 * 60 * 1e3,
+  maxActiveRunsPerWorkspace: 1,
+  maxActiveRunsPerUserOrToken: 1,
+  pollingBaseIntervalMs: 5e3,
+  pollingMaxIntervalMs: 6e4,
+  pollingJitterRatio: 0.2,
+  providerCreateTokensPerMinute: 20,
+  providerDeleteTokensPerMinute: 30,
+  providerPollTokensPerMinute: 60,
+  providerRetryBackoffMs: 5e3,
+  leaseDurationMs: 6e4,
+  leaseRenewalThresholdMs: 2e4,
+  maxProviderAttempts: 1,
+  cleanupRetryCount: 3,
+  cleanupRetryBackoffMs: 1e4,
+  outputDownloadSafetyCapBytes: 1024 * 1024 * 1024,
+  workspaceStorageCapBytes: 5 * 1024 * 1024 * 1024,
+  signedUrlTtlSeconds: 300
+};
+
+// ../shared/dist/proxy-protocol.js
+var PROXY_PROTOCOL_VERSION = "1";
+var PROXY_PROTOCOL_HEADER = "x-antpath-proxy-protocol";
+var PROXY_METHOD_HEADER = "x-antpath-method";
+var PROXY_PATH_HEADER = "x-antpath-path";
+var PROXY_QUERY_HEADER = "x-antpath-query";
+var PROXY_HEADERS_HEADER = "x-antpath-headers";
+var PROXY_RESPONSE_MODE_HEADER = "x-antpath-response-mode";
+var PROXY_RESPONSE_MODES = ["status_only", "headers_only", "full"];
+
+// ../shared/dist/status.js
+var TERMINAL_RUN_STATUSES = [
+  "succeeded",
+  "failed",
+  "timed_out",
+  "cancelled",
+  "cleanup_failed",
+  "pending_delete",
+  "deleted"
+];
+var terminalRunStatuses = new Set(TERMINAL_RUN_STATUSES);
+
+// ../shared/dist/submission.js
+var PROXY_ENDPOINT_DEFAULTS = {
+  allowHeaders: [],
+  responseMode: "headers_only",
+  maxRequestBytes: 64 * 1024,
+  maxResponseBytes: 1024 * 1024,
+  timeoutMs: 1e4,
+  perCallBudget: 60,
+  responseByteBudget: 1024 * 1024
+};
+
+// ../shared/dist/stable.js
+import { createHash } from "node:crypto";
+function stableStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sha256(value) {
+  return createHash("sha256").update(typeof value === "string" ? value : stableStringify(value)).digest("hex");
+}
+function sortValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortValue);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, sortValue(item)]));
+  }
+  return value;
+}
+
+// ../shared/dist/sdk-secrets.js
+var SECRET_PATTERNS = [
+  /sk-ant-[A-Za-z0-9_\-]{16,}/g,
+  /sk-[A-Za-z0-9_\-]{20,}/g,
+  /xox[pbar]-[A-Za-z0-9\-]{10,}/g,
+  /(?:bearer|token|api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret)["'\s:=]+[A-Za-z0-9_\-./+=]{12,}/gi
+];
+var REDACTED = "[REDACTED]";
+function redactSecrets(value) {
+  if (typeof value === "string") {
+    return redactString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactSecrets(item));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (isSecretKey(key)) {
+        out[key] = REDACTED;
+      } else {
+        out[key] = redactSecrets(item);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function redactString(input) {
+  return SECRET_PATTERNS.reduce((current, pattern) => current.replace(pattern, REDACTED), input);
+}
+function containsSecretLikeValue(input) {
+  return SECRET_PATTERNS.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(input);
+  });
+}
+function isSecretKey(key) {
+  return /(?:api[_-]?key|authorization|token|secret|password|credential)/i.test(key);
+}
+
+// ../shared/dist/sdk-errors.js
+var AntpathError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(redactSecrets(message));
+    this.name = this.constructor.name;
+    this.code = code;
+    this.details = details === void 0 ? void 0 : redactSecrets(details);
+  }
+};
+var TemplateValidationError = class extends AntpathError {
+  constructor(message, details) {
+    super("TEMPLATE_INVALID", message, details);
+  }
+};
+var AntpathApiError = class extends AntpathError {
+  status;
+  body;
+  constructor(status, message, body) {
+    super("API_ERROR", message, body);
+    this.status = status;
+    this.body = redactSecrets(body);
+  }
+};
+
+// ../shared/dist/template/compiler.js
+var ESCAPED_OPEN = "\0ANTPATH_ESCAPED_OPEN\0";
+var VARIABLE_PATTERN = /{{\s*([A-Za-z_][A-Za-z0-9_]*)\s*}}/g;
+function compileTemplate(template, variables = {}) {
+  assertTemplateShape(template);
+  const values = resolveVariableValues(template, variables);
+  const resolved = {
+    name: template.name,
+    model: resolveValue(template.model, values, template.variables ?? {}),
+    system: template.system === void 0 ? void 0 : resolveValue(template.system, values, template.variables ?? {}),
+    messages: template.messages.map((message) => resolveValue(message, values, template.variables ?? {})),
+    mcpServers: resolveMcpServers(template.mcpServers ?? {}, values, template.variables ?? {}),
+    environment: resolveValue(template.environment ?? {}, values, template.variables ?? {}),
+    skills: resolveValue(template.skills ?? [], values, template.variables ?? {}),
+    outputs: {
+      recommendedPath: "/antpath/outputs",
+      ...resolveValue(template.outputs ?? {}, values, template.variables ?? {})
+    },
+    metadata: resolveValue(template.metadata ?? {}, values, template.variables ?? {}),
+    credentialRequirements: {}
+  };
+  resolved.credentialRequirements = Object.fromEntries(resolved.mcpServers.filter((server) => server.auth).map((server) => [server.key, server.auth]));
+  scanForSecrets(resolved);
+  return {
+    ...resolved,
+    hash: sha256(stableStringify(resolved))
+  };
+}
+function assertTemplateShape(template) {
+  if (!template.name?.trim()) {
+    throw new TemplateValidationError("Template name is required");
+  }
+  if (!template.model) {
+    throw new TemplateValidationError("Template model is required");
+  }
+  if (!Array.isArray(template.messages) || template.messages.length === 0) {
+    throw new TemplateValidationError("Template must define at least one user message");
+  }
+  for (const [key, server] of Object.entries(template.mcpServers ?? {})) {
+    if (!/^[A-Za-z0-9_-]+$/.test(key)) {
+      throw new TemplateValidationError(`MCP server key '${key}' must use letters, numbers, underscores, or hyphens`);
+    }
+    if (server.tools?.allow && server.tools.deny) {
+      throw new TemplateValidationError(`MCP server '${key}' cannot define both allow and deny tool policies`);
+    }
+  }
+}
+function resolveVariableValues(template, variables) {
+  const definitions = template.variables ?? {};
+  const resolved = {};
+  for (const [key, definition] of Object.entries(definitions)) {
+    const value = variables[key] ?? definition.default;
+    if (value === void 0) {
+      continue;
+    }
+    if (typeof value !== "string") {
+      throw new TemplateValidationError(`Variable '${key}' must resolve to a string`);
+    }
+    resolved[key] = value;
+  }
+  for (const key of Object.keys(variables)) {
+    if (!definitions[key]) {
+      throw new TemplateValidationError(`Unknown Template variable '${key}'`);
+    }
+  }
+  return resolved;
+}
+function resolveMcpServers(servers, values, definitions) {
+  return Object.entries(servers).map(([key, server]) => {
+    const resolved = {
+      key,
+      name: key,
+      url: resolveValue(server.url, values, definitions ?? {})
+    };
+    if (server.auth)
+      resolved.auth = server.auth;
+    if (server.tools)
+      resolved.tools = resolveValue(server.tools, values, definitions ?? {});
+    return resolved;
+  });
+}
+function resolveValue(value, variables, definitions) {
+  if (typeof value === "string") {
+    return resolveString(value, variables, definitions);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveValue(item, variables, definitions));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, resolveValue(item, variables, definitions)]));
+  }
+  return value;
+}
+function resolveString(input, variables, definitions) {
+  const protectedInput = input.replace(/\\{{/g, ESCAPED_OPEN);
+  const resolved = protectedInput.replace(VARIABLE_PATTERN, (_match, name) => {
+    if (!definitions[name]) {
+      throw new TemplateValidationError(`Unresolved Template variable '${name}'`);
+    }
+    const value = variables[name];
+    if (value === void 0) {
+      throw new TemplateValidationError(`Missing value for Template variable '${name}'`);
+    }
+    return value;
+  });
+  return resolved.replace(new RegExp(ESCAPED_OPEN, "g"), "{{");
+}
+function scanForSecrets(value) {
+  const serialized = stableStringify(value);
+  if (containsSecretLikeValue(serialized)) {
+    throw new TemplateValidationError("Template contains a secret-like value; pass secrets through typed credentials instead");
+  }
+}
+
+// ../shared/dist/template/mapper.js
+function toPlatformSubmissionTemplate(resolved) {
+  const modelId = typeof resolved.model === "string" ? resolved.model : resolved.model.id;
+  const environment = mapEnvironment(resolved.environment);
+  const metadata = filterMetadata(resolved.metadata);
+  const submission = {
+    name: resolved.name,
+    model: modelId,
+    templateHash: resolved.hash,
+    messages: resolved.messages
+  };
+  return {
+    ...submission,
+    ...resolved.system ? { system: resolved.system } : {},
+    ...metadata ? { metadata } : {},
+    ...environment ? { environment } : {}
+  };
+}
+function mapEnvironment(env) {
+  if (!env)
+    return void 0;
+  let networking;
+  if (env.network) {
+    if (env.network === "restricted") {
+      networking = { mode: "limited", allowedHosts: [] };
+    } else if (env.network === "unrestricted") {
+      networking = { mode: "open" };
+    } else if (typeof env.network === "object" && env.network.type === "limited") {
+      const allowedHosts = env.network.allowedHosts ?? [];
+      networking = { mode: "limited", allowedHosts };
+    }
+  }
+  let packages;
+  if (env.packages) {
+    const collected = [];
+    for (const [manager, list] of Object.entries(env.packages)) {
+      if (!list)
+        continue;
+      for (const item of list) {
+        collected.push({ name: `${manager}:${item}` });
+      }
+    }
+    if (collected.length > 0)
+      packages = collected;
+  }
+  if (!networking && !packages)
+    return void 0;
+  return {
+    ...networking ? { networking } : {},
+    ...packages ? { packages } : {}
+  };
+}
+function filterMetadata(metadata) {
+  if (!metadata)
+    return void 0;
+  const entries = Object.entries(metadata);
+  if (entries.length === 0)
+    return void 0;
+  return Object.fromEntries(entries);
+}
+
+// ../shared/dist/http.js
+var HttpClient = class {
+  #baseUrl;
+  #apiToken;
+  #fetch;
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error("HttpClient: baseUrl is required");
+    }
+    if (!options.apiToken) {
+      throw new Error("HttpClient: apiToken is required");
+    }
+    const normalized = options.baseUrl.endsWith("/") ? options.baseUrl : `${options.baseUrl}/`;
+    this.#baseUrl = new URL(normalized);
+    this.#apiToken = options.apiToken;
+    this.#fetch = options.fetch ?? fetch;
+  }
+  async request(path, init = {}, query = {}) {
+    const url = new URL(path.replace(/^\//, ""), this.#baseUrl);
+    for (const [key, value] of Object.entries(query)) {
+      url.searchParams.set(key, value);
+    }
+    const headers = {
+      accept: "application/json",
+      authorization: `Bearer ${this.#apiToken}`,
+      ...normalizeHeaders(init.headers)
+    };
+    if (init.body !== void 0 && init.body !== null && !headers["content-type"]) {
+      headers["content-type"] = "application/json";
+    }
+    const response = await this.#fetch(url, { ...init, headers });
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new AntpathApiError(response.status, extractErrorMessage(body), body);
+    }
+    return body;
+  }
+  async download(path, init = {}, query = {}) {
+    const url = new URL(path.replace(/^\//, ""), this.#baseUrl);
+    for (const [key, value] of Object.entries(query)) {
+      url.searchParams.set(key, value);
+    }
+    const headers = {
+      authorization: `Bearer ${this.#apiToken}`,
+      ...normalizeHeaders(init.headers)
+    };
+    const response = await this.#fetch(url, { ...init, headers });
+    if (!response.ok) {
+      const body = await readJson(response);
+      throw new AntpathApiError(response.status, extractErrorMessage(body), body);
+    }
+    return { response };
+  }
+};
+function normalizeHeaders(headers) {
+  if (!headers)
+    return {};
+  if (headers instanceof Headers)
+    return Object.fromEntries(headers.entries());
+  if (Array.isArray(headers))
+    return Object.fromEntries(headers);
+  return headers;
+}
+async function readJson(response) {
+  const text = await response.text();
+  if (text.length === 0)
+    return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+function extractErrorMessage(body) {
+  if (body && typeof body === "object" && "error" in body) {
+    const error = body.error;
+    if (typeof error === "string")
+      return error;
+    if (error && typeof error === "object" && "message" in error) {
+      const message = error.message;
+      if (typeof message === "string")
+        return message;
+    }
+  }
+  return "antpath API request failed";
+}
+
+// ../shared/dist/operations.js
+var operations_exports = {};
+__export(operations_exports, {
+  cancelRun: () => cancelRun,
+  createOutputLink: () => createOutputLink,
+  deleteRun: () => deleteRun,
+  getRun: () => getRun,
+  listOutputs: () => listOutputs,
+  listRunEvents: () => listRunEvents,
+  submitRun: () => submitRun,
+  whoami: () => whoami
+});
+async function submitRun(http, request) {
+  return http.request("/api/runs", {
+    method: "POST",
+    body: JSON.stringify(request)
+  });
+}
+async function getRun(http, workspaceId, runId) {
+  const result = await http.request(`/api/runs/${encodeURIComponent(runId)}`, {}, { workspaceId });
+  return hasRun(result) ? result.run : result;
+}
+async function listRunEvents(http, workspaceId, runId) {
+  const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/events`, {}, { workspaceId });
+  return result.events;
+}
+async function listOutputs(http, workspaceId, runId) {
+  const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/outputs`, {}, { workspaceId });
+  return result.outputs;
+}
+async function createOutputLink(http, workspaceId, runId, outputId) {
+  return http.request(`/api/runs/${encodeURIComponent(runId)}/outputs/${encodeURIComponent(outputId)}/link`, { method: "POST" }, { workspaceId });
+}
+async function cancelRun(http, workspaceId, runId) {
+  await http.request(`/api/runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" }, { workspaceId });
+}
+async function deleteRun(http, workspaceId, runId) {
+  await http.request(`/api/runs/${encodeURIComponent(runId)}`, { method: "DELETE" }, { workspaceId });
+}
+async function whoami(http) {
+  return http.request("/api/whoami");
+}
+function hasRun(value) {
+  return Boolean(value && typeof value === "object" && "run" in value);
+}
+
+// ../shared/dist/proxy-validation.js
+function validateProxyAuth(endpoints, auth) {
+  const authList = auth ?? [];
+  const endpointNames = new Set(endpoints.map((e) => e.name));
+  const authNames = /* @__PURE__ */ new Set();
+  for (const entry of authList) {
+    if (authNames.has(entry.name)) {
+      throw new Error(`secrets.proxyEndpointAuth contains duplicate name '${entry.name}'`);
+    }
+    authNames.add(entry.name);
+    if (!endpointNames.has(entry.name)) {
+      throw new Error(`secrets.proxyEndpointAuth[].name='${entry.name}' has no matching proxyEndpoints[].name`);
+    }
+  }
+  for (const endpoint of endpoints) {
+    const match = authList.find((a) => a.name === endpoint.name);
+    if (!match) {
+      throw new Error(`proxyEndpoints[].name='${endpoint.name}' is missing a matching secrets.proxyEndpointAuth entry`);
+    }
+    if (match.value.type !== endpoint.authShape.type) {
+      throw new Error(`secrets.proxyEndpointAuth[name='${endpoint.name}'].value.type='${match.value.type}' does not match proxyEndpoints[name='${endpoint.name}'].authShape.type='${endpoint.authShape.type}'`);
+    }
+  }
+}
+
+// dist/internal.js
+var ANTPATH_INDEX_PATH = "/antpath/index.json";
+var ANTPATH_RUN_TOKEN_PATH = "/antpath/run-token";
+
+// dist/host/common.js
+var SUCCESS = { code: 0 };
+var USAGE_ERR = { code: 2 };
+var RUNTIME_ERR = { code: 1 };
+function parseCommonHostFlags(argv, options = {}) {
+  const requireWorkspace = options.requireWorkspace ?? true;
+  let apiToken = null;
+  let workspaceId = null;
+  let dashboardUrl = null;
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--api-token") {
+      const v = argv[++i];
+      if (v === void 0)
+        return { ok: false, reason: "--api-token requires a value" };
+      apiToken = v;
+      continue;
+    }
+    if (arg === "--workspace") {
+      const v = argv[++i];
+      if (v === void 0)
+        return { ok: false, reason: "--workspace requires a value" };
+      workspaceId = v;
+      continue;
+    }
+    if (arg === "--dashboard-url") {
+      const v = argv[++i];
+      if (v === void 0)
+        return { ok: false, reason: "--dashboard-url requires a value" };
+      dashboardUrl = v;
+      continue;
+    }
+    rest.push(arg);
+  }
+  if (!apiToken)
+    return { ok: false, reason: "--api-token is required" };
+  if (!dashboardUrl)
+    return { ok: false, reason: "--dashboard-url is required" };
+  if (requireWorkspace && !workspaceId) {
+    return { ok: false, reason: "--workspace is required" };
+  }
+  return {
+    ok: true,
+    flags: { apiToken, workspaceId: workspaceId ?? "", dashboardUrl },
+    rest
+  };
+}
+function makeHttpClient(io2, flags) {
+  return new HttpClient({
+    baseUrl: flags.dashboardUrl,
+    apiToken: flags.apiToken,
+    fetch: io2.fetchImpl
+  });
+}
+async function refuseInsideManagedRun(io2, verb) {
+  try {
+    await io2.readFile(ANTPATH_INDEX_PATH);
+    io2.stderr(`\`antpath ${verb}\` is a host command and cannot run inside a managed run container.
+Use \`antpath proxy ...\` to call your declared upstream endpoints from inside the run.
+`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function emitJsonError(io2, code, message, extra = {}) {
+  io2.stderr(JSON.stringify({ error: code, message, ...extra }) + "\n");
+  return RUNTIME_ERR;
+}
+function collectRepeatedKv(rest, flag) {
+  const entries = {};
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const kv = rest[++i];
+      if (kv === void 0) {
+        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 };
+}
+function collectRepeated(rest, flag) {
+  const values = [];
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const v = rest[++i];
+      if (v === void 0) {
+        return { values, remaining, error: `${flag} requires a value` };
+      }
+      values.push(v);
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { values, remaining, error: null };
+}
+function takeFlagValue(rest, flag) {
+  let value = null;
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const v = rest[++i];
+      if (v === void 0) {
+        return { value, remaining, error: `${flag} requires a value` };
+      }
+      value = v;
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { value, remaining, error: null };
+}
+function takeBooleanFlag(rest, flag) {
+  const remaining = [];
+  let present = false;
+  for (const arg of rest) {
+    if (arg === flag) {
+      present = true;
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { present, remaining };
+}
+
+// dist/proxy.js
+function parseProxyFlags(rest) {
+  let endpointName = null;
+  let method = "GET";
+  let path = "/";
+  let query = null;
+  const headers = /* @__PURE__ */ new Map();
+  let dataSpec = null;
+  let responseMode = null;
+  let showHelp = false;
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--help" || arg === "-h") {
+      showHelp = true;
+      continue;
+    }
+    if (arg === "--method") {
+      method = expect(rest, ++i, "--method");
+      continue;
+    }
+    if (arg === "--path") {
+      path = expect(rest, ++i, "--path");
+      continue;
+    }
+    if (arg === "--query") {
+      query = expect(rest, ++i, "--query");
+      continue;
+    }
+    if (arg === "--header") {
+      const kv = expect(rest, ++i, "--header");
+      const eq = kv.indexOf("=");
+      if (eq <= 0)
+        return { ok: false, reason: "--header must be in the form KEY=VALUE" };
+      headers.set(kv.slice(0, eq).toLowerCase(), kv.slice(eq + 1));
+      continue;
+    }
+    if (arg === "--data") {
+      dataSpec = expect(rest, ++i, "--data");
+      continue;
+    }
+    if (arg === "--response-mode") {
+      responseMode = expect(rest, ++i, "--response-mode");
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      return { ok: false, reason: `unknown flag: ${arg}` };
+    }
+    if (endpointName === null) {
+      endpointName = arg;
+      continue;
+    }
+    return { ok: false, reason: `unexpected positional argument: ${arg}` };
+  }
+  return { ok: true, flags: { endpointName, method, path, query, headers, dataSpec, responseMode, showHelp } };
+}
+function expect(arr, idx, flag) {
+  const v = arr[idx];
+  if (v === void 0) {
+    throw new CliUsageError(`${flag} requires a value`);
+  }
+  return v;
+}
+var CliUsageError = class extends Error {
+};
+async function printProxyHelp(io2) {
+  io2.stdout("antpath proxy \u2014 call an upstream HTTP endpoint via the managed proxy.\n\n");
+  io2.stdout("Usage:\n");
+  io2.stdout("  antpath proxy <endpoint-name> [flags]\n\n");
+  io2.stdout("Flags:\n");
+  io2.stdout("  --method <verb>          HTTP method (default: GET)\n");
+  io2.stdout("  --path <path>            Caller-supplied path; must match policy prefixes\n");
+  io2.stdout(`  --query <json>           JSON object of query parameters (e.g. '{"q":"x"}')
+`);
+  io2.stdout("  --header K=V             Add a caller header (repeatable)\n");
+  io2.stdout("  --data <value>           Request body. Use '-' for stdin, '@<file>' for file content\n");
+  io2.stdout("  --response-mode <mode>   status_only | headers_only | full (may only narrow policy)\n");
+  io2.stdout("  --help                   Show this message\n\n");
+  const manifest = await tryReadManifest(io2);
+  if (manifest && manifest.endpoints.length > 0) {
+    io2.stdout("Declared endpoints:\n");
+    for (const ep of manifest.endpoints) {
+      io2.stdout(`  \u2022 ${ep.name}: ${ep.allowMethods.join(",")} ${ep.allowPathPrefixes.join(",")} (mode=${ep.responseMode}, budget=${ep.perCallBudget}/run)
+`);
+    }
+  }
+  return SUCCESS;
+}
+async function runProxy(io2, rest) {
+  let parsed;
+  try {
+    parsed = parseProxyFlags(rest);
+  } catch (err) {
+    if (err instanceof CliUsageError) {
+      io2.stderr(`${err.message}
+`);
+      return USAGE_ERR;
+    }
+    throw err;
+  }
+  if (!parsed.ok) {
+    io2.stderr(`${parsed.reason}
+`);
+    return USAGE_ERR;
+  }
+  const f = parsed.flags;
+  if (f.showHelp) {
+    return await printProxyHelp(io2);
+  }
+  if (!f.endpointName) {
+    io2.stderr("missing endpoint-name\n");
+    io2.stderr("usage: antpath proxy <endpoint-name> [flags]\n");
+    return USAGE_ERR;
+  }
+  if (f.responseMode && !PROXY_RESPONSE_MODES.includes(f.responseMode)) {
+    io2.stderr(`--response-mode must be one of: ${PROXY_RESPONSE_MODES.join(", ")}
+`);
+    return USAGE_ERR;
+  }
+  const manifest = await tryReadManifest(io2);
+  if (!manifest) {
+    emitError(io2, {
+      error: "internal_error",
+      message: "manifest not mounted; this CLI must run inside an antpath-managed run"
+    });
+    return RUNTIME_ERR;
+  }
+  if (!manifest.proxyBaseUrl) {
+    emitError(io2, {
+      error: "endpoint_not_found",
+      message: "this run has no proxy endpoints declared",
+      endpointName: f.endpointName
+    });
+    return RUNTIME_ERR;
+  }
+  let token;
+  try {
+    token = (await io2.readFile(ANTPATH_RUN_TOKEN_PATH)).trim();
+  } catch {
+    emitError(io2, {
+      error: "unauthorized",
+      message: "run token file missing; this run has no proxy bearer"
+    });
+    return RUNTIME_ERR;
+  }
+  if (!token) {
+    emitError(io2, { error: "unauthorized", message: "run token is empty" });
+    return RUNTIME_ERR;
+  }
+  let body;
+  if (f.dataSpec !== null) {
+    try {
+      body = await resolveBody(io2, f.dataSpec);
+    } catch (err) {
+      io2.stderr(`failed to read request body: ${err.message}
+`);
+      return RUNTIME_ERR;
+    }
+  }
+  const url = `${manifest.proxyBaseUrl.replace(/\/+$/, "")}/${encodeURIComponent(f.endpointName)}`;
+  const requestHeaders = new Headers();
+  requestHeaders.set("authorization", `Bearer ${token}`);
+  requestHeaders.set(PROXY_PROTOCOL_HEADER, PROXY_PROTOCOL_VERSION);
+  requestHeaders.set(PROXY_METHOD_HEADER, f.method.toUpperCase());
+  requestHeaders.set(PROXY_PATH_HEADER, f.path);
+  if (f.query) {
+    requestHeaders.set(PROXY_QUERY_HEADER, f.query);
+  }
+  if (f.headers.size > 0) {
+    requestHeaders.set(PROXY_HEADERS_HEADER, JSON.stringify(Object.fromEntries(f.headers)));
+  }
+  if (f.responseMode) {
+    requestHeaders.set(PROXY_RESPONSE_MODE_HEADER, f.responseMode);
+  }
+  if (body !== void 0) {
+    requestHeaders.set("content-length", String(body.byteLength));
+  }
+  const init = {
+    method: "POST",
+    headers: requestHeaders,
+    redirect: "manual"
+  };
+  if (body !== void 0) {
+    init.body = body;
+  }
+  let response;
+  try {
+    response = await io2.fetchImpl(url, init);
+  } catch (err) {
+    emitError(io2, {
+      error: "upstream_error",
+      message: `proxy request failed: ${err.message}`,
+      endpointName: f.endpointName
+    });
+    return RUNTIME_ERR;
+  }
+  const text = await response.text();
+  let parsedBody;
+  try {
+    parsedBody = text ? JSON.parse(text) : {};
+  } catch {
+    emitError(io2, {
+      error: "internal_error",
+      message: "proxy returned non-JSON response",
+      endpointName: f.endpointName
+    });
+    return RUNTIME_ERR;
+  }
+  if (!response.ok) {
+    io2.stderr(JSON.stringify(parsedBody) + "\n");
+    return RUNTIME_ERR;
+  }
+  io2.stdout(JSON.stringify(parsedBody) + "\n");
+  return SUCCESS;
+}
+async function resolveBody(io2, spec) {
+  if (spec === "-") {
+    const data = await io2.readFile("/dev/stdin");
+    return new Uint8Array(Buffer.from(data, "utf8"));
+  }
+  if (spec.startsWith("@")) {
+    const path = spec.slice(1);
+    if (!path)
+      throw new Error("--data @<file> requires a path");
+    const data = await io2.readFile(path);
+    return new Uint8Array(Buffer.from(data, "utf8"));
+  }
+  return new Uint8Array(Buffer.from(spec, "utf8"));
+}
+function emitError(io2, body) {
+  io2.stderr(JSON.stringify(body) + "\n");
+}
+async function tryReadManifest(io2) {
+  try {
+    const raw = await io2.readFile(ANTPATH_INDEX_PATH);
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// dist/host/template.js
+import { resolve as resolvePath } from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadTemplate(io2, filePath, variables) {
+  const absPath = resolvePath(io2.cwd(), filePath);
+  const lower = absPath.toLowerCase();
+  if (lower.endsWith(".json")) {
+    const text = await io2.readFile(absPath);
+    const parsed = JSON.parse(text);
+    return { resolved: ensureResolved(parsed, variables) };
+  }
+  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".ts")) {
+    const mod = await import(pathToFileURL(absPath).href);
+    if (!mod.default) {
+      throw new Error(`template module ${filePath} must export a default TemplateDefinition`);
+    }
+    return { resolved: ensureResolved(mod.default, variables) };
+  }
+  throw new Error(`unsupported template extension: ${filePath}. Use .json, .js, .mjs, or .ts.`);
+}
+function ensureResolved(value, variables) {
+  if (!value || typeof value !== "object") {
+    throw new Error("template must be an object");
+  }
+  const obj = value;
+  if (typeof obj.hash === "string" && obj.hash.length > 0) {
+    return value;
+  }
+  return compileTemplate(value, variables);
+}
+
+// dist/host/run-cmd.js
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "terminated",
+  "cancelled",
+  "canceled",
+  "cleaned_up"
+]);
+async function runRunCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "run"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  let rest = common.rest;
+  const anthropicKey = takeFlagValue(rest, "--anthropic-api-key");
+  if (anthropicKey.error) {
+    io2.stderr(`${anthropicKey.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = anthropicKey.remaining;
+  if (!anthropicKey.value) {
+    io2.stderr("--anthropic-api-key is required (the platform does not store provider keys on your behalf)\n");
+    return USAGE_ERR;
+  }
+  const idempotency = takeFlagValue(rest, "--idempotency-key");
+  if (idempotency.error) {
+    io2.stderr(`${idempotency.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = idempotency.remaining;
+  const cleanup = takeFlagValue(rest, "--cleanup");
+  if (cleanup.error) {
+    io2.stderr(`${cleanup.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = cleanup.remaining;
+  if (cleanup.value && cleanup.value !== "retain" && cleanup.value !== "delete") {
+    io2.stderr("--cleanup must be one of: retain, delete\n");
+    return USAGE_ERR;
+  }
+  const follow = takeBooleanFlag(rest, "--follow");
+  rest = follow.remaining;
+  const variables = collectRepeatedKv(rest, "--var");
+  if (variables.error) {
+    io2.stderr(`${variables.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = variables.remaining;
+  const mcpServerEntries = collectRepeated(rest, "--mcp-server");
+  if (mcpServerEntries.error) {
+    io2.stderr(`${mcpServerEntries.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = mcpServerEntries.remaining;
+  const skillEntries = collectRepeated(rest, "--skill");
+  if (skillEntries.error) {
+    io2.stderr(`${skillEntries.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = skillEntries.remaining;
+  const proxyEndpointEntries = collectRepeated(rest, "--proxy-endpoint");
+  if (proxyEndpointEntries.error) {
+    io2.stderr(`${proxyEndpointEntries.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = proxyEndpointEntries.remaining;
+  const proxyAuthEntries = collectRepeatedKv(rest, "--proxy-auth");
+  if (proxyAuthEntries.error) {
+    io2.stderr(`${proxyAuthEntries.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = proxyAuthEntries.remaining;
+  const positional = rest.filter((a) => !a.startsWith("--"));
+  const unknownFlags = rest.filter((a) => a.startsWith("--"));
+  if (unknownFlags.length > 0) {
+    io2.stderr(`unknown flag: ${unknownFlags[0]}
+`);
+    return USAGE_ERR;
+  }
+  if (positional.length !== 1) {
+    io2.stderr("usage: antpath run <template-path> [flags]\n");
+    return USAGE_ERR;
+  }
+  const templatePath = positional[0];
+  let resolved;
+  try {
+    const load = await loadTemplate(io2, templatePath, variables.entries);
+    resolved = load.resolved;
+  } catch (err) {
+    io2.stderr(`failed to load template: ${err.message}
+`);
+    return USAGE_ERR;
+  }
+  let mcpServers;
+  try {
+    mcpServers = mcpServerEntries.values.map((raw, i) => parseJsonOrThrow(raw, `--mcp-server[${i}]`));
+  } catch (err) {
+    io2.stderr(`${err.message}
+`);
+    return USAGE_ERR;
+  }
+  let skills;
+  try {
+    skills = skillEntries.values.map((raw, i) => parseSkillFlag(raw, i));
+  } catch (err) {
+    io2.stderr(`${err.message}
+`);
+    return USAGE_ERR;
+  }
+  let proxyEndpoints;
+  try {
+    proxyEndpoints = proxyEndpointEntries.values.map((raw, i) => parseJsonOrThrow(raw, `--proxy-endpoint[${i}]`));
+  } catch (err) {
+    io2.stderr(`${err.message}
+`);
+    return USAGE_ERR;
+  }
+  const proxyAuth = [];
+  for (const [name, spec] of Object.entries(proxyAuthEntries.entries)) {
+    const parsed = parseProxyAuth(spec);
+    if (!parsed.ok) {
+      io2.stderr(`--proxy-auth ${name}: ${parsed.reason}
+`);
+      return USAGE_ERR;
+    }
+    proxyAuth.push({ name, value: parsed.value });
+  }
+  if (proxyEndpoints.length > 0) {
+    try {
+      validateProxyAuth(proxyEndpoints, proxyAuth);
+    } catch (err) {
+      io2.stderr(`proxy auth validation failed: ${err.message}
+`);
+      return USAGE_ERR;
+    }
+  }
+  const secrets = {
+    anthropic: { apiKey: anthropicKey.value },
+    ...mcpServers.length ? { mcpServers } : {},
+    ...skills.length ? { skills } : {},
+    ...proxyAuth.length ? { proxyEndpointAuth: proxyAuth } : {}
+  };
+  const submission = {
+    workspaceId: common.flags.workspaceId,
+    idempotencyKey: idempotency.value ?? generateIdempotencyKey(),
+    template: toPlatformSubmissionTemplate(resolved),
+    secrets,
+    ...cleanup.value ? { cleanup: { session: cleanup.value } } : {},
+    ...proxyEndpoints.length ? { proxyEndpoints } : {}
+  };
+  const http = makeHttpClient(io2, common.flags);
+  let run;
+  try {
+    run = await operations_exports.submitRun(http, submission);
+  } catch (err) {
+    return emitJsonError(io2, "submit_failed", err.message ?? "submission failed");
+  }
+  io2.stdout(JSON.stringify(run) + "\n");
+  if (!follow.present)
+    return SUCCESS;
+  let emittedEventCount = 0;
+  let currentStatus = run.status;
+  while (!TERMINAL_STATUSES.has(currentStatus)) {
+    await sleep(2e3);
+    try {
+      const events = await operations_exports.listRunEvents(http, common.flags.workspaceId, run.id);
+      for (let i = emittedEventCount; i < events.length; i++) {
+        io2.stdout(JSON.stringify(events[i]) + "\n");
+      }
+      emittedEventCount = events.length;
+    } catch (err) {
+      io2.stderr(`(transient) event poll failed: ${err.message}
+`);
+    }
+    try {
+      const updated = await operations_exports.getRun(http, common.flags.workspaceId, run.id);
+      currentStatus = updated.status;
+    } catch (err) {
+      io2.stderr(`(transient) status poll failed: ${err.message}
+`);
+    }
+  }
+  try {
+    const final = await operations_exports.getRun(http, common.flags.workspaceId, run.id);
+    io2.stdout(JSON.stringify(final) + "\n");
+    return final.status === "succeeded" ? SUCCESS : RUNTIME_ERR;
+  } catch (err) {
+    io2.stderr(`final status fetch failed: ${err.message}
+`);
+    return RUNTIME_ERR;
+  }
+}
+function parseProxyAuth(spec) {
+  const idx = spec.indexOf(":");
+  if (idx <= 0) {
+    return { ok: false, reason: `expected '<type>:<value>' (got: ${spec})` };
+  }
+  const type = spec.slice(0, idx);
+  const rest = spec.slice(idx + 1);
+  switch (type) {
+    case "bearer":
+      if (!rest)
+        return { ok: false, reason: "bearer requires a token value" };
+      return { ok: true, value: { type: "bearer", token: rest } };
+    case "header":
+      if (!rest)
+        return { ok: false, reason: "header requires a value" };
+      return { ok: true, value: { type: "header", value: rest } };
+    case "query":
+      if (!rest)
+        return { ok: false, reason: "query requires a value" };
+      return { ok: true, value: { type: "query", value: rest } };
+    case "basic": {
+      const sep = rest.indexOf(":");
+      if (sep <= 0 || sep >= rest.length - 1) {
+        return { ok: false, reason: "basic requires <username>:<password>" };
+      }
+      return {
+        ok: true,
+        value: { type: "basic", username: rest.slice(0, sep), password: rest.slice(sep + 1) }
+      };
+    }
+    default:
+      return { ok: false, reason: `unknown auth type '${type}' (expected bearer|basic|header|query)` };
+  }
+}
+function parseSkillFlag(raw, idx) {
+  if (raw.trim().startsWith("{")) {
+    return parseJsonOrThrow(raw, `--skill[${idx}]`);
+  }
+  const sep = raw.indexOf(":");
+  if (sep === -1) {
+    return { skillId: raw };
+  }
+  const skillId = raw.slice(0, sep);
+  const version = raw.slice(sep + 1);
+  if (!skillId || !version) {
+    throw new Error(`--skill[${idx}] must be 'skillId' or 'skillId:version' (got: ${raw})`);
+  }
+  return { skillId, version };
+}
+function parseJsonOrThrow(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`${label} is not valid JSON: ${err.message}`);
+  }
+}
+function generateIdempotencyKey() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID)
+    return c.randomUUID();
+  return `idem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// dist/host/status.js
+async function runStatusCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "status"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: antpath status <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const run = await operations_exports.getRun(http, common.flags.workspaceId, runId);
+    io2.stdout(JSON.stringify(run) + "\n");
+    return SUCCESS;
+  } catch (err) {
+    return emitJsonError(io2, "status_failed", err.message ?? "status fetch failed", { runId });
+  }
+}
+
+// dist/host/events.js
+var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "terminated",
+  "cancelled",
+  "canceled",
+  "cleaned_up"
+]);
+async function runEventsCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "events"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const followResult = takeBooleanFlag(common.rest, "--follow");
+  const positional = followResult.remaining.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: antpath events <run-id> [--follow] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  if (!followResult.present) {
+    try {
+      const events = await operations_exports.listRunEvents(http, common.flags.workspaceId, runId);
+      for (const event of events) {
+        io2.stdout(JSON.stringify(event) + "\n");
+      }
+      return SUCCESS;
+    } catch (err) {
+      return emitJsonError(io2, "events_failed", err.message ?? "event fetch failed", { runId });
+    }
+  }
+  let emittedCount = 0;
+  while (true) {
+    let events;
+    try {
+      events = await operations_exports.listRunEvents(http, common.flags.workspaceId, runId);
+    } catch (err) {
+      io2.stderr(`(transient) event poll failed: ${err.message}
+`);
+      await sleep2(2e3);
+      continue;
+    }
+    for (let i = emittedCount; i < events.length; i++) {
+      io2.stdout(JSON.stringify(events[i]) + "\n");
+    }
+    emittedCount = events.length;
+    try {
+      const run = await operations_exports.getRun(http, common.flags.workspaceId, runId);
+      if (TERMINAL_STATUSES2.has(run.status)) {
+        return SUCCESS;
+      }
+    } catch (err) {
+      io2.stderr(`(transient) status poll failed: ${err.message}
+`);
+    }
+    await sleep2(2e3);
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// dist/host/outputs.js
+async function runOutputsCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "outputs"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: antpath outputs <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const outputs = await operations_exports.listOutputs(http, common.flags.workspaceId, runId);
+    for (const out of outputs) {
+      io2.stdout(JSON.stringify(out) + "\n");
+    }
+    return SUCCESS;
+  } catch (err) {
+    return emitJsonError(io2, "outputs_failed", err.message ?? "outputs fetch failed", { runId });
+  }
+}
+
+// dist/host/download.js
+import { resolve as resolvePath2, basename } from "node:path";
+async function runDownloadCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "download"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const outFlag = takeFlagValue(common.rest, "--out");
+  if (outFlag.error) {
+    io2.stderr(`${outFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  const positional = outFlag.remaining.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 2) {
+    io2.stderr("usage: antpath download <run-id> <output-id> [--out path] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const outputId = positional[1];
+  const http = makeHttpClient(io2, common.flags);
+  let link;
+  try {
+    link = await operations_exports.createOutputLink(http, common.flags.workspaceId, runId, outputId);
+  } catch (err) {
+    return emitJsonError(io2, "link_failed", err.message ?? "create link failed", { runId, outputId });
+  }
+  let response;
+  try {
+    response = await io2.fetchImpl(link.url, { method: "GET", redirect: "follow" });
+  } catch (err) {
+    return emitJsonError(io2, "download_failed", `download fetch failed: ${err.message}`, { runId, outputId });
+  }
+  if (!response.ok) {
+    return emitJsonError(io2, "download_failed", `download HTTP ${response.status}`, { runId, outputId });
+  }
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  const destination = resolveDestination(io2, outFlag.value, outputId, link.url);
+  try {
+    await io2.writeFile(destination, buffer);
+  } catch (err) {
+    return emitJsonError(io2, "write_failed", `failed to write output: ${err.message}`, { destination });
+  }
+  io2.stdout(JSON.stringify({ runId, outputId, path: destination, bytes: buffer.byteLength }) + "\n");
+  return SUCCESS;
+}
+function resolveDestination(io2, out, outputId, signedUrl) {
+  if (out) {
+    return resolvePath2(io2.cwd(), out);
+  }
+  let fileName = `${outputId}`;
+  try {
+    const url = new URL(signedUrl);
+    const tail = basename(url.pathname);
+    if (tail)
+      fileName = tail;
+  } catch {
+  }
+  return resolvePath2(io2.cwd(), fileName);
+}
+
+// dist/host/cancel.js
+async function runCancelCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "cancel"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: antpath cancel <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    await operations_exports.cancelRun(http, common.flags.workspaceId, runId);
+    io2.stdout(JSON.stringify({ runId, status: "cancel_requested" }) + "\n");
+    return SUCCESS;
+  } catch (err) {
+    return emitJsonError(io2, "cancel_failed", err.message ?? "cancel failed", { runId });
+  }
+}
+
+// dist/host/delete.js
+async function runDeleteCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "delete"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: antpath delete <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    await operations_exports.deleteRun(http, common.flags.workspaceId, runId);
+    io2.stdout(JSON.stringify({ runId, deleted: true }) + "\n");
+    return SUCCESS;
+  } catch (err) {
+    return emitJsonError(io2, "delete_failed", err.message ?? "delete failed", { runId });
+  }
+}
+
+// dist/host/whoami.js
+async function runWhoamiCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "whoami"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv, { requireWorkspace: false });
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  if (common.rest.length > 0) {
+    io2.stderr(`unexpected arguments: ${common.rest.join(" ")}
+`);
+    return USAGE_ERR;
+  }
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const me = await operations_exports.whoami(http);
+    io2.stdout(JSON.stringify(me) + "\n");
+    return SUCCESS;
+  } catch (err) {
+    return emitJsonError(io2, "whoami_failed", err.message ?? "whoami failed");
+  }
+}
+
+// dist/run.js
+async function runCli(io2) {
+  const args = io2.argv.slice(2);
+  try {
+    const exit = await dispatch(io2, args);
+    io2.exit(exit.code);
+  } catch (err) {
+    const body = { error: "internal_error", message: err.message ?? "unknown error" };
+    io2.stderr(JSON.stringify(body) + "\n");
+    io2.exit(RUNTIME_ERR.code);
+  }
+}
+async function dispatch(io2, args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    return printGlobalHelp(io2);
+  }
+  const sub = args[0];
+  const rest = args.slice(1);
+  switch (sub) {
+    case "proxy":
+      return runProxy(io2, rest);
+    case "run":
+      return runRunCmd(io2, rest);
+    case "status":
+      return runStatusCmd(io2, rest);
+    case "events":
+      return runEventsCmd(io2, rest);
+    case "outputs":
+      return runOutputsCmd(io2, rest);
+    case "download":
+      return runDownloadCmd(io2, rest);
+    case "cancel":
+      return runCancelCmd(io2, rest);
+    case "delete":
+      return runDeleteCmd(io2, rest);
+    case "whoami":
+      return runWhoamiCmd(io2, rest);
+    default:
+      io2.stderr(`unknown subcommand: ${sub}
+`);
+      io2.stderr("run `antpath --help` for usage\n");
+      return USAGE_ERR;
+  }
+}
+async function printGlobalHelp(io2) {
+  const manifest = await tryReadManifest(io2);
+  if (manifest) {
+    io2.stdout("antpath \u2014 in-container CLI for managed run sessions\n\n");
+    io2.stdout("Usage:\n");
+    io2.stdout("  antpath proxy <endpoint-name> [flags]\n");
+    io2.stdout("  antpath proxy --help\n\n");
+    if (manifest.endpoints.length === 0) {
+      io2.stdout("This run declared no proxy endpoints.\n");
+    } else {
+      io2.stdout("Declared proxy endpoints for this run:\n");
+      for (const ep of manifest.endpoints) {
+        io2.stdout(`  \u2022 ${ep.name}  (${ep.allowMethods.join("/")} ${ep.allowPathPrefixes.join(",")}, mode=${ep.responseMode})
+`);
+      }
+    }
+    io2.stdout(`
+Protocol version: ${manifest.protocolVersion}
+`);
+    return SUCCESS;
+  }
+  io2.stdout("antpath \u2014 unified CLI for the antpath platform (mirrors the SDK 1:1)\n\n");
+  io2.stdout("Usage:\n");
+  io2.stdout("  antpath run <template-path> --api-token T --workspace W --dashboard-url U [flags]\n");
+  io2.stdout("  antpath status <run-id> --api-token T --workspace W --dashboard-url U\n");
+  io2.stdout("  antpath events <run-id> [--follow] --api-token T --workspace W --dashboard-url U\n");
+  io2.stdout("  antpath outputs <run-id> --api-token T --workspace W --dashboard-url U\n");
+  io2.stdout("  antpath download <run-id> <output-id> [--out path] --api-token T --workspace W --dashboard-url U\n");
+  io2.stdout("  antpath cancel <run-id> --api-token T --workspace W --dashboard-url U\n");
+  io2.stdout("  antpath delete <run-id> --api-token T --workspace W --dashboard-url U\n");
+  io2.stdout("  antpath whoami --api-token T --dashboard-url U\n");
+  io2.stdout("  antpath --help\n\n");
+  io2.stdout("Required flags on every host subcommand:\n");
+  io2.stdout("  --api-token <token>         Workspace-scoped antpath SDK API token\n");
+  io2.stdout("  --workspace <id-or-slug>    Workspace this call targets (omit for whoami)\n");
+  io2.stdout("  --dashboard-url <url>       Dashboard BFF root, e.g. https://antpath.example.com\n\n");
+  io2.stdout("Submit flags (antpath run):\n");
+  io2.stdout("  --anthropic-api-key <key>   REQUIRED \u2014 provider key (never stored)\n");
+  io2.stdout("  --var name=value            Template variable (repeatable)\n");
+  io2.stdout("  --mcp-server '<json>'       PlatformMcpServerSecret JSON (repeatable)\n");
+  io2.stdout("  --skill <skillId>[:<ver>]   Skill reference (repeatable)\n");
+  io2.stdout("  --proxy-endpoint '<json>'   PlatformProxyEndpoint JSON (repeatable)\n");
+  io2.stdout("  --proxy-auth name=<spec>    bearer:tok | basic:u:p | header:v | query:v (repeatable)\n");
+  io2.stdout("  --cleanup retain|delete     Session cleanup policy\n");
+  io2.stdout("  --idempotency-key <key>     Optional; defaults to a fresh UUID\n");
+  io2.stdout("  --follow                    Poll events to stdout until the run terminates\n\n");
+  io2.stdout("Template formats: .json, .js, .mjs, .ts (default export must be a TemplateDefinition).\n");
+  return SUCCESS;
+}
+
+// dist/cli.js
+var io = {
+  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()
+};
+await runCli(io);