lark-coding-assistant 0.2.2 → 0.2.4

package/README.md

@@ -57,7 +57,7 @@ claude --version
 npm install -g lark-coding-assistant@latest && lark-coding-assistant init
 ```
 
-初始化向导会让你选择飞书或 Lark，并显示 PersonalAgent 注册二维码：
+初始化向导会让你选择飞书或 Lark、可选配置常用 workspace 目录，并显示 PersonalAgent 注册二维码：
 
 1. 保持 `init` 命令运行；
 2. 使用飞书/Lark 扫描二维码；
@@ -108,13 +108,15 @@ lca start --name docs --agent claude --cwd ~/workspace/docs
 
 名称只允许字母、数字、下划线和短横线，最长 40 个字符。不指定名称时使用 `default`。
 
+Session 创建和恢复采用 30 秒启动事务。本地与飞书都会等到 agent 可用后再报告成功；超过 30 秒会取消底层启动、清理临时 tmux 和状态，并返回包含失败阶段与最近终端输出的提示，不会继续在后台运行。同名 session 正在启动时会直接提示“正在启动”，不同名称可以并行启动。Resume Picker 等待用户选择不计入 30 秒，提交选择后重新开始一次 30 秒恢复事务。该限制只作用于启动链路，不影响消息、审批、Question、`status`、`tail`、`attach`、`stop` 或 daemon 管理。
+
 一个 PersonalAgent 私聊同一时刻只连接一个 active session。在飞书发送：
 
 ```text
 /sessions
 ```
 
-机器人会发送一张交互卡，按 codex、traex、claude 分组展示仍存活的 session，并显示每个项目的绝对路径。`● 当前` 表示 active session，点击其他 session 的“连接”按钮即可切换，点击“关闭”可停止对应 agent 和 tmux session；也可点击“新建 Session”，填写名称、Agent、绝对工作目录和恢复方式。创建成功后会自动连接；原 session 列表仍可查看、连接和关闭，只会禁用已经使用过的“新建 Session”按钮。也可使用：
+机器人会发送一张交互卡，按 codex、traex、claude 分组展示仍存活的 session，并显示每个项目的绝对路径。`● 当前` 表示 active session，点击其他 session 的“连接”按钮即可切换，点击“关闭”可停止对应 agent 和 tmux session；也可点击“新建 Session”，填写名称、Agent、项目目录和恢复方式。项目目录可直接从已有 Session、最近成功目录和常用 workspace 中选择，必要时可手动填写 `/绝对路径` 或 `~/路径`。创建成功后会自动连接；原 session 列表仍可查看、连接和关闭，只会禁用已经使用过的“新建 Session”按钮。也可使用：
 
 ```text
 /use web
@@ -122,6 +124,26 @@ lca start --name docs --agent claude --cwd ~/workspace/docs
 
 切换只改变飞书消息和通知的路由，不会停止其他 session。普通消息、`/tail`、`/status`、审批、`/stop` 和停止输出通知都只作用于 active session。
 
+## Workspace 项目目录
+
+可以配置多个常用 workspace root：
+
+```bash
+lca workspace add .
+lca workspace add ~/workspace
+lca workspace add ~/code/company
+lca workspace list
+lca workspace remove ~/code/company
+```
+
+`add` 和 `remove` 支持相对路径，并按执行命令时的当前目录解析。例如 `lca workspace add .` 会把当前目录保存为绝对路径。
+
+配置修改会在下一次打开飞书“新建 Session”表单时生效，不需要重启 daemon。
+
+飞书新建 Session 时，LCA 按以下顺序合并项目目录：仍存活 Session 的目录、最近成功启动的目录、已配置 workspace 下的项目。每个 workspace 只扫描下一级目录，Git 仓库优先于普通目录；同一路径只展示一次。项目目录与其他启动信息在同一张卡片内一次提交；需要使用列表外目录时，选择“手动填写其他路径…”并填写其他路径。最近目录最多保留 30 条。
+
+候选扫描有 2 秒和 500 个目录的上限。达到上限或部分目录不可访问时，卡片仍会展示已经找到的项目，并保留“手动填写其他路径”兜底。手动输入支持 `~/...`，启动前会展开并校验；启动结果、状态和 Session 列表始终展示完整绝对路径。
+
 ## 恢复 agent 历史会话
 
 恢复参数同时适用于三个 agent，bridge 会转换为各 CLI 的原生参数：
