ccpanel 0.1.2 → 0.1.4

package/dist/{chunk-7ROXP6AO.js → chunk-HRPQYUJV.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,11 +46,35 @@ 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
+import { stat } from "fs/promises";
+var ConflictError = class extends Error {
+  constructor(message = "\u6587\u4EF6\u5DF2\u88AB\u5916\u90E8\u4FEE\u6539\uFF0C\u8BF7\u91CD\u65B0\u52A0\u8F7D\u540E\u518D\u4FDD\u5B58") {
+    super(message);
+    this.name = "ConflictError";
+  }
+};
+async function currentMtime(file) {
+  try {
+    return (await stat(file)).mtimeMs;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function assertNoConflict(file, baseMtime) {
+  if (baseMtime === void 0) return;
+  if (await currentMtime(file) !== baseMtime) throw new ConflictError();
+}
+
 // src/server/routes/mcp.ts
 import { Hono } from "hono";
 
@@ -58,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");
@@ -90,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
@@ -110,10 +163,25 @@ var McpServerInputSchema = z.intersection(
   McpServerSchema
 );
 var SkillFrontmatterSchema = z.object({ name: z.string().min(1), description: z.string().min(1) }).passthrough();
-var SkillFileWriteSchema = z.object({ content: z.string() });
-var MemoryWriteSchema = z.object({ content: z.string() });
-var ConfigFileIdSchema = z.enum(["settings", "claude-json"]);
-var ConfigFileWriteSchema = z.object({ content: z.string() });
+var BaseMtimeSchema = z.number().nullable().optional();
+var SkillFileWriteSchema = z.object({
+  content: z.string(),
+  baseMtime: BaseMtimeSchema
+});
+var MemoryWriteSchema = z.object({
+  content: z.string(),
+  baseMtime: BaseMtimeSchema
+});
+var ConfigFileIdSchema = z.enum([
+  "settings",
+  "claude-json",
+  "codex-config",
+  "codex-agents"
+]);
+var ConfigFileWriteSchema = z.object({
+  content: z.string(),
+  baseMtime: BaseMtimeSchema
+});
 var ScopeQuerySchema = z.object({
   scope: ScopeSchema,
   projectPath: z.string().optional()
@@ -126,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);
@@ -174,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);
@@ -205,13 +290,14 @@ function skillRoutes(deps) {
   });
   app.put("/:name/files/:filePath{.+}", async (c) => {
     const { q, paths } = ctx(c);
-    const { content } = SkillFileWriteSchema.parse(await c.req.json());
+    const { content, baseMtime } = SkillFileWriteSchema.parse(await c.req.json());
     await deps.skills.writeFileRaw(
       paths,
       q.scope,
       c.req.param("name"),
       c.req.param("filePath"),
-      content
+      content,
+      baseMtime
     );
     return c.json({ ok: true });
   });
@@ -234,34 +320,72 @@ 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.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"),
@@ -275,104 +399,172 @@ function memoryRoutes(deps) {
   });
   app.put("/", async (c) => {
     const { q, paths } = ctx(c);
-    const { content } = MemoryWriteSchema.parse(await c.req.json());
-    await deps.memory.write(paths, q.scope, content);
+    const { content, baseMtime } = MemoryWriteSchema.parse(await c.req.json());
+    await deps.memory.write(paths, q.scope, content, baseMtime);
     return c.json({ ok: true });
   });
   return app;
 }
 
 // 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);
@@ -380,20 +572,23 @@ function configFileRoutes(deps) {
   });
   app.put("/:file", async (c) => {
     const { fileId, q, paths } = ctx(c);
-    const { content } = ConfigFileWriteSchema.parse(await c.req.json());
-    await deps.configFiles.write(paths, fileId, q.scope, content);
+    const { content, baseMtime } = ConfigFileWriteSchema.parse(await c.req.json());
+    await deps.configFiles.write(paths, fileId, q.scope, content, baseMtime);
     return c.json({ ok: true });
   });
   return app;
 }
 
 // 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() });
+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"),
@@ -417,8 +612,8 @@ function agentCommandRoutes(deps, kind) {
   });
   app.put("/:name", async (c) => {
     const { q, paths } = ctx(c);
-    const { content } = WriteSchema.parse(await c.req.json());
-    await deps.agentCommands.write(paths, kind, q.scope, c.req.param("name"), content);
+    const { content, baseMtime } = WriteSchema.parse(await c.req.json());
+    await deps.agentCommands.write(paths, kind, q.scope, c.req.param("name"), content, baseMtime);
     return c.json({ ok: true });
   });
   app.delete("/:name", async (c) => {
@@ -431,7 +626,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);
@@ -442,10 +637,14 @@ function createApp(deps) {
     if (err instanceof InvalidJsonError) {
       return c.json({ error: err.message }, 400);
     }
+    if (err instanceof ConflictError) {
+      return c.json({ error: err.message, code: "conflict" }, 409);
+    }
     return c.json({ error: err.message }, 500);
   });
   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));
@@ -459,8 +658,12 @@ function createApp(deps) {
 }
 
 export {
+  ConfigCorruptError,
   InvalidJsonError,
   ConfigStore,
+  ConflictError,
+  currentMtime,
+  assertNoConflict,
   SkillFrontmatterSchema,
   createApp
 };