ccpanel 0.1.3 → 0.1.5

package/README.md

@@ -1,78 +1,20 @@
-# ccpanel
-
-本地图形化管理 Claude Code 配置：MCP 服务器、Skills、子 Agent、Commands、配置文件、Memory、Sessions、Plugins（全局级 + 项目级）。
-
-## 使用
-
-```bash
-npx ccpanel
-```
-
-启动后自动打开浏览器（默认 http://localhost:7788）。
-
-## 开发
-
-```bash
-npm install && npm --prefix web install
-# 终端 A：后端
-npm run dev
-# 终端 B：前端
-npm --prefix web run dev
-```
-
-## 构建
-
-修改代码后需重新编译，构建产物供 `npx claude-config-manager` 生产运行：
-
-```bash
-npm run build          # 全量：前端 web/dist + 后端 dist
-npm run build:web      # 仅前端，产物 web/dist（改动 web/ 下代码时）
-npm run build:server   # 仅后端，产物 dist/（改动 src/ 下代码时）
-```
-
-- 改完**前端**：`npm run build:web` 后刷新浏览器即可生效（后端静态托管 `web/dist`，无需重启）。
-- 改完**后端**：`npm run build:server`；若用 `npm run dev`（tsx）运行后端，改动后需重启该进程才生效（tsx 不热重载）。
-- 开发模式下前端 `npm --prefix web run dev` 自带热更新（HMR），免手动构建。
-
-## 测试
-
-```bash
-npm test
-```
-
-## 发布 / 分发
-
-让别人也能使用，有两种方式。两者都会自动包含前端产物 `web/dist`，发布前请确保已执行过 `npm run build`（`npm publish` 会通过 `prepublishOnly` 自动构建）。
-
-### 方式一：发布到 npm（推荐，别人 `npx` 即用）
-
-```bash
-npm login        # 首次需要 npm 账号
-npm publish      # prepublishOnly 会自动先 npm run build
-```
-
-发布后任何人可直接运行：
-
-```bash
-npx ccpanel
-```
-
-> 包名 `ccpanel` 目前在 npm 上可用；如后续被占用，可改用作用域名（如 `@你的用户名/ccpanel`），并以 `npm publish --access public` 发布。
-
-### 方式二：分发 tarball（内网 / 小范围，无需发布）
-
-```bash
-npm run build    # 先构建
-npm pack         # 生成 ccpanel-<version>.tgz
-```
-
-把生成的 `.tgz` 发给对方，对方安装运行：
-
-```bash
-npm install -g ./ccpanel-0.1.0.tgz
-ccpanel
-# 或免安装直接运行：
-npx ./ccpanel-0.1.0.tgz
-```
-
-> 使用者需 Node.js ≥ 20。工具为本地服务，启动后在 `localhost:7788` 读写本机 `~/.claude` 下的配置。
+# ccpanel
+
+本地图形化管理 Claude Code 与 Codex 配置：MCP 服务器、Skills、子 Agent、Commands、配置文件、Memory、Sessions、Plugins（全局级 + 项目级）。
+
+- **Claude**：管理 `~/.claude` 下全部配置（全局级 + 项目级）
+- **Codex**：管理 `~/.codex` 下的 MCP、Skills、插件、配置文件、记忆和会话（配置仅全局级；记忆/会话只读）
+- **公共 Skills**：展示 `~/.agents/skills`，一键同步到 Claude / Codex（创建目录链接），也可把本地技能「转公共」
+
+## 快速开始
+
+```bash
+npx ccpanel
+```
+
+启动后自动打开浏览器（默认 http://localhost:7788），顶部可切换 Claude / Codex / 公共三个视图。需 Node.js ≥ 20。
+
+## 文档
+
+- 技术栈、开发/构建/测试、发布分发：[docs/development.md](docs/development.md)
+- Claude Code / Codex / 公共 Skills 目录结构与 ccpanel 读写范围：[docs/agent-directories.md](docs/agent-directories.md)

package/dist/{chunk-SZFZF7CH.js → chunk-LZFMCC5M.js}

@@ -1,5 +1,5 @@
 // src/server/app.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { ZodError } from "zod";
 