@@ -166,7 +188,7 @@ lca attach web
 
 - `/sessions`：按 agent 分组展示所有仍存活的 session 及其绝对路径，可直接连接、关闭或打开新建表单。
 - `/start`：直接打开新建 Session 表单。
-- `/start <name> --agent <codex|traex|claude> --cwd <绝对路径> [--resume]`：用文本命令启动并自动连接新 session；包含空格的路径请加引号。使用 `--resume` 会打开原生 Resume Picker。飞书端不支持“恢复上次”或直接输入历史 Session ID。
+- `/start <name> --agent <codex|traex|claude> --cwd <绝对路径或 ~/路径> [--resume]`：用文本命令启动并自动连接新 session；包含空格的路径请加引号。使用 `--resume` 会打开原生 Resume Picker。飞书端不支持“恢复上次”或直接输入历史 Session ID。
 - `/use <name>`：用文本命令切换 session。
 - `/tail [20-300]`：返回当前 session 最近的终端输出，默认 80 行。
 - `/manual`：打开当前 active session 的手动终端遥控卡。

package/dist/cli.js

@@ -3,7 +3,7 @@ import { randomBytes as randomBytes2 } from "crypto";
 import { readFile as readFile3 } from "fs/promises";
 import { spawn as spawn3 } from "child_process";
 import { fileURLToPath } from "url";
-import { resolve } from "path";
+import { resolve as resolve3 } from "path";
 import { Command } from "commander";
 import * as p from "@clack/prompts";
 import { registerApp } from "@larksuite/channel";
@@ -72,6 +72,77 @@ function normalizeAgentId(value) {
   return AGENT_IDS.includes(value) ? value : void 0;
 }
 
+// src/workspace/path.ts
+import { constants } from "fs";
+import { access, stat } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { isAbsolute, normalize, resolve } from "path";
+
+// src/core/errors.ts
+var AppError = class extends Error {
+  code;
+  context;
+  constructor(code, message, context = {}, options = {}) {
+    super(message, options);
+    this.name = "AppError";
+    this.code = code;
+    this.context = context;
+  }
+};
+function isAppError(error) {
+  return error instanceof AppError;
+}
+function asAppError(error, code = "UNKNOWN", context = {}) {
+  if (isAppError(error)) {
+    if (Object.keys(context).length === 0) return error;
+    return new AppError(error.code, error.message, { ...context, ...error.context }, { cause: error });
+  }
+  return new AppError(code, errorMessage(error), context, { cause: error });
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function systemErrorCode(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+
+// src/workspace/path.ts
+function normalizeWorkspacePath(input, home = homedir2()) {
+  const value = input.trim();
+  if (!value) throw invalidCwd(input, "\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u80FD\u4E3A\u7A7A");
+  let expanded = value;
+  if (value === "~") expanded = home;
+  else if (value.startsWith("~/")) expanded = resolve(home, value.slice(2));
+  else if (value.startsWith("~")) throw invalidCwd(input, "\u4E0D\u652F\u6301 ~other-user\uFF0C\u8BF7\u4F7F\u7528 ~ \u6216 ~/\u76EE\u5F55");
+  if (!isAbsolute(expanded)) throw invalidCwd(input, "\u5DE5\u4F5C\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u6216\u4F7F\u7528 ~/\u76EE\u5F55");
+  return normalize(expanded);
+}
+async function validateWorkspaceDirectory(input, home = homedir2()) {
+  const cwd = normalizeWorkspacePath(input, home);
+  let info;
+  try {
+    info = await stat(cwd);
+  } catch (error) {
+    const reason = systemErrorCode(error) === "EACCES" ? `\u65E0\u6743\u8BBF\u95EE\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}` : `\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u7528\uFF1A${cwd}`;
+    throw invalidCwd(cwd, reason, error);
+  }
+  if (!info.isDirectory()) throw invalidCwd(cwd, `\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6\u5939\uFF1A${cwd}`);
+  try {
+    await access(cwd, constants.R_OK | constants.X_OK);
+  } catch (error) {
+    throw invalidCwd(cwd, `\u65E0\u6743\u8FDB\u5165\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}`, error);
+  }
+  return cwd;
+}
+function normalizeWorkspaceRoots(values, home = homedir2()) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const value of values) unique.add(normalizeWorkspacePath(value, home));
+  return [...unique];
+}
+function invalidCwd(cwd, reason, cause) {
+  return new AppError("INVALID_CWD", reason, { cwd, reason }, cause === void 0 ? {} : { cause });
+}
+
 // src/core/store.ts
 var AppStore = class {
   constructor(paths2) {
@@ -101,11 +172,15 @@ var AppStore = class {
         traex: binaries.traex ?? binaries["trae-cli"] ?? "trae-cli",
         claude: binaries.claude ?? binaries["claude-code"] ?? "claude"
       },
-      pollIntervalMs: config.pollIntervalMs
+      pollIntervalMs: config.pollIntervalMs,
+      workspaceRoots: normalizeWorkspaceRoots(config.workspaceRoots ?? [])
     };
   }
   saveConfig(config) {
-    return writeJsonAtomic(this.paths.config, config);
+    return writeJsonAtomic(this.paths.config, {
+      ...config,
+      workspaceRoots: normalizeWorkspaceRoots(config.workspaceRoots)
+    });
   }
   loadSecrets() {
     return readJson(this.paths.secrets);
@@ -120,23 +195,45 @@ var AppStore = class {
       const agent = normalizeAgentId(session.agent);
       return agent ? [[id, { ...session, agent }]] : [];
     }));
