ccpanel 0.1.2 → 0.1.4

package/dist/cli.js

@@ -1,20 +1,93 @@
 #!/usr/bin/env node
 import {
+  ConfigCorruptError,
   ConfigStore,
+  ConflictError,
   InvalidJsonError,
   SkillFrontmatterSchema,
-  createApp
-} from "./chunk-7ROXP6AO.js";
+  assertNoConflict,
+  createApp,
+  currentMtime
+} from "./chunk-HRPQYUJV.js";
 
 // src/cli.ts
 import { homedir, networkInterfaces } from "os";
-import { join as join6 } from "path";
+import { join as join12 } from "path";
 import { createServer } from "net";
 import { fileURLToPath } from "url";
 import { realpathSync } from "fs";
 import { serve } from "@hono/node-server";
 import open from "open";
 
+// src/core/mcp-service.ts
+import { join as join2 } from "path";
+
+// src/core/mcp-store.ts
+import { constants, copyFile, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { randomUUID } from "crypto";
+import { parse, stringify } from "smol-toml";
+var ClaudeMcpStore = class {
+  constructor(store, file) {
+    this.store = store;
+    this.file = file;
+  }
+  store;
+  file;
+  async read() {
+    const data = await this.store.readJson(this.file) ?? {};
+    return data.mcpServers ?? {};
+  }
+  async write(map) {
+    const data = await this.store.readJson(this.file) ?? {};
+    data.mcpServers = map;
+    await this.store.writeJson(this.file, data);
+  }
+};
+var CodexMcpStore = class {
+  constructor(file, backupDir) {
+    this.file = file;
+    this.backupDir = backupDir;
+  }
+  file;
+  backupDir;
+  async parseFile() {
+    let raw;
+    try {
+      raw = await readFile(this.file, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw err;
+    }
+    if (raw.trim() === "") return {};
+    try {
+      return parse(raw);
+    } catch {
+      throw new ConfigCorruptError(this.file);
+    }
+  }
+  async read() {
+    const data = await this.parseFile();
+    return data.mcp_servers ?? {};
+  }
+  async write(map) {
+    const data = await this.parseFile();
+    if (Object.keys(map).length > 0) data.mcp_servers = map;
+    else delete data.mcp_servers;
+    await mkdir(this.backupDir, { recursive: true });
+    try {
+      await copyFile(this.file, join(this.backupDir, "config.toml.bak"), constants.COPYFILE_EXCL);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST" && code !== "ENOENT") throw err;
+    }
+    await mkdir(dirname(this.file), { recursive: true });
+    const tmp = `${this.file}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tmp, stringify(data) + "\n", "utf8");
+    await rename(tmp, this.file);
+  }
+};
+
 // src/core/mcp-service.ts
 var McpService = class {
   constructor(store) {
@@ -25,20 +98,23 @@ var McpService = class {
     const { name, ...server } = input;
     return { name, server };
   }
+  // 按 provider 选择用户级主配置的存储实现（claude=JSON / codex=TOML）。
+  userStore(paths) {
+    return paths.provider === "codex" ? new CodexMcpStore(paths.userMcpFile, join2(paths.panelDir, "backup")) : new ClaudeMcpStore(this.store, paths.userMcpFile);
+  }
+  async readDisabled(paths) {
+    return await this.store.readJson(paths.userDisabledMcp) ?? {};
+  }
   async list(paths, scope) {
     if (scope === "user") {
-      const claude = await this.store.readJson(
-        paths.userClaudeJson
-      ) ?? {};
-      const disabled = await this.store.readJson(paths.userDisabledMcp) ?? {};
-      const enabled = Object.entries(claude.mcpServers ?? {}).map(
-        ([name, server]) => ({
-          name,
-          server,
-          enabled: true,
-          path: paths.userClaudeJson
-        })
-      );
+      const active = await this.userStore(paths).read();
+      const disabled = await this.readDisabled(paths);
+      const enabled = Object.entries(active).map(([name, server]) => ({
+        name,
+        server,
+        enabled: true,
+        path: paths.userMcpFile
+      }));
       const off = Object.entries(disabled).map(([name, server]) => ({
         name,
         server,
@@ -64,17 +140,16 @@ var McpService = class {
   async upsert(paths, scope, input) {
     const { name, server } = this.stripName(input);
     if (scope === "user") {
-      const claude = await this.store.readJson(
-        paths.userClaudeJson
-      ) ?? {};
-      const disabled = await this.store.readJson(paths.userDisabledMcp) ?? {};
+      const disabled = await this.readDisabled(paths);
       if (disabled[name]) {
         disabled[name] = server;
         await this.store.writeJson(paths.userDisabledMcp, disabled);
         return;
       }
-      claude.mcpServers = { ...claude.mcpServers ?? {}, [name]: server };
-      await this.store.writeJson(paths.userClaudeJson, claude);
+      const store = this.userStore(paths);
+      const active = await store.read();
+      active[name] = server;
+      await store.write(active);
       return;
     }
     const mcp = await this.store.readJson(
@@ -85,13 +160,12 @@ var McpService = class {
   }
   async remove(paths, scope, name) {
     if (scope === "user") {
-      const claude = await this.store.readJson(
-        paths.userClaudeJson
-      ) ?? {};
-      const disabled = await this.store.readJson(paths.userDisabledMcp) ?? {};
-      if (claude.mcpServers) delete claude.mcpServers[name];
+      const store = this.userStore(paths);
+      const active = await store.read();
+      const disabled = await this.readDisabled(paths);
+      delete active[name];
       delete disabled[name];
-      await this.store.writeJson(paths.userClaudeJson, claude);
+      await store.write(active);
       await this.store.writeJson(paths.userDisabledMcp, disabled);
       return;
     }
@@ -104,11 +178,9 @@ var McpService = class {
   }
   async toggle(paths, scope, name, enabled) {
     if (scope === "user") {
-      const claude = await this.store.readJson(
-        paths.userClaudeJson
-      ) ?? {};
-      const disabled = await this.store.readJson(paths.userDisabledMcp) ?? {};
-      const active = claude.mcpServers ?? {};
+      const store = this.userStore(paths);
+      const active = await store.read();
+      const disabled = await this.readDisabled(paths);
       if (enabled && disabled[name]) {
         active[name] = disabled[name];
         delete disabled[name];
@@ -116,8 +188,7 @@ var McpService = class {
         disabled[name] = active[name];
         delete active[name];
       }
-      claude.mcpServers = active;
-      await this.store.writeJson(paths.userClaudeJson, claude);
+      await store.write(active);
       await this.store.writeJson(paths.userDisabledMcp, disabled);
       return;
     }
@@ -138,17 +209,35 @@ var McpService = class {
 // src/core/skill-service.ts
 import {
   cp,
-  mkdir,
+  mkdir as mkdir2,
   readdir,
-  readFile,
+  readFile as readFile2,
   readlink,
-  rename,
+  rename as rename2,
   rm,
   stat,
-  writeFile
+  writeFile as writeFile2
 } from "fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { dirname as dirname2, isAbsolute, join as join3, relative, resolve as resolve2 } from "path";
 import matter from "gray-matter";
+
+// src/core/link-utils.ts
+import { resolve, sep } from "path";
+function normalizeLinkTarget(p) {
+  const stripped = p.startsWith("\\\\?\\") ? p.slice(4) : p;
+  const abs = resolve(stripped);
+  return process.platform === "win32" ? abs.toLowerCase() : abs;
+}
+function classifyLinkTarget(target, agentsSkillsDir) {
+  const t = normalizeLinkTarget(target);
+  const base = normalizeLinkTarget(agentsSkillsDir);
+  return t === base || t.startsWith(base + sep) ? "shared" : "external";
+}
+function isSameLink(target, expected) {
+  return normalizeLinkTarget(target) === normalizeLinkTarget(expected);
+}
+
+// src/core/skill-service.ts
 function assertSafeName(name) {
   if (!name || name.includes("/") || name.includes("\\") || name.includes("..") || name.includes("\0")) {
     throw new Error(`\u975E\u6CD5 skill \u540D\u79F0\uFF1A${name}`);
@@ -175,7 +264,7 @@ var SkillService = class {
     if (!dir) throw new Error("\u7F3A\u5C11\u9879\u76EE\u7981\u7528 skills \u76EE\u5F55");
     return dir;
   }
-  async scan(dir, enabled) {
+  async scan(dir, enabled, agentsSkillsDir) {
     let entries;
     try {
       entries = await readdir(dir, { withFileTypes: true });
@@ -185,43 +274,61 @@ var SkillService = class {
     }
     const out = [];
     for (const e of entries) {
+      if (e.name.startsWith(".")) continue;
       if (!e.isDirectory() && !e.isSymbolicLink()) continue;
-      const path = join(dir, e.name);
+      const path = join3(dir, e.name);
       let linkTarget;
+      let linkKind;
       if (e.isSymbolicLink()) {
+        linkTarget = await readlink(path).catch(() => void 0);
+        if (linkTarget !== void 0) {
+          linkKind = classifyLinkTarget(resolve2(dir, linkTarget), agentsSkillsDir);
+        }
         try {
           if (!(await stat(path)).isDirectory()) continue;
-          linkTarget = await readlink(path).catch(() => void 0);
         } catch {
+          out.push({
+            name: e.name,
+            description: "(\u65AD\u94FE\uFF1A\u94FE\u63A5\u76EE\u6807\u4E0D\u5B58\u5728)",
+            enabled,
+            path,
+            linkTarget,
+            linkKind,
+            broken: true,
+            mtime: 0
+          });
           continue;
         }
       }
+      const mtime = await currentMtime(join3(path, "SKILL.md")) ?? await currentMtime(path) ?? 0;
       try {
-        const raw = await readFile(join(path, "SKILL.md"), "utf8");
+        const raw = await readFile2(join3(path, "SKILL.md"), "utf8");
         const fm = SkillFrontmatterSchema.parse(matter(raw).data);
-        out.push({ name: e.name, description: fm.description, enabled, path, linkTarget });
+        out.push({ name: e.name, description: fm.description, enabled, path, linkTarget, linkKind, mtime });
       } catch {
         out.push({
           name: e.name,
           description: "(SKILL.md \u7F3A\u5931\u6216\u65E0\u6548)",
           enabled,
           path,
-          linkTarget
+          linkTarget,
+          linkKind,
+          mtime
         });
       }
     }
     return out;
   }
   async list(paths, scope) {
-    const on = await this.scan(this.enabledDir(paths, scope), true);
-    const off = await this.scan(this.disabledDir(paths, scope), false);
+    const on = await this.scan(this.enabledDir(paths, scope), true, paths.agentsSkillsDir);
+    const off = await this.scan(this.disabledDir(paths, scope), false, paths.agentsSkillsDir);
     return [...on, ...off].sort((a, b) => a.name.localeCompare(b.name));
   }
   // 返回该技能实际所在目录（启用或禁用），都不存在则抛错。
   async resolveSkillDir(paths, scope, name) {
     assertSafeName(name);
     for (const base of [this.enabledDir(paths, scope), this.disabledDir(paths, scope)]) {
-      const dir = join(base, name);
+      const dir = join3(base, name);
       try {
         await readdir(dir);
         return dir;
@@ -232,7 +339,7 @@ var SkillService = class {
   }
   // 把相对路径安全地解析到技能目录内，防止 `..` 越权。
   resolveWithin(baseDir, relPath) {
-    const full = resolve(baseDir, relPath);
+    const full = resolve2(baseDir, relPath);
     const rel = relative(baseDir, full);
     if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
       throw new Error(`\u975E\u6CD5\u6587\u4EF6\u8DEF\u5F84\uFF1A${relPath}`);
@@ -241,14 +348,14 @@ var SkillService = class {
   }
   async read(paths, scope, name) {
     assertSafeName(name);
-    const enabledPath = join(this.enabledDir(paths, scope), name, "SKILL.md");
-    const disabledPath = join(this.disabledDir(paths, scope), name, "SKILL.md");
+    const enabledPath = join3(this.enabledDir(paths, scope), name, "SKILL.md");
+    const disabledPath = join3(this.disabledDir(paths, scope), name, "SKILL.md");
     let raw;
     try {
-      raw = await readFile(enabledPath, "utf8");
+      raw = await readFile2(enabledPath, "utf8");
     } catch {
       try {
-        raw = await readFile(disabledPath, "utf8");
+        raw = await readFile2(disabledPath, "utf8");
       } catch {
         throw new Error(`\u672A\u627E\u5230 skill\u300C${name}\u300D\uFF08scope: ${scope}\uFF09`);
       }
@@ -266,12 +373,12 @@ var SkillService = class {
     const walk = async (dir) => {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const e of entries) {
-        const full = join(dir, e.name);
+        const full = join3(dir, e.name);
         if (e.isDirectory()) {
           if (IGNORED_DIRS.has(e.name)) continue;
           await walk(full);
         } else if (e.isFile()) {
-          if (isBinary(await readFile(full))) continue;
+          if (isBinary(await readFile2(full))) continue;
           out.push(relative(root, full).split("\\").join("/"));
         }
       }
@@ -282,39 +389,40 @@ var SkillService = class {
   async readFileRaw(paths, scope, name, relPath) {
     const root = await this.resolveSkillDir(paths, scope, name);
     const full = this.resolveWithin(root, relPath);
-    const buf = await readFile(full);
+    const buf = await readFile2(full);
     if (isBinary(buf)) throw new Error(`\u4E8C\u8FDB\u5236\u6587\u4EF6\u65E0\u6CD5\u7F16\u8F91\uFF1A${relPath}`);
-    return { content: buf.toString("utf8") };
+    return { content: buf.toString("utf8"), mtime: await currentMtime(full) };
   }
-  async writeFileRaw(paths, scope, name, relPath, content) {
+  async writeFileRaw(paths, scope, name, relPath, content, baseMtime) {
     const root = await this.resolveSkillDir(paths, scope, name);
     const full = this.resolveWithin(root, relPath);
-    await mkdir(dirname(full), { recursive: true });
-    await writeFile(full, content, "utf8");
+    await assertNoConflict(full, baseMtime);
+    await mkdir2(dirname2(full), { recursive: true });
+    await writeFile2(full, content, "utf8");
   }
   async upsert(paths, scope, name, frontmatter, body) {
     assertSafeName(name);
-    const file = join(this.enabledDir(paths, scope), name, "SKILL.md");
-    await mkdir(dirname(file), { recursive: true });
+    const file = join3(this.enabledDir(paths, scope), name, "SKILL.md");
+    await mkdir2(dirname2(file), { recursive: true });
     const content = matter.stringify(body, frontmatter);
-    await writeFile(file, content, "utf8");
+    await writeFile2(file, content, "utf8");
   }
   async remove(paths, scope, name) {
     assertSafeName(name);
-    await rm(join(this.enabledDir(paths, scope), name), {
+    await rm(join3(this.enabledDir(paths, scope), name), {
       recursive: true,
       force: true
     });
-    await rm(join(this.disabledDir(paths, scope), name), {
+    await rm(join3(this.disabledDir(paths, scope), name), {
       recursive: true,
       force: true
     });
   }
   // 跨盘符 rename 会抛 EXDEV（如项目在 D: 而 ~/.ccpanel 在 C:），回退到复制+删除。
   async moveDir(from, to) {
-    await mkdir(dirname(to), { recursive: true });
+    await mkdir2(dirname2(to), { recursive: true });
     try {
-      await rename(from, to);
+      await rename2(from, to);
     } catch (err) {
       if (err.code === "EXDEV") {
         await cp(from, to, { recursive: true });
@@ -326,11 +434,11 @@ var SkillService = class {
   }
   async toggle(paths, scope, name, enabled) {
     assertSafeName(name);
-    const from = join(
+    const from = join3(
       enabled ? this.disabledDir(paths, scope) : this.enabledDir(paths, scope),
       name
     );
-    const to = join(
+    const to = join3(
       enabled ? this.enabledDir(paths, scope) : this.disabledDir(paths, scope),
       name
     );
@@ -368,38 +476,41 @@ var ProjectService = class {
 };
 
 // src/core/memory-service.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
 var MemoryService = class {
   file(paths, scope) {
     const f = scope === "user" ? paths.userClaudeMd : paths.projectClaudeMd;
     if (!f) throw new Error("\u7F3A\u5C11\u9879\u76EE CLAUDE.md \u8DEF\u5F84");
     return f;
   }
-  // 文件不存在视为「尚未创建」，返回空串。
+  // 文件不存在视为「尚未创建」，返回空串与 null mtime。
   async read(paths, scope) {
+    const f = this.file(paths, scope);
     try {
-      return { content: await readFile2(this.file(paths, scope), "utf8") };
+      return { content: await readFile3(f, "utf8"), mtime: await currentMtime(f) };
     } catch (err) {
-      if (err.code === "ENOENT") return { content: "" };
+      if (err.code === "ENOENT")
+        return { content: "", mtime: null };
       throw err;
     }
   }
-  async write(paths, scope, content) {
+  async write(paths, scope, content, baseMtime) {
     const f = this.file(paths, scope);
-    await mkdir2(dirname2(f), { recursive: true });
-    await writeFile2(f, content, "utf8");
+    await assertNoConflict(f, baseMtime);
+    await mkdir3(dirname3(f), { recursive: true });
+    await writeFile3(f, content, "utf8");
   }
 };
 
 // src/core/memory-files-service.ts
-import { readdir as readdir3, readFile as readFile4, stat as stat3 } from "fs/promises";
-import { join as join3 } from "path";
+import { readdir as readdir3, readFile as readFile5, stat as stat3 } from "fs/promises";
+import { join as join5 } from "path";
 import matter2 from "gray-matter";
 
 // src/core/session-service.ts
-import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
-import { join as join2 } from "path";
+import { readdir as readdir2, readFile as readFile4, stat as stat2 } from "fs/promises";
+import { join as join4 } from "path";
 var MAX_BLOCK = 1e4;
 var NOISE_PREFIXES = ["<local-command", "<command-", "<system-reminder", "Caveat:"];
 function encodeProjectDir(projectPath) {
@@ -483,7 +594,7 @@ function toBlocks(content) {
 }
 var SessionService = class {
   dir(paths, projectPath) {
-    return join2(paths.userProjectsDir, encodeProjectDir(projectPath));
+    return join4(paths.userProjectsDir, encodeProjectDir(projectPath));
   }
   async list(paths, projectPath) {
     const dir = this.dir(paths, projectPath);
@@ -496,7 +607,7 @@ var SessionService = class {
     }
     const out = [];
     for (const name of names) {
-      const full = join2(dir, name);
+      const full = join4(dir, name);
       const st = await stat2(full);
       const { firstPrompt, messageCount } = await this.summarize(full);
       out.push({
@@ -510,7 +621,7 @@ var SessionService = class {
     return out.sort((a, b) => b.mtime - a.mtime);
   }
   async summarize(file) {
-    const raw = await readFile3(file, "utf8");
+    const raw = await readFile4(file, "utf8");
     let firstPrompt = "";
     let messageCount = 0;
     for (const line of raw.split("\n")) {
@@ -535,9 +646,9 @@ var SessionService = class {
   async read(paths, projectPath, id) {
     assertSafeId(id);
     const dir = this.dir(paths, projectPath);
-    const raw = await readFile3(join2(dir, `${id}.jsonl`), "utf8");
+    const raw = await readFile4(join4(dir, `${id}.jsonl`), "utf8");
     const messages = parseMessages(raw);
-    const subagents = await this.readSubagents(join2(dir, id, "subagents"));
+    const subagents = await this.readSubagents(join4(dir, id, "subagents"));
     return { messages, subagents };
   }
   // 读取某会话的 subagents/ 目录：每个 agent-<id>.jsonl 配对同名 .meta.json。
@@ -554,8 +665,8 @@ var SessionService = class {
     for (const name of names) {
       const agentId = parseAgentId(name);
       if (!agentId) continue;
-      const messages = parseMessages(await readFile3(join2(subDir, name), "utf8"));
-      const meta = await this.readMeta(join2(subDir, `agent-${agentId}.meta.json`));
+      const messages = parseMessages(await readFile4(join4(subDir, name), "utf8"));
+      const meta = await this.readMeta(join4(subDir, `agent-${agentId}.meta.json`));
       out.push({
         toolUseId: meta.toolUseId,
         agentId,
@@ -568,7 +679,7 @@ var SessionService = class {
   }
   async readMeta(file) {
     try {
-      const obj = JSON.parse(await readFile3(file, "utf8"));
+      const obj = JSON.parse(await readFile4(file, "utf8"));
       return {
         toolUseId: String(obj.toolUseId ?? ""),
         agentType: String(obj.agentType ?? "subagent"),
@@ -589,7 +700,7 @@ function assertSafeMemoryFile(file) {
 }
 var MemoryFilesService = class {
   dir(paths, projectPath) {
-    return join3(paths.userProjectsDir, encodeProjectDir(projectPath), "memory");
+    return join5(paths.userProjectsDir, encodeProjectDir(projectPath), "memory");
   }
   // 目录不存在视为「尚无记忆」，返回空概览。
   async overview(paths, projectPath) {
@@ -604,9 +715,9 @@ var MemoryFilesService = class {
     let index = null;
     const files = [];
     for (const name of names) {
-      const full = join3(dir, name);
+      const full = join5(dir, name);
       if (name === INDEX_FILE) {
-        index = await readFile4(full, "utf8");
+        index = await readFile5(full, "utf8");
         continue;
       }
       const st = await stat3(full);
@@ -620,7 +731,7 @@ var MemoryFilesService = class {
   async parseFront(full, fileName) {
     const fallbackName = fileName.replace(/\.md$/, "");
     try {
-      const data = matter2(await readFile4(full, "utf8")).data;
+      const data = matter2(await readFile5(full, "utf8")).data;
       const meta = data.metadata ?? {};
       return {
         name: typeof data.name === "string" && data.name ? data.name : fallbackName,
@@ -634,13 +745,13 @@ var MemoryFilesService = class {
   // 读取单个记忆文件原文（含 frontmatter）。
   async read(paths, projectPath, file) {
     assertSafeMemoryFile(file);
-    return { content: await readFile4(join3(this.dir(paths, projectPath), file), "utf8") };
+    return { content: await readFile5(join5(this.dir(paths, projectPath), file), "utf8") };
   }
 };
 
 // src/core/plugin-service.ts
-import { readFile as readFile5, readdir as readdir4, stat as stat4 } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve2 } from "path";
+import { readFile as readFile6, readdir as readdir4, stat as stat4 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve3 } from "path";
 import matter3 from "gray-matter";
 var PluginService = class {
   constructor(store) {
@@ -659,7 +770,7 @@ var PluginService = class {
     }
   }
   manifestFile(installPath) {
-    return join4(installPath, ".claude-plugin", "plugin.json");
+    return join6(installPath, ".claude-plugin", "plugin.json");
   }
   // id 形如 "name@marketplace"，按最后一个 @ 切分。
   splitId(id) {
@@ -691,7 +802,8 @@ var PluginService = class {
       repo: markets[marketplace]?.source?.repo,
       installPath,
       enabled: enabled[id] === true,
-      exists
+      exists,
+      source: "user"
     };
     return { entry, manifest };
   }
@@ -736,7 +848,7 @@ var PluginService = class {
   // 读取 frontmatter 的 description / name 作为子组件摘要，失败返回空串。
   async readDescription(file) {
     try {
-      const fm = matter3(await readFile5(file, "utf8")).data;
+      const fm = matter3(await readFile6(file, "utf8")).data;
       return fm.description ?? fm.name ?? "";
     } catch {
       return "";
@@ -753,7 +865,7 @@ var PluginService = class {
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const description = await this.readDescription(
-        join4(dir, e.name, "SKILL.md")
+        join6(dir, e.name, "SKILL.md")
       );
       out.push({ type: "skill", name: e.name, description });
     }
@@ -770,7 +882,7 @@ var PluginService = class {
         return;
       }
       for (const e of entries) {
-        const full = join4(cur, e.name);
+        const full = join6(cur, e.name);
         if (e.isDirectory()) {
           await walk(full);
         } else if (e.isFile() && e.name.endsWith(".md")) {
@@ -788,7 +900,7 @@ var PluginService = class {
   }
   async scanHooks(file) {
     try {
-      const json = JSON.parse(await readFile5(file, "utf8"));
+      const json = JSON.parse(await readFile6(file, "utf8"));
       const events = Object.keys(json.hooks ?? json);
       return [
         {
@@ -811,7 +923,7 @@ var PluginService = class {
   // 插件 MCP 既可能在 .mcp.json（顶层即 server 映射或带 mcpServers 包裹），
   // 也可能在 plugin.json 的 mcpServers 字段；合并两者。
   async loadMcpServers(installPath, manifest) {
-    const fromFile = await this.safeReadJson(join4(installPath, ".mcp.json"));
+    const fromFile = await this.safeReadJson(join6(installPath, ".mcp.json"));
     const fileMap = fromFile?.mcpServers ?? fromFile ?? {};
     const manifestMap = manifest?.mcpServers ?? {};
     return { ...fileMap, ...manifestMap };
@@ -826,17 +938,17 @@ var PluginService = class {
   }
   async scanComponents(installPath, manifest) {
     const [skills, commands, agents, hooks, mcp] = await Promise.all([
-      this.scanSkills(join4(installPath, "skills")),
-      this.scanMarkdownDir(join4(installPath, "commands"), "command"),
-      this.scanMarkdownDir(join4(installPath, "agents"), "agent"),
-      this.scanHooks(join4(installPath, "hooks", "hooks.json")),
+      this.scanSkills(join6(installPath, "skills")),
+      this.scanMarkdownDir(join6(installPath, "commands"), "command"),
+      this.scanMarkdownDir(join6(installPath, "agents"), "agent"),
+      this.scanHooks(join6(installPath, "hooks", "hooks.json")),
       this.scanMcp(installPath, manifest)
     ]);
     return [...skills, ...commands, ...agents, ...hooks, ...mcp];
   }
   // 把外部传入的相对路径安全解析到 baseDir 内，防止 `..` 越权。
   resolveWithin(baseDir, relPath) {
-    const full = resolve2(baseDir, relPath);
+    const full = resolve3(baseDir, relPath);
     const rel = relative2(baseDir, full);
     if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) {
       throw new Error(`\u975E\u6CD5\u7EC4\u4EF6\u8DEF\u5F84\uFF1A${relPath}`);
@@ -848,33 +960,33 @@ var PluginService = class {
     const base = rec.installPath;
     if (type === "skill") {
       const file = this.resolveWithin(
-        join4(base, "skills"),
-        join4(name, "SKILL.md")
+        join6(base, "skills"),
+        join6(name, "SKILL.md")
       );
       return {
         type,
         name,
         language: "markdown",
-        content: await readFile5(file, "utf8")
+        content: await readFile6(file, "utf8")
       };
     }
     if (type === "command" || type === "agent") {
       const sub = type === "command" ? "commands" : "agents";
-      const file = this.resolveWithin(join4(base, sub), `${name}.md`);
+      const file = this.resolveWithin(join6(base, sub), `${name}.md`);
       return {
         type,
         name,
         language: "markdown",
-        content: await readFile5(file, "utf8")
+        content: await readFile6(file, "utf8")
       };
     }
     if (type === "hook") {
-      const file = join4(base, "hooks", "hooks.json");
+      const file = join6(base, "hooks", "hooks.json");
       return {
         type,
         name,
         language: "json",
-        content: await readFile5(file, "utf8")
+        content: await readFile6(file, "utf8")
       };
     }
     const manifest = await this.safeReadJson(
@@ -900,52 +1012,758 @@ var PluginService = class {
   }
 };
 
+// src/core/codex-plugin-service.ts
+import { readFile as readFile7, readdir as readdir5, stat as stat5 } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join7, relative as relative3, resolve as resolve4 } from "path";
+import matter4 from "gray-matter";
+import { parse as parse2, stringify as stringify2 } from "smol-toml";
+var BUILTIN_MARKETPLACES = /* @__PURE__ */ new Set([
+  "openai-bundled",
+  "openai-primary-runtime",
+  "openai-curated"
+]);
+var CodexPluginService = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async pathExists(p) {
+    return stat5(p).then(() => true).catch(() => false);
+  }
+  async readConfig(paths) {
+    let raw;
+    try {
+      raw = await readFile7(paths.codexConfigToml, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw err;
+    }
+    if (!raw.trim()) return {};
+    return parse2(raw);
+  }
+  // id 形如 "name@marketplace"，按最后一个 @ 切分，兼容插件名自身含 @。
+  splitId(id) {
+    const at = id.lastIndexOf("@");
+    if (at <= 0 || at === id.length - 1) {
+      throw new Error(`\u975E\u6CD5\u63D2\u4EF6 id\uFF1A${id}`);
+    }
+    return { name: id.slice(0, at), marketplace: id.slice(at + 1) };
+  }
+  authorName(a) {
+    if (!a) return void 0;
+    return typeof a === "string" ? a : a.name;
+  }
+  manifestFile(installPath) {
+    return join7(installPath, ".codex-plugin", "plugin.json");
+  }
+  async readManifest(installPath) {
+    try {
+      return JSON.parse(await readFile7(this.manifestFile(installPath), "utf8"));
+    } catch {
+      return void 0;
+    }
+  }
+  compareVersionDir(a, b) {
+    const pa = a.split(".").map((x) => Number.parseInt(x, 10));
+    const pb = b.split(".").map((x) => Number.parseInt(x, 10));
+    const validA = pa.every(Number.isFinite);
+    const validB = pb.every(Number.isFinite);
+    if (validA && validB) {
+      for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const diff = (pb[i] ?? 0) - (pa[i] ?? 0);
+        if (diff !== 0) return diff;
+      }
+      return 0;
+    }
+    if (validA !== validB) return validA ? -1 : 1;
+    return b.localeCompare(a);
+  }
+  async findInstallPath(paths, id) {
+    const { name, marketplace } = this.splitId(id);
+    const root = join7(paths.codexPluginsDir, "cache", marketplace, name);
+    let entries;
+    try {
+      entries = await readdir5(root, { withFileTypes: true });
+    } catch (err) {
+      if (err.code === "ENOENT") return void 0;
+      throw err;
+    }
+    const versions = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort((a, b) => this.compareVersionDir(a, b));
+    return versions[0] ? join7(root, versions[0]) : void 0;
+  }
+  async buildEntry(paths, id, enabled, config) {
+    const { name: idName, marketplace } = this.splitId(id);
+    const installPath = await this.findInstallPath(paths, id) ?? "";
+    const exists = installPath ? await this.pathExists(installPath) : false;
+    const manifest = exists ? await this.readManifest(installPath) : void 0;
+    const entry = {
+      id,
+      name: manifest?.name ?? idName,
+      description: manifest?.description ?? "",
+      version: manifest?.version ?? (installPath ? installPath.split(/[\\/]/).at(-1) : "unknown") ?? "unknown",
+      author: this.authorName(manifest?.author),
+      homepage: manifest?.homepage,
+      marketplace,
+      repo: config.marketplaces?.[marketplace]?.source,
+      installPath,
+      enabled,
+      exists,
+      source: BUILTIN_MARKETPLACES.has(marketplace) ? "builtin" : "user"
+    };
+    return { entry, manifest };
+  }
+  async list(paths) {
+    const config = await this.readConfig(paths);
+    const out = [];
+    for (const [id, rec] of Object.entries(config.plugins ?? {})) {
+      const { entry } = await this.buildEntry(paths, id, rec.enabled === true, config);
+      out.push(entry);
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async detail(paths, id) {
+    const config = await this.readConfig(paths);
+    const rec = config.plugins?.[id];
+    if (!rec) throw new Error(`\u672A\u627E\u5230\u63D2\u4EF6\u300C${id}\u300D`);
+    const { entry, manifest } = await this.buildEntry(
+      paths,
+      id,
+      rec.enabled === true,
+      config
+    );
+    const components = entry.exists ? await this.scanComponents(entry.installPath, manifest) : [];
+    return { ...entry, components };
+  }
+  async readDescription(file) {
+    try {
+      const fm = matter4(await readFile7(file, "utf8")).data;
+      return fm.description ?? fm.name ?? "";
+    } catch {
+      return "";
+    }
+  }
+  async scanSkills(dir) {
+    let entries;
+    try {
+      entries = await readdir5(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      out.push({
+        type: "skill",
+        name: e.name,
+        description: await this.readDescription(join7(dir, e.name, "SKILL.md"))
+      });
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async scanMarkdownDir(dir, type) {
+    const out = [];
+    const walk = async (cur) => {
+      let entries;
+      try {
+        entries = await readdir5(cur, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        const full = join7(cur, e.name);
+        if (e.isDirectory()) {
+          await walk(full);
+        } else if (e.isFile() && e.name.endsWith(".md")) {
+          out.push({
+            type,
+            name: relative3(dir, full).split("\\").join("/").replace(/\.md$/, ""),
+            description: await this.readDescription(full)
+          });
+        }
+      }
+    };
+    await walk(dir);
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async scanHooks(file) {
+    try {
+      const json = JSON.parse(await readFile7(file, "utf8"));
+      const events = Object.keys(json.hooks ?? json);
+      return [
+        {
+          type: "hook",
+          name: "hooks.json",
+          description: events.length ? `\u4E8B\u4EF6\uFF1A${events.join(", ")}` : ""
+        }
+      ];
+    } catch {
+      return [];
+    }
+  }
+  summarizeMcp(config) {
+    if (config.command) {
+      return `${config.command} ${(config.args ?? []).join(" ")}`.trim();
+    }
+    if (config.url) return `${config.type ?? ""} ${config.url}`.trim();
+    return "";
+  }
+  async scanMcp(manifest) {
+    return Object.entries(manifest?.mcpServers ?? {}).map(([name, config]) => ({
+      type: "mcp",
+      name,
+      description: this.summarizeMcp(config)
+    }));
+  }
+  async scanComponents(installPath, manifest) {
+    const [skills, commands, agents, hooks, mcp] = await Promise.all([
+      this.scanSkills(join7(installPath, "skills")),
+      this.scanMarkdownDir(join7(installPath, "commands"), "command"),
+      this.scanMarkdownDir(join7(installPath, "agents"), "agent"),
+      this.scanHooks(join7(installPath, "hooks", "hooks.json")),
+      this.scanMcp(manifest)
+    ]);
+    return [...skills, ...commands, ...agents, ...hooks, ...mcp];
+  }
+  resolveWithin(baseDir, relPath) {
+    const full = resolve4(baseDir, relPath);
+    const rel = relative3(baseDir, full);
+    if (rel === "" || rel.startsWith("..") || isAbsolute3(rel)) {
+      throw new Error(`\u975E\u6CD5\u7EC4\u4EF6\u8DEF\u5F84\uFF1A${relPath}`);
+    }
+    return full;
+  }
+  async readComponent(paths, id, type, name) {
+    const detail = await this.detail(paths, id);
+    const base = detail.installPath;
+    if (type === "skill") {
+      const file = this.resolveWithin(join7(base, "skills"), join7(name, "SKILL.md"));
+      return { type, name, language: "markdown", content: await readFile7(file, "utf8") };
+    }
+    if (type === "command" || type === "agent") {
+      const sub = type === "command" ? "commands" : "agents";
+      const file = this.resolveWithin(join7(base, sub), `${name}.md`);
+      return { type, name, language: "markdown", content: await readFile7(file, "utf8") };
+    }
+    if (type === "hook") {
+      const file = this.resolveWithin(join7(base, "hooks"), name);
+      return { type, name, language: "json", content: await readFile7(file, "utf8") };
+    }
+    const manifest = await this.readManifest(base);
+    const config = manifest?.mcpServers?.[name];
+    if (!config) throw new Error(`\u672A\u627E\u5230 MCP server\u300C${name}\u300D`);
+    return {
+      type,
+      name,
+      language: "json",
+      content: JSON.stringify(config, null, 2)
+    };
+  }
+  async setEnabled(paths, id, enabled, baseMtime) {
+    if (baseMtime !== void 0) {
+      const st = await stat5(paths.codexConfigToml);
+      if (Math.abs(st.mtimeMs - baseMtime) > 1) {
+        throw new Error("\u914D\u7F6E\u6587\u4EF6\u5DF2\u88AB\u5176\u4ED6\u8FDB\u7A0B\u4FEE\u6539\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5");
+      }
+    }
+    const config = await this.readConfig(paths);
+    config.plugins = { ...config.plugins ?? {} };
+    config.plugins[id] = { ...config.plugins[id] ?? {}, enabled };
+    await this.store.writeText(paths.codexConfigToml, stringify2(config));
+  }
+};
+
+// src/core/codex-memory-service.ts
+import Database from "better-sqlite3";
+import { readFile as readFile8, readdir as readdir6, stat as stat6 } from "fs/promises";
+import { basename, extname, isAbsolute as isAbsolute4, join as join8, relative as relative4, resolve as resolve5 } from "path";
+var CodexDataCompatibilityError = class extends Error {
+  constructor(message = "Codex \u8BB0\u5FC6\u6570\u636E\u5E93\u683C\u5F0F\u6682\u4E0D\u652F\u6301") {
+    super(message);
+    this.name = "CodexDataCompatibilityError";
+  }
+};
+var SUPPORTED_COLUMNS = /* @__PURE__ */ new Set([
+  "id",
+  "title",
+  "content",
+  "project_path",
+  "created_at",
+  "updated_at"
+]);
+var FILE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".json"]);
+var STAGE1_COLUMNS = /* @__PURE__ */ new Set([
+  "thread_id",
+  "source_updated_at",
+  "raw_memory",
+  "rollout_summary",
+  "rollout_slug",
+  "generated_at"
+]);
+var CodexMemoryService = class {
+  async overview(paths) {
+    const [sqliteItems, fileItems] = await Promise.all([
+      this.sqliteOverview(paths),
+      this.fileOverview(paths)
+    ]);
+    return {
+      items: [...sqliteItems, ...fileItems].sort((a, b) => b.mtime - a.mtime)
+    };
+  }
+  async read(paths, id) {
+    if (id.startsWith("sqlite:")) {
+      return this.readSqlite(paths, id.slice("sqlite:".length));
+    }
+    if (id.startsWith("file:")) {
+      const file = this.resolveMemoryFile(paths, id.slice("file:".length));
+      return { content: await readFile8(file, "utf8") };
+    }
+    throw new Error(`\u975E\u6CD5\u8BB0\u5FC6 id\uFF1A${id}`);
+  }
+  async sqliteOverview(paths) {
+    if (!await this.exists(paths.codexMemoriesDb)) return [];
+    const db = new Database(paths.codexMemoriesDb, {
+      readonly: true,
+      fileMustExist: true
+    });
+    try {
+      const schema = this.detectSupportedSchema(db);
+      if (schema === "memories") {
+        const rows2 = db.prepare(
+          `SELECT id, title, content, project_path, created_at, updated_at
+             FROM memories
+             ORDER BY COALESCE(updated_at, created_at, 0) DESC`
+        ).all();
+        return rows2.map((row) => ({
+          id: `sqlite:${row.id}`,
+          name: row.title || row.id,
+          description: this.describe(row.content),
+          source: "sqlite",
+          projectPath: row.project_path ?? void 0,
+          mtime: row.updated_at ?? row.created_at ?? 0
+        }));
+      }
+      const rows = db.prepare(
+        `SELECT thread_id, source_updated_at, raw_memory, rollout_summary,
+                  rollout_slug, generated_at
+           FROM stage1_outputs
+           ORDER BY source_updated_at DESC`
+      ).all();
+      return rows.map((row) => ({
+        id: `sqlite:stage1:${row.thread_id}`,
+        name: row.rollout_slug || row.thread_id,
+        description: row.rollout_summary || this.describe(row.raw_memory),
+        source: "sqlite",
+        mtime: row.source_updated_at || row.generated_at || 0
+      }));
+    } finally {
+      db.close();
+    }
+  }
+  async readSqlite(paths, id) {
+    if (!id || id.includes("/") || id.includes("\\") || id.includes("..")) {
+      throw new Error(`\u975E\u6CD5\u8BB0\u5FC6 id\uFF1Asqlite:${id}`);
+    }
+    const db = new Database(paths.codexMemoriesDb, {
+      readonly: true,
+      fileMustExist: true
+    });
+    try {
+      const schema = this.detectSupportedSchema(db);
+      if (schema === "memories") {
+        const row2 = db.prepare("SELECT content FROM memories WHERE id = ?").get(id);
+        if (!row2) throw new Error(`\u672A\u627E\u5230\u8BB0\u5FC6\uFF1Asqlite:${id}`);
+        return { content: row2.content ?? "" };
+      }
+      const stage1Id = id.startsWith("stage1:") ? id.slice("stage1:".length) : id;
+      const row = db.prepare("SELECT raw_memory FROM stage1_outputs WHERE thread_id = ?").get(stage1Id);
+      if (!row) throw new Error(`\u672A\u627E\u5230\u8BB0\u5FC6\uFF1Asqlite:${id}`);
+      return { content: row.raw_memory ?? "" };
+    } finally {
+      db.close();
+    }
+  }
+  detectSupportedSchema(db) {
+    if (this.hasColumns(db, "memories", SUPPORTED_COLUMNS)) return "memories";
+    if (this.hasColumns(db, "stage1_outputs", STAGE1_COLUMNS)) return "stage1";
+    throw new CodexDataCompatibilityError();
+  }
+  hasColumns(db, tableName, expectedColumns) {
+    const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+    if (!table) return false;
+    const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
+    const names = new Set(columns.map((c) => c.name));
+    for (const expected of expectedColumns) {
+      if (!names.has(expected)) return false;
+    }
+    return true;
+  }
+  async fileOverview(paths) {
+    let entries;
+    try {
+      entries = await readdir6(paths.codexMemoriesDir, { withFileTypes: true });
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const out = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !FILE_EXTENSIONS.has(extname(entry.name))) continue;
+      const file = join8(paths.codexMemoriesDir, entry.name);
+      const st = await stat6(file);
+      out.push({
+        id: `file:${entry.name}`,
+        name: entry.name,
+        description: this.describe(await readFile8(file, "utf8")),
+        source: "file",
+        mtime: st.mtimeMs
+      });
+    }
+    return out;
+  }
+  resolveMemoryFile(paths, name) {
+    if (!name || name !== basename(name) || !FILE_EXTENSIONS.has(extname(name))) {
+      throw new Error(`\u975E\u6CD5\u8BB0\u5FC6\u6587\u4EF6\uFF1A${name}`);
+    }
+    const full = resolve5(paths.codexMemoriesDir, name);
+    const rel = relative4(paths.codexMemoriesDir, full);
+    if (rel === "" || rel.startsWith("..") || isAbsolute4(rel)) {
+      throw new Error(`\u975E\u6CD5\u8BB0\u5FC6\u6587\u4EF6\uFF1A${name}`);
+    }
+    return full;
+  }
+  describe(content) {
+    return content.replace(/\s+/g, " ").trim().slice(0, 120);
+  }
+  async exists(file) {
+    return stat6(file).then(() => true).catch((err) => {
+      if (err.code === "ENOENT") return false;
+      throw err;
+    });
+  }
+};
+
+// src/core/codex-session-service.ts
+import { readdir as readdir7, readFile as readFile9, stat as stat7 } from "fs/promises";
+import { join as join9, resolve as resolve6 } from "path";
+var MAX_BLOCK2 = 1e4;
+function truncate2(s) {
+  return s.length > MAX_BLOCK2 ? s.slice(0, MAX_BLOCK2) + "\n\u2026(\u5DF2\u622A\u65AD)" : s;
+}
+function assertSafeId2(id) {
+  if (!id || !/^[A-Za-z0-9-]+$/.test(id)) {
+    throw new Error(`\u975E\u6CD5\u4F1A\u8BDD id\uFF1A${id}`);
+  }
+}
+function normalizeProjectPath(p) {
+  return resolve6(p).replace(/\\/g, "/").toLowerCase();
+}
+function payloadOf(obj) {
+  const payload = obj.payload;
+  return payload && typeof payload === "object" ? payload : obj;
+}
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((raw) => {
+    if (!raw || typeof raw !== "object") return "";
+    const b = raw;
+    if (typeof b.text === "string") return b.text;
+    return "";
+  }).join(" ");
+}
+function blocksFromContent(content) {
+  if (typeof content === "string") {
+    return content.trim() ? [{ kind: "text", text: truncate2(content) }] : [];
+  }
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const raw of content) {
+    if (!raw || typeof raw !== "object") continue;
+    const b = raw;
+    const type = String(b.type ?? "");
+    if ((type === "input_text" || type === "output_text" || type === "text") && b.text) {
+      out.push({ kind: "text", text: truncate2(String(b.text)) });
+    }
+    if (type === "thinking") {
+      out.push({ kind: "thinking", text: truncate2(String(b.text ?? "")) });
+    }
+  }
+  return out;
+}
+function parseFunctionArguments(args) {
+  if (typeof args !== "string") return JSON.stringify(args ?? {}, null, 2);
+  try {
+    return JSON.stringify(JSON.parse(args), null, 2);
+  } catch {
+    return args;
+  }
+}
+var CodexSessionService = class {
+  async list(paths, projectPath) {
+    const [rollouts, index] = await Promise.all([
+      this.scanRollouts(paths),
+      this.readIndex(paths)
+    ]);
+    const project = normalizeProjectPath(projectPath);
+    return rollouts.filter((r) => normalizeProjectPath(r.cwd) === project).map((r) => {
+      const idx = index.get(r.id);
+      const mtime = idx?.updatedAt ? Date.parse(idx.updatedAt) : r.mtime;
+      return {
+        id: r.id,
+        mtime: Number.isFinite(mtime) ? mtime : r.mtime,
+        size: r.size,
+        firstPrompt: idx?.threadName || r.firstPrompt,
+        messageCount: r.messageCount
+      };
+    }).sort((a, b) => b.mtime - a.mtime);
+  }
+  async read(paths, projectPath, id) {
+    assertSafeId2(id);
+    const project = normalizeProjectPath(projectPath);
+    const found = (await this.scanRollouts(paths)).find(
+      (r) => r.id === id && normalizeProjectPath(r.cwd) === project
+    );
+    if (!found) throw new Error(`\u672A\u627E\u5230\u4F1A\u8BDD\uFF1A${id}`);
+    const parsed = this.parseDetail(await readFile9(found.file, "utf8"));
+    return { messages: parsed.messages, subagents: [], skippedRecords: parsed.skipped };
+  }
+  async scanRollouts(paths) {
+    const files = await this.rolloutFiles(paths.codexSessionsDir);
+    const out = [];
+    for (const file of files) {
+      const info = await this.summarizeRollout(file);
+      if (info) out.push(info);
+    }
+    return out;
+  }
+  async rolloutFiles(dir) {
+    let entries;
+    try {
+      entries = await readdir7(dir, { withFileTypes: true });
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const out = [];
+    for (const entry of entries) {
+      const full = join9(dir, entry.name);
+      if (entry.isDirectory()) {
+        out.push(...await this.rolloutFiles(full));
+      } else if (entry.isFile() && /^rollout-[A-Za-z0-9-]+\.jsonl$/.test(entry.name)) {
+        out.push(full);
+      }
+    }
+    return out;
+  }
+  async summarizeRollout(file) {
+    const st = await stat7(file);
+    const raw = await readFile9(file, "utf8");
+    let id = "";
+    let cwd = "";
+    let firstPrompt = "";
+    let messageCount = 0;
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let obj;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const payload = payloadOf(obj);
+      if (obj.type === "session_meta" || payload.type === "session_meta") {
+        id = String(payload.id ?? id);
+        cwd = String(payload.cwd ?? cwd);
+        continue;
+      }
+      if (payload.type === "message") {
+        const role = String(payload.role ?? "");
+        if (role === "user" || role === "assistant") messageCount++;
+        if (!firstPrompt && role === "user") {
+          firstPrompt = textFromContent(payload.content).replace(/\s+/g, " ").trim();
+        }
+      }
+    }
+    if (!id) {
+      const m = /rollout-([A-Za-z0-9-]+)\.jsonl$/.exec(file);
+      id = m?.[1] ?? "";
+    }
+    if (!id || !cwd) return void 0;
+    return { id, file, cwd, mtime: st.mtimeMs, size: st.size, firstPrompt, messageCount };
+  }
+  async readIndex(paths) {
+    const out = /* @__PURE__ */ new Map();
+    let raw;
+    try {
+      raw = await readFile9(paths.codexSessionIndex, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return out;
+      throw err;
+    }
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        const id = String(obj.id ?? "");
+        if (id) {
+          out.set(id, {
+            threadName: obj.thread_name ? String(obj.thread_name) : void 0,
+            updatedAt: obj.updated_at ? String(obj.updated_at) : void 0
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+    return out;
+  }
+  parseDetail(raw) {
+    const messages = [];
+    let skipped = 0;
+    let currentAssistant;
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let obj;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        skipped++;
+        continue;
+      }
+      const payload = payloadOf(obj);
+      if (payload.type === "message") {
+        const role = String(payload.role ?? "");
+        if (role !== "user" && role !== "assistant") continue;
+        const msg = {
+          type: role,
+          role,
+          timestamp: obj.timestamp ? String(obj.timestamp) : void 0,
+          blocks: blocksFromContent(payload.content)
+        };
+        if (msg.blocks.length === 0) continue;
+        messages.push(msg);
+        currentAssistant = role === "assistant" ? msg : void 0;
+        continue;
+      }
+      if (payload.type === "function_call") {
+        const target = currentAssistant ?? {
+          type: "assistant",
+          role: "assistant",
+          timestamp: obj.timestamp ? String(obj.timestamp) : void 0,
+          blocks: []
+        };
+        if (!currentAssistant) {
+          messages.push(target);
+          currentAssistant = target;
+        }
+        target.blocks.push({
+          kind: "tool_use",
+          name: String(payload.name ?? "tool"),
+          text: truncate2(parseFunctionArguments(payload.arguments)),
+          toolUseId: payload.call_id ? String(payload.call_id) : void 0
+        });
+        continue;
+      }
+      if (payload.type === "function_call_output") {
+        const target = currentAssistant ?? {
+          type: "assistant",
+          role: "assistant",
+          timestamp: obj.timestamp ? String(obj.timestamp) : void 0,
+          blocks: []
+        };
+        if (!currentAssistant) {
+          messages.push(target);
+          currentAssistant = target;
+        }
+        target.blocks.push({
+          kind: "tool_result",
+          text: truncate2(String(payload.output ?? "")),
+          isError: payload.is_error === true,
+          toolUseId: payload.call_id ? String(payload.call_id) : void 0
+        });
+      }
+    }
+    return { messages, skipped };
+  }
+};
+
 // src/core/config-file-service.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
+import { parse as parseToml } from "smol-toml";
 var REGISTRY = {
-  settings: (paths, scope) => scope === "user" ? paths.userSettings : paths.projectSettings,
-  "claude-json": (paths, scope) => scope === "user" ? paths.userClaudeJson : void 0
+  settings: {
+    resolve: (paths, scope) => scope === "user" ? paths.userSettings : paths.projectSettings,
+    kind: "json"
+  },
+  "claude-json": {
+    resolve: (paths, scope) => scope === "user" ? paths.userClaudeJson : void 0,
+    kind: "json"
+  },
+  "codex-config": {
+    resolve: (paths, scope) => scope === "user" ? paths.codexConfigToml : void 0,
+    kind: "toml"
+  },
+  "codex-agents": {
+    resolve: (paths, scope) => scope === "user" ? paths.codexAgentsMd : void 0,
+    kind: "text"
+  }
 };
 var ConfigFileService = class {
   constructor(store) {
     this.store = store;
   }
   store;
-  file(paths, fileId, scope) {
-    const f = REGISTRY[fileId](paths, scope);
+  entry(paths, fileId, scope) {
+    const e = REGISTRY[fileId];
+    const f = e.resolve(paths, scope);
     if (!f) {
       throw new Error(
         scope === "project" ? `\u914D\u7F6E\u6587\u4EF6 ${fileId} \u4E0D\u652F\u6301\u9879\u76EE\u7EA7\u4F5C\u7528\u57DF` : `\u7F3A\u5C11\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\uFF1A${fileId}`
       );
     }
-    return f;
+    return { file: f, kind: e.kind };
   }
-  // 文件不存在视为「尚未创建」，返回空串（与 MemoryService 一致）。
+  // 文件不存在视为「尚未创建」，返回空串与 null mtime（与 MemoryService 一致）。
   async read(paths, fileId, scope) {
+    const { file } = this.entry(paths, fileId, scope);
     try {
-      return { content: await readFile6(this.file(paths, fileId, scope), "utf8") };
+      return { content: await readFile10(file, "utf8"), mtime: await currentMtime(file) };
     } catch (err) {
-      if (err.code === "ENOENT") return { content: "" };
+      if (err.code === "ENOENT")
+        return { content: "", mtime: null };
       throw err;
     }
   }
-  // 校验合法 JSON 后整文件写回；非法内容抛 InvalidJsonError，不触碰磁盘原文件。
-  async write(paths, fileId, scope, content) {
-    const file = this.file(paths, fileId, scope);
-    let parsed;
-    try {
-      parsed = JSON.parse(content);
-    } catch {
-      throw new InvalidJsonError();
+  // 按 kind 校验后写回；非法内容抛 InvalidJsonError，不触碰磁盘原文件。
+  async write(paths, fileId, scope, content, baseMtime) {
+    const { file, kind } = this.entry(paths, fileId, scope);
+    if (kind === "json") {
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch {
+        throw new InvalidJsonError();
+      }
+      await assertNoConflict(file, baseMtime);
+      await this.store.writeJson(file, parsed);
+      return;
+    }
+    if (kind === "toml") {
+      try {
+        parseToml(content);
+      } catch {
+        throw new InvalidJsonError("\u5185\u5BB9\u4E0D\u662F\u5408\u6CD5\u7684 TOML");
+      }
     }
-    await this.store.writeJson(file, parsed);
+    await assertNoConflict(file, baseMtime);
+    await this.store.writeText(file, content);
   }
 };
 
 // src/core/agent-command-service.ts
-import { mkdir as mkdir3, readdir as readdir5, readFile as readFile7, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, join as join5 } from "path";
-import matter4 from "gray-matter";
+import { mkdir as mkdir4, readdir as readdir8, readFile as readFile11, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4, join as join10 } from "path";
+import matter5 from "gray-matter";
 function assertSafeName2(name) {
   if (!name || name.includes("/") || name.includes("\\") || name.includes("..") || name.includes("\0")) {
     throw new Error(`\u975E\u6CD5\u540D\u79F0\uFF1A${name}`);
@@ -959,13 +1777,13 @@ var AgentCommandService = class {
   }
   fileFor(paths, kind, scope, name) {
     assertSafeName2(name);
-    return join5(this.dir(paths, kind, scope), `${name}.md`);
+    return join10(this.dir(paths, kind, scope), `${name}.md`);
   }
   async list(paths, kind, scope) {
     const dir = this.dir(paths, kind, scope);
     let entries;
     try {
-      entries = await readdir5(dir, { withFileTypes: true });
+      entries = await readdir8(dir, { withFileTypes: true });
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
@@ -974,10 +1792,10 @@ var AgentCommandService = class {
     for (const e of entries) {
       if (!e.isFile() || !e.name.endsWith(".md")) continue;
       const name = e.name.slice(0, -3);
-      const path = join5(dir, e.name);
+      const path = join10(dir, e.name);
       let description;
       try {
-        const fm = matter4(await readFile7(path, "utf8")).data;
+        const fm = matter5(await readFile11(path, "utf8")).data;
         description = typeof fm.description === "string" ? fm.description : "";
       } catch {
         description = "(frontmatter \u89E3\u6790\u5931\u8D25)";
@@ -989,15 +1807,16 @@ var AgentCommandService = class {
   async read(paths, kind, scope, name) {
     const file = this.fileFor(paths, kind, scope, name);
     try {
-      return { content: await readFile7(file, "utf8") };
+      return { content: await readFile11(file, "utf8"), mtime: await currentMtime(file) };
     } catch {
       throw new Error(`\u672A\u627E\u5230 ${kind}\u300C${name}\u300D\uFF08scope: ${scope}\uFF09`);
     }
   }
-  async write(paths, kind, scope, name, content) {
+  async write(paths, kind, scope, name, content, baseMtime) {
     const file = this.fileFor(paths, kind, scope, name);
-    await mkdir3(dirname3(file), { recursive: true });
-    await writeFile3(file, content, "utf8");
+    await assertNoConflict(file, baseMtime);
+    await mkdir4(dirname4(file), { recursive: true });
+    await writeFile4(file, content, "utf8");
   }
   async remove(paths, kind, scope, name) {
     const file = this.fileFor(paths, kind, scope, name);
@@ -1005,23 +1824,137 @@ var AgentCommandService = class {
   }
 };
 
+// src/core/sync-service.ts
+import { cp as cp2, lstat, mkdir as mkdir5, readlink as readlink2, rm as rm3, rmdir, stat as stat8, symlink, unlink } from "fs/promises";
+import { dirname as dirname5, join as join11, resolve as resolve7 } from "path";
+var SyncService = class {
+  agentsSkillsDir;
+  targets;
+  constructor(home) {
+    this.agentsSkillsDir = join11(home, ".agents", "skills");
+    this.targets = {
+      claude: join11(home, ".claude", "skills"),
+      codex: join11(home, ".codex", "skills")
+    };
+  }
+  // 删除目录链接本身（不触碰目标）：POSIX 符号链接用 unlink，Windows junction 需 rmdir。
+  async removeLink(p) {
+    try {
+      await unlink(p);
+    } catch {
+      await rmdir(p);
+    }
+  }
+  // 读取 p 处链接的绝对目标；不是链接或读取失败返回 undefined。
+  async linkTargetOf(p) {
+    try {
+      if (!(await lstat(p)).isSymbolicLink()) return void 0;
+    } catch {
+      return void 0;
+    }
+    const raw = await readlink2(p).catch(() => void 0);
+    return raw === void 0 ? void 0 : resolve7(dirname5(p), raw);
+  }
+  async stateFor(targetDir, name) {
+    const p = join11(targetDir, name);
+    try {
+      await lstat(p);
+    } catch {
+      return "none";
+    }
+    const target = await this.linkTargetOf(p);
+    if (target !== void 0 && isSameLink(target, join11(this.agentsSkillsDir, name))) {
+      return "linked";
+    }
+    return "conflict";
+  }
+  async status(name) {
+    assertSafeName(name);
+    return {
+      claude: await this.stateFor(this.targets.claude, name),
+      codex: await this.stateFor(this.targets.codex, name)
+    };
+  }
+  async syncTo(name, target) {
+    assertSafeName(name);
+    const src = join11(this.agentsSkillsDir, name);
+    try {
+      if (!(await stat8(src)).isDirectory()) throw new Error();
+    } catch {
+      throw new Error(`\u672A\u627E\u5230\u516C\u5171 skill\u300C${name}\u300D`);
+    }
+    const dest = join11(this.targets[target], name);
+    try {
+      await lstat(dest);
+      throw new ConflictError(`\u76EE\u6807\u76EE\u5F55\u5DF2\u5B58\u5728\u540C\u540D\u6761\u76EE\u300C${name}\u300D\uFF0C\u8BF7\u5148\u5904\u7406\u51B2\u7A81`);
+    } catch (err) {
+      if (err instanceof ConflictError) throw err;
+    }
+    await mkdir5(this.targets[target], { recursive: true });
+    await symlink(src, dest, "junction");
+  }
+  async unsync(name, target) {
+    assertSafeName(name);
+    const dest = join11(this.targets[target], name);
+    const linkTarget = await this.linkTargetOf(dest);
+    if (linkTarget === void 0 || !isSameLink(linkTarget, join11(this.agentsSkillsDir, name))) {
+      throw new Error(`\u300C${name}\u300D\u4E0D\u662F\u6307\u5411\u516C\u5171\u76EE\u5F55\u7684\u94FE\u63A5\uFF0C\u62D2\u7EDD\u5220\u9664`);
+    }
+    await this.removeLink(dest);
+  }
+  async makeShared(provider, name) {
+    assertSafeName(name);
+    const src = join11(this.targets[provider], name);
+    let st;
+    try {
+      st = await lstat(src);
+    } catch {
+      throw new Error(`\u672A\u627E\u5230 skill\u300C${name}\u300D\uFF08\u987B\u4E3A\u542F\u7528\u72B6\u6001\uFF09`);
+    }
+    if (st.isSymbolicLink()) {
+      const target = await this.linkTargetOf(src);
+      const kind = target === void 0 ? "external" : classifyLinkTarget(target, this.agentsSkillsDir);
+      throw new Error(
+        kind === "shared" ? `\u300C${name}\u300D\u5DF2\u7ECF\u662F\u516C\u5171 skill \u7684\u94FE\u63A5` : `\u300C${name}\u300D\u662F\u6307\u5411\u5916\u90E8\u4F4D\u7F6E\u7684\u94FE\u63A5\uFF0C\u4E0D\u652F\u6301\u8F6C\u516C\u5171`
+      );
+    }
+    const dest = join11(this.agentsSkillsDir, name);
+    try {
+      await lstat(dest);
+      throw new ConflictError(`\u516C\u5171\u76EE\u5F55\u5DF2\u5B58\u5728\u540C\u540D\u6280\u80FD\u300C${name}\u300D`);
+    } catch (err) {
+      if (err instanceof ConflictError) throw err;
+    }
+    await mkdir5(this.agentsSkillsDir, { recursive: true });
+    await cp2(src, dest, { recursive: true });
+    await rm3(src, { recursive: true, force: true });
+    try {
+      await symlink(dest, src, "junction");
+    } catch (err) {
+      await cp2(dest, src, { recursive: true });
+      await rm3(dest, { recursive: true, force: true });
+      throw err;
+    }
+  }
+};
+
 // src/cli.ts
 function findFreePort(start) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve8, reject) => {
     const srv = createServer();
     srv.once("error", (err) => {
-      if (err.code === "EADDRINUSE") resolve3(findFreePort(start + 1));
+      if (err.code === "EADDRINUSE") resolve8(findFreePort(start + 1));
       else reject(err);
     });
     srv.listen(start, () => {
-      srv.close(() => resolve3(start));
+      srv.close(() => resolve8(start));
     });
   });
 }
 async function main() {
   const home = homedir();
   const store = new ConfigStore();
-  const registryFile = join6(home, ".ccpanel", "ccpanel-projects.json");
+  const registryFile = join12(home, ".ccpanel", "ccpanel-projects.json");
   const webRoot = fileURLToPath(new URL("../web/dist", import.meta.url));
   const app = createApp({
     home,
@@ -1033,8 +1966,12 @@ async function main() {
     memoryFiles: new MemoryFilesService(),
     sessions: new SessionService(),
     plugins: new PluginService(store),
+    codexPlugins: new CodexPluginService(store),
+    codexMemory: new CodexMemoryService(),
+    codexSessions: new CodexSessionService(),
     configFiles: new ConfigFileService(store),
     agentCommands: new AgentCommandService(),
+    sync: new SyncService(home),
     registryFile,
     webRoot
   });