nx-ce 0.1.5 → 0.1.7

package/README.md

@@ -41,12 +41,13 @@ nx-ce query "用中文回答：1+1=？" --model claude-haiku-4-5
 # Start WebSocket server (persistent, multi-session)
 nx-ce serve --port 3100
 
-# In another terminal, connect via WebSocket (see test/serve-test.mjs)
+# In another terminal, run tests
+node test/serve-test.mjs
 ```
 
 ---
 
-## `nx-ce query` — One-shot Cold-Start Query / 一次性冷启动查询
+## `nx-ce query` — One-Shot Cold-Start Query / 一次性冷启动查询
 
 ```bash
 nx-ce query "解释这段代码" --model claude-sonnet-4-6
@@ -80,9 +81,9 @@ nx-ce query "Analyze" --skill all
 
 ## `nx-ce serve` — WebSocket Multi-Session Server / WebSocket 多会话服务器
 
-**Single process. Multiple concurrent sessions. FIFO queries per session.**
+**Single process. Multiple concurrent sessions. Each session has its own cwd.**
 
-单例进程。多会话隔离。每个会话独立 SDK agentQuery，互不阻塞。
+单例进程。多会话隔离。每个会话可指定自己的工作目录。
 
 ```bash
 nx-ce serve                     # default port 3100
@@ -96,7 +97,7 @@ nx-ce serve --name "main" --port 3100 --cwd "D:/project"
 | `--port <port>` | WebSocket port (default `3100`) / 端口 |
 | `--model <id>` | Model override / 模型 ID |
 | `--claude-path <path>` | Path to Claude CLI / CLI 路径 |
-| `--cwd <path>` | Working directory / 工作目录 |
+| `--cwd <path>` | Default working directory / 默认工作目录 |
 | `--env "KEY=val,..."` | Extra env vars / 额外环境变量 |
 
 > WebSocket address: `ws://127.0.0.1:3100` (localhost only)
@@ -105,7 +106,58 @@ nx-ce serve --name "main" --port 3100 --cwd "D:/project"
 
 ```bash
 nx-ce serve --port 3100      # first → OK
-nx-ce serve --port 3100      # second → Port 3100 already in use — another nx-ce serve is running
+nx-ce serve --port 3100      # second → Port already in use — another instance is running
+```
+
+---
+
+## Multi-Session / 多会话管理
+
+### Auto-create on first query / 首次 query 自动创建
+
+Session 是**隐式创建**的。第一次发 `query` 时自动创建 SDK 会话，之后同名的 query 续接上下文：
+
+```javascript
+// 新会话 "proj-a"，工作目录 D:/project-a
+→ { "type": "query", "session": "proj-a", "cwd": "D:/project-a", "prompt": "分析目录结构" }
+
+// 新会话 "proj-b"，工作目录 D:/project-b（不同的 session 名 = 不同的 agentQuery）
+→ { "type": "query", "session": "proj-b", "cwd": "D:/project-b", "prompt": "分析目录结构" }
+
+// 同一 session 名 + 不同 cwd → 也是独立的 agentQuery
+→ { "type": "query", "session": "proj-a", "cwd": "D:/project-a/src", "prompt": "分析 src" }
+```
+
+内部标识 key 格式为 `{name}:{cwd}`：
+
+```
+proj-a:D~project-a       → SDK 会话 A
+proj-b:D~project-b       → SDK 会话 B
+proj-a:D~project-a~src   → SDK 会话 C
+```
+
+### Close session / 关闭会话
+
+```javascript
+// 关闭精确会话（指定 cwd）
+→ { "type": "closeSession", "session": "proj-a", "cwd": "D:/project-a" }
+
+// 关闭该 name 下所有 cwd 变体
+→ { "type": "closeSession", "session": "proj-a" }
+```
+
+### Idle auto-reclaim / 空闲自动回收
+
+客户端断开连接 5 分钟后，session 自动销毁并清理状态文件。
+
+### List sessions / 查看会话
+
+```javascript
+→ { "type": "listSessions" }
+← { "type": "session_list", "sessions": [
+    { "name": "proj-a", "cwd": "D:/project-a", "sessionId": "sess_xxx", "processing": false },
+    { "name": "proj-b", "cwd": "D:/project-b", "sessionId": "sess_yyy", "processing": true }
+  ]}
 ```
 
 ---
