mixdog 1.4.1 → 1.4.3

package/src/runtime/shared/connector-catalog.mjs

@@ -184,25 +184,28 @@ export function gmailAppPasswordServerInput(name, email, password) {
 }
 
 /** Whether several accounts of catalog connector `entry` can be connected at
- *  once: Gmail (also by app password), Calendar and Drive with the Google
- *  sign-in. Other remote servers keep one (their tokens and URL are shared). */
+ *  once: every catalog connector holds its accounts in one server. */
 export function connectorMultiAccount(entry) {
-  return entry?.backend?.kind === 'oauth' && entry.backend.oauthClient === 'google';
+  return Boolean(entry?.id) && connectorById(entry.id) === entry;
 }
 
-// ── One server per multi-account connector ──────────────────────────────────
-// A multi-account connector is ONE MCP server (`gmail`, `google-calendar`,
-// `google-drive`) holding its accounts:
+// ── One server per connector ────────────────────────────────────────────────
+// A catalog connector is ONE MCP server (`gmail`, `notion`, `postgres`…)
+// holding its accounts:
 //   { type: 'http', url: connectorAccountsUrl(id), connector: id,
-//     accounts: [{ name, url, headers?, oauthClientId? }, …] }
-// Each account keeps the transport it had as a server of its own (the Google
-// sign-in URL its tokens are stored under, or the app-password address and
-// account header), so its keychain entries are untouched. Account names share
-// the server-name space (`gmail`, `gmail-2`…): a name-based call (remove, sign
-// in, sign out) that names an account acts on that account. The server is
-// answered in-process (connectors/connector-accounts-mcp.mjs): one tool set
-// with an `account` argument.
-const ACCOUNT_FIELDS = ['url', 'headers', 'oauthClientId'];
+//     accounts: [{ name, id?, type?, url?, headers?, oauthClientId?, oauthKey?,
+//                  command?, args?, env? }, …] }
+// (`id`: the account's random identity; connectorAccountId)
+// Each account keeps the transport it had as a server of its own (its remote
+// URL and sign-in, its key header, its app-password address, or its local
+// command and environment), so its keychain entries are untouched. A remote
+// sign-in is stored under the account's URL, or under its own `oauthKey` when
+// another account of the connector already signs in at that URL. Account names
+// share the server-name space (`notion`, `notion-2`…): a name-based call
+// (remove, sign in, sign out) that names an account acts on that account. The
+// server is answered in-process (connectors/connector-accounts-mcp.mjs): one
+// tool set with an `account` argument.
+const ACCOUNT_FIELDS = ['type', 'url', 'headers', 'oauthClientId', 'oauthKey', 'command', 'args', 'env'];
 
 /** The reserved (never resolvable) address of connector `id`'s accounts server. */
 export function connectorAccountsUrl(id) {
@@ -211,14 +214,16 @@ export function connectorAccountsUrl(id) {
 
 const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 
-/** The stored accounts of a multi-account connector server, [] for any other
- *  config (a legacy one-account server included). */
+/** The stored accounts of a connector server, [] for any other config (a
+ *  legacy one-account server included). */
 export function connectorAccountsOf(cfg) {
-  if (!isRecord(cfg) || !Array.isArray(cfg.accounts)) return [];
-  if (!connectorMultiAccount(connectorById(connectorOfServer(cfg)))) return [];
+  if (!isRecord(cfg) || !Array.isArray(cfg.accounts) || !connectorOfServer(cfg)) return [];
   return cfg.accounts.filter(
     (account) =>
-      isRecord(account) && typeof account.name === 'string' && account.name && typeof account.url === 'string'
+      isRecord(account) &&
+      typeof account.name === 'string' &&
+      account.name &&
+      (typeof account.url === 'string' || typeof account.command === 'string')
   );
 }
 
@@ -231,6 +236,21 @@ export function connectorAccountServer(cfg, account) {
   return out;
 }
 
+/** `cfg` without what is an account's own connection: the settings of the
+ *  server holding its accounts (timeouts, enabled…). */
+export function connectorServerSettings(cfg) {
+  return Object.fromEntries(Object.entries(cfg).filter(([key]) => key !== 'accounts' && !ACCOUNT_FIELDS.includes(key)));
+}
+
+/** The identity of stored account `account`, which a chosen account is
+ *  remembered by: the random `id` stored with it (given when it is added, or
+ *  on load to one stored without: connector-accounts-mcp.mjs
+ *  ensureConnectorAccountIds). A new account given a removed one's name gets
+ *  a new id; an edit keeps it. '' while it has none (nothing is bound to it). */
+export function connectorAccountId(_cfg, account) {
+  return typeof account?.id === 'string' ? account.id : '';
+}
+
 /** Every account of `cfg` as its one-account server config. */
 export function connectorAccountServers(cfg) {
   return connectorAccountsOf(cfg).map((account) => connectorAccountServer(cfg, account));
@@ -264,33 +284,39 @@ export function withConnectorAccountEnabled(cfg, name, enabled) {
   return connectorAccountsOf(next).some(connectorAccountEnabled) ? next : { ...next, enabled: false };
 }
 
-/** The stored account entry of one-account config `cfg` under `name`. */
+/** The stored account entry of one-account config `cfg` under `name` (an
+ *  http transport is the default and is not stored). */
 export function connectorAccountEntry(name, cfg) {
   const out = { name };
   for (const field of ACCOUNT_FIELDS) if (cfg?.[field] !== undefined) out[field] = cfg[field];
+  if (out.type === 'http') delete out.type;
   return out;
 }
 
 const naturalOrder = (a, b) => a.localeCompare(b, 'en', { numeric: true });
 
+/** What makes an account the same connection as another: its transport
+ *  (URL, sign-in key, headers, command and environment), whatever its name. */
+const connectionOf = (cfg, account) => JSON.stringify({ ...connectorAccountServer(cfg, account), name: '' });
+
 /**
- * Merges every multi-account connector's servers into one server holding the
- * accounts: legacy one-account servers (`gmail`, `gmail-2`…, Calendar and
- * Drive alike) and any second accounts server. The server keeps the name of
- * an existing accounts server, else the connector id when a server has it,
+ * Merges every catalog connector's servers into one server holding the
+ * accounts: legacy one-account servers (`notion`, `notion-2`…, Gmail, Calendar
+ * and Drive alike) and any second accounts server. The server keeps the name
+ * of an existing accounts server, else the connector id when a server has it,
  * else the first name; its other fields come from that server. Accounts keep
  * their names, transports and order (that server's first); a second entry
- * for the same name or app-password address is dropped. The merged server is
- * off only when every merged one was; otherwise the accounts of a merged
- * server that was off stay off (`enabled: false` on the account), and an
- * account's own `enabled: false` is kept. A server left with no switched-on
- * account is off. Idempotent: `merged` is empty when
- * nothing changed. Returns `{ servers, merged: [{ connector, name, from }] }`.
+ * for the same name, app-password address or connection is dropped. The
+ * merged server is off only when every merged one was; otherwise the accounts
+ * of a merged server that was off stay off (`enabled: false` on the account),
+ * and an account's own `enabled: false` is kept. A server left with no
+ * switched-on account is off. Idempotent: `merged` is empty when nothing
+ * changed. Returns `{ servers, merged: [{ connector, name, from }] }`.
  */
 export function mergeConnectorAccountServers(input) {
   const servers = isRecord(input) ? { ...input } : {};
   const merged = [];
-  for (const entry of CONNECTOR_CATALOG.filter(connectorMultiAccount)) {
+  for (const entry of CONNECTOR_CATALOG) {
     const names = Object.keys(servers)
       .filter((name) => isRecord(servers[name]) && connectorOfServer(servers[name]) === entry.id)
       .sort(naturalOrder);
@@ -303,6 +329,7 @@ export function mergeConnectorAccountServers(input) {
     const accounts = [];
     const seenNames = new Set();
     const seenAddresses = new Set();
+    const seenConnections = new Set();
     for (const name of order) {
       const cfg = servers[name];
       const own = Array.isArray(cfg.accounts) ? connectorAccountsOf(cfg) : [connectorAccountEntry(name, cfg)];
@@ -311,21 +338,17 @@ export function mergeConnectorAccountServers(input) {
       const serverOff = !off && cfg.enabled === false;
       for (const account of own) {
         const address = gmailAppPasswordAccount(connectorAccountServer(cfg, account));
-        if (seenNames.has(account.name) || (address && seenAddresses.has(address))) continue;
+        const connection = connectionOf(cfg, account);
+        if (seenNames.has(account.name) || (address && seenAddresses.has(address)) || seenConnections.has(connection)) {
+          continue;
+        }
         seenNames.add(account.name);
         if (address) seenAddresses.add(address);
+        seenConnections.add(connection);
         accounts.push(serverOff ? { ...account, enabled: false } : account);
       }
     }
-    const {
-      type: _type,
-      url: _url,
-      headers: _headers,
-      oauthClientId: _client,
-      accounts: _accounts,
-      enabled: _enabled,
-      ...rest
-    } = servers[target];
+    const { enabled: _enabled, ...rest } = connectorServerSettings(servers[target]);
     for (const name of order) delete servers[name];
     servers[target] = {
       ...rest,
@@ -352,17 +375,12 @@ export function connectorUsesGoogleClient(entry) {
 }
 
 /** The MCP server input that connects catalog entry `entry` under `name`
- *  (oauth / apiKey); `key` fills an apiKey backend; `extraAccount`
- *  makes it one more account of a multi-account connector. */
-export function connectorServerInput(entry, name, key = '', { extraAccount = false } = {}) {
+ *  (oauth / apiKey); `key` fills an apiKey backend. Every account keeps the
+ *  service's real URL; another account at that URL gets its own sign-in key
+ *  (resource-mcp-connector-accounts.mjs). */
+export function connectorServerInput(entry, name, key = '') {
   const { backend } = entry;
-  if (backend.kind === 'oauth') {
-    // Tokens are stored per exact server URL, so another account of the same
-    // connector needs its own URL; the in-process Google servers ignore the query.
-    const url =
-      extraAccount && connectorMultiAccount(entry) ? `${backend.url}?account=${encodeURIComponent(name)}` : backend.url;
-    return { name, type: 'http', url, connector: entry.id };
-  }
+  if (backend.kind === 'oauth') return { name, type: 'http', url: backend.url, connector: entry.id };
   if (backend.kind !== 'apiKey') throw new Error(`${entry.name} is not an MCP connector`);
   const value = String(key || '').trim();
   if (!value) throw new Error(`${entry.name} needs a key`);

package/src/runtime/shared/custom-provider-keys.mjs

@@ -0,0 +1,20 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { getSecret } = require('../../lib/keychain-cjs.cjs');
+
+// A custom provider's additional API keys are keychain secrets beside its
+// primary key (`agent.<id>.apiKey`), one per key id of its roster
+// (provider-accounts.mjs `setCustomProviderKeyIds`). Never config values.
+export function customProviderKeyAccount(providerId, keyId) {
+  return `agent.${providerId}.apiKey.${keyId}`;
+}
+
+/** The stored value of additional key `keyId`, or '' when it is not readable. */
+export function readCustomProviderKey(providerId, keyId) {
+  try {
+    return getSecret(customProviderKeyAccount(providerId, keyId)) || '';
+  } catch {
+    return '';
+  }
+}

package/src/runtime/shared/file-has-data.mjs

@@ -1,14 +1,22 @@
 import { closeSync, openSync, readSync } from 'node:fs';
+import { open } from 'node:fs/promises';
 import { holdsNoData } from './atomic-file.mjs';
 
 const PROBE_BYTES = 4096;
 
+// Only these errno codes mean the path names no file. Every other failure
+// leaves the file present (a scanner's or the running process's lock, EIO, ...):
+// this is an install check on settings and status paths, so it never throws.
+const ABSENT_CODES = new Set(['ENOENT', 'ENOTDIR']);
+const presentDespite = (err) => !ABSENT_CODES.has(err?.code);
+
 /**
  * Install check for a downloaded binary or model: false when `path` is absent
  * or its first bytes hold no data (empty, or NUL-filled by a crash that
  * committed the size but not the bytes). Cheaper than hashing a multi-GB file
  * on every use. A file that exists but cannot be opened right now (locked by a
- * scanner or by the process running it) still counts as present.
+ * scanner or by the process running it) still counts as present, as does any
+ * other failure.
  */
 export function fileHasData(path) {
   let fd;
@@ -17,7 +25,7 @@ export function fileHasData(path) {
     const head = Buffer.alloc(PROBE_BYTES);
     return !holdsNoData(head.subarray(0, readSync(fd, head, 0, PROBE_BYTES, 0)));
   } catch (err) {
-    return err?.code !== 'ENOENT' && err?.code !== 'ENOTDIR';
+    return presentDespite(err);
   } finally {
     if (fd !== undefined) {
       try {
@@ -26,3 +34,19 @@ export function fileHasData(path) {
     }
   }
 }
+
+/** Same verdict as `fileHasData`, without blocking the event loop on the open
+ *  (an antivirus scan of a binary can stall a synchronous open for seconds). */
+export async function fileHasDataAsync(path) {
+  let handle;
+  try {
+    handle = await open(path, 'r');
+    const head = Buffer.alloc(PROBE_BYTES);
+    const { bytesRead } = await handle.read(head, 0, PROBE_BYTES, 0);
+    return !holdsNoData(head.subarray(0, bytesRead));
+  } catch (err) {
+    return presentDespite(err);
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}

package/src/runtime/shared/file-lock.mjs

@@ -1,16 +1,8 @@
-import {
-  linkSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from 'node:fs';
+import { linkSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import {
   link as linkAsync,
   mkdir as mkdirAsync,
+  readdir as readdirAsync,
   readFile as readFileAsync,
   stat as statAsync,
   unlink as unlinkAsync,
@@ -122,9 +114,14 @@ async function runAsync(steps) {
 
 function* readLockOwner(lockPath) {
   try {
-    const parts = String(yield ['read', lockPath])
-      .trim()
-      .split(/\s+/);
+    const text = String(yield ['read', lockPath]).trim();
+    // v1.4.2 pg-spawn.lock wrote `{"pid":N,"startedAt":T}`; an older process
+    // may still hold one, so its pid must count as an owner.
+    if (text.startsWith('{')) {
+      const legacyPid = Number(JSON.parse(text)?.pid);
+      return { pid: Number.isInteger(legacyPid) && legacyPid > 0 ? legacyPid : null, token: null };
+    }
+    const parts = text.split(/\s+/);
     const pid = Number.parseInt(parts[0], 10);
     return {
       pid: Number.isFinite(pid) && pid > 0 ? pid : null,
@@ -384,10 +381,16 @@ function lockStaleMs(opts) {
 // A staged owner record lives for one link call; a process killed between its
 // create and unlink leaves `<lock>.<pid>.<hex>.tmp` behind. Each lock path is
 // swept once per process for staged files older than this whose pid is dead.
+// The sweep is cleanup only — no lock decision depends on it — so it runs
+// beside the acquisition instead of in front of it: listing a crowded
+// directory synchronously blocked every lock taker for seconds. A file it
+// removes belongs to a dead pid and is past any link call, so it cannot race
+// a live acquisition.
 const STAGED_LOCK_FILE_STALE_MS = 60_000;
 const sweptLockPaths = new Set();
 
-export function sweepStagedLockFiles(lockPath, now = Date.now()) {
+/** Resolves with the number of staged files removed; 0 once the path was swept in this process. */
+export async function sweepStagedLockFiles(lockPath, now = Date.now()) {
   if (sweptLockPaths.has(lockPath)) return 0;
   sweptLockPaths.add(lockPath);
   const dir = dirname(lockPath);
@@ -395,7 +398,7 @@ export function sweepStagedLockFiles(lockPath, now = Date.now()) {
   let removed = 0;
   let names;
   try {
-    names = readdirSync(dir);
+    names = await readdirAsync(dir);
   } catch {
     return 0;
   }
@@ -405,9 +408,9 @@ export function sweepStagedLockFiles(lockPath, now = Date.now()) {
     if (!match) continue;
     const path = join(dir, name);
     try {
-      if (now - statSync(path).mtimeMs < STAGED_LOCK_FILE_STALE_MS) continue;
+      if (now - (await statAsync(path)).mtimeMs < STAGED_LOCK_FILE_STALE_MS) continue;
       if (ownerIsLive({ pid: Number(match[1]), token: null })) continue;
-      unlinkSync(path);
+      await unlinkAsync(path);
       removed += 1;
     } catch {
       // Another sweeper or a late unlink got there first.
@@ -421,7 +424,7 @@ function* acquireLock(lockPath, opts, mode, markHeld, timing = null) {
   const staleMs = lockStaleMs(opts);
   const deadline = Date.now() + timeoutMs;
   yield ['mkdirp', dirname(lockPath)];
-  sweepStagedLockFiles(lockPath);
+  void sweepStagedLockFiles(lockPath);
   const waitStartedAt = Date.now();
   let attempt = 0;
   let lastError = null;

package/src/runtime/shared/git-launch.d.mts

@@ -0,0 +1,9 @@
+export function gitCommand(env?: NodeJS.ProcessEnv | null): string;
+export function gitChildEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export function gitChildEnv(env?: null): NodeJS.ProcessEnv | null;
+export function forgetMissingGit(command: string, error: unknown): boolean;
+export function startGit<T>(
+  env: NodeJS.ProcessEnv,
+  start: (command: string, env: NodeJS.ProcessEnv) => Promise<T>,
+  spawnError?: (outcome: T) => unknown
+): Promise<T>;

package/src/runtime/shared/git-launch.mjs

@@ -0,0 +1,213 @@
+// The git executable product code starts, and the environment it starts with.
+//
+// On Windows `git` on PATH is usually Git for Windows' launcher,
+// <root>\cmd\git.exe (or the identical <root>\bin\git.exe). It only prepares
+// the environment and starts <root>\<msystem>\bin\git.exe as a second process,
+// so every git child costs two process creations. When PATH's git is that
+// launcher, children start the real binary directly with the environment the
+// launcher would have built. The steps below follow git-wrapper.c
+// (git-for-windows/MINGW-packages, mingw-w64-git/git-wrapper.c): main()'s
+// `git.exe` branch and setup_environment(top_level_path, full_path=1) plus
+// maybe_read_config(). Anything else — another platform, a scoop shim, MinGit,
+// a git.exe outside such a layout, an ambiguous or incomplete install — keeps
+// plain `git` and the caller's environment, exactly as before.
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { basename, delimiter, dirname, isAbsolute, join } from 'node:path';
+
+// The wrapper's compile-time MSYSTEM, lower-cased, names its binary directory.
+const MSYSTEM_DIRECTORIES = ['mingw64', 'clangarm64', 'mingw32'];
+
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// Windows names are case-insensitive. Of several spellings in one object
+// Node passes the first in sorted order to the child, so that one is read and
+// written.
+function envKey(env, name) {
+  const upper = name.toUpperCase();
+  return (
+    Object.keys(env)
+      .filter((key) => key.toUpperCase() === upper)
+      .sort()[0] ?? name
+  );
+}
+
+function envValue(env, name) {
+  const value = env[envKey(env, name)];
+  return value === undefined || value === null ? undefined : String(value);
+}
+
+// The wrapper's my_path_append: one backslash between the parts.
+function appendPath(list, part) {
+  return list.endsWith('\\') ? `${list}${part}` : `${list}\\${part}`;
+}
+
+// libuv's search for a bare `git` (no directory, no extension): each PATH
+// entry in order, `git.com` before `git.exe`.
+function launcherOnPath(pathValue) {
+  for (const raw of String(pathValue || '').split(delimiter)) {
+    const entry = raw.trim().replace(/^"(.*)"$/, '$1');
+    if (!entry) continue;
+    // A relative entry resolves against each child's cwd; not decidable once.
+    if (!isAbsolute(entry)) return null;
+    if (isFile(join(entry, 'git.com'))) return null;
+    const candidate = join(entry, 'git.exe');
+    if (isFile(candidate)) return candidate;
+  }
+  return null;
+}
+
+// etc\git-bash.config `MSYS=` lines, each prepended to MSYS in file order.
+function readMsysConfig(root) {
+  let text = '';
+  try {
+    text = readFileSync(join(root, 'etc', 'git-bash.config'), 'utf8');
+  } catch {
+    return [];
+  }
+  return text
+    .split('\n')
+    .map((line) => line.replace(/\r$/, ''))
+    .filter((line) => line.startsWith('MSYS='))
+    .map((line) => line.slice(5));
+}
+
+/**
+ * The Git for Windows layout behind PATH's `git`, or null when there is none
+ * to bypass. `{ command, root, msystem, msysConfig }`.
+ */
+export function resolveGitLaunch({ platform = process.platform, pathValue = process.env.PATH } = {}) {
+  if (platform !== 'win32') return null;
+  const found = launcherOnPath(pathValue);
+  if (!found) return null;
+  let launcher;
+  try {
+    // The wrapper locates its install from its own final path.
+    launcher = realpathSync.native(found);
+  } catch {
+    return null;
+  }
+  if (basename(launcher).toLowerCase() !== 'git.exe') return null;
+  const launcherDirectory = dirname(launcher);
+  if (!['cmd', 'bin'].includes(basename(launcherDirectory).toLowerCase())) return null;
+  const root = dirname(launcherDirectory);
+  // The installer and PortableGit ship git-bash.exe; MinGit and other layouts do not.
+  if (!isFile(join(root, 'git-bash.exe')) || !isDirectory(join(root, 'usr', 'bin'))) return null;
+  const installed = MSYSTEM_DIRECTORIES.filter((name) => isFile(join(root, name, 'bin', 'git.exe')));
+  if (installed.length !== 1) return null;
+  const [msystemDirectory] = installed;
+  return {
+    command: join(root, msystemDirectory, 'bin', 'git.exe'),
+    root,
+    msystem: msystemDirectory.toUpperCase(),
+    msysConfig: readMsysConfig(root),
+  };
+}
+
+function isSystemDirectory(path) {
+  const system = join(process.env.SystemRoot || process.env.windir || 'C:\\Windows', 'System32');
+  return path.toLowerCase() === system.toLowerCase();
+}
+
+/** `base` as the launcher would hand it to the real git (setup_environment). */
+export function gitLaunchEnvironment(launch, base) {
+  const env = { ...base };
+  const set = (name, value) => {
+    env[envKey(env, name)] = value;
+  };
+  set('MSYSTEM', launch.msystem);
+  if (envValue(env, 'PLINK_PROTOCOL') === undefined) set('PLINK_PROTOCOL', 'ssh');
+  if (envValue(env, 'HOME') === undefined) {
+    const homePath = envValue(env, 'HOMEPATH');
+    const drive = `${envValue(env, 'HOMEDRIVE') ?? ''}${homePath ?? ''}`;
+    if (homePath !== undefined && !isSystemDirectory(drive) && isDirectory(drive)) set('HOME', drive);
+    else if (envValue(env, 'USERPROFILE') !== undefined) set('HOME', envValue(env, 'USERPROFILE'));
+  }
+  // <root>\<msystem>\bin;<root>\usr\bin;<HOME>\bin; ahead of the inherited PATH.
+  const prefix =
+    `${appendPath(launch.root, `${launch.msystem.toLowerCase()}\\bin`)};` +
+    appendPath(launch.root, 'usr\\bin;') +
+    appendPath(envValue(env, 'HOME') ?? '', 'bin;');
+  set('PATH', `${prefix}${envValue(env, 'PATH') ?? ''}`);
+  for (const msys of launch.msysConfig) {
+    const current = envValue(env, 'MSYS');
+    set('MSYS', current === undefined ? msys : `${msys} ${current}`);
+  }
+  return env;
+}
+
+// PATH value -> its launch (or null), resolved once per PATH: a child is
+// started with the git its own environment's PATH names, as bare `git` is.
+const resolved = new Map();
+function gitLaunch(env) {
+  const pathValue = envValue(env ?? process.env, 'PATH') ?? '';
+  if (!resolved.has(pathValue)) resolved.set(pathValue, resolveGitLaunch({ pathValue }));
+  return resolved.get(pathValue);
+}
+
+/** The program to spawn for git with `env` (null: this process's environment). */
+export function gitCommand(env = null) {
+  return gitLaunch(env)?.command ?? 'git';
+}
+
+/**
+ * The environment for a git child: `env` (null: this process's environment)
+ * with the launcher's additions when {@link gitCommand} bypasses it. Without a
+ * bypass `env` is returned unchanged, null included.
+ */
+export function gitChildEnv(env = null) {
+  const launch = gitLaunch(env);
+  return launch ? gitLaunchEnvironment(launch, env ?? process.env) : env;
+}
+
+/**
+ * Whether a spawn of `command` failed because that resolved binary is gone (an
+ * uninstalled or moved Git). Its resolutions are dropped then, so the next
+ * {@link gitCommand} resolves PATH afresh. ENOENT alone is not enough: a
+ * missing cwd reports it too, with the binary still in place.
+ */
+export function forgetMissingGit(command, error) {
+  if (error?.code !== 'ENOENT' || command === 'git' || isFile(command)) return false;
+  for (const [pathValue, launch] of resolved) if (launch?.command === command) resolved.delete(pathValue);
+  return true;
+}
+
+/**
+ * Starts git as `start(command, childEnv)` and, when that spawn failed only
+ * because the resolved binary is gone, once more with a fresh resolution —
+ * where bare `git` would have found whatever PATH holds now. `start` rejects
+ * with the spawn error, or settles an outcome `spawnError` reads it from.
+ */
+export async function startGit(env, start, spawnError = () => null) {
+  const command = gitCommand(env);
+  let outcome;
+  try {
+    outcome = await start(command, gitChildEnv(env));
+  } catch (error) {
+    if (!forgetMissingGit(command, error)) throw error;
+    return start(gitCommand(env), gitChildEnv(env));
+  }
+  if (!forgetMissingGit(command, spawnError(outcome))) return outcome;
+  return start(gitCommand(env), gitChildEnv(env));
+}
+
+/** {@link startGit} for a synchronous `start` (spawnSync). */
+export function startGitSync(env, start, spawnError = (result) => result?.error) {
+  const command = gitCommand(env);
+  const outcome = start(command, gitChildEnv(env));
+  if (!forgetMissingGit(command, spawnError(outcome))) return outcome;
+  return start(gitCommand(env), gitChildEnv(env));
+}

package/src/runtime/shared/git-runner-worker.mjs

@@ -2,7 +2,8 @@
 // thread, never on the host event loop (run-child.mjs). Each request resolves
 // to { code, stdout, stderr } or an error with the same codes the in-process
 // runner used (ETIMEDOUT, EMAXBUFFER, spawn errors).
+import { startGit } from './git-launch.mjs';
 import { runChild } from './run-child.mjs';
 import { serveWorkerRequests } from './worker-requests.mjs';
 
-serveWorkerRequests((request) => runChild({ ...request, command: 'git' }));
+serveWorkerRequests((request) => startGit(request.env, (command, env) => runChild({ ...request, command, env })));

package/src/runtime/shared/git-runner.mjs

@@ -15,7 +15,12 @@ const requestGit = createWorkerRequestClient(new URL('./git-runner-worker.mjs',
  * timeoutMs (the child is killed), EMAXBUFFER once stdout+stderr exceed
  * maxBytes, or the spawn error itself. `stdoutEncoding: 'base64'` returns the
  * exact stdout bytes base64-encoded instead of decoded as UTF-8.
+ * `waitForExitMs`: a timeout rejects only once the killed child exited (or
+ * after that bound), with `childExited` and `pid` on the error (run-child.mjs).
  */
-export function runGitOffThread(args, { cwd, input = '', env = null, timeoutMs, maxBytes, stdoutEncoding = 'utf8' }) {
-  return requestGit({ args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding });
+export function runGitOffThread(
+  args,
+  { cwd, input = '', env = null, timeoutMs, maxBytes, stdoutEncoding = 'utf8', waitForExitMs = 0 }
+) {
+  return requestGit({ args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding, waitForExitMs });
 }