-    return { ...state, sessions };
+    const recentWorkspaces = await normalizeRecentWorkspaces(state.recentWorkspaces ?? []);
+    return { ...state, sessions, recentWorkspaces };
   }
   saveState(state) {
     return writeJsonAtomic(this.paths.state, state);
   }
 };
+async function normalizeRecentWorkspaces(values) {
+  const unique = /* @__PURE__ */ new Set();
+  const result2 = [];
+  const ordered = [...values].sort((left, right) => right.lastUsedAt - left.lastUsedAt);
+  for (const value of ordered) {
+    if (result2.length >= 30) break;
+    if (!Number.isFinite(value.lastUsedAt)) continue;
+    let cwd;
+    try {
+      cwd = normalizeWorkspacePath(value.cwd);
+      await validateWorkspaceDirectory(cwd);
+    } catch {
+      continue;
+    }
+    if (unique.has(cwd)) continue;
+    unique.add(cwd);
+    result2.push({ cwd, lastUsedAt: value.lastUsedAt });
+  }
+  return result2;
+}
 
 // src/platform/process.ts
 import { execFile, spawn } from "child_process";
 function runFile(file, args, options = {}) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     execFile(
       file,
       [...args],
       {
         cwd: options.cwd,
         timeout: options.timeoutMs ?? 1e4,
+        signal: options.signal,
         encoding: "utf8",
         maxBuffer: 4 * 1024 * 1024
       },
@@ -145,7 +242,7 @@ function runFile(file, args, options = {}) {
           reject(Object.assign(error, { stdout, stderr }));
           return;
         }
-        resolve2({ stdout, stderr });
+        resolve4({ stdout, stderr });
       }
     );
   });