@@ -118,21 +170,22 @@ Server: `ws://127.0.0.1:PORT`. All messages are JSON (no length prefix).
 
 | type | Fields / 字段 | Description / 说明 |
 |------|---------------|-------------------|
-| `query` | `prompt: string`, `session?: string`, `id?: string` | Submit a query / 发起查询 |
+| `query` | `prompt: string`, `session?: string`, `cwd?: string`, `id?: string` | Submit a query / 发起查询 |
 | `ping` | — | Heartbeat / 心跳 |
-| `getSkills` | `session?: string` | Fetch skills/tools/agents / 拉取元数据 |
-| `getStatus` | `session?: string` | Query session status / 查询状态 |
-| `closeSession` | `session: string` | Close a session / 关闭会话 |
+| `getSkills` | `session?: string`, `cwd?: string` | Fetch skills/tools/agents / 拉取元数据 |
+| `getStatus` | `session?: string`, `cwd?: string` | Query session status / 查询状态 |
+| `closeSession` | `session: string`, `cwd?: string` | Close session(s) / 关闭会话 |
 | `listSessions` | — | List all active sessions / 列出会话 |
 
-`session` defaults to `"default"` if omitted.
+`session` defaults to `"default"`.
 
 ```json
-→ { "type": "query",   "session": "tab-1", "prompt": "分析这个目录" }
+→ { "type": "query",        "session": "proj-a", "cwd": "D:/project-a", "prompt": "分析" }
 → { "type": "ping" }
-→ { "type": "getSkills",         "session": "tab-1" }
-→ { "type": "getStatus",         "session": "tab-1" }
-→ { "type": "closeSession",      "session": "tab-1" }
+→ { "type": "getSkills",    "session": "proj-a" }
+→ { "type": "getStatus",    "session": "proj-a", "cwd": "D:/project-a" }
+→ { "type": "closeSession", "session": "proj-a", "cwd": "D:/project-a" }
+→ { "type": "closeSession", "session": "proj-a" }
 → { "type": "listSessions" }
 ```
 
@@ -142,7 +195,7 @@ Server: `ws://127.0.0.1:PORT`. All messages are JSON (no length prefix).
 
 ```json
 ← { "type": "connected", "port": 3100, "host": "MY-PC",
-    "machineId": "744e51b9-ad7d-85bb-1600-bbfb", "serverTime": 1780736149028 }
+    "machineId": "744e51b9-...", "serverTime": 1780736149028 }
 ```
 
 **Session init (auto-push on first query per session) / 会话初始化（自动推送）:**
@@ -161,7 +214,7 @@ Server: `ws://127.0.0.1:PORT`. All messages are JSON (no length prefix).
 ← { "type": "turn_start", "turn": "turn_xxx", "time": ... }
 ← { "type": "text",     "content": "这是一段回复...", "time": ... }
 ← { "type": "thinking", "content": "模型思考过程...", "time": ... }
