mixdog 1.4.1 → 1.4.2

package/src/session-runtime/resource-mcp-connector-accounts.mjs

@@ -1,6 +1,7 @@
-// The accounts of a multi-account connector server as the MCP server API
-// edits them: adding one more account (into its server, or a new server
-// holding it) and editing one account's transport, app password or client.
+// The accounts of a connector server as the MCP server API edits them: adding
+// one more account (into its server, or a new server holding it) and editing
+// one account's transport, app password or client.
+import { randomUUID } from 'node:crypto';
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import {
   mergeMcpServerConfig,
@@ -13,15 +14,16 @@ import {
   connectorAccountServers,
   connectorAccountsOf,
   connectorAccountsUrl,
-  connectorById,
   connectorOfServer,
+  connectorServerSettings,
   gmailAppPasswordAccount,
   withConnectorAccountEnabled,
 } from '../runtime/shared/connector-catalog.mjs';
 import { forgetConnectorAccountHealth } from '../runtime/connectors/connector-accounts-mcp.mjs';
-import { accountTarget, mergedServerInput, nameTakenError, oauthUrlOf } from './resource-mcp-servers.mjs';
+import { hasConfiguredMcpAuth } from '../runtime/agent/orchestrator/mcp/client-transport.mjs';
+import { accountTarget, mergedServerInput, nameTakenError, oauthCredentialOf } from './resource-mcp-servers.mjs';
 
-/** The server of multi-account connector `connector` in `servers`, or ''. */
+/** The server of connector `connector` in `servers`, or ''. */
 function connectorServerName(servers, connector) {
   return (
     Object.keys(servers).find(
@@ -36,7 +38,7 @@ function connectorServerName(servers, connector) {
 export const editsServerItself = (target, input) => {
   if (target.serverName !== target.account.name || !clean(input.url)) return false;
   try {
-    return oauthUrlOf({ type: input.type || 'http', url: input.url }) === oauthUrlOf(target.cfg);
+    return oauthCredentialOf({ type: input.type || 'http', url: input.url }) === oauthCredentialOf(target.cfg);
   } catch {
     return false;
   }
@@ -51,12 +53,14 @@ export function createConnectorAccountEdits({
   storeOAuthClientSecret,
   storeGmailAppPassword,
   forgetUnusedGmailAppPassword,
+  forgetStoredSecrets,
   releaseOAuth,
 }) {
-  /** One more account of multi-account connector `connector` (one-account
-   *  config `accountCfg` as normalized from `input`): into its server, or a
-   *  new server named `name` holding it. The same Gmail address again takes
-   *  the new app password. Resolves `{ name, account, status }`. */
+  /** One more account of connector `connector` (one-account config
+   *  `accountCfg` as normalized from `input`): into its server, or a new
+   *  server named `name` holding it. The same Gmail address again takes the
+   *  new app password. `servers` is read under the caller's per-connector
+   *  serialization (resource-mcp-api.mjs). Resolves `{ name, account, status }`. */
   async function addConnectorAccount(servers, connector, name, accountCfg, input) {
     const serverName = connectorServerName(servers, connector);
     const address = gmailAppPasswordAccount(accountCfg);
@@ -77,29 +81,38 @@ export function createConnectorAccountEdits({
     }
     const accountName = serverName ? freeName(servers, name) : name;
     const account = connectorAccountEntry(accountName, accountCfg);
-    // Sign-in tokens are stored per exact URL: another account needs its own.
-    const backendUrl = connectorById(connector)?.backend?.url;
-    if (
-      !address &&
-      cfg &&
-      connectorAccountServers(cfg).some((other) => oauthUrlOf(other) === oauthUrlOf({ type: 'http', url: account.url }))
-    ) {
-      account.url = `${backendUrl}?account=${encodeURIComponent(accountName)}`;
+    // A sign-in is stored per exact URL: another account signing in at the
+    // same URL gets its own key, so the two never share tokens.
+    const asServer = connectorAccountServer({ connector }, account);
+    const signIn = hasConfiguredMcpAuth(asServer) ? null : oauthCredentialOf(asServer);
+    if (signIn && cfg && connectorAccountServers(cfg).some((other) => oauthCredentialOf(other) === signIn)) {
+      account.oauthKey = randomUUID();
     }
     const storedCfg = connectorAccountServer({ connector }, account);
-    await storeOAuthClientSecret(input, storedCfg);
-    await storeGmailAppPassword(input, storedCfg, true);
-    forgetConnectorAccountHealth(accountName);
     let target = serverName;
-    if (cfg) {
-      servers[serverName] = { ...cfg, accounts: [...connectorAccountsOf(cfg), account] };
-    } else {
-      // The server's own settings (timeouts, enabled) ride on the input.
-      const { type: _type, url: _url, headers: _headers, oauthClientId: _client, ...rest } = accountCfg;
-      target = name;
-      servers[name] = { ...rest, type: 'http', url: connectorAccountsUrl(connector), connector, accounts: [account] };
+    // Its secrets and its config land together: a failed step takes back the secrets.
+    try {
+      await storeOAuthClientSecret(input, storedCfg);
+      await storeGmailAppPassword(input, storedCfg, true);
+      if (cfg) {
+        servers[serverName] = { ...cfg, accounts: [...connectorAccountsOf(cfg), account] };
+      } else {
+        // The server's own settings (timeouts, enabled) ride on the input.
+        target = name;
+        servers[name] = {
+          ...connectorServerSettings(accountCfg),
+          type: 'http',
+          url: connectorAccountsUrl(connector),
+          connector,
+          accounts: [account],
+        };
+      }
+      saveServers(servers);
+    } catch (error) {
+      await forgetStoredSecrets(storedCfg);
+      throw error;
     }
-    saveServers(servers);
+    forgetConnectorAccountHealth(accountName);
     const status = await sync.reconnectMcpAndAnnounce({ only: target, enabled: servers[target].enabled !== false });
     return { name: target, account: accountName, status };
   }
@@ -116,7 +129,7 @@ export function createConnectorAccountEdits({
     await storeOAuthClientSecret(input, next, accountCfg);
     await storeGmailAppPassword(input, next, false);
     // Settings that are not the account's transport (timeouts) are the server's.
-    const { type: _type, url: _url, headers: _headers, oauthClientId: _client, ...serverFields } = config;
+    const serverFields = connectorServerSettings(config);
     const server = { ...cfg };
     for (const group of MCP_TIMEOUT_FIELD_GROUPS) {
       if (group.some((field) => Object.hasOwn(serverFields, field))) for (const field of group) delete server[field];

package/src/session-runtime/resource-mcp-secrets.mjs

@@ -6,8 +6,8 @@ import {
   gmailAppPasswordValue,
   connectorAccountServers,
 } from '../runtime/shared/connector-catalog.mjs';
-import { forgetConnectorAccountHealth } from '../runtime/connectors/connector-accounts-mcp.mjs';
-import { oauthUrlOf } from './resource-mcp-servers.mjs';
+import { forgetConnectorAccountHealth, retireConnectorAccount } from '../runtime/connectors/connector-accounts-mcp.mjs';
+import { oauthCredentialOf } from './resource-mcp-servers.mjs';
 
 /** Every config `servers` connects with, a multi-account server's accounts
  *  as the one-account configs they are. */
@@ -44,15 +44,16 @@ export function createMcpServerSecrets({
     }
   };
   // A server's OAuth tokens and client registration go with it, unless another
-  // configured server (plugin or disabled ones included, even with MCP
-  // disabled for this runtime) still uses them through the same exact URL.
-  // `signIn` tells the caller what happened to the sign-in: `removed` (local
-  // secrets deleted, `revoked` when the provider confirmed the revocation
-  // too), `shared` (another server still uses it), or none (null).
+  // configured server or account (plugin or disabled ones included, even with
+  // MCP disabled for this runtime) still uses them through the same exact URL
+  // (or the same account key). `signIn` tells the caller what happened to the
+  // sign-in: `removed` (local secrets deleted, `revoked` when the provider
+  // confirmed the revocation too), `shared` (another server still uses it),
+  // or none (null).
   const releaseOAuth = async (cfg) => {
-    const url = oauthUrlOf(cfg);
-    if (!url) return null;
-    if (expandedConfigs(resolveConfiguredMcpCatalog().servers).some((other) => oauthUrlOf(other) === url)) {
+    const key = oauthCredentialOf(cfg);
+    if (!key) return null;
+    if (expandedConfigs(resolveConfiguredMcpCatalog().servers).some((other) => oauthCredentialOf(other) === key)) {
       return { signIn: 'shared', revoked: false };
     }
     const { revoked = false } = (await clearMcpServerOAuth(cfg, { revoke: true })) || {};
@@ -66,10 +67,19 @@ export function createMcpServerSecrets({
     await gmailAppPassword.forget(account);
     return true;
   };
+  // What storeOAuthClientSecret / storeGmailAppPassword stored for `cfg`, gone
+  // again unless a configured server uses it (an add that was not saved).
+  const forgetStoredSecrets = async (cfg) => {
+    await forgetUnusedGmailAppPassword(gmailAppPasswordAccount(cfg));
+    if (!cfg?.url || !cfg.oauthClientId) return;
+    const servers = expandedConfigs(resolveConfiguredMcpCatalog().servers);
+    if (!servers.some((other) => other.url === cfg.url && other.oauthClientId)) await saveOAuthClientSecret(cfg.url, '');
+  };
   // A removed account keeps no sign-in another configured server or account
   // does not share: `{ signIn, revoked }` as removeMcpServer reports it.
   const releaseAccount = async (accountCfg) => {
     forgetConnectorAccountHealth(accountCfg.name);
+    retireConnectorAccount(accountCfg.connector, accountCfg.name);
     const address = gmailAppPasswordAccount(accountCfg);
     if (address) {
       const forgotten = await forgetUnusedGmailAppPassword(address);
@@ -78,5 +88,12 @@ export function createMcpServerSecrets({
     return releaseOAuth(accountCfg);
   };
 
-  return { storeOAuthClientSecret, storeGmailAppPassword, releaseOAuth, forgetUnusedGmailAppPassword, releaseAccount };
+  return {
+    storeOAuthClientSecret,
+    storeGmailAppPassword,
+    releaseOAuth,
+    forgetUnusedGmailAppPassword,
+    forgetStoredSecrets,
+    releaseAccount,
+  };
 }

package/src/session-runtime/resource-mcp-servers.mjs

@@ -3,7 +3,7 @@
 // name refusals and the merge of a partial server edit.
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { MCP_TIMEOUT_FIELD_GROUPS } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
-import { resolveMcpOAuthUrl } from '../runtime/agent/orchestrator/mcp/client-config.mjs';
+import { resolveMcpOAuthCredentialKey } from '../runtime/agent/orchestrator/mcp/client-config.mjs';
 import {
   connectorAccountServer,
   connectorAccountsOf,
@@ -11,10 +11,11 @@ import {
   connectorOfServer,
 } from '../runtime/shared/connector-catalog.mjs';
 
-/** The URL a server's OAuth credentials are stored under, or null. */
-export function oauthUrlOf(cfg) {
+/** What a server's OAuth credentials are stored under (its URL, or a
+ *  connector account's own key), or null. */
+export function oauthCredentialOf(cfg) {
   try {
-    return resolveMcpOAuthUrl(cfg);
+    return resolveMcpOAuthCredentialKey(cfg);
   } catch {
     // No valid remote URL: such a server never logged in.
     return null;

package/src/session-runtime/services/agent-tool/send-flow.mjs

@@ -1,5 +1,6 @@
 import {
   isAgentProgressWatchdogAbortError,
+  noteStoppedShellJobsOnError,
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
@@ -20,6 +21,7 @@ import { handoffContent } from '../../handoff-attachments.mjs';
 import { rebindDelegation } from '../../../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import { settledWorkerStatus } from './worker-index/row-liveness.mjs';
 import { whileTurnDispatched } from '../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
+import { takeStoppedShellJobs } from '../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 
 function workerResultIdentity({ session, tag, sessionId }) {
   return { tag, sessionId, agent: session.agent || null, provider: session.provider, model: session.model };
@@ -92,7 +94,12 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     // the watchdog sweep re-stamps turnStartedAt at each turn boundary.
     const watchdogPolicy = resolveAgentWatchdogPolicy(
       sendAgent,
-      spawnFlow.agentWatchdogOverrides({ agent: sendAgent, provider: session.provider, model: session.model })
+      spawnFlow.agentWatchdogOverrides({
+        agent: sendAgent,
+        provider: session.provider,
+        model: session.model,
+        ...(session.modelParameters ? { modelParameters: session.modelParameters } : {}),
+      })
     );
     const watchdog = spawnFlow.startProgressIdleWatchdog(sessionId, watchdogPolicy, sendAgent, {
       onTurnStart: spawnFlow.turnStartStamper(session, tag),
@@ -146,7 +153,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         finalStatus = 'idle';
         const value = {
           ...workerResultIdentity({ session, tag, sessionId }),
-          content: watchdogStoppedHandoff(error, partial),
+          content: watchdogStoppedHandoff(error, partial, await takeStoppedShellJobs(sessionId)),
           stallAbort: true,
         };
         if (job) job._terminalResultValue = value;
@@ -154,6 +161,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         return value;
       }
       finalStatus = 'error';
+      noteStoppedShellJobsOnError(error, await takeStoppedShellJobs(sessionId));
       reconcileJobStreamStalled(job, error);
       throw error;
     } finally {

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-prep.mjs

@@ -77,8 +77,8 @@ export function createSpawnPreparer({
    *  first-response deadline and the provider's first-response budget for the
    *  routed model (headers, and first output), handed to
    *  resolveAgentWatchdogPolicy. A provider on the shared window names none. */
-  function agentWatchdogOverrides({ agent, provider, model }) {
-    const budget = getProvider(provider)?.firstResponseBudget?.(model);
+  function agentWatchdogOverrides({ agent, provider, model, modelParameters }) {
+    const budget = getProvider(provider)?.firstResponseBudget?.(model, { modelParameters });
     return {
       firstResponseTimeoutMs: readAgentFirstResponseTimeoutMs(agent, dataDir, STANDALONE_SOURCE_ROOT) ?? undefined,
       providerFirstByteTimeoutMs: budget?.transportMs,
@@ -145,7 +145,12 @@ export function createSpawnPreparer({
       prompt: plan.prompt,
       watchdogPolicy: resolveAgentWatchdogPolicy(
         plan.agent,
-        agentWatchdogOverrides({ agent: plan.agent, provider: plan.preset.provider, model: plan.preset.model })
+        agentWatchdogOverrides({
+          agent: plan.agent,
+          provider: plan.preset.provider,
+          model: plan.preset.model,
+          modelParameters: plan.preset.modelParameters,
+        })
       ),
     };
   }

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-run.mjs

@@ -16,6 +16,7 @@ import { abnormalEmptyFinishError } from '../render.mjs';
 import { createProgressWatchdogRegistry } from '../../agent-watchdog-registry.mjs';
 import {
   isAgentProgressWatchdogAbortError,
+  noteStoppedShellJobsOnError,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
   watchdogPartialHandoffFromError,
@@ -27,6 +28,7 @@ import { presetDescriptor } from './spawn-prep.mjs';
 import { workerStageForStatus } from '../worker-rows.mjs';
 import { handoffContent } from '../../../handoff-attachments.mjs';
 import { whileTurnDispatched } from '../../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
+import { takeStoppedShellJobs } from '../../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 
 // Mid-turn worker persistence cadence. The watchdog sweep runs every second;
 // a transcript save is far more expensive than a bookkeeping stamp, so the
@@ -209,7 +211,7 @@ export function createSpawnRunner({
           tag,
           sessionId: session.id,
           ...presetDescriptor(agent, preset, presetName),
-          content: watchdogStoppedHandoff(error, partial),
+          content: watchdogStoppedHandoff(error, partial, await takeStoppedShellJobs(session.id)),
           stallAbort: true,
         };
         if (job) job._terminalResultValue = value;
@@ -217,6 +219,7 @@ export function createSpawnRunner({
         return value;
       }
       finalStatus = 'error';
+      noteStoppedShellJobsOnError(error, await takeStoppedShellJobs(session.id));
       reconcileJobStreamStalled(job, error);
       throw error;
     } finally {

package/src/session-runtime/services/agent-watchdog-registry.mjs

@@ -2,6 +2,8 @@
 // One shared 1s timer sweeps every watched session, so a burst
 // of agents costs a single interval; the timer stops as soon as the last
 // watchdog is released. Abort policy itself lives in the runtime module.
+import { randomUUID } from 'node:crypto';
+import { armTurnTimeout } from '../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 import {
   abortAgentProgressWatchdog,
   agentWatchdogPolicyActive,
@@ -23,6 +25,13 @@ export function getProgressWatchdogState(mgr, sessionId) {
   };
 }
 
+// This watchdog owns its timeout: arm the session's shell reap before the
+// abort propagates, unless the turn is already stopped (the guard skips it).
+function abortOnTimeout(controller, ctx) {
+  if (!controller?.signal?.aborted && ctx?.error) armTurnTimeout(ctx.sessionId);
+  abortAgentProgressWatchdog(controller, ctx);
+}
+
 export function createProgressWatchdogRegistry({ mgr }) {
   const watched = new Map();
   registrations.set(mgr, watched);
@@ -100,6 +109,15 @@ export function createProgressWatchdogRegistry({ mgr }) {
     const abortErr = snapshot ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy) : null;
     // No progress snapshot: fall back to the coarse last-progress timestamp so a
     // session that never reports structured progress can still stall out.
+    const observe = () => {
+      try {
+        return typeof mgr.getSessionProgressObservation === 'function'
+          ? mgr.getSessionProgressObservation(sessionId)
+          : null;
+      } catch {
+        return null;
+      }
+    };
     if (!abortErr && !snapshot) {
       // start() admits a manager that provides EITHER progress source, so this
       // fallback must not assume the coarse one exists: throwing here escaped
@@ -114,7 +132,7 @@ export function createProgressWatchdogRegistry({ mgr }) {
       }
       const last = reported || anchorTs;
       if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
-        abortAgentProgressWatchdog(controller, {
+        abortOnTimeout(controller, {
           sessionId,
           agent,
           error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
@@ -123,12 +141,14 @@ export function createProgressWatchdogRegistry({ mgr }) {
           anchorTs,
           lastProgressAt: reported,
           iteration,
+          observation: observe(),
+          registrationId: state.registrationId,
         });
       }
       return;
     }
     if (abortErr) {
-      abortAgentProgressWatchdog(controller, {
+      abortOnTimeout(controller, {
         sessionId,
         agent,
         error: abortErr,
@@ -137,6 +157,8 @@ export function createProgressWatchdogRegistry({ mgr }) {
         now,
         anchorTs,
         iteration,
+        observation: observe(),
+        registrationId: state.registrationId,
       });
     }
   }
@@ -151,14 +173,19 @@ export function createProgressWatchdogRegistry({ mgr }) {
           state.lastSuccessfulCheckAt = Date.now();
         } catch (error) {
           state.error = String(error?.message || error);
-          const elapsed = Date.now() - (state.lastSuccessfulCheckAt || state.anchorTs);
+          const compared = state.lastSuccessfulCheckAt
+            ? { at: state.lastSuccessfulCheckAt, field: 'last_successful_check_at' }
+            : { at: state.anchorTs, field: 'anchor_ts' };
+          const elapsed = Date.now() - compared.at;
           if (state.watchdogPolicy.idleStaleMs > 0 && elapsed > state.watchdogPolicy.idleStaleMs) {
-            abortAgentProgressWatchdog(state.controller, {
+            abortOnTimeout(state.controller, {
               sessionId: state.sessionId,
               agent: state.agent,
               error: new AgentStallAbortError(`agent progress checks failed: ${state.error}`),
               policy: state.watchdogPolicy,
               anchorTs: state.anchorTs,
+              comparedClock: compared,
+              registrationId: state.registrationId,
             });
           }
         }
@@ -177,6 +204,7 @@ export function createProgressWatchdogRegistry({ mgr }) {
         return null;
       if (typeof mgr.linkParentSignalToSession !== 'function') return null;
       const state = {
+        registrationId: randomUUID().slice(0, 8),
         sessionId,
         watchdogPolicy,
         agent,

package/src/session-runtime/services/channel-worker/daemon-spawn.mjs

@@ -7,6 +7,7 @@ import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { scrubLoaderVars } from '../../../runtime/agent/orchestrator/tools/env-scrub.mjs';
 import { withHeapCap } from '../../../runtime/shared/heap-cap.mjs';
+import { systemProxyHandoffEnv } from '../../../runtime/shared/llm/system-proxy.mjs';
 import { detachedSpawnOpts } from '../../../runtime/shared/spawn-flags.mjs';
 import { forkDaemonCandidate } from '../daemon-candidate.mjs';
 
@@ -24,6 +25,7 @@ export function daemonEnv({ rootDir, dataDir, runtimeDir, leadPid }) {
   scrubLoaderVars(env);
   return {
     ...env,
+    ...systemProxyHandoffEnv(),
     MIXDOG_ROOT: rootDir,
     MIXDOG_DATA_DIR: dataDir,
     MIXDOG_RUNTIME_ROOT: runtimeDir,

package/src/session-runtime/services/daemon-candidate.mjs

@@ -8,6 +8,7 @@
 // and attaches to whoever won. The resolved `summary()` describes this boot as
 // observed when called, for a caller that has to give up.
 import { fork } from 'node:child_process';
+import { withEnvProxy } from '../../runtime/shared/llm/http-agent.mjs';
 import { beginDaemonSpawnCapture } from './daemon-crash-capture.mjs';
 
 export function forkDaemonCandidate({
@@ -43,7 +44,9 @@ export function forkDaemonCandidate({
         cwd,
         execArgv,
         stdio: ['ignore', 'ignore', capture.stderrStdio, 'ipc'],
-        env,
+        // Proxy variables (the user's or the desktop's system proxy) need
+        // NODE_USE_ENV_PROXY to reach the daemon's fetch.
+        env: withEnvProxy(env),
         ...spawnOptions,
       });
     } catch (error) {

package/src/session-runtime/services/memory-runtime-proxy/daemon-spawn.mjs

@@ -4,6 +4,7 @@ import { dirname } from 'node:path';
 import { detachedSpawnOpts } from '../../../runtime/shared/spawn-flags.mjs';
 import { withHeapCap } from '../../../runtime/shared/heap-cap.mjs';
 import { resolveRuntimeRoot } from '../../../runtime/shared/runtime-root.mjs';
+import { systemProxyHandoffEnv } from '../../../runtime/shared/llm/system-proxy.mjs';
 import { scrubLoaderVars } from '../../../runtime/agent/orchestrator/tools/env-scrub.mjs';
 
 // Once a spawn crashes deterministically, short-circuit re-forks for this
@@ -33,6 +34,9 @@ function daemonEnv({ dataDir, idleTtlMs }) {
   scrubLoaderVars(env);
   return {
     ...env,
+    // The runtime and model downloads follow the system proxy this process
+    // settled; the memory process consumes the handoff at startup.
+    ...systemProxyHandoffEnv(),
     MIXDOG_DATA_DIR: dataDir,
     MIXDOG_RUNTIME_ROOT: resolveRuntimeRoot(),
     MIXDOG_WORKER_MODE: '1',

package/src/session-runtime/services/plugin-admin.mjs

@@ -8,6 +8,7 @@ import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
 import { pluginManifest } from '../../runtime/shared/plugin-manifest.mjs';
 import { pluginMetadata } from '../../runtime/shared/plugin-metadata.mjs';
 import { clean } from '../../runtime/shared/clean.mjs';
+import { startGitSync } from '../../runtime/shared/git-launch.mjs';
 
 const REGISTRY_VERSION = 1;
 
@@ -125,12 +126,15 @@ function normalizeSource(input) {
 }
 
 function runGit(args, options = {}) {
-  const result = spawnSync('git', args, {
-    cwd: options.cwd,
-    encoding: 'utf8',
-    windowsHide: true,
-    timeout: options.timeout ?? 120000,
-  });
+  const result = startGitSync(null, (command, env) =>
+    spawnSync(command, args, {
+      cwd: options.cwd,
+      env,
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: options.timeout ?? 120000,
+    })
+  );
   if (result.status !== 0) {
     const detail = clean(result.stderr) || clean(result.stdout) || `git ${args.join(' ')} failed`;
     throw new Error(detail);