@t2000/cli 9.0.0 → 9.2.0

package/dist/index.js

@@ -33689,6 +33689,542 @@ function registerModels(program3) {
   });
 }
 
+// src/commands/connect/index.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3, appendFileSync } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+
+// src/commands/connect/clients.ts
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var API_BASE = "https://api.t2000.ai/v1";
+var CHAT_COMPLETIONS_URL = `${API_BASE}/chat/completions`;
+var DEFAULT_MODEL = "t2000/auto";
+var OPEN_MODEL = "t2000/auto-open";
+var CONSOLE_KEYS_URL = "https://agents.t2000.ai/manage";
+var CONNECT_CLIENTS = [
+  {
+    slug: "t2code",
+    name: "t2 code",
+    aliases: ["code"],
+    blurb: "the t2000 coding agent (npm i -g @t2000/code) \u2014 saves your key"
+  },
+  {
+    slug: "claude-code",
+    name: "Claude Code (via claude-code-router)",
+    aliases: ["ccr", "claude"],
+    blurb: "adds a t2000 provider to ~/.claude-code-router"
+  },
+  {
+    slug: "continue",
+    name: "Continue",
+    aliases: [],
+    blurb: "model entry for ~/.continue/config.yaml"
+  },
+  {
+    slug: "aider",
+    name: "Aider",
+    aliases: [],
+    blurb: "OpenAI-compatible base + model for ~/.aider.conf.yml"
+  },
+  {
+    slug: "codex",
+    name: "OpenAI Codex CLI",
+    aliases: [],
+    blurb: "t2000 provider profile in ~/.codex/config.toml"
+  },
+  {
+    slug: "grok",
+    name: "Grok Build",
+    aliases: ["grok-build"],
+    blurb: "custom-model block in ~/.grok/config.toml (the BYOK pattern)"
+  },
+  {
+    slug: "cline",
+    name: "Cline",
+    aliases: [],
+    blurb: "settings walkthrough (GUI-managed config)"
+  },
+  {
+    slug: "cursor",
+    name: "Cursor",
+    aliases: [],
+    blurb: "settings walkthrough (GUI-managed config)"
+  }
+];
+function resolveClientSlug(input) {
+  const needle = input.toLowerCase();
+  for (const c of CONNECT_CLIENTS) {
+    if (c.slug === needle || c.aliases.includes(needle)) return c.slug;
+  }
+  return void 0;
+}
+function t2codeCredentialsPath(home = homedir3()) {
+  return join4(home, ".config", "t2code", "credentials.json");
+}
+function withT2codeKey(existing, key) {
+  return {
+    ...existing,
+    default: {
+      name: "t2000",
+      email: "",
+      ...typeof existing.default === "object" && existing.default !== null ? existing.default : {},
+      authToken: key
+    }
+  };
+}
+function t2codeHasKey(existing, key) {
+  return existing.default?.authToken === key;
+}
+function ccrDir(home = homedir3()) {
+  return join4(home, ".claude-code-router");
+}
+function ccrSqlitePath(home = homedir3()) {
+  return join4(ccrDir(home), "config.sqlite");
+}
+function ccrConfigJsonPath(home = homedir3()) {
+  return join4(ccrDir(home), "config.json");
+}
+function withCcrProvider(existing, key) {
+  const provider = {
+    name: "t2000",
+    api_base_url: CHAT_COMPLETIONS_URL,
+    api_key: key,
+    models: [DEFAULT_MODEL, OPEN_MODEL]
+  };
+  const providers = Array.isArray(existing.Providers) ? [...existing.Providers] : [];
+  const idx = providers.findIndex((p) => p?.name === "t2000");
+  if (idx >= 0) providers[idx] = { ...providers[idx], ...provider };
+  else providers.push(provider);
+  const router = { ...existing.Router ?? {} };
+  if (!router.default) router.default = `t2000,${DEFAULT_MODEL}`;
+  return { ...existing, Providers: providers, Router: router };
+}
+function ccrHasProvider(existing) {
+  return Array.isArray(existing.Providers) && existing.Providers.some((p) => p?.name === "t2000");
+}
+function continueConfigPath(home = homedir3()) {
+  return join4(home, ".continue", "config.yaml");
+}
+function continueModelYaml(key) {
+  return [
+    `  - name: t2000 auto`,
+    `    provider: openai`,
+    `    model: ${DEFAULT_MODEL}`,
+    `    apiBase: ${API_BASE}`,
+    `    apiKey: ${key}`,
+    `    roles:`,
+    `      - chat`,
+    `      - edit`,
+    `      - apply`
+  ].join("\n");
+}
+function continueFreshConfigYaml(key) {
+  return [
+    `name: t2000 Private Inference`,
+    `version: 0.0.1`,
+    `schema: v1`,
+    ``,
+    `models:`,
+    continueModelYaml(key),
+    ``
+  ].join("\n");
+}
+function aiderConfPath(home = homedir3()) {
+  return join4(home, ".aider.conf.yml");
+}
+function aiderConfYaml(key) {
+  return [
+    `# t2000 Private Inference (written by \`t2 connect aider\`)`,
+    `openai-api-base: ${API_BASE}`,
+    `openai-api-key: ${key}`,
+    `model: openai/${DEFAULT_MODEL}`,
+    ``
+  ].join("\n");
+}
+function codexConfigPath(home = homedir3()) {
+  return join4(home, ".codex", "config.toml");
+}
+function codexTomlBlock() {
+  return [
+    ``,
+    `# t2000 Private Inference (written by \`t2 connect codex\`)`,
+    `[model_providers.t2000]`,
+    `name = "t2000"`,
+    `base_url = "${API_BASE}"`,
+    `env_key = "T2000_API_KEY"`,
+    ``,
+    `[profiles.t2000]`,
+    `model = "${DEFAULT_MODEL}"`,
+    `model_provider = "t2000"`,
+    ``
+  ].join("\n");
+}
+function codexHasProvider(existingToml) {
+  return existingToml.includes("[model_providers.t2000]");
+}
+function grokConfigPath(home = homedir3()) {
+  return join4(home, ".grok", "config.toml");
+}
+function grokModelBlock() {
+  return [
+    ``,
+    `# t2000 Private Inference (written by \`t2 connect grok\`)`,
+    `[model.t2000]`,
+    `model = "${DEFAULT_MODEL}"`,
+    `base_url = "${API_BASE}"`,
+    `name = "t2000 auto (Private Inference)"`,
+    `env_key = "T2000_API_KEY"`,
+    `api_backend = "chat_completions"`,
+    ``
+  ].join("\n");
+}
+function grokFreshConfigToml() {
+  return grokModelBlock().trimStart() + [`[models]`, `default = "t2000"`, ``].join("\n");
+}
+function grokHasModel(existingToml) {
+  return existingToml.includes("[model.t2000]");
+}
+
+// src/commands/connect/index.ts
+function t2000ConfigPath() {
+  return join5(homedir4(), ".t2000", "config.json");
+}
+function loadSavedKey() {
+  try {
+    const raw = JSON.parse(readFileSync3(t2000ConfigPath(), "utf-8"));
+    const inference = raw.inference;
+    if (typeof inference === "object" && inference !== null) {
+      const key = inference.apiKey;
+      if (typeof key === "string" && key.length > 0) return key;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function saveKey2(key) {
+  const path2 = t2000ConfigPath();
+  let existing = {};
+  try {
+    existing = JSON.parse(readFileSync3(path2, "utf-8"));
+  } catch {
+    existing = {};
+  }
+  const merged = { ...existing, inference: { apiKey: key } };
+  if (!existsSync3(dirname3(path2))) mkdirSync2(dirname3(path2), { recursive: true });
+  writeFileSync3(path2, JSON.stringify(merged, null, 2) + "\n", { mode: 384 });
+}
+function resolveKey(flagKey) {
+  if (flagKey && flagKey.trim().length > 0) return { key: flagKey.trim(), source: "--key" };
+  const envKey = process.env.T2000_API_KEY;
+  if (envKey && envKey.trim().length > 0) return { key: envKey.trim(), source: "T2000_API_KEY" };
+  const saved = loadSavedKey();
+  if (saved) return { key: saved, source: "~/.t2000/config.json" };
+  return { source: "none" };
+}
+function readJson(path2) {
+  try {
+    return JSON.parse(readFileSync3(path2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeFileEnsuringDir(path2, contents, mode) {
+  const dir = dirname3(path2);
+  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync3(path2, contents, mode !== void 0 ? { mode } : void 0);
+}
+function connectT2code(key, print2) {
+  const path2 = t2codeCredentialsPath();
+  const existing = readJson(path2);
+  if (t2codeHasKey(existing, key)) {
+    return { client: "t2code", action: "exists", path: path2, detail: "already connected with this key" };
+  }
+  if (print2) {
+    return {
+      client: "t2code",
+      action: "snippet",
+      path: path2,
+      detail: "would write the key into t2 code credentials",
+      text: `Would set default.authToken in ${path2}`
+    };
+  }
+  writeFileEnsuringDir(path2, JSON.stringify(withT2codeKey(existing, key), null, 2), 384);
+  return {
+    client: "t2code",
+    action: "written",
+    path: path2,
+    detail: "key saved \u2014 run `t2code` (or `npm i -g @t2000/code` first)"
+  };
+}
+function connectClaudeCode(key, print2) {
+  const sqlite = ccrSqlitePath();
+  if (existsSync3(sqlite)) {
+    return {
+      client: "claude-code",
+      action: "instructions",
+      detail: "claude-code-router already manages config in SQLite \u2014 add the provider in its UI",
+      text: [
+        `claude-code-router found (SQLite config). Add the provider in the ccr UI:`,
+        `  Providers \u2192 Add Provider \u2192 Other / custom API endpoint`,
+        `    name:      t2000`,
+        `    base URL:  ${API_BASE}/chat/completions`,
+        `    protocol:  OpenAI`,
+        `    API key:   ${key}`,
+        `    models:    ${DEFAULT_MODEL}`,
+        `  Then set the default route to t2000,${DEFAULT_MODEL}.`
+      ].join("\n")
+    };
+  }
+  const path2 = ccrConfigJsonPath();
+  const existing = readJson(path2);
+  const already = ccrHasProvider(existing);
+  if (print2) {
+    return {
+      client: "claude-code",
+      action: "snippet",
+      path: path2,
+      detail: already ? "t2000 provider already present" : "would add the t2000 provider",
+      text: JSON.stringify(withCcrProvider(existing, key), null, 2)
+    };
+  }
+  writeFileEnsuringDir(path2, JSON.stringify(withCcrProvider(existing, key), null, 2) + "\n", 384);
+  return {
+    client: "claude-code",
+    action: "written",
+    path: path2,
+    detail: already ? "t2000 provider refreshed \u2014 install ccr (npm i -g @musistudio/claude-code-router), then `ccr code`" : "t2000 provider added \u2014 install ccr (npm i -g @musistudio/claude-code-router), then `ccr code`"
+  };
+}
+function connectContinue(key, print2) {
+  const path2 = continueConfigPath();
+  if (!existsSync3(path2) && !print2) {
+    writeFileEnsuringDir(path2, continueFreshConfigYaml(key), 384);
+    return { client: "continue", action: "written", path: path2, detail: "config.yaml created" };
+  }
+  return {
+    client: "continue",
+    action: "snippet",
+    path: path2,
+    detail: existsSync3(path2) ? "config.yaml exists \u2014 paste this model block under `models:`" : "would create config.yaml with this model block",
+    text: continueModelYaml(key)
+  };
+}
+function connectAider(key, print2) {
+  const path2 = aiderConfPath();
+  if (!existsSync3(path2) && !print2) {
+    writeFileEnsuringDir(path2, aiderConfYaml(key), 384);
+    return { client: "aider", action: "written", path: path2, detail: ".aider.conf.yml created" };
+  }
+  return {
+    client: "aider",
+    action: "snippet",
+    path: path2,
+    detail: existsSync3(path2) ? ".aider.conf.yml exists \u2014 add these lines (or use the flags below)" : "would create .aider.conf.yml",
+    text: aiderConfYaml(key) + `
+# or without touching the file:
+#   aider --openai-api-base ${API_BASE} --openai-api-key ${key} --model openai/${DEFAULT_MODEL}`
+  };
+}
+function connectCodex(key, print2) {
+  const path2 = codexConfigPath();
+  const existing = existsSync3(path2) ? readFileSync3(path2, "utf-8") : "";
+  if (codexHasProvider(existing)) {
+    return {
+      client: "codex",
+      action: "exists",
+      path: path2,
+      detail: "t2000 provider already in config.toml \u2014 run `codex --profile t2000`"
+    };
+  }
+  if (print2) {
+    return {
+      client: "codex",
+      action: "snippet",
+      path: path2,
+      detail: "would append the t2000 provider + profile",
+      text: codexTomlBlock()
+    };
+  }
+  if (existsSync3(path2)) appendFileSync(path2, codexTomlBlock());
+  else writeFileEnsuringDir(path2, codexTomlBlock().trimStart(), 384);
+  return {
+    client: "codex",
+    action: "written",
+    path: path2,
+    detail: `provider + profile added \u2014 export T2000_API_KEY=${maskKey(key)} then \`codex --profile t2000\``
+  };
+}
+function connectGrok(key, print2) {
+  const path2 = grokConfigPath();
+  const existing = existsSync3(path2) ? readFileSync3(path2, "utf-8") : "";
+  if (grokHasModel(existing)) {
+    return {
+      client: "grok",
+      action: "exists",
+      path: path2,
+      detail: "t2000 model already in config.toml \u2014 run `grok -m t2000` (or /model t2000)"
+    };
+  }
+  if (print2) {
+    return {
+      client: "grok",
+      action: "snippet",
+      path: path2,
+      detail: existsSync3(path2) ? "would append the t2000 model block" : "would create config.toml with the t2000 model (+ default)",
+      text: existsSync3(path2) ? grokModelBlock() : grokFreshConfigToml()
+    };
+  }
+  if (existsSync3(path2)) {
+    appendFileSync(path2, grokModelBlock());
+    return {
+      client: "grok",
+      action: "written",
+      path: path2,
+      detail: `t2000 model added \u2014 export T2000_API_KEY=${maskKey(key)} then \`grok -m t2000\` (set \`default = "t2000"\` under your existing [models] to make it stick)`
+    };
+  }
+  writeFileEnsuringDir(path2, grokFreshConfigToml(), 384);
+  return {
+    client: "grok",
+    action: "written",
+    path: path2,
+    detail: `config.toml created with t2000 as default \u2014 export T2000_API_KEY=${maskKey(key)} then \`grok\``
+  };
+}
+function connectCline(key) {
+  return {
+    client: "cline",
+    action: "instructions",
+    detail: "Cline stores provider config in VS Code \u2014 set it in the extension settings",
+    text: [
+      `In Cline settings, choose the "OpenAI Compatible" API provider:`,
+      `  Base URL:  ${API_BASE}`,
+      `  API key:   ${key}`,
+      `  Model ID:  ${DEFAULT_MODEL}`
+    ].join("\n")
+  };
+}
+function connectCursor(key) {
+  return {
+    client: "cursor",
+    action: "instructions",
+    detail: "Cursor is configured in Settings \u2014 no file to write",
+    text: [
+      `Cursor \u2192 Settings \u2192 Models \u2192 API Keys:`,
+      `  1. Paste the key into "OpenAI API Key": ${maskKey(key)}`,
+      `  2. Expand "Override OpenAI Base URL" and set: ${API_BASE}`,
+      `  3. Under Models, add \`${DEFAULT_MODEL}\`, then Verify.`,
+      `Note: Cursor's agent features are tuned for its own models \u2014 use this`,
+      `for private chat models; delegation runs through t2 code.`
+    ].join("\n")
+  };
+}
+function maskKey(key) {
+  return key.length > 8 ? `${key.slice(0, 5)}\u2026${key.slice(-3)}` : "sk-\u2026";
+}
+function runConnect(slug, key, print2) {
+  switch (slug) {
+    case "t2code":
+      return connectT2code(key, print2);
+    case "claude-code":
+      return connectClaudeCode(key, print2);
+    case "continue":
+      return connectContinue(key, print2);
+    case "aider":
+      return connectAider(key, print2);
+    case "codex":
+      return connectCodex(key, print2);
+    case "grok":
+      return connectGrok(key, print2);
+    case "cline":
+      return connectCline(key);
+    case "cursor":
+      return connectCursor(key);
+  }
+}
+function registerConnect(program3) {
+  program3.command("connect").description("Point a coding tool at Private Inference (api.t2000.ai/v1) with your key").argument("[client]", "client to connect: t2code | claude-code | continue | aider | codex | grok | cline | cursor").option("--key <sk-key>", `Private Inference key (create one at ${CONSOLE_KEYS_URL})`).option("--print", "Show what would be written / the paste snippet, without writing").addHelpText(
+    "after",
+    `
+Examples:
+  $ t2 connect                         List supported clients
+  $ t2 connect t2code --key sk-...     Save your key into t2 code
+  $ t2 connect claude-code             Add the t2000 provider to claude-code-router
+  $ t2 connect aider --print           Show the aider config without writing it
+
+The key comes from the console: sign in at ${CONSOLE_KEYS_URL}
+(Google), create an API key, paste it once \u2014 it is saved to ~/.t2000/config.json
+and reused by later connects. All clients get model ${DEFAULT_MODEL} (the router;
+you pay the price of the model that actually served each request).`
+  ).action(async (clientArg, opts) => {
+    try {
+      if (!clientArg) {
+        const { key: key2 } = resolveKey(opts.key);
+        if (isJsonMode()) {
+          printJson({
+            clients: CONNECT_CLIENTS.map((c) => ({ slug: c.slug, name: c.name, blurb: c.blurb })),
+            keySaved: !!key2
+          });
+          return;
+        }
+        printBlank();
+        printLine("  Connect a coding tool to Private Inference:");
+        printBlank();
+        for (const c of CONNECT_CLIENTS) {
+          printKeyValue(c.slug.padEnd(12), c.blurb);
+        }
+        printBlank();
+        printInfo(`Usage: t2 connect <client> [--key sk-...]`);
+        printInfo(
+          key2 ? "A key is saved \u2014 connects will reuse it." : `No key yet \u2014 create one at ${CONSOLE_KEYS_URL}`
+        );
+        printBlank();
+        return;
+      }
+      const slug = resolveClientSlug(clientArg);
+      if (!slug) {
+        printWarning(`Unknown client '${clientArg}'.`);
+        printInfo(`Supported: ${CONNECT_CLIENTS.map((c) => c.slug).join(" \xB7 ")}`);
+        process.exitCode = 1;
+        return;
+      }
+      const { key, source } = resolveKey(opts.key);
+      if (!key) {
+        printBlank();
+        printWarning("No API key found.");
+        printInfo(`1. Sign in at ${CONSOLE_KEYS_URL} (Google) and create an API key`);
+        printInfo(`2. Re-run: t2 connect ${slug} --key sk-...`);
+        printBlank();
+        process.exitCode = 1;
+        return;
+      }
+      const result = runConnect(slug, key, !!opts.print);
+      if (!opts.print && source !== "~/.t2000/config.json") saveKey2(key);
+      if (isJsonMode()) {
+        printJson({ ...result, keySource: source });
+        return;
+      }
+      printBlank();
+      if (result.action === "written") {
+        printSuccess(`${slug}: ${result.detail}`);
+        if (result.path) printKeyValue("wrote", result.path);
+      } else if (result.action === "exists") {
+        printInfo(`${slug}: ${result.detail}`);
+      } else {
+        printInfo(`${slug}: ${result.detail}`);
+      }
+      if (result.text) {
+        printBlank();
+        for (const line of result.text.split("\n")) printLine(`  ${line}`);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
 // src/commands/verify.ts
 var import_picocolors10 = __toESM(require_picocolors(), 1);
 function mark(check2) {
@@ -34121,7 +34657,7 @@ function registerMcpStart(parent) {
   parent.command("start", { isDefault: true }).description("Start MCP server (stdio transport \u2014 for AI client integration)").option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").action(async (opts) => {
     let mod3;
     try {
-      mod3 = await import("./dist-5XBLHNG7.js");
+      mod3 = await import("./dist-STP3HAL6.js");
     } catch {
       console.error("MCP server not installed. Run:\n  npm install -g @t2000/mcp");
       process.exit(1);
@@ -34172,12 +34708,12 @@ function registerMcpInstall(parent) {
 }
 
 // src/commands/mcp/uninstall.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 async function runUninstall() {
   const platforms = getPlatformConfigs();
   const results = [];
   for (const platform of platforms) {
-    if (!existsSync3(platform.path)) {
+    if (!existsSync4(platform.path)) {
       results.push({ name: platform.name, slug: platform.slug, removed: false });
       continue;
     }
@@ -34233,12 +34769,12 @@ Subcommands:
 
 // src/commands/skills/check.ts
 import { readdir, readFile as readFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 
 // src/commands/skills/lib.ts
 import { stat } from "fs/promises";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 var MANIFEST_URL = "https://t2000.ai/.well-known/agent-skills/index.json";
 var SKILL_PREFIXES = ["t2000-", "mpp-"];
 function isManagedSkillName(name) {
@@ -34246,21 +34782,21 @@ function isManagedSkillName(name) {
 }
 var SKILL_TARGETS = ["agents", "cursor", "claude-code"];
 function resolveTargetDir(target, useGlobal, cwd = process.cwd()) {
-  const root = useGlobal ? homedir3() : cwd;
+  const root = useGlobal ? homedir5() : cwd;
   switch (target) {
     case "agents":
-      return join4(root, ".agents", "skills");
+      return join6(root, ".agents", "skills");
     case "cursor":
-      return join4(root, ".cursor", "rules");
+      return join6(root, ".cursor", "rules");
     case "claude-code":
-      return join4(root, ".claude", "skills");
+      return join6(root, ".claude", "skills");
   }
 }
 function filenameForTarget(slug, target) {
   switch (target) {
     case "agents":
     case "claude-code":
-      return join4(slug, "SKILL.md");
+      return join6(slug, "SKILL.md");
     case "cursor":
       return `${slug}.mdc`;
   }
@@ -34334,7 +34870,7 @@ async function checkTargetScope(manifest, servedCache, target, scope) {
   const slugs = await installedSlugs(dir, target);
   const rows = [];
   for (const slug of slugs) {
-    const path2 = join5(dir, filenameForTarget(slug, target));
+    const path2 = join7(dir, filenameForTarget(slug, target));
     let installed;
     try {
       installed = await readFile3(path2, "utf-8");
@@ -34462,7 +34998,7 @@ function registerSkillsList(parent) {
 
 // src/commands/skills/install.ts
 import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 function registerSkillsInstall(parent) {
   parent.command("install [slug]").description("Install all skills (or one named slug) into a local directory").option("--target <name>", "Target client layout: agents (default), cursor, claude-code", "agents").option("--global", "Install to ~/.<target>/ instead of <cwd>/.<target>/").action(async (slug, opts) => {
     try {
@@ -34483,8 +35019,8 @@ function registerSkillsInstall(parent) {
         const raw = await fetchSkill(s.url);
         const transformed = transformForTarget(raw, target, s.description);
         const relPath = filenameForTarget(s.name, target);
-        const fullPath = join6(targetDir, relPath);
-        await mkdir3(join6(fullPath, ".."), { recursive: true });
+        const fullPath = join8(targetDir, relPath);
+        await mkdir3(join8(fullPath, ".."), { recursive: true });
         await writeFile3(fullPath, transformed, "utf-8");
         installed.push({ name: s.name, path: fullPath });
       }
@@ -34513,7 +35049,7 @@ function registerSkillsInstall(parent) {
 
 // src/commands/skills/uninstall.ts
 import { readdir as readdir2, unlink, rmdir } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 function registerSkillsUninstall(parent) {
   parent.command("uninstall").description("Remove installed t2000 + MPP skills from the target directory").option("--target <name>", "Target client layout: agents (default), cursor, claude-code", "agents").option("--global", "Uninstall from ~/.<target>/ instead of <cwd>/.<target>/").action(async (opts) => {
     try {
@@ -34531,7 +35067,7 @@ function registerSkillsUninstall(parent) {
       const entries = await readdir2(targetDir);
       const removed = [];
       for (const entry of entries) {
-        const full = join7(targetDir, entry);
+        const full = join9(targetDir, entry);
         if (target === "cursor") {
           const slug = entry.endsWith(".mdc") ? entry.slice(0, -".mdc".length) : entry;
           if (entry.endsWith(".mdc") && isManagedSkillName(slug)) {
@@ -34540,7 +35076,7 @@ function registerSkillsUninstall(parent) {
           }
         } else {
           if (isManagedSkillName(entry)) {
-            const skillFile = join7(full, "SKILL.md");
+            const skillFile = join9(full, "SKILL.md");
             try {
               await unlink(skillFile);
             } catch {
@@ -35156,6 +35692,7 @@ Examples:
   $ t2 send 5 USDC alice.sui           Send 5 USDC (gasless; asset required)
   $ t2 swap 100 USDC SUI               Swap 100 USDC for SUI via Cetus
   $ t2 models                          List the Private Inference model catalog (chat lives in \`t2 code\`)
+  $ t2 connect t2code --key sk-...     Point a coding tool at Private Inference
   $ t2 pay <url> --estimate            Preview an x402 service's price + input schema (no payment)
   $ t2 services search "image"         Discover x402 services in the gateway catalog
   $ t2 agents                          Look up the agent directory (agents.t2000.ai)
@@ -35172,6 +35709,7 @@ Examples:
   registerSwap(program3);
   registerPay(program3);
   registerModels(program3);
+  registerConnect(program3);
   registerVerify(program3);
   registerServices(program3);
   registerLimit(program3);