@serviceme/devtools-core 0.3.2 → 0.3.4

package/dist/index.mjs

@@ -454,6 +454,50 @@ var AccessControl = class {
   }
 };
 
+// src/logger.ts
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+function formatArgs(args) {
+  return args.map((arg) => {
+    if (typeof arg === "string") {
+      return arg;
+    }
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function createConsoleLogger(prefix = "serviceme") {
+  return {
+    debug(message, ...args) {
+      process.stderr.write(`[${prefix}] DEBUG ${message} ${formatArgs(args)}
+`);
+    },
+    info(message, ...args) {
+      process.stderr.write(`[${prefix}] INFO ${message} ${formatArgs(args)}
+`);
+    },
+    warn(message, ...args) {
+      process.stderr.write(`[${prefix}] WARN ${message} ${formatArgs(args)}
+`);
+    },
+    error(message, ...args) {
+      process.stderr.write(`[${prefix}] ERROR ${message} ${formatArgs(args)}
+`);
+    }
+  };
+}
+
 // src/auth/AuthStateManager.ts
 import { EventEmitter } from "events";
 var AuthStateManager = class {
@@ -616,6 +660,7 @@ var AuthCore = class {
     this.state = opts.stateManager ?? new AuthStateManager();
     this.tokenStore = opts.tokenStore;
     this.accessControl = opts.accessControl;
+    this.logger = opts.logger ?? noopLogger;
   }
   /** Snapshot of every account, the active provider, and the last error. */
   status() {
@@ -637,16 +682,28 @@ var AuthCore = class {
    */
   async login(provider, ui, shouldContinue) {
     const providerImpl = this.registry.get(provider);
+    this.logger.info("[AuthCore] Starting device-flow login", { provider });
     try {
       const initial = await providerImpl.requestDeviceFlow();
       await ui(initial);
+      if (!initial.deviceCode) {
+        this.logger.error("[AuthCore] Provider did not return deviceCode", provider);
+        throw new Error("Auth provider did not return deviceCode for device flow completion");
+      }
       const session = await providerImpl.completeDeviceFlow(
-        initial.userCode ? initial.deviceCode ?? "" : "",
-        shouldContinue
+        initial.deviceCode,
+        shouldContinue,
+        initial.pollIntervalMs
       );
-      return await this.persistSession(providerImpl, session);
+      const result = await this.persistSession(providerImpl, session);
+      this.logger.info("[AuthCore] Device-flow login completed", { provider });
+      return result;
     } catch (err) {
-      this.state.recordError(err instanceof Error ? err.message : String(err));
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.error("[AuthCore] Device-flow login failed", message, {
+        provider
+      });
+      this.state.recordError(message);
       throw err;
     }
   }
@@ -671,7 +728,10 @@ var AuthCore = class {
     if (!provider) return null;
     const account = this.state.getActiveAccount();
     if (!account) return null;
-    const envelope = await this.tokenStore.get({ provider, accountId: account.id });
+    const envelope = await this.tokenStore.get({
+      provider,
+      accountId: account.id
+    });
     if (!envelope) return null;
     return { provider, account, token: envelope.token };
   }
@@ -681,9 +741,15 @@ var AuthCore = class {
    * every account.
    */
   async logout(provider) {
+    this.logger.info("[AuthCore] Logout requested", {
+      provider: provider ?? "all"
+    });
     if (!provider) {
       for (const account of this.state.listAccounts()) {
-        await this.tokenStore.delete({ provider: account.provider, accountId: account.id });
+        await this.tokenStore.delete({
+          provider: account.provider,
+          accountId: account.id
+        });
         this.state.removeAccount(account.provider, account.id);
       }
       this.state.clearAll();
@@ -758,6 +824,10 @@ var AuthCore = class {
       avatarUrl: meta.avatarUrl,
       expiresAt: meta.expiresAt ?? expiresAt
     };
+    this.logger.debug("[AuthCore] Persisting session", {
+      provider: meta.provider,
+      accountId: meta.id
+    });
     await this.tokenStore.set({ provider: meta.provider, accountId: meta.id }, session.token, {
       expiresAt
     });
@@ -860,11 +930,13 @@ var GitHubAuthProvider = class {
       userUrl: config.userUrl ?? DEFAULT_USER_URL,
       scope: config.scope ?? DEFAULT_SCOPE,
       minPollIntervalMs: config.minPollIntervalMs ?? 1e3,
-      maxPollIntervalMs: config.maxPollIntervalMs ?? 15e3,
+      maxPollIntervalMs: config.maxPollIntervalMs ?? 6e4,
       maxWaitMs: config.maxWaitMs,
       fetchImpl: config.fetchImpl ?? fetch,
       deviceCodeRetryBaseDelayMs: config.deviceCodeRetryBaseDelayMs ?? DEFAULT_DEVICE_CODE_RETRY_BASE_DELAY_MS
     };
+    this.logger = config.logger ?? noopLogger;
+    this.sleepImpl = config.sleepImpl ?? sleep;
   }
   async requestDeviceFlow(opts) {
     const body = JSON.stringify({
@@ -873,6 +945,10 @@ var GitHubAuthProvider = class {
     });
     let lastNetworkError;
     for (let attempt = 1; attempt <= DEVICE_CODE_MAX_ATTEMPTS; attempt++) {
+      this.logger.debug("[GitHubAuthProvider] Requesting device code", {
+        attempt,
+        maxAttempts: DEVICE_CODE_MAX_ATTEMPTS
+      });
       let resp;
       try {
         resp = await this.cfg.fetchImpl(this.cfg.deviceCodeUrl, {
@@ -886,45 +962,99 @@ var GitHubAuthProvider = class {
         });
       } catch (error) {
         if (!isTransientNetworkError(error) || attempt === DEVICE_CODE_MAX_ATTEMPTS) {
+          this.logger.error(
+            "[GitHubAuthProvider] Device-code request failed (non-retryable)",
+            error instanceof Error ? error.message : String(error),
+            { attempt }
+          );
           throw error;
         }
+        const delayMs = this.cfg.deviceCodeRetryBaseDelayMs * 2 ** (attempt - 1);
+        this.logger.warn(
+          "[GitHubAuthProvider] Transient network error requesting device code, retrying",
+          {
+            attempt,
+            delayMs,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
         lastNetworkError = error;
-        await sleep(this.cfg.deviceCodeRetryBaseDelayMs * 2 ** (attempt - 1));
+        await this.sleepImpl(delayMs);
         continue;
       }
       if (!resp.ok) {
+        this.logger.error(
+          "[GitHubAuthProvider] Device-code request rejected by GitHub",
+          `HTTP ${resp.status}`
+        );
         throw new Error(`GitHub device-code request failed: HTTP ${resp.status}`);
       }
       const data = await resp.json();
       if (!data.device_code || !data.user_code || !data.verification_uri) {
+        this.logger.error(
+          "[GitHubAuthProvider] Device-code response missing required fields",
+          JSON.stringify(Object.keys(data))
+        );
         throw new Error("GitHub device-code response missing required fields");
       }
+      this.logger.info("[GitHubAuthProvider] Device code obtained", {
+        userCode: data.user_code,
+        verificationUri: data.verification_uri,
+        expiresInSec: data.expires_in,
+        pollIntervalSec: data.interval
+      });
       return {
         provider: this.providerId,
+        deviceCode: data.device_code,
         userCode: data.user_code,
         verificationUrl: data.verification_uri,
         expiresAt: Date.now() + data.expires_in * 1e3,
+        pollIntervalMs: data.interval * 1e3,
         message: `Open ${data.verification_uri} and enter ${data.user_code}`
       };
     }
     throw lastNetworkError ?? new Error("GitHub device-code request failed");
   }
-  async completeDeviceFlow(deviceCode, shouldContinue) {
+  async completeDeviceFlow(deviceCode, shouldContinue, initialPollIntervalMs) {
     const start = Date.now();
-    let pollIntervalMs = this.cfg.minPollIntervalMs;
+    let pollIntervalMs = Math.max(this.cfg.minPollIntervalMs, initialPollIntervalMs ?? 0);
     let consecutiveSlowDown = 0;
+    let pollCount = 0;
+    this.logger.info("[GitHubAuthProvider] Starting device-flow polling", {
+      initialPollIntervalMs: pollIntervalMs,
+      maxWaitMs: this.cfg.maxWaitMs
+    });
     while (true) {
       if (shouldContinue && !shouldContinue()) {
+        this.logger.info("[GitHubAuthProvider] Device flow cancelled by caller", {
+          elapsedMs: Date.now() - start,
+          pollCount
+        });
         throw new Error("GitHub device flow cancelled by caller");
       }
       const elapsed = Date.now() - start;
       if (this.cfg.maxWaitMs !== void 0 && elapsed > this.cfg.maxWaitMs) {
+        this.logger.warn("[GitHubAuthProvider] Device flow exceeded max wait time", {
+          elapsedMs: elapsed,
+          maxWaitMs: this.cfg.maxWaitMs,
+          pollCount
+        });
         throw new Error("GitHub device flow exceeded max wait time");
       }
-      await sleep(pollIntervalMs);
+      await this.sleepImpl(pollIntervalMs);
       if (shouldContinue && !shouldContinue()) {
+        this.logger.info("[GitHubAuthProvider] Device flow cancelled by caller", {
+          elapsedMs: Date.now() - start,
+          pollCount
+        });
         throw new Error("GitHub device flow cancelled by caller");
       }
+      pollCount++;
+      this.logger.debug("[GitHubAuthProvider] Polling for authorization", {
+        pollCount,
+        elapsedMs: Date.now() - start,
+        pollIntervalMs
+      });
       let resp;
       try {
         resp = await this.cfg.fetchImpl(this.cfg.tokenUrl, {
@@ -942,19 +1072,59 @@ var GitHubAuthProvider = class {
         });
       } catch (error) {
         if (!isTransientNetworkError(error)) {
+          this.logger.error(
+            "[GitHubAuthProvider] Non-retryable error while polling token endpoint",
+            error instanceof Error ? error.message : String(error),
+            { pollCount }
+          );
           throw error;
         }
-        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
+        const nextPollIntervalMs = Math.min(
+          Math.round(pollIntervalMs * 1.5),
+          this.cfg.maxPollIntervalMs
+        );
+        this.logger.warn(
+          "[GitHubAuthProvider] Transient network error while polling, backing off",
+          {
+            pollCount,
+            error: error instanceof Error ? error.message : String(error),
+            previousPollIntervalMs: pollIntervalMs,
+            nextPollIntervalMs
+          }
+        );
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       if (!resp.ok) {
-        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
+        const nextPollIntervalMs = Math.min(
+          Math.round(pollIntervalMs * 1.5),
+          this.cfg.maxPollIntervalMs
+        );
+        this.logger.warn(
+          "[GitHubAuthProvider] Token endpoint returned non-OK status, backing off",
+          {
+            pollCount,
+            status: resp.status,
+            previousPollIntervalMs: pollIntervalMs,
+            nextPollIntervalMs
+          }
+        );
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       const data = await resp.json();
       if (data.access_token) {
+        this.logger.info("[GitHubAuthProvider] Authorization granted, fetching user profile", {
+          pollCount,
+          elapsedMs: Date.now() - start
+        });
         const rawUser = await this.fetchGitHubUser(data.access_token);
         const email = await this.resolveEmail(data.access_token, rawUser);
+        this.logger.info("[GitHubAuthProvider] Device-flow login completed", {
+          pollCount,
+          elapsedMs: Date.now() - start,
+          login: rawUser.login
+        });
         return {
           token: data.access_token,
           refreshToken: data.refresh_token,
@@ -969,22 +1139,42 @@ var GitHubAuthProvider = class {
         };
       }
       if (data.error === "authorization_pending") {
+        this.logger.debug("[GitHubAuthProvider] Authorization still pending", {
+          pollCount,
+          elapsedMs: Date.now() - start
+        });
         continue;
       }
       if (data.error === "slow_down") {
         consecutiveSlowDown++;
-        pollIntervalMs = Math.min(
-          Math.round(pollIntervalMs * 1.5 + Math.min(consecutiveSlowDown * 500, 2e3)),
-          this.cfg.maxPollIntervalMs
-        );
+        const nextPollIntervalMs = Math.min(pollIntervalMs + 5e3, this.cfg.maxPollIntervalMs);
+        this.logger.warn("[GitHubAuthProvider] GitHub requested slower polling (slow_down)", {
+          pollCount,
+          consecutiveSlowDown,
+          previousPollIntervalMs: pollIntervalMs,
+          nextPollIntervalMs
+        });
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       if (data.error === "access_denied") {
+        this.logger.warn("[GitHubAuthProvider] User denied authorization", {
+          pollCount
+        });
         throw new Error("User denied authorization");
       }
       if (data.error === "expired_token") {
+        this.logger.warn(
+          "[GitHubAuthProvider] Device code expired before authorization completed",
+          { pollCount, elapsedMs: Date.now() - start }
+        );
         throw new Error("GitHub device code expired \u2014 restart the flow");
       }
+      this.logger.error(
+        "[GitHubAuthProvider] Unexpected device-flow error from token endpoint",
+        data.error ?? "unknown",
+        { pollCount }
+      );
       throw new Error(`GitHub device flow error: ${data.error ?? "unknown"}`);
     }
   }
@@ -1866,10 +2056,20 @@ function isRecord(value) {
 function isNodeError(value) {
   return value instanceof Error && typeof value.code === "string";
 }
+var LOCK_PID_FILE = "pid";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var FileLock = class {
   constructor(filePath, timeoutMs, retryMs) {
     this.acquired = false;
     this.dirPath = `${filePath}.lock`;
+    this.pidFilePath = path3.join(this.dirPath, LOCK_PID_FILE);
     this.timeoutMs = timeoutMs;
     this.retryMs = retryMs;
   }
@@ -1878,12 +2078,18 @@ var FileLock = class {
     while (true) {
       try {
         await fsp.mkdir(this.dirPath, { mode: LOCK_DIR_MODE });
+        await fsp.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
         this.acquired = true;
         return;
       } catch (err) {
         if (!isNodeError(err) || err.code !== "EEXIST") {
           throw err;
         }
+        const stale = await this.isStaleLock();
+        if (stale) {
+          await fsp.rm(this.dirPath, { recursive: true, force: true });
+          continue;
+        }
         if (Date.now() - start >= this.timeoutMs) {
           throw new Error(`IdentityStore lock acquisition timed out for ${this.dirPath}`);
         }
@@ -1891,6 +2097,16 @@ var FileLock = class {
       }
     }
   }
+  async isStaleLock() {
+    try {
+      const pidStr = await fsp.readFile(this.pidFilePath, "utf8");
+      const pid = Number.parseInt(pidStr.trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) return true;
+      return !isProcessAlive(pid);
+    } catch {
+      return true;
+    }
+  }
   async release() {
     if (!this.acquired) return;
     this.acquired = false;
@@ -2319,12 +2535,43 @@ var TOOL_CHECK_TIMEOUT_MS = {
   pnpm: 15e3,
   nrm: 15e3
 };
+var POSIX_LOGIN_SHELL_FALLBACK_TOOLS = /* @__PURE__ */ new Set([
+  "npm",
+  "pnpm",
+  "nrm",
+  "node",
+  "dotnet",
+  "rtk"
+]);
 var ERROR_CODE_NOT_FOUND = 127;
 var ERROR_CODE_TIMEOUT = "ETIMEDOUT";
+var NVM_FALLBACK_DIRS = [
+  "/opt/homebrew/opt/nvm",
+  "/usr/local/opt/nvm",
+  "$HOME/.nvm"
+];
+function resolveUserLoginShell(platform3, envShell) {
+  const shell = envShell?.trim();
+  if (shell && shell.length > 0) {
+    return shell;
+  }
+  return platform3 === "darwin" ? "/bin/zsh" : "/bin/bash";
+}
+function buildNvmSourcingSnippet() {
+  const fallbackList = NVM_FALLBACK_DIRS.map((dir) => `"${dir}"`).join(" ");
+  return `for d in $NVM_DIR ${fallbackList}; do [ -n "$d" ] && [ -s "$d/nvm.sh" ] && export NVM_DIR="$d" && . "$d/nvm.sh" && break; done`;
+}
+function posixLoginShellArgs(platform3, envShell, command) {
+  return {
+    command: resolveUserLoginShell(platform3, envShell),
+    args: ["-lc", `${buildNvmSourcingSnippet()}; ${command}`]
+  };
+}
 var EnvironmentInspector = class {
   constructor(options = {}) {
     this.runCommandFn = options.runCommand ?? runCommand;
     this.platform = options.platform ?? process.platform;
+    this.shell = options.shell ?? process.env.SHELL;
   }
   async checkEnvironment() {
     const results = await Promise.all(
@@ -2362,6 +2609,21 @@ var EnvironmentInspector = class {
         timeoutMs: this.getToolTimeout(toolName)
       });
       return result.stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
+    } catch {
+      if (this.shouldUsePosixLoginShellFallback(toolName)) {
+        return this.getToolPathFromLoginShell(toolName);
+      }
+      return void 0;
+    }
+  }
+  async getToolPathFromLoginShell(toolName) {
+    try {
+      const spawnArgs = posixLoginShellArgs(this.platform, this.shell, `command -v ${toolName}`);
+      const result = await this.runCommandFn(spawnArgs.command, {
+        args: spawnArgs.args,
+        timeoutMs: this.getToolTimeout(toolName)
+      });
+      return result.stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
     } catch {
       return void 0;
     }
@@ -2386,12 +2648,31 @@ var EnvironmentInspector = class {
     }
   }
   async getToolVersion(toolName) {
-    const invocation = await this.getVersionInvocation(toolName);
-    const result = await this.runCommandFn(invocation.command, {
-      args: invocation.args,
-      timeoutMs: this.getToolTimeout(toolName)
-    });
-    return this.parseVersion(toolName, result.stdout || result.stderr);
+    try {
+      const invocation = await this.getVersionInvocation(toolName);
+      const result = await this.runCommandFn(invocation.command, {
+        args: invocation.args,
+        timeoutMs: this.getToolTimeout(toolName)
+      });
+      return this.parseVersion(toolName, result.stdout || result.stderr);
+    } catch (error) {
+      if (!this.shouldUsePosixLoginShellFallback(toolName)) {
+        throw error;
+      }
+      const fallbackArgs = posixLoginShellArgs(this.platform, this.shell, `${toolName} --version`);
+      const fallbackResult = await this.runCommandFn(fallbackArgs.command, {
+        args: fallbackArgs.args,
+        timeoutMs: this.getToolTimeout(toolName)
+      });
+      const fallbackOutput = (fallbackResult.stdout || fallbackResult.stderr).trim();
+      if (!fallbackOutput) {
+        throw error;
+      }
+      return this.parseVersion(toolName, fallbackOutput);
+    }
+  }
+  shouldUsePosixLoginShellFallback(toolName) {
+    return this.platform !== "win32" && POSIX_LOGIN_SHELL_FALLBACK_TOOLS.has(toolName);
   }
   async checkNvm() {
     if (this.platform === "win32") {
@@ -2413,11 +2694,9 @@ var EnvironmentInspector = class {
       }
     }
     try {
-      const result = await this.runCommandFn("/bin/bash", {
-        args: [
-          "-lc",
-          'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; nvm --version'
-        ],
+      const nvmArgs = posixLoginShellArgs(this.platform, this.shell, "nvm --version");
+      const result = await this.runCommandFn(nvmArgs.command, {
+        args: nvmArgs.args,
         timeoutMs: this.getToolTimeout("nvm")
       });
       return {
@@ -2441,7 +2720,7 @@ var EnvironmentInspector = class {
       };
     }
     try {
-      const result = await this.runCommandFn("dotnet", {
+      const result = await this.runCommandFn(dotnetPath, {
         args: ["nuget", "list", "source"],
         timeoutMs: this.getToolTimeout("nuget")
       });
@@ -2604,7 +2883,9 @@ var GitClient = class {
     }
     const targetUrl = useProxy ? remoteUrl : originalUrl ?? remoteUrl;
     const proxyUrl = this.rewriteRemoteUrl(repoId, targetUrl, useProxy);
-    await this.runOrThrow(["remote", "set-url", "origin", proxyUrl], { cwd: localPath });
+    await this.runOrThrow(["remote", "set-url", "origin", proxyUrl], {
+      cwd: localPath
+    });
     const before = await this.safeRevParse(localPath);
     await this.runOrThrow(["fetch", "origin"], { cwd: localPath });
     const after = await this.safeRevParse(localPath);
@@ -2640,7 +2921,9 @@ var GitClient = class {
       throw new Error(`no 'origin' remote configured at ${localPath}`);
     }
     const proxyUrl = this.rewriteRemoteUrl(repoId, remoteUrl, useProxy);
-    await this.runOrThrow(["remote", "set-url", "origin", proxyUrl], { cwd: localPath });
+    await this.runOrThrow(["remote", "set-url", "origin", proxyUrl], {
+      cwd: localPath
+    });
     const result = await this.spawner.spawn(
       ["push", "origin", `refs/heads/${branch}:refs/heads/${branch}`],
       { cwd: localPath }
@@ -2694,7 +2977,9 @@ var GitClient = class {
     return { commitSha: sha };
   }
   async runOrThrow(args, opts) {
-    const result = await this.spawner.spawn(args, { cwd: opts.cwd ?? process.cwd() });
+    const result = await this.spawner.spawn(args, {
+      cwd: opts.cwd ?? process.cwd()
+    });
     if (result.code !== 0) {
       throw new GitError(args, result);
     }
@@ -2709,7 +2994,9 @@ var GitClient = class {
     return url.length > 0 ? url : void 0;
   }
   async safeRevParse(localPath) {
-    const result = await this.spawner.spawn(["rev-parse", "HEAD"], { cwd: localPath });
+    const result = await this.spawner.spawn(["rev-parse", "HEAD"], {
+      cwd: localPath
+    });
     if (result.code !== 0) return "";
     return result.stdout.trim();
   }
@@ -2756,7 +3043,11 @@ var StubGitSpawner = class {
     this.calls.push({ args, cwd: opts.cwd });
     const next = this.script.shift();
     if (!next) {
-      return { stdout: "", stderr: `stub: no scripted response for ${args.join(" ")}`, code: 1 };
+      return {
+        stdout: "",
+        stderr: `stub: no scripted response for ${args.join(" ")}`,
+        code: 1
+      };
     }
     return next;
   }
@@ -2768,6 +3059,10 @@ function toFileUrl(absolutePath) {
   }
   return `file://${normalized}`;
 }
+var GIT_PROXY_PATH_SUFFIX = "/git-proxy";
+function buildGitProxyBase(serverBaseUrl) {
+  return `${serverBaseUrl.replace(/\/+$/, "")}${GIT_PROXY_PATH_SUFFIX}`;
+}
 
 // src/image/imageTools.ts
 import * as fs5 from "fs/promises";
@@ -2977,50 +3272,6 @@ function detectIndent(text) {
   return 2;
 }
 
-// src/logger.ts
-var noopLogger = {
-  debug() {
-  },
-  info() {
-  },
-  warn() {
-  },
-  error() {
-  }
-};
-function formatArgs(args) {
-  return args.map((arg) => {
-    if (typeof arg === "string") {
-      return arg;
-    }
-    try {
-      return JSON.stringify(arg);
-    } catch {
-      return String(arg);
-    }
-  }).join(" ");
-}
-function createConsoleLogger(prefix = "serviceme") {
-  return {
-    debug(message, ...args) {
-      process.stderr.write(`[${prefix}] DEBUG ${message} ${formatArgs(args)}
-`);
-    },
-    info(message, ...args) {
-      process.stderr.write(`[${prefix}] INFO ${message} ${formatArgs(args)}
-`);
-    },
-    warn(message, ...args) {
-      process.stderr.write(`[${prefix}] WARN ${message} ${formatArgs(args)}
-`);
-    },
-    error(message, ...args) {
-      process.stderr.write(`[${prefix}] ERROR ${message} ${formatArgs(args)}
-`);
-    }
-  };
-}
-
 // src/paths/serverProxyGlobal.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import * as fs6 from "fs/promises";
@@ -3176,7 +3427,7 @@ import {
 // src/utils/fileUtils.ts
 import { constants, createWriteStream } from "fs";
 import { access as access5, copyFile, lstat, mkdir as mkdir5, readdir as readdir3, rename as rename4, rm as rm3 } from "fs/promises";
-import { dirname as dirname7, join as join7 } from "path";
+import { dirname as dirname7, join as join8 } from "path";
 import yauzl from "yauzl";
 var unzipFile = (zipPath, dest) => {
   return new Promise((resolve3, reject) => {
@@ -3186,11 +3437,11 @@ var unzipFile = (zipPath, dest) => {
       zipfile.readEntry();
       zipfile.on("entry", (entry) => {
         if (/\/$/.test(entry.fileName)) {
-          void mkdir5(join7(dest, entry.fileName), { recursive: true }).then(() => {
+          void mkdir5(join8(dest, entry.fileName), { recursive: true }).then(() => {
             zipfile.readEntry();
           }).catch(reject);
         } else {
-          const outputPath = join7(dest, entry.fileName);
+          const outputPath = join8(dest, entry.fileName);
           void mkdir5(dirname7(outputPath), { recursive: true }).then(() => {
             zipfile.openReadStream(
               entry,
@@ -3239,7 +3490,7 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
     await mkdir5(destPath, { recursive: true });
     const children = await readdir3(sourcePath);
     for (const child of children) {
-      await mergeEntry(join7(sourcePath, child), join7(destPath, child), overwrite);
+      await mergeEntry(join8(sourcePath, child), join8(destPath, child), overwrite);
     }
     await rm3(sourcePath, { recursive: true, force: true });
     return;
@@ -3262,8 +3513,8 @@ var moveFiles = async (sourceDir, destDir, overwrite = false) => {
   await mkdir5(destDir, { recursive: true });
   const files = await readdir3(sourceDir);
   for (const file of files) {
-    const sourceFile = join7(sourceDir, file);
-    const destFile = join7(destDir, file);
+    const sourceFile = join8(sourceDir, file);
+    const destFile = join8(destDir, file);
     if (!overwrite) {
       try {
         await access5(destFile, constants.F_OK);
@@ -6678,10 +6929,19 @@ function coercePersistedToolbox(parsed) {
 function isNodeError2(value) {
   return value instanceof Error && typeof value.code === "string";
 }
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var ToolboxFileLock = class {
   constructor(filePath, timeoutMs, retryMs) {
     this.acquired = false;
     this.dirPath = `${filePath}.lock`;
+    this.pidFilePath = path25.join(this.dirPath, "pid");
     this.timeoutMs = timeoutMs;
     this.retryMs = retryMs;
   }
@@ -6690,10 +6950,16 @@ var ToolboxFileLock = class {
     while (true) {
       try {
         await fsp2.mkdir(this.dirPath, { mode: LOCK_DIR_MODE2 });
+        await fsp2.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
         this.acquired = true;
         return;
       } catch (err) {
         if (!isNodeError2(err) || err.code !== "EEXIST") throw err;
+        const stale = await this.isStaleLock();
+        if (stale) {
+          await fsp2.rm(this.dirPath, { recursive: true, force: true });
+          continue;
+        }
         if (Date.now() - start >= this.timeoutMs) {
           throw new Error(`ToolboxStore lock acquisition timed out for ${this.dirPath}`);
         }
@@ -6701,6 +6967,16 @@ var ToolboxFileLock = class {
       }
     }
   }
+  async isStaleLock() {
+    try {
+      const pidStr = await fsp2.readFile(this.pidFilePath, "utf8");
+      const pid = Number.parseInt(pidStr.trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) return true;
+      return !isProcessAlive2(pid);
+    } catch {
+      return true;
+    }
+  }
   async release() {
     if (!this.acquired) return;
     this.acquired = false;
@@ -6979,6 +7255,7 @@ export {
   EnvironmentInspector,
   FsIdentityFileBackend,
   FsToolboxFileBackend,
+  GIT_PROXY_PATH_SUFFIX,
   GitClient,
   GitError,
   GitHubAuthProvider,
@@ -7045,6 +7322,7 @@ export {
   bootstrapPhase5Placeholders,
   buildDefaultReposFile,
   buildGitHubLocalEmail,
+  buildGitProxyBase,
   buildSignedHeaders,
   copilotDoctor,
   copilotPrompt,