antpath 0.2.0 → 0.2.1

package/dist/cli.mjs

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+// dist/cli.js
+import { readFile } 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
+};
+
+// dist/internal.js
+var ANTPATH_INDEX_PATH = "/antpath/index.json";
+var ANTPATH_RUN_TOKEN_PATH = "/antpath/run-token";
+
+// dist/run.js
+var SUCCESS = { code: 0 };
+var USAGE_ERR = { code: 2 };
+var RUNTIME_ERR = { code: 1 };
+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 await printGlobalHelp(io2);
+  }
+  const sub = args[0];
+  const rest = args.slice(1);
+  switch (sub) {
+    case "proxy":
+      return await runProxy(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);
+  io2.stdout("antpath \u2014 managed proxy CLI for skill scripts\n\n");
+  io2.stdout("Usage:\n");
+  io2.stdout("  antpath proxy <endpoint-name> [flags]\n");
+  io2.stdout("  antpath --help\n\n");
+  if (manifest) {
+    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}
+`);
+  } else {
+    io2.stdout("(no manifest mounted \u2014 run `antpath proxy --help` for details)\n");
+  }
+  return SUCCESS;
+}
+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;
+}
+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 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/cli.js
+var io = {
+  readFile: (path) => readFile(path, "utf8"),
+  fetchImpl: fetch,
+  stdout: (chunk) => process.stdout.write(chunk),
+  stderr: (chunk) => process.stderr.write(chunk),
+  exit: (code) => process.exit(code),
+  argv: process.argv
+};
+await runCli(io);

package/dist/cli.mjs.sha256

@@ -0,0 +1 @@
+e4adb3ee5b4053a78a8ddaf9cd653fbaf6a0ddf98432411308964c8fd40909f8  cli.mjs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antpath",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "TypeScript SDK for running autonomous Claude Managed Agents sessions.",
   "repository": {
     "type": "git",
@@ -15,6 +15,9 @@
       "import": "./dist/index.js"
     }
   },
+  "bin": {
+    "antpath": "./dist/cli.mjs"
+  },
   "files": [
     "dist",
     "README.md",
@@ -30,7 +33,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "pnpm --filter @antpath/cli run build && tsc -p tsconfig.build.json && node ./scripts/bundle-cli.mjs",
     "lint": "tsc --noEmit",
     "test": "vitest run test/unit",
     "test:unit": "vitest run test/unit",