@xuda.io/ai_module 1.1.5658 → 1.1.5660

package/index_ms.mjs

@@ -69,28 +69,28 @@ export const git_repo_list = async function (...args) {
   return await broker.send_to_queue("git_repo_list", ...args);
 };
 
-export const xudex_key_set = async function (...args) {
-  return await broker.send_to_queue("xudex_key_set", ...args);
+export const xucode_key_set = async function (...args) {
+  return await broker.send_to_queue("xucode_key_set", ...args);
 };
 
-export const xudex_key_list = async function (...args) {
-  return await broker.send_to_queue("xudex_key_list", ...args);
+export const xucode_key_list = async function (...args) {
+  return await broker.send_to_queue("xucode_key_list", ...args);
 };
 
-export const xudex_key_delete = async function (...args) {
-  return await broker.send_to_queue("xudex_key_delete", ...args);
+export const xucode_key_delete = async function (...args) {
+  return await broker.send_to_queue("xucode_key_delete", ...args);
 };
 
-export const xudex_engine_list = async function (...args) {
-  return await broker.send_to_queue("xudex_engine_list", ...args);
+export const xucode_engine_list = async function (...args) {
+  return await broker.send_to_queue("xucode_engine_list", ...args);
 };
 
 export const git_repo_disconnect = async function (...args) {
   return await broker.send_to_queue("git_repo_disconnect", ...args);
 };
 
-export const xudex_run = async function (...args) {
-  return await broker.send_to_queue("xudex_run", ...args);
+export const xucode_run = async function (...args) {
+  return await broker.send_to_queue("xucode_run", ...args);
 };
 
 export const git_repo_status = async function (...args) {

package/index_msa.mjs

@@ -69,28 +69,28 @@ export const git_repo_list =  function (...args) {
    broker.send_to_queue_async("git_repo_list", ...args);
 };
 
-export const xudex_key_set =  function (...args) {
-   broker.send_to_queue_async("xudex_key_set", ...args);
+export const xucode_key_set =  function (...args) {
+   broker.send_to_queue_async("xucode_key_set", ...args);
 };
 
-export const xudex_key_list =  function (...args) {
-   broker.send_to_queue_async("xudex_key_list", ...args);
+export const xucode_key_list =  function (...args) {
+   broker.send_to_queue_async("xucode_key_list", ...args);
 };
 
-export const xudex_key_delete =  function (...args) {
-   broker.send_to_queue_async("xudex_key_delete", ...args);
+export const xucode_key_delete =  function (...args) {
+   broker.send_to_queue_async("xucode_key_delete", ...args);
 };
 
-export const xudex_engine_list =  function (...args) {
-   broker.send_to_queue_async("xudex_engine_list", ...args);
+export const xucode_engine_list =  function (...args) {
+   broker.send_to_queue_async("xucode_engine_list", ...args);
 };
 
 export const git_repo_disconnect =  function (...args) {
    broker.send_to_queue_async("git_repo_disconnect", ...args);
 };
 
-export const xudex_run =  function (...args) {
-   broker.send_to_queue_async("xudex_run", ...args);
+export const xucode_run =  function (...args) {
+   broker.send_to_queue_async("xucode_run", ...args);
 };
 
 export const git_repo_status =  function (...args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.5658",
+  "version": "1.1.5660",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",

package/{xudex_engines.mjs → xucode_engines.mjs}

@@ -1,6 +1,6 @@
-// Xudex engines: the seam between "an agent did some work" and "which CLI did it".
+// Xucode engines: the seam between "an agent did some work" and "which CLI did it".
 //
-// docs/plans/xudex.md 5.1. An engine is four things and no more:
+// docs/plans/xucode.md 5.1. An engine is four things and no more:
 //
 //   1. AUTH            what environment it needs to be allowed to run
 //   2. A LAUNCH        the argv, including how to resume an existing thread
@@ -41,7 +41,7 @@ if (!global._conf) {
   global._conf = (await import(path.join(process.env.XUDA_HOME, 'common', 'load_conf.mjs'))).loadConf();
 }
 
-const engines_conf = () => global._conf.xudex?.engines || {};
+const engines_conf = () => global._conf.xucode?.engines || {};
 
 const num = (...values) => {
   for (const v of values) {
@@ -132,6 +132,48 @@ const codex_adapter = {
     return api_key ? { OPENAI_API_KEY: api_key } : {};
   },
 
+  // Point codex at the region-server proxy instead of the provider, so the machine holds a
+  // run token rather than a key. See xucode_proxy.mjs for why that trade is worth making.
+  //
+  // OPENAI_BASE_URL DOES NOT WORK for this, which is worth stating because it is the obvious
+  // thing to reach for: codex 0.128.0 ignores it outright. Verified against the real binary by
+  // pointing it at a listener that recorded nothing while the turn completed against the live
+  // API. The supported redirect is a custom model_provider, whose `env_key` names the variable
+  // codex puts in the Authorization header, which is exactly the slot our token wants.
+  proxy_launch({ base_url, token, home } = {}) {
+    const config = [
+      '# Written by Xucode for this run. The token below is a run-scoped credential for the',
+      '# Xuda proxy, not a provider key: it is signed, it expires with the run, and it is only',
+      '# accepted by this one endpoint.',
+      'model_provider = "xucode"',
+      '',
+      '# `codex exec` sandboxes to READ-ONLY by default, so without this the agent reads the',
+      '# project, decides on a change, cannot write it, and reports success over an unchanged',
+      '# repository. Verified the hard way: a run that made three model calls and produced no',
+      '# files. workspace-write is the right level rather than a full bypass, because it is also',
+      '# correct when the substrate is the region server itself, where "the machine is the',
+      '# sandbox" is not true.',
+      'sandbox_mode = "workspace-write"',
+      '# Nothing is watching to approve anything: a prompt here is a run that hangs until it',
+      '# times out.',
+      'approval_policy = "never"',
+      '',
+      '[model_providers.xucode]',
+      'name = "Xucode"',
+      `base_url = "${base_url}/v1"`,
+      'env_key = "XUCODE_TOKEN"',
+      'wire_api = "responses"',
+      '',
+    ].join('\n');
+    return {
+      // CODEX_HOME moves the whole config directory, which also guarantees the machine cannot
+      // fall back to a stored auth.json: there is nothing in a fresh home to fall back to.
+      env: { CODEX_HOME: home, XUCODE_TOKEN: token },
+      files: [{ path: `${home}/config.toml`, content: config }],
+      scratch: home,
+    };
+  },
+
   normalize(event) {
     if (!event || typeof event !== 'object') return [];
     switch (event.type) {
@@ -190,6 +232,15 @@ const claude_code_adapter = {
     return api_key ? { ANTHROPIC_API_KEY: api_key } : {};
   },
 
+  // The same seam, for the day BYOK keys move behind the proxy too. Claude Code reads
+  // ANTHROPIC_BASE_URL and takes its credential from ANTHROPIC_AUTH_TOKEN, so no config file
+  // is needed. UNVERIFIED against the real CLI, like the rest of this adapter: nothing routes
+  // through here yet, because a customer's own key on a customer's own machine is not the
+  // problem the proxy was built to solve.
+  proxy_launch({ base_url, token } = {}) {
+    return { env: { ANTHROPIC_BASE_URL: base_url, ANTHROPIC_AUTH_TOKEN: token }, files: [] };
+  },
+
   normalize(event) {
     if (!event || typeof event !== 'object') return [];
     switch (event.type) {
@@ -255,21 +306,37 @@ export const get_engine = function (key) {
 // A BYOK engine with no key is refused HERE, before anything is spawned. The alternative is
 // a run that starts, burns a workspace slot, and dies on a provider 401 that reads to the
 // customer like our failure.
-export const prepare_launch = function ({ engine: engine_key, model, resume_session_id, api_key, sandbox, bypass_sandbox } = {}) {
+export const prepare_launch = function ({ engine: engine_key, model, resume_session_id, api_key, sandbox, bypass_sandbox, proxy = null } = {}) {
   const engine = get_engine(engine_key);
   if (!engine) return { error: 'That engine is not available.' };
-  if (engine.byok && !api_key) {
+  // A proxied launch satisfies the credential requirement without a key being present HERE: the
+  // customer's key stays on the region server and the proxy attaches it. The caller is responsible
+  // for only minting a token once it knows the account actually has a key, which it checks without
+  // reading one.
+  if (engine.byok && !api_key && !proxy) {
     return {
       error: `${engine.label} runs on your own API key. Add an ${engine.provider === 'anthropic' ? 'Anthropic' : engine.provider} API key in settings, then try again.`,
       needs_key: engine.provider,
     };
   }
+
+  // The proxy REPLACES the credential rather than sitting alongside it. Leaving a real key in
+  // the environment as well would defeat the point twice over: the engine would prefer the key
+  // and skip the proxy, and the key would be on the machine anyway.
+  const proxied = proxy && typeof engine.proxy_launch === 'function' ? engine.proxy_launch(proxy) : null;
+
   return {
     engine: engine.key,
     label: engine.label,
     command: engine.command,
     args: engine.build_args({ model, resume_session_id, sandbox, bypass_sandbox }),
-    env: engine.env({ api_key }),
+    env: proxied ? { ...engine.env({}), ...proxied.env } : engine.env({ api_key }),
+    // Files the machine needs before the engine starts. The runner writes them without knowing
+    // what they are, which keeps "codex needs a TOML" from becoming everyone's problem.
+    files: proxied?.files || [],
+    // Where those files went, so the runner can remove them without knowing what they were.
+    scratch_dir: proxied?.scratch || null,
+    proxied: !!proxied,
     resuming: !!resume_session_id,
   };
 };
@@ -310,7 +377,7 @@ export const create_run_state = function () {
         case 'error':
           // Verbatim, per plan 5.2. With BYOK we cannot see the customer's balance or rate
           // limits, so a 429 from their account must read as their provider saying no, not
-          // as Xudex breaking.
+          // as Xucode breaking.
           state.error = event.message;
           break;
         case 'done':

package/{xudex_mirror.mjs → xucode_mirror.mjs}

@@ -1,6 +1,6 @@
-// Xudex git mirror: how a repository reaches a machine we do not fully trust.
+// Xucode git mirror: how a repository reaches a machine we do not fully trust.
 //
-// docs/plans/xudex.md 9.2. UI-226's verified property is that a repository token never leaves the
+// docs/plans/xucode.md 9.2. UI-226's verified property is that a repository token never leaves the
 // region server: it is validated by an authenticated ls-remote before anything is stored, kept on a
 // git_repo doc in the account's project database rather than in xuda_master (which replicates
 // fleet-wide), and handed to git only through GIT_ASKPASS so it never lands in an argv, in
@@ -28,6 +28,7 @@
 // default.
 
 import fs from 'fs';
+import os from 'os';
 import path from 'node:path';
 
 const DEFAULTS = {
@@ -66,7 +67,7 @@ export const create_mirror = function ({ git_exec, du_mb, mirror_root, clone_tim
         await fs.promises.rm(dir, { recursive: true, force: true }).catch(() => {});
         const cloned = await git_exec({ args: ['clone', '--bare', '--no-tags', repo.remote_url, dir], token, timeout_ms: CLONE_TIMEOUT_MS });
         if (cloned.exit_code !== 0) {
-          console.error(`[xudex] mirror clone failed for ${repo._id}: exit ${cloned.exit_code}`);
+          console.error(`[xucode] mirror clone failed for ${repo._id}: exit ${cloned.exit_code}`);
           return { error: 'Xuda could not clone that repository.' };
         }
         // A bare clone carries no fetch refspec, so without this the mirror would never learn about a
@@ -83,7 +84,7 @@ export const create_mirror = function ({ git_exec, du_mb, mirror_root, clone_tim
       const fetched = await git_exec({ cwd: dir, args: ['fetch', '--prune', 'origin'], token, timeout_ms: CLONE_TIMEOUT_MS });
       // A stale mirror still serves a clone, so a failed refresh is a warning rather than an error:
       // the customer gets slightly old code instead of no code, and the next run tries again.
-      if (fetched.exit_code !== 0) console.warn(`[xudex] mirror fetch failed for ${repo._id}: exit ${fetched.exit_code}`);
+      if (fetched.exit_code !== 0) console.warn(`[xucode] mirror fetch failed for ${repo._id}: exit ${fetched.exit_code}`);
       return { dir, created: false, stale: fetched.exit_code !== 0 };
     },
 
@@ -94,7 +95,7 @@ export const create_mirror = function ({ git_exec, du_mb, mirror_root, clone_tim
       await fs.promises.rm(dest, { recursive: true, force: true }).catch(() => {});
       const cloned = await git_exec({ args: ['clone', '--no-tags', from, dest], timeout_ms: CLONE_TIMEOUT_MS });
       if (cloned.exit_code !== 0) {
-        console.error(`[xudex] workspace clone from mirror failed: exit ${cloned.exit_code}`);
+        console.error(`[xucode] workspace clone from mirror failed: exit ${cloned.exit_code}`);
         return { error: 'Xuda could not prepare a working copy for this project.' };
       }
 
@@ -128,7 +129,7 @@ export const create_mirror = function ({ git_exec, du_mb, mirror_root, clone_tim
       if (!has_git) return await this.clone_workspace({ mirror_dir: from, dest, branch, default_branch });
 
       const fetched = await git_exec({ cwd: dest, args: ['fetch', '--prune', 'origin'], timeout_ms: CLONE_TIMEOUT_MS });
-      if (fetched.exit_code !== 0) console.warn(`[xudex] workspace fetch from mirror failed: exit ${fetched.exit_code}`);
+      if (fetched.exit_code !== 0) console.warn(`[xucode] workspace fetch from mirror failed: exit ${fetched.exit_code}`);
 
       if (branch) {
         // Reuse the branch when it is already here rather than resetting onto the remote: a
@@ -153,13 +154,119 @@ export const create_mirror = function ({ git_exec, du_mb, mirror_root, clone_tim
       return { dir: dest, branch: branch || null, base_sha: head.exit_code === 0 ? head.stdout : null, reused: true };
     },
 
+    // ── Getting the repository INTO a workspace that cannot reach the mirror ────────────────
+    // The mirror is a bare repo on the region server's disk. A Xucode machine is a different
+    // computer, keyless by design and reachable only through the Proxmox guest agent, so it cannot
+    // clone from a path it cannot see and must not be handed a key so that it could.
+    //
+    // A git BUNDLE is the answer git already has for this: one file carrying real objects and refs,
+    // clonable and fetchable like any remote, and needing no network path between the two machines.
+    // It crosses as base64 text, which is the only thing the agent channel carries.
+    //
+    // The cost is honest and worth stating: the first hydration of a large repository moves the
+    // whole history as base64 in 60 KB chunks, which is slow. It is correct everywhere today with
+    // no new infrastructure and no credentials on the machine. Making the mirror reachable over the
+    // WireGuard mesh would turn this into a plain clone and is the optimisation, not the design.
+    async hydrate_workspace({ workspace, uid, repo, branch, default_branch }) {
+      const dir = mirror_dir(uid, repo._id);
+      const bundle = path.join(os.tmpdir(), `xucode-${repo._id}-${Date.now()}.bundle`);
+      try {
+        // --all rather than one branch: the workspace needs the default branch to cut from as well
+        // as any branch this chat already has.
+        const made = await git_exec({ cwd: dir, args: ['bundle', 'create', bundle, '--all'], timeout_ms: CLONE_TIMEOUT_MS });
+        if (made.exit_code !== 0) return { error: 'Xuda could not package that repository for the machine.' };
+        const b64 = await fs.promises.readFile(bundle, 'base64');
+
+        // Does the workspace already hold a checkout? A warm machine keeps its working copy between
+        // runs, and that warmth is most of what the paid tiers sell, so this fetches rather than
+        // re-cloning and never touches uncommitted work.
+        const existing = await workspace.exec(['sh', '-c', 'test -d .git && echo yes || echo no'], { timeout_ms: 60000 });
+        const has_repo = (existing.stdout || '').includes('yes');
+
+        await workspace.write_file('.xucode_repo.b64', b64);
+        // GNU base64 decodes with -d, BSD (macOS) with -D and has no --decode. A workspace can be
+        // either: the VM is Linux, a developer running the local substrate is not. Same shape of
+        // trap as setsid in the preview, and it only ever shows up on the machine you are not on.
+        // Read from STDIN, not a positional filename. GNU base64 accepts a path, BSD (macOS) does
+        // not and answers "invalid argument" while still creating the empty output file, so the
+        // failure looks like a corrupt bundle rather than a wrong flag. Redirection works on both,
+        // and so does -d on both, which the -D fallback obscured.
+        const unpack = await workspace.exec(['sh', '-c', 'base64 -d < .xucode_repo.b64 > .xucode_repo.bundle && rm -f .xucode_repo.b64'], { timeout_ms: CLONE_TIMEOUT_MS });
+        if (unpack.exit_code !== 0) return { error: 'Xuda could not unpack that repository on the machine.' };
+
+        if (!has_repo) {
+          // `git clone <bundle> .` refuses a non-empty directory, so init and fetch instead, which
+          // also leaves the bundle as a named remote we control.
+          const init = await workspace.exec(['sh', '-c', 'git init -q . && git remote remove origin 2>/dev/null; git remote add origin .xucode_repo.bundle'], { timeout_ms: 120000 });
+          if (init.exit_code !== 0) return { error: 'Xuda could not prepare a working copy on the machine.' };
+        } else {
+          await workspace.exec(['sh', '-c', 'git remote remove origin 2>/dev/null; git remote add origin .xucode_repo.bundle'], { timeout_ms: 60000 });
+        }
+
+        const fetched = await workspace.exec(['sh', '-c', 'git fetch -q origin "+refs/heads/*:refs/remotes/origin/*"'], { timeout_ms: CLONE_TIMEOUT_MS });
+        if (fetched.exit_code !== 0) {
+          console.error(`[xucode] workspace fetch from bundle failed: ${(fetched.stderr || '').slice(-200)}`);
+          return { error: 'Xuda could not read that repository on the machine.' };
+        }
+
+        if (branch) {
+          // Same contract as everywhere else: the chat owns a branch, the default branch is never
+          // checked out for writing. Reuse the branch when the workspace already has it rather than
+          // resetting onto the remote, or a warm machine loses whatever the last run left dirty.
+          const local = await workspace.exec(['sh', '-c', `git rev-parse --verify refs/heads/${branch}`], { timeout_ms: 60000 });
+          if (local.exit_code === 0) {
+            const co = await workspace.exec(['sh', '-c', `git checkout -q ${branch}`], { timeout_ms: 120000 });
+            if (co.exit_code !== 0) return { error: 'Xuda could not switch to this chat branch on the machine.' };
+          } else {
+            const on_remote = await workspace.exec(['sh', '-c', `git rev-parse --verify refs/remotes/origin/${branch}`], { timeout_ms: 60000 });
+            const from = on_remote.exit_code === 0 ? `origin/${branch}` : `origin/${default_branch}`;
+            const made_branch = await workspace.exec(['sh', '-c', `git checkout -q -B ${branch} ${from} || git checkout -q -B ${branch}`], { timeout_ms: 120000 });
+            if (made_branch.exit_code !== 0) return { error: 'Xuda could not create a branch on the machine.' };
+          }
+        }
+
+        const head = await workspace.exec(['sh', '-c', 'git rev-parse HEAD'], { timeout_ms: 60000 });
+        return { dir: workspace.dir, branch: branch || null, base_sha: (head.stdout || '').trim() || null, reused: has_repo };
+      } finally {
+        await fs.promises.rm(bundle, { force: true }).catch(() => {});
+      }
+    },
+
+    // The return trip. The workspace bundles whatever the run produced, the bundle crosses back as
+    // base64, and the MIRROR fetches from it. Only then does the mirror push upstream, which is the
+    // one authenticated step and it still happens on the region server.
+    async collect_from_workspace({ workspace, uid, repo, branch }) {
+      if (!branch) return { error: 'no branch to collect' };
+      // -w0 is GNU-only, and BSD wraps at 76 columns with no way to turn it off, so the newlines
+      // are stripped afterwards instead. Works on both.
+      const made = await workspace.exec(['sh', '-c', `git bundle create .xucode_out.bundle ${branch} && base64 < .xucode_out.bundle | tr -d '\n'`], { timeout_ms: CLONE_TIMEOUT_MS });
+      if (made.exit_code !== 0) {
+        console.error(`[xucode] could not bundle ${branch} on the machine: ${(made.stderr || '').slice(-200)}`);
+        return { error: 'Xuda could not package your changes.' };
+      }
+      const bundle = path.join(os.tmpdir(), `xucode-in-${repo._id}-${Date.now()}.bundle`);
+      try {
+        await fs.promises.writeFile(bundle, Buffer.from((made.stdout || '').trim(), 'base64'));
+        const dir = mirror_dir(uid, repo._id);
+        const fetched = await git_exec({ cwd: dir, args: ['fetch', bundle, `+refs/heads/${branch}:refs/heads/${branch}`], timeout_ms: CLONE_TIMEOUT_MS });
+        if (fetched.exit_code !== 0) {
+          console.error(`[xucode] mirror could not fetch ${branch} from the workspace bundle: exit ${fetched.exit_code}`);
+          return { error: 'Xuda could not save your changes.' };
+        }
+        return { collected: true, branch };
+      } finally {
+        await fs.promises.rm(bundle, { force: true }).catch(() => {});
+        await workspace.exec(['sh', '-c', 'rm -f .xucode_out.bundle'], { timeout_ms: 60000 }).catch(() => {});
+      }
+    },
+
     // Workspace to mirror. Runs with the workspace's own git, over a path or a VPN url, and never
     // sees a credential.
     async push_from_workspace({ work_dir, mirror_dir: to, branch }) {
       if (!branch) return { error: 'no branch to push' };
       const pushed = await git_exec({ cwd: work_dir, args: ['push', to, `refs/heads/${branch}:refs/heads/${branch}`], timeout_ms: CLONE_TIMEOUT_MS });
       if (pushed.exit_code !== 0) {
-        console.error(`[xudex] workspace push to mirror failed for ${branch}: exit ${pushed.exit_code}`);
+        console.error(`[xucode] workspace push to mirror failed for ${branch}: exit ${pushed.exit_code}`);
         return { error: 'Xuda could not save that branch.' };
       }
       return { pushed: true, branch };
@@ -184,7 +291,7 @@ export const create_mirror = function ({ git_exec, du_mb, mirror_root, clone_tim
         timeout_ms: CLONE_TIMEOUT_MS,
       });
       if (pushed.exit_code !== 0) {
-        console.error(`[xudex] mirror push failed for ${repo._id} ${branch}: exit ${pushed.exit_code}`);
+        console.error(`[xucode] mirror push failed for ${repo._id} ${branch}: exit ${pushed.exit_code}`);
         return { error: 'Xuda could not push that branch to your repository.' };
       }
       return { pushed: true, branch };

package/{xudex_preview.mjs → xucode_preview.mjs}

@@ -1,6 +1,6 @@
-// Xudex preview: the project, actually running.
+// Xucode preview: the project, actually running.
 //
-// docs/plans/xudex.md section 7, and the last gate of the verify loop in section 6. The verify
+// docs/plans/xucode.md section 7, and the last gate of the verify loop in section 6. The verify
 // loop already left the seam open (`runtime_check`); this is what plugs into it.
 //
 // ── Why this is a gate and not a feature ───────────────────────────────────────────────
@@ -27,7 +27,7 @@ if (!global._conf) {
   global._conf = (await import(path.join(process.env.XUDA_HOME, 'common', 'load_conf.mjs'))).loadConf();
 }
 
-const preview_conf = () => global._conf.xudex?.preview || {};
+const preview_conf = () => global._conf.xucode?.preview || {};
 const num = (key, fallback) => Number(preview_conf()[key]) || fallback;
 
 // Where a project's dev server is told to listen. Fixed per project rather than random, so a
@@ -111,8 +111,8 @@ export const extract_errors = function (log, max = num('max_errors', 8)) {
 const shq = (value) => `'${String(value).replace(/'/g, `'\\''`)}'`;
 
 export const create_preview = function ({ conf = preview_conf, now = () => Date.now() } = {}) {
-  const log_path = (project_id) => `/tmp/xudex-preview-${String(project_id).replace(/[^a-zA-Z0-9_-]/g, '')}.log`;
-  const pid_path = (project_id) => `/tmp/xudex-preview-${String(project_id).replace(/[^a-zA-Z0-9_-]/g, '')}.pid`;
+  const log_path = (project_id) => `/tmp/xucode-preview-${String(project_id).replace(/[^a-zA-Z0-9_-]/g, '')}.log`;
+  const pid_path = (project_id) => `/tmp/xucode-preview-${String(project_id).replace(/[^a-zA-Z0-9_-]/g, '')}.pid`;
 
   const is_listening = async function (workspace, port) {
     // Node is guaranteed present (this is a Node project by definition) and curl is not, so the