ccnew 0.1.10

package/core/desktop-state.js

@@ -0,0 +1,1021 @@
+import fs from "node:fs";
+import path from "node:path";
+import TOML from "@iarna/toml";
+import { SUPPORTED_PLATFORMS } from "./constants.js";
+import {
+  getAgentsSkillsDir,
+  getCodexConfigPath,
+  getCodexDir,
+  getMarchDesktopStatePath,
+  getOpenClawConfigPath,
+  getOpenClawDir,
+  getOpenClawSkillsDir,
+  getOpenCodeAgentsPath,
+  getOpenCodeConfigPath,
+  getOpenCodeDir,
+  getOpenCodeSkillsDir
+} from "./paths.js";
+import {
+  ensureDir,
+  pathExists,
+  readJson,
+  readText,
+  resolveHomePath,
+  slugify,
+  toTildePath,
+  writeJson,
+  writeText
+} from "./utils.js";
+
+const SUPPORTED_APP_TYPES = ["global", ...SUPPORTED_PLATFORMS];
+const PROMPT_MARKER_BEGIN = "<!-- fml-managed:begin -->";
+const PROMPT_MARKER_END = "<!-- fml-managed:end -->";
+
+function now() {
+  return new Date().toISOString();
+}
+
+function normalizeText(value, fallback = "") {
+  const text = `${value ?? ""}`.trim();
+  return text || fallback;
+}
+
+function uniqueStrings(values) {
+  const result = [];
+  const seen = new Set();
+
+  for (const value of values || []) {
+    const text = normalizeText(value);
+    if (!text) {
+      continue;
+    }
+
+    const key = text.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    result.push(text);
+  }
+
+  return result;
+}
+
+function uniquePlatforms(values) {
+  return uniqueStrings(values).filter((item) => SUPPORTED_PLATFORMS.includes(item));
+}
+
+function sanitizeAppType(raw, fallback = "global") {
+  const value = normalizeText(raw, fallback);
+  return SUPPORTED_APP_TYPES.includes(value) ? value : fallback;
+}
+
+function createId(prefix, seed) {
+  return `${prefix}-${slugify(seed || "item")}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function readToml(filePath) {
+  const raw = readText(filePath, "");
+  if (!raw.trim()) {
+    return {};
+  }
+
+  try {
+    return TOML.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function writeToml(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  writeText(filePath, TOML.stringify(value));
+}
+
+function loadDesktopManifest() {
+  const raw = readJson(getMarchDesktopStatePath(), {});
+
+  return {
+    version: 2,
+    mcpServers: Array.isArray(raw?.mcpServers) ? raw.mcpServers : [],
+    prompts: Array.isArray(raw?.prompts) ? raw.prompts : [],
+    skills: Array.isArray(raw?.skills) ? raw.skills : [],
+    skillRepos: Array.isArray(raw?.skillRepos) ? raw.skillRepos : []
+  };
+}
+
+function saveDesktopManifest(manifest) {
+  writeJson(getMarchDesktopStatePath(), {
+    version: 2,
+    mcpServers: manifest.mcpServers,
+    prompts: manifest.prompts,
+    skills: manifest.skills,
+    skillRepos: manifest.skillRepos
+  });
+}
+
+function isManagedPromptContent(content) {
+  return content.includes(PROMPT_MARKER_BEGIN) && content.includes(PROMPT_MARKER_END);
+}
+
+function buildManagedPromptContent(prompts, platformLabel) {
+  const items = prompts.filter((item) => item.enabled);
+  if (items.length === 0) {
+    return "";
+  }
+
+  const body = items
+    .map(
+      (prompt) =>
+        `## ${prompt.name}\n\n${prompt.content.trim()}`
+    )
+    .join("\n\n");
+
+  return `${PROMPT_MARKER_BEGIN}\n# ccon ${platformLabel} prompts\n\n${body}\n${PROMPT_MARKER_END}\n`;
+}
+
+function inferMcpDescription(entry) {
+  if (!entry || typeof entry !== "object") {
+    return "MCP 连接器";
+  }
+
+  if (typeof entry.url === "string" && entry.url.trim()) {
+    return `远程 MCP：${entry.url}`;
+  }
+
+  if (typeof entry.command === "string" && entry.command.trim()) {
+    const args = Array.isArray(entry.args) ? entry.args.join(" ") : "";
+    return `本地 MCP：${[entry.command, args].filter(Boolean).join(" ")}`.trim();
+  }
+
+  if (Array.isArray(entry.command) && entry.command.length > 0) {
+    return `本地 MCP：${entry.command.join(" ")}`;
+  }
+
+  return "MCP 连接器";
+}
+
+function parseKeyValueRecord(input) {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    const nextKey = normalizeText(key);
+    if (!nextKey) {
+      continue;
+    }
+    result[nextKey] = `${value ?? ""}`;
+  }
+  return result;
+}
+
+function parseTextRecord(raw) {
+  const text = `${raw ?? ""}`.trim();
+  if (!text) {
+    return {};
+  }
+
+  const result = {};
+  for (const line of text.split(/\r?\n/)) {
+    const [left, ...rest] = line.split("=");
+    const key = normalizeText(left);
+    if (!key) {
+      continue;
+    }
+    result[key] = rest.join("=").trim();
+  }
+  return result;
+}
+
+function inferMcpTransport(entry) {
+  return typeof entry?.url === "string" && entry.url.trim() ? "http" : "stdio";
+}
+
+function normalizeManifestMcp(entry, fallback = {}) {
+  const id = normalizeText(entry?.id, fallback.id);
+  if (!id) {
+    return null;
+  }
+
+  return {
+    id,
+    name: normalizeText(entry?.name, fallback.name || id),
+    description: normalizeText(entry?.description, fallback.description || "MCP 连接器"),
+    tags: uniqueStrings(entry?.tags || fallback.tags || []),
+    homepage: normalizeText(entry?.homepage || fallback.homepage) || undefined,
+    enabledPlatforms: uniquePlatforms(entry?.enabledPlatforms || fallback.enabledPlatforms || []),
+    bindings: uniquePlatforms(entry?.bindings || fallback.bindings || entry?.enabledPlatforms || fallback.enabledPlatforms || []),
+    transport: entry?.transport === "http" || fallback.transport === "http" ? "http" : "stdio",
+    command: normalizeText(entry?.command, fallback.command),
+    args: uniqueStrings(entry?.args || fallback.args || []),
+    url: normalizeText(entry?.url, fallback.url),
+    cwd: normalizeText(entry?.cwd, fallback.cwd),
+    env: parseKeyValueRecord(entry?.env || fallback.env),
+    headers: parseKeyValueRecord(entry?.headers || fallback.headers),
+    updatedAt: normalizeText(entry?.updatedAt, fallback.updatedAt || now())
+  };
+}
+
+function mergeMcpEntry(target, incoming) {
+  const merged = normalizeManifestMcp(
+    {
+      ...target,
+      ...incoming,
+      tags: uniqueStrings([...(target?.tags || []), ...(incoming?.tags || [])]),
+      enabledPlatforms: uniquePlatforms([...(target?.enabledPlatforms || []), ...(incoming?.enabledPlatforms || [])]),
+      bindings: uniquePlatforms([...(target?.bindings || []), ...(incoming?.bindings || [])])
+    },
+    target
+  );
+
+  return merged;
+}
+
+function buildCodexImportedMcpEntries(config) {
+  const entries = [];
+  const record = config?.mcp_servers && typeof config.mcp_servers === "object" ? config.mcp_servers : {};
+
+  for (const [id, entry] of Object.entries(record)) {
+    entries.push(
+      normalizeManifestMcp({
+        id,
+        name: id,
+        description: inferMcpDescription(entry),
+        homepage: typeof entry?.url === "string" ? entry.url : "",
+        tags: [inferMcpTransport(entry)],
+        enabledPlatforms: entry?.enabled === false ? [] : ["codex"],
+        bindings: ["codex"],
+        transport: inferMcpTransport(entry),
+        command: typeof entry?.command === "string" ? entry.command : "",
+        args: Array.isArray(entry?.args) ? entry.args : [],
+        url: typeof entry?.url === "string" ? entry.url : "",
+        cwd: typeof entry?.cwd === "string" ? entry.cwd : "",
+        env: entry?.env,
+        headers: entry?.http_headers,
+        updatedAt: now()
+      })
+    );
+  }
+
+  return entries.filter(Boolean);
+}
+
+function buildOpenCodeImportedMcpEntries(config) {
+  const entries = [];
+  const record = config?.mcp && typeof config.mcp === "object" ? config.mcp : {};
+
+  for (const [id, entry] of Object.entries(record)) {
+    const isRemote = entry?.type === "remote";
+    const command = Array.isArray(entry?.command) ? entry.command : [];
+    entries.push(
+      normalizeManifestMcp({
+        id,
+        name: id,
+        description: inferMcpDescription(isRemote ? { url: entry?.url } : { command }),
+        homepage: typeof entry?.url === "string" ? entry.url : "",
+        tags: [isRemote ? "http" : "stdio"],
+        enabledPlatforms: entry?.enabled === false ? [] : ["opencode"],
+        bindings: ["opencode"],
+        transport: isRemote ? "http" : "stdio",
+        command: isRemote ? "" : normalizeText(command[0]),
+        args: isRemote ? [] : command.slice(1),
+        url: isRemote ? normalizeText(entry?.url) : "",
+        env: entry?.environment,
+        headers: entry?.headers,
+        updatedAt: now()
+      })
+    );
+  }
+
+  return entries.filter(Boolean);
+}
+
+function mergeMcpServers(manifest, codexConfig, openCodeConfig) {
+  const merged = new Map();
+
+  for (const item of manifest.mcpServers.map((entry) => normalizeManifestMcp(entry)).filter(Boolean)) {
+    merged.set(item.id, item);
+  }
+
+  for (const item of [...buildCodexImportedMcpEntries(codexConfig), ...buildOpenCodeImportedMcpEntries(openCodeConfig)]) {
+    const existing = merged.get(item.id);
+    merged.set(item.id, existing ? mergeMcpEntry(existing, item) : item);
+  }
+
+  return [...merged.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+
+function normalizePromptEntry(entry, fallback = {}) {
+  const id = normalizeText(entry?.id, fallback.id);
+  if (!id) {
+    return null;
+  }
+
+  return {
+    id,
+    appType: sanitizeAppType(entry?.appType, fallback.appType || "global"),
+    name: normalizeText(entry?.name, fallback.name || id),
+    description: normalizeText(entry?.description, fallback.description),
+    content: normalizeText(entry?.content, fallback.content),
+    enabled: typeof entry?.enabled === "boolean" ? entry.enabled : Boolean(fallback.enabled),
+    updatedAt: normalizeText(entry?.updatedAt, fallback.updatedAt || now())
+  };
+}
+
+function importPromptFromSource(id, appType, name, description, content) {
+  const normalized = normalizeText(content);
+  if (!normalized || isManagedPromptContent(normalized)) {
+    return null;
+  }
+
+  return normalizePromptEntry({
+    id,
+    appType,
+    name,
+    description,
+    content: normalized,
+    enabled: true,
+    updatedAt: now()
+  });
+}
+
+function getOpenClawWorkspace(config) {
+  const workspace = normalizeText(config?.agents?.defaults?.workspace);
+  if (workspace) {
+    return resolveHomePath(workspace);
+  }
+
+  return getOpenClawDir();
+}
+
+function loadPromptCatalog(manifest, codexConfig, openCodeConfig, openClawConfig) {
+  const merged = new Map();
+
+  for (const prompt of manifest.prompts.map((entry) => normalizePromptEntry(entry)).filter(Boolean)) {
+    merged.set(prompt.id, prompt);
+  }
+
+  const imported = [
+    importPromptFromSource(
+      "codex-developer-instructions",
+      "codex",
+      "Codex 当前指令",
+      `来自 ${toTildePath(getCodexConfigPath())}`,
+      codexConfig?.developer_instructions || ""
+    ),
+    importPromptFromSource(
+      "opencode-global-agents",
+      "opencode",
+      "OpenCode 全局 AGENTS",
+      `来自 ${toTildePath(getOpenCodeAgentsPath())}`,
+      readText(getOpenCodeAgentsPath(), "")
+    ),
+    importPromptFromSource(
+      "openclaw-workspace-agents",
+      "openclaw",
+      "OpenClaw 工作区 AGENTS",
+      `来自 ${toTildePath(path.join(getOpenClawWorkspace(openClawConfig), "AGENTS.md"))}`,
+      readText(path.join(getOpenClawWorkspace(openClawConfig), "AGENTS.md"), "")
+    )
+  ].filter(Boolean);
+
+  for (const prompt of imported) {
+    if (!merged.has(prompt.id)) {
+      merged.set(prompt.id, prompt);
+    }
+  }
+
+  return [...merged.values()].sort((left, right) => left.updatedAt < right.updatedAt ? 1 : -1);
+}
+
+function getSkillRoots() {
+  return {
+    codex: [path.join(getCodexDir(), "skills"), getAgentsSkillsDir()],
+    opencode: [getOpenCodeSkillsDir(), getAgentsSkillsDir()],
+    openclaw: [getOpenClawSkillsDir(), getAgentsSkillsDir()]
+  };
+}
+
+function listSkillDirectories(rootDir) {
+  if (!pathExists(rootDir)) {
+    return [];
+  }
+
+  const direct = fs
+    .readdirSync(rootDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .flatMap((entry) => {
+      if (entry.name === ".system") {
+        const nestedRoot = path.join(rootDir, entry.name);
+        return fs
+          .readdirSync(nestedRoot, { withFileTypes: true })
+          .filter((nested) => nested.isDirectory())
+          .map((nested) => path.join(nestedRoot, nested.name));
+      }
+
+      return [path.join(rootDir, entry.name)];
+    });
+
+  return direct;
+}
+
+function inferSkillDescription(directory) {
+  const skillFile = path.join(directory, "SKILL.md");
+  if (!pathExists(skillFile)) {
+    return "";
+  }
+
+  const content = readText(skillFile, "");
+  for (const line of content.split(/\r?\n/)) {
+    const text = line.trim();
+    if (!text || text.startsWith("#")) {
+      continue;
+    }
+    return text.replace(/^[-*]\s*/, "");
+  }
+
+  return "";
+}
+
+function normalizeSkillEntry(entry, fallback = {}) {
+  const directory = normalizeText(entry?.directory, fallback.directory);
+  const name = normalizeText(entry?.name, fallback.name || path.basename(directory));
+  const id = normalizeText(entry?.id, fallback.id || slugify(`${name}-${directory}`));
+  if (!id || !directory) {
+    return null;
+  }
+
+  return {
+    id,
+    name,
+    description: normalizeText(entry?.description, fallback.description),
+    directory: toTildePath(resolveHomePath(directory)),
+    enabledPlatforms: uniquePlatforms(entry?.enabledPlatforms || fallback.enabledPlatforms || []),
+    updatedAt: normalizeText(entry?.updatedAt, fallback.updatedAt || now())
+  };
+}
+
+function loadCodexSkillEnabledMap(config) {
+  const entries = Array.isArray(config?.skills?.config) ? config.skills.config : [];
+  const result = {};
+
+  for (const entry of entries) {
+    const skillPath = normalizeText(entry?.path);
+    if (!skillPath) {
+      continue;
+    }
+
+    result[path.resolve(resolveHomePath(skillPath))] = entry?.enabled !== false;
+  }
+
+  return result;
+}
+
+function loadOpenCodeSkillPermissions(config) {
+  return config?.permission?.skill && typeof config.permission.skill === "object" ? config.permission.skill : {};
+}
+
+function loadOpenClawSkillEntries(config) {
+  return config?.skills?.entries && typeof config.skills.entries === "object" ? config.skills.entries : {};
+}
+
+function loadSkillCatalog(manifest, codexConfig, openCodeConfig, openClawConfig) {
+  const merged = new Map();
+  const codexEnabledMap = loadCodexSkillEnabledMap(codexConfig);
+  const opencodePermissions = loadOpenCodeSkillPermissions(openCodeConfig);
+  const openclawEntries = loadOpenClawSkillEntries(openClawConfig);
+  const roots = getSkillRoots();
+
+  for (const skill of manifest.skills.map((entry) => normalizeSkillEntry(entry)).filter(Boolean)) {
+    merged.set(path.resolve(resolveHomePath(skill.directory)), skill);
+  }
+
+  for (const [platform, skillRoots] of Object.entries(roots)) {
+    for (const rootDir of skillRoots) {
+      for (const directory of listSkillDirectories(rootDir)) {
+        const resolved = path.resolve(directory);
+        const existing = merged.get(resolved);
+        const basename = path.basename(directory);
+        const next = normalizeSkillEntry(
+          {
+            id: existing?.id || slugify(`${platform}-${basename}`),
+            name: existing?.name || basename,
+            description: existing?.description || inferSkillDescription(directory),
+            directory: resolved,
+            enabledPlatforms: uniquePlatforms([
+              ...(existing?.enabledPlatforms || []),
+              ...(platform === "codex" && codexEnabledMap[resolved] !== false ? ["codex"] : []),
+              ...(platform === "opencode" && opencodePermissions[basename] !== "deny" ? ["opencode"] : []),
+              ...(platform === "openclaw" && openclawEntries[basename]?.enabled !== false ? ["openclaw"] : [])
+            ])
+          },
+          existing
+        );
+
+        if (next) {
+          merged.set(resolved, next);
+        }
+      }
+    }
+  }
+
+  return [...merged.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+
+function normalizeSkillRepoEntry(entry, fallback = {}) {
+  const id = normalizeText(entry?.id, fallback.id);
+  if (!id) {
+    return null;
+  }
+
+  return {
+    id,
+    owner: normalizeText(entry?.owner, fallback.owner),
+    name: normalizeText(entry?.name, fallback.name),
+    branch: normalizeText(entry?.branch, fallback.branch || "main"),
+    enabled: typeof entry?.enabled === "boolean" ? entry.enabled : Boolean(fallback.enabled)
+  };
+}
+
+function discoverOpenClawRepos() {
+  const repos = [];
+  const rootDir = getOpenClawSkillsDir();
+  if (!pathExists(rootDir)) {
+    return repos;
+  }
+
+  for (const directory of listSkillDirectories(rootDir)) {
+    const originPath = path.join(directory, ".clawhub", "origin.json");
+    if (!pathExists(originPath)) {
+      continue;
+    }
+
+    const origin = readJson(originPath, {});
+    const registryHost = normalizeText(origin.registry).replace(/^https?:\/\//, "");
+    const slug = normalizeText(origin.slug, path.basename(directory));
+    const repo = normalizeSkillRepoEntry({
+      id: `clawhub-${slugify(slug)}`,
+      owner: registryHost || "clawhub.ai",
+      name: slug,
+      branch: normalizeText(origin.installedVersion, "registry"),
+      enabled: true
+    });
+
+    if (repo) {
+      repos.push(repo);
+    }
+  }
+
+  return repos;
+}
+
+function loadSkillRepos(manifest) {
+  const merged = new Map();
+
+  for (const repo of manifest.skillRepos.map((entry) => normalizeSkillRepoEntry(entry)).filter(Boolean)) {
+    merged.set(repo.id, repo);
+  }
+
+  for (const repo of discoverOpenClawRepos()) {
+    if (!merged.has(repo.id)) {
+      merged.set(repo.id, repo);
+    }
+  }
+
+  return [...merged.values()].sort((left, right) => `${left.owner}/${left.name}`.localeCompare(`${right.owner}/${right.name}`));
+}
+
+function mergePromptState(prompts, codexConfig) {
+  const codexPrompts = prompts.filter((prompt) => prompt.enabled && (prompt.appType === "global" || prompt.appType === "codex"));
+  const nextCodexConfig = { ...(codexConfig || {}) };
+  nextCodexConfig.developer_instructions = buildManagedPromptContent(codexPrompts, "Codex");
+  delete nextCodexConfig.model_instructions_file;
+  return nextCodexConfig;
+}
+
+function writePromptFiles(prompts, openClawConfig) {
+  const opencodePrompts = prompts.filter((prompt) => prompt.enabled && (prompt.appType === "global" || prompt.appType === "opencode"));
+  const openclawPrompts = prompts.filter((prompt) => prompt.enabled && (prompt.appType === "global" || prompt.appType === "openclaw"));
+  const opencodeAgents = buildManagedPromptContent(opencodePrompts, "OpenCode");
+  if (opencodeAgents) {
+    ensureDir(getOpenCodeDir());
+    writeText(getOpenCodeAgentsPath(), opencodeAgents);
+  } else if (pathExists(getOpenCodeAgentsPath())) {
+    writeText(getOpenCodeAgentsPath(), "");
+  }
+
+  const workspace = getOpenClawWorkspace(openClawConfig);
+  const workspaceAgentsPath = path.join(workspace, "AGENTS.md");
+  const openclawAgents = buildManagedPromptContent(openclawPrompts, "OpenClaw");
+  if (openclawAgents) {
+    ensureDir(workspace);
+    writeText(workspaceAgentsPath, openclawAgents);
+  } else if (pathExists(workspaceAgentsPath)) {
+    writeText(workspaceAgentsPath, "");
+  }
+}
+
+function buildCodexMcpEntry(server, enabled) {
+  if (server.transport === "http") {
+    const entry = {
+      url: server.url
+    };
+    if (enabled === false) {
+      entry.enabled = false;
+    }
+    if (Object.keys(server.headers).length > 0) {
+      entry.http_headers = server.headers;
+    }
+    return entry;
+  }
+
+  const entry = {
+    command: server.command,
+    args: server.args
+  };
+  if (server.cwd) {
+    entry.cwd = server.cwd;
+  }
+  if (Object.keys(server.env).length > 0) {
+    entry.env = server.env;
+  }
+  if (enabled === false) {
+    entry.enabled = false;
+  }
+  return entry;
+}
+
+function buildOpenCodeMcpEntry(server, enabled) {
+  if (server.transport === "http") {
+    const entry = {
+      type: "remote",
+      url: server.url,
+      enabled
+    };
+    if (Object.keys(server.headers).length > 0) {
+      entry.headers = server.headers;
+    }
+    return entry;
+  }
+
+  const entry = {
+    type: "local",
+    command: [server.command, ...server.args].filter(Boolean),
+    enabled
+  };
+  if (Object.keys(server.env).length > 0) {
+    entry.environment = server.env;
+  }
+  return entry;
+}
+
+function mergeMcpState(mcpServers, codexConfig, openCodeConfig) {
+  const nextCodexConfig = { ...(codexConfig || {}) };
+  nextCodexConfig.mcp_servers = {};
+
+  for (const server of mcpServers.filter((item) => item.bindings.includes("codex"))) {
+    nextCodexConfig.mcp_servers[server.id] = buildCodexMcpEntry(server, server.enabledPlatforms.includes("codex"));
+  }
+
+  const nextOpenCodeConfig = { ...(openCodeConfig || {}) };
+  nextOpenCodeConfig.mcp = {};
+
+  for (const server of mcpServers.filter((item) => item.bindings.includes("opencode"))) {
+    nextOpenCodeConfig.mcp[server.id] = buildOpenCodeMcpEntry(server, server.enabledPlatforms.includes("opencode"));
+  }
+
+  return {
+    codexConfig: nextCodexConfig,
+    openCodeConfig: nextOpenCodeConfig
+  };
+}
+
+function mergeSkillState(skills, codexConfig, openCodeConfig, openClawConfig) {
+  const nextCodexConfig = { ...(codexConfig || {}) };
+  nextCodexConfig.skills = {
+    ...(nextCodexConfig.skills && typeof nextCodexConfig.skills === "object" ? nextCodexConfig.skills : {}),
+    config: skills.map((skill) => ({
+      path: resolveHomePath(skill.directory),
+      enabled: skill.enabledPlatforms.includes("codex")
+    }))
+  };
+
+  const nextOpenCodeConfig = { ...(openCodeConfig || {}) };
+  const existingPermission =
+    nextOpenCodeConfig.permission && typeof nextOpenCodeConfig.permission === "object" ? nextOpenCodeConfig.permission : {};
+  const skillPermission =
+    existingPermission.skill && typeof existingPermission.skill === "object" ? { ...existingPermission.skill } : {};
+
+  for (const skill of skills) {
+    skillPermission[skill.name] = skill.enabledPlatforms.includes("opencode") ? "allow" : "deny";
+  }
+
+  nextOpenCodeConfig.permission = {
+    ...existingPermission,
+    skill: skillPermission
+  };
+
+  const nextOpenClawConfig = { ...(openClawConfig || {}) };
+  const existingSkills =
+    nextOpenClawConfig.skills && typeof nextOpenClawConfig.skills === "object" ? nextOpenClawConfig.skills : {};
+  const entries = existingSkills.entries && typeof existingSkills.entries === "object" ? { ...existingSkills.entries } : {};
+
+  for (const skill of skills) {
+    entries[skill.name] = {
+      ...(entries[skill.name] && typeof entries[skill.name] === "object" ? entries[skill.name] : {}),
+      path: resolveHomePath(skill.directory),
+      enabled: skill.enabledPlatforms.includes("openclaw")
+    };
+  }
+
+  nextOpenClawConfig.skills = {
+    ...existingSkills,
+    entries
+  };
+
+  return {
+    codexConfig: nextCodexConfig,
+    openCodeConfig: nextOpenCodeConfig,
+    openClawConfig: nextOpenClawConfig
+  };
+}
+
+function loadLiveState() {
+  const manifest = loadDesktopManifest();
+  const codexConfig = readToml(getCodexConfigPath());
+  const openCodeConfig = readJson(getOpenCodeConfigPath(), {});
+  const openClawConfig = readJson(getOpenClawConfigPath(), {});
+
+  return {
+    manifest,
+    codexConfig,
+    openCodeConfig,
+    openClawConfig,
+    state: {
+      mcpServers: mergeMcpServers(manifest, codexConfig, openCodeConfig),
+      prompts: loadPromptCatalog(manifest, codexConfig, openCodeConfig, openClawConfig),
+      skills: loadSkillCatalog(manifest, codexConfig, openCodeConfig, openClawConfig),
+      skillRepos: loadSkillRepos(manifest)
+    }
+  };
+}
+
+function persistState(nextState) {
+  const live = loadLiveState();
+  const manifest = {
+    version: 2,
+    mcpServers: nextState.mcpServers,
+    prompts: nextState.prompts,
+    skills: nextState.skills,
+    skillRepos: nextState.skillRepos
+  };
+
+  const afterMcp = mergeMcpState(nextState.mcpServers, live.codexConfig, live.openCodeConfig);
+  const afterPrompts = {
+    codexConfig: mergePromptState(nextState.prompts, afterMcp.codexConfig),
+    openCodeConfig: afterMcp.openCodeConfig
+  };
+  const afterSkills = mergeSkillState(
+    nextState.skills,
+    afterPrompts.codexConfig,
+    afterPrompts.openCodeConfig,
+    live.openClawConfig
+  );
+
+  writeToml(getCodexConfigPath(), afterSkills.codexConfig);
+  ensureDir(getOpenCodeDir());
+  writeJson(getOpenCodeConfigPath(), afterSkills.openCodeConfig);
+  ensureDir(getOpenClawDir());
+  writeJson(getOpenClawConfigPath(), afterSkills.openClawConfig);
+  writePromptFiles(nextState.prompts, afterSkills.openClawConfig);
+  saveDesktopManifest(manifest);
+  return loadLiveState().state;
+}
+
+export function getDesktopState() {
+  return loadLiveState().state;
+}
+
+export function toggleMcpServerForPlatform(serverId, platform) {
+  if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  const live = loadLiveState();
+  const server = live.state.mcpServers.find((item) => item.id === serverId);
+  if (!server) {
+    throw new Error(`MCP server not found: ${serverId}`);
+  }
+
+  server.enabledPlatforms = server.enabledPlatforms.includes(platform)
+    ? server.enabledPlatforms.filter((item) => item !== platform)
+    : uniquePlatforms([...server.enabledPlatforms, platform]);
+  server.bindings = uniquePlatforms([...server.bindings, platform]);
+  server.updatedAt = now();
+
+  return persistState(live.state);
+}
+
+export function upsertMcpServerFromDesktop(input) {
+  const live = loadLiveState();
+  const existing = live.state.mcpServers.find((item) => item.id === normalizeText(input?.id));
+
+  const payload = normalizeManifestMcp(
+    {
+      id: normalizeText(input?.id) || createId("mcp", input?.name || input?.command || input?.url),
+      name: normalizeText(input?.name),
+      description: normalizeText(input?.description),
+      tags: uniqueStrings(input?.tags || []),
+      homepage: normalizeText(input?.homepage),
+      enabledPlatforms: uniquePlatforms(input?.enabledPlatforms || []),
+      bindings: uniquePlatforms(input?.bindings || input?.enabledPlatforms || []),
+      transport: input?.transport === "http" ? "http" : "stdio",
+      command: normalizeText(input?.command),
+      args: uniqueStrings(input?.args || []),
+      url: normalizeText(input?.url),
+      cwd: normalizeText(input?.cwd),
+      env: input?.env || parseTextRecord(input?.envText),
+      headers: input?.headers || parseTextRecord(input?.headersText),
+      updatedAt: now()
+    },
+    existing
+  );
+
+  if (!payload) {
+    throw new Error("MCP 配置不完整");
+  }
+  if (!payload.name) {
+    throw new Error("MCP 名称不能为空");
+  }
+  if (!payload.description) {
+    throw new Error("MCP 描述不能为空");
+  }
+  if (payload.transport === "http" && !payload.url) {
+    throw new Error("HTTP MCP 需要填写 URL");
+  }
+  if (payload.transport === "stdio" && !payload.command) {
+    throw new Error("stdio MCP 需要填写 command");
+  }
+
+  if (payload.bindings.length === 0) {
+    payload.bindings = uniquePlatforms(payload.enabledPlatforms.length > 0 ? payload.enabledPlatforms : ["codex", "opencode"]);
+  }
+
+  const index = live.state.mcpServers.findIndex((item) => item.id === payload.id);
+  if (index >= 0) {
+    live.state.mcpServers[index] = payload;
+  } else {
+    live.state.mcpServers.unshift(payload);
+  }
+
+  return persistState(live.state);
+}
+
+export function deleteMcpServerFromDesktop(serverId) {
+  const live = loadLiveState();
+  const next = live.state.mcpServers.filter((item) => item.id !== normalizeText(serverId));
+  if (next.length === live.state.mcpServers.length) {
+    throw new Error(`MCP server not found: ${serverId}`);
+  }
+
+  live.state.mcpServers = next;
+  return persistState(live.state);
+}
+
+export function togglePromptFromDesktop(promptId) {
+  const live = loadLiveState();
+  const prompt = live.state.prompts.find((item) => item.id === normalizeText(promptId));
+  if (!prompt) {
+    throw new Error(`Prompt not found: ${promptId}`);
+  }
+
+  prompt.enabled = !prompt.enabled;
+  prompt.updatedAt = now();
+  return persistState(live.state);
+}
+
+export function upsertPromptFromDesktop(input) {
+  const live = loadLiveState();
+  const existing = live.state.prompts.find((item) => item.id === normalizeText(input?.id));
+  const payload = normalizePromptEntry(
+    {
+      id: normalizeText(input?.id) || createId("prompt", input?.name),
+      appType: sanitizeAppType(input?.appType, "global"),
+      name: normalizeText(input?.name),
+      description: normalizeText(input?.description),
+      content: normalizeText(input?.content),
+      enabled: typeof input?.enabled === "boolean" ? input.enabled : true,
+      updatedAt: now()
+    },
+    existing
+  );
+
+  if (!payload) {
+    throw new Error("提示词配置不完整");
+  }
+  if (!payload.name) {
+    throw new Error("提示词名称不能为空");
+  }
+  if (!payload.content) {
+    throw new Error("提示词内容不能为空");
+  }
+
+  const index = live.state.prompts.findIndex((item) => item.id === payload.id);
+  if (index >= 0) {
+    live.state.prompts[index] = payload;
+  } else {
+    live.state.prompts.unshift(payload);
+  }
+
+  return persistState(live.state);
+}
+
+export function deletePromptFromDesktop(promptId) {
+  const live = loadLiveState();
+  const next = live.state.prompts.filter((item) => item.id !== normalizeText(promptId));
+  if (next.length === live.state.prompts.length) {
+    throw new Error(`Prompt not found: ${promptId}`);
+  }
+
+  live.state.prompts = next;
+  return persistState(live.state);
+}
+
+export function upsertSkillFromDesktop(input) {
+  const live = loadLiveState();
+  const existing = live.state.skills.find((item) => item.id === normalizeText(input?.id));
+  const payload = normalizeSkillEntry(
+    {
+      id: normalizeText(input?.id) || createId("skill", input?.name || input?.directory),
+      name: normalizeText(input?.name),
+      description: normalizeText(input?.description),
+      directory: normalizeText(input?.directory),
+      enabledPlatforms: uniquePlatforms(input?.enabledPlatforms || []),
+      updatedAt: now()
+    },
+    existing
+  );
+
+  if (!payload) {
+    throw new Error("技能配置不完整");
+  }
+  if (!payload.name) {
+    throw new Error("技能名称不能为空");
+  }
+  if (!payload.directory) {
+    throw new Error("技能目录不能为空");
+  }
+
+  const index = live.state.skills.findIndex((item) => item.id === payload.id);
+  if (index >= 0) {
+    live.state.skills[index] = payload;
+  } else {
+    live.state.skills.unshift(payload);
+  }
+
+  return persistState(live.state);
+}
+
+export function deleteSkillFromDesktop(skillId) {
+  const live = loadLiveState();
+  const next = live.state.skills.filter((item) => item.id !== normalizeText(skillId));
+  if (next.length === live.state.skills.length) {
+    throw new Error(`Skill not found: ${skillId}`);
+  }
+
+  live.state.skills = next;
+  return persistState(live.state);
+}
+
+export function toggleSkillRepoFromDesktop(repoId) {
+  const live = loadLiveState();
+  const repo = live.state.skillRepos.find((item) => item.id === normalizeText(repoId));
+  if (!repo) {
+    throw new Error(`Skill repo not found: ${repoId}`);
+  }
+
+  repo.enabled = !repo.enabled;
+
+  if (repo.id.startsWith("clawhub-")) {
+    const slug = repo.id.slice("clawhub-".length);
+    live.state.skills = live.state.skills.map((skill) => {
+      const skillSlug = slugify(skill.name);
+      if (skillSlug !== slug) {
+        return skill;
+      }
+
+      return {
+        ...skill,
+        enabledPlatforms: repo.enabled
+          ? uniquePlatforms([...skill.enabledPlatforms, "openclaw"])
+          : skill.enabledPlatforms.filter((item) => item !== "openclaw"),
+        updatedAt: now()
+      };
+    });
+  }
+
+  return persistState(live.state);
+}