-← { "type": "tool_use", "name": "readFile", "input": {...}, "id": "toolu_xxx" }
+← { "type": "tool_use", "name": "readFile", "input": {...} }
 ← { "type": "done",     "sessionId": "sess_xxx", "time": ... }
 ```
 
@@ -170,19 +223,19 @@ Server: `ws://127.0.0.1:PORT`. All messages are JSON (no length prefix).
 ```json
 ← { "type": "pong",          "sessionId": "sess_xxx", "serverTime": ... }
 ← { "type": "skills",        "skills": [...], "tools": [...], ... }
-← { "type": "status",        "session": "tab-1", "sessionId": "sess_xxx", "isActive": true, "queueLength": 0, "processing": false }
-← { "type": "session_list",  "sessions": [{ "name": "tab-1", ... }, ...] }
-← { "type": "session_closed","session": "tab-1" }
+← { "type": "status",        "session": "proj-a", "cwd": "D:/project-a", "sessionId": "...", "isActive": true }
+← { "type": "session_list",  "sessions": [{ "name":"proj-a", "cwd":"D:/project-a", ... }, ...] }
+← { "type": "session_closed","session": "proj-a", "cwd": "D:/project-a" }
 ← { "type": "error",         "content": "error message" }
 ```
 
 ### Full exchange example / 完整示例
 
 ```
-→ { "type":"query", "session":"tab-1", "prompt":"Hello" }
+→ { "type":"query", "session":"proj-a", "cwd":"D:/project-a", "prompt":"Hello" }
 ← { "type":"turn_start", "turn":"turn_xxx", "time":... }
-← { "type":"text",      "content":"Hello! How can I help you today?" }
-← { "type":"done",      "sessionId":"sess_abc", "time":... }
+← { "type":"text",       "content":"Hello! How can I help?" }
+← { "type":"done",       "sessionId":"sess_abc", "time":... }
 
 → { "type":"ping" }
 ← { "type":"pong",       "sessionId":"sess_abc", "serverTime":... }
@@ -190,51 +243,41 @@ Server: `ws://127.0.0.1:PORT`. All messages are JSON (no length prefix).
 
 ---
 
-## Multi-Session Architecture / 多会话架构
+## Architecture / 架构
 
 ```
                         nx-ce serve (single Node.js process)
-  ┌───────────────────────────────────────────────────────────┐
+  ┌──────────────────────────────────────────────────────────┐
   │  WebSocket Server (127.0.0.1:3100)                       │
   │                                                           │
   │  SessionManager                                           │
   │  ┌─────────────────────────────────────────────────────┐  │
-  │  │  "tab-1": { agentQuery(), messageChannel, queue }   │  │
-  │  │  "tab-2": { agentQuery(), messageChannel, queue }   │  │
-  │  │  "tab-3": { agentQuery(), messageChannel, queue }   │  │
+  │  │  "proj-a:D~/project-a" → agentQuery(cwd: project-a) │  │
+  │  │  "proj-b:D~/project-b" → agentQuery(cwd: project-b) │  │
+  │  │  "proj-a:D~/other"    → agentQuery(cwd: other)     │  │
   │  └──────────────────────┬──────────────────────────────┘  │
   │              spawn each | (SDK manages CLI processes)     │
-  │         Claude CLI ─────┴──── Claude CLI ───── Claude CLI │
+  │    Claude CLI ──────────┴── Claude CLI ──── Claude CLI    │
   └───────────────────────────────────────────────────────────┘
 ```
 
+### Session identity / 会话标识
+
+Session key = `{name}:{cwd}`. Same name + different cwd = different SDK session.
+Each session has its own `agentQuery()`, `MessageChannel`, `MonotonicClock`, and state file.
+
 ### Concurrency guarantees / 竞态保护
 
 | Race / 竞态 | Solution / 方案 |
 |-------------|----------------|
 | Concurrent session creation | `_pendingCreates` Map deduplicates in-flight creation promises |
 | SDK response routing | Each session has independent `for await` loop, writes only to `session.client` |
-| State file overwrite | Per-session files (`{name}.json`) + write lock |
-| Message ordering | Per-session `MonotonicClock` ensures strict time ordering |
+| State file overwrite | Per-session files (`{name~cwd}.json`) |
+| Message ordering | Per-session `MonotonicClock` ensures strict ordering |
 | Client disconnect cleanup | Null client ref + clear queue + 5-min idle timeout auto-destroy |
 
 ---
 
