agent-relay 6.0.22 → 6.2.1

package/dist/index.cjs

@@ -18571,7 +18571,7 @@ function createWorkflowRenderer() {
   });
   workflowDone.catch(() => {
   });
-  let setHeader = () => {
+  let setHeader2 = () => {
   };
   let listr = null;
   const pendingAdds = [];
@@ -18583,7 +18583,7 @@ function createWorkflowRenderer() {
       {
         title: import_chalk3.default.dim("Workflow starting..."),
         task: async (_ctx, task) => {
-          setHeader = (text) => {
+          setHeader2 = (text) => {
             task.title = text;
           };
           await workflowDone;
@@ -18611,7 +18611,7 @@ function createWorkflowRenderer() {
   const onEvent = (event) => {
     switch (event.type) {
       case "run:started": {
-        setHeader(import_chalk3.default.dim(`[workflow] run ${event.runId.slice(0, 8)}...`));
+        setHeader2(import_chalk3.default.dim(`[workflow] run ${event.runId.slice(0, 8)}...`));
         break;
       }
       case "step:started": {
@@ -18709,17 +18709,17 @@ function createWorkflowRenderer() {
         break;
       }
       case "run:completed": {
-        setHeader(import_chalk3.default.green("Workflow completed"));
+        setHeader2(import_chalk3.default.green("Workflow completed"));
         resolveWorkflow();
         break;
       }
       case "run:failed": {
-        setHeader(import_chalk3.default.red(`Workflow failed: ${event.error ?? "unknown error"}`));
+        setHeader2(import_chalk3.default.red(`Workflow failed: ${event.error ?? "unknown error"}`));
         rejectWorkflow(new Error(event.error ?? "Workflow failed"));
         break;
       }
       case "run:cancelled": {
-        setHeader(import_chalk3.default.yellow("Workflow cancelled"));
+        setHeader2(import_chalk3.default.yellow("Workflow cancelled"));
         resolveWorkflow();
         break;
       }
@@ -19866,7 +19866,7 @@ async function parseJsonResponse(response) {
       {
         status: response.status,
         responseBody: text,
-        responseHeaders: headersToRecord(response.headers)
+        responseHeaders: headersToRecord2(response.headers)
       }
     );
   }
@@ -19881,7 +19881,7 @@ async function parseJsonResponse(response) {
       {
         status: response.status,
         responseBody: text,
-        responseHeaders: headersToRecord(response.headers),
+        responseHeaders: headersToRecord2(response.headers),
         cause: error51
       }
     );
@@ -19898,7 +19898,7 @@ function joinUrl(baseUrl, path28) {
 function stripLeadingSlash(value) {
   return value.replace(/^\/+/, "");
 }
-function headersToRecord(headers) {
+function headersToRecord2(headers) {
   const record2 = {};
   headers.forEach((value, key) => {
     record2[key] = value;
@@ -34027,7 +34027,7 @@ var require_axios = __commonJS({
       }
       set(header, valueOrRewrite, rewrite) {
         const self2 = this;
-        function setHeader(_value, _header, _rewrite) {
+        function setHeader2(_value, _header, _rewrite) {
           const lHeader = normalizeHeader(_header);
           if (!lHeader) {
             throw new Error("header name must be a non-empty string");
@@ -34037,7 +34037,7 @@ var require_axios = __commonJS({
             self2[key || _header] = normalizeValue(_value);
           }
         }
-        const setHeaders = (headers, _rewrite) => utils$1.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+        const setHeaders = (headers, _rewrite) => utils$1.forEach(headers, (_value, _header) => setHeader2(_value, _header, _rewrite));
         if (utils$1.isPlainObject(header) || header instanceof this.constructor) {
           setHeaders(header, valueOrRewrite);
         } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
@@ -34052,7 +34052,7 @@ var require_axios = __commonJS({
           }
           setHeaders(obj, valueOrRewrite);
         } else {
-          header != null && setHeader(valueOrRewrite, header, rewrite);
+          header != null && setHeader2(valueOrRewrite, header, rewrite);
         }
         return this;
       }
@@ -43732,18 +43732,21 @@ var wrapper_default = import_websocket.default;
 var AgentRelayProtocolError = class extends Error {
   code;
   retryable;
+  status;
   data;
   constructor(payload) {
     super(payload.message);
     this.name = "AgentRelayProtocolError";
     this.code = payload.code;
     this.retryable = payload.retryable ?? false;
+    this.status = payload.status;
     this.data = payload.data;
   }
 };
 var BrokerTransport = class {
   baseUrl;
   apiKey;
+  fetchFn;
   requestTimeoutMs;
   maxBufferSize;
   ws = null;
@@ -43756,6 +43759,7 @@ var BrokerTransport = class {
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.apiKey = options.apiKey;
+    this.fetchFn = options.fetch ?? fetch;
     this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
     this.maxBufferSize = options.maxBufferSize ?? 1e3;
   }
@@ -43767,15 +43771,15 @@ var BrokerTransport = class {
   }
   // ── HTTP ─────────────────────────────────────────────────────────────
   async request(path28, init) {
-    const headers = new Headers(init?.headers);
-    if (!headers.has("Content-Type")) {
-      headers.set("Content-Type", "application/json");
+    const headers = headersToRecord(init?.headers);
+    if (init?.body !== void 0 && !hasHeader(headers, "Content-Type")) {
+      headers["Content-Type"] = "application/json";
     }
     if (this.apiKey) {
-      headers.set("X-API-Key", this.apiKey);
+      setHeader(headers, "X-API-Key", this.apiKey);
     }
     const signal = init?.signal ?? AbortSignal.timeout(this.requestTimeoutMs);
-    const res = await fetch(`${this.baseUrl}${path28}`, { ...init, headers, signal });
+    const res = await this.fetchFn(`${this.baseUrl}${path28}`, { ...init, headers, signal });
     if (!res.ok) {
       let body;
       try {
@@ -43784,11 +43788,29 @@ var BrokerTransport = class {
       }
       throw new AgentRelayProtocolError({
         code: body?.code ?? `http_${res.status}`,
-        message: body?.message ?? body?.error ?? res.statusText,
-        retryable: res.status >= 500
+        message: (body?.message ?? body?.error ?? res.statusText) || `HTTP ${res.status}`,
+        retryable: res.status >= 500,
+        status: res.status,
+        data: body
+      });
+    }
+    if (isEmptySuccessResponse(res)) {
+      return void 0;
+    }
+    const bodyText = await res.text();
+    if (bodyText.length === 0) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(bodyText);
+    } catch {
+      throw new AgentRelayProtocolError({
+        code: "invalid_response",
+        message: "response was not JSON",
+        retryable: false,
+        status: res.status
       });
     }
-    return res.json();
   }
   // ── WebSocket events ─────────────────────────────────────────────────
   connect(sinceSeq) {
@@ -43890,6 +43912,46 @@ var BrokerTransport = class {
     return void 0;
   }
 };
+function headersToRecord(headersInit) {
+  const headers = {};
+  if (!headersInit)
+    return headers;
+  if (headersInit instanceof Headers) {
+    headersInit.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return headers;
+  }
+  if (Array.isArray(headersInit)) {
+    for (const [key, value] of headersInit) {
+      headers[key] = value;
+    }
+    return headers;
+  }
+  for (const [key, value] of Object.entries(headersInit)) {
+    headers[key] = value;
+  }
+  return headers;
+}
+function hasHeader(headers, name) {
+  const lowerName = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lowerName);
+}
+function setHeader(headers, name, value) {
+  const lowerName = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === lowerName && key !== name) {
+      delete headers[key];
+    }
+  }
+  headers[name] = value;
+}
+function isEmptySuccessResponse(res) {
+  if (res.status === 204 || res.status === 205) {
+    return true;
+  }
+  return res.headers.get("content-length")?.trim() === "0";
+}
 
 // packages/sdk/dist/client.js
 var import_node_child_process2 = require("node:child_process");
@@ -44153,6 +44215,7 @@ var AgentRelayClient = class _AgentRelayClient {
     this.transport = new BrokerTransport({
       baseUrl: options.baseUrl,
       apiKey: options.apiKey,
+      fetch: options.fetch,
       requestTimeoutMs: options.requestTimeoutMs
     });
   }
@@ -44318,19 +44381,19 @@ var AgentRelayClient = class _AgentRelayClient {
       body: JSON.stringify({
         name: input.name,
         cli: input.cli,
-        model: input.model,
+        ...input.model !== void 0 ? { model: input.model } : {},
         args: input.args ?? [],
-        task: input.task,
+        ...input.task !== void 0 ? { task: input.task } : {},
         channels: input.channels ?? [],
-        cwd: input.cwd,
-        team: input.team,
-        agentToken: input.agentToken,
-        shadowOf: input.shadowOf,
-        shadowMode: input.shadowMode,
-        continueFrom: input.continueFrom,
-        idleThresholdSecs: input.idleThresholdSecs,
-        restartPolicy: input.restartPolicy,
-        skipRelayPrompt: input.skipRelayPrompt
+        ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
+        ...input.team !== void 0 ? { team: input.team } : {},
+        ...input.agentToken !== void 0 ? { agentToken: input.agentToken } : {},
+        ...input.shadowOf !== void 0 ? { shadowOf: input.shadowOf } : {},
+        ...input.shadowMode !== void 0 ? { shadowMode: input.shadowMode } : {},
+        ...input.continueFrom !== void 0 ? { continueFrom: input.continueFrom } : {},
+        ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
+        ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
+        ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {}
       })
     });
   }
@@ -44344,19 +44407,19 @@ var AgentRelayClient = class _AgentRelayClient {
       body: JSON.stringify({
         name: input.name,
         cli: input.provider,
-        model: input.model,
+        ...input.model !== void 0 ? { model: input.model } : {},
         args: input.args ?? [],
-        task: input.task,
+        ...input.task !== void 0 ? { task: input.task } : {},
         channels: input.channels ?? [],
-        cwd: input.cwd,
-        team: input.team,
-        agentToken: input.agentToken,
-        shadowOf: input.shadowOf,
-        shadowMode: input.shadowMode,
-        continueFrom: input.continueFrom,
-        idleThresholdSecs: input.idleThresholdSecs,
-        restartPolicy: input.restartPolicy,
-        skipRelayPrompt: input.skipRelayPrompt,
+        ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
+        ...input.team !== void 0 ? { team: input.team } : {},
+        ...input.agentToken !== void 0 ? { agentToken: input.agentToken } : {},
+        ...input.shadowOf !== void 0 ? { shadowOf: input.shadowOf } : {},
+        ...input.shadowMode !== void 0 ? { shadowMode: input.shadowMode } : {},
+        ...input.continueFrom !== void 0 ? { continueFrom: input.continueFrom } : {},
+        ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
+        ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
+        ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {},
         transport
       })
     });
@@ -44393,6 +44456,104 @@ var AgentRelayClient = class _AgentRelayClient {
       body: JSON.stringify({ rows, cols })
     });
   }
+  async getInboundDeliveryMode(name) {
+    const result = await this.transport.request(`/api/spawned/${encodeURIComponent(name)}/delivery-mode`);
+    if (result.mode !== "auto_inject" && result.mode !== "manual_flush") {
+      throw new AgentRelayProtocolError({
+        code: "invalid_response",
+        message: "inbound delivery mode response missing valid 'mode'"
+      });
+    }
+    return result.mode;
+  }
+  async setInboundDeliveryMode(name, mode) {
+    const result = await this.transport.request(`/api/spawned/${encodeURIComponent(name)}/delivery-mode`, {
+      method: "PUT",
+      body: JSON.stringify({ mode })
+    });
+    if (result.mode !== "auto_inject" && result.mode !== "manual_flush") {
+      throw new AgentRelayProtocolError({
+        code: "invalid_response",
+        message: "set inbound delivery mode response missing valid 'mode'"
+      });
+    }
+    return {
+      mode: result.mode,
+      flushed: typeof result.flushed === "number" ? result.flushed : 0
+    };
+  }
+  async getPending(name) {
+    const result = await this.transport.request(`/api/spawned/${encodeURIComponent(name)}/pending`);
+    return Array.isArray(result.pending) ? result.pending : [];
+  }
+  async flushPending(name) {
+    const result = await this.transport.request(`/api/spawned/${encodeURIComponent(name)}/flush`, { method: "POST" });
+    return { flushed: typeof result.flushed === "number" ? result.flushed : 0 };
+  }
+  async snapshot(name, format2 = "plain") {
+    return this.transport.request(`/api/spawned/${encodeURIComponent(name)}/snapshot?format=${encodeURIComponent(format2)}`);
+  }
+  subscribeWorkerStream(name, options = {}) {
+    this.connectEvents(options.sinceSeq);
+    return {
+      [Symbol.asyncIterator]: () => {
+        const queue = [];
+        let pending;
+        let done = false;
+        const unsubscribe = this.onEvent((event) => {
+          if (event.kind !== "worker_stream" || event.name !== name || options.stream !== void 0 && event.stream !== options.stream) {
+            return;
+          }
+          if (pending) {
+            const { resolve: resolve4 } = pending;
+            pending = void 0;
+            resolve4({ done: false, value: event.chunk });
+            return;
+          }
+          queue.push(event.chunk);
+        });
+        const close = () => {
+          done = true;
+          unsubscribe();
+          if (pending) {
+            const { resolve: resolve4 } = pending;
+            pending = void 0;
+            resolve4({ done: true, value: void 0 });
+          }
+          return { done: true, value: void 0 };
+        };
+        return {
+          next() {
+            if (queue.length > 0) {
+              return Promise.resolve({ done: false, value: queue.shift() });
+            }
+            if (done) {
+              return Promise.resolve({ done: true, value: void 0 });
+            }
+            return new Promise((resolve4, reject) => {
+              pending = { resolve: resolve4, reject };
+            });
+          },
+          return() {
+            return Promise.resolve(close());
+          },
+          throw(error51) {
+            done = true;
+            unsubscribe();
+            if (pending) {
+              const { reject } = pending;
+              pending = void 0;
+              reject(error51);
+            }
+            return Promise.reject(error51);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+      }
+    };
+  }
   // ── Messaging ──────────────────────────────────────────────────────
   async sendMessage(input) {
     try {
@@ -90242,12 +90403,22 @@ function ensureLocalSdkWorkflowRuntime(startDir, execRunner = import_node_child_
   const workflowsEntry = import_node_path36.default.join(workspace.sdkDir, "dist", "workflows", "index.js");
   if (import_node_fs24.default.existsSync(workflowsEntry))
     return;
-  console.log("[agent-relay] Detected local @agent-relay/sdk workspace without built workflows runtime; building packages/sdk...");
-  execRunner("npm", ["run", "build:sdk"], {
-    cwd: workspace.rootDir,
-    stdio: "inherit",
-    env: process.env
-  });
+  console.log("[agent-relay] Detected local @agent-relay/sdk workspace without built workflows runtime; building SDK workflow dependencies...");
+  const buildCommands = [
+    ["run", "build:config"],
+    ["--prefix", "packages/workflow-types", "run", "build"],
+    ["--prefix", "packages/github-primitive", "run", "build"],
+    ["--prefix", "packages/slack-primitive", "run", "build"],
+    ["--prefix", "packages/cloud", "run", "build"],
+    ["run", "build:sdk"]
+  ];
+  for (const args of buildCommands) {
+    execRunner("npm", args, {
+      cwd: workspace.rootDir,
+      stdio: "inherit",
+      env: process.env
+    });
+  }
   if (!import_node_fs24.default.existsSync(workflowsEntry)) {
     throw new Error(`Local SDK workflows runtime is still missing after build: ${workflowsEntry}`);
   }
@@ -90288,6 +90459,120 @@ function parseTsxStderr(stderr) {
   }
   return null;
 }
+function resolveLocalTypeScriptImport(fromFile, specifier) {
+  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+    return null;
+  }
+  const basePath = specifier.startsWith("/") ? import_node_path36.default.resolve(specifier) : import_node_path36.default.resolve(import_node_path36.default.dirname(fromFile), specifier);
+  const ext = import_node_path36.default.extname(basePath);
+  const candidates = ext === ".js" || ext === ".mjs" || ext === ".cjs" ? [
+    `${basePath.slice(0, -ext.length)}.ts`,
+    `${basePath.slice(0, -ext.length)}.tsx`,
+    `${basePath.slice(0, -ext.length)}.mts`,
+    `${basePath.slice(0, -ext.length)}.cts`,
+    basePath
+  ] : ext ? [basePath] : [
+    `${basePath}.ts`,
+    `${basePath}.tsx`,
+    `${basePath}.mts`,
+    `${basePath}.cts`,
+    import_node_path36.default.join(basePath, "index.ts"),
+    import_node_path36.default.join(basePath, "index.tsx"),
+    import_node_path36.default.join(basePath, "index.mts"),
+    import_node_path36.default.join(basePath, "index.cts")
+  ];
+  for (const candidate of candidates) {
+    if (/\.(?:ts|tsx|mts|cts)$/.test(candidate) && import_node_fs24.default.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function findStaticLocalTypeScriptImports(filePath, source) {
+  const imports = [];
+  const staticImportPattern = /(?:^|[\n;])\s*(?:import\s+(?:type\s+)?(?:[^'"]*?\s+from\s+)?|export\s+(?:type\s+)?[^'"]*?\s+from\s+)['"]([^'"]+)['"]/g;
+  for (const match of source.matchAll(staticImportPattern)) {
+    const resolved = resolveLocalTypeScriptImport(filePath, match[1]);
+    if (resolved) {
+      imports.push(resolved);
+    }
+  }
+  return imports;
+}
+function shouldSkipNodeStripTypesPreflight(filePath, seen = /* @__PURE__ */ new Set(), isEntry = true) {
+  const resolvedPath = import_node_path36.default.resolve(filePath);
+  if (seen.has(resolvedPath)) {
+    return false;
+  }
+  seen.add(resolvedPath);
+  let source;
+  try {
+    source = import_node_fs24.default.readFileSync(resolvedPath, "utf8");
+  } catch {
+    return !isEntry;
+  }
+  if (containsNodeStripTypesUnsupportedSyntax(source)) {
+    return true;
+  }
+  return findStaticLocalTypeScriptImports(resolvedPath, source).some((importPath) => shouldSkipNodeStripTypesPreflight(importPath, seen, false));
+}
+function stripCommentsAndStringsForSyntaxScan(source) {
+  let output = "";
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (char === "/" && next === "/") {
+      output += "  ";
+      index += 1;
+      while (index + 1 < source.length && source[index + 1] !== "\n") {
+        output += " ";
+        index += 1;
+      }
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      output += "  ";
+      index += 1;
+      while (index + 1 < source.length) {
+        index += 1;
+        const current = source[index];
+        output += current === "\n" ? "\n" : " ";
+        if (current === "*" && source[index + 1] === "/") {
+          output += " ";
+          index += 1;
+          break;
+        }
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      output += " ";
+      while (index + 1 < source.length) {
+        index += 1;
+        const current = source[index];
+        output += current === "\n" ? "\n" : " ";
+        if (current === "\\") {
+          if (index + 1 < source.length) {
+            index += 1;
+            output += source[index] === "\n" ? "\n" : " ";
+          }
+          continue;
+        }
+        if (current === quote) {
+          break;
+        }
+      }
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+function containsNodeStripTypesUnsupportedSyntax(source) {
+  const scanSource = stripCommentsAndStringsForSyntaxScan(source);
+  return /(?:^|[;\n{}])\s*(?:export\s+)?(?:const\s+)?enum\s+[A-Za-z_$][\w$]*/.test(scanSource) || /(?:^|[;\n{}])\s*(?:export\s+)?(?:declare\s+)?(?:namespace|module)\s+[A-Za-z_$][\w$]*/.test(scanSource) || /\bconstructor\s*\([^)]*\b(?:public|private|protected|readonly)\s+(?:readonly\s+)?[A-Za-z_$][\w$]*/.test(scanSource) || /(?:^|[;\n{}])\s*import\s+[A-Za-z_$][\w$]*\s*=\s*(?:require\s*\(|[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/.test(scanSource) || /(?:^|[;\n{}])\s*export\s*=\s*/.test(scanSource);
+}
 function formatWorkflowParseError(parsed) {
   const where = parsed.line !== void 0 ? `${parsed.file}:${parsed.line}${parsed.column !== void 0 ? `:${parsed.column}` : ""}` : parsed.file;
   const hints = [];
@@ -90408,6 +90693,10 @@ Run ID: ${runId}`;
       { label: "ts-node", bin: "ts-node", preArgs: [] }
     ];
     for (const { label, bin, preArgs } of runners) {
+      if (bin === "node" && shouldSkipNodeStripTypesPreflight(resolved)) {
+        diag(`runScriptWorkflow: ${label} cannot parse this TypeScript file \u2014 trying next`);
+        continue;
+      }
       diag(`runScriptWorkflow: trying runner ${label}`);
       const result = await spawnRunnerWithStderrCapture(bin, [...preArgs, resolved], childEnv);
       if (result.error) {
@@ -90419,7 +90708,7 @@ Run ID: ${runId}`;
       }
       if (result.status !== 0) {
         if (bin === "node" && result.status === 9) {
-          diag(`runScriptWorkflow: runner ${label} unsupported on this Node (exit 9) \u2014 trying next`);
+          diag(`runScriptWorkflow: runner ${label} cannot handle this TypeScript file \u2014 trying next`);
           continue;
         }
         return augmentErrorWithRunId(wrapRunnerError(label, result));

package/dist/src/cli/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/cli/bootstrap.ts"],"names":[],"mappings":";AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyDpC,eAAO,MAAM,OAAO,QAAsB,CAAC;AAkB3C,eAAO,MAAM,WAAW,oBAAsB,CAAC;AAoL/C,wBAAgB,aAAa,CAAC,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAuBtE;AAaD,wBAAsB,MAAM,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiE5E"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/cli/bootstrap.ts"],"names":[],"mappings":";AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+DpC,eAAO,MAAM,OAAO,QAAsB,CAAC;AAkB3C,eAAO,MAAM,WAAW,oBAAsB,CAAC;AAoL/C,wBAAgB,aAAa,CAAC,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CA+BtE;AA8BD,wBAAsB,MAAM,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CA+F5E"}

package/dist/src/cli/bootstrap.js

@@ -22,6 +22,12 @@ import { registerSwarmCommands } from './commands/swarm.js';
 import { registerConnectCommands } from './commands/connect.js';
 import { registerOnCommands } from './commands/on.js';
 import { registerDlqCommands } from './commands/dlq.js';
+import { registerViewCommands } from './commands/view.js';
+import { registerDriveCommands } from './commands/drive.js';
+import { registerPassthroughCommands } from './commands/passthrough.js';
+import { registerNewCommands } from './commands/new.js';
+import { registerRmCommands } from './commands/rm.js';
+import { parseVerblessAlias, runVerblessAliasDispatch } from './lib/spawn-and-attach.js';
 dotenvConfig({ quiet: true });
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -241,6 +247,14 @@ export function createProgram(options = {}) {
     registerOnCommands(program);
     registerConnectCommands(program);
     registerDlqCommands(program);
+    registerViewCommands(program);
+    registerDriveCommands(program);
+    registerPassthroughCommands(program);
+    // The `run` command (registered by `registerSetupCommands` above) is the
+    // workflow-file runner and is intentionally untouched. The spawn-and-attach
+    // composition lives on `new --attach` — see `src/cli/commands/new.ts`.
+    registerNewCommands(program);
+    registerRmCommands(program);
     return program;
 }
 function maybeRunUpdateCheck(version, argv) {
@@ -253,6 +267,22 @@ function shouldSkipTelemetryInit(argv) {
     const commandName = argv[2];
     return Boolean(commandName && TELEMETRY_MANAGEMENT_COMMANDS.has(commandName));
 }
+/**
+ * Top-level verb names that the verbless `-n NAME CLI` silent alias
+ * must NOT swallow. Built once from the program's leaf+group command
+ * tree so we can't drift if a new verb is added without updating both
+ * places.
+ */
+function collectTopLevelVerbs(program) {
+    const verbs = new Set();
+    for (const command of program.commands) {
+        verbs.add(command.name());
+        for (const alias of command.aliases()) {
+            verbs.add(alias);
+        }
+    }
+    return verbs;
+}
 export async function runCli(argv = process.argv) {
     maybeRunUpdateCheck(VERSION, argv);
     propagateVersionsToChildren();
@@ -266,6 +296,38 @@ export async function runCli(argv = process.argv) {
     const program = createProgram({ name: resolveProgramName(argv) });
     installTelemetryHooks(program);
     installExitHooks();
+    // Bare `-n NAME CLI` shorthand. `agent-relay -n NAME CLI [args...]`
+    // dispatches to `runSpawnAndAttach` with mode='passthrough' and ephemeral=true,
+    // which is equivalent to `agent-relay new NAME CLI --attach --mode passthrough --ephemeral`.
+    // Detected here BEFORE commander parses so the shorthand routes
+    // identically to the verbose form. See `parseVerblessAlias` in
+    // `lib/spawn-and-attach.ts`.
+    const knownVerbs = collectTopLevelVerbs(program);
+    const aliasMatch = parseVerblessAlias(argv.slice(2), knownVerbs);
+    if (aliasMatch) {
+        try {
+            const code = await runVerblessAliasDispatch(aliasMatch);
+            try {
+                await shutdownTelemetry();
+            }
+            catch {
+                // Never let telemetry shutdown mask the real exit code.
+            }
+            if (code !== 0) {
+                process.exit(code);
+            }
+            return program;
+        }
+        catch (err) {
+            try {
+                await shutdownTelemetry();
+            }
+            catch {
+                // ignore
+            }
+            throw err;
+        }
+    }
     try {
         await program.parseAsync(argv);
     }