toolcapsule 0.1.0-alpha.1 → 0.1.0-alpha.10

package/README.md

@@ -5,14 +5,17 @@
 [![License: MIT](https://img.shields.io/badge/license-MIT-black?style=flat-square)](LICENSE)
 [![GitHub Repo stars](https://img.shields.io/github/stars/RainSunMe/toolcapsule?style=flat-square)](https://github.com/RainSunMe/toolcapsule)
 
-> Heavy MCP tools don't belong in your prompt. Put them in a ToolCapsule.
+> MCP-to-Skill for heavy MCP tools.
 
-**ToolCapsule** turns heavy MCP servers into lightweight, lazy-loaded, file-first **Agent Skills** with patch-and-retry workflows.
+**ToolCapsule** turns heavy MCP servers into lightweight, lazy-loaded, file-first **Agent Skills** with saved runs and patch-and-retry recovery.
+
+If you are looking for **lazy MCP**, **MCP to Skill**, **MCP-to-Skill**, or **Agent Skills for MCP tools**, ToolCapsule is built for that workflow.
 
 It is not a replacement for MCP or Skills. It is the missing workflow layer between them:
 
 ```text
 Heavy MCP server
+→ MCP-to-Skill workflow layer
 → compact Agent Skill
 → local args/content files
 → auditable tool runs
@@ -31,6 +34,36 @@ But large MCP servers can be expensive in agent contexts:
 - failed tool calls force the model to regenerate the whole call.
 
 ToolCapsule keeps the MCP server as the source of truth, but exposes it through a lightweight Skill and local artifacts.
+Transport logs are quiet by default so remote MCP URLs are not printed during normal use. Set `TOOLCAPSULE_DEBUG=1` only when debugging.
+
+## MCP-to-Skill and lazy MCP
+
+ToolCapsule is an **MCP-to-Skill workflow layer**. It imports existing MCP configurations and generates Agent Skills that let agents lazy-load MCP schemas only when needed.
+
+This is the practical version of a lazy MCP workflow:
+
+- MCP remains the protocol and source of truth;
+- Skills become the agent-facing workflow;
+- large payloads move into local files;
+- failed calls become patchable artifacts instead of regenerated prompts.
+
+## Import your existing MCP setup
+
+Already configured MCP in Claude Code, GitHub Copilot / VS Code, OpenCode, Gemini CLI, or Cursor? Import it instead of retyping URLs and commands:
+
+```bash
+tcap import --dry-run
+tcap import --name github --target claude
+```
+
+ToolCapsule scans common workspace MCP config files such as `.mcp.json`, `.vscode/mcp.json`, `opencode.json`, `.gemini/settings.json`, and `.cursor/mcp.json`, then creates:
+
+```text
+.toolcapsule/profiles/<server>.json
+.claude/skills/<server>-mcp/SKILL.md
+```
+
+Use `--target copilot`, `--target opencode`, `--target agents`, or `--target all` to write skills for other agents. User-level MCP configs are only inspected when you opt in with `--include-user`.
 
 ## What is a ToolCapsule?
 
@@ -47,7 +80,9 @@ Instead of making the model hold everything in the prompt, ToolCapsule stores he
 ```bash
 npm i -g toolcapsule
 
-toolcapsule init feishu --url https://mcp.example.com/mcp/xxx
+toolcapsule install-skill
+toolcapsule import --dry-run
+toolcapsule import --name feishu --target claude
 toolcapsule tools feishu --brief
 toolcapsule schema feishu create-doc
 toolcapsule call feishu create-doc @args.json --save-run
@@ -64,7 +99,7 @@ tcap call feishu create-doc @args.json --save-run
 ## What it generates
 
 ```text
-.github/skills/feishu-mcp/
+.claude/skills/feishu-mcp/
   SKILL.md                  # lightweight Agent Skill entrypoint
   toolcapsule.config.json   # MCP transport/profile config
   scripts/README.md
@@ -113,8 +148,12 @@ Results vary by MCP server, model, and host.
 ## CLI
 
 ```text
-toolcapsule init <name> --url <remote-mcp-url>
-toolcapsule init <name> --command <stdio-command> --arg <arg>
+toolcapsule init <name> --url <remote-mcp-url> --target claude
+toolcapsule init <name> --command <stdio-command> --arg <arg> --target claude
+toolcapsule install-skill --target claude
+toolcapsule import --dry-run
+toolcapsule import --name <server> --target claude
+toolcapsule import --all --target all
 toolcapsule tools <profile> --brief
 toolcapsule describe <profile> <tool> --brief
 toolcapsule schema <profile> <tool>
@@ -146,12 +185,15 @@ Early alpha. APIs may change before v1.0.
 
 - [Concept](docs/concept.md)
 - [Architecture](docs/architecture.md)
+- [Import existing MCP configuration](docs/importing-mcp.md)
 - [Patch and retry](docs/patch-and-retry.md)
 - [Benchmark methodology](docs/benchmark-methodology.md)
 - [Releasing](docs/releasing.md)
 - [Launch notes](docs/launch.md)
+- [Screenshots and recordings](docs/screenshots.md)
 - [Next steps](docs/next-steps.md)
 - [Release checklist](docs/release-checklist.md)
+- [Agent tool compatibility research](docs/agent-tool-compatibility.md)
 - [Roadmap](ROADMAP.md)
 
 ## License

package/dist/cli.js

@@ -2,39 +2,51 @@
 
 // src/cli.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 import { cac } from "cac";
 import pc 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], {
-        stdio: ["pipe", "pipe", "pipe"]
+      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"]
+        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) => process.stderr.write(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;
@@ -63,14 +75,14 @@ var McpClient = class {
     await this.request("initialize", {
       protocolVersion: "2025-03-26",
       capabilities: {},
-      clientInfo: { name: "toolcapsule", version: "0.1.0" }
+      clientInfo: { name: "toolcapsule", version: this.clientVersion }
     });
     this.notify("notifications/initialized", {});
   }
   async request(method, params) {
     const id = this.nextId++;
-    const responsePromise = new Promise((resolve2, reject) => {
-      this.pending.set(id, { resolve: resolve2, reject });
+    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 })}
 `);
@@ -90,7 +102,7 @@ var McpClient = class {
   }
   async close() {
     if (!this.child.killed) this.child.kill();
-    if (this.child.exitCode === null) await Promise.race([once(this.child, "exit"), new Promise((resolve2) => setTimeout(resolve2, 500))]);
+    if (this.child.exitCode === null) await Promise.race([once(this.child, "exit"), new Promise((resolve3) => setTimeout(resolve3, 500))]);
   }
   async withTimeout(promise, label) {
     let timer;
@@ -104,15 +116,22 @@ var McpClient = class {
     }
   }
 };
+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
+// src/mcp/importer.ts
 import { existsSync } from "fs";
+import { homedir } from "os";
 import { join } from "path";
-import { z } from "zod";
 
 // src/utils/fs.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { dirname, resolve } from "path";
+import { dirname, resolve as resolve2 } from "path";
 async function readJson(path) {
   return JSON.parse(await readFile(path, "utf8"));
 }
@@ -122,12 +141,128 @@ async function writeJson(path, value) {
 `);
 }
 
+// src/mcp/importer.ts
+var workspaceSources = [
+  { tool: "vscode", path: join(".vscode", "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: "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 }
+];
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+function stringRecord(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const entries = Object.entries(record).filter((entry) => typeof entry[1] === "string");
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function cleanName(name) {
+  const cleaned = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return cleaned || "imported-mcp";
+}
+function mapServer(name, source, raw) {
+  const server = asRecord(raw);
+  if (!server) return void 0;
+  const warnings = [];
+  let transport;
+  const type = typeof server.type === "string" ? server.type : void 0;
+  const url = typeof server.url === "string" ? server.url : typeof server.httpUrl === "string" ? server.httpUrl : void 0;
+  const commandValue = server.command;
+  const headers = stringRecord(server.headers);
+  const env = stringRecord(server.env) ?? stringRecord(server.environment);
+  const cwd = typeof server.cwd === "string" ? server.cwd : void 0;
+  if (url && (!type || ["http", "streamable-http", "remote", "sse", "ws"].includes(type))) {
+    transport = { type: "remote", url, ...headers ? { headers } : {}, ...env ? { env } : {} };
+    if (type === "sse" || type === "ws") warnings.push(`Imported ${type} server as remote URL; verify transport compatibility.`);
+  } else if (typeof commandValue === "string") {
+    transport = {
+      type: "stdio",
+      command: commandValue,
+      args: stringArray(server.args) ?? [],
+      ...env ? { env } : {},
+      ...cwd ? { cwd } : {}
+    };
+  } else if (Array.isArray(commandValue) && commandValue.every((item) => typeof item === "string") && commandValue.length > 0) {
+    transport = { type: "stdio", command: commandValue[0], args: commandValue.slice(1), ...env ? { env } : {}, ...cwd ? { cwd } : {} };
+  }
+  if (!transport) return void 0;
+  if (server.headers && !headers) warnings.push("Headers were present but not copied because they were not string values.");
+  if ((server.env || server.environment) && !env) warnings.push("Environment variables were present but not copied because they were not string values.");
+  if (server.includeTools || server.excludeTools) warnings.push("Tool include/exclude filters were not copied; use ToolCapsule brief/schema commands to choose tools manually.");
+  const profileName = cleanName(name);
+  return {
+    name: profileName,
+    source,
+    warnings,
+    profile: {
+      name: profileName,
+      transport
+    }
+  };
+}
+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) ?? {});
+  if (source.tool === "claude") {
+    const projectEntries = Object.entries(asRecord(config.mcpServers) ?? {});
+    const projectConfigs = Object.entries(asRecord(config.projects) ?? {}).flatMap(
+      ([, project]) => Object.entries(asRecord(asRecord(project)?.mcpServers) ?? {})
+    );
+    return [...projectEntries, ...projectConfigs];
+  }
+  return Object.entries(asRecord(config.mcpServers) ?? {});
+}
+async function discoverMcpServers(opts = {}) {
+  const sources = opts.includeUser ? [...workspaceSources, ...userSources] : workspaceSources;
+  const discovered = [];
+  for (const source of sources) {
+    if (!existsSync(source.path)) continue;
+    const config = asRecord(await readJson(source.path));
+    if (!config) continue;
+    for (const [name, raw] of serverEntries(source, config)) {
+      const imported = mapServer(name, source, raw);
+      if (imported) discovered.push(imported);
+    }
+  }
+  return discovered;
+}
+function selectImportedServers(servers, name, all) {
+  if (all) return servers;
+  if (!name) return servers.length === 1 ? servers : [];
+  const normalized = cleanName(name);
+  return servers.filter((server) => server.name === normalized || server.name === name);
+}
+
 // src/profile.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { z } from "zod";
 var profileSchema = z.object({
   name: z.string().min(1),
   transport: z.union([
-    z.object({ type: z.literal("remote"), url: z.string().url() }),
-    z.object({ type: z.literal("stdio"), command: z.string().min(1), args: z.array(z.string()).optional() })
+    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(),
@@ -145,10 +280,10 @@ async function loadProfile(profilePathOrName) {
   const candidates = [
     profilePathOrName,
     `${profilePathOrName}.json`,
-    join(".toolcapsule", "profiles", `${profilePathOrName}.json`),
-    join(".github", "skills", `${profilePathOrName}-mcp`, "toolcapsule.config.json")
+    join2(".toolcapsule", "profiles", `${profilePathOrName}.json`),
+    join2(".github", "skills", `${profilePathOrName}-mcp`, "toolcapsule.config.json")
   ];
-  const found = candidates.find((path) => existsSync(path));
+  const found = candidates.find((path) => existsSync2(path));
   if (!found) throw new Error(`Profile not found: ${profilePathOrName}`);
   return profileSchema.parse(await readJson(found));
 }
@@ -195,8 +330,18 @@ function summarizeTools(tools) {
 
 // src/skill/generator.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname2, join as join3 } 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);
+}
+function expandSkillTargets(target) {
+  return target === "all" ? ["copilot", "claude", "opencode", "agents"] : [target];
+}
 var skillTemplate = `---
 name: {{skillName}}
 description: '{{description}}'
@@ -238,11 +383,10 @@ toolcapsule retry <run-dir>
 - Do not print secrets.
 - Review destructive tools before calling.
 `;
-async function generateSkill(profile, opts = {}) {
+async function generateSkillAt(profile, outputDir) {
   const skillName = profile.skill?.name || `${profile.name}-mcp`;
-  const outputDir = opts.outputDir || join2(".github", "skills", skillName);
-  await mkdir2(join2(outputDir, "scripts"), { recursive: true });
-  await mkdir2(join2(outputDir, "runs"), { recursive: true });
+  await mkdir2(join3(outputDir, "scripts"), { recursive: true });
+  await mkdir2(join3(outputDir, "runs"), { 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({
@@ -251,10 +395,10 @@ async function generateSkill(profile, opts = {}) {
     title: `${profile.name} MCP Skill`,
     description: description.replace(/'/g, "''")
   });
-  await writeFile2(join2(outputDir, "SKILL.md"), markdown);
-  await writeJson(join2(outputDir, "toolcapsule.config.json"), profile);
+  await writeFile2(join3(outputDir, "SKILL.md"), markdown);
+  await writeJson(join3(outputDir, "toolcapsule.config.json"), profile);
   await writeFile2(
-    join2(outputDir, "scripts", "README.md"),
+    join3(outputDir, "scripts", "README.md"),
     `# Scripts
 
 This skill uses the project-level \`toolcapsule\` CLI.
@@ -262,34 +406,125 @@ This skill uses the project-level \`toolcapsule\` CLI.
   );
   return outputDir;
 }
+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))));
+  return outputs.join(", ");
+}
 async function writeProfile(path, profile) {
   await mkdir2(dirname2(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 runs/<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.
+`;
+async function installAgentSkill(outputDir, target = defaultSkillTarget) {
+  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);
+    })
+  );
+  return outputDirs.join(", ");
+}
+
 // src/runs/recorder.ts
-import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { mkdir as mkdir4, readFile as readFile2, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
 function createRunId() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 async function saveRun(baseDir, record) {
-  const dir = join3(baseDir, record.id);
-  await mkdir3(dir, { recursive: true });
-  await writeJson(join3(dir, "run.json"), record);
-  await writeJson(join3(dir, "request.json"), record.request);
-  if (record.response !== void 0) await writeJson(join3(dir, "response.json"), record.response);
-  if (record.error) await writeFile3(join3(dir, "error.txt"), record.error);
-  await writeFile3(join3(dir, "command.txt"), `${record.command}
+  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}
 `);
   return dir;
 }
 async function loadRun(runDir) {
-  return JSON.parse(await readFile2(join3(runDir, "run.json"), "utf8"));
+  return JSON.parse(await readFile2(join5(runDir, "run.json"), "utf8"));
 }
 
 // src/cli.ts
-import { writeFile as writeFile4 } from "fs/promises";
+import { writeFile as writeFile5 } from "fs/promises";
 
 // src/utils/tokens.ts
 function roughTokens(value) {
@@ -302,8 +537,17 @@ function percentReduction(before, after) {
 
 // src/cli.ts
 var cli = cac("toolcapsule");
+async function readPackageVersion() {
+  try {
+    const pkg = JSON.parse(await readFile3(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var packageVersion = await readPackageVersion();
 async function withClient(profile, fn) {
-  const client = new McpClient(profile);
+  const client = new McpClient(profile, { clientVersion: packageVersion });
   try {
     await client.init();
     return await fn(client);
@@ -314,13 +558,48 @@ async function withClient(profile, fn) {
 function readArgsPath(raw) {
   return raw.startsWith("@") ? raw.slice(1) : raw;
 }
-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").action(async (name, options) => {
+function readSkillTarget(raw) {
+  const target = raw || defaultSkillTarget;
+  if (["copilot", "claude", "opencode", "agents", "all"].includes(target)) return target;
+  throw new Error("Invalid --target. Use one of: copilot, claude, opencode, agents, all");
+}
+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) => {
   if (!options.url && !options.command) throw new Error("Provide --url for remote MCP or --command for stdio MCP");
   const profile = options.url ? { name, transport: { type: "remote", url: options.url } } : { name, transport: { type: "stdio", command: options.command, args: options.arg ?? [] } };
-  await writeProfile(join4(".toolcapsule", "profiles", `${name}.json`), profile);
-  const out = await generateSkill(profile, options.output ? { outputDir: options.output } : {});
+  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}`));
 });
+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}`));
+});
+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(
+  async (options) => {
+    const discovered = await discoverMcpServers(options.includeUser ? { includeUser: true } : {});
+    if (discovered.length === 0) {
+      console.log("No importable MCP servers found.");
+      return;
+    }
+    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}`));
+      }
+      return;
+    }
+    const selected = selectImportedServers(discovered, options.name, options.all);
+    if (selected.length === 0) {
+      throw new Error("Multiple MCP servers found. Re-run with --dry-run, then pass --name <server> or --all.");
+    }
+    for (const server of selected) {
+      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}`));
+    }
+  }
+);
 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());
@@ -420,14 +699,14 @@ 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 writeFile4(options.out, output);
+  if (options.out) await writeFile5(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"));
 });
 cli.help();
-cli.version("0.1.0-alpha.0");
+cli.version(packageVersion);
 try {
   cli.parse();
 } catch (error) {