@@ -37,7 +37,8 @@ var ConfigStore = class {
       throw new ConfigCorruptError(file);
     }
   }
-  async writeJson(file, data) {
+  // 原子写 + 写前同目录 .bak 备份（仅当原文件存在）。内容原样落盘。
+  async writeText(file, content) {
     await mkdir(dirname(file), { recursive: true });
     try {
       await copyFile(file, file + ".bak");
@@ -45,9 +46,12 @@ var ConfigStore = class {
       if (err.code !== "ENOENT") throw err;
     }
     const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-    await writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+    await writeFile(tmp, content, "utf8");
     await rename(tmp, file);
   }
+  async writeJson(file, data) {
+    await this.writeText(file, JSON.stringify(data, null, 2) + "\n");
+  }
 };
 
 // src/core/errors.ts
@@ -79,21 +83,36 @@ import { createHash } from "crypto";
 import { join, resolve } from "path";
 function resolvePaths(opts) {
   const { home, projectPath } = opts;
+  const provider = opts.provider ?? "claude";
   const panelDir = join(home, ".ccpanel");
+  const codexDir = join(home, ".codex");
+  const agentsSkillsDir = join(home, ".agents", "skills");
+  const userSkillsDir = provider === "codex" ? join(codexDir, "skills") : provider === "agents" ? agentsSkillsDir : join(home, ".claude", "skills");
+  const userDisabledSkillsDir = provider === "codex" ? join(panelDir, "codex-disabled-skills") : provider === "agents" ? join(panelDir, "agents-disabled-skills") : join(panelDir, "disabled-skills");
   const paths = {
+    provider,
     userClaudeJson: join(home, ".claude.json"),
-    userSkillsDir: join(home, ".claude", "skills"),
+    userMcpFile: provider === "codex" ? join(codexDir, "config.toml") : join(home, ".claude.json"),
+    userSkillsDir,
     userAgentsDir: join(home, ".claude", "agents"),
     userCommandsDir: join(home, ".claude", "commands"),
-    userDisabledMcp: join(panelDir, "disabled-mcp.json"),
-    userDisabledSkillsDir: join(panelDir, "disabled-skills"),
+    userDisabledMcp: provider === "codex" ? join(panelDir, "codex-disabled-mcp.json") : join(panelDir, "disabled-mcp.json"),
+    userDisabledSkillsDir,
     userSettings: join(home, ".claude", "settings.json"),
     userClaudeMd: join(home, ".claude", "CLAUDE.md"),
     userProjectsDir: join(home, ".claude", "projects"),
     pluginsDir: join(home, ".claude", "plugins"),
     installedPluginsJson: join(home, ".claude", "plugins", "installed_plugins.json"),
     knownMarketplacesJson: join(home, ".claude", "plugins", "known_marketplaces.json"),
-    panelDir
+    panelDir,
+    agentsSkillsDir,
+    codexConfigToml: join(codexDir, "config.toml"),
+    codexAgentsMd: join(codexDir, "AGENTS.md"),
+    codexPluginsDir: join(codexDir, "plugins"),
+    codexMemoriesDir: join(codexDir, "memories"),
+    codexMemoriesDb: join(codexDir, "memories_1.sqlite"),
+    codexSessionsDir: join(codexDir, "sessions"),
+    codexSessionIndex: join(codexDir, "session_index.jsonl")
   };
   if (projectPath) {
     paths.projectMcpJson = join(projectPath, ".mcp.json");
@@ -111,17 +130,30 @@ function resolvePaths(opts) {
 // src/shared/schemas.ts
 import { z } from "zod";
 var ScopeSchema = z.enum(["user", "project"]);
+var ProviderSchema = z.enum(["claude", "codex", "agents"]);
+var McpProviderSchema = z.enum(["claude", "codex"]);
+var ProviderScopeQuerySchema = z.object({
+  provider: ProviderSchema.default("claude"),
+  scope: ScopeSchema,
+  projectPath: z.string().optional()
+}).refine((v) => v.scope === "user" || !!v.projectPath, {
+  message: "project scope \u9700\u8981 projectPath",
+  path: ["projectPath"]
+}).refine((v) => v.provider === "claude" || v.scope === "user", {
+  message: "\u8BE5 provider \u4EC5\u652F\u6301\u7528\u6237\u7EA7\u4F5C\u7528\u57DF\uFF08scope=user\uFF09",
+  path: ["provider"]
+});
 var StdioMcpServerSchema = z.object({
   type: z.literal("stdio").optional(),
   command: z.string().min(1),
   args: z.array(z.string()).optional(),
   env: z.record(z.string()).optional()
-});
+}).passthrough();
 var RemoteMcpServerSchema = z.object({
   type: z.enum(["sse", "http"]),
   url: z.string().url(),
   headers: z.record(z.string()).optional()
-});
+}).passthrough();
 var McpServerSchema = z.union([
   RemoteMcpServerSchema,
   StdioMcpServerSchema
@@ -140,7 +172,12 @@ var MemoryWriteSchema = z.object({
   content: z.string(),
   baseMtime: BaseMtimeSchema
 });
-var ConfigFileIdSchema = z.enum(["settings", "claude-json"]);
+var ConfigFileIdSchema = z.enum([
+  "settings",
+  "claude-json",
+  "codex-config",
+  "codex-agents"
+]);
 var ConfigFileWriteSchema = z.object({
   content: z.string(),
   baseMtime: BaseMtimeSchema
@@ -157,11 +194,20 @@ var ScopeQuerySchema = z.object({
 function mcpRoutes(deps) {
   const app = new Hono();
   const ctx = (c) => {
-    const q = ScopeQuerySchema.parse({
+    const q = ProviderScopeQuerySchema.parse({
+      provider: c.req.query("provider"),
       scope: c.req.query("scope"),
       projectPath: c.req.query("projectPath")
     });
-    return { q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+    McpProviderSchema.parse(q.provider);
+    return {
+      q,
+      paths: resolvePaths({
+        home: deps.home,
+        projectPath: q.projectPath,
+        provider: q.provider
+      })
+    };
   };
   app.get("/", async (c) => {
     const { q, paths } = ctx(c);
@@ -205,11 +251,19 @@ var SkillBodySchema = z2.object({
 function skillRoutes(deps) {
   const app = new Hono2();
   const ctx = (c) => {
-    const q = ScopeQuerySchema.parse({
+    const q = ProviderScopeQuerySchema.parse({
+      provider: c.req.query("provider"),
       scope: c.req.query("scope"),
       projectPath: c.req.query("projectPath")
     });
-    return { q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+    return {
+      q,
+      paths: resolvePaths({
+        home: deps.home,
+        projectPath: q.projectPath,
+        provider: q.provider
+      })
+    };
   };
   app.get("/", async (c) => {
     const { q, paths } = ctx(c);
@@ -266,34 +320,76 @@ function skillRoutes(deps) {
   });
   app.post("/:name/toggle", async (c) => {
     const { q, paths } = ctx(c);
+    if (q.provider === "agents") {
+      return c.json({ error: "\u516C\u5171 skills \u4E0D\u652F\u6301\u542F\u7528/\u7981\u7528" }, 400);
+    }
     const { enabled } = await c.req.json();
     await deps.skills.toggle(paths, q.scope, c.req.param("name"), enabled);
     return c.json(await deps.skills.list(paths, q.scope));
   });
+  app.post("/:name/make-shared", async (c) => {
+    const { q } = ctx(c);
+    if (q.provider === "agents") {
+      return c.json({ error: "\u8F6C\u516C\u5171\u4EC5\u652F\u6301 claude/codex \u4E0B\u7684\u6280\u80FD" }, 400);
+    }
+    await deps.sync.makeShared(q.provider, c.req.param("name"));
+    return c.json({ ok: true });
+  });
   return app;
 }
 
-// src/server/routes/projects.ts
+// src/server/routes/shared-skills.ts
 import { Hono as Hono3 } from "hono";
 import { z as z3 } from "zod";
-function projectRoutes(deps) {
+var SyncBodySchema = z3.object({ target: z3.enum(["claude", "codex"]) });
+function sharedSkillRoutes(deps) {
   const app = new Hono3();
+  app.get("/", async (c) => {
+    const paths = resolvePaths({ home: deps.home, provider: "agents" });
+    const base = await deps.skills.list(paths, "user");
+    const withSync = await Promise.all(
+      base.map(async (s) => ({ ...s, sync: await deps.sync.status(s.name) }))
+    );
+    return c.json(withSync);
+  });
+  app.post("/:name/sync", async (c) => {
+    const { target } = SyncBodySchema.parse(await c.req.json());
+    await deps.sync.syncTo(c.req.param("name"), target);
+    return c.json({ ok: true });
+  });
+  app.delete("/:name/sync", async (c) => {
+    const { target } = SyncBodySchema.parse(await c.req.json());
+    await deps.sync.unsync(c.req.param("name"), target);
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// src/server/routes/projects.ts
+import { Hono as Hono4 } from "hono";
+import { z as z4 } from "zod";
+function projectRoutes(deps) {
+  const app = new Hono4();
   app.get("/", async (c) => c.json({ projects: await deps.projects.list() }));
+  app.get(
+    "/known",
+    async (c) => c.json({ projects: await deps.projects.known() })
+  );
   app.post("/", async (c) => {
-    const { path } = z3.object({ path: z3.string().min(1) }).parse(await c.req.json());
+    const { path } = z4.object({ path: z4.string().min(1) }).parse(await c.req.json());
     return c.json({ projects: await deps.projects.add(path) });
   });
   app.delete("/", async (c) => {
-    const { path } = z3.object({ path: z3.string().min(1) }).parse(await c.req.json());
+    const { path } = z4.object({ path: z4.string().min(1) }).parse(await c.req.json());
     return c.json({ projects: await deps.projects.remove(path) });
   });
   return app;
 }
 
 // src/server/routes/memory.ts
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono5 } from "hono";
 function memoryRoutes(deps) {
-  const app = new Hono4();
+  const app = new Hono5();
   const ctx = (c) => {
     const q = ScopeQuerySchema.parse({
       scope: c.req.query("scope"),
@@ -315,96 +411,164 @@ function memoryRoutes(deps) {
 }
 
 // src/server/routes/memory-files.ts
-import { Hono as Hono5 } from "hono";
-import { z as z4 } from "zod";
-var QuerySchema = z4.object({ projectPath: z4.string().min(1) });
+import { Hono as Hono6 } from "hono";
+import { z as z5 } from "zod";
+var ProviderQuerySchema = z5.object({
+  provider: z5.enum(["claude", "codex"]).default("claude")
+});
+var ClaudeQuerySchema = z5.object({ projectPath: z5.string().min(1) });
 function memoryFilesRoutes(deps) {
-  const app = new Hono5();
+  const app = new Hono6();
   const ctx = (c) => {
-    const { projectPath } = QuerySchema.parse({ projectPath: c.req.query("projectPath") });
-    return { projectPath, paths: resolvePaths({ home: deps.home, projectPath }) };
+    const { provider } = ProviderQuerySchema.parse({
+      provider: c.req.query("provider") ?? "claude"
+    });
+    if (provider === "codex") {
+      return {
+        provider,
+        projectPath: void 0,
+        paths: resolvePaths({ home: deps.home, provider })
+      };
+    }
+    const { projectPath } = ClaudeQuerySchema.parse({
+      projectPath: c.req.query("projectPath")
+    });
+    return {
+      provider,
+      projectPath,
+      paths: resolvePaths({ home: deps.home, projectPath, provider })
+    };
   };
   app.get("/", async (c) => {
-    const { projectPath, paths } = ctx(c);
-    return c.json(await deps.memoryFiles.overview(paths, projectPath));
+    const { provider, projectPath, paths } = ctx(c);
+    return c.json(
+      provider === "codex" ? await deps.codexMemory.overview(paths) : await deps.memoryFiles.overview(paths, projectPath)
+    );
   });
   app.get("/:file", async (c) => {
-    const { projectPath, paths } = ctx(c);
-    return c.json(await deps.memoryFiles.read(paths, projectPath, c.req.param("file")));
+    const { provider, projectPath, paths } = ctx(c);
+    return c.json(
+      provider === "codex" ? await deps.codexMemory.read(paths, c.req.param("file")) : await deps.memoryFiles.read(paths, projectPath, c.req.param("file"))
+    );
   });
   return app;
 }
 
 // src/server/routes/sessions.ts
-import { Hono as Hono6 } from "hono";
-import { z as z5 } from "zod";
-var QuerySchema2 = z5.object({ projectPath: z5.string().min(1) });
+import { Hono as Hono7 } from "hono";
+import { z as z6 } from "zod";
+var QuerySchema = z6.object({
+  provider: z6.enum(["claude", "codex"]).default("claude"),
+  projectPath: z6.string().min(1)
+});
 function sessionRoutes(deps) {
-  const app = new Hono6();
+  const app = new Hono7();
   const ctx = (c) => {
-    const { projectPath } = QuerySchema2.parse({ projectPath: c.req.query("projectPath") });
-    return { projectPath, paths: resolvePaths({ home: deps.home, projectPath }) };
+    const { provider, projectPath } = QuerySchema.parse({
+      provider: c.req.query("provider") ?? "claude",
+      projectPath: c.req.query("projectPath")
+    });
+    return {
+      provider,
+      projectPath,
+      paths: resolvePaths({ home: deps.home, projectPath, provider })
+    };
   };
   app.get("/", async (c) => {
-    const { projectPath, paths } = ctx(c);
-    return c.json(await deps.sessions.list(paths, projectPath));
+    const { provider, projectPath, paths } = ctx(c);
+    return c.json(
+      provider === "codex" ? await deps.codexSessions.list(paths, projectPath) : await deps.sessions.list(paths, projectPath)
+    );
   });
   app.get("/:id", async (c) => {
-    const { projectPath, paths } = ctx(c);
-    return c.json(await deps.sessions.read(paths, projectPath, c.req.param("id")));
+    const { provider, projectPath, paths } = ctx(c);
+    return c.json(
+      provider === "codex" ? await deps.codexSessions.read(paths, projectPath, c.req.param("id")) : await deps.sessions.read(paths, projectPath, c.req.param("id"))
+    );
   });
   return app;
 }
 
 // src/server/routes/plugins.ts
-import { Hono as Hono7 } from "hono";
-import { z as z6 } from "zod";
-var EnabledBodySchema = z6.object({ enabled: z6.boolean() });
-var ComponentQuerySchema = z6.object({
-  type: z6.enum(["skill", "command", "agent", "hook", "mcp"]),
-  name: z6.string().min(1)
+import { Hono as Hono8 } from "hono";
+import { z as z7 } from "zod";
+var ProviderQuerySchema2 = z7.object({
+  provider: z7.enum(["claude", "codex"]).default("claude")
+});
+var EnabledBodySchema = z7.object({
+  enabled: z7.boolean(),
+  baseMtime: z7.number().optional()
+});
+var ComponentQuerySchema = z7.object({
+  type: z7.enum(["skill", "command", "agent", "hook", "mcp"]),
+  name: z7.string().min(1)
 });
 function pluginRoutes(deps) {
-  const app = new Hono7();
-  const paths = () => resolvePaths({ home: deps.home });
-  app.get("/", async (c) => c.json(await deps.plugins.list(paths())));
-  app.get(
-    "/:id",
-    async (c) => c.json(await deps.plugins.detail(paths(), c.req.param("id")))
-  );
+  const app = new Hono8();
+  const ctx = (c) => {
+    const { provider } = ProviderQuerySchema2.parse({
+      provider: c.req.query("provider") ?? "claude"
+    });
+    return { provider, paths: resolvePaths({ home: deps.home, provider }) };
+  };
+  app.get("/", async (c) => {
+    const { provider, paths } = ctx(c);
+    return c.json(
+      provider === "codex" ? await deps.codexPlugins.list(paths) : await deps.plugins.list(paths)
+    );
+  });
+  app.get("/:id", async (c) => {
+    const { provider, paths } = ctx(c);
+    return c.json(
+      provider === "codex" ? await deps.codexPlugins.detail(paths, c.req.param("id")) : await deps.plugins.detail(paths, c.req.param("id"))
+    );
+  });
   app.get("/:id/component", async (c) => {
+    const { provider, paths } = ctx(c);
     const q = ComponentQuerySchema.parse({
       type: c.req.query("type"),
       name: c.req.query("name")
     });
+    const svc = provider === "codex" ? deps.codexPlugins : deps.plugins;
     return c.json(
-      await deps.plugins.readComponent(
-        paths(),
-        c.req.param("id"),
-        q.type,
-        q.name
-      )
+      await svc.readComponent(paths, c.req.param("id"), q.type, q.name)
     );
   });
   app.patch("/:id", async (c) => {
-    const { enabled } = EnabledBodySchema.parse(await c.req.json());
-    await deps.plugins.setEnabled(paths(), c.req.param("id"), enabled);
-    return c.json(await deps.plugins.list(paths()));
+    const { provider, paths } = ctx(c);
+    const { enabled, baseMtime } = EnabledBodySchema.parse(await c.req.json());
+    if (provider === "codex") {
+      await deps.codexPlugins.setEnabled(
+        paths,
+        c.req.param("id"),
+        enabled,
+        baseMtime
+      );
+      return c.json(await deps.codexPlugins.list(paths));
+    }
+    await deps.plugins.setEnabled(paths, c.req.param("id"), enabled);
+    return c.json(await deps.plugins.list(paths));
   });
   return app;
 }
 
 // src/server/routes/config-files.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 function configFileRoutes(deps) {
-  const app = new Hono8();
+  const app = new Hono9();
   const ctx = (c) => {
     const fileId = ConfigFileIdSchema.parse(c.req.param("file"));
-    const q = ScopeQuerySchema.parse({
+    const q = ProviderScopeQuerySchema.parse({
+      provider: c.req.query("provider"),
       scope: c.req.query("scope"),
       projectPath: c.req.query("projectPath")
     });
-    return { fileId, q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+    McpProviderSchema.parse(q.provider);
+    return {
+      fileId,
+      q,
+      paths: resolvePaths({ home: deps.home, projectPath: q.projectPath, provider: q.provider })
+    };
   };
   app.get("/:file", async (c) => {
     const { fileId, q, paths } = ctx(c);
@@ -420,15 +584,15 @@ function configFileRoutes(deps) {
 }
 
 // src/server/routes/agent-commands.ts
-import { Hono as Hono9 } from "hono";
-import { z as z7 } from "zod";
-var CreateSchema = z7.object({ name: z7.string().min(1), content: z7.string() });
-var WriteSchema = z7.object({
-  content: z7.string(),
-  baseMtime: z7.number().nullable().optional()
+import { Hono as Hono10 } from "hono";
+import { z as z8 } from "zod";
+var CreateSchema = z8.object({ name: z8.string().min(1), content: z8.string() });
+var WriteSchema = z8.object({
+  content: z8.string(),
+  baseMtime: z8.number().nullable().optional()
 });
 function agentCommandRoutes(deps, kind) {
-  const app = new Hono9();
+  const app = new Hono10();
   const ctx = (c) => {
     const q = ScopeQuerySchema.parse({
       scope: c.req.query("scope"),
@@ -466,7 +630,7 @@ function agentCommandRoutes(deps, kind) {
 
 // src/server/app.ts
 function createApp(deps) {
-  const app = new Hono10();
+  const app = new Hono11();
   app.onError((err, c) => {
     if (err instanceof ZodError) {
       return c.json({ error: "\u6821\u9A8C\u5931\u8D25", issues: err.issues }, 400);
@@ -484,6 +648,7 @@ function createApp(deps) {
   });
   app.route("/api/mcp", mcpRoutes(deps));
   app.route("/api/skills", skillRoutes(deps));
+  app.route("/api/shared-skills", sharedSkillRoutes(deps));
   app.route("/api/projects", projectRoutes(deps));
   app.route("/api/memory", memoryRoutes(deps));
   app.route("/api/memory-files", memoryFilesRoutes(deps));
@@ -497,8 +662,10 @@ function createApp(deps) {
 }
 
 export {
+  ConfigCorruptError,
   InvalidJsonError,
   ConfigStore,
+  ConflictError,
   currentMtime,
   assertNoConflict,
   SkillFrontmatterSchema,