-## `nx-ce status` — Instance Status / 查看实例状态
-
-```bash
-nx-ce status                  # List all instances
-nx-ce status --name chat-1    # Show specific instance
-```
-
-```json
-{ "name": "chat-1", "pid": 12345, "lifecycleState": "running",
-  "sessionId": "sess_abc", "model": "claude-sonnet-4-6",
-  "port": 3100, "host": "MY-PC" }
-```
-
----
-
 ## `nx-ce skills` — List Available Skills / 列出可用 Skill
 
 ```bash
@@ -252,18 +295,16 @@ nx-ce skills --cwd "D:/project"
 
 ## State Persistence / 状态持久化
 
-State files at `~/.nx-ce/instances/{name}.json`:
+State files at `~/.nx-ce/instances/{key}.json`. Key format: `{name}~{cwd}`.
 
 ```json
 {
-  "name": "chat-tab-1",
-  "pid": 12345,
-  "startedAt": "2026-06-06T10:30:00.000Z",
-  "updatedAt": "2026-06-06T11:00:00.000Z",
+  "name": "proj-a:D~/project-a",
   "sessionId": "sess_abc123",
   "model": "claude-sonnet-4-6",
+  "cwd": "D:/project-a",
   "host": "MY-PC",
-  "machineId": "a1b2c3d4-e5f6-...",
+  "machineId": "744e51b9-...",
   "lifecycleState": "running",
   "port": 3100,
   "usage": { "inputTokens": 1500, "outputTokens": 3200, ... }
@@ -279,21 +320,6 @@ State files at `~/.nx-ce/instances/{name}.json`:
 
 ---
 
-## Architecture / 架构
-
-```
-Chrome Extension / 浏览器扩展
-       ↕ WebSocket (ws://127.0.0.1:3100)
-nx-ce serve (Node.js)
-  ├─ SessionManager → agentQuery()
-  │                     ↕
-  │                  Claude CLI
-  │
-  └─ (Native Host via exec.Command → nx-ce query --resume)
-```
-
----
-
 ## Development / 开发
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx-ce",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Claude Engine — SDK adapter layer for native messaging host. Bridges @anthropic-ai/claude-agent-sdk calls over a length-prefixed JSON protocol.",
   "type": "module",
   "main": "src/index.js",

package/src/serve.js

@@ -5,6 +5,9 @@
  * 每个会话（session）拥有独立的 agentQuery()、MessageChannel 和状态文件，
  * 天然并行，互不阻塞。
  *
+ * 会话标识 = name:cwd（同一 name 不同 cwd 视为不同会话）。
+ * 客户端可通过 query 消息的 cwd 字段指定工作目录。
+ *
  * 竞态保护：
  *   - session 创建：pendingCreates Map 防止重复创建
  *   - client 绑定：SDK 回复只写 session.client，不走 broadcast
@@ -24,6 +27,31 @@ const DEFAULT_PORT = 3100;
 /** 空闲 session 超时（毫秒），超过此时间无客户端则自动关闭 */
 const SESSION_IDLE_TIMEOUT_MS = 300_000; // 5 分钟
 
+// =================================================================
+// 工具函数
+// =================================================================
+
+/**
+ * 生成 session 内部标识 key。
+ * 同一 name 不同 cwd 产生不同 key，各自独立 agentQuery。
+ *
+ * @param {string} name - 会话名称（来自客户端）
+ * @param {string} [cwd] - 工作目录
+ * @returns {string} 内部 key
+ */
+function sessionKey(name, cwd) {
+  if (cwd) return `${name}:${cwd}`;
+  return name;
+}
+
+/**
+ * 从 sessionKey 中提取原始 name（用于 closeSession 匹配）。
+ */
+function baseName(key) {
+  const idx = key.indexOf(':');
+  return idx === -1 ? key : key.slice(0, idx);
+}
+
 // =================================================================
 // SessionManager — 管理多个独立 SDK 会话
 // =================================================================
@@ -40,56 +68,58 @@ class SessionManager {
 
     /** 清理定时器 */
     this._idleTimers = new Map();
-
-    /** 会话状态文件写锁 */
-    this._writeLocks = new Map();
   }
 
   /**
    * 获取或创建一个 session。
-   * 如果另一个协程正在创建同名 session，则等待其完成。
+   * 以 (name, cwd) 为唯一标识。
+   * 如果另一个协程正在创建同 key session，则等待其完成。
    *
-   * @param {string} name - session 名称（每个客户端/标签页唯一）
+   * @param {string} name - 会话名称
+   * @param {string} [cwd] - 工作目录（可选，默认服务器级 cwd）
    * @returns {Promise<Session>}
    */
-  async getOrCreate(name) {
+  async getOrCreate(name, cwd) {
+    const key = sessionKey(name, cwd);
+
     // 已有活跃 session → 直接返回
-    const existing = this.sessions.get(name);
+    const existing = this.sessions.get(key);
     if (existing && !existing.closed) {
-      // 取消 idle 定时器（客户端回来了）
-      this._cancelIdleTimer(name);
+      this._cancelIdleTimer(key);
       return existing;
     }
 
     // 正在被另一个协程创建 → 等它
-    if (this._pendingCreates.has(name)) {
-      return this._pendingCreates.get(name);
+    if (this._pendingCreates.has(key)) {
+      return this._pendingCreates.get(key);
     }
 
     // 创建锁 + 创建
-    const promise = this._createSession(name);
-    this._pendingCreates.set(name, promise);
+    const promise = this._createSession(name, key, cwd);
+    this._pendingCreates.set(key, promise);
 
     try {
       return await promise;
     } finally {
-      this._pendingCreates.delete(name);
+      this._pendingCreates.delete(key);
     }
   }
 
   /**
    * 创建内部 session 结构。
-   * 注意：JS 是单线程 event loop，此函数不会被并发调用（pendingCreates 保证）。
    */
-  async _createSession(name) {
-    const { claudePath, model, cwd, env } = this.serverOptions;
+  async _createSession(name, key, cwd) {
+    const { claudePath, model, env } = this.serverOptions;
+
+    // session 用自己的 cwd（优先客户端传入，fallback 到服务器级）
+    const actualCwd = cwd || this.serverOptions.cwd || process.cwd();
 
-    // 检查是否有可恢复的会话状态
-    const existingState = readState(name);
+    // 检查是否有可恢复的会话状态（按 key 存储，实现不同目录独立状态）
+    const existingState = readState(key);
 
     // 组装 SDK 选项
     const sdkOptions = {
-      cwd: cwd || process.cwd(),
+      cwd: actualCwd,
       model: model || 'claude-sonnet-4-6',
       pathToClaudeCodeExecutable: claudePath,
       permissionMode: 'bypassPermissions',
@@ -140,9 +170,10 @@ class SessionManager {
     // 启动 SDK 持久化查询
     const response = agentQuery({ prompt: messageChannel, options: sdkOptions });
 
-    /** @type {Session} */
     const session = {
-      name,
+      key,              // 内部标识：name:cwd
+      name,             // 客户端名称
+      cwd: actualCwd,   // session 自己的工作目录
       messageChannel,
       enqueueMessage,
       onTurnComplete,
@@ -161,22 +192,19 @@ class SessionManager {
       existingState,
 
       // 客户端状态
-      client: null,        // 当前绑定的 WebSocket 客户端
-      queue: [],           // 待处理查询 FIFO
-      turnActive: false,   // SDK 是否正在处理
+      client: null,
+      queue: [],
       currentTurnId: null,
       processing: false,
 
       // 元数据
       sessionId: existingState?.sessionId || null,
-      metadata: null,       // init 消息中的 skills/tools 等
+      metadata: null,
       clock: new MonotonicClock(),
       closed: false,
 
-      // 消费 Promise（用于等待关闭）
       consumerPromise: null,
 
-      // usage 追踪
       usage: existingState?.usage || {
         inputTokens: 0,
         outputTokens: 0,
@@ -190,9 +218,9 @@ class SessionManager {
     // 后台消费 SDK 输出
     session.consumerPromise = this._startConsumer(session);
 
-    this.sessions.set(name, session);
+    this.sessions.set(key, session);
 
-    // 持久化初始状态
+    // 持久化初始状态（使用 key 做文件名，不同 cwd 独立文件）
     this._safeWriteState(session);
 
     return session;
@@ -200,13 +228,11 @@ class SessionManager {
 
   /**
    * 后台消费循环 — 每个 session 独立。
-   * SDK 回复只会写入 session.client（绑定的 WS 客户端）。
    */
   _startConsumer(session) {
     return (async () => {
       try {
         for await (const message of session.response) {
-          // init 消息 → 捕获元数据
           if (message.type === 'system' && message.subtype === 'init') {
             session.sessionId = message.session_id;
             session.metadata = {
@@ -217,15 +243,13 @@ class SessionManager {
               tools: message.tools || [],
               slashCommands: message.slash_commands || [],
               agents: message.agents || [],
+              cwd: session.cwd,
               time: session.clock.next(),
             };
             this._safeWriteState(session);
-
-            // 推给当前绑定的客户端
             this._send(session.client, session.metadata);
           }
 
-          // 助手消息 → 分块转发
           if (message.type === 'assistant' && message.message?.content) {
             const content = message.message.content;
             if (typeof content === 'string') {
@@ -243,11 +267,9 @@ class SessionManager {
             }
           }
 
-          // result → 回合结束
           if (message.type === 'result') {
             this._send(session.client, { type: 'done', sessionId: session.sessionId, time: session.clock.next() });
 
-            // usage 累积
             if (message.usage) {
               const u = message.usage;
               session.usage = {
@@ -261,11 +283,10 @@ class SessionManager {
             }
 
             session.onTurnComplete();
-            session.client = null;     // 解绑客户端，允许下一个 query 绑定
+            session.client = null;
             session.processing = false;
             this._safeWriteState(session);
 
-            // 异步处理队列中的下一个请求
             setImmediate(() => this._processQueue(session));
           }
         }
@@ -304,44 +325,38 @@ class SessionManager {
     session.enqueueMessage(sdkMessage);
   }
 
-  /** 向一个 WS 客户端发 JSON（安全断开则跳过） */
+  /** 向一个 WS 客户端发 JSON */
   _send(client, data) {
     if (client && client.readyState === 1) {
       client.send(JSON.stringify(data));
     }
   }
 
-  /** 持久化 session 状态（写锁防止同名并发写） */
+  /** 持久化 session 状态（按 key 为文件名） */
   _safeWriteState(session) {
-    const name = session.name;
-    // JS 单线程，用简单 flag 防同一 session 的递归写
-    writeState(name, createState(name, {
+    writeState(session.key, createState(session.key, {
       sessionId: session.sessionId,
       model: session.sdkOptions.model,
+      cwd: session.cwd,
       usage: session.usage,
     }));
   }
 
-  /** 取消 idle 定时器 */
-  _cancelIdleTimer(name) {
-    const timer = this._idleTimers.get(name);
+  _cancelIdleTimer(key) {
+    const timer = this._idleTimers.get(key);
     if (timer) {
       clearTimeout(timer);
-      this._idleTimers.delete(name);
+      this._idleTimers.delete(key);
     }
   }
 
-  /** 安排 idle 关闭 */
-  _scheduleIdleCleanup(name) {
-    this._cancelIdleTimer(name);
-    this._idleTimers.set(name, setTimeout(() => {
-      this.destroy(name, 'idle timeout');
+  _scheduleIdleCleanup(key) {
+    this._cancelIdleTimer(key);
+    this._idleTimers.set(key, setTimeout(() => {
+      this.destroy(key, 'idle timeout');
     }, SESSION_IDLE_TIMEOUT_MS));
   }
 
-  /**
-   * 从 session 队列中移除指定客户端的所有待处理请求。
-   */
   removeClientFromQueue(session, ws) {
     if (!session || session.closed) return;
     session.queue = session.queue.filter(item => item.client !== ws);
@@ -349,40 +364,41 @@ class SessionManager {
 
   /**
    * 销毁一个 session。
+   * @param {string} key - 内部 key（name:cwd）
    */
-  async destroy(name, reason = 'shutdown') {
-    const session = this.sessions.get(name);
+  async destroy(key, reason = 'shutdown') {
+    const session = this.sessions.get(key);
     if (!session || session.closed) return;
     session.closed = true;
-    this._cancelIdleTimer(name);
+    this._cancelIdleTimer(key);
 
-    // 关闭 MessageChannel → SDK next() 返回 done
     session.closeChannel();
 
-    // 中断 SDK 查询
-    try {
-      await session.response.interrupt();
-    } catch { /* ignore */ }
-
-    // 等待消费循环结束
-    try {
-      await session.consumerPromise;
-    } catch { /* ignore */ }
+    try { await session.response.interrupt(); } catch { /* ignore */ }
+    try { await session.consumerPromise; } catch { /* ignore */ }
 
-    this.sessions.delete(name);
+    this.sessions.delete(key);
 
-    // 如果是正常关闭才清理状态文件（crash 留文件便于恢复）
     if (reason !== 'crash') {
-      deleteState(name);
+      deleteState(key);
     }
   }
 
+  /**
+   * 按客户端 name 销毁匹配的所有 session（包括不同 cwd）。
+   * @param {string} name - 客户端传入的 session 名称
+   */
+  async destroyByName(name) {
+    const keys = [...this.sessions.keys()].filter(k => baseName(k) === name);
+    await Promise.allSettled(keys.map(k => this.destroy(k, 'client request')));
+  }
+
   /**
    * 销毁所有 session。
    */
   async destroyAll(reason = 'shutdown') {
-    const names = [...this.sessions.keys()];
-    await Promise.allSettled(names.map(name => this.destroy(name, reason)));
+    const keys = [...this.sessions.keys()];
+    await Promise.allSettled(keys.map(k => this.destroy(k, reason)));
   }
 }
 
@@ -400,11 +416,10 @@ export async function startServe(options) {
   const host = hostname();
   const osInfo = `${platform()}/${release()}/${machine()}`;
 
-  // 服务器级别状态
   const serverState = readState(name);
   const serverSessionId = serverState?.sessionId || null;
 
-  // 创建 SessionManager
+  // 创建 SessionManager（cwd 为服务器级默认，session 可覆盖）
   const sessionManager = new SessionManager({ claudePath, model, cwd, env });
 
   // =================================================================
@@ -413,7 +428,6 @@ export async function startServe(options) {
 
   const wss = new WebSocketServer({ port, host: '127.0.0.1' });
 
-  // 等待服务器就绪
   await new Promise((resolve, reject) => {
     wss.once('listening', resolve);
     wss.once('error', (err) => {
@@ -424,7 +438,6 @@ export async function startServe(options) {
     });
   });
 
-  // 写入服务器级状态
   writeState(name, {
     name,
     pid: process.pid,
@@ -438,7 +451,6 @@ export async function startServe(options) {
 
   // 客户端连接处理
   wss.on('connection', (ws) => {
-    // 初始连接消息
     ws.send(JSON.stringify({
       type: 'connected',
       port,
@@ -465,16 +477,16 @@ export async function startServe(options) {
             break;
           }
 
-          // 获取或创建 session（创建锁保证并发安全）
+          // 支持每个 query 指定自己的工作目录
+          // 同一 session name + 不同 cwd = 不同 SDK 会话
           let session;
           try {
-            session = await sessionManager.getOrCreate(sessionName);
+            session = await sessionManager.getOrCreate(sessionName, req.cwd);
           } catch (err) {
             ws.send(JSON.stringify({ type: 'error', content: `session create failed: ${err.message}` }));
             break;
           }
 
-          // 入队
           session.queue.push({ client: ws, prompt: req.prompt, id: req.id });
           sessionManager._processQueue(session);
           break;
@@ -485,7 +497,9 @@ export async function startServe(options) {
           break;
 
         case 'getSkills': {
-          const session = sessionManager.sessions.get(sessionName);
+          // 按 (name, cwd) 查 session
+          const key = sessionKey(sessionName, req.cwd);
+          const session = sessionManager.sessions.get(key);
           if (session?.metadata) {
             ws.send(JSON.stringify(session.metadata));
           } else {
@@ -502,10 +516,12 @@ export async function startServe(options) {
         }
 
         case 'getStatus': {
-          const session = sessionManager.sessions.get(sessionName);
+          const key = sessionKey(sessionName, req.cwd);
+          const session = sessionManager.sessions.get(key);
           ws.send(JSON.stringify({
             type: 'status',
             session: sessionName,
+            cwd: req.cwd || cwd || process.cwd(),
             sessionId: session?.sessionId || null,
             isActive: session ? !session.closed : false,
             queueLength: session?.queue?.length || 0,
@@ -515,16 +531,26 @@ export async function startServe(options) {
         }
 
         case 'closeSession': {
-          await sessionManager.destroy(sessionName, 'client request');
-          ws.send(JSON.stringify({ type: 'session_closed', session: sessionName }));
+          if (req.cwd) {
+            // 精确关闭：name + cwd
+            const key = sessionKey(sessionName, req.cwd);
+            await sessionManager.destroy(key, 'client request');
+            ws.send(JSON.stringify({ type: 'session_closed', session: sessionName, cwd: req.cwd }));
+          } else {
+            // 关闭该 name 下所有 cwd 变体
+            await sessionManager.destroyByName(sessionName);
+            ws.send(JSON.stringify({ type: 'session_closed', session: sessionName }));
+          }
           break;
         }
 
         case 'listSessions': {
           const sessions = [...sessionManager.sessions.entries()]
             .filter(([_, s]) => !s.closed)
-            .map(([name, s]) => ({
-              name,
+            .map(([key, s]) => ({
+              name: s.name,
+              key,
+              cwd: s.cwd,
               sessionId: s.sessionId,
               queueLength: s.queue.length,
               processing: s.processing,
@@ -540,15 +566,14 @@ export async function startServe(options) {
 
     // 客户端断开 → 清理引用
     ws.on('close', () => {
-      for (const [sName, session] of sessionManager.sessions) {
+      for (const [sKey, session] of sessionManager.sessions) {
         if (session.client === ws) {
           session.client = null;
         }
         sessionManager.removeClientFromQueue(session, ws);
 
-        // 如果没有客户端了，安排 idle 回收
         if (session.client === null && session.queue.length === 0 && !session.closed) {
-          sessionManager._scheduleIdleCleanup(sName);
+          sessionManager._scheduleIdleCleanup(sKey);
         }
       }
     });
@@ -559,13 +584,11 @@ export async function startServe(options) {
   // =================================================================
 
   async function shutdown() {
-    // 更新服务器状态
     writeState(name, {
       ...readState(name),
       lifecycleState: LifecycleState.STOPPED,
     });
 
-    // 通知所有 WS 客户端
     wss.clients.forEach((client) => {
       if (client.readyState === 1) {
         client.close(1001, 'server shutting down');
@@ -573,10 +596,7 @@ export async function startServe(options) {
     });
     wss.close();
 
-    // 关闭所有 session
     await sessionManager.destroyAll('shutdown');
-
-    // 删除服务端状态文件
     deleteState(name);
 
     process.exit(0);
@@ -585,10 +605,6 @@ export async function startServe(options) {
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 
-  // =================================================================
-  // 返回
-  // =================================================================
-
   const info = { port, name };
   console.error(`nx-ce serve ws://127.0.0.1:${port} [${name}]`);
 

package/src/session-store.js

@@ -132,11 +132,13 @@ export function listStates() {
 
 /**
  * 将实例名称清理为安全的文件名。
- * 移除非字母数字的字符，替换为下划线。
+ * 保留字母、数字、点、下划线、连字符、冒号（转为 ~）。
+ * 冒号转为 ~ 是为了支持 "name:cwd" 格式的内部 key。
  *
  * @param {string} name - 原始实例名称
  * @returns {string} 安全的文件名（带 .json 后缀）
  */
 function sanitize(name) {
-  return `${String(name).replace(/[^a-zA-Z0-9._-]/g, '_')}.json`;
+  const safe = String(name).replace(/[^a-zA-Z0-9._~-]/g, '_').replace(/:/g, '~');
+  return `${safe}.json`;
 }