ccpanel 0.1.0

package/README.md

@@ -0,0 +1,78 @@
+# 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` 下的配置。

package/dist/chunk-7ROXP6AO.js

@@ -0,0 +1,466 @@
+// src/server/app.ts
+import { Hono as Hono10 } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { ZodError } from "zod";
+
+// src/core/config-store.ts
+import { mkdir, readFile, rename, writeFile, copyFile } from "fs/promises";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+var ConfigCorruptError = class extends Error {
+  constructor(file) {
+    super(`\u914D\u7F6E\u6587\u4EF6\u5DF2\u635F\u574F\uFF0C\u65E0\u6CD5\u89E3\u6790\uFF1A${file}`);
+    this.file = file;
+    this.name = "ConfigCorruptError";
+  }
+  file;
+};
+var InvalidJsonError = class extends Error {
+  constructor(message = "\u5185\u5BB9\u4E0D\u662F\u5408\u6CD5\u7684 JSON") {
+    super(message);
+    this.name = "InvalidJsonError";
+  }
+};
+var ConfigStore = class {
+  async readJson(file) {
+    let raw;
+    try {
+      raw = await readFile(file, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return void 0;
+      throw err;
+    }
+    if (raw.trim() === "") return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new ConfigCorruptError(file);
+    }
+  }
+  async writeJson(file, data) {
+    await mkdir(dirname(file), { recursive: true });
+    try {
+      await copyFile(file, file + ".bak");
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+    await rename(tmp, file);
+  }
+};
+
+// src/server/routes/mcp.ts
+import { Hono } from "hono";
+
+// src/core/paths.ts
+import { createHash } from "crypto";
+import { join, resolve } from "path";
+function resolvePaths(opts) {
+  const { home, projectPath } = opts;
+  const panelDir = join(home, ".ccpanel");
+  const paths = {
+    userClaudeJson: join(home, ".claude.json"),
+    userSkillsDir: join(home, ".claude", "skills"),
+    userAgentsDir: join(home, ".claude", "agents"),
+    userCommandsDir: join(home, ".claude", "commands"),
+    userDisabledMcp: join(panelDir, "disabled-mcp.json"),
+    userDisabledSkillsDir: join(panelDir, "disabled-skills"),
+    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
+  };
+  if (projectPath) {
+    paths.projectMcpJson = join(projectPath, ".mcp.json");
+    paths.projectSkillsDir = join(projectPath, ".claude", "skills");
+    paths.projectAgentsDir = join(projectPath, ".claude", "agents");
+    paths.projectCommandsDir = join(projectPath, ".claude", "commands");
+    paths.projectSettings = join(projectPath, ".claude", "settings.json");
+    paths.projectClaudeMd = join(projectPath, "CLAUDE.md");
+    const ns = createHash("sha256").update(resolve(projectPath)).digest("hex");
+    paths.projectDisabledSkillsDir = join(panelDir, "projects", ns, "disabled-skills");
+  }
+  return paths;
+}
+
+// src/shared/schemas.ts
+import { z } from "zod";
+var ScopeSchema = z.enum(["user", "project"]);
+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()
+});
+var RemoteMcpServerSchema = z.object({
+  type: z.enum(["sse", "http"]),
+  url: z.string().url(),
+  headers: z.record(z.string()).optional()
+});
+var McpServerSchema = z.union([
+  RemoteMcpServerSchema,
+  StdioMcpServerSchema
+]);
+var McpServerInputSchema = z.intersection(
+  z.object({ name: z.string().min(1) }),
+  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 ScopeQuerySchema = z.object({
+  scope: ScopeSchema,
+  projectPath: z.string().optional()
+}).refine((v) => v.scope === "user" || !!v.projectPath, {
+  message: "project scope \u9700\u8981 projectPath",
+  path: ["projectPath"]
+});
+
+// src/server/routes/mcp.ts
+function mcpRoutes(deps) {
+  const app = new Hono();
+  const ctx = (c) => {
+    const q = ScopeQuerySchema.parse({
+      scope: c.req.query("scope"),
+      projectPath: c.req.query("projectPath")
+    });
+    return { q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+  };
+  app.get("/", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(await deps.mcp.list(paths, q.scope));
+  });
+  app.post("/", async (c) => {
+    const { q, paths } = ctx(c);
+    const input = McpServerInputSchema.parse(await c.req.json());
+    await deps.mcp.upsert(paths, q.scope, input);
+    return c.json(await deps.mcp.list(paths, q.scope));
+  });
+  app.put("/:name", async (c) => {
+    const { q, paths } = ctx(c);
+    const body = await c.req.json();
+    const input = McpServerInputSchema.parse({ ...body, name: c.req.param("name") });
+    await deps.mcp.upsert(paths, q.scope, input);
+    return c.json(await deps.mcp.list(paths, q.scope));
+  });
+  app.delete("/:name", async (c) => {
+    const { q, paths } = ctx(c);
+    await deps.mcp.remove(paths, q.scope, c.req.param("name"));
+    return c.json(await deps.mcp.list(paths, q.scope));
+  });
+  app.post("/:name/toggle", async (c) => {
+    const { q, paths } = ctx(c);
+    const { enabled } = await c.req.json();
+    await deps.mcp.toggle(paths, q.scope, c.req.param("name"), enabled);
+    return c.json(await deps.mcp.list(paths, q.scope));
+  });
+  return app;
+}
+
+// src/server/routes/skills.ts
+import { Hono as Hono2 } from "hono";
+import { z as z2 } from "zod";
+var SkillBodySchema = z2.object({
+  name: z2.string().min(1),
+  frontmatter: SkillFrontmatterSchema,
+  body: z2.string()
+});
+function skillRoutes(deps) {
+  const app = new Hono2();
+  const ctx = (c) => {
+    const q = ScopeQuerySchema.parse({
+      scope: c.req.query("scope"),
+      projectPath: c.req.query("projectPath")
+    });
+    return { q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+  };
+  app.get("/", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(await deps.skills.list(paths, q.scope));
+  });
+  app.get("/:name", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(await deps.skills.read(paths, q.scope, c.req.param("name")));
+  });
+  app.get("/:name/files", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(await deps.skills.listFiles(paths, q.scope, c.req.param("name")));
+  });
+  app.get("/:name/files/:filePath{.+}", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(
+      await deps.skills.readFileRaw(
+        paths,
+        q.scope,
+        c.req.param("name"),
+        c.req.param("filePath")
+      )
+    );
+  });
+  app.put("/:name/files/:filePath{.+}", async (c) => {
+    const { q, paths } = ctx(c);
+    const { content } = SkillFileWriteSchema.parse(await c.req.json());
+    await deps.skills.writeFileRaw(
+      paths,
+      q.scope,
+      c.req.param("name"),
+      c.req.param("filePath"),
+      content
+    );
+    return c.json({ ok: true });
+  });
+  app.post("/", async (c) => {
+    const { q, paths } = ctx(c);
+    const data = SkillBodySchema.parse(await c.req.json());
+    await deps.skills.upsert(paths, q.scope, data.name, data.frontmatter, data.body);
+    return c.json(await deps.skills.list(paths, q.scope));
+  });
+  app.put("/:name", async (c) => {
+    const { q, paths } = ctx(c);
+    const data = SkillBodySchema.parse({ ...await c.req.json(), name: c.req.param("name") });
+    await deps.skills.upsert(paths, q.scope, data.name, data.frontmatter, data.body);
+    return c.json(await deps.skills.list(paths, q.scope));
+  });
+  app.delete("/:name", async (c) => {
+    const { q, paths } = ctx(c);
+    await deps.skills.remove(paths, q.scope, c.req.param("name"));
+    return c.json(await deps.skills.list(paths, q.scope));
+  });
+  app.post("/:name/toggle", async (c) => {
+    const { q, paths } = ctx(c);
+    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));
+  });
+  return app;
+}
+
+// src/server/routes/projects.ts
+import { Hono as Hono3 } from "hono";
+import { z as z3 } from "zod";
+function projectRoutes(deps) {
+  const app = new Hono3();
+  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());
+    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());
+    return c.json({ projects: await deps.projects.remove(path) });
+  });
+  return app;
+}
+
+// src/server/routes/memory.ts
+import { Hono as Hono4 } from "hono";
+function memoryRoutes(deps) {
+  const app = new Hono4();
+  const ctx = (c) => {
+    const q = ScopeQuerySchema.parse({
+      scope: c.req.query("scope"),
+      projectPath: c.req.query("projectPath")
+    });
+    return { q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+  };
+  app.get("/", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(await deps.memory.read(paths, q.scope));
+  });
+  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);
+    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) });
+function memoryFilesRoutes(deps) {
+  const app = new Hono5();
+  const ctx = (c) => {
+    const { projectPath } = QuerySchema.parse({ projectPath: c.req.query("projectPath") });
+    return { projectPath, paths: resolvePaths({ home: deps.home, projectPath }) };
+  };
+  app.get("/", async (c) => {
+    const { projectPath, paths } = ctx(c);
+    return c.json(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")));
+  });
+  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) });
+function sessionRoutes(deps) {
+  const app = new Hono6();
+  const ctx = (c) => {
+    const { projectPath } = QuerySchema2.parse({ projectPath: c.req.query("projectPath") });
+    return { projectPath, paths: resolvePaths({ home: deps.home, projectPath }) };
+  };
+  app.get("/", async (c) => {
+    const { projectPath, paths } = ctx(c);
+    return c.json(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")));
+  });
+  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)
+});
+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")))
+  );
+  app.get("/:id/component", async (c) => {
+    const q = ComponentQuerySchema.parse({
+      type: c.req.query("type"),
+      name: c.req.query("name")
+    });
+    return c.json(
+      await deps.plugins.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()));
+  });
+  return app;
+}
+
+// src/server/routes/config-files.ts
+import { Hono as Hono8 } from "hono";
+function configFileRoutes(deps) {
+  const app = new Hono8();
+  const ctx = (c) => {
+    const fileId = ConfigFileIdSchema.parse(c.req.param("file"));
+    const q = ScopeQuerySchema.parse({
+      scope: c.req.query("scope"),
+      projectPath: c.req.query("projectPath")
+    });
+    return { fileId, q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+  };
+  app.get("/:file", async (c) => {
+    const { fileId, q, paths } = ctx(c);
+    return c.json(await deps.configFiles.read(paths, fileId, q.scope));
+  });
+  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);
+    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() });
+function agentCommandRoutes(deps, kind) {
+  const app = new Hono9();
+  const ctx = (c) => {
+    const q = ScopeQuerySchema.parse({
+      scope: c.req.query("scope"),
+      projectPath: c.req.query("projectPath")
+    });
+    return { q, paths: resolvePaths({ home: deps.home, projectPath: q.projectPath }) };
+  };
+  app.get("/", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(await deps.agentCommands.list(paths, kind, q.scope));
+  });
+  app.get("/:name", async (c) => {
+    const { q, paths } = ctx(c);
+    return c.json(await deps.agentCommands.read(paths, kind, q.scope, c.req.param("name")));
+  });
+  app.post("/", async (c) => {
+    const { q, paths } = ctx(c);
+    const data = CreateSchema.parse(await c.req.json());
+    await deps.agentCommands.write(paths, kind, q.scope, data.name, data.content);
+    return c.json(await deps.agentCommands.list(paths, kind, q.scope));
+  });
+  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);
+    return c.json({ ok: true });
+  });
+  app.delete("/:name", async (c) => {
+    const { q, paths } = ctx(c);
+    await deps.agentCommands.remove(paths, kind, q.scope, c.req.param("name"));
+    return c.json(await deps.agentCommands.list(paths, kind, q.scope));
+  });
+  return app;
+}
+
+// src/server/app.ts
+function createApp(deps) {
+  const app = new Hono10();
+  app.onError((err, c) => {
+    if (err instanceof ZodError) {
+      return c.json({ error: "\u6821\u9A8C\u5931\u8D25", issues: err.issues }, 400);
+    }
+    if (err instanceof ConfigCorruptError) {
+      return c.json({ error: err.message, file: err.file }, 409);
+    }
+    if (err instanceof InvalidJsonError) {
+      return c.json({ error: err.message }, 400);
+    }
+    return c.json({ error: err.message }, 500);
+  });
+  app.route("/api/mcp", mcpRoutes(deps));
+  app.route("/api/skills", skillRoutes(deps));
+  app.route("/api/projects", projectRoutes(deps));
+  app.route("/api/memory", memoryRoutes(deps));
+  app.route("/api/memory-files", memoryFilesRoutes(deps));
+  app.route("/api/sessions", sessionRoutes(deps));
+  app.route("/api/plugins", pluginRoutes(deps));
+  app.route("/api/config-files", configFileRoutes(deps));
+  app.route("/api/agents", agentCommandRoutes(deps, "agents"));
+  app.route("/api/commands", agentCommandRoutes(deps, "commands"));
+  app.use("/*", serveStatic({ root: deps.webRoot ?? "./web/dist" }));
+  return app;
+}
+
+export {
+  InvalidJsonError,
+  ConfigStore,
+  SkillFrontmatterSchema,
+  createApp
+};