@swmansion/argent 0.9.0 → 0.10.0

package/dist/mcp-server.mjs

@@ -3225,8 +3225,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path2) {
-      let input = path2;
+    function removeDotSegments(path3) {
+      let input = path3;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3478,8 +3478,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path2, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
+        const [path3, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6886,9 +6886,9 @@ var require_dist = __commonJS({
 });
 
 // ../argent-mcp/src/mcp-server.ts
-import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir3 } from "node:fs/promises";
 import { dirname } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 
 // ../../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process3 from "node:process";
@@ -7133,10 +7133,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path3) {
+  if (!path3)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path3.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7545,11 +7545,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path3, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path3);
     return iss;
   });
 }
@@ -7696,16 +7696,16 @@ function flattenError(error2, mapper = (issue2) => issue2.message) {
 }
 function formatError(error2, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error3, path2 = []) => {
+  const processError = (error3, path3 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path3, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -15457,17 +15457,30 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
-import { mkdir, writeFile, readFile, unlink } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { mkdir, writeFile, readFile, unlink, rename, chmod } from "node:fs/promises";
 var STATE_DIR = path.join(homedir(), ".argent");
 var STATE_FILE = path.join(STATE_DIR, "tool-server.json");
 var LOG_FILE = path.join(STATE_DIR, "tool-server.log");
-function buildToolsServerEnv(paths, port, baseEnv = process.env) {
-  return {
+var AUTH_TOKEN_BYTES = 32;
+var AUTH_TOKEN_ENV = "ARGENT_AUTH_TOKEN";
+var AUTOSPAWN_IDLE_TIMEOUT_MINUTES = 30;
+function buildToolsServerEnv(paths, port, baseEnv = process.env, options = {}) {
+  const env = {
     ...baseEnv,
-    PORT: String(port),
+    ARGENT_PORT: String(port),
     ARGENT_SIMULATOR_SERVER_DIR: paths.simulatorServerDir,
     ARGENT_NATIVE_DEVTOOLS_DIR: paths.nativeDevtoolsDir
   };
+  if (options.host !== void 0) env.ARGENT_HOST = options.host;
+  if (options.idleTimeoutMinutes !== void 0) {
+    env.ARGENT_IDLE_TIMEOUT_MINUTES = String(options.idleTimeoutMinutes);
+  }
+  if (options.token) env[AUTH_TOKEN_ENV] = options.token;
+  return env;
+}
+function generateToken() {
+  return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
 }
 function findFreePort() {
   return new Promise((resolve, reject) => {
@@ -15495,12 +15508,25 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-async function isHealthy(port) {
+function healthCheckHost(host) {
+  if (host === "0.0.0.0" || host === "") return "127.0.0.1";
+  if (host === "::" || host === "::0") return "::1";
+  return host;
+}
+function formatUrl(host, port) {
+  const h = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `http://${h}:${port}`;
+}
+function authHeaders(token) {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, token) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 2e3);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const res = await fetch(`http://127.0.0.1:${port}/tools`, {
-      signal: controller.signal
+    const res = await fetch(`${formatUrl(healthCheckHost(host), port)}/tools`, {
+      signal: controller.signal,
+      headers: authHeaders(token)
     });
     return res.ok;
   } catch {
@@ -15509,7 +15535,7 @@ async function isHealthy(port) {
     clearTimeout(timer);
   }
 }
-function spawnToolsServer(paths, port) {
+function spawnToolsServer(paths, port, options = {}) {
   return new Promise((resolve, reject) => {
     let logFd;
     try {
@@ -15521,7 +15547,7 @@ function spawnToolsServer(paths, port) {
     const child = spawn("node", [paths.bundlePath, "start"], {
       detached: true,
       stdio: ["ignore", "pipe", logFd],
-      env: buildToolsServerEnv(paths, port)
+      env: buildToolsServerEnv(paths, port, process.env, options)
     });
     child.unref();
     const pid = child.pid;
@@ -15537,7 +15563,7 @@ function spawnToolsServer(paths, port) {
     };
     const rl = readline.createInterface({ input: child.stdout });
     rl.on("line", (line) => {
-      const match = line.match(/Tools server listening on http:\/\/127\.0\.0\.1:(\d+)/);
+      const match = line.match(/Tools server listening on http:\/\/.+:(\d+)/);
       if (match) {
         const actualPort = parseInt(match[1], 10);
         rl.close();
@@ -15560,7 +15586,7 @@ function spawnToolsServer(paths, port) {
     rl.on("close", () => clearTimeout(timer));
   });
 }
-async function readState() {
+async function readToolsServerState() {
   try {
     const raw = await readFile(STATE_FILE, "utf8");
     return JSON.parse(raw);
@@ -15568,41 +15594,113 @@ async function readState() {
     return null;
   }
 }
-async function writeState(state) {
+async function writeToolsServerState(state) {
   await mkdir(STATE_DIR, { recursive: true });
-  await writeFile(STATE_FILE, JSON.stringify(state, null, 2) + "\n", "utf8");
+  const tmp = `${STATE_FILE}.${process.pid}.tmp`;
+  try {
+    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", {
+      encoding: "utf8",
+      mode: 384
+    });
+    await chmod(tmp, 384);
+    await rename(tmp, STATE_FILE);
+  } catch (err) {
+    await unlink(tmp).catch(() => {
+    });
+    throw err;
+  }
 }
-async function clearState() {
+async function clearToolsServerState() {
   try {
     await unlink(STATE_FILE);
   } catch {
   }
 }
+var readState = readToolsServerState;
+var writeState = writeToolsServerState;
+var clearState = clearToolsServerState;
 async function ensureToolsServer(paths) {
   const state = await readState();
   if (state) {
     const alive = isProcessAlive(state.pid);
     if (alive) {
-      const healthy = await isHealthy(state.port);
+      const host = state.host ?? "127.0.0.1";
+      const healthy = await isToolsServerHealthy(state.port, host, 2e3, state.token);
       if (healthy) {
-        return `http://127.0.0.1:${state.port}`;
+        return {
+          url: formatUrl(healthCheckHost(host), state.port),
+          token: state.token ?? ""
+        };
       }
     }
     await clearState();
   }
+  const token = generateToken();
   const port = await findFreePort();
-  const { port: actualPort, pid } = await spawnToolsServer(paths, port);
+  const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
+    token,
+    idleTimeoutMinutes: AUTOSPAWN_IDLE_TIMEOUT_MINUTES
+  });
   await writeState({
     port: actualPort,
     pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    bundlePath: paths.bundlePath
+    bundlePath: paths.bundlePath,
+    host: "127.0.0.1",
+    token
   });
-  return `http://127.0.0.1:${actualPort}`;
+  return { url: formatUrl("127.0.0.1", actualPort), token };
+}
+
+// ../argent-tools-client/src/link-config.ts
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2, unlink as unlink2, chmod as chmod2 } from "node:fs/promises";
+var LINK_DIR = path2.join(homedir2(), ".argent");
+var LINK_FILE = path2.join(LINK_DIR, "link.json");
+async function readLinkConfig() {
+  try {
+    const raw = await readFile2(LINK_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.url !== "string" || typeof parsed.host !== "string" || typeof parsed.port !== "number" || typeof parsed.createdAt !== "string") {
+      return null;
+    }
+    return {
+      url: parsed.url,
+      host: parsed.host,
+      port: parsed.port,
+      createdAt: parsed.createdAt,
+      ...typeof parsed.token === "string" ? { token: parsed.token } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+async function getResolvedToolsUrl() {
+  const envUrl = process.env.ARGENT_TOOLS_URL;
+  if (envUrl) {
+    const link2 = await readLinkConfig();
+    const envToken = process.env[AUTH_TOKEN_ENV];
+    return {
+      url: envUrl,
+      source: "env",
+      ...envToken ? { token: envToken } : {},
+      ...link2 ? { shadowedLink: link2 } : {}
+    };
+  }
+  const link = await readLinkConfig();
+  if (link) {
+    return { url: link.url, source: "link", ...link.token ? { token: link.token } : {} };
+  }
+  return { url: null, source: "none" };
+}
+async function isRemoteRouted() {
+  const { url } = await getResolvedToolsUrl();
+  return url !== null;
 }
 
 // ../argent-mcp/src/content.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 async function fetchPngBytes(url) {
   try {
@@ -15652,7 +15750,7 @@ function isScreenshotDiffResult(value) {
 async function screenshotDiffToMcpContent(result) {
   const blocks = [];
   if (typeof result.contextDiffPath === "string") {
-    const buf = await readFile2(result.contextDiffPath);
+    const buf = await readFile3(result.contextDiffPath);
     blocks.push({
       type: "image",
       data: buf.toString("base64"),
@@ -15800,35 +15898,44 @@ async function fetchWithReconnect(getUrl, reconnect, config2) {
 }
 async function startMcpServer(options) {
   let TOOLS_URL;
-  if (process.env.ARGENT_TOOLS_URL) {
-    TOOLS_URL = process.env.ARGENT_TOOLS_URL;
+  let AUTH_TOKEN;
+  const resolved = await getResolvedToolsUrl();
+  if (resolved.url) {
+    TOOLS_URL = resolved.url;
+    AUTH_TOKEN = resolved.token ?? "";
   } else {
     try {
-      TOOLS_URL = await ensureToolsServer(options.paths);
+      const handle = await ensureToolsServer(options.paths);
+      TOOLS_URL = handle.url;
+      AUTH_TOKEN = handle.token;
     } catch (err) {
       process.stderr.write(`[argent] Failed to start tools server: ${err}
 `);
       process.exit(1);
     }
   }
+  function authHeader() {
+    return AUTH_TOKEN ? { Authorization: `Bearer ${AUTH_TOKEN}` } : {};
+  }
   let reconnectPromise = null;
   async function reconnect() {
-    if (process.env.ARGENT_TOOLS_URL) return;
+    if (await isRemoteRouted()) return;
     if (!reconnectPromise) {
-      reconnectPromise = ensureToolsServer(options.paths).then((url) => {
-        TOOLS_URL = url;
+      reconnectPromise = ensureToolsServer(options.paths).then((handle) => {
+        TOOLS_URL = handle.url;
+        AUTH_TOKEN = handle.token;
       }).finally(() => {
         reconnectPromise = null;
       });
     }
     return reconnectPromise;
   }
-  const LOG_FILE2 = process.env.ARGENT_MCP_LOG ?? `${homedir2()}/.argent/mcp-calls.log`;
+  const LOG_FILE2 = process.env.ARGENT_MCP_LOG ?? `${homedir3()}/.argent/mcp-calls.log`;
   let logDirReady = false;
   async function spyLog(entry) {
     try {
       if (!logDirReady) {
-        await mkdir2(dirname(LOG_FILE2), { recursive: true });
+        await mkdir3(dirname(LOG_FILE2), { recursive: true });
         logDirReady = true;
       }
       await appendFile(LOG_FILE2, JSON.stringify(entry) + "\n");
@@ -15836,7 +15943,9 @@ async function startMcpServer(options) {
     }
   }
   async function fetchTools() {
-    const res = await fetchWithReconnect(() => `${TOOLS_URL}/tools`, reconnect);
+    const res = await fetchWithReconnect(() => `${TOOLS_URL}/tools`, reconnect, {
+      init: { headers: authHeader() }
+    });
     const json = await res.json();
     return json.tools;
   }
@@ -15846,7 +15955,7 @@ async function startMcpServer(options) {
     const res = await fetchWithReconnect(() => `${TOOLS_URL}/tools/${name}`, reconnect, {
       init: {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: { "Content-Type": "application/json", ...authHeader() },
         body: JSON.stringify(args ?? {})
       },
       fetchTimeoutMs: meta2?.longRunning ? null : FETCH_TIMEOUT_MS
@@ -15951,14 +16060,17 @@ async function startMcpServer(options) {
     }
   });
   await server.connect(new StdioServerTransport());
-  if (!process.env.ARGENT_TOOLS_URL) {
+  if (!await isRemoteRouted()) {
     const HEALTH_INTERVAL_MS = 3e4;
     const healthInterval = setInterval(async () => {
       try {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), 3e3);
         try {
-          const res = await fetch(`${TOOLS_URL}/tools`, { signal: controller.signal });
+          const res = await fetch(`${TOOLS_URL}/tools`, {
+            signal: controller.signal,
+            headers: authHeader()
+          });
           if (!res.ok) throw new Error(`health check returned ${res.status}`);
         } finally {
           clearTimeout(timer);
@@ -15973,7 +16085,7 @@ async function startMcpServer(options) {
   }
   if (process.env.ARGENT_AUTO_SHUTDOWN === "1") {
     process.stdin.on("close", () => {
-      fetch(`${TOOLS_URL}/shutdown`, { method: "POST" }).catch(() => {
+      fetch(`${TOOLS_URL}/shutdown`, { method: "POST", headers: authHeader() }).catch(() => {
       });
       setTimeout(() => process.exit(0), 5e3);
     });