@clawos-dev/clawd 0.2.7 → 0.2.8-beta.2.525faa1

package/dist/cli.cjs

@@ -8075,7 +8075,6 @@ Env (advanced):
 `;
 
 // src/index.ts
-var import_node_os10 = __toESM(require("os"), 1);
 var import_node_path15 = __toESM(require("path"), 1);
 var import_node_fs16 = __toESM(require("fs"), 1);
 
@@ -17135,6 +17134,244 @@ function writeAuthFile(file, content) {
   }
 }
 
+// src/handlers/session.ts
+function buildSessionHandlers(deps) {
+  const { manager, observer, getAdapter: getAdapter2 } = deps;
+  const create = async (frame) => {
+    const args = SessionCreateArgs.parse(frame);
+    const { response, broadcast } = manager.create(args);
+    return { response: { type: "session:info", ...response }, broadcast };
+  };
+  const list = async () => {
+    const { response } = manager.list();
+    return { response: { type: "session:list", ...response } };
+  };
+  const get = async (frame) => {
+    const args = SessionIdArgs.parse(frame);
+    const { response } = manager.get(args);
+    return { response: { type: "session:info", ...response } };
+  };
+  const update = async (frame) => {
+    const args = SessionUpdateArgs.parse(frame);
+    const { response, broadcast } = manager.update(args);
+    return { response: { type: "session:info", ...response }, broadcast };
+  };
+  const del = async (frame) => {
+    const args = SessionIdArgs.parse(frame);
+    const { broadcast } = manager.delete(args);
+    return {
+      response: { type: "session:deleted", sessionId: args.sessionId },
+      broadcast
+    };
+  };
+  const send = async (frame) => {
+    const args = SessionSendArgs.parse(frame);
+    const { broadcast } = manager.send(args);
+    return { response: { type: "session:send", ok: true }, broadcast };
+  };
+  const stop = async (frame) => {
+    const args = SessionIdArgs.parse(frame);
+    const { broadcast } = manager.stop(args);
+    return { response: { type: "session:stop", ok: true }, broadcast };
+  };
+  const interrupt = async (frame) => {
+    const args = SessionIdArgs.parse(frame);
+    const { broadcast } = await manager.interrupt(args);
+    return { response: { type: "session:interrupt", ok: true }, broadcast };
+  };
+  const rewind = async (frame) => {
+    const args = SessionRewindArgs.parse(frame);
+    const { response, broadcast } = await manager.rewind(args);
+    return { response: { type: "session:rewind", ...response }, broadcast };
+  };
+  const rewindDiff = async (frame) => {
+    const args = SessionRewindDiffArgs.parse(frame);
+    const { response } = await manager.rewindDiff(args);
+    return { response: { type: "session:rewind-diff", ...response } };
+  };
+  const rewindableMessageIds = async (frame) => {
+    const args = SessionRewindableMessageIdsArgs.parse(frame);
+    const { response } = manager.rewindableMessageIds(args);
+    return {
+      response: { type: "session:rewindable-message-ids", ...response }
+    };
+  };
+  const newSession = async (frame) => {
+    const args = SessionIdArgs.parse(frame);
+    observer.stop(args.sessionId);
+    const { response, broadcast } = manager.newSession(args);
+    return { response: { type: "session:info", ...response }, broadcast };
+  };
+  const resume = async (frame) => {
+    const args = SessionResumeArgs.parse(frame);
+    const { response, broadcast } = manager.resume(args);
+    return { response: { type: "session:info", ...response }, broadcast };
+  };
+  const observe = async (frame) => {
+    const args = SessionObserveArgs.parse(frame);
+    const { response: file } = manager.get({ sessionId: args.sessionId });
+    const sessionFile = file;
+    manager.ensureSession(sessionFile);
+    const adapter = getAdapter2(sessionFile.tool ?? "claude");
+    observer.start({
+      sessionId: args.sessionId,
+      cwd: sessionFile.cwd,
+      toolSessionId: args.toolSessionId,
+      jsonlPath: args.jsonlPath,
+      adapter
+    });
+    return { response: { type: "session:observe", ok: true } };
+  };
+  const events = async (frame) => {
+    const args = SessionEventsArgs.parse(frame);
+    const { response } = manager.getEvents(args);
+    return { response: { type: "session:events", ...response } };
+  };
+  const subscribe = async (frame, client) => {
+    if (typeof frame.sessionId === "string")
+      addSubscription(client, frame.sessionId);
+    return {
+      response: { type: "subscribed", sessionId: frame.sessionId }
+    };
+  };
+  const unsubscribe = async (frame, client) => {
+    if (typeof frame.sessionId === "string")
+      removeSubscription(client, frame.sessionId);
+    return {
+      response: { type: "unsubscribed", sessionId: frame.sessionId }
+    };
+  };
+  const pin = async (frame) => {
+    const args = SessionPinArgs.parse(frame);
+    const { response, broadcast } = manager.pin(args);
+    return { response: { type: "session:info", ...response }, broadcast };
+  };
+  return {
+    "session:create": create,
+    "session:list": list,
+    "session:get": get,
+    "session:update": update,
+    "session:delete": del,
+    "session:send": send,
+    "session:stop": stop,
+    "session:interrupt": interrupt,
+    "session:rewind": rewind,
+    "session:rewind-diff": rewindDiff,
+    "session:rewindable-message-ids": rewindableMessageIds,
+    "session:new": newSession,
+    "session:resume": resume,
+    "session:observe": observe,
+    "session:events": events,
+    "session:subscribe": subscribe,
+    "session:unsubscribe": unsubscribe,
+    "session:pin": pin
+  };
+}
+
+// src/handlers/permission.ts
+function buildPermissionHandlers(deps) {
+  const { manager } = deps;
+  const respond = async (frame) => {
+    const args = PermissionRespondArgs.parse(frame);
+    const { broadcast } = manager.respondPermission(args);
+    return { response: { type: "permission:respond", ok: true }, broadcast };
+  };
+  return {
+    "permission:respond": respond
+  };
+}
+
+// src/workspace/recent-dirs.ts
+function listRecentDirs(store, limit = 50) {
+  const sessions = store.list();
+  const latestByCwd = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    if (!s.cwd) continue;
+    const prev = latestByCwd.get(s.cwd);
+    if (!prev || s.updatedAt > prev) {
+      latestByCwd.set(s.cwd, s.updatedAt);
+    }
+  }
+  return Array.from(latestByCwd.entries()).map(([cwd, updatedAt]) => ({ cwd, updatedAt })).sort((a, b) => a.updatedAt > b.updatedAt ? -1 : a.updatedAt < b.updatedAt ? 1 : 0).slice(0, limit);
+}
+
+// src/handlers/history.ts
+function buildHistoryHandlers(deps) {
+  const { manager, history, store } = deps;
+  const projects = async () => {
+    const list2 = await history.listProjects();
+    return { response: { type: "history:projects", projects: list2 } };
+  };
+  const list = async (frame) => {
+    const args = HistoryListArgs.parse(frame);
+    const sessions = await history.listSessions(args);
+    return { response: { type: "history:list", sessions } };
+  };
+  const read = async (frame) => {
+    const args = HistoryReadArgs.parse(frame);
+    const { response: file } = manager.get({ sessionId: args.sessionId });
+    if (!file.toolSessionId) {
+      return {
+        response: { type: "history:read", messages: [], total: 0, offset: 0 }
+      };
+    }
+    const res = await history.read({
+      cwd: file.cwd,
+      toolSessionId: file.toolSessionId,
+      limit: args.limit,
+      offset: args.offset
+    });
+    return { response: { type: "history:read", ...res } };
+  };
+  const subagents = async (frame) => {
+    const args = HistorySubagentsArgs.parse(frame);
+    const subs = await history.listSubagents(args);
+    return { response: { type: "history:subagents", subagents: subs } };
+  };
+  const subagentRead = async (frame) => {
+    const args = HistorySubagentReadArgs.parse(frame);
+    const res = await history.readSubagent(args);
+    return { response: { type: "history:subagent-read", ...res } };
+  };
+  const recentDirs = async () => {
+    const dirs = listRecentDirs(store);
+    return { response: { type: "history:recentDirs", dirs } };
+  };
+  return {
+    "history:projects": projects,
+    "history:list": list,
+    "history:read": read,
+    "history:subagents": subagents,
+    "history:subagent-read": subagentRead,
+    "history:recentDirs": recentDirs
+  };
+}
+
+// src/handlers/workspace.ts
+function buildWorkspaceHandlers(deps) {
+  const { workspace, skills } = deps;
+  const list = async (frame) => {
+    const args = WorkspaceListArgs.parse(frame);
+    const res = workspace.list(args);
+    return { response: { type: "workspace:list", ...res } };
+  };
+  const read = async (frame) => {
+    const args = WorkspaceReadArgs.parse(frame);
+    const res = workspace.read(args);
+    return { response: { type: "workspace:read", ...res } };
+  };
+  const skillsList = async (frame) => {
+    const args = SkillsListArgs.parse(frame);
+    const list2 = skills.list(args);
+    return { response: { type: "skills:list", skills: list2 } };
+  };
+  return {
+    "workspace:list": list,
+    "workspace:read": read,
+    "skills:list": skillsList
+  };
+}
+
 // src/workspace/git.ts
 var import_node_child_process5 = require("child_process");
 var import_node_fs15 = __toESM(require("fs"), 1);
@@ -17371,23 +17608,122 @@ async function removeWorktree(input) {
   }
 }
 
-// src/workspace/recent-dirs.ts
-function listRecentDirs(store, limit = 50) {
-  const sessions = store.list();
-  const latestByCwd = /* @__PURE__ */ new Map();
-  for (const s of sessions) {
-    if (!s.cwd) continue;
-    const prev = latestByCwd.get(s.cwd);
-    if (!prev || s.updatedAt > prev) {
-      latestByCwd.set(s.cwd, s.updatedAt);
+// src/handlers/git.ts
+function buildGitHandlers() {
+  const root = async (frame) => {
+    const args = GitRootArgs.parse(frame);
+    const res = await getGitRoot(args.cwd);
+    return { response: { type: "git:root", ...res } };
+  };
+  const branch = async (frame) => {
+    const args = GitBranchArgs.parse(frame);
+    const res = await readGitBranch(args.cwd);
+    return { response: { type: "git:branch", ...res } };
+  };
+  const branches = async (frame) => {
+    const args = GitBranchesArgs.parse(frame);
+    const res = await listGitBranches(args.cwd);
+    return { response: { type: "git:branches", ...res } };
+  };
+  const worktreePrefix = async () => {
+    return {
+      response: { type: "git:worktree:prefix", prefix: computePrefix() }
+    };
+  };
+  const worktreeCreate = async (frame) => {
+    const args = GitWorktreeCreateArgs.parse(frame);
+    try {
+      const res = await createWorktree(args);
+      return { response: { type: "git:worktree:create", ...res } };
+    } catch (err) {
+      throw new ClawdError(ERROR_CODES.INTERNAL, err.message);
     }
-  }
-  return Array.from(latestByCwd.entries()).map(([cwd, updatedAt]) => ({ cwd, updatedAt })).sort((a, b) => a.updatedAt > b.updatedAt ? -1 : a.updatedAt < b.updatedAt ? 1 : 0).slice(0, limit);
+  };
+  const worktreeRemove = async (frame) => {
+    const args = GitWorktreeRemoveArgs.parse(frame);
+    try {
+      await removeWorktree(args);
+      return { response: { type: "git:worktree:remove", ok: true } };
+    } catch (err) {
+      throw new ClawdError(ERROR_CODES.INTERNAL, err.message);
+    }
+  };
+  return {
+    "git:root": root,
+    "git:branch": branch,
+    "git:branches": branches,
+    "git:worktree:prefix": worktreePrefix,
+    "git:worktree:create": worktreeCreate,
+    "git:worktree:remove": worktreeRemove
+  };
+}
+
+// src/handlers/capabilities.ts
+function buildCapabilitiesHandlers(deps) {
+  const { manager } = deps;
+  const get = async (frame) => {
+    const args = CapabilitiesGetArgs.parse(frame);
+    const caps = await manager.getCapabilities(args.tool);
+    return { response: { type: "capabilities:get", ...caps } };
+  };
+  return {
+    "capabilities:get": get
+  };
 }
 
+// src/handlers/meta.ts
+var import_node_os10 = __toESM(require("os"), 1);
+
 // src/version.ts
 var version = "0.2.6".length > 0 ? "0.2.6" : "dev";
 
+// src/handlers/meta.ts
+function buildReadyFrame(deps) {
+  const info = deps.manager.info();
+  const tools = [];
+  for (const id of listRegistered()) {
+    try {
+      const a = deps.getAdapter(id);
+      tools.push({ id: a.id, available: true });
+    } catch {
+      tools.push({ id, available: false });
+    }
+  }
+  return {
+    version,
+    protocolVersion: PROTOCOL_VERSION,
+    hostname: import_node_os10.default.hostname(),
+    os: process.platform,
+    tools,
+    runningSessions: info.runningSessions
+  };
+}
+function buildMetaHandlers(deps) {
+  const info = async () => ({
+    response: { type: "info", ...buildReadyFrame(deps) }
+  });
+  const ping = async () => ({
+    response: { type: "pong", at: Date.now() }
+  });
+  return {
+    info,
+    ping
+  };
+}
+
+// src/handlers/index.ts
+function buildMethodHandlers(deps) {
+  return {
+    ...buildSessionHandlers(deps),
+    ...buildPermissionHandlers(deps),
+    ...buildHistoryHandlers(deps),
+    ...buildWorkspaceHandlers(deps),
+    ...buildGitHandlers(),
+    ...buildCapabilitiesHandlers(deps),
+    ...buildMetaHandlers(deps)
+  };
+}
+
 // src/index.ts
 async function startDaemon(config) {
   const logger = createLogger({
@@ -17574,233 +17910,6 @@ ${bar}
     authToken: resolvedAuthToken
   };
 }
-function buildMethodHandlers(deps) {
-  const { manager, workspace, skills, history, observer, getAdapter: getAdapter2, store } = deps;
-  return {
-    "session:create": async (frame) => {
-      const args = SessionCreateArgs.parse(frame);
-      const { response, broadcast } = manager.create(args);
-      return { response: { type: "session:info", ...response }, broadcast };
-    },
-    "session:list": async () => {
-      const { response } = manager.list();
-      return { response: { type: "session:list", ...response } };
-    },
-    "session:get": async (frame) => {
-      const args = SessionIdArgs.parse(frame);
-      const { response } = manager.get(args);
-      return { response: { type: "session:info", ...response } };
-    },
-    "session:update": async (frame) => {
-      const args = SessionUpdateArgs.parse(frame);
-      const { response, broadcast } = manager.update(args);
-      return { response: { type: "session:info", ...response }, broadcast };
-    },
-    "session:delete": async (frame) => {
-      const args = SessionIdArgs.parse(frame);
-      const { broadcast } = manager.delete(args);
-      return { response: { type: "session:deleted", sessionId: args.sessionId }, broadcast };
-    },
-    "session:send": async (frame) => {
-      const args = SessionSendArgs.parse(frame);
-      const { broadcast } = manager.send(args);
-      return { response: { type: "session:send", ok: true }, broadcast };
-    },
-    "session:stop": async (frame) => {
-      const args = SessionIdArgs.parse(frame);
-      const { broadcast } = manager.stop(args);
-      return { response: { type: "session:stop", ok: true }, broadcast };
-    },
-    "session:interrupt": async (frame) => {
-      const args = SessionIdArgs.parse(frame);
-      const { broadcast } = await manager.interrupt(args);
-      return { response: { type: "session:interrupt", ok: true }, broadcast };
-    },
-    "session:rewind": async (frame) => {
-      const args = SessionRewindArgs.parse(frame);
-      const { response, broadcast } = await manager.rewind(args);
-      return { response: { type: "session:rewind", ...response }, broadcast };
-    },
-    "session:rewind-diff": async (frame) => {
-      const args = SessionRewindDiffArgs.parse(frame);
-      const { response } = await manager.rewindDiff(args);
-      return { response: { type: "session:rewind-diff", ...response } };
-    },
-    "session:rewindable-message-ids": async (frame) => {
-      const args = SessionRewindableMessageIdsArgs.parse(frame);
-      const { response } = manager.rewindableMessageIds(args);
-      return { response: { type: "session:rewindable-message-ids", ...response } };
-    },
-    "session:new": async (frame) => {
-      const args = SessionIdArgs.parse(frame);
-      observer.stop(args.sessionId);
-      const { response, broadcast } = manager.newSession(args);
-      return { response: { type: "session:info", ...response }, broadcast };
-    },
-    "session:resume": async (frame) => {
-      const args = SessionResumeArgs.parse(frame);
-      const { response, broadcast } = manager.resume(args);
-      return { response: { type: "session:info", ...response }, broadcast };
-    },
-    "session:observe": async (frame) => {
-      const args = SessionObserveArgs.parse(frame);
-      const { response: file } = manager.get({ sessionId: args.sessionId });
-      const sessionFile = file;
-      manager.ensureSession(sessionFile);
-      const adapter = getAdapter2(sessionFile.tool ?? "claude");
-      observer.start({
-        sessionId: args.sessionId,
-        cwd: sessionFile.cwd,
-        toolSessionId: args.toolSessionId,
-        jsonlPath: args.jsonlPath,
-        adapter
-      });
-      return { response: { type: "session:observe", ok: true } };
-    },
-    "session:events": async (frame) => {
-      const args = SessionEventsArgs.parse(frame);
-      const { response } = manager.getEvents(args);
-      return { response: { type: "session:events", ...response } };
-    },
-    "session:subscribe": async (frame, client) => {
-      if (typeof frame.sessionId === "string") addSubscription(client, frame.sessionId);
-      return { response: { type: "subscribed", sessionId: frame.sessionId } };
-    },
-    "session:unsubscribe": async (frame, client) => {
-      if (typeof frame.sessionId === "string") removeSubscription(client, frame.sessionId);
-      return { response: { type: "unsubscribed", sessionId: frame.sessionId } };
-    },
-    "session:pin": async (frame) => {
-      const args = SessionPinArgs.parse(frame);
-      const { response, broadcast } = manager.pin(args);
-      return { response: { type: "session:info", ...response }, broadcast };
-    },
-    "permission:respond": async (frame) => {
-      const args = PermissionRespondArgs.parse(frame);
-      const { broadcast } = manager.respondPermission(args);
-      return { response: { type: "permission:respond", ok: true }, broadcast };
-    },
-    "history:projects": async () => {
-      const projects = await history.listProjects();
-      return { response: { type: "history:projects", projects } };
-    },
-    "history:list": async (frame) => {
-      const args = HistoryListArgs.parse(frame);
-      const sessions = await history.listSessions(args);
-      return { response: { type: "history:list", sessions } };
-    },
-    "history:read": async (frame) => {
-      const args = HistoryReadArgs.parse(frame);
-      const { response: file } = manager.get({ sessionId: args.sessionId });
-      if (!file.toolSessionId) {
-        return {
-          response: { type: "history:read", messages: [], total: 0, offset: 0 }
-        };
-      }
-      const res = await history.read({
-        cwd: file.cwd,
-        toolSessionId: file.toolSessionId,
-        limit: args.limit,
-        offset: args.offset
-      });
-      return { response: { type: "history:read", ...res } };
-    },
-    "history:subagents": async (frame) => {
-      const args = HistorySubagentsArgs.parse(frame);
-      const subs = await history.listSubagents(args);
-      return { response: { type: "history:subagents", subagents: subs } };
-    },
-    "history:subagent-read": async (frame) => {
-      const args = HistorySubagentReadArgs.parse(frame);
-      const res = await history.readSubagent(args);
-      return { response: { type: "history:subagent-read", ...res } };
-    },
-    "history:recentDirs": async () => {
-      const dirs = listRecentDirs(store);
-      return { response: { type: "history:recentDirs", dirs } };
-    },
-    "workspace:list": async (frame) => {
-      const args = WorkspaceListArgs.parse(frame);
-      const res = workspace.list(args);
-      return { response: { type: "workspace:list", ...res } };
-    },
-    "workspace:read": async (frame) => {
-      const args = WorkspaceReadArgs.parse(frame);
-      const res = workspace.read(args);
-      return { response: { type: "workspace:read", ...res } };
-    },
-    "skills:list": async (frame) => {
-      const args = SkillsListArgs.parse(frame);
-      const list = skills.list(args);
-      return { response: { type: "skills:list", skills: list } };
-    },
-    "git:root": async (frame) => {
-      const args = GitRootArgs.parse(frame);
-      const res = await getGitRoot(args.cwd);
-      return { response: { type: "git:root", ...res } };
-    },
-    "git:branch": async (frame) => {
-      const args = GitBranchArgs.parse(frame);
-      const res = await readGitBranch(args.cwd);
-      return { response: { type: "git:branch", ...res } };
-    },
-    "git:branches": async (frame) => {
-      const args = GitBranchesArgs.parse(frame);
-      const res = await listGitBranches(args.cwd);
-      return { response: { type: "git:branches", ...res } };
-    },
-    "git:worktree:prefix": async () => {
-      return { response: { type: "git:worktree:prefix", prefix: computePrefix() } };
-    },
-    "git:worktree:create": async (frame) => {
-      const args = GitWorktreeCreateArgs.parse(frame);
-      try {
-        const res = await createWorktree(args);
-        return { response: { type: "git:worktree:create", ...res } };
-      } catch (err) {
-        throw new ClawdError(ERROR_CODES.INTERNAL, err.message);
-      }
-    },
-    "git:worktree:remove": async (frame) => {
-      const args = GitWorktreeRemoveArgs.parse(frame);
-      try {
-        await removeWorktree(args);
-        return { response: { type: "git:worktree:remove", ok: true } };
-      } catch (err) {
-        throw new ClawdError(ERROR_CODES.INTERNAL, err.message);
-      }
-    },
-    "capabilities:get": async (frame) => {
-      const args = CapabilitiesGetArgs.parse(frame);
-      const caps = await manager.getCapabilities(args.tool);
-      return { response: { type: "capabilities:get", ...caps } };
-    },
-    // 必须带 type：ext-clawd DaemonConnection.handleFrame 看到 frame.type 不是 string
-    // 直接丢弃整帧，pending requestId 永远不会被匹配，UI 端 info 调用就一直 pending 到超时。
-    info: async () => ({ response: { type: "info", ...buildReadyFrame(deps) } }),
-    ping: async () => ({ response: { type: "pong", at: Date.now() } })
-  };
-}
-function buildReadyFrame(deps) {
-  const info = deps.manager.info();
-  const tools = [];
-  for (const id of listRegistered()) {
-    try {
-      const a = deps.getAdapter(id);
-      tools.push({ id: a.id, available: true });
-    } catch {
-      tools.push({ id, available: false });
-    }
-  }
-  return {
-    version,
-    protocolVersion: PROTOCOL_VERSION,
-    hostname: import_node_os10.default.hostname(),
-    os: process.platform,
-    tools,
-    runningSessions: info.runningSessions
-  };
-}
 
 // src/cli.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.7",
+  "version": "0.2.8-beta.2.525faa1",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",