neko-harness 0.1.0 → 0.2.0

package/dist/neko.js

@@ -221,8 +221,8 @@ function validate(config, source) {
     if (port !== undefined && (!Number.isInteger(port) || port < 0 || port > 65535)) {
       throw new Error(`neko config: ${source}: "gateway.port" must be an integer between 0 and 65535.`);
     }
-    if (socketPath !== undefined && typeof socketPath !== "string") {
-      throw new Error(`neko config: ${source}: "gateway.socketPath" must be a string.`);
+    if (socketPath !== undefined && socketPath !== null && typeof socketPath !== "string") {
+      throw new Error(`neko config: ${source}: "gateway.socketPath" must be a string or null.`);
     }
   }
   const theme = config.theme;
@@ -1897,7 +1897,10 @@ async function createNekoRuntime(options = {}) {
     conversationCreated: async (tx, record) => {
       (await tx.doc(SessionMetadataDoc, record.id)).createdAt = Date.now();
     },
-    env: ({ cwd }) => new NodeExecutionEnv({ cwd: executionWorkspace(cwd) })
+    env: ({ cwd }) => new NodeExecutionEnv({
+      cwd: executionWorkspace(cwd),
+      ...process.platform === "win32" ? { shellEnv: { PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1" } } : {}
+    })
   }, context);
   const scanConversations = () => harness.commit(async (tx) => {
     const records = [];
@@ -3582,7 +3585,7 @@ function fileCompletion(commands, root, notice) {
         const items = [];
         for (const item of result.items) {
           const path = item.value.slice(1).replace(/^"|"$/g, "").replace(/\/$/, "");
-          if (path.split("/").includes(".git"))
+          if (path.split(/[\\/]/).includes(".git"))
             continue;
           try {
             await workspaceTarget(root, path);
@@ -3855,14 +3858,43 @@ var init_client = __esm(() => {
   init_ws_listener();
 });
 
+// packages/gateway/src/port-file.ts
+import { readFile as readFile4, rm, writeFile } from "fs/promises";
+import { join as join7 } from "path";
+function gatewayPortFilePath(nekoDir, serverId) {
+  return join7(nekoDir, `${serverId}.port`);
+}
+async function writeGatewayPortFile(nekoDir, serverId, wsUrl) {
+  await writeFile(gatewayPortFilePath(nekoDir, serverId), `${wsUrl}
+`, { mode: 384 });
+}
+async function readGatewayPortFile(nekoDir, serverId) {
+  let content;
+  try {
+    content = await readFile4(gatewayPortFilePath(nekoDir, serverId), "utf8");
+  } catch {
+    return;
+  }
+  const url = content.trim();
+  return url.startsWith("ws://") || url.startsWith("wss://") ? url : undefined;
+}
+async function removeGatewayPortFile(nekoDir, serverId) {
+  await rm(gatewayPortFilePath(nekoDir, serverId), { force: true });
+}
+var init_port_file = () => {};
+
 // packages/gateway/src/workspaces.ts
 import { constants as constants3 } from "fs";
 import { access, readdir as readdir2, stat as stat2 } from "fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join7 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute3, join as join8 } from "path";
 async function browseWorkspaces(options) {
-  if (!isAbsolute3(options.path))
+  const requested = options.path.replace(/^\/+([A-Za-z]:[\\/])/, "$1");
+  if (process.platform === "win32" && (requested === "/" || requested === "\\")) {
+    return { path: "/", parent: null, entries: await listDrives(), next: null };
+  }
+  if (!isAbsolute3(requested))
     throw new Error("\u8BF7\u9009\u62E9\u5B8C\u6574\u7684\u7EDD\u5BF9\u76EE\u5F55\u8DEF\u5F84");
-  const path = accessibleWorkspace(options.path);
+  const path = accessibleWorkspace(requested);
   const query = options.query?.toLowerCase() ?? "";
   const key = JSON.stringify([path, query, options.showHidden === true]);
   let offset = 0;
@@ -3881,7 +3913,7 @@ async function browseWorkspaces(options) {
   let next = offset;
   for (;next < entries.length && directories.length < 100; next++) {
     const entry = entries[next];
-    const target = join7(path, entry.name);
+    const target = join8(path, entry.name);
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     try {
@@ -3900,6 +3932,17 @@ async function browseWorkspaces(options) {
     next: next < entries.length ? JSON.stringify({ key, offset: next }) : null
   };
 }
+async function listDrives() {
+  const drives = [];
+  for (const letter of "ABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+    const root = `${letter}:\\`;
+    try {
+      await access(root);
+      drives.push({ name: `${letter}:`, path: root });
+    } catch {}
+  }
+  return drives;
+}
 var init_workspaces = __esm(() => {
   init_src();
 });
@@ -4440,8 +4483,8 @@ var init_session_host = __esm(() => {
 
 // packages/gateway/src/gateway.ts
 import { randomUUID } from "crypto";
-import { mkdir as mkdir2, readFile as readFile4, writeFile } from "fs/promises";
-import { basename as basename5, dirname as dirname6, join as join8 } from "path";
+import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename5, dirname as dirname6, join as join9 } from "path";
 import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
 import { isServerId } from "@earendil-works/pi-protocol";
 import { Server, SessionNotFoundError } from "@earendil-works/pi-server";
@@ -4452,10 +4495,10 @@ async function startGateway(options = {}) {
   const model = options.model ?? fileConfig.defaultModel ?? DEFAULT_MODEL;
   const storagePath = options.storagePath ?? fileConfig.storagePath ?? DEFAULT_STORAGE_PATH;
   const host = options.host ?? fileConfig.gateway?.host ?? DEFAULT_HOST;
-  const port = options.port !== undefined ? options.port : fileConfig.gateway?.port ?? DEFAULT_PORT;
+  const port = options.port !== undefined ? options.port : fileConfig.gateway?.port ?? (process.platform === "win32" ? 0 : DEFAULT_PORT);
   const nekoDir = dirname6(storagePath);
   const serverId = options.serverId ?? await loadOrCreateServerId(nekoDir);
-  const socketPath = options.socketPath !== undefined ? options.socketPath : fileConfig.gateway?.socketPath ?? join8(nekoDir, `${serverId}.sock`);
+  const socketPath = options.socketPath !== undefined ? options.socketPath : fileConfig.gateway?.socketPath !== undefined ? fileConfig.gateway.socketPath : process.platform === "win32" ? null : join9(nekoDir, `${serverId}.sock`);
   const runtime = await createNekoRuntime({
     context,
     storage: options.storage ?? "sqlite",
@@ -4476,6 +4519,7 @@ async function startGateway(options = {}) {
       port,
       socketPath,
       serverId,
+      nekoDir,
       model,
       onError: options.onError
     });
@@ -4485,7 +4529,7 @@ async function startGateway(options = {}) {
   }
 }
 async function bindGateway(runtime, options) {
-  const { context, host, port, socketPath, serverId, model } = options;
+  const { context, host, port, socketPath, serverId, nekoDir, model } = options;
   const modelLabel = `${model.provider}/${model.modelId}`;
   const serverServices = await createNekoServerServices({ runtime, context });
   let wsListener;
@@ -4518,6 +4562,10 @@ async function bindGateway(runtime, options) {
     await serverServices.dispose().catch(() => {});
     throw toStartupError(error, { socketPath, port, host, serverId });
   }
+  const portFile = process.platform === "win32" && wsListener !== undefined ? { nekoDir, serverId } : undefined;
+  if (portFile !== undefined && wsListener !== undefined) {
+    await writeGatewayPortFile(portFile.nekoDir, portFile.serverId, `ws://${host}:${wsListener.port}`);
+  }
   let closed = false;
   return {
     serverId,
@@ -4529,6 +4577,8 @@ async function bindGateway(runtime, options) {
       if (closed)
         return;
       closed = true;
+      if (portFile !== undefined)
+        await removeGatewayPortFile(portFile.nekoDir, portFile.serverId).catch(() => {});
       await server.close();
       await serverServices.dispose();
       await runtime.close();
@@ -4538,7 +4588,8 @@ async function bindGateway(runtime, options) {
 function toStartupError(error, info) {
   const message = error instanceof Error ? error.message : String(error);
   const existingServerId = info.socketPath === null ? undefined : serverIdFromSocketPath(info.socketPath);
-  const connectHint = existingServerId !== undefined ? `\u5982\u9700\u8FDE\u63A5\u5DF2\u6709\u5B9E\u4F8B\uFF1AUnix socket ${info.socketPath}\uFF08serverId: ${existingServerId}\uFF09\uFF0C\u6216\u505C\u6389\u5360\u7528\u65B9\u540E\u91CD\u8BD5\u3002` : `\u5982\u9700\u8FDE\u63A5\u5DF2\u6709\u5B9E\u4F8B\uFF1AUnix socket ${info.socketPath ?? "\uFF08\u672A\u542F\u7528\uFF09"}\uFF0C\u6216\u505C\u6389\u5360\u7528\u65B9\u540E\u91CD\u8BD5\u3002`;
+  const existingAddress = info.socketPath !== null ? `Unix socket ${info.socketPath}${existingServerId !== undefined ? `\uFF08serverId: ${existingServerId}\uFF09` : ""}` : process.platform === "win32" ? `\u7AEF\u53E3\u6587\u4EF6 <\u6570\u636E\u76EE\u5F55>/${info.serverId}.port \u4E2D\u7684 ws \u5730\u5740` : "Unix socket\uFF08\u672A\u542F\u7528\uFF09";
+  const connectHint = `\u5982\u9700\u8FDE\u63A5\u5DF2\u6709\u5B9E\u4F8B\uFF1A${existingAddress}\uFF0C\u6216\u505C\u6389\u5360\u7528\u65B9\u540E\u91CD\u8BD5\u3002`;
   if (message.includes("already running")) {
     return new Error(`neko gateway \u542F\u52A8\u5931\u8D25\uFF1A${message}
 \u8BE5\u5730\u5740\u5DF2\u88AB\u4E00\u4E2A\u6D3B\u8DC3\u7F51\u5173\u5360\u7528\uFF0C\u4E0D\u80FD\u542F\u52A8\u7B2C\u4E8C\u4E2A\u5B9E\u4F8B\u3002
@@ -4558,21 +4609,22 @@ function serverIdFromSocketPath(socketPath) {
   return isServerId(candidate) ? candidate : undefined;
 }
 async function loadOrCreateServerId(nekoDir) {
-  const file = join8(nekoDir, SERVER_ID_FILENAME);
+  const file = join9(nekoDir, SERVER_ID_FILENAME);
   try {
-    const existing = (await readFile4(file, "utf8")).trim();
+    const existing = (await readFile5(file, "utf8")).trim();
     if (existing !== "")
       return existing;
   } catch {}
   const created = randomUUID();
   await mkdir2(nekoDir, { recursive: true, mode: 448 });
-  await writeFile(file, `${created}
+  await writeFile2(file, `${created}
 `, { mode: 384 });
   return created;
 }
 var DEFAULT_HOST = "127.0.0.1", DEFAULT_PORT = 8321, SERVER_ID_FILENAME = "gateway-server-id";
 var init_gateway = __esm(() => {
   init_src();
+  init_port_file();
   init_server_services();
   init_session_host();
   init_ws_listener();
@@ -4610,6 +4662,7 @@ var init_src2 = __esm(() => {
   init_client();
   init_contract();
   init_gateway();
+  init_port_file();
   init_process();
   init_ws_listener();
 });
@@ -4617,15 +4670,27 @@ var init_src2 = __esm(() => {
 // packages/tui/src/gateway.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { basename as basename6, dirname as dirname7, join as join9 } from "path";
+import { basename as basename6, dirname as dirname7, join as join10 } from "path";
 import { isServerId as isServerId2 } from "@earendil-works/pi-protocol";
 async function connectToGateway(options = {}) {
   const config = loadNekoConfig(options.configDir);
   const storagePath = options.storagePath ?? config.storagePath ?? DEFAULT_STORAGE_PATH;
   const nekoDir = dirname7(storagePath);
-  const fileServerId = readServerId(join9(nekoDir, SERVER_ID_FILENAME2));
-  const socketPath = options.socketPath ?? config.gateway?.socketPath ?? (fileServerId !== undefined ? join9(nekoDir, `${fileServerId}.sock`) : undefined);
-  const serverIdFor = (path) => fileServerId ?? serverIdFromSocketPath2(path) ?? readServerId(join9(nekoDir, SERVER_ID_FILENAME2));
+  const fileServerId = readServerId(join10(nekoDir, SERVER_ID_FILENAME2));
+  if (process.platform === "win32") {
+    if (fileServerId !== undefined) {
+      const wsUrl = await readGatewayPortFile(nekoDir, fileServerId);
+      if (wsUrl !== undefined) {
+        try {
+          const client = await connectNekoGateway({ transport: "ws", url: wsUrl, serverId: fileServerId });
+          return { client, socketPath: undefined, serverId: fileServerId, spawned: false, close: () => client.close() };
+        } catch {}
+      }
+    }
+    return spawnAndConnect({ ...options, storagePath, socketPath: undefined, nekoDir, fileServerId });
+  }
+  const socketPath = options.socketPath ?? config.gateway?.socketPath ?? (fileServerId !== undefined ? join10(nekoDir, `${fileServerId}.sock`) : undefined);
+  const serverIdFor = (path) => fileServerId ?? serverIdFromSocketPath2(path) ?? readServerId(join10(nekoDir, SERVER_ID_FILENAME2));
   if (socketPath !== undefined && existsSync2(socketPath)) {
     const serverId = serverIdFor(socketPath);
     if (serverId !== undefined) {
@@ -4653,13 +4718,42 @@ async function spawnAndConnect(plan) {
   }
 }
 async function connectSpawned(plan, child, outputTail, spawnError) {
+  const timeoutMs = plan.spawnTimeoutMs ?? 20000;
+  if (process.platform === "win32") {
+    const serverId = plan.fileServerId ?? await waitForValue(() => readServerId(join10(plan.nekoDir, SERVER_ID_FILENAME2)), "gateway serverId file", timeoutMs, child, outputTail, spawnError);
+    const wsUrl = await waitForValue(() => readGatewayPortFile(plan.nekoDir, serverId), "gateway ready (port file)", timeoutMs, child, outputTail, spawnError);
+    let lastError;
+    for (let attempt = 0;attempt < CONNECT_RETRIES; attempt++) {
+      if (child.exitCode !== null || spawnError() !== undefined)
+        break;
+      try {
+        const client = await connectNekoGateway({ transport: "ws", url: wsUrl, serverId });
+        return {
+          client,
+          socketPath: undefined,
+          serverId,
+          spawned: true,
+          async close() {
+            await client.close().catch(() => {});
+            await stopGatewayProcess(child);
+            await removeGatewayPortFile(plan.nekoDir, serverId).catch(() => {});
+          }
+        };
+      } catch (error) {
+        lastError = error;
+        await sleep(CONNECT_RETRY_MS);
+      }
+    }
+    throw new Error(`Gateway connection failed: ${lastError instanceof Error ? lastError.message : String(lastError)}
+${outputTail()}`);
+  }
   let socketPath = plan.socketPath;
   if (socketPath === undefined) {
-    const generated = await waitForValue(() => readServerId(join9(plan.nekoDir, SERVER_ID_FILENAME2)), "gateway serverId file", plan.spawnTimeoutMs ?? 20000, child, outputTail, spawnError);
-    socketPath = join9(plan.nekoDir, `${generated}.sock`);
+    const generated = await waitForValue(() => readServerId(join10(plan.nekoDir, SERVER_ID_FILENAME2)), "gateway serverId file", timeoutMs, child, outputTail, spawnError);
+    socketPath = join10(plan.nekoDir, `${generated}.sock`);
   }
-  await waitForValue(() => existsSync2(socketPath) ? true : undefined, `gateway ready (socket: ${socketPath})`, plan.spawnTimeoutMs ?? 20000, child, outputTail, spawnError);
-  const serverId = plan.fileServerId ?? serverIdFromSocketPath2(socketPath) ?? readServerId(join9(plan.nekoDir, SERVER_ID_FILENAME2));
+  await waitForValue(() => existsSync2(socketPath) ? true : undefined, `gateway ready (socket: ${socketPath})`, timeoutMs, child, outputTail, spawnError);
+  const serverId = plan.fileServerId ?? serverIdFromSocketPath2(socketPath) ?? readServerId(join10(plan.nekoDir, SERVER_ID_FILENAME2));
   if (serverId === undefined) {
     throw new Error(`Cannot determine gateway serverId (socket: ${socketPath})`);
   }
@@ -4688,6 +4782,16 @@ async function connectSpawned(plan, child, outputTail, spawnError) {
 ${outputTail()}`);
 }
 function gatewayArgs(plan) {
+  if (process.platform === "win32") {
+    return [
+      "--no-socket",
+      "--storage",
+      plan.storagePath,
+      ...plan.credentialsPath ? ["--credentials", plan.credentialsPath] : [],
+      ...plan.configDir ? ["--cwd", plan.configDir, "--config", plan.configDir] : [],
+      ...plan.model !== undefined ? ["--model", `${plan.model.provider}/${plan.model.modelId}`] : []
+    ];
+  }
   return [
     "--port",
     "0",
@@ -4732,7 +4836,7 @@ async function waitForValue(poll, what, timeoutMs, child, outputTail, spawnError
     const error = spawnError();
     if (error !== undefined)
       throw new Error(`Gateway process failed to start: ${error.message}${formatTail(outputTail())}`);
-    const value = poll();
+    const value = await poll();
     if (value !== undefined)
       return value;
     if (child.exitCode !== null) {
@@ -4761,19 +4865,19 @@ var init_gateway2 = __esm(() => {
 
 // packages/tui/src/image-input.ts
 import { execFile } from "child_process";
-import { readFile as readFile5, stat as stat3 } from "fs/promises";
+import { readFile as readFile6, stat as stat3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { basename as basename7, resolve as resolve5 } from "path";
 import { promisify } from "util";
 import { isKeyRelease as isKeyRelease4, isKeyRepeat as isKeyRepeat2, matchesKey as matchesKey4 } from "@earendil-works/pi-tui";
-function imagePaths(text) {
+function imagePaths(text, platform = process.platform) {
   const paths = [];
   let word = "", quote = "", escaped = false;
   for (const c of text.trim()) {
     if (escaped) {
       word += c;
       escaped = false;
-    } else if (c === "\\" && quote !== "'") {
+    } else if (c === "\\" && quote !== "'" && platform !== "win32") {
       escaped = true;
     } else if (quote) {
       if (c === quote)
@@ -4801,7 +4905,7 @@ async function readImageFile(path, cwd) {
   const info = await stat3(full);
   if (!info.isFile() || info.size > 20 * 1024 * 1024)
     throw new Error("Image must be a file no larger than 20 MiB");
-  const bytes = await readFile5(full);
+  const bytes = await readFile6(full);
   const after = await stat3(full);
   if (bytes.length !== info.size || after.size !== info.size || after.mtimeMs !== info.mtimeMs)
     throw new Error("Image changed while reading");
@@ -5206,7 +5310,7 @@ class NekoTuiApp {
       this.sendImages(text, "followUp");
   }
   async addImagePaths(paths) {
-    return paths.map((path) => this.addImage(readImageFile(path, this.#options.cwd ?? process.cwd()), path.split("/").at(-1) ?? "Image")).join(" ");
+    return paths.map((path) => this.addImage(readImageFile(path, this.#options.cwd ?? process.cwd()), path.split(/[\\/]/).at(-1) ?? "Image")).join(" ");
   }
   addImage(file, name) {
     const ref = `[Image ${++this.#imageCounter}: ${name.replace(/[\]\r\n]/g, "")}]`;
@@ -5836,7 +5940,7 @@ Options:
   --cwd <dir>          Workspace (default: launch directory; not an access sandbox)
   --model <ref>        provider/modelId for a spawned gateway
   --storage <path>     SQLite storage (default: ~/.neko/neko.sqlite)
-  --socket-path <path> Gateway Unix socket
+  --socket-path <path> Gateway Unix socket\uFF08POSIX\uFF1BWindows \u7ECF\u7AEF\u53E3\u6587\u4EF6\u53D1\u73B0 ws \u5730\u5740\uFF09
   --theme <mode>       light / dark / auto (overrides NEKO_THEME)
   -h, --help           Show help
 
@@ -5873,16 +5977,53 @@ var init_open_browser = () => {};
 // packages/web/src/gateway-spawn.ts
 import { spawn as spawn3 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname8, join as join10 } from "path";
+import { mkdir as mkdir3, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname8, join as join11 } from "path";
 async function ensureNekoGateway(options) {
   const nekoDir = dirname8(options.storagePath);
   const serverId = options.serverId ?? await loadOrCreateServerId2(nekoDir);
-  const socketPath = options.socketPath ?? join10(nekoDir, `${serverId}.sock`);
+  if (process.platform === "win32") {
+    const discovered = await readGatewayPortFile(nekoDir, serverId);
+    if (discovered !== undefined && await probeWs(discovered, serverId)) {
+      return makeHandle(serverId, undefined, discovered, null, nekoDir);
+    }
+    const child = spawnGatewayProcess(options, null, serverId);
+    pipeChildLogs(child, options.onLog);
+    let spawnError;
+    child.on("error", (error) => {
+      spawnError = error;
+    });
+    try {
+      const timeoutAt = Date.now() + (options.spawnTimeoutMs ?? 30000);
+      let lastError = new Error("gateway \u672A\u5C31\u7EEA");
+      while (Date.now() < timeoutAt) {
+        if (spawnError !== undefined)
+          throw spawnError;
+        if (child.exitCode !== null || child.signalCode !== null) {
+          throw new Error(`neko gateway \u5B50\u8FDB\u7A0B\u63D0\u524D\u9000\u51FA\uFF08code ${child.exitCode}\uFF09\uFF0C\u8BE6\u89C1\u4E0A\u65B9\u65E5\u5FD7\u3002\u7AEF\u53E3\u6587\u4EF6\u53EF\u80FD\u88AB\u5176\u4ED6\u5B9E\u4F8B\u5360\u7528\u3002`);
+        }
+        const wsUrl = await readGatewayPortFile(nekoDir, serverId);
+        if (wsUrl !== undefined) {
+          try {
+            if (await probeWs(wsUrl, serverId))
+              return makeHandle(serverId, undefined, wsUrl, child, nekoDir);
+          } catch (error) {
+            lastError = error;
+          }
+        }
+        await sleep2(PROBE_INTERVAL_MS);
+      }
+      throw new Error(`\u7B49\u5F85 neko gateway \u5C31\u7EEA\u8D85\u65F6\uFF08${options.spawnTimeoutMs ?? 30000}ms\uFF09\uFF1A${lastError instanceof Error ? lastError.message : String(lastError)}`);
+    } catch (error) {
+      await stopGatewayProcess(child);
+      throw error;
+    }
+  }
+  const socketPath = options.socketPath ?? join11(nekoDir, `${serverId}.sock`);
   const host = options.host ?? "127.0.0.1";
   const port = options.port ?? 8321;
   if (await probeGateway(socketPath, serverId)) {
-    return makeHandle(serverId, socketPath, host, port, null);
+    return makeHandle(serverId, socketPath, `ws://${host}:${port}`, null, nekoDir);
   }
   const child = spawnGatewayProcess(options, socketPath, serverId);
   pipeChildLogs(child, options.onLog);
@@ -5901,7 +6042,7 @@ async function ensureNekoGateway(options) {
       }
       try {
         if (await probeGateway(socketPath, serverId))
-          return makeHandle(serverId, socketPath, host, port, child);
+          return makeHandle(serverId, socketPath, `ws://${host}:${port}`, child, nekoDir);
       } catch (error) {
         lastError = error;
       }
@@ -5917,10 +6058,7 @@ function spawnGatewayProcess(options, socketPath, serverId) {
   const args = [
     "--host",
     options.host ?? "127.0.0.1",
-    "--port",
-    String(options.port ?? 8321),
-    "--socket-path",
-    socketPath,
+    ...process.platform === "win32" ? ["--no-socket"] : ["--port", String(options.port ?? 8321), "--socket-path", socketPath ?? ""],
     "--server-id",
     serverId,
     "--storage",
@@ -5959,28 +6097,40 @@ async function probeGateway(socketPath, serverId) {
     return false;
   }
 }
-function makeHandle(serverId, socketPath, host, port, spawned) {
+async function probeWs(wsUrl, serverId) {
+  try {
+    const probe = await connectNekoGateway({ transport: "ws", url: wsUrl, serverId });
+    await probe.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function makeHandle(serverId, socketPath, wsUrl, spawned, nekoDir) {
   return {
     serverId,
     socketPath,
-    wsUrl: `ws://${host}:${port}`,
+    wsUrl,
     spawned,
     async close() {
-      if (spawned !== null)
+      if (spawned !== null) {
         await stopGatewayProcess(spawned);
+        if (process.platform === "win32")
+          await removeGatewayPortFile(nekoDir, serverId).catch(() => {});
+      }
     }
   };
 }
 async function loadOrCreateServerId2(nekoDir) {
-  const file = join10(nekoDir, SERVER_ID_FILENAME3);
+  const file = join11(nekoDir, SERVER_ID_FILENAME3);
   try {
-    const existing = (await readFile6(file, "utf8")).trim();
+    const existing = (await readFile7(file, "utf8")).trim();
     if (existing !== "")
       return existing;
   } catch {}
   const created = randomUUID2();
   await mkdir3(nekoDir, { recursive: true, mode: 448 });
-  await writeFile2(file, `${created}
+  await writeFile3(file, `${created}
 `, { mode: 384 });
   return created;
 }
@@ -6215,7 +6365,7 @@ var USAGE2 = `\u7528\u6CD5: main.ts [\u9009\u9879]
   --port <n>           \u9759\u6001 HTTP \u7AEF\u53E3\uFF08\u9ED8\u8BA4 8322\uFF09
   --host <ip>          \u9759\u6001 HTTP \u5730\u5740\uFF08\u9ED8\u8BA4 127.0.0.1\uFF09
   --gateway-port <n>   \u7F51\u5173 WebSocket \u7AEF\u53E3\uFF08\u9ED8\u8BA4 8321\uFF09
-  --socket-path <path> \u7F51\u5173 Unix socket \u8DEF\u5F84\uFF08\u9ED8\u8BA4 <\u6570\u636E\u76EE\u5F55>/<serverId>.sock\uFF09
+  --socket-path <path> \u7F51\u5173 Unix socket \u8DEF\u5F84\uFF08\u9ED8\u8BA4 <\u6570\u636E\u76EE\u5F55>/<serverId>.sock\uFF1B\u4EC5 POSIX\uFF09
   --server-id <id>     \u7F51\u5173\u903B\u8F91\u8EAB\u4EFD\uFF08\u9ED8\u8BA4\u8BFB\u53D6/\u751F\u6210 <\u6570\u636E\u76EE\u5F55>/gateway-server-id\uFF09
   --storage <path>     SQLite \u5B58\u50A8\u6587\u4EF6\uFF08\u9ED8\u8BA4 ~/.neko/neko.sqlite\uFF09
   --cwd <dir>          \u4F1A\u8BDD\u5DE5\u5177\u7684\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
@@ -6269,8 +6419,8 @@ var init_main2 = __esm(async () => {
   }
 });
 
-// packages/gateway/src/main.ts
-function parseArgs3(argv) {
+// packages/gateway/src/cli-args.ts
+function parseGatewayArgs(argv) {
   let port;
   const options = {};
   for (let i = 0;i < argv.length; i++) {
@@ -6304,6 +6454,9 @@ function parseArgs3(argv) {
         options.socketPath = next;
         i++;
         break;
+      case "--no-socket":
+        options.socketPath = null;
+        break;
       case "--server-id":
         if (next === undefined)
           throw new Error("--server-id \u9700\u8981\u53C2\u6570");
@@ -6344,11 +6497,6 @@ function parseArgs3(argv) {
         options.configDir = next;
         i++;
         break;
-      case "-h":
-      case "--help":
-        console.log(USAGE3);
-        process.exit(0);
-        break;
       default:
         throw new Error(`\u672A\u77E5\u9009\u9879: ${arg}`);
     }
@@ -6357,12 +6505,13 @@ function parseArgs3(argv) {
     options.port = port;
   return options;
 }
-var USAGE3 = `\u7528\u6CD5: main.ts [\u9009\u9879]
+var GATEWAY_USAGE = `\u7528\u6CD5: main.ts [\u9009\u9879]
 
 \u9009\u9879:
-  --host <ip>          WebSocket \u76D1\u542C\u5730\u5740\uFF08\u9ED8\u8BA4 127.0.0.1\uFF0C\u4EC5\u672C\u673A\uFF1B0/null \u7981\u7528 WS\uFF09
-  --port <n>           WebSocket \u76D1\u542C\u7AEF\u53E3\uFF08\u9ED8\u8BA4 8321\uFF1B0 = \u968F\u673A\u5206\u914D\uFF09
-  --socket-path <path> Unix socket \u8DEF\u5F84\uFF08\u9ED8\u8BA4 <\u6570\u636E\u76EE\u5F55>/<serverId>.sock\uFF09
+  --host <ip>          WebSocket \u76D1\u542C\u5730\u5740\uFF08\u9ED8\u8BA4 127.0.0.1\uFF0C\u4EC5\u672C\u673A\uFF09
+  --port <n>           WebSocket \u76D1\u542C\u7AEF\u53E3\uFF08\u9ED8\u8BA4 8321\uFF0CWindows \u9ED8\u8BA4\u968F\u673A\uFF1B0/null \u7981\u7528 WS\uFF09
+  --socket-path <path> Unix socket \u8DEF\u5F84\uFF08\u9ED8\u8BA4 <\u6570\u636E\u76EE\u5F55>/<serverId>.sock\uFF1BWindows \u9ED8\u8BA4\u7981\u7528\uFF09
+  --no-socket          \u7981\u7528 Unix socket \u4F20\u8F93\uFF08\u4EC5 WebSocket\uFF09
   --server-id <id>     \u903B\u8F91\u670D\u52A1\u5668\u8EAB\u4EFD\uFF08\u9ED8\u8BA4\u8BFB\u53D6/\u751F\u6210 <\u6570\u636E\u76EE\u5F55>/gateway-server-id\uFF09
   --cwd <dir>          \u4F1A\u8BDD\u5DE5\u5177\u7684\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
   --model <ref>        \u6A21\u578B\uFF0C\u683C\u5F0F provider/modelId\uFF08\u9ED8\u8BA4 deepseek/deepseek-flash\uFF09
@@ -6371,7 +6520,10 @@ var USAGE3 = `\u7528\u6CD5: main.ts [\u9009\u9879]
   --config <dir>       neko.config.json \u67E5\u627E\u8D77\u59CB\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
   -h, --help           \u663E\u793A\u6B64\u5E2E\u52A9
 
-\u53EF\u901A\u8FC7\u524D\u7AEF\u8BBE\u7F6E\u6216 DEEPSEEK_API_KEY \u914D\u7F6E\u51ED\u636E\u3002`, options, gateway, stopping = false, stop = () => {
+\u53EF\u901A\u8FC7\u524D\u7AEF\u8BBE\u7F6E\u6216 DEEPSEEK_API_KEY \u914D\u7F6E\u51ED\u636E\u3002`;
+
+// packages/gateway/src/main.ts
+var argv, options, gateway, stopping = false, stop = () => {
   if (stopping)
     return;
   stopping = true;
@@ -6382,7 +6534,12 @@ var USAGE3 = `\u7528\u6CD5: main.ts [\u9009\u9879]
 };
 var init_main3 = __esm(async () => {
   init_gateway();
-  options = parseArgs3(process.argv.slice(2));
+  argv = process.argv.slice(2);
+  if (argv.includes("-h") || argv.includes("--help")) {
+    console.log(GATEWAY_USAGE);
+    process.exit(0);
+  }
+  options = parseGatewayArgs(argv);
   gateway = await startGateway({
     ...options,
     onError: (error) => console.error("gateway error:", error.message)
@@ -6398,12 +6555,12 @@ var init_main3 = __esm(async () => {
 });
 
 // packages/cli/src/main.ts
-var USAGE4 = `\u7528\u6CD5: neko <command> [options]
+var USAGE3 = `\u7528\u6CD5: neko <command> [options]
 
 \u547D\u4EE4:
   tui     \u542F\u52A8\u7EC8\u7AEF\u4EA4\u4E92\u754C\u9762\uFF08\u81EA\u52A8\u62C9\u8D77 gateway\uFF09
   web     \u542F\u52A8 Web UI \u9759\u6001\u6258\u7BA1\uFF08\u81EA\u52A8\u62C9\u8D77 gateway\uFF09
-  serve   \u4EC5\u542F\u52A8 gateway\uFF08Unix socket + WebSocket\uFF09
+  serve   \u4EC5\u542F\u52A8 gateway\uFF08WebSocket\uFF1BPOSIX \u53E6\u6709 Unix socket\uFF09
 
 \u5404\u547D\u4EE4\u7684\u9009\u9879\u900F\u4F20\uFF0C\u8BE6\u89C1 neko <command> --help\u3002
 \u53EF\u901A\u8FC7 TUI /login\u3001Web \u8BBE\u7F6E\u9875\u6216 DEEPSEEK_API_KEY / TAVILY_API_KEY \u914D\u7F6E\u51ED\u636E\u3002`;
@@ -6423,16 +6580,16 @@ switch (command2) {
   }
   case "--version":
   case "-v":
-    console.log("0.1.0");
+    console.log("0.2.0");
     break;
   case undefined:
   case "-h":
   case "--help":
-    console.log(USAGE4);
+    console.log(USAGE3);
     break;
   default:
     console.error(`\u672A\u77E5\u547D\u4EE4: ${command2}
 
-${USAGE4}`);
+${USAGE3}`);
     process.exitCode = 1;
 }

package/package.json

@@ -24,7 +24,7 @@
 	},
 	"packageManager": "bun@1.4.2",
 	"trustedDependencies": [],
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "A local AI coding assistant with terminal and web interfaces, powered by Pi and Bun.",
 	"license": "MIT",
 	"repository": {