@ryanreh99/skills-sync 1.0.0

package/dist/lib/mcp-config.js

@@ -0,0 +1,264 @@
+import fs from "fs-extra";
+import os from "node:os";
+import path from "node:path";
+import {
+  CODEX_MCP_BLOCK_END,
+  CODEX_MCP_BLOCK_START,
+  MCP_MANAGED_PREFIX,
+  fileSha256
+} from "./core.js";
+
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value ?? ""));
+}
+
+function tomlArray(values) {
+  const list = (Array.isArray(values) ? values : []).map((item) => tomlString(item));
+  return `[${list.join(", ")}]`;
+}
+
+function tomlInlineTable(values) {
+  const entries = values && typeof values === "object" && !Array.isArray(values) ? values : {};
+  const keys = Object.keys(entries).sort((left, right) => left.localeCompare(right));
+  const pairs = keys.map((key) => `${tomlTableKey(key)} = ${tomlString(entries[key])}`);
+  return `{ ${pairs.join(", ")} }`;
+}
+
+function tomlTableKey(value) {
+  return JSON.stringify(String(value ?? ""));
+}
+
+function runtimeHomeDir() {
+  return process.env.USERPROFILE || process.env.HOME || os.homedir();
+}
+
+function expandRuntimeValue(value) {
+  const text = String(value ?? "");
+  const home = runtimeHomeDir();
+  if (text === "~") {
+    return home;
+  }
+  if (text.startsWith("~/") || text.startsWith("~\\")) {
+    return `${home}${text.slice(1)}`;
+  }
+
+  return text
+    .replace(/\$\{HOME\}/g, home)
+    .replace(/\$HOME/g, home)
+    .replace(/%USERPROFILE%/gi, home);
+}
+
+function normalizeRuntimeEnv(rawEnv) {
+  if (!rawEnv || typeof rawEnv !== "object" || Array.isArray(rawEnv)) {
+    return {};
+  }
+  const normalized = {};
+  const keys = Object.keys(rawEnv).sort((left, right) => left.localeCompare(right));
+  for (const key of keys) {
+    if (key.length === 0) {
+      continue;
+    }
+    normalized[key] = expandRuntimeValue(rawEnv[key]);
+  }
+  return normalized;
+}
+
+export function buildManagedServerEntries(canonicalMcp) {
+  const servers = canonicalMcp?.mcpServers ?? {};
+  const names = Object.keys(servers).sort((left, right) => left.localeCompare(right));
+  return names.map((name) => ({
+    rawName: name,
+    managedName: `${MCP_MANAGED_PREFIX}${name}`,
+    server: (() => {
+      const server = servers[name] ?? {};
+      if (typeof server.url === "string" && server.url.trim().length > 0) {
+        return {
+          url: expandRuntimeValue(server.url.trim())
+        };
+      }
+      const normalized = {
+        ...server,
+        args: (Array.isArray(server?.args) ? server.args : []).map((arg) => expandRuntimeValue(arg))
+      };
+      const env = normalizeRuntimeEnv(server.env);
+      if (Object.keys(env).length > 0) {
+        normalized.env = env;
+      } else {
+        delete normalized.env;
+      }
+      return normalized;
+    })()
+  }));
+}
+
+function writeManagedJsonServers(document, canonicalMcp, tool) {
+  if (!document.mcpServers) {
+    document.mcpServers = {};
+  }
+  if (typeof document.mcpServers !== "object" || Array.isArray(document.mcpServers)) {
+    throw new Error("Target MCP document must contain an object 'mcpServers' field.");
+  }
+
+  for (const key of Object.keys(document.mcpServers)) {
+    if (key.startsWith(MCP_MANAGED_PREFIX)) {
+      delete document.mcpServers[key];
+    }
+  }
+
+  for (const entry of buildManagedServerEntries(canonicalMcp)) {
+    if (typeof entry.server.url === "string" && entry.server.url.trim().length > 0) {
+      document.mcpServers[entry.managedName] = {
+        url: entry.server.url
+      };
+      continue;
+    }
+    const base = {
+      command: entry.server.command,
+      args: Array.isArray(entry.server.args) ? entry.server.args : []
+    };
+    if (entry.server.env && Object.keys(entry.server.env).length > 0) {
+      base.env = entry.server.env;
+    }
+    document.mcpServers[entry.managedName] =
+      tool === "gemini"
+        ? base
+        : {
+            transport: "stdio",
+            ...base
+          };
+  }
+}
+
+function renderCodexManagedBlock(canonicalMcp) {
+  const lines = [CODEX_MCP_BLOCK_START];
+  for (const entry of buildManagedServerEntries(canonicalMcp)) {
+    lines.push(`[mcp_servers.${tomlTableKey(entry.managedName)}]`);
+    if (typeof entry.server.url === "string" && entry.server.url.trim().length > 0) {
+      lines.push(`url = ${tomlString(entry.server.url)}`);
+    } else {
+      lines.push('transport = "stdio"');
+      lines.push(`command = ${tomlString(entry.server.command)}`);
+      lines.push(`args = ${tomlArray(entry.server.args)}`);
+      if (entry.server.env && Object.keys(entry.server.env).length > 0) {
+        lines.push(`env = ${tomlInlineTable(entry.server.env)}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(CODEX_MCP_BLOCK_END);
+  return `${lines.join("\n").trimEnd()}\n`;
+}
+
+function stripCodexManagedBlock(content) {
+  const start = escapeForRegExp(CODEX_MCP_BLOCK_START);
+  const end = escapeForRegExp(CODEX_MCP_BLOCK_END);
+  const pattern = new RegExp(`\\n?${start}[\\s\\S]*?${end}\\n?`, "g");
+  return content.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n");
+}
+
+export async function applyManagedMcpConfig({ tool, targetPath, canonicalMcp, dryRun = false }) {
+  if (!dryRun) {
+    await fs.ensureDir(path.dirname(targetPath));
+  }
+  const exists = await fs.pathExists(targetPath);
+  const managedNames = buildManagedServerEntries(canonicalMcp).map((entry) => entry.managedName);
+
+  if (tool === "codex") {
+    let existing = "";
+    if (exists) {
+      existing = await fs.readFile(targetPath, "utf8");
+    }
+    const stripped = stripCodexManagedBlock(existing).trimEnd();
+    const managedBlock = renderCodexManagedBlock(canonicalMcp).trimEnd();
+    const next = `${stripped.length > 0 ? `${stripped}\n\n` : ""}${managedBlock}\n`;
+    const wouldWrite = next !== existing;
+    if (!dryRun) {
+      await fs.writeFile(targetPath, next, "utf8");
+    }
+    return {
+      method: "toml-namespace",
+      hash: dryRun ? null : await fileSha256(targetPath),
+      managedNames,
+      wouldWrite
+    };
+  }
+
+  let document = {};
+  let before = "{}";
+  if (exists) {
+    try {
+      document = await fs.readJson(targetPath);
+      before = JSON.stringify(document);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON config at ${targetPath}: ${error.message}`);
+    }
+  }
+  if (!document || typeof document !== "object" || Array.isArray(document)) {
+    throw new Error(`Target MCP document at ${targetPath} must be a JSON object.`);
+  }
+  writeManagedJsonServers(document, canonicalMcp, tool);
+  const after = JSON.stringify(document);
+  const wouldWrite = !exists || before !== after;
+  if (!dryRun) {
+    await fs.writeFile(targetPath, `${JSON.stringify(document, null, 2)}\n`, "utf8");
+  }
+  return {
+    method: "json-namespace",
+    hash: dryRun ? null : await fileSha256(targetPath),
+    managedNames,
+    wouldWrite
+  };
+}
+
+export async function removeManagedMcpConfig(binding, options = {}) {
+  const { dryRun = false } = options;
+  const { tool, targetPath } = binding;
+  if (!(await fs.pathExists(targetPath))) {
+    return { removed: false };
+  }
+
+  if (tool === "codex") {
+    const existing = await fs.readFile(targetPath, "utf8");
+    const stripped = stripCodexManagedBlock(existing).trimEnd();
+    const next = stripped.length > 0 ? `${stripped}\n` : "";
+    if (next !== existing) {
+      if (!dryRun) {
+        await fs.writeFile(targetPath, next, "utf8");
+      }
+      return { removed: true };
+    }
+    return { removed: false };
+  }
+
+  let document;
+  try {
+    document = await fs.readJson(targetPath);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON config at ${targetPath}: ${error.message}`);
+  }
+
+  if (!document || typeof document !== "object" || Array.isArray(document)) {
+    throw new Error(`Target MCP document at ${targetPath} must be a JSON object.`);
+  }
+  if (!document.mcpServers || typeof document.mcpServers !== "object" || Array.isArray(document.mcpServers)) {
+    return { removed: false };
+  }
+
+  let changed = false;
+  for (const key of Object.keys(document.mcpServers)) {
+    if (key.startsWith(MCP_MANAGED_PREFIX)) {
+      delete document.mcpServers[key];
+      changed = true;
+    }
+  }
+  if (changed) {
+    if (!dryRun) {
+      await fs.writeFile(targetPath, `${JSON.stringify(document, null, 2)}\n`, "utf8");
+    }
+  }
+  return { removed: changed };
+}

package/dist/lib/profile-transfer.js

@@ -0,0 +1,221 @@
+import fs from "fs-extra";
+import path from "node:path";
+import {
+  LOCAL_OVERRIDES_ROOT,
+  SCHEMAS,
+  assertObjectMatchesSchema,
+  logInfo,
+  writeJsonFile
+} from "./core.js";
+import { readDefaultProfile, resolvePack, resolveProfile } from "./config.js";
+
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function normalizeRequiredText(value, label) {
+  const normalized = normalizeOptionalText(value);
+  if (!normalized) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+
+function normalizeRelativePath(rawPath, label) {
+  const normalized = String(rawPath ?? "")
+    .replace(/\\/g, "/")
+    .replace(/^\/+/, "")
+    .trim();
+  if (normalized.length === 0) {
+    throw new Error(`${label} cannot be empty.`);
+  }
+  const segments = normalized.split("/");
+  for (const segment of segments) {
+    if (segment.length === 0 || segment === "." || segment === "..") {
+      throw new Error(`Invalid relative path '${rawPath}' for ${label}.`);
+    }
+  }
+  return segments.join("/");
+}
+
+async function readJsonIfExists(filePath, fallbackValue) {
+  if (!(await fs.pathExists(filePath))) {
+    return fallbackValue;
+  }
+  return fs.readJson(filePath);
+}
+
+async function collectSkillFiles(rootPath) {
+  if (!(await fs.pathExists(rootPath))) {
+    return [];
+  }
+
+  const files = [];
+  async function walk(currentPath) {
+    const entries = await fs.readdir(currentPath, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const absolutePath = path.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const relativePath = path.relative(rootPath, absolutePath).split(path.sep).join("/");
+      const content = await fs.readFile(absolutePath);
+      files.push({
+        path: relativePath,
+        contentBase64: content.toString("base64")
+      });
+    }
+  }
+
+  await walk(rootPath);
+  return files;
+}
+
+export async function cmdProfileExport({ profile, output } = {}) {
+  const explicitProfile = normalizeOptionalText(profile);
+  const resolvedProfile = explicitProfile ?? (await readDefaultProfile());
+  if (!resolvedProfile) {
+    throw new Error(
+      "Profile is required. Provide profile name or set a default with 'skills-sync use <name>'."
+    );
+  }
+
+  const { profile: profileDoc } = await resolveProfile(resolvedProfile);
+  const packRoot = await resolvePack(profileDoc);
+  const packManifestPath = path.join(packRoot, "pack.json");
+  const sourcesPath = path.join(packRoot, "sources.json");
+  const mcpPath = path.join(packRoot, "mcp", "servers.json");
+  const skillsRoot = path.join(packRoot, "skills");
+
+  const packManifest = await readJsonIfExists(packManifestPath, {
+    name: resolvedProfile,
+    version: "0.0.0",
+    description: "",
+    maintainer: "",
+    tags: []
+  });
+  const sources = await readJsonIfExists(sourcesPath, { imports: [] });
+  const mcpServers = await readJsonIfExists(mcpPath, { servers: {} });
+
+  await assertObjectMatchesSchema(packManifest, SCHEMAS.packManifest, packManifestPath);
+  await assertObjectMatchesSchema(sources, SCHEMAS.packSources, sourcesPath);
+  await assertObjectMatchesSchema(mcpServers, SCHEMAS.mcpServers, mcpPath);
+
+  const skillFiles = await collectSkillFiles(skillsRoot);
+
+  const payload = {
+    schemaVersion: 1,
+    exportedAt: new Date().toISOString(),
+    profile: {
+      name: resolvedProfile,
+      pack: {
+        manifest: packManifest,
+        sources,
+        mcpServers,
+        skillFiles
+      }
+    }
+  };
+
+  const outputPath = normalizeOptionalText(output);
+  if (outputPath) {
+    await writeJsonFile(path.resolve(outputPath), payload);
+    logInfo(`Exported profile '${resolvedProfile}'.`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function decodeSkillFileContent(contentBase64, filePath) {
+  if (typeof contentBase64 !== "string") {
+    throw new Error(`Skill file '${filePath}' is missing base64 content.`);
+  }
+  try {
+    return Buffer.from(contentBase64, "base64");
+  } catch (error) {
+    throw new Error(`Failed to decode skill file '${filePath}': ${error.message}`);
+  }
+}
+
+async function writeSkillFiles(skillsRoot, skillFiles) {
+  for (const file of skillFiles) {
+    const relativePath = normalizeRelativePath(file.path, "skill file path");
+    const targetPath = path.join(skillsRoot, relativePath.split("/").join(path.sep));
+    await fs.ensureDir(path.dirname(targetPath));
+    await fs.writeFile(targetPath, decodeSkillFileContent(file.contentBase64, relativePath));
+  }
+}
+
+export async function cmdProfileImport({ profile, input, replace = false } = {}) {
+  const profileName = normalizeRequiredText(profile, "Profile name");
+  const inputPath = path.resolve(normalizeRequiredText(input, "Input path"));
+  if (!(await fs.pathExists(inputPath))) {
+    throw new Error("Input file not found.");
+  }
+
+  let payload;
+  try {
+    payload = await fs.readJson(inputPath);
+  } catch (error) {
+    throw new Error(`Failed to parse import file: ${error.message}`);
+  }
+
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("Import payload must be a JSON object.");
+  }
+  if (payload.schemaVersion !== 1) {
+    throw new Error(`Unsupported import schemaVersion '${payload.schemaVersion}'.`);
+  }
+
+  const packDoc = payload.profile?.pack;
+  if (!packDoc || typeof packDoc !== "object" || Array.isArray(packDoc)) {
+    throw new Error("Import payload is missing profile.pack.");
+  }
+
+  const manifest = packDoc.manifest ?? {};
+  const sources = packDoc.sources ?? { imports: [] };
+  const mcpServers = packDoc.mcpServers ?? { servers: {} };
+  const skillFiles = Array.isArray(packDoc.skillFiles) ? packDoc.skillFiles : [];
+
+  await assertObjectMatchesSchema(manifest, SCHEMAS.packManifest, "import.pack.manifest");
+  await assertObjectMatchesSchema(sources, SCHEMAS.packSources, "import.pack.sources");
+  await assertObjectMatchesSchema(mcpServers, SCHEMAS.mcpServers, "import.pack.mcpServers");
+
+  const profilePath = path.join(LOCAL_OVERRIDES_ROOT, "profiles", `${profileName}.json`);
+  const packRoot = path.join(LOCAL_OVERRIDES_ROOT, "packs", profileName);
+  const packManifestPath = path.join(packRoot, "pack.json");
+  const sourcesPath = path.join(packRoot, "sources.json");
+  const mcpPath = path.join(packRoot, "mcp", "servers.json");
+  const skillsRoot = path.join(packRoot, "skills");
+
+  if (!replace && (await fs.pathExists(profilePath))) {
+    throw new Error(`Profile '${profileName}' already exists. Use --replace to overwrite local files.`);
+  }
+
+  await fs.ensureDir(path.dirname(profilePath));
+  await fs.ensureDir(path.dirname(mcpPath));
+  await writeJsonFile(profilePath, {
+    name: profileName,
+    packPath: `workspace/packs/${profileName}`
+  });
+  await writeJsonFile(packManifestPath, manifest);
+  await writeJsonFile(sourcesPath, sources);
+  await writeJsonFile(mcpPath, mcpServers);
+
+  if (replace) {
+    await fs.remove(skillsRoot);
+  }
+  await fs.ensureDir(skillsRoot);
+  await writeSkillFiles(skillsRoot, skillFiles);
+
+  logInfo(`Imported profile '${profileName}'.`);
+}