@swmansion/argent 0.26.1-next.9 → 0.27.1-next.0

package/dist/cli-cmds.mjs

@@ -1675,7 +1675,9 @@ function spawnToolsServer(paths, port, options = {}) {
     } catch {
       logFd = fs.openSync("/dev/null", "w");
     }
-    const child = spawn("node", [paths.bundlePath, "start"], {
+    const { bun, deno, electron } = process.versions;
+    const nodeBin = !(bun || deno || electron) && fs.existsSync(process.execPath) ? process.execPath : "node";
+    const child = spawn(nodeBin, [paths.bundlePath, "start"], {
       detached: true,
       stdio: ["ignore", "pipe", logFd],
       env: buildToolsServerEnv(paths, port, process.env, options)
@@ -1683,7 +1685,14 @@ function spawnToolsServer(paths, port, options = {}) {
     child.unref();
     const pid = child.pid;
     if (!pid) {
-      reject(new Error("Failed to get PID of spawned tools server"));
+      child.once(
+        "error",
+        (err) => reject(
+          new Error(
+            err.code === "ENOENT" && nodeBin === "node" ? "Could not start the argent tool-server: `node` was not found on PATH. Install Node.js 20+ or add it to PATH." : `Could not start the argent tool-server: ${err.message}`
+          )
+        )
+      );
       return;
     }
     let settled = false;
@@ -1847,14 +1856,20 @@ async function terminatePid(pid, stillOurs) {
 }
 async function killToolServer(bundlePath) {
   const state2 = await readState(bundlePath);
-  if (!state2) return;
-  await terminatePid(state2.pid);
+  if (!state2) return false;
+  const stillOurs = () => couldBeOurToolServer(state2.pid, state2.bundlePath);
+  const alive = isProcessAlive(state2.pid);
+  if (alive && !stillOurs()) return false;
+  if (alive) await terminatePid(state2.pid, stillOurs);
   await clearToolsServerState(bundlePath ?? state2.bundlePath);
+  return alive;
 }
 var PS_BIN = ["/bin/ps", "/usr/bin/ps"].find((p) => fs.existsSync(p)) ?? "ps";
 var PS_WIDTH_FLAGS = ["-ww"];
-function readProcessCommandLine(pid, flags2 = PS_WIDTH_FLAGS) {
+var PS_LOCALE = process.platform === "darwin" ? "en_US.UTF-8" : "C.UTF-8";
+function readProcessCommandLine(pid, flags2 = PS_WIDTH_FLAGS, env = { ...process.env, LC_ALL: PS_LOCALE }) {
   return execFileSync(PS_BIN, [...flags2, "-p", String(pid), "-o", "command="], {
+    env,
     encoding: "utf8",
     timeout: 2e3,
     // A recycled pid can sit on a process with an argv past Node's 1 MiB exec
@@ -1869,19 +1884,27 @@ function readProcessCommandLine(pid, flags2 = PS_WIDTH_FLAGS) {
 function couldBeOurToolServer(pid, marker) {
   if (!marker) return false;
   if (process.platform === "win32") return true;
-  let cmd;
-  try {
-    cmd = readProcessCommandLine(pid);
-  } catch (err) {
+  const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const ours = new RegExp(`(?:^|[\\t\\n\\v\\f\\r ])${escaped} start(?:[\\t\\n\\v\\f\\r ]|$)`);
+  const nonAscii = [...marker].some((c2) => c2.charCodeAt(0) > 127);
+  let failure;
+  for (const env of [void 0, process.env]) {
+    try {
+      if (ours.test(readProcessCommandLine(pid, PS_WIDTH_FLAGS, env))) return true;
+      failure = void 0;
+      if (!nonAscii) break;
+    } catch (err) {
+      failure = String(err);
+      if (err.code === "ETIMEDOUT") break;
+    }
+  }
+  if (failure !== void 0) {
     process.stderr.write(
-      `[launcher] ps could not read pid ${pid}'s command line; leaving it alone: ${String(err)}
+      `[launcher] ps could not read pid ${pid}'s command line; leaving it alone: ${failure}
 `
     );
-    return false;
   }
-  if (!cmd) return false;
-  const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`(?:^|\\s)${escaped} start(?:\\s|$)`).test(cmd);
+  return false;
 }
 var LOCK_WAIT_TIMEOUT_MS = 3e4;
 var LOCK_STALE_MS = 45e3;
@@ -17130,7 +17153,7 @@ function sha256File(filePath) {
     createReadStream(filePath).on("data", (chunk) => hash2.update(chunk)).on("end", () => resolve11(hash2.digest("hex"))).on("error", reject);
   });
 }
-async function uploadTar(tarPath, endpoint) {
+async function uploadTar(tarPath, endpoint, signal) {
   const init2 = {
     method: "POST",
     headers: {
@@ -17138,7 +17161,8 @@ async function uploadTar(tarPath, endpoint) {
       ...endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {}
     },
     body: createReadStream(tarPath),
-    duplex: "half"
+    duplex: "half",
+    signal
   };
   const res = await fetch(`${endpoint.url}/upload`, init2);
   if (!res.ok) {
@@ -17190,7 +17214,7 @@ async function prepareFileInputs(specs, args, opts) {
           );
           tarPath = await tarball(filePath);
           wire.contentHash = await sha256File(tarPath);
-          wire.uploadId = await uploadTar(tarPath, opts.uploadEndpoint);
+          wire.uploadId = await uploadTar(tarPath, opts.uploadEndpoint, opts.signal);
         } finally {
           if (tarPath) await rm2(tarPath, { force: true }).catch(() => {
           });
@@ -17259,7 +17283,7 @@ var ToolInvocationError = class extends Error {
 function authHeaders2(token) {
   return token ? { Authorization: `Bearer ${token}` } : {};
 }
-async function consumeToolStream(body, onProgress) {
+async function consumeToolStream(body, onProgress, signal) {
   let final;
   const handleLine = (line) => {
     if (!line.trim()) return;
@@ -17283,6 +17307,7 @@ async function consumeToolStream(body, onProgress) {
       buffered += decoder.decode(value, { stream: true });
       let newline;
       while ((newline = buffered.indexOf("\n")) !== -1) {
+        signal?.throwIfAborted();
         const line = buffered.slice(0, newline);
         buffered = buffered.slice(newline + 1);
         handleLine(line);
@@ -17295,6 +17320,7 @@ async function consumeToolStream(body, onProgress) {
     });
     throw err;
   }
+  signal?.throwIfAborted();
   if (!final) {
     throw new Error("tool stream ended without a result \u2014 connection lost mid-run?");
   }
@@ -17321,27 +17347,33 @@ function createToolsClient(options = {}) {
     cached3 = await ensureToolsServer(options.paths);
     return cached3;
   }
-  async function fetchTools() {
+  async function fetchTools(opts) {
+    opts?.signal?.throwIfAborted();
     const { url: url2, token } = await baseUrl();
-    const res = await fetch(`${url2}/tools`, { headers: authHeaders2(token) });
+    const res = await fetch(`${url2}/tools`, {
+      headers: authHeaders2(token),
+      signal: opts?.signal
+    });
     if (!res.ok) throw new Error(`GET /tools failed: ${res.status} ${res.statusText}`);
     const json2 = await res.json();
     return json2.tools;
   }
-  async function fetchTool(name) {
-    const tools2 = await fetchTools();
+  async function fetchTool(name, opts) {
+    const tools2 = await fetchTools(opts);
     return tools2.find((t2) => t2.name === name) ?? null;
   }
   async function callTool(name, args, opts) {
+    opts?.signal?.throwIfAborted();
     const { url: url2, token } = await baseUrl();
     let finalArgs = args;
-    const meta3 = await fetchTool(name);
+    const meta3 = await fetchTool(name, { signal: opts?.signal });
     if (meta3?.fileInputs?.length) {
       const { url: routedUrl } = await getResolvedToolsUrl();
       const isRemote = routedUrl !== null;
       finalArgs = await prepareFileInputs(meta3.fileInputs, args ?? {}, {
         includeContent: isRemote,
-        uploadEndpoint: isRemote ? { url: url2, token } : void 0
+        uploadEndpoint: isRemote ? { url: url2, token } : void 0,
+        signal: opts?.signal
       });
     }
     const res = await fetch(`${url2}/tools/${encodeURIComponent(name)}`, {
@@ -17351,13 +17383,17 @@ function createToolsClient(options = {}) {
         ...opts?.onProgress ? { Accept: "application/x-ndjson" } : {},
         ...authHeaders2(token)
       },
-      body: JSON.stringify(finalArgs ?? {})
+      body: JSON.stringify(finalArgs ?? {}),
+      signal: opts?.signal
     });
     const contentType = res.headers.get("content-type") ?? "";
     if (opts?.onProgress && res.ok && res.body && contentType.includes("application/x-ndjson")) {
-      return consumeToolStream(res.body, opts.onProgress);
+      return consumeToolStream(res.body, opts.onProgress, opts.signal);
     }
-    const json2 = await res.json().catch(() => ({}));
+    const json2 = await res.json().catch(() => {
+      opts?.signal?.throwIfAborted();
+      return {};
+    });
     if (!res.ok) {
       throw new ToolInvocationError(errorBodyMessage(json2) ?? `${res.status} ${res.statusText}`, {
         errorCode: json2.error_code,
@@ -17365,6 +17401,7 @@ function createToolsClient(options = {}) {
         issues: Array.isArray(json2.issues) ? json2.issues : void 0
       });
     }
+    opts?.signal?.throwIfAborted();
     const { result: data } = await applyClientFileDirectives(json2.data);
     return { data, note: json2.note };
   }
@@ -18275,7 +18312,8 @@ async function materializeArtifacts(result, ctx) {
             return null;
           }
           const res = await fetchFn(`${ctx.toolsUrl}/artifacts/${value.id}`, {
-            headers: authHeaders3
+            headers: authHeaders3,
+            signal: ctx.signal
           });
           if (!res.ok) return null;
           const data = await readCapped(res, value.size);
@@ -18302,7 +18340,8 @@ async function materializeArtifacts(result, ctx) {
       }
       try {
         const res = await fetchFn(`${ctx.toolsUrl}/artifacts/${value.id}`, {
-          headers: authHeaders3
+          headers: authHeaders3,
+          signal: ctx.signal
         });
         if (!res.ok) return null;
         const data = Buffer.from(await res.arrayBuffer());
@@ -21877,7 +21916,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID5();
 function readCliVersion() {
   if (true) {
-    return "0.26.1-next.9";
+    return "0.27.1-next.0";
   }
   return "0.0.0";
 }
@@ -24188,8 +24227,13 @@ async function stopCmd(paths) {
 Stop one with: kill <pid>`);
     return;
   }
-  await killToolServer(paths?.bundlePath);
-  console.log(`tool-server stopped (pid ${state2.pid}).`);
+  if (await killToolServer(paths?.bundlePath)) {
+    console.log(`tool-server stopped (pid ${state2.pid}).`);
+  } else {
+    console.log(
+      `tool-server: not running (pid ${state2.pid} is gone or not an argent tool-server).`
+    );
+  }
 }
 function logsCmd(follow) {
   if (!fs11.existsSync(LOG_FILE2)) {

package/dist/client.d.ts

@@ -0,0 +1,52 @@
+export interface ArgentTool {
+    name: string;
+    description: string;
+    /** JSON Schema of the tool's arguments. */
+    inputSchema: Record<string, unknown>;
+}
+export interface ArgentToolResult<T = unknown> {
+    /** The tool's result. Artifacts (screenshots, recordings) are local file paths. */
+    data: T;
+    /** Optional advisory note the tool attached to the result. */
+    note?: string;
+}
+export interface CallToolOptions {
+    /** Receive progress events while a long-running tool works. */
+    onProgress?: (event: unknown) => void;
+    /** Stop waiting for the call. It rejects with the signal's reason, not ArgentToolError. */
+    signal?: AbortSignal;
+}
+/** The tool-server rejected or failed a call. */
+export declare class ArgentToolError extends Error {
+    /** Stable failure code, when the server sent one. */
+    readonly code?: string;
+    /** Failure category, e.g. "subprocess", when the server sent one. */
+    readonly kind?: string;
+    /** Schema issues of a rejected argument object; set only on a validation failure. */
+    readonly issues?: readonly unknown[];
+    constructor(message: string, details?: {
+        code?: string;
+        kind?: string;
+        issues?: readonly unknown[];
+    });
+}
+export interface ArgentFlag {
+    name: string;
+    description: string;
+    /** Effective state, as `argent flags` reports it. */
+    enabled: boolean;
+}
+/** Feature flags and their effective state: project overrides global, then the default. */
+export declare function listFlags(): ArgentFlag[];
+export interface ArgentClient {
+    listTools(options?: {
+        signal?: AbortSignal;
+    }): Promise<ArgentTool[]>;
+    callTool<T = unknown>(name: string, args?: Record<string, unknown>, options?: CallToolOptions): Promise<ArgentToolResult<T>>;
+    /**
+     * Stop this install's local tool-server, like `argent server stop`. The next
+     * call starts a fresh one. Resolves false when none was running.
+     */
+    stopServer(): Promise<boolean>;
+}
+export declare function createArgentClient(): ArgentClient;