@@ -154,38 +251,8 @@ function runFile(file, args, options = {}) {
 // src/daemon/client.ts
 import { randomUUID } from "crypto";
 import { createConnection } from "net";
-
-// src/core/errors.ts
-var AppError = class extends Error {
-  code;
-  context;
-  constructor(code, message, context = {}, options = {}) {
-    super(message, options);
-    this.name = "AppError";
-    this.code = code;
-    this.context = context;
-  }
-};
-function isAppError(error) {
-  return error instanceof AppError;
-}
-function asAppError(error, code = "UNKNOWN", context = {}) {
-  if (isAppError(error)) {
-    if (Object.keys(context).length === 0) return error;
-    return new AppError(error.code, error.message, { ...context, ...error.context }, { cause: error });
-  }
-  return new AppError(code, errorMessage(error), context, { cause: error });
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function systemErrorCode(error) {
-  return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
-}
-
-// src/daemon/client.ts
 function requestDaemon(socketPath, request, timeoutMs = 5e3) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const id = randomUUID();
     const socket = createConnection(socketPath);
     let buffer = "";
@@ -203,7 +270,7 @@ function requestDaemon(socketPath, request, timeoutMs = 5e3) {
       clearTimeout(timer);
       socket.destroy();
       try {
-        resolve2(JSON.parse(buffer.slice(0, newline)));
+        resolve4(JSON.parse(buffer.slice(0, newline)));
       } catch (error) {
         reject(error);
       }
@@ -381,9 +448,9 @@ function promptContentIsDim(rawLine) {
   let cursor = 0;
   for (const match of rawLine.matchAll(sgr)) {
     const index = match.index ?? cursor;
-    const text = rawLine.slice(cursor, index);
-    visible += text;
-    dimAt.push(...Array.from(text, () => dim));
+    const text2 = rawLine.slice(cursor, index);
+    visible += text2;
+    dimAt.push(...Array.from(text2, () => dim));
     const params = (match[1] || "0").split(";").map(Number);
     if (params.includes(0)) dim = false;
     if (params.includes(2)) dim = true;
@@ -596,10 +663,10 @@ function parseChoiceOptionLine(line) {
   if (!match?.[3] || !match[5]) return void 0;
   return { focused: Boolean(match[1]), marker: match[2] ?? match[4], key: match[3], label: match[5] };
 }
-function choiceRisk(text) {
-  if (/full access|bypass|without sandbox|dangerously/i.test(text)) return "privileged";
-  if (/always|don't ask again|do not ask again|auto mode|persist/i.test(text)) return "persistent";
-  if (/^\s*no\b|reject|deny|cancel|do differently/i.test(text)) return "reject";
+function choiceRisk(text2) {
+  if (/full access|bypass|without sandbox|dangerously/i.test(text2)) return "privileged";
+  if (/always|don't ask again|do not ask again|auto mode|persist/i.test(text2)) return "persistent";
+  if (/^\s*no\b|reject|deny|cancel|do differently/i.test(text2)) return "reject";
   return "normal";
 }
 function result(state, confidence, normalized, fingerprint, evidence) {
@@ -814,7 +881,7 @@ function isDaemonInfo(value) {
   return typeof info.version === "string" && typeof info.pid === "number";
 }
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // src/lark/registration.ts
@@ -848,6 +915,28 @@ function formatKnownError(error, context) {
         `  lark-coding-assistant attach ${sessionId}`,
         "  lark-coding-assistant start --name <\u65B0\u540D\u79F0>"
       ];
+    case "SESSION_STARTING":
+      return [
+        `session\u300C${sessionId}\u300D\u6B63\u5728\u542F\u52A8\uFF0C\u8BF7\u7B49\u5F85\u5F53\u524D\u64CD\u4F5C\u5B8C\u6210\u3002`,
+        "",
+        "\u7A0D\u540E\u53EF\u67E5\u770B\u72B6\u6001\uFF1A",
+        `  lark-coding-assistant status ${sessionId}`
+      ];
+    case "SESSION_START_TIMEOUT": {
+      const excerpt = safeValue(context.terminalExcerpt, "Agent \u672A\u8F93\u51FA\u53EF\u7528\u9519\u8BEF\u4FE1\u606F\u3002");
+      return [
+        `session\u300C${sessionId}\u300D\u542F\u52A8\u8D85\u8FC7 30 \u79D2\uFF0C\u5DF2\u53D6\u6D88\u5E76\u6E05\u7406\u3002`,
+        "",
+        `Agent\uFF1A${safeValue(context.agent, "\u672A\u77E5")}`,
+        `\u5DE5\u4F5C\u76EE\u5F55\uFF1A${safeValue(context.cwd, "\u672A\u77E5")}`,
+        `\u8D85\u65F6\u9636\u6BB5\uFF1A${safeValue(context.stage, "unknown")}`,
+        "",
+        "\u6700\u8FD1\u7EC8\u7AEF\u8F93\u51FA\uFF1A",
+        excerpt,
+        "",
+        "\u53EF\u4EE5\u76F4\u63A5\u4F7F\u7528\u540C\u540D session \u91CD\u8BD5\u3002"
+      ];
+    }
     case "AGENT_SESSION_IN_USE": {
       const ownerSessionId = safeValue(context.ownerSessionId, "\u73B0\u6709 session");
       return [
@@ -972,7 +1061,8 @@ function operationLabel(value) {
     stop: "\u505C\u6B62 session",
     logs: "\u8BFB\u53D6\u65E5\u5FD7",
     "reset-owner": "\u91CD\u7F6E owner",
-    daemon: "\u7BA1\u7406 bridge daemon"
+    daemon: "\u7BA1\u7406 bridge daemon",
+    workspace: "\u7BA1\u7406 workspace"
   };
   return typeof value === "string" ? labels[value] ?? "\u6267\u884C\u547D\u4EE4" : "\u6267\u884C\u547D\u4EE4";
 }
@@ -994,8 +1084,6 @@ function debugStack(error) {
 }
 
 // src/session/start-request.ts
-import { stat } from "fs/promises";
-import { isAbsolute } from "path";
 async function validateStartSessionRequest(request) {
   if (!validSessionId(request.sessionId)) {
     throw new AppError(
@@ -1004,21 +1092,13 @@ async function validateStartSessionRequest(request) {
       { sessionId: request.sessionId }
     );
   }
-  if (!isAbsolute(request.cwd)) {
-    throw new AppError("INVALID_CWD", "working directory must be absolute", { cwd: request.cwd });
-  }
-  const info = await stat(request.cwd).catch((error) => {
-    throw new AppError("INVALID_CWD", `working directory is unavailable: ${request.cwd}`, { cwd: request.cwd }, { cause: error });
-  });
-  if (!info.isDirectory()) {
-    throw new AppError("INVALID_CWD", `working directory is not a directory: ${request.cwd}`, { cwd: request.cwd });
-  }
+  const cwd = await validateWorkspaceDirectory(request.cwd);
   if (request.resume?.mode === "session" && !request.resume.sessionId.trim()) {
     throw new AppError("INVALID_RESUME", "resume session id must not be empty", {
       reason: "\u6062\u590D\u5386\u53F2\u4F1A\u8BDD\u65F6\u5FC5\u987B\u63D0\u4F9B session ID"
     });
   }
-  return request;
+  return { ...request, cwd };
 }
 function validSessionId(value) {
   return /^[a-zA-Z0-9_-]{1,40}$/.test(value);
@@ -1170,6 +1250,31 @@ function sanitize(value) {
   return value.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u001f\u007f]+/g, " ").trim();
 }
 
+// src/workspace/config.ts
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+async function addWorkspaceRoot(config, input, cwd = process.cwd()) {
+  const path = await validateWorkspaceDirectory(resolveWorkspaceRootInput(input, cwd));
+  const existing = new Set(config.workspaceRoots);
+  if (existing.has(path)) return { config, path, added: false };
+  return { config: { ...config, workspaceRoots: [...config.workspaceRoots, path] }, path, added: true };
+}
+function removeWorkspaceRoot(config, input, cwd = process.cwd()) {
+  const path = normalizeWorkspacePath(resolveWorkspaceRootInput(input, cwd));
+  const workspaceRoots = config.workspaceRoots.filter((candidate) => candidate !== path);
+  return {
+    config: workspaceRoots.length === config.workspaceRoots.length ? config : { ...config, workspaceRoots },
+    path,
+    removed: workspaceRoots.length !== config.workspaceRoots.length
+  };
+}
+function listWorkspaceRoots(config) {
+  return [...config.workspaceRoots];
+}
+function resolveWorkspaceRootInput(input, cwd) {
+  const value = input.trim();
+  return value && !value.startsWith("~") && !isAbsolute2(value) ? resolve2(cwd, value) : value;
+}
+
 // src/cli.ts
 var program = new Command();
 var paths = resolveAppPaths();
@@ -1191,6 +1296,10 @@ daemonCommand.command("start").description("Start the bridge daemon").action(run
 daemonCommand.command("stop").description("Stop the bridge daemon without stopping coding-agent sessions").action(runDaemonStop);
 daemonCommand.command("restart").description("Restart the bridge daemon without stopping coding-agent sessions").action(runDaemonRestart);
 daemonCommand.command("status").description("Show bridge daemon status and version").action(runDaemonStatus);
+var workspaceCommand = program.command("workspace").description("Manage project workspace roots");
+workspaceCommand.command("add").argument("<path>", "Workspace root path").description("Add a workspace root").action(runWorkspaceAdd);
+workspaceCommand.command("list").description("List workspace roots").action(runWorkspaceList);
+workspaceCommand.command("remove").argument("<path>", "Workspace root path").description("Remove a workspace root").action(runWorkspaceRemove);
 try {
   await program.parseAsync();
 } catch (error) {
@@ -1201,6 +1310,7 @@ try {
 }
 async function runInit() {
   await store.ensure();
+  const previousConfig = await store.loadConfig();
   const tenantAnswer = await p.select({
     message: "\u9009\u62E9\u5E73\u53F0",
     options: [
@@ -1210,6 +1320,15 @@ async function runInit() {
   });
   if (p.isCancel(tenantAnswer)) return p.cancel("\u5DF2\u53D6\u6D88");
   const tenant = tenantAnswer;
+  const workspaceAnswer = await p.text({
+    message: "\u5E38\u7528 workspace \u76EE\u5F55\uFF08\u53EF\u9009\uFF0C\u591A\u4E2A\u76EE\u5F55\u7528\u9017\u53F7\u5206\u9694\uFF09",
+    placeholder: "~/workspace, ~/code",
+    initialValue: previousConfig?.workspaceRoots.join(", ") ?? ""
+  });
+  if (p.isCancel(workspaceAnswer)) return p.cancel("\u5DF2\u53D6\u6D88");
+  const workspaceRoots = normalizeWorkspaceRoots(
+    String(workspaceAnswer).split(",").map((value) => value.trim()).filter(Boolean)
+  );
   p.log.info("\u8BF7\u4F7F\u7528\u98DE\u4E66/Lark \u626B\u63CF\u4E0B\u9762\u7684\u4E8C\u7EF4\u7801\uFF0C\u521B\u5EFA\u6216\u9009\u62E9 PersonalAgent\u3002");
   const registration = await registerApp({
     ...registrationDomains,
@@ -1239,7 +1358,8 @@ ${url}
     appId: registration.client_id,
     tmuxBinary: "tmux",
     agentBinaries: { codex: "codex", traex: "trae-cli", claude: "claude" },
-    pollIntervalMs: 650
+    pollIntervalMs: 650,
+    workspaceRoots
   };
   const previousState = await store.loadState();
   const registeredOwnerOpenId = registration.user_info?.open_id;
@@ -1263,7 +1383,8 @@ ${url}
   p.outro("PersonalAgent \u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002");
 }
 async function runStart(options) {
-  const cwd = resolve(options.cwd ?? process.cwd());
+  const requestedCwd = options.cwd ?? process.cwd();
+  const cwd = requestedCwd.startsWith("~") ? requestedCwd : resolve3(requestedCwd);
   const resume = resolveResumeOption(options);
   const request = await validateStartSessionRequest({
     sessionId: options.name,
@@ -1274,10 +1395,11 @@ async function runStart(options) {
   await ensureInitialized();
   await preflight(options.agent);
   await ensureDaemon();
+  console.log(`\u6B63\u5728\u542F\u52A8 ${options.agent} session\u300C${options.name}\u300D\u2026`);
   const value = await daemonValue({
     method: "start",
     ...request
-  });
+  }, 35e3);
   if (value.binding.mode === "reused") {
     console.log("\n\u5DF2\u81EA\u52A8\u6CBF\u7528\u539F\u6709\u98DE\u4E66/Lark \u79C1\u804A\u7ED1\u5B9A\u3002\n");
   } else if (value.binding.mode === "awaiting-owner-message") {
@@ -1294,6 +1416,25 @@ async function runStart(options) {
   }
   await attachLocal(options.name);
 }
+async function runWorkspaceAdd(path) {
+  await ensureInitialized();
+  const config = await store.loadConfig();
+  const result2 = await addWorkspaceRoot(config, path);
+  if (result2.added) await store.saveConfig(result2.config);
+  console.log(result2.added ? `Workspace \u5DF2\u6DFB\u52A0\uFF1A${result2.path}` : `Workspace \u5DF2\u5B58\u5728\uFF1A${result2.path}`);
+}
+async function runWorkspaceList() {
+  await ensureInitialized();
+  const roots = listWorkspaceRoots(await store.loadConfig());
+  console.log(roots.length > 0 ? roots.join("\n") : "\u5C1A\u672A\u914D\u7F6E workspace\u3002\u53EF\u8FD0\u884C\uFF1Alca workspace add ~/workspace");
+}
+async function runWorkspaceRemove(path) {
+  await ensureInitialized();
+  const config = await store.loadConfig();
+  const result2 = removeWorkspaceRoot(config, path);
+  if (result2.removed) await store.saveConfig(result2.config);
+  console.log(result2.removed ? `Workspace \u5DF2\u79FB\u9664\uFF1A${result2.path}` : `Workspace \u672A\u914D\u7F6E\uFF1A${result2.path}`);
+}
 async function runAttach(name) {
   await attachLocal(name);
 }
@@ -1458,8 +1599,8 @@ async function ensureDaemon() {
 function daemonEntryPath() {
   return fileURLToPath(new URL("./daemon-entry.js", import.meta.url));
 }
-async function daemonValue(request) {
-  const response = await requestDaemon(paths.socket, request);
+async function daemonValue(request, timeoutMs) {
+  const response = await requestDaemon(paths.socket, request, timeoutMs);
   if (!response.ok) throw daemonResultError(response);
   return response.value;
 }