neko-harness 0.4.6 → 0.4.7

package/dist/gateway.js

@@ -16501,6 +16501,7 @@ var GATEWAY_USAGE = `\u7528\u6CD5: neko serve [\u9009\u9879]
   --storage <path>     SQLite \u5B58\u50A8\u6587\u4EF6\uFF08\u9ED8\u8BA4 ~/.neko/neko.sqlite\uFF09
   --credentials <path> \u7528\u6237\u51ED\u636E\u6587\u4EF6\uFF08\u9ED8\u8BA4 ~/.neko/credentials.json\uFF09
   --config <dir>       neko.config.json \u67E5\u627E\u8D77\u59CB\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
+  --stop-on-stdin      \u6807\u51C6\u8F93\u5165\u7ED3\u675F\u65F6\u5173\u505C\u7F51\u5173\uFF08\u4F9B Windows \u4E0A\u62C9\u8D77\u7F51\u5173\u7684\u524D\u7AEF\u4F7F\u7528\uFF09
   -h, --help           \u663E\u793A\u6B64\u5E2E\u52A9
 
 \u53EF\u901A\u8FC7\u524D\u7AEF\u8BBE\u7F6E\u6216\u73AF\u5883\u53D8\u91CF\uFF08DEEPSEEK_API_KEY / OPENROUTER_API_KEY / OPENCODE_API_KEY / TAVILY_API_KEY \u7B49\uFF09\u914D\u7F6E\u51ED\u636E\uFF1B
@@ -16584,6 +16585,9 @@ function parseGatewayArgs(argv) {
         options.configDir = next;
         i++;
         break;
+      case "--stop-on-stdin":
+        options.stopOnStdin = true;
+        break;
       default:
         throw new Error(`\u672A\u77E5\u9009\u9879: ${arg}`);
     }
@@ -16890,6 +16894,16 @@ function validate(config, source) {
       throw new Error(`neko config: ${source}: "skills.marketUrl" must be a string.`);
     }
   }
+  const shell = config.shell;
+  if (shell !== undefined) {
+    if (typeof shell !== "object" || shell === null || Array.isArray(shell)) {
+      throw new Error(`neko config: ${source}: "shell" must be an object.`);
+    }
+    const { path } = shell;
+    if (path !== undefined && typeof path !== "string") {
+      throw new Error(`neko config: ${source}: "shell.path" must be a string.`);
+    }
+  }
   const webSearch = config.webSearch;
   if (webSearch !== undefined) {
     if (typeof webSearch !== "object" || webSearch === null || Array.isArray(webSearch)) {
@@ -16909,10 +16923,36 @@ function validate(config, source) {
   }
 }
 // packages/core/src/credentials.ts
-import { chmod, mkdir, open, readFile, rename, unlink } from "fs/promises";
+import { chmod, mkdir, open, readFile, stat, unlink } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 
+// packages/core/src/rename-with-retry.ts
+import { rename } from "fs/promises";
+var TRANSIENT = new Set(["EPERM", "EBUSY", "EACCES"]);
+var FIRST_DELAY_MS = 10;
+var MAX_TOTAL_MS = 1000;
+async function renameWithRetry(from, to, deps = {}) {
+  const doRename = deps.rename ?? rename;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let delay = FIRST_DELAY_MS;
+  let waited = 0;
+  for (;; ) {
+    try {
+      await doRename(from, to);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (typeof code !== "string" || !TRANSIENT.has(code) || waited >= MAX_TOTAL_MS)
+        throw error;
+      const step = Math.min(delay, MAX_TOTAL_MS - waited);
+      await sleep(step);
+      waited += step;
+      delay *= 2;
+    }
+  }
+}
+
 // packages/core/src/credential-providers.ts
 var model = (id, name, envVar, signupUrl) => ({ id, kind: "model", name, envVar, signupUrl, keyless: false });
 var MODEL_PROVIDERS = [
@@ -16981,12 +17021,15 @@ function normalizeEnabledProviders(saved) {
 
 // packages/core/src/credentials.ts
 import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
+var STALE_LOCK_MS = 30000;
 var DEFAULT_CREDENTIALS_PATH = join2(homedir2(), ".neko", "credentials.json");
 
 class FileCredentialStore {
   path;
-  constructor(path = DEFAULT_CREDENTIALS_PATH) {
+  #renameDeps;
+  constructor(path = DEFAULT_CREDENTIALS_PATH, renameDeps = {}) {
     this.path = path;
+    this.#renameDeps = renameDeps;
   }
   async#read() {
     try {
@@ -17016,6 +17059,7 @@ class FileCredentialStore {
     await mkdir(dirname2(this.path), { recursive: true, mode: 448 });
     const lockPath = `${this.path}.lock`;
     let lock;
+    let reclaimed = false;
     for (let attempt = 0;; attempt++) {
       try {
         lock = await open(lockPath, "wx", 384);
@@ -17023,6 +17067,16 @@ class FileCredentialStore {
       } catch (error) {
         if (error.code !== "EEXIST" || attempt >= 100)
           throw new Error("Credential storage is busy or unavailable.");
+        if (!reclaimed) {
+          const info = await stat(lockPath).catch(() => {
+            return;
+          });
+          if (info && Date.now() - info.mtimeMs > STALE_LOCK_MS) {
+            reclaimed = true;
+            await unlink(lockPath).catch(() => {});
+            continue;
+          }
+        }
         await new Promise((resolve) => setTimeout(resolve, 25));
       }
     }
@@ -17044,7 +17098,7 @@ class FileCredentialStore {
       } finally {
         await file.close();
       }
-      await rename(temporary, this.path);
+      await renameWithRetry(temporary, this.path, this.#renameDeps);
       return result;
     } catch (error) {
       if (callbackFailed)
@@ -19069,7 +19123,7 @@ var SearchText = defineTool2({
             complete = false;
             continue;
           }
-          const lines = new TextDecoder("utf-8", { fatal: true }).decode(data).split(/\r?\n/);
+          const lines = new TextDecoder("utf-8", { fatal: true }).decode(data).replace(/^\uFEFF/, "").split(/\r?\n/);
           for (let i = 0;i < lines.length; i++) {
             ctx.abortSignal?.throwIfAborted();
             const value = lines[i];
@@ -19502,8 +19556,11 @@ class JobManager {
                 outcome = { status: "failed", exitCode: null, reason: "timeout" };
               else if (result.error.code === "aborted")
                 outcome = { status: "stopped", exitCode: null, reason: "aborted" };
-              else
+              else {
+                entry.buffer.append(`${result.error.message}
+`);
                 outcome = { status: "failed", exitCode: null, reason: "spawn-error" };
+              }
             }
             if (this.#closing) {
               await new Promise((resolve) => {
@@ -19900,10 +19957,15 @@ var TOOL_GUIDELINES = {
   ]
 };
 var GENERIC_RULES = ["Be concise in your responses", "Show file paths clearly when working with files"];
-var buildRules = (toolNames) => {
+var WINDOWS_SHELL_RULE = "On Windows, commands run in Git Bash (not PowerShell, cmd or WSL); write paths with forward slashes, e.g. D:/code or /d/code.";
+var toolRules = (name, platform) => {
+  const rules = TOOL_GUIDELINES[name] ?? [];
+  return platform === "win32" && (name === "bash" || name === "job") ? [...rules, WINDOWS_SHELL_RULE] : rules;
+};
+var buildRules = (toolNames, platform) => {
   const rules = [];
   const seen = new Set;
-  for (const rule of [...toolNames.flatMap((name) => TOOL_GUIDELINES[name] ?? []), ...GENERIC_RULES]) {
+  for (const rule of [...toolNames.flatMap((name) => toolRules(name, platform)), ...GENERIC_RULES]) {
     if (seen.has(rule))
       continue;
     seen.add(rule);
@@ -19920,7 +19982,7 @@ ${content}
 ].join(`
 
 `);
-var createNekoPrompt = (loadResources) => {
+var createNekoPrompt = (loadResources, platform = process.platform) => {
   const built = new WeakMap;
   const build = async (input, context) => {
     const cwd = input.agent.cwd;
@@ -19928,7 +19990,7 @@ var createNekoPrompt = (loadResources) => {
     const resources = cwd ? await loadResources(input.conversationId, cwd) : { contextFiles: [], skills: [] };
     const sections = {
       preamble: role ? ROLE_PROMPTS[role] + SUBAGENT_DELIVERY : PREAMBLE,
-      rules: buildRules(input.agent.tools.map((tool) => tool.name)),
+      rules: buildRules(input.agent.tools.map((tool) => tool.name), platform),
       project_context: renderProjectContext(resources.contextFiles),
       skills: formatSkillsForPrompt(resources.skills) || undefined,
       cwd: cwd?.replace(/\\/g, "/")
@@ -19976,7 +20038,7 @@ var readResources = async (workspace, home, builtinDir, report, invocationName)
   const contextFiles = [];
   for (const path of [userAgentsFile(home), workspaceAgentsFile(workspace)]) {
     try {
-      const content = await readFile3(path, "utf8");
+      const content = (await readFile3(path, "utf8")).replace(/^\uFEFF/, "");
       if (Buffer.byteLength(content, "utf8") > 64 * 1024)
         report({
           path,
@@ -21433,11 +21495,152 @@ function createTavilyProvider(resolveKey, fetchImpl = fetch) {
   };
 }
 
+// packages/core/src/windows-shell.ts
+import { spawnSync } from "child_process";
+import { statSync as statSync2 } from "fs";
+import { win32 } from "path";
+function isWslBashPath(path) {
+  const normalized = path.replace(/\//g, "\\").toLowerCase();
+  return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/.test(normalized) || /\\microsoft\\windowsapps\\(?:[^\\]+\\)*bash\.exe$/.test(normalized);
+}
+function envValue(env, name) {
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(env))
+    if (key.toLowerCase() === wanted && value)
+      return value;
+  return;
+}
+function bashBesideGit(gitExe) {
+  const dir = win32.dirname(gitExe);
+  const parent = win32.dirname(dir);
+  const name = win32.basename(dir).toLowerCase();
+  if (name === "cmd")
+    return win32.join(parent, "bin", "bash.exe");
+  if (name === "bin") {
+    const root = win32.basename(parent).toLowerCase() === "mingw64" ? win32.dirname(parent) : parent;
+    return win32.join(root, "bin", "bash.exe");
+  }
+  return;
+}
+function configProblem(path, kind) {
+  if (isWslBashPath(path))
+    return "it is WSL's bash, which is not supported (commands must run in Git Bash)";
+  if (kind === "missing")
+    return "the file does not exist";
+  if (kind === "directory")
+    return "it is a directory, not bash.exe";
+  return;
+}
+function resolveWindowsShell(deps, configPath) {
+  if (configPath !== undefined && configPath !== "") {
+    const problem = configProblem(configPath, deps.kind(configPath));
+    if (problem !== undefined) {
+      return {
+        kind: "missing",
+        reason: "invalid_config",
+        detail: `shell.path "${configPath}" is invalid: ${problem}.`,
+        searched: [configPath]
+      };
+    }
+    return { kind: "found", path: configPath, source: "config" };
+  }
+  const searched = [];
+  const check = (path) => {
+    if (!searched.includes(path))
+      searched.push(path);
+    return !isWslBashPath(path) && deps.kind(path) === "file";
+  };
+  const roots = [
+    envValue(deps.env, "ProgramFiles"),
+    envValue(deps.env, "ProgramFiles(x86)"),
+    (() => {
+      const local = envValue(deps.env, "LOCALAPPDATA");
+      return local === undefined ? undefined : win32.join(local, "Programs");
+    })()
+  ];
+  for (const root of roots) {
+    if (root === undefined)
+      continue;
+    const candidate = win32.join(root, "Git", "bin", "bash.exe");
+    if (check(candidate))
+      return { kind: "found", path: candidate, source: "auto" };
+  }
+  for (const gitExe of deps.where("git.exe")) {
+    const candidate = bashBesideGit(gitExe);
+    if (candidate !== undefined && check(candidate))
+      return { kind: "found", path: candidate, source: "auto" };
+  }
+  for (const candidate of deps.where("bash.exe")) {
+    if (check(candidate))
+      return { kind: "found", path: candidate, source: "auto" };
+  }
+  return { kind: "missing", reason: "not_found", detail: "No Git Bash was found.", searched };
+}
+function summarizeWindowsShell(status) {
+  return status.kind === "found" ? { status: "ready", path: status.path, source: status.source } : { status: "missing", reason: status.reason, detail: status.detail };
+}
+function windowsShellMessage(status) {
+  const lines = status.reason === "invalid_config" ? [
+    `Cannot run shell commands: ${status.detail}`,
+    "Fix shell.path in neko.config.json, or remove it to auto-detect Git Bash."
+  ] : [
+    "Cannot run shell commands: Git Bash was not found. neko runs commands in Git for Windows' bash, not PowerShell, cmd or WSL.",
+    "Install Git for Windows (https://git-scm.com/download/win), or set shell.path in neko.config.json to its bash.exe."
+  ];
+  if (status.searched.length > 0)
+    lines.push("Checked:", ...status.searched.map((path) => `  ${path}`));
+  lines.push("File tools (read, write, edit) still work.");
+  return lines.join(`
+`);
+}
+function systemWindowsShellDeps() {
+  return {
+    env: process.env,
+    kind(path) {
+      try {
+        return statSync2(path).isDirectory() ? "directory" : "file";
+      } catch {
+        return "missing";
+      }
+    },
+    where(program) {
+      const result = spawnSync("where", [program], { encoding: "utf8", timeout: 5000, windowsHide: true });
+      if (result.status !== 0 || typeof result.stdout !== "string")
+        return [];
+      return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "");
+    }
+  };
+}
+var WINDOWS_SHELL_RETRY_MS = 30000;
+function createWindowsShellResolver(options) {
+  const deps = options?.deps ?? systemWindowsShellDeps();
+  const now = options?.now ?? Date.now;
+  let cached;
+  return {
+    status(call) {
+      if (cached !== undefined && call?.refresh !== true) {
+        if (cached.status.kind === "found") {
+          if (deps.kind(cached.status.path) === "file")
+            return cached.status;
+        } else if (now() - cached.at < WINDOWS_SHELL_RETRY_MS) {
+          return cached.status;
+        }
+      }
+      cached = { status: resolveWindowsShell(deps, options?.configPath), at: now() };
+      return cached.status;
+    }
+  };
+}
+
 // packages/core/src/workspace-files.ts
-import { open as open2, realpath as realpath2, stat } from "fs/promises";
+import { open as open2, realpath as realpath2, stat as stat2 } from "fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
 import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2, withAbortSignal as withAbortSignal3 } from "@earendil-works/chord/context";
-import { getOrThrow as getOrThrow2 } from "@earendil-works/pi-durable/env";
+import {
+  ExecutionError,
+  err,
+  getOrThrow as getOrThrow2
+} from "@earendil-works/pi-durable/env";
 import { Connection, LocalExecutionEnv, localDaemon } from "@earendil-works/pi-env";
 var BROWSE_LIMITS = { children: 1000, readBytes: 512 * 1024 };
 var ENV_TEMPLATE = /\.(example|sample|template)$/;
@@ -21475,6 +21678,19 @@ var FILE_CACHE_LIMITS = {
   concurrent: 2
 };
 
+class ShellUnavailableEnv extends LocalExecutionEnv {
+  #message;
+  constructor(options, message) {
+    super(options);
+    this.#message = message;
+  }
+  async exec(command, options, context) {
+    if (typeof command === "string")
+      return err(new ExecutionError("shell_unavailable", this.#message));
+    return super.exec(command, options, context);
+  }
+}
+
 class WorkspaceFiles {
   #connection;
   #starting;
@@ -21489,8 +21705,10 @@ class WorkspaceFiles {
   #waiting = new Set;
   #timer;
   limits;
-  constructor(limits = FILE_CACHE_LIMITS) {
+  #shell;
+  constructor(limits = FILE_CACHE_LIMITS, shell) {
     this.limits = limits;
+    this.#shell = shell;
     this.#timer = setInterval(() => {
       for (const [key, item] of this.#cache)
         if (!item.waiters && Date.now() - item.used >= this.limits.idleMs)
@@ -21509,20 +21727,31 @@ class WorkspaceFiles {
       queued: this.#waiting.size
     };
   }
-  env(cwd) {
+  shellStatus(options) {
+    return this.#shell?.status(options);
+  }
+  #open() {
     if (this.#closed)
       throw new Error("File environment closed");
     this.#connection ??= new Connection({ command: [localDaemon()] });
-    return new LocalExecutionEnv({
-      connection: this.#connection,
+    return this.#connection;
+  }
+  env(cwd) {
+    const options = {
+      connection: this.#open(),
       cwd,
       ...process.platform === "win32" ? { shellEnv: { PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1" } } : {}
-    });
+    };
+    const shell = this.#shell?.status();
+    if (shell === undefined)
+      return new LocalExecutionEnv(options);
+    if (shell.kind === "found")
+      return new LocalExecutionEnv({ ...options, shellPath: shell.path });
+    return new ShellUnavailableEnv(options, windowsShellMessage(shell));
   }
   async#ready() {
     if (!this.#starting) {
-      this.env(process.cwd());
-      const connection = this.#connection;
+      const connection = this.#open();
       let timer;
       const work = Promise.race([
         connection.info().then(() => connection.session()),
@@ -21599,7 +21828,7 @@ class WorkspaceFiles {
           { path: item.root, recursive: true, exclude: { names: [".git"] } }
         ];
         const git = resolve4(item.root, ".git");
-        if (await stat(git).then(() => true, () => false))
+        if (await stat2(git).then(() => true, () => false))
           targets.push({ path: git, recursive: true, exclude: { names: ["objects", "logs", "refs"] } });
         const result = await env.watch(targets, (change) => {
           for (const user of current.users) {
@@ -21707,7 +21936,7 @@ class WorkspaceFiles {
     const slash = query.lastIndexOf("/"), prefix = slash < 0 ? "" : query.slice(0, slash + 1), needle = query.slice(slash + 1);
     root = await realpath2(root);
     const base = await workspaceTarget(root, prefix);
-    if (!(await stat(base)).isDirectory())
+    if (!(await stat2(base)).isDirectory())
       throw new Error("Workspace directory is unavailable.");
     return this.#withListing(root, base, signal, async (listing) => {
       const pattern = new RegExp([...needle].map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*"), /[A-Z]/.test(needle) ? "" : "i");
@@ -21737,7 +21966,7 @@ class WorkspaceFiles {
     const clean = dir === "" ? "" : relativeQuery(dir).replace(/\/+$/, "");
     root = await realpath2(root);
     const target = await workspaceTarget(root, clean);
-    if (!(await stat(target)).isDirectory())
+    if (!(await stat2(target)).isDirectory())
       throw new Error("Not a directory.");
     const prefix = clean === "" ? "" : `${clean}/`;
     return this.#withListing(root, root, signal, async (listing) => {
@@ -21779,7 +22008,7 @@ class WorkspaceFiles {
         throw new Error("File not found.");
       throw error;
     }
-    const info = await stat(target);
+    const info = await stat2(target);
     if (!info.isFile())
       throw new Error("Not a file.");
     const base = { path: clean, size: info.size, mtimeMs: info.mtimeMs };
@@ -22006,7 +22235,8 @@ async function createNekoRuntime(options = {}) {
     }));
     return modelInfoCache;
   };
-  const workspaceFiles = new WorkspaceFiles;
+  const shellResolver = options.shellResolver ?? (process.platform === "win32" ? createWindowsShellResolver({ configPath: options.shellPath }) : undefined);
+  const workspaceFiles = new WorkspaceFiles(undefined, shellResolver);
   const storage = options.storage === "memory" ? new MemoryStorage : await openNodeSqliteStorage(options.storagePath ?? DEFAULT_STORAGE_PATH);
   const registry = createRegistry();
   registry.install(createCodingTools({ images: await createNodePhotonImages() }));
@@ -22516,6 +22746,10 @@ async function createNekoRuntime(options = {}) {
     questions,
     closed: harness.closed,
     workspaceFiles,
+    shellStatus(call) {
+      const status = workspaceFiles.shellStatus(call);
+      return status === undefined ? undefined : summarizeWindowsShell(status);
+    },
     conversation,
     root: rootSession,
     submit: rootSession.submit,
@@ -23418,6 +23652,14 @@ var NekoSkillMarket = contract("neko.skill-market", {
     }
   }
 });
+var ShellStatusSchema = Type7.Union([
+  Type7.Object({ status: Type7.Literal("ready"), path: str, source: Type7.Enum(["config", "auto"]) }),
+  Type7.Object({
+    status: Type7.Literal("missing"),
+    reason: Type7.Enum(["not_found", "invalid_config"]),
+    detail: Type7.Optional(str)
+  })
+]);
 var ApplicationInfoSchema = Type7.Object({
   runningVersion: str,
   installedVersion: nullableString,
@@ -23425,7 +23667,8 @@ var ApplicationInfoSchema = Type7.Object({
   latestVersion: nullableString,
   checkedAt: Type7.Union([integer, nil]),
   checkState: Type7.Enum(["unknown", "checking", "ok", "failed", "development"]),
-  serverId: str
+  serverId: str,
+  shell: Type7.Optional(ShellStatusSchema)
 });
 var NekoApplicationInfo = contract("neko.application-info", {
   version: 1,
@@ -23463,7 +23706,7 @@ function isMobilePrincipal(principal) {
 
 // packages/gateway/src/mobile/store.ts
 import { randomBytes } from "crypto";
-import { chmod as chmod2, mkdir as mkdir2, readFile as readFile4, rename as rename2, rm, writeFile } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile4, rm, writeFile } from "fs/promises";
 import { join as join6 } from "path";
 var MOBILE_STATE_FORMAT_VERSION = 1;
 var MOBILE_DEFAULT_PORT = 8323;
@@ -23591,9 +23834,10 @@ async function writeFileAtomic(filePath, contents, mode) {
     await writeFile(tempPath, contents, { mode });
     if (POSIX)
       await chmod2(tempPath, mode);
-    await rename2(tempPath, filePath);
-  } finally {
+    await renameWithRetry(tempPath, filePath);
+  } catch (error) {
     await rm(tempPath, { force: true });
+    throw error;
   }
 }
 async function writeSecretFile(filePath, contents) {
@@ -24149,7 +24393,7 @@ function subagentClient(connect) {
 import { createHash as createHash2 } from "crypto";
 
 // packages/core/src/application-version.ts
-var RUNNING_VERSION = "0.4.6";
+var RUNNING_VERSION = "0.4.7";
 var APPLICATION_PROTOCOL = 8;
 function stableVersion(value) {
   return typeof value === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) && value.split(".").every((n) => Number.isSafeInteger(Number(n)));
@@ -26799,6 +27043,10 @@ function toMessage(error) {
   }
   return String(error);
 }
+function normalizeLocalAddress(address) {
+  const mapped = address?.startsWith("::ffff:") ? address.slice("::ffff:".length) : undefined;
+  return mapped !== undefined && isIpv4Literal(mapped) ? mapped : address;
+}
 
 class MobileGateway {
   serverId;
@@ -27127,11 +27375,12 @@ class MobileGateway {
       connection.sendNotification(method, params);
   }
   advertisedAddress(localAddress) {
+    const normalized = normalizeLocalAddress(localAddress);
     const state = this.stateValue;
-    if (state.status === "listening" && state.mode === "wsl-relay" && localAddress === state.bindAddress) {
+    if (state.status === "listening" && state.mode === "wsl-relay" && normalized === state.bindAddress) {
       return state.address;
     }
-    return localAddress;
+    return normalized;
   }
   requireStore() {
     if (this.storeHandle === undefined)
@@ -27392,7 +27641,7 @@ import { randomUUID as randomUUID5 } from "crypto";
 import { ChordError as ChordError5, local as local3, method as method2 } from "@earendil-works/chord";
 
 // packages/core/src/application-updates.ts
-import { mkdir as mkdir3, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile6, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -27522,7 +27771,7 @@ class UpdateChecker {
       try {
         await mkdir3(dirname5(this.#cachePath), { recursive: true });
         await writeFile3(temporary, JSON.stringify({ latestVersion: value.version, checkedAt: now }), { mode: 384 });
-        await rename3(temporary, this.#cachePath);
+        await renameWithRetry(temporary, this.#cachePath);
       } catch {} finally {
         await rm3(temporary, { force: true }).catch(() => {});
       }
@@ -28256,7 +28505,7 @@ function serveSessions(host, runtime, context) {
 
 // packages/gateway/src/skill-market.ts
 import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir4, readdir as readdir2, rename as rename4, rm as rm4, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir4, readdir as readdir2, rm as rm4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname6, join as join11 } from "path";
 
@@ -28401,11 +28650,11 @@ var ec = [
   "stream finishing",
   "invalid zip data"
 ];
-var err = function(ind, msg, nt) {
+var err2 = function(ind, msg, nt) {
   var e = new Error(msg || ec[ind]);
   e.code = ind;
   if (Error.captureStackTrace)
-    Error.captureStackTrace(e, err);
+    Error.captureStackTrace(e, err2);
   if (!nt)
     throw e;
   return e;
@@ -28438,7 +28687,7 @@ var inflt = function(dat, st, buf, dict) {
         var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
         if (t > sl) {
           if (noSt)
-            err(0);
+            err2(0);
           break;
         }
         if (resize)
@@ -28484,10 +28733,10 @@ var inflt = function(dat, st, buf, dict) {
         lm = hMap(lt, lbt, 1);
         dm = hMap(dt, dbt, 1);
       } else
-        err(1);
+        err2(1);
       if (pos > tbts) {
         if (noSt)
-          err(0);
+          err2(0);
         break;
       }
     }
@@ -28500,11 +28749,11 @@ var inflt = function(dat, st, buf, dict) {
       pos += c & 15;
       if (pos > tbts) {
         if (noSt)
-          err(0);
+          err2(0);
         break;
       }
       if (!c)
-        err(2);
+        err2(2);
       if (sym < 256)
         buf[bt++] = sym;
       else if (sym == 256) {
@@ -28519,7 +28768,7 @@ var inflt = function(dat, st, buf, dict) {
         }
         var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
         if (!d)
-          err(3);
+          err2(3);
         pos += d & 15;
         var dt = fd[dsym];
         if (dsym > 3) {
@@ -28528,7 +28777,7 @@ var inflt = function(dat, st, buf, dict) {
         }
         if (pos > tbts) {
           if (noSt)
-            err(0);
+            err2(0);
           break;
         }
         if (resize)
@@ -28537,7 +28786,7 @@ var inflt = function(dat, st, buf, dict) {
         if (bt < dt) {
           var shift = dl - dt, dend = Math.min(dt, end);
           if (shift + bt < 0)
-            err(3);
+            err2(3);
           for (;bt < dend; ++bt)
             buf[bt] = dict[shift + bt];
         }
@@ -28597,7 +28846,7 @@ function strFromU8(dat, latin1) {
   } else {
     var _a = dutf8(dat), { s, r } = _a;
     if (r.length)
-      err(8);
+      err2(8);
     return s;
   }
 }
@@ -28624,7 +28873,7 @@ var z64hs = function(d, b, l, z, sc, su, off) {
       }
     }
     if (z < 2)
-      err(13);
+      err2(13);
   }
   return [sc, su, off, 0];
 };
@@ -28633,7 +28882,7 @@ function unzipSync(data, opts) {
   var e = data.length - 22;
   for (;b4(data, e) != 101010256; --e) {
     if (!e || data.length - e > 65558)
-      err(13);
+      err2(13);
   }
   var c = b2(data, e + 8);
   if (!c)
@@ -28663,7 +28912,7 @@ function unzipSync(data, opts) {
       else if (c_2 == 8)
         files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
       else
-        err(14, "unknown compression type " + c_2);
+        err2(14, "unknown compression type " + c_2);
     }
   }
   return files;
@@ -28704,6 +28953,7 @@ function createSkillMarketClient(options) {
   const home = options.home ?? homedir6();
   const fetchImpl = options.fetchImpl ?? fetch;
   const now = options.now ?? Date.now;
+  const placeRename = options.renameImpl;
   let base;
   try {
     base = new URL(options.marketUrl);
@@ -28808,6 +29058,8 @@ function createSkillMarketClient(options) {
       throw new SkillMarketError("market_unavailable", "Project-scope install needs a workspaceRoot");
     return projectSkillsDir(workspaceRoot);
   };
+  const BACKUP_PREFIX = ".bak-";
+  const UUID_LENGTH = 36;
   const sweepTempDirs = async (skillsDir) => {
     const parent = dirname6(skillsDir);
     let names = [];
@@ -28817,11 +29069,26 @@ function createSkillMarketClient(options) {
       return;
     }
     await Promise.all(names.filter((n) => n.startsWith(".tmp-")).map((n) => rm4(join11(parent, n), { recursive: true, force: true }).catch(() => {})));
+    for (const n of names.filter((n) => n.startsWith(BACKUP_PREFIX))) {
+      const backup = join11(parent, n);
+      const skill = n.slice(BACKUP_PREFIX.length + UUID_LENGTH + 1);
+      if (skill === "" || skill.includes("/") || skill.includes("\\") || skill === "." || skill === "..")
+        continue;
+      const target = join11(skillsDir, skill);
+      if (await stat3(target).catch(() => {
+        return;
+      }) === undefined) {
+        await mkdir4(skillsDir, { recursive: true }).catch(() => {});
+        await renameWithRetry(backup, target).catch(() => {});
+      } else {
+        await rm4(backup, { recursive: true, force: true }).catch(() => {});
+      }
+    }
   };
   const install = async ({ name, scope, workspaceRoot, overwrite }) => {
     const skillsDir = skillsDirFor(scope, workspaceRoot);
     const target = join11(skillsDir, name);
-    const exists = await stat2(target).catch(() => {
+    const exists = await stat3(target).catch(() => {
       return;
     }) !== undefined;
     if (exists && overwrite !== true)
@@ -28836,17 +29103,27 @@ function createSkillMarketClient(options) {
         await mkdir4(dirname6(dest), { recursive: true });
         await writeFile4(dest, bytes);
       }
-      if (exists)
-        await rm4(target, { recursive: true, force: true });
       await mkdir4(skillsDir, { recursive: true });
-      await rename4(temp, target);
+      if (exists) {
+        const backup = join11(dirname6(skillsDir), `${BACKUP_PREFIX}${randomUUID4()}-${name}`);
+        await renameWithRetry(target, backup);
+        try {
+          await renameWithRetry(temp, target, placeRename ? { rename: placeRename } : {});
+        } catch (error) {
+          await renameWithRetry(backup, target).catch(() => {});
+          throw error;
+        }
+        await rm4(backup, { recursive: true, force: true }).catch(() => {});
+      } else {
+        await renameWithRetry(temp, target, placeRename ? { rename: placeRename } : {});
+      }
     } finally {
       await rm4(temp, { recursive: true, force: true }).catch(() => {});
     }
     let shadowedBy;
     if (scope === "user" && workspaceRoot !== undefined && workspaceRoot !== "") {
       const projectDir = join11(projectSkillsDir(workspaceRoot), name);
-      if (await stat2(projectDir).catch(() => {
+      if (await stat3(projectDir).catch(() => {
         return;
       }) !== undefined)
         shadowedBy = "project";
@@ -28856,7 +29133,7 @@ function createSkillMarketClient(options) {
   const uninstall = async ({ name, scope, workspaceRoot }) => {
     const skillsDir = skillsDirFor(scope, workspaceRoot);
     const target = join11(skillsDir, name);
-    if (await stat2(target).catch(() => {
+    if (await stat3(target).catch(() => {
       return;
     }) === undefined)
       throw new SkillMarketError("skill_not_installed", `Skill ${name} is not installed at ${scope} level`);
@@ -28890,7 +29167,7 @@ function createSkillMarketClient(options) {
 
 // packages/gateway/src/workspaces.ts
 import { constants as constants3 } from "fs";
-import { access, readdir as readdir3, stat as stat3 } from "fs/promises";
+import { access, readdir as readdir3, stat as stat4 } from "fs/promises";
 import { dirname as dirname7, isAbsolute as isAbsolute4, join as join12 } from "path";
 async function browseWorkspaces(options) {
   const requested = options.path.replace(/^\/+([A-Za-z]:[\\/])/, "$1");
@@ -28922,7 +29199,7 @@ async function browseWorkspaces(options) {
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     try {
-      if (!(await stat3(target)).isDirectory())
+      if (!(await stat4(target)).isDirectory())
         continue;
       await access(target, constants3.R_OK | constants3.X_OK);
       directories.push({ name: entry.name, path: target });
@@ -28971,12 +29248,15 @@ async function createNekoServerServices(options) {
   const updates = new UpdateChecker(options.updates);
   await updates.local();
   const updateListeners = new Set;
-  const info = (value) => ({ ...value, serverId: options.serverId });
-  let published = JSON.stringify(updates.state), closed = false;
+  const info = (value) => {
+    const shell = runtime.shellStatus();
+    return { ...value, serverId: options.serverId, ...shell === undefined ? {} : { shell } };
+  };
+  let published = JSON.stringify(info(updates.state)), closed = false;
   const publishUpdates = () => {
     if (closed)
       return;
-    const next = JSON.stringify(updates.state);
+    const next = JSON.stringify(info(updates.state));
     if (next === published)
       return;
     published = next;
@@ -28995,6 +29275,7 @@ async function createNekoServerServices(options) {
       variant: "ready",
       info: current,
       check: async () => {
+        runtime.shellStatus({ refresh: true });
         await updates.check(true);
         publishUpdates();
         return info(updates.state);
@@ -29519,7 +29800,9 @@ async function startGateway(options = {}) {
     ...options.cwd !== undefined ? { cwd: options.cwd } : {},
     ...options.providers !== undefined ? { providers: options.providers } : {},
     ...options.extensions !== undefined ? { extensions: options.extensions } : {},
-    ...options.promptHome !== undefined ? { promptHome: options.promptHome } : {}
+    ...options.promptHome !== undefined ? { promptHome: options.promptHome } : {},
+    ...fileConfig.shell?.path !== undefined ? { shellPath: fileConfig.shell.path } : {},
+    ...options.shellResolver !== undefined ? { shellResolver: options.shellResolver } : {}
   });
   try {
     return await bindGateway(runtime, {
@@ -29534,6 +29817,7 @@ async function startGateway(options = {}) {
       updates: options.updates,
       updateIntervalMs: options.updateIntervalMs,
       mobileServerName: options.mobileServerName,
+      mobileNetwork: options.mobileNetwork,
       onError: options.onError
     });
   } catch (error) {
@@ -29568,12 +29852,13 @@ async function bindGateway(runtime, options) {
     wsListener = createWsListener({ host, port, onError: options.onError });
     listeners.push(wsListener);
   }
+  const acceptLocal = (link) => chord.accept(link, {
+    principal: { kind: "local", connectionId: randomUUID6() },
+    onProtocolMismatch: ({ peer }) => options.onError?.(new Error(`Rejected a client on Chord protocol ${peer ?? "unknown"}; restart or update it.`))
+  });
   try {
     for (const listener of listeners)
-      await listener.start((link) => chord.accept(link, {
-        principal: { kind: "local", connectionId: randomUUID6() },
-        onProtocolMismatch: ({ peer }) => options.onError?.(new Error(`Rejected a client on Chord protocol ${peer ?? "unknown"}; restart or update it.`))
-      }));
+      await listener.start(acceptLocal);
   } catch (error) {
     await Promise.allSettled(listeners.map((listener) => listener.close()));
     await chord.close();
@@ -29589,6 +29874,7 @@ async function bindGateway(runtime, options) {
     serverId,
     serverName: options.mobileServerName,
     onError: options.onError,
+    network: options.mobileNetwork,
     chord: {
       accept: (link, acceptOptions) => chord.accept(link, acceptOptions),
       invalidatePrincipal: (match) => chord.invalidatePrincipal(match)
@@ -29613,6 +29899,9 @@ async function bindGateway(runtime, options) {
     port: wsListener?.port,
     runtime,
     mobile,
+    accept(link) {
+      acceptLocal(link);
+    },
     async close() {
       if (closing)
         return closing;
@@ -29698,14 +29987,15 @@ function installShutdown(options = {}) {
       exit(1);
     });
   };
-  const onSignal = () => {
+  const begin = (reason) => {
     if (controller.signal.aborted) {
       options.log?.("\u518D\u6B21\u6536\u5230\u7EC8\u6B62\u4FE1\u53F7\uFF0C\u5F3A\u5236\u9000\u51FA\u3002");
       exit(130);
       return;
     }
-    options.log?.(`
-\u6B63\u5728\u5173\u95ED\u2026`);
+    options.log?.(reason === undefined ? `
+\u6B63\u5728\u5173\u95ED\u2026` : `
+\u6B63\u5728\u5173\u95ED\uFF08${reason}\uFF09\u2026`);
     controller.abort();
     timer = setTimeout(() => {
       options.log?.("\u5173\u95ED\u8D85\u65F6\uFF0C\u5F3A\u5236\u9000\u51FA\u3002");
@@ -29714,6 +30004,7 @@ function installShutdown(options = {}) {
     timer.unref?.();
     runCleanup();
   };
+  const onSignal = () => begin(undefined);
   const installed = [];
   for (const signal of shutdownSignals(proc.platform)) {
     try {
@@ -29728,6 +30019,9 @@ function installShutdown(options = {}) {
       if (controller.signal.aborted)
         runCleanup();
     },
+    trigger(reason) {
+      begin(reason);
+    },
     dispose() {
       clearTimeout(timer);
       for (const signal of installed)
@@ -29758,3 +30052,15 @@ if (gateway.wsUrl !== undefined)
   console.log(`  WebSocket:   ${gateway.wsUrl}`);
 console.log("\u6309 Ctrl+C \u505C\u6B62\u3002");
 shutdown.setCleanup(() => gateway.close());
+if (options.stopOnStdin === true) {
+  let triggered = false;
+  const onStdinEnd = () => {
+    if (triggered)
+      return;
+    triggered = true;
+    shutdown.trigger("stdin \u5DF2\u5173\u95ED");
+  };
+  process.stdin.once("end", onStdinEnd);
+  process.stdin.once("close", onStdinEnd);
+  process.stdin.resume();
+}