toolcapsule 0.1.0-alpha.11 → 0.1.0-alpha.13

package/dist/cli.js

@@ -1,137 +1,25 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile5 } from "fs/promises";
 import { cac } from "cac";
-import pc from "picocolors";
+import pc2 from "picocolors";
 
-// src/mcp/client.ts
-import { spawn } from "child_process";
-import { once } from "events";
-import { resolve } from "path";
-var McpClient = class {
-  child;
-  nextId = 1;
-  buffer = "";
-  pending = /* @__PURE__ */ new Map();
-  timeoutMs;
-  debug;
-  clientVersion;
-  constructor(profile, opts = {}) {
-    this.timeoutMs = opts.timeoutMs ?? Number(process.env.TOOLCAPSULE_TIMEOUT_MS || "45000");
-    this.debug = opts.debug ?? process.env.TOOLCAPSULE_DEBUG === "1";
-    this.clientVersion = opts.clientVersion ?? "0.0.0";
-    if (profile.transport.type === "remote") {
-      this.child = spawn("npx", ["-y", "mcp-remote", profile.transport.url, ...headersToArgs(profile.transport.headers)], {
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env, ...profile.transport.env }
-      });
-    } else {
-      this.child = spawn(profile.transport.command, profile.transport.args ?? [], {
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env, ...profile.transport.env },
-        cwd: profile.transport.cwd ? resolve(profile.transport.cwd) : void 0
-      });
-    }
-    this.child.stdout.setEncoding("utf8");
-    this.child.stdout.on("data", (chunk) => this.onStdout(chunk));
-    this.child.stderr.on("data", (chunk) => this.onStderr(chunk));
-    this.child.on("exit", (code, signal) => {
-      const error = new Error(`MCP process exited early (code=${code}, signal=${signal})`);
-      for (const waiter of this.pending.values()) waiter.reject(error);
-      this.pending.clear();
-    });
-  }
-  onStderr(chunk) {
-    if (!this.debug) return;
-    process.stderr.write(redactSecrets(chunk.toString("utf8")));
-  }
-  onStdout(chunk) {
-    this.buffer += chunk;
-    let newlineIndex;
-    while ((newlineIndex = this.buffer.indexOf("\n")) >= 0) {
-      const line = this.buffer.slice(0, newlineIndex).trim();
-      this.buffer = this.buffer.slice(newlineIndex + 1);
-      if (!line) continue;
-      let message;
-      try {
-        message = JSON.parse(line);
-      } catch {
-        process.stderr.write(`${line}
-`);
-        continue;
-      }
-      if (typeof message.id === "number") {
-        const waiter = this.pending.get(message.id);
-        if (waiter) {
-          this.pending.delete(message.id);
-          waiter.resolve(message);
-        }
-      }
-    }
-  }
-  async init() {
-    await this.request("initialize", {
-      protocolVersion: "2025-03-26",
-      capabilities: {},
-      clientInfo: { name: "toolcapsule", version: this.clientVersion }
-    });
-    this.notify("notifications/initialized", {});
-  }
-  async request(method, params) {
-    const id = this.nextId++;
-    const responsePromise = new Promise((resolve3, reject) => {
-      this.pending.set(id, { resolve: resolve3, reject });
-    });
-    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
-`);
-    const response = await this.withTimeout(responsePromise, method);
-    if (response.error) throw new Error(`${method} failed: ${JSON.stringify(response.error, null, 2)}`);
-    return response.result;
-  }
-  notify(method, params) {
-    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
-`);
-  }
-  async listTools() {
-    return await this.request("tools/list", {});
-  }
-  async callTool(name, args) {
-    return await this.request("tools/call", { name, arguments: args });
-  }
-  async close() {
-    if (!this.child.killed) this.child.kill();
-    if (this.child.exitCode === null) await Promise.race([once(this.child, "exit"), new Promise((resolve3) => setTimeout(resolve3, 500))]);
-  }
-  async withTimeout(promise, label) {
-    let timer;
-    const timeout = new Promise((_, reject) => {
-      timer = setTimeout(() => reject(new Error(`${label} timed out after ${this.timeoutMs}ms`)), this.timeoutMs);
-    });
-    try {
-      return await Promise.race([promise, timeout]);
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-};
-function headersToArgs(headers) {
-  if (!headers) return [];
-  return Object.entries(headers).flatMap(([key, value]) => ["--header", `${key}:${value}`]);
-}
-function redactSecrets(text) {
-  return text.replace(/https:\/\/mcp\.feishu\.cn\/mcp\/[^\s"']+/g, "https://mcp.feishu.cn/mcp/[redacted]").replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]").replace(/(token=)[^\s&"']+/gi, "$1[redacted]").replace(/(api[_-]?key=)[^\s&"']+/gi, "$1[redacted]");
-}
+// src/mcp/inventory.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2, readdir, rename, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { basename, dirname as dirname2, join as join3 } from "path";
+import pc from "picocolors";
 
 // src/mcp/importer.ts
 import { existsSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { isAbsolute, join, resolve as resolve2 } from "path";
 
 // src/utils/fs.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { dirname, resolve as resolve2 } from "path";
+import { dirname, resolve } from "path";
 async function readJson(path) {
   return JSON.parse(await readFile(path, "utf8"));
 }
@@ -160,15 +48,26 @@ async function ensureToolCapsuleIgnored() {
 // src/mcp/importer.ts
 var workspaceSources = [
   { tool: "vscode", path: join(".vscode", "mcp.json") },
+  { tool: "generic", path: "mcp.json" },
   { tool: "claude", path: ".mcp.json" },
   { tool: "opencode", path: "opencode.json" },
   { tool: "gemini", path: join(".gemini", "settings.json") },
   { tool: "cursor", path: join(".cursor", "mcp.json") }
 ];
 var userSources = [
+  { tool: "vscode", path: join(homedir(), ".config", "Code", "User", "mcp.json"), userLevel: true },
+  { tool: "vscode", path: join(homedir(), ".config", "Code - Insiders", "User", "mcp.json"), userLevel: true },
+  { tool: "vscode", path: join(homedir(), ".vscode-server", "data", "User", "mcp.json"), userLevel: true },
+  { tool: "vscode", path: join(homedir(), ".vscode-server-insiders", "data", "User", "mcp.json"), userLevel: true },
   { tool: "claude", path: join(homedir(), ".claude.json"), userLevel: true },
   { tool: "opencode", path: join(homedir(), ".config", "opencode", "opencode.json"), userLevel: true },
-  { tool: "gemini", path: join(homedir(), ".gemini", "settings.json"), userLevel: true }
+  { tool: "gemini", path: join(homedir(), ".gemini", "settings.json"), userLevel: true },
+  { tool: "cursor", path: join(homedir(), ".cursor", "mcp.json"), userLevel: true },
+  { tool: "cursor", path: join(homedir(), ".config", "Cursor", "User", "mcp.json"), userLevel: true },
+  { tool: "cursor", path: join(homedir(), ".config", "Cursor", "User", "settings.json"), userLevel: true }
+];
+var managedSources = [
+  { tool: "claude", path: "/etc/claude-code/managed-mcp.json", managed: true }
 ];
 function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -218,6 +117,7 @@ function mapServer(name, source, raw) {
   const profileName = cleanName(name);
   return {
     name: profileName,
+    originalName: name,
     source,
     warnings,
     profile: {
@@ -226,6 +126,25 @@ function mapServer(name, source, raw) {
     }
   };
 }
+function linkedProfileForImportedServer(server, name = server.name) {
+  return {
+    name,
+    kind: "linked",
+    source: {
+      ...server.source,
+      path: isAbsolute(server.source.path) ? server.source.path : resolve2(server.source.path),
+      server: server.originalName
+    }
+  };
+}
+async function resolveProfileSource(source) {
+  if (!existsSync(source.path)) return void 0;
+  const config = asRecord(await readJson(source.path));
+  if (!config) return void 0;
+  const entry = serverEntries(source, config).find(([name]) => name === source.server);
+  if (!entry) return void 0;
+  return mapServer(entry[0], source, entry[1])?.profile;
+}
 function serverEntries(source, config) {
   if (source.tool === "vscode" || source.tool === "cursor") return Object.entries(asRecord(config.servers) ?? {});
   if (source.tool === "opencode") return Object.entries(asRecord(config.mcp) ?? {});
@@ -239,7 +158,11 @@ function serverEntries(source, config) {
   return Object.entries(asRecord(config.mcpServers) ?? {});
 }
 async function discoverMcpServers(opts = {}) {
-  const sources = opts.includeUser ? [...workspaceSources, ...userSources] : workspaceSources;
+  const sources = [
+    ...workspaceSources,
+    ...opts.includeUser ? userSources : [],
+    ...opts.includeManaged ? managedSources : []
+  ];
   const discovered = [];
   for (const source of sources) {
     if (!existsSync(source.path)) continue;
@@ -259,49 +182,345 @@ function selectImportedServers(servers, name, all) {
   return servers.filter((server) => server.name === normalized || server.name === name);
 }
 
-// src/profile.ts
-import { existsSync as existsSync2 } from "fs";
+// src/paths.ts
+import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
+function toolCapsuleHome() {
+  return process.env.TOOLCAPSULE_HOME || join2(homedir2(), ".toolcapsule");
+}
+function userProfilePath(profileName) {
+  return join2(toolCapsuleHome(), "profiles", `${profileName}.json`);
+}
+function workspaceProfilePath(profileName) {
+  return join2(".toolcapsule", "profiles", `${profileName}.json`);
+}
+function workspaceRunBaseDir(profileName) {
+  return join2(".toolcapsule", "runs", profileName);
+}
+
+// src/mcp/inventory.ts
+function sourceScope(server) {
+  if (server.source.managed) return "managed";
+  return server.source.userLevel ? "user" : "workspace";
+}
+function sourceStatus(server) {
+  return server.source.managed ? "managed" : "enabled";
+}
+async function profileItems(dir, scope) {
+  if (!existsSync2(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  const items = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const path = join3(dir, entry.name);
+    try {
+      const profile = await readJson(path);
+      items.push({
+        name: profile.name || basename(entry.name, ".json"),
+        status: "enabled",
+        scope,
+        source: "toolcapsule",
+        mode: profile.kind === "linked" ? "linked" : "snapshot",
+        path
+      });
+    } catch {
+      items.push({ name: basename(entry.name, ".json"), status: "error", scope, source: "toolcapsule", mode: "snapshot", path });
+    }
+  }
+  return items;
+}
+async function listMcpInventory(opts = {}) {
+  const nativeServers = await discoverMcpServers(opts.includeUser ? { includeUser: true, includeManaged: true } : {});
+  const nativeItems = nativeServers.map((server) => ({
+    name: server.name,
+    originalName: server.originalName,
+    status: sourceStatus(server),
+    scope: sourceScope(server),
+    source: server.source.tool,
+    mode: "native",
+    path: server.source.path,
+    warnings: server.warnings
+  }));
+  const workspaceProfiles = await profileItems(join3(".toolcapsule", "profiles"), "workspace");
+  const userProfiles = await profileItems(join3(toolCapsuleHome(), "profiles"), "user");
+  return [...nativeItems, ...workspaceProfiles, ...userProfiles];
+}
+function colorStatus(status) {
+  if (status === "enabled") return pc.green("\u25CF on");
+  if (status === "disabled") return pc.gray("\u25CB off");
+  if (status === "managed") return pc.yellow("\u25C6 managed");
+  return pc.red("\xD7 error");
+}
+function colorMode(mode) {
+  if (mode === "linked") return pc.cyan(mode);
+  if (mode === "snapshot") return pc.magenta(mode);
+  return pc.gray(mode);
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function padDisplay(display, raw, width) {
+  return raw.length >= width ? display : `${display}${" ".repeat(width - raw.length)}`;
+}
+function formatInventory(items) {
+  if (items.length === 0) return "No MCP servers found.";
+  const rows = items.map((item) => ({
+    status: colorStatus(item.status),
+    statusRaw: item.status === "enabled" ? "\u25CF on" : item.status === "disabled" ? "\u25CB off" : item.status === "managed" ? "\u25C6 managed" : "\xD7 error",
+    name: item.originalName && item.originalName !== item.name ? `${item.name} (${item.originalName})` : item.name,
+    scope: item.scope,
+    source: item.source,
+    mode: colorMode(item.mode),
+    modeRaw: item.mode,
+    path: item.path.replace(`${homedir3()}/`, "~/")
+  }));
+  const widths = {
+    status: Math.max("STATUS".length, ...rows.map((row) => row.statusRaw.length)),
+    name: Math.max("NAME".length, ...rows.map((row) => row.name.length)),
+    scope: Math.max("SCOPE".length, ...rows.map((row) => row.scope.length)),
+    source: Math.max("SOURCE".length, ...rows.map((row) => row.source.length)),
+    mode: Math.max("MODE".length, ...rows.map((row) => row.modeRaw.length))
+  };
+  const lines = [
+    `${pad("STATUS", widths.status)}  ${pad("NAME", widths.name)}  ${pad("SCOPE", widths.scope)}  ${pad("SOURCE", widths.source)}  ${pad("MODE", widths.mode)}  PATH`,
+    ...rows.map(
+      (row) => `${padDisplay(row.status, row.statusRaw, widths.status)}  ${pad(row.name, widths.name)}  ${pad(row.scope, widths.scope)}  ${pad(row.source, widths.source)}  ${padDisplay(row.mode, row.modeRaw, widths.mode)}  ${row.path}`
+    )
+  ];
+  return lines.join("\n");
+}
+function disableKeys(tool) {
+  if (tool === "vscode" || tool === "cursor") return { fromKey: "servers", toKey: "disabledServers" };
+  if (tool === "opencode") return { fromKey: "mcp", toKey: "disabledMcp" };
+  return { fromKey: "mcpServers", toKey: "disabledMcpServers" };
+}
+async function disableNativeMcp(serverName, opts = {}) {
+  const servers = await discoverMcpServers(opts.includeUser ? { includeUser: true } : {});
+  const server = servers.find((item) => item.name === serverName || item.originalName === serverName);
+  if (!server) throw new Error(`Native MCP server not found: ${serverName}`);
+  if (server.source.managed) throw new Error(`Cannot modify managed MCP config: ${server.source.path}`);
+  const keys = disableKeys(server.source.tool);
+  const plan = { path: server.source.path, tool: server.source.tool, server: server.originalName, ...keys };
+  const message = `Disable native MCP ${plan.server} in ${plan.path}: move ${plan.fromKey}.${plan.server} -> ${plan.toKey}.${plan.server}`;
+  if (opts.dryRun !== false) return `${message}
+Dry run only. Re-run with --yes to write changes.`;
+  const config = await readJson(plan.path);
+  const source = config[plan.fromKey] && typeof config[plan.fromKey] === "object" && !Array.isArray(config[plan.fromKey]) ? config[plan.fromKey] : {};
+  if (!(plan.server in source)) throw new Error(`Server ${plan.server} not found under ${plan.fromKey} in ${plan.path}`);
+  const disabled = config[plan.toKey] && typeof config[plan.toKey] === "object" && !Array.isArray(config[plan.toKey]) ? config[plan.toKey] : {};
+  disabled[plan.server] = source[plan.server];
+  delete source[plan.server];
+  config[plan.fromKey] = source;
+  config[plan.toKey] = disabled;
+  const backup = `${plan.path}.toolcapsule.bak`;
+  await mkdir2(dirname2(backup), { recursive: true }).catch(() => void 0);
+  if (existsSync2(plan.path)) await writeFile2(backup, await readFile2(plan.path, "utf8"));
+  await writeJson(plan.path, config);
+  return `${message}
+Backup: ${backup}`;
+}
+async function disableToolCapsuleProfile(profileName) {
+  const candidates = [workspaceProfilePath(profileName), join3(toolCapsuleHome(), "profiles", `${profileName}.json`)];
+  const found = candidates.find((path) => existsSync2(path));
+  if (!found) throw new Error(`ToolCapsule profile not found: ${profileName}`);
+  const disabledPath = `${found}.disabled`;
+  await rename(found, disabledPath);
+  return `Disabled ToolCapsule profile ${profileName}: ${found} -> ${disabledPath}`;
+}
+
+// src/mcp/client.ts
+import { spawn } from "child_process";
+import { once } from "events";
+import { resolve as resolve3 } from "path";
+var McpClient = class {
+  child;
+  nextId = 1;
+  buffer = "";
+  pending = /* @__PURE__ */ new Map();
+  timeoutMs;
+  debug;
+  clientVersion;
+  constructor(profile, opts = {}) {
+    this.timeoutMs = opts.timeoutMs ?? Number(process.env.TOOLCAPSULE_TIMEOUT_MS || "45000");
+    this.debug = opts.debug ?? process.env.TOOLCAPSULE_DEBUG === "1";
+    this.clientVersion = opts.clientVersion ?? "0.0.0";
+    if (profile.transport.type === "remote") {
+      this.child = spawn("npx", ["-y", "mcp-remote", profile.transport.url, ...headersToArgs(profile.transport.headers)], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...profile.transport.env }
+      });
+    } else {
+      this.child = spawn(profile.transport.command, profile.transport.args ?? [], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...profile.transport.env },
+        cwd: profile.transport.cwd ? resolve3(profile.transport.cwd) : void 0
+      });
+    }
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => this.onStdout(chunk));
+    this.child.stderr.on("data", (chunk) => this.onStderr(chunk));
+    this.child.on("exit", (code, signal) => {
+      const error = new Error(`MCP process exited early (code=${code}, signal=${signal})`);
+      for (const waiter of this.pending.values()) waiter.reject(error);
+      this.pending.clear();
+    });
+  }
+  onStderr(chunk) {
+    if (!this.debug) return;
+    process.stderr.write(redactSecrets(chunk.toString("utf8")));
+  }
+  onStdout(chunk) {
+    this.buffer += chunk;
+    let newlineIndex;
+    while ((newlineIndex = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, newlineIndex).trim();
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        process.stderr.write(`${line}
+`);
+        continue;
+      }
+      if (typeof message.id === "number") {
+        const waiter = this.pending.get(message.id);
+        if (waiter) {
+          this.pending.delete(message.id);
+          waiter.resolve(message);
+        }
+      }
+    }
+  }
+  async init() {
+    await this.request("initialize", {
+      protocolVersion: "2025-03-26",
+      capabilities: {},
+      clientInfo: { name: "toolcapsule", version: this.clientVersion }
+    });
+    this.notify("notifications/initialized", {});
+  }
+  async request(method, params) {
+    const id = this.nextId++;
+    const responsePromise = new Promise((resolve4, reject) => {
+      this.pending.set(id, { resolve: resolve4, reject });
+    });
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+    const response = await this.withTimeout(responsePromise, method);
+    if (response.error) throw new Error(`${method} failed: ${JSON.stringify(response.error, null, 2)}`);
+    return response.result;
+  }
+  notify(method, params) {
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
+`);
+  }
+  async listTools() {
+    return await this.request("tools/list", {});
+  }
+  async callTool(name, args) {
+    return await this.request("tools/call", { name, arguments: args });
+  }
+  async close() {
+    if (!this.child.killed) this.child.kill();
+    if (this.child.exitCode === null) await Promise.race([once(this.child, "exit"), new Promise((resolve4) => setTimeout(resolve4, 500))]);
+  }
+  async withTimeout(promise, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timed out after ${this.timeoutMs}ms`)), this.timeoutMs);
+    });
+    try {
+      return await Promise.race([promise, timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+};
+function headersToArgs(headers) {
+  if (!headers) return [];
+  return Object.entries(headers).flatMap(([key, value]) => ["--header", `${key}:${value}`]);
+}
+function redactSecrets(text) {
+  return text.replace(/https:\/\/mcp\.feishu\.cn\/mcp\/[^\s"']+/g, "https://mcp.feishu.cn/mcp/[redacted]").replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]").replace(/(token=)[^\s&"']+/gi, "$1[redacted]").replace(/(api[_-]?key=)[^\s&"']+/gi, "$1[redacted]");
+}
+
+// src/profile.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 import { z } from "zod";
-var profileSchema = z.object({
+var transportSchema = z.union([
+  z.object({
+    type: z.literal("remote"),
+    url: z.string().url(),
+    headers: z.record(z.string()).optional(),
+    env: z.record(z.string()).optional()
+  }),
+  z.object({
+    type: z.literal("stdio"),
+    command: z.string().min(1),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string()).optional(),
+    cwd: z.string().optional()
+  })
+]);
+var skillSchema = z.object({
+  name: z.string().optional(),
+  description: z.string().optional()
+}).optional();
+var shortcutsSchema = z.record(
+  z.object({
+    tool: z.string(),
+    description: z.string().optional(),
+    args: z.record(z.enum(["string", "file", "json", "boolean", "number"])).optional()
+  })
+).optional();
+var snapshotProfileSchema = z.object({
   name: z.string().min(1),
-  transport: z.union([
-    z.object({
-      type: z.literal("remote"),
-      url: z.string().url(),
-      headers: z.record(z.string()).optional(),
-      env: z.record(z.string()).optional()
-    }),
-    z.object({
-      type: z.literal("stdio"),
-      command: z.string().min(1),
-      args: z.array(z.string()).optional(),
-      env: z.record(z.string()).optional(),
-      cwd: z.string().optional()
-    })
-  ]),
-  skill: z.object({
-    name: z.string().optional(),
-    description: z.string().optional()
-  }).optional(),
-  shortcuts: z.record(
-    z.object({
-      tool: z.string(),
-      description: z.string().optional(),
-      args: z.record(z.enum(["string", "file", "json", "boolean", "number"])).optional()
-    })
-  ).optional()
+  kind: z.literal("snapshot").optional(),
+  transport: transportSchema,
+  skill: skillSchema,
+  shortcuts: shortcutsSchema
 });
+var linkedProfileSchema = z.object({
+  name: z.string().min(1),
+  kind: z.literal("linked"),
+  source: z.object({
+    tool: z.enum(["vscode", "claude", "opencode", "gemini", "cursor", "generic"]),
+    path: z.string().min(1),
+    server: z.string().min(1),
+    userLevel: z.boolean().optional()
+  }),
+  skill: skillSchema,
+  shortcuts: shortcutsSchema
+});
+var profileSchema = z.union([snapshotProfileSchema, linkedProfileSchema]);
 async function loadProfile(profilePathOrName) {
   const candidates = [
     profilePathOrName,
     `${profilePathOrName}.json`,
-    join2(".toolcapsule", "profiles", `${profilePathOrName}.json`),
-    join2(".github", "skills", `${profilePathOrName}-mcp`, "toolcapsule.config.json")
+    workspaceProfilePath(profilePathOrName),
+    userProfilePath(profilePathOrName),
+    join4(".github", "skills", `${profilePathOrName}-mcp`, "toolcapsule.config.json"),
+    join4(".claude", "skills", `${profilePathOrName}-mcp`, "toolcapsule.config.json"),
+    join4(".opencode", "skills", `${profilePathOrName}-mcp`, "toolcapsule.config.json"),
+    join4(".agents", "skills", `${profilePathOrName}-mcp`, "toolcapsule.config.json")
   ];
-  const found = candidates.find((path) => existsSync2(path));
+  const found = candidates.find((path) => existsSync3(path));
   if (!found) throw new Error(`Profile not found: ${profilePathOrName}`);
-  return profileSchema.parse(await readJson(found));
+  const profile = profileSchema.parse(await readJson(found));
+  if (profile.kind !== "linked") return profile;
+  const resolved = await resolveProfileSource(profile.source);
+  if (!resolved) {
+    throw new Error(`Linked profile source not found: ${profile.source.path}#${profile.source.server}`);
+  }
+  return snapshotProfileSchema.parse({
+    ...resolved,
+    name: profile.name,
+    skill: profile.skill ?? resolved.skill,
+    shortcuts: profile.shortcuts ?? resolved.shortcuts
+  });
 }
 
 // src/schema/brief.ts
@@ -345,15 +564,15 @@ function summarizeTools(tools) {
 }
 
 // src/skill/generator.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join3 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join5 } from "path";
 import Handlebars from "handlebars";
 var defaultSkillTarget = "claude";
 function skillOutputDir(skillName, target) {
-  if (target === "copilot") return join3(".github", "skills", skillName);
-  if (target === "claude") return join3(".claude", "skills", skillName);
-  if (target === "opencode") return join3(".opencode", "skills", skillName);
-  return join3(".agents", "skills", skillName);
+  if (target === "copilot") return join5(".github", "skills", skillName);
+  if (target === "claude") return join5(".claude", "skills", skillName);
+  if (target === "opencode") return join5(".opencode", "skills", skillName);
+  return join5(".agents", "skills", skillName);
 }
 function expandSkillTargets(target) {
   return target === "all" ? ["copilot", "claude", "opencode", "agents"] : [target];
@@ -384,6 +603,18 @@ toolcapsule call {{profileName}} <tool> @args.json
 toolcapsule retry .toolcapsule/runs/{{profileName}}/<run-id>
 \`\`\`
 
+{{#if toolsMarkdown}}
+## Tool summary
+
+Use this summary for planning. Only run \`toolcapsule schema {{profileName}} <tool>\` when these brief details are insufficient.
+
+{{{toolsMarkdown}}}
+{{else}}
+## Tool discovery
+
+Run \`toolcapsule tools {{profileName}} --brief\` once before choosing a tool. Then run \`toolcapsule schema {{profileName}} <tool>\` only when the brief summary is insufficient.
+{{/if}}
+
 ## Workflow
 
 1. Use \`tools --brief\` to find the likely tool.
@@ -399,24 +630,48 @@ toolcapsule retry .toolcapsule/runs/{{profileName}}/<run-id>
 - Do not print secrets.
 - Review destructive tools before calling.
 `;
-async function generateSkillAt(profile, outputDir) {
+function toolsMarkdown(tools) {
+  if (!tools || tools.length === 0) return void 0;
+  const summaries = summarizeTools(tools);
+  const rows = summaries.slice(0, 40).map((tool) => {
+    const required = Array.isArray(tool.required) && tool.required.length > 0 ? tool.required.join(", ") : "-";
+    const risk = tool.annotations?.destructiveHint ? "writes" : tool.annotations?.readOnlyHint ? "read" : "unknown";
+    const description = (tool.description || "-").replace(/\|/g, "\\|").slice(0, 120);
+    return `| \`${tool.name || "unknown"}\` | ${description} | ${required} | ${risk} |`;
+  });
+  return ["| Tool | Purpose | Required args | Risk |", "|---|---|---|---|", ...rows].join("\n");
+}
+async function fetchProfileTools(profile, opts = {}) {
+  if (profile.kind === "linked") return void 0;
+  const client = new McpClient(profile, { ...opts.clientVersion ? { clientVersion: opts.clientVersion } : {}, timeoutMs: 15e3 });
+  try {
+    await client.init();
+    return (await client.listTools()).tools;
+  } catch {
+    return void 0;
+  } finally {
+    await client.close().catch(() => void 0);
+  }
+}
+async function generateSkillAt(profile, outputDir, opts = {}) {
   const skillName = profile.skill?.name || `${profile.name}-mcp`;
-  await mkdir2(join3(outputDir, "scripts"), { recursive: true });
+  await mkdir3(join5(outputDir, "scripts"), { recursive: true });
   const template = Handlebars.compile(skillTemplate);
   const description = profile.skill?.description || `Use when operating tools from the ${profile.name} MCP server. Lazy-load schemas, call tools through local files, and retry failed calls by patching artifacts.`;
   const markdown = template({
     skillName,
     profileName: profile.name,
     title: `${profile.name} MCP Skill`,
-    description: description.replace(/'/g, "''")
+    description: description.replace(/'/g, "''"),
+    toolsMarkdown: toolsMarkdown(opts.tools)
   });
-  await writeFile2(join3(outputDir, "SKILL.md"), markdown);
-  await writeJson(join3(outputDir, "toolcapsule.config.json"), profile);
-  await writeFile2(
-    join3(outputDir, "scripts", "README.md"),
+  await writeFile3(join5(outputDir, "SKILL.md"), markdown);
+  if (opts.embedProfile) await writeJson(join5(outputDir, "toolcapsule.config.json"), profile);
+  await writeFile3(
+    join5(outputDir, "scripts", "README.md"),
     `# Scripts
 
-This skill uses the project-level \`toolcapsule\` CLI.
+This skill uses the \`toolcapsule\` CLI and profiles resolved by name.
 `
   );
   return outputDir;
@@ -424,122 +679,63 @@ This skill uses the project-level \`toolcapsule\` CLI.
 async function generateSkill(profile, opts = {}) {
   const skillName = profile.skill?.name || `${profile.name}-mcp`;
   const target = opts.target || defaultSkillTarget;
-  const outputs = opts.outputDir ? [await generateSkillAt(profile, opts.outputDir)] : await Promise.all(expandSkillTargets(target).map((item) => generateSkillAt(profile, skillOutputDir(skillName, item))));
+  const embedProfile = opts.embedProfile === true;
+  const atOptions = { embedProfile, ...opts.tools ? { tools: opts.tools } : {} };
+  const outputs = opts.outputDir ? [await generateSkillAt(profile, opts.outputDir, atOptions)] : await Promise.all(
+    expandSkillTargets(target).map(
+      (item) => generateSkillAt(profile, skillOutputDir(skillName, item), atOptions)
+    )
+  );
   return outputs.join(", ");
 }
 async function writeProfile(path, profile) {
-  await mkdir2(dirname2(path), { recursive: true });
+  await mkdir3(dirname3(path), { recursive: true });
   await writeJson(path, profile);
 }
 
 // src/skill/installer.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import { join as join4 } from "path";
-var agentSkill = `---
-name: toolcapsule
-description: 'Use when: converting MCP servers into lightweight Agent Skills, installing ToolCapsule, lazy-loading MCP schemas, calling MCP tools through local args files, or using patch-and-retry workflows for heavy MCP tools.'
-argument-hint: 'MCP server URL/command, tool name, args file, or retry task'
----
-
-# ToolCapsule Agent Skill
-
-Use ToolCapsule when an agent needs to work with heavy MCP servers without carrying every tool schema in the prompt.
-
-## Install
-
-If \`toolcapsule\` or \`tcap\` is missing:
-
-\`\`\`bash
-npm install -g toolcapsule
-\`\`\`
-
-## Core workflow
-
-1. Initialize a profile and generated Skill:
-
-\`\`\`bash
-tcap init <name> --url <remote-mcp-url>
-# or
-tcap init <name> --command <stdio-command> --arg <arg>
-\`\`\`
-
-2. Discover tools briefly:
-
-\`\`\`bash
-tcap tools <name> --brief
-\`\`\`
-
-3. Inspect one tool only when needed:
-
-\`\`\`bash
-tcap schema <name> <tool>
-\`\`\`
-
-4. Put complex arguments in a local JSON file.
-
-5. Call the MCP tool through the local args file:
-
-\`\`\`bash
-tcap call <name> <tool> @args.json --save-run
-\`\`\`
-
-6. If the call fails, patch the local file and retry:
-
-\`\`\`bash
-tcap retry .toolcapsule/runs/<name>/<run-id>
-\`\`\`
-
-## Safety
-
-- Do not print or commit private MCP URLs, tokens, API keys, user IDs, or document IDs.
-- Keep generated profiles and run artifacts local unless reviewed.
-- Use \`TOOLCAPSULE_DEBUG=1\` only when debugging; normal transport logs are quiet by default.
-- Prefer \`--brief\` and \`schema\` before reading full MCP schemas.
-
-## When to use
-
-Use ToolCapsule for MCP servers with:
-
-- many tools;
-- long schemas;
-- large Markdown/JSON payloads;
-- document, ticket, wiki, dashboard, or batch workflows;
-- failures that benefit from patching local artifacts instead of regenerating a full tool call.
-`;
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import { join as join6 } from "path";
 async function installAgentSkill(outputDir, target = defaultSkillTarget) {
+  let agentSkill;
+  try {
+    agentSkill = await readFile3(new URL("../skills/toolcapsule/SKILL.md", import.meta.url), "utf8");
+  } catch {
+    agentSkill = await readFile3(new URL("../../skills/toolcapsule/SKILL.md", import.meta.url), "utf8");
+  }
   const outputDirs = outputDir ? [outputDir] : expandSkillTargets(target).map((item) => skillOutputDir("toolcapsule", item));
   await Promise.all(
     outputDirs.map(async (dir) => {
-      await mkdir3(dir, { recursive: true });
-      await writeFile3(join4(dir, "SKILL.md"), agentSkill);
+      await mkdir4(dir, { recursive: true });
+      await writeFile4(join6(dir, "SKILL.md"), agentSkill);
     })
   );
   return outputDirs.join(", ");
 }
 
 // src/runs/recorder.ts
-import { mkdir as mkdir4, readFile as readFile2, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import { join as join7 } from "path";
 function createRunId() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 async function saveRun(baseDir, record) {
-  const dir = join5(baseDir, record.id);
-  await mkdir4(dir, { recursive: true });
-  await writeJson(join5(dir, "run.json"), record);
-  await writeJson(join5(dir, "request.json"), record.request);
-  if (record.response !== void 0) await writeJson(join5(dir, "response.json"), record.response);
-  if (record.error) await writeFile4(join5(dir, "error.txt"), record.error);
-  await writeFile4(join5(dir, "command.txt"), `${record.command}
+  const dir = join7(baseDir, record.id);
+  await mkdir5(dir, { recursive: true });
+  await writeJson(join7(dir, "run.json"), record);
+  await writeJson(join7(dir, "request.json"), record.request);
+  if (record.response !== void 0) await writeJson(join7(dir, "response.json"), record.response);
+  if (record.error) await writeFile5(join7(dir, "error.txt"), record.error);
+  await writeFile5(join7(dir, "command.txt"), `${record.command}
 `);
   return dir;
 }
 async function loadRun(runDir) {
-  return JSON.parse(await readFile2(join5(runDir, "run.json"), "utf8"));
+  return JSON.parse(await readFile4(join7(runDir, "run.json"), "utf8"));
 }
 
 // src/cli.ts
-import { writeFile as writeFile5 } from "fs/promises";
+import { writeFile as writeFile6 } from "fs/promises";
 
 // src/utils/tokens.ts
 function roughTokens(value) {
@@ -554,7 +750,7 @@ function percentReduction(before, after) {
 var cli = cac("toolcapsule");
 async function readPackageVersion() {
   try {
-    const pkg = JSON.parse(await readFile3(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(await readFile5(new URL("../package.json", import.meta.url), "utf8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -578,23 +774,47 @@ function readSkillTarget(raw) {
   if (["copilot", "claude", "opencode", "agents", "all"].includes(target)) return target;
   throw new Error("Invalid --target. Use one of: copilot, claude, opencode, agents, all");
 }
-function runBaseDir(profileName) {
-  return join6(".toolcapsule", "runs", profileName);
-}
-cli.command("init <name>", "Create a profile and generated Agent Skill for an MCP server").option("--url <url>", "Remote MCP URL").option("--command <command>", "stdio MCP command").option("--arg <arg>", "stdio MCP argument, repeatable", { type: [String] }).option("--output <dir>", "Skill output directory").option("--target <target>", "Skill target: copilot, claude, opencode, agents, all", { default: defaultSkillTarget }).action(async (name, options) => {
+function renameSnapshotProfile(profile, name) {
+  return { ...profile, name };
+}
+async function writeImportedServer(server, opts) {
+  const profileName = opts.as || server.name;
+  const local = opts.local === true;
+  const copy = opts.copy === true;
+  const profilePath = local ? workspaceProfilePath(profileName) : userProfilePath(profileName);
+  if (local) await ensureToolCapsuleIgnored();
+  const profile = copy ? renameSnapshotProfile(server.profile, profileName) : linkedProfileForImportedServer(server, profileName);
+  await writeProfile(profilePath, profile);
+  const tools = await fetchProfileTools(renameSnapshotProfile(server.profile, profileName), { clientVersion: packageVersion });
+  const skillOptions = { target: readSkillTarget(opts.target), embedProfile: local, ...tools ? { tools } : {} };
+  const out = await generateSkill(profile, skillOptions);
+  const mode = copy ? "snapshot" : "linked";
+  console.log(pc2.green(`Imported ${server.name} as ${profileName} from ${server.source.path} -> ${profilePath} (${mode}), ${out}`));
+  for (const warning of server.warnings) console.log(pc2.yellow(`  warning: ${warning}`));
+}
+cli.command("init <name>", "Create a profile and generated Agent Skill for an MCP server").option("--url <url>", "Remote MCP URL").option("--command <command>", "stdio MCP command").option("--arg <arg>", "stdio MCP argument, repeatable", { type: [String] }).option("--output <dir>", "Skill output directory").option("--target <target>", "Skill target: copilot, claude, opencode, agents, all", { default: defaultSkillTarget }).option("--local", "Store the MCP profile in this workspace instead of ~/.toolcapsule").action(async (name, options) => {
   if (!options.url && !options.command) throw new Error("Provide --url for remote MCP or --command for stdio MCP");
+  const local = options.local === true;
   const profile = options.url ? { name, transport: { type: "remote", url: options.url } } : { name, transport: { type: "stdio", command: options.command, args: options.arg ?? [] } };
-  await ensureToolCapsuleIgnored();
-  await writeProfile(join6(".toolcapsule", "profiles", `${name}.json`), profile);
-  const out = await generateSkill(profile, options.output ? { outputDir: options.output } : { target: readSkillTarget(options.target) });
-  console.log(pc.green(`Created profile and skill at ${out}`));
+  const profilePath = local ? workspaceProfilePath(name) : userProfilePath(name);
+  if (local) await ensureToolCapsuleIgnored();
+  await writeProfile(profilePath, profile);
+  const tools = await fetchProfileTools(profile, { clientVersion: packageVersion });
+  const skillOptions = options.output ? { outputDir: options.output, embedProfile: local, ...tools ? { tools } : {} } : { target: readSkillTarget(options.target), embedProfile: local, ...tools ? { tools } : {} };
+  const out = await generateSkill(
+    profile,
+    skillOptions
+  );
+  console.log(pc2.green(`Created profile at ${profilePath} and skill at ${out}`));
 });
 cli.command("install-skill", "Install the generic ToolCapsule Agent Skill into this workspace").option("--output <dir>", "Skill output directory").option("--target <target>", "Skill target: copilot, claude, opencode, agents, all", { default: defaultSkillTarget }).action(async (options) => {
   const out = await installAgentSkill(options.output, readSkillTarget(options.target));
-  console.log(pc.green(`Installed ToolCapsule Agent Skill at ${out}`));
+  console.log(pc2.green(`Installed ToolCapsule Agent Skill at ${out}`));
 });
-cli.command("import", "Import existing MCP configuration into ToolCapsule profiles and skills").option("--include-user", "Also inspect user-level MCP config files").option("--name <name>", "Import only one MCP server by name").option("--all", "Import all discovered MCP servers").option("--target <target>", "Skill target: copilot, claude, opencode, agents, all", { default: defaultSkillTarget }).option("--dry-run", "List importable MCP servers without writing files").action(
+cli.command("import", "Import existing MCP configuration into ToolCapsule profiles and skills").option("--include-user", "Also inspect user-level MCP config files").option("--name <name>", "Import only one MCP server by name").option("--as <name>", "Store the imported server under a different ToolCapsule profile name").option("--all", "Import all discovered MCP servers").option("--target <target>", "Skill target: copilot, claude, opencode, agents, all", { default: defaultSkillTarget }).option("--local", "Store imported MCP profiles in this workspace instead of ~/.toolcapsule").option("--copy", "Copy MCP transport details into a ToolCapsule snapshot instead of linking the source config").option("--dry-run", "List importable MCP servers without writing files").action(
   async (options) => {
+    const local = options.local === true;
+    const copy = options.copy === true;
     const discovered = await discoverMcpServers(options.includeUser ? { includeUser: true } : {});
     if (discovered.length === 0) {
       console.log("No importable MCP servers found.");
@@ -603,7 +823,7 @@ cli.command("import", "Import existing MCP configuration into ToolCapsule profil
     if (options.dryRun) {
       for (const server of discovered) {
         console.log(`${server.name}	${server.source.tool}	${server.source.path}`);
-        for (const warning of server.warnings) console.log(pc.yellow(`  warning: ${warning}`));
+        for (const warning of server.warnings) console.log(pc2.yellow(`  warning: ${warning}`));
       }
       return;
     }
@@ -612,14 +832,32 @@ cli.command("import", "Import existing MCP configuration into ToolCapsule profil
       throw new Error("Multiple MCP servers found. Re-run with --dry-run, then pass --name <server> or --all.");
     }
     for (const server of selected) {
-      await ensureToolCapsuleIgnored();
-      await writeProfile(join6(".toolcapsule", "profiles", `${server.profile.name}.json`), server.profile);
-      const out = await generateSkill(server.profile, { target: readSkillTarget(options.target) });
-      console.log(pc.green(`Imported ${server.name} from ${server.source.path} -> ${out}`));
-      for (const warning of server.warnings) console.log(pc.yellow(`  warning: ${warning}`));
+      await writeImportedServer(server, { as: options.as, local, copy, target: options.target });
     }
   }
 );
+cli.command("mcp <action> [name]", "List, enable, or disable MCP servers").option("--include-user", "Also inspect user-level MCP config files").option("--json", "Print JSON output for list").option("--as <name>", "Store an enabled server under a different ToolCapsule profile name").option("--target <target>", "Skill target: copilot, claude, opencode, agents, all", { default: defaultSkillTarget }).option("--local", "Store ToolCapsule profile in this workspace").option("--copy", "Copy MCP transport details into a ToolCapsule snapshot instead of linking source config").option("--native", "For disable: disable the native MCP config instead of the ToolCapsule profile").option("--yes", "Apply native disable changes; otherwise native disable is dry-run").action(async (action, name, options) => {
+  if (action === "list") {
+    const items = await listMcpInventory(options.includeUser ? { includeUser: true } : {});
+    console.log(options.json ? JSON.stringify(items, null, 2) : formatInventory(items));
+    return;
+  }
+  if (action === "enable") {
+    if (!name) throw new Error("Usage: tcap mcp enable <server> [--as <profile>]");
+    const discovered = await discoverMcpServers(options.includeUser ? { includeUser: true } : {});
+    const selected = selectImportedServers(discovered, name, false);
+    if (selected.length !== 1) throw new Error(`Expected one MCP server named ${name}; run tcap mcp list --include-user first.`);
+    await writeImportedServer(selected[0], { as: options.as, local: options.local, copy: options.copy, target: options.target });
+    return;
+  }
+  if (action === "disable") {
+    if (!name) throw new Error("Usage: tcap mcp disable <profile|server>");
+    const message = options.native ? await disableNativeMcp(name, { ...options.includeUser ? { includeUser: true } : {}, dryRun: options.yes !== true }) : await disableToolCapsuleProfile(name);
+    console.log(message);
+    return;
+  }
+  throw new Error("Unknown mcp action. Use: list, enable, disable");
+});
 cli.command("tools <profile>", "List MCP tools").option("--brief", "Print compact tool summaries").option("--names", "Print tool names only").option("--json", "Print raw JSON").action(async (profileName, options) => {
   const profile = await loadProfile(profileName);
   const result = await withClient(profile, (client) => client.listTools());
@@ -653,7 +891,7 @@ cli.command("call <profile> <tool> <args>", "Call an MCP tool with JSON args or
     console.log(JSON.stringify(response, null, 2));
     if (options.saveRun) {
       await ensureToolCapsuleIgnored();
-      const dir = await saveRun(runBaseDir(profile.name), {
+      const dir = await saveRun(workspaceRunBaseDir(profile.name), {
         id: runId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         profile: profile.name,
@@ -664,12 +902,12 @@ cli.command("call <profile> <tool> <args>", "Call an MCP tool with JSON args or
         request,
         response
       });
-      console.error(pc.green(`Saved run: ${dir}`));
+      console.error(pc2.green(`Saved run: ${dir}`));
     }
   } catch (error) {
     if (options.saveRun) {
       await ensureToolCapsuleIgnored();
-      const dir = await saveRun(runBaseDir(profile.name), {
+      const dir = await saveRun(workspaceRunBaseDir(profile.name), {
         id: runId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         profile: profile.name,
@@ -680,7 +918,7 @@ cli.command("call <profile> <tool> <args>", "Call an MCP tool with JSON args or
         request,
         error: error instanceof Error ? error.message : String(error)
       });
-      console.error(pc.yellow(`Saved failed run: ${dir}`));
+      console.error(pc2.yellow(`Saved failed run: ${dir}`));
     }
     throw error;
   }
@@ -721,18 +959,18 @@ cli.command("benchmark <profile>", "Estimate schema savings for a profile").opti
 
 > Rough tokens are estimated from serialized schema length. Use this report to compare schema footprint before and after capsule summaries.
 ` : JSON.stringify(summary, null, 2);
-  if (options.out) await writeFile5(options.out, output);
+  if (options.out) await writeFile6(options.out, output);
   console.log(output);
 });
 cli.command("render-readme", "Print website hero copy snippets").action(async () => {
-  console.log(await readFile3(new URL("../docs/hero-copy.md", import.meta.url), "utf8"));
+  console.log(await readFile5(new URL("../docs/hero-copy.md", import.meta.url), "utf8"));
 });
 cli.help();
 cli.version(packageVersion);
 try {
   cli.parse();
 } catch (error) {
-  console.error(pc.red(error instanceof Error ? error.message : String(error)));
+  console.error(pc2.red(error instanceof Error ? error.message : String(error)));
   process.exit(1);
 }
 //# sourceMappingURL=cli.js.map