@agentvalet/register 0.3.0 → 0.3.2

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk5 from "chalk";
+import chalk7 from "chalk";
 
 // src/wizard.ts
 import prompts from "prompts";
@@ -79,7 +79,7 @@ async function registerAgent(apiUrl, body) {
 import { fetch as fetch3 } from "undici";
 async function waitForApproval(apiUrl, token, timeoutMs, onTick) {
   const deadline = Date.now() + timeoutMs;
-  const sseResult = await trySSE(apiUrl, token, Math.min(3e4, timeoutMs), onTick);
+  const sseResult = await trySSE(apiUrl, token, timeoutMs, onTick);
   if (sseResult) return enrichWithKey(apiUrl, token, sseResult);
   const pollResult = await poll(apiUrl, token, deadline, onTick);
   return enrichWithKey(apiUrl, token, pollResult);
@@ -191,11 +191,102 @@ async function saveOutput(opts) {
 }
 
 // src/commands/refresh.ts
-import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync, statSync } from "fs";
 import { createSign, createPrivateKey } from "crypto";
 import { dirname as dirname2, resolve as resolve2 } from "path";
 
 // src/lib/skill-writer.ts
+import { existsSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import chalk2 from "chalk";
+function writeAgentsMd() {
+  const dest = path.join(process.cwd(), "AGENTS.md");
+  if (existsSync(dest)) {
+    console.log(chalk2.dim("  AGENTS.md already exists \u2014 skipping"));
+    return;
+  }
+  const content = `# AgentValet \u2014 Credential Governance
+
+All external platform API calls must go through the AgentValet proxy.
+Never call platform APIs (Slack, Stripe, Gmail, GitHub, etc.) directly.
+
+## Making a platform call
+
+Use the \`use_platform\` MCP tool:
+
+\`\`\`
+use_platform({
+  platform: "slack",
+  endpoint: "/api/chat.postMessage",
+  method: "POST",
+  scope: "slack:write",
+  data: { channel: "#general", text: "Hello" }
+})
+\`\`\`
+
+## Before any platform session
+
+1. Call \`list_platforms\` to see approved platforms and scopes
+2. Call \`authzen_evaluate\` before destructive operations
+3. If a call returns \`pending_approval\` \u2014 wait, do not retry
+
+## If AgentValet MCP is not available
+
+Do not call platform APIs directly. Tell the user:
+"AgentValet MCP is not connected. Run: npx @agentvalet/register"
+`;
+  writeFileSync(dest, content, "utf8");
+  console.log(chalk2.green("  \u2713 AGENTS.md created in current directory"));
+  console.log(chalk2.dim("    Commit this file to your repo"));
+}
+function writeSkillMd() {
+  const dest = path.join(process.cwd(), "SKILL.md");
+  if (existsSync(dest)) {
+    console.log(chalk2.dim("  SKILL.md already exists \u2014 skipping"));
+    return;
+  }
+  const content = `# AgentValet Skill
+
+Routes all platform API calls through AgentValet's credential proxy.
+
+## Making platform calls
+
+Use the \`use_platform\` tool instead of calling APIs directly:
+
+\`\`\`
+use_platform({
+  platform: "slack",
+  endpoint: "/api/chat.postMessage",
+  method: "POST",
+  scope: "slack:write",
+  data: { channel: "#general", text: "Hello" }
+})
+\`\`\`
+
+## Rules
+
+1. Never call platform APIs directly
+2. Call \`list_platforms\` before assuming a platform is available
+3. Call \`authzen_evaluate\` before destructive operations
+4. Wait for human approval when required \u2014 do not retry aggressively
+
+Dashboard: https://app.agentvalet.ai
+`;
+  writeFileSync(dest, content, "utf8");
+  console.log(chalk2.green("  \u2713 SKILL.md created in current directory"));
+  console.log(chalk2.dim("    Commit this file to your repo"));
+}
+function ensureMcpServer() {
+  try {
+    execSync("npx --yes @agentvalet/mcp-server --version", {
+      stdio: "ignore",
+      timeout: 1e4
+    });
+  } catch {
+    console.log(chalk2.dim("  @agentvalet/mcp-server will be fetched on first use via npx"));
+  }
+}
 function generatePermissionsFile(agentId, ownerId, permissions) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const platformSections = permissions.length === 0 ? "_No platforms approved yet. Visit https://agentvalet.ai to connect platforms._" : permissions.map((p) => {
@@ -274,7 +365,7 @@ function writePermissionsFromEvent(agentId, ownerId, platforms, outputPath = "./
   const content = generatePermissionsFile(agentId, ownerId, platforms);
   const resolvedPath = resolve2(outputPath);
   mkdirSync(dirname2(resolvedPath), { recursive: true });
-  writeFileSync(resolvedPath, content, "utf-8");
+  writeFileSync2(resolvedPath, content, "utf-8");
   embedInClaudeMd(content);
   ensureHook();
 }
@@ -285,7 +376,7 @@ async function runRefresh(options) {
       const stat = statSync(outputPath);
       const fileIsFresh = Date.now() - stat.mtimeMs < 36e5;
       const claudeMdPath = resolve2("CLAUDE.md");
-      const claudeMd = existsSync(claudeMdPath) ? readFileSync(claudeMdPath, "utf-8") : "";
+      const claudeMd = existsSync2(claudeMdPath) ? readFileSync2(claudeMdPath, "utf-8") : "";
       const blockStart = claudeMd.indexOf(CLAUDE_START);
       const blockEnd = claudeMd.indexOf(CLAUDE_END);
       const blockContent = blockStart !== -1 && blockEnd !== -1 ? claudeMd.slice(blockStart, blockEnd) : "";
@@ -297,7 +388,7 @@ async function runRefresh(options) {
   const envPath = resolve2(options.envFile);
   let envVars;
   try {
-    envVars = parseEnvFile(readFileSync(envPath, "utf-8"));
+    envVars = parseEnvFile(readFileSync2(envPath, "utf-8"));
   } catch {
     throw new Error(`Cannot read env file: ${envPath}
 Run 'agentvalet-register' first to create it.`);
@@ -311,7 +402,7 @@ Run 'agentvalet-register' first to create it.`);
   }
   let privateKeyPem;
   try {
-    privateKeyPem = readFileSync(keyPath, "utf-8");
+    privateKeyPem = readFileSync2(keyPath, "utf-8");
   } catch {
     throw new Error(`Cannot read private key: ${keyPath}`);
   }
@@ -330,7 +421,7 @@ Run 'agentvalet-register' first to create it.`);
   const platforms = json.data?.platforms ?? [];
   const content = generatePermissionsFile(agentId, ownerId, platforms);
   mkdirSync(dirname2(outputPath), { recursive: true });
-  writeFileSync(outputPath, content, "utf-8");
+  writeFileSync2(outputPath, content, "utf-8");
   embedInClaudeMd(content);
   ensureHook();
   if (!options.quiet) {
@@ -342,23 +433,23 @@ function embedInClaudeMd(permissionsContent) {
   const block = `${CLAUDE_START}
 ${permissionsContent.trimEnd()}
 ${CLAUDE_END}`;
-  if (!existsSync(claudeMdPath)) {
-    writeFileSync(claudeMdPath, `# Agent Instructions
+  if (!existsSync2(claudeMdPath)) {
+    writeFileSync2(claudeMdPath, `# Agent Instructions
 
 ${block}
 `, "utf-8");
     return;
   }
-  const existing = readFileSync(claudeMdPath, "utf-8");
+  const existing = readFileSync2(claudeMdPath, "utf-8");
   if (existing.includes(CLAUDE_START)) {
     const replaced = existing.replace(
       new RegExp(`${CLAUDE_START}[\\s\\S]*?${CLAUDE_END}`, "m"),
       block
     );
-    writeFileSync(claudeMdPath, replaced, "utf-8");
+    writeFileSync2(claudeMdPath, replaced, "utf-8");
   } else {
     const cleaned = existing.replace(/^@\.claude\/agentvalet-permissions\.md\s*$/m, "").trimEnd();
-    writeFileSync(claudeMdPath, `${cleaned}
+    writeFileSync2(claudeMdPath, `${cleaned}
 
 ${block}
 `, "utf-8");
@@ -367,9 +458,9 @@ ${block}
 function ensureHook() {
   const settingsPath = resolve2(".claude/settings.local.json");
   let settings = {};
-  if (existsSync(settingsPath)) {
+  if (existsSync2(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
     } catch {
       return;
     }
@@ -392,15 +483,15 @@ function ensureHook() {
     settings.permissions = perms;
   }
   mkdirSync(dirname2(settingsPath), { recursive: true });
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   ensureMcpJson();
 }
 function ensureMcpJson() {
   const mcpJsonPath = resolve2(".mcp.json");
   let mcpConfig = {};
-  if (existsSync(mcpJsonPath)) {
+  if (existsSync2(mcpJsonPath)) {
     try {
-      mcpConfig = JSON.parse(readFileSync(mcpJsonPath, "utf-8"));
+      mcpConfig = JSON.parse(readFileSync2(mcpJsonPath, "utf-8"));
     } catch {
       return;
     }
@@ -408,10 +499,10 @@ function ensureMcpJson() {
   const servers = mcpConfig.mcpServers ?? {};
   if (servers["agent-authority"]) return;
   const envPath = resolve2(".env.agentvalet");
-  if (!existsSync(envPath)) return;
+  if (!existsSync2(envPath)) return;
   let envVars;
   try {
-    envVars = parseEnvFile(readFileSync(envPath, "utf-8"));
+    envVars = parseEnvFile(readFileSync2(envPath, "utf-8"));
   } catch {
     return;
   }
@@ -431,18 +522,18 @@ function ensureMcpJson() {
     }
   };
   mcpConfig.mcpServers = servers;
-  writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
+  writeFileSync2(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/onboard.ts
-import chalk4 from "chalk";
+import chalk6 from "chalk";
 import ora from "ora";
-import prompts2 from "prompts";
+import prompts3 from "prompts";
 
 // src/auth/github-device-flow.ts
 import { createOAuthDeviceAuth } from "@octokit/auth-oauth-device";
 import open from "open";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 var GITHUB_CLIENT_ID = process.env.AGENTVALET_GITHUB_CLIENT_ID ?? "Ov23liXXXXXXXXXXXXXX";
 async function authenticateWithGitHub() {
   const auth = createOAuthDeviceAuth({
@@ -451,15 +542,15 @@ async function authenticateWithGitHub() {
     scopes: ["user:email", "read:user"],
     onVerification(verification) {
       console.log("");
-      console.log(chalk2.bold("  Authenticate with GitHub"));
+      console.log(chalk3.bold("  Authenticate with GitHub"));
       console.log("");
-      console.log(`  1. Open: ${chalk2.cyan.underline(verification.verification_uri)}`);
-      console.log(`  2. Enter code: ${chalk2.bold.yellow(verification.user_code)}`);
+      console.log(`  1. Open: ${chalk3.cyan.underline(verification.verification_uri)}`);
+      console.log(`  2. Enter code: ${chalk3.bold.yellow(verification.user_code)}`);
       console.log("");
       open(verification.verification_uri).catch(() => {
-        console.log(chalk2.dim("  (Could not open browser \u2014 navigate to the URL above manually)"));
+        console.log(chalk3.dim("  (Could not open browser \u2014 navigate to the URL above manually)"));
       });
-      console.log(chalk2.dim("  Waiting for authorisation..."));
+      console.log(chalk3.dim("  Waiting for authorisation..."));
     }
   });
   const tokenAuth = await auth({ type: "oauth" });
@@ -566,12 +657,12 @@ function isAuthenticated() {
 
 // src/config/local.ts
 import { mkdir as mkdir2, writeFile as writeFile2, appendFile, readFile } from "fs/promises";
-import path from "path";
+import path2 from "path";
 async function writeLocalConfig(config) {
-  const dir = path.join(process.cwd(), ".agentvalet");
+  const dir = path2.join(process.cwd(), ".agentvalet");
   await mkdir2(dir, { recursive: true });
   await writeFile2(
-    path.join(dir, "config.json"),
+    path2.join(dir, "config.json"),
     JSON.stringify({
       agent_id: config.agentId,
       agent_name: config.agentName,
@@ -581,14 +672,14 @@ async function writeLocalConfig(config) {
     { encoding: "utf8", mode: 384 }
   );
   await writeFile2(
-    path.join(dir, "agent.key"),
+    path2.join(dir, "agent.key"),
     config.privateKeyPem,
     { encoding: "utf8", mode: 384 }
   );
   if (process.platform === "win32") {
     console.warn("  Note: file permissions (0o600) are not enforced on Windows. Keep .agentvalet/ in a secure location.");
   }
-  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  const gitignorePath = path2.join(process.cwd(), ".gitignore");
   const gitignoreContent = await readFile(gitignorePath, "utf8").catch(() => null);
   if (gitignoreContent !== null) {
     const lines = gitignoreContent.split("\n").map((l) => l.trim());
@@ -599,30 +690,196 @@ async function writeLocalConfig(config) {
 }
 
 // src/output/env.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { appendFile as appendFile2, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import path2 from "path";
+import { existsSync as existsSync3 } from "fs";
+import path3 from "path";
 function formatEnvBlock(vars) {
   return Object.entries(vars).map(([key, value]) => {
     const truncated = value.length > 60 ? value.substring(0, 40) + "..." + value.substring(value.length - 10) : value;
-    return `  ${chalk3.dim(key + "=")}${chalk3.white(truncated)}`;
+    return `  ${chalk4.dim(key + "=")}${chalk4.white(truncated)}`;
   }).join("\n");
 }
 
-// src/commands/onboard.ts
+// src/config/ide.ts
+import { mkdir as mkdir3, writeFile as writeFile4, readFile as readFile2, appendFile as appendFile3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path4 from "path";
 import os from "os";
+function buildMcpEntry(params) {
+  return {
+    command: "npx",
+    args: ["-y", "@agentvalet/register", "mcp-server"],
+    env: {
+      AGENT_ID: params.agentId,
+      OWNER_ID: params.ownerId,
+      PROXY_URL: params.proxyUrl,
+      AGENT_PRIVATE_KEY_PATH: params.keyPath
+    }
+  };
+}
+async function mergeJsonFile(filePath, key, value) {
+  let existing = {};
+  if (existsSync4(filePath)) {
+    try {
+      const text = await readFile2(filePath, "utf8");
+      existing = JSON.parse(text);
+    } catch {
+    }
+  }
+  const mcpServers = existing.mcpServers ?? {};
+  mcpServers[key] = value;
+  existing.mcpServers = mcpServers;
+  await writeFile4(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+}
+async function writeGlobalFrameworkConfigs(params) {
+  const written = [];
+  const privateKeyEscaped = params.privateKeyPem.replace(/\n/g, "\\n");
+  const codexConfigPath = path4.join(os.homedir(), ".codex", "config.toml");
+  if (existsSync4(codexConfigPath)) {
+    try {
+      const existing = await readFile2(codexConfigPath, "utf8");
+      if (!existing.includes("[mcp.servers.agentvalet]")) {
+        const addition = `
+[mcp.servers.agentvalet]
+command = "npx"
+args = ["-y", "@agentvalet/mcp-server"]
+
+[mcp.servers.agentvalet.env]
+AGENT_ID = "${params.agentId}"
+OWNER_ID = "${params.ownerId}"
+PROXY_URL = "${params.proxyUrl}"
+AGENT_PRIVATE_KEY = "${privateKeyEscaped}"
+`;
+        await appendFile3(codexConfigPath, addition, "utf8");
+        written.push("~/.codex/config.toml");
+      }
+    } catch (err) {
+      console.warn(`  Warning: could not write Codex CLI config: ${err.message}`);
+    }
+  }
+  const claudeConfigPath = path4.join(os.homedir(), ".claude", "claude_desktop_config.json");
+  if (existsSync4(claudeConfigPath)) {
+    try {
+      let config = {};
+      try {
+        const text = await readFile2(claudeConfigPath, "utf8");
+        config = JSON.parse(text);
+      } catch {
+        console.warn("  Warning: ~/.claude/claude_desktop_config.json is malformed \u2014 skipping");
+        config = null;
+      }
+      if (config !== null) {
+        if (config.mcpServers?.agentvalet) {
+        } else {
+          config.mcpServers = config.mcpServers ?? {};
+          config.mcpServers.agentvalet = {
+            command: "npx",
+            args: ["-y", "@agentvalet/mcp-server"],
+            env: {
+              AGENT_ID: params.agentId,
+              OWNER_ID: params.ownerId,
+              PROXY_URL: params.proxyUrl,
+              AGENT_PRIVATE_KEY: privateKeyEscaped
+            }
+          };
+          await writeFile4(claudeConfigPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+          written.push("~/.claude/claude_desktop_config.json");
+        }
+      }
+    } catch (err) {
+      console.warn(`  Warning: could not write Claude Code global config: ${err.message}`);
+    }
+  }
+  return written;
+}
+async function writeIdeConfigs(params) {
+  const cwd = process.cwd();
+  const written = [];
+  const entry = buildMcpEntry(params);
+  const claudeMcpPath = path4.join(cwd, ".mcp.json");
+  if (existsSync4(claudeMcpPath) || existsSync4(path4.join(cwd, "CLAUDE.md"))) {
+    try {
+      await mergeJsonFile(claudeMcpPath, "agentvalet", entry);
+      written.push(".mcp.json");
+    } catch (err) {
+      console.warn(`  Warning: could not write .mcp.json: ${err.message}`);
+    }
+  }
+  const cursorDir = path4.join(cwd, ".cursor");
+  const cursorMcpPath = path4.join(cursorDir, "mcp.json");
+  if (existsSync4(cursorDir)) {
+    try {
+      await mkdir3(cursorDir, { recursive: true });
+      await mergeJsonFile(cursorMcpPath, "agentvalet", entry);
+      written.push(".cursor/mcp.json");
+    } catch (err) {
+      console.warn(`  Warning: could not write .cursor/mcp.json: ${err.message}`);
+    }
+  }
+  return written;
+}
+
+// src/config/frameworks.ts
+import { existsSync as existsSync5 } from "fs";
+import os2 from "os";
+import path5 from "path";
+import prompts2 from "prompts";
+import chalk5 from "chalk";
+function detectFrameworks() {
+  const home = os2.homedir();
+  return {
+    codex: existsSync5(path5.join(home, ".codex", "config.toml")),
+    claudeCode: existsSync5(path5.join(home, ".claude")),
+    cursor: existsSync5(path5.join(process.cwd(), ".cursor")),
+    openclaw: existsSync5(path5.join(home, ".openclaw"))
+  };
+}
+async function frameworkSetupConsent(detected) {
+  const items = [];
+  if (detected.codex) {
+    items.push("Codex CLI    \u2192 add MCP server to ~/.codex/config.toml");
+    items.push("             \u2192 copy AGENTS.md to current directory");
+  }
+  if (detected.openclaw) {
+    items.push("OpenClaw     \u2192 copy SKILL.md to current directory");
+  }
+  if (detected.claudeCode) {
+    items.push("Claude Code  \u2192 ~/.claude/claude_desktop_config.json");
+  }
+  if (detected.cursor) {
+    items.push("Cursor       \u2192 .cursor/mcp.json");
+  }
+  if (items.length === 0) return false;
+  console.log("");
+  console.log(chalk5.bold("  Agent framework setup"));
+  for (const item of items) {
+    console.log(chalk5.dim(`  ${item}`));
+  }
+  console.log("");
+  const { confirm } = await prompts2({
+    type: "confirm",
+    name: "confirm",
+    message: "Configure these automatically?",
+    initial: true
+  });
+  return confirm ?? false;
+}
+
+// src/commands/onboard.ts
+import os3 from "os";
+import path6 from "path";
 async function runOnboard() {
   console.log("");
-  console.log(chalk4.bold("  AgentValet \u2014 Agent Registration"));
-  console.log(chalk4.dim("  agentvalet.ai"));
+  console.log(chalk6.bold("  AgentValet \u2014 Agent Registration"));
+  console.log(chalk6.dim("  agentvalet.ai"));
   console.log("");
   if (isAuthenticated()) {
     const stored = getStoredConfig();
     console.log(
-      chalk4.green("  \u2713 Already authenticated as") + chalk4.bold(` ${stored.email}`)
+      chalk6.green("  \u2713 Already authenticated as") + chalk6.bold(` ${stored.email}`)
     );
-    const { action } = await prompts2({
+    const { action } = await prompts3({
       type: "select",
       name: "action",
       message: "What would you like to do?",
@@ -641,7 +898,7 @@ async function runOnboard() {
     }
     if (action === "signout") {
       clearConfig();
-      console.log(chalk4.dim("  Signed out. Run again to re-authenticate."));
+      console.log(chalk6.dim("  Signed out. Run again to re-authenticate."));
       return;
     }
     await registerAgentFlow(stored.apiKey, stored.ownerId);
@@ -653,20 +910,20 @@ async function runOnboard() {
     const result = await authenticateWithGitHub();
     githubToken = result.token;
   } catch (err) {
-    console.error(chalk4.red(`  \u2717 Authentication failed: ${err.message}`));
+    console.error(chalk6.red(`  \u2717 Authentication failed: ${err.message}`));
     process.exit(1);
   }
   spinner = ora("  Fetching your GitHub profile...").start();
   let githubUser;
   try {
     githubUser = await getGitHubUser(githubToken);
-    spinner.succeed(`  GitHub: ${chalk4.bold("@" + githubUser.login)}`);
+    spinner.succeed(`  GitHub: ${chalk6.bold("@" + githubUser.login)}`);
   } catch (err) {
     spinner.fail(`  Failed to fetch GitHub profile: ${err.message}`);
     process.exit(1);
   }
   if (!githubUser.email) {
-    const { email } = await prompts2({
+    const { email } = await prompts3({
       type: "text",
       name: "email",
       message: "Your email address (not visible on GitHub):",
@@ -707,9 +964,9 @@ async function runOnboard() {
   await registerAgentFlow(account.owner_id, account.owner_id);
 }
 async function registerAgentFlow(apiKey, ownerId) {
-  const hostname = os.hostname().split(".")[0];
+  const hostname = os3.hostname().split(".")[0];
   const dirName = process.cwd().split("/").pop() ?? process.cwd().split("\\").pop() ?? "agent";
-  const { agentName } = await prompts2({
+  const { agentName } = await prompts3({
     type: "text",
     name: "agentName",
     message: "Name for this agent:",
@@ -727,7 +984,7 @@ async function registerAgentFlow(apiKey, ownerId) {
       name: agentName.trim(),
       source: "cli"
     }, apiKey);
-    spinner.succeed(`  Agent registered: ${chalk4.bold(agent.agent_id)}`);
+    spinner.succeed(`  Agent registered: ${chalk6.bold(agent.agent_id)}`);
   } catch (err) {
     spinner.fail(`  Registration failed: ${err.message}`);
     process.exit(1);
@@ -740,37 +997,74 @@ async function registerAgentFlow(apiKey, ownerId) {
       privateKeyPem: agent.private_key_pem
     });
   } catch (err) {
-    console.error(chalk4.red(`  \u2717 Failed to write local config: ${err.message}`));
-    console.log(chalk4.dim("  Agent was registered \u2014 run again to save config locally."));
+    console.error(chalk6.red(`  \u2717 Failed to write local config: ${err.message}`));
+    console.log(chalk6.dim("  Agent was registered \u2014 run again to save config locally."));
     process.exit(1);
   }
+  const detected = detectFrameworks();
+  const shouldSetup = await frameworkSetupConsent(detected);
+  if (shouldSetup) {
+    console.log("");
+    console.log(chalk6.bold("  Configuring agent frameworks..."));
+    console.log("");
+    const ideResults = await writeIdeConfigs({
+      agentId: agent.agent_id,
+      ownerId,
+      proxyUrl: getStoredConfig().proxyUrl,
+      keyPath: path6.join(process.cwd(), ".agentvalet", "agent.key")
+    });
+    for (const r of ideResults) {
+      console.log(chalk6.green(`  \u2713 ${r}`));
+    }
+    const globalResults = await writeGlobalFrameworkConfigs({
+      agentId: agent.agent_id,
+      ownerId,
+      proxyUrl: getStoredConfig().proxyUrl,
+      privateKeyPem: agent.private_key_pem
+    });
+    for (const r of globalResults) {
+      console.log(chalk6.green(`  \u2713 ${r}`));
+    }
+    if (detected.codex) {
+      writeAgentsMd();
+    }
+    if (detected.openclaw) {
+      writeSkillMd();
+    }
+    ensureMcpServer();
+  } else if (shouldSetup === false) {
+    console.log("");
+    console.log(chalk6.dim("  To configure agent frameworks manually:"));
+    console.log(chalk6.dim("  https://docs.agentvalet.ai/setup"));
+  }
   console.log("");
-  console.log(chalk4.bold.green("  \u2713 All done!"));
+  console.log(chalk6.bold.green("  \u2713 All done!"));
   console.log("");
   console.log("  Set these in your environment:");
   console.log("");
   console.log(formatEnvBlock({
-    AGENTVALET_PROXY_URL: getStoredConfig().proxyUrl,
-    AGENTVALET_AGENT_ID: agent.agent_id,
-    AGENTVALET_PRIVATE_KEY: agent.private_key_pem.replace(/\n/g, "\\n")
+    AGENT_ID: agent.agent_id,
+    OWNER_ID: ownerId,
+    PROXY_URL: getStoredConfig().proxyUrl,
+    AGENT_PRIVATE_KEY_PATH: path6.join(process.cwd(), ".agentvalet", "agent.key")
   }));
   console.log("");
-  console.log(chalk4.dim("  Private key also saved to: .agentvalet/agent.key"));
-  console.log(chalk4.dim("  Add .agentvalet/ to your .gitignore"));
+  console.log(chalk6.dim("  Private key also saved to: .agentvalet/agent.key"));
+  console.log(chalk6.dim("  Add .agentvalet/ to your .gitignore"));
   console.log("");
   console.log(
-    `  Dashboard: ${chalk4.cyan.underline("https://app.agentvalet.ai")}`
+    `  Dashboard: ${chalk6.cyan.underline("https://app.agentvalet.ai")}`
   );
-  console.log(chalk4.dim("  Approve this agent in your dashboard to activate it."));
+  console.log(chalk6.dim("  Approve this agent in your dashboard to activate it."));
   console.log("");
 }
 function showCredentials(config) {
   console.log("");
   console.log("  Your AgentValet credentials:");
   console.log("");
-  console.log(`  Owner ID:  ${chalk4.bold(config.ownerId)}`);
-  console.log(`  Proxy URL: ${chalk4.bold(config.proxyUrl)}`);
-  console.log(`  Email:     ${chalk4.bold(config.email)}`);
+  console.log(`  Owner ID:  ${chalk6.bold(config.ownerId)}`);
+  console.log(`  Proxy URL: ${chalk6.bold(config.proxyUrl)}`);
+  console.log(`  Email:     ${chalk6.bold(config.email)}`);
   console.log("");
 }
 
@@ -805,7 +1099,7 @@ program.name("agentvalet-register").description("Self-register an AI agent with
       console.error(JSON.stringify({ error: "--owner or AGENTVALET_OWNER is required" }));
       process.exit(3);
     }
-    console.error(chalk5.red("Error: --owner or AGENTVALET_OWNER environment variable is required"));
+    console.error(chalk7.red("Error: --owner or AGENTVALET_OWNER environment variable is required"));
     process.exit(3);
   }
   const scopeMap = /* @__PURE__ */ new Map();
@@ -813,7 +1107,7 @@ program.name("agentvalet-register").description("Self-register an AI agent with
     const colon = s.indexOf(":");
     if (colon === -1) {
       console.error(
-        isJson ? JSON.stringify({ error: `Invalid scope format: ${s} (expected platform:scope)` }) : chalk5.red(`Invalid scope format: ${s} (expected platform:scope)`)
+        isJson ? JSON.stringify({ error: `Invalid scope format: ${s} (expected platform:scope)` }) : chalk7.red(`Invalid scope format: ${s} (expected platform:scope)`)
       );
       process.exit(3);
     }
@@ -836,11 +1130,11 @@ program.name("agentvalet-register").description("Self-register an AI agent with
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(isJson ? JSON.stringify({ error: msg }) : chalk5.red(`Registration failed: ${msg}`));
+    console.error(isJson ? JSON.stringify({ error: msg }) : chalk7.red(`Registration failed: ${msg}`));
     process.exit(3);
   }
   if (!isJson) {
-    console.log(chalk5.cyan(`
+    console.log(chalk7.cyan(`
 Approve at: https://agentvalet.ai/registrations
 `));
   }
@@ -848,7 +1142,7 @@ Approve at: https://agentvalet.ai/registrations
     if (isJson) {
       console.log(JSON.stringify({ status: "pending", token }));
     } else {
-      console.log(chalk5.yellow("Registration submitted (--no-wait). Token:"), token);
+      console.log(chalk7.yellow("Registration submitted (--no-wait). Token:"), token);
     }
     process.exit(0);
   }
@@ -859,14 +1153,14 @@ Approve at: https://agentvalet.ai/registrations
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(isJson ? JSON.stringify({ error: msg }) : chalk5.red(`Wait failed: ${msg}`));
+    console.error(isJson ? JSON.stringify({ error: msg }) : chalk7.red(`Wait failed: ${msg}`));
     process.exit(3);
   }
   if (result.status === "rejected") {
     if (isJson) {
       console.log(JSON.stringify({ status: "rejected" }));
     } else {
-      console.log(chalk5.red("\nRegistration denied by owner."));
+      console.log(chalk7.red("\nRegistration denied by owner."));
     }
     process.exit(1);
   }
@@ -874,7 +1168,7 @@ Approve at: https://agentvalet.ai/registrations
     if (isJson) {
       console.log(JSON.stringify({ status: "timeout" }));
     } else {
-      console.log(chalk5.yellow("\nTimed out waiting for approval."));
+      console.log(chalk7.yellow("\nTimed out waiting for approval."));
     }
     process.exit(2);
   }
@@ -893,30 +1187,30 @@ Approve at: https://agentvalet.ai/registrations
     }));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(isJson ? JSON.stringify({ error: msg }) : chalk5.red(`Failed to save output: ${msg}`));
+    console.error(isJson ? JSON.stringify({ error: msg }) : chalk7.red(`Failed to save output: ${msg}`));
     process.exit(3);
   }
   const keyWritten = !!privateKey;
   if (isJson) {
     console.log(JSON.stringify({ status: "approved", agentId, keyPath: keyWritten ? keyPath : null, envPath }));
   } else {
-    console.log(chalk5.green(`
+    console.log(chalk7.green(`
 Approved! Agent ID: ${agentId}`));
     if (keyWritten) {
-      console.log(chalk5.gray(`Key:        ${keyPath}`));
+      console.log(chalk7.gray(`Key:        ${keyPath}`));
     } else {
-      console.log(chalk5.yellow(`Key:        not written \u2014 copy it from the dashboard and paste into ${keyPath}`));
+      console.log(chalk7.yellow(`Key:        not written \u2014 copy it from the dashboard and paste into ${keyPath}`));
     }
-    console.log(chalk5.gray(`Env file:   ${envPath}`));
+    console.log(chalk7.gray(`Env file:   ${envPath}`));
     console.log(`
 Source the env file before calling any tool:`);
-    console.log(chalk5.cyan(`  source ${envPath}`));
+    console.log(chalk7.cyan(`  source ${envPath}`));
   }
   if (keyWritten) {
     try {
       if (grantedPlatforms && grantedPlatforms.length > 0) {
         writePermissionsFromEvent(agentId, resolvedOwnerId, grantedPlatforms);
-        if (!isJson) console.log(chalk5.gray(`Permissions: .claude/agentvalet-permissions.md`));
+        if (!isJson) console.log(chalk7.gray(`Permissions: .claude/agentvalet-permissions.md`));
       } else {
         await runRefresh({
           envFile: opts.output,
@@ -924,10 +1218,10 @@ Source the env file before calling any tool:`);
           ifStale: false,
           quiet: isJson
         });
-        if (!isJson) console.log(chalk5.gray(`Permissions: .claude/agentvalet-permissions.md`));
+        if (!isJson) console.log(chalk7.gray(`Permissions: .claude/agentvalet-permissions.md`));
       }
     } catch {
-      if (!isJson) console.log(chalk5.yellow(`Permissions: run 'agentvalet-register refresh' to generate`));
+      if (!isJson) console.log(chalk7.yellow(`Permissions: run 'agentvalet-register refresh' to generate`));
     }
   }
   process.exit(0);
@@ -942,7 +1236,7 @@ program.command("refresh").description("Refresh approved permissions and update
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(chalk5.red(`Refresh failed: ${msg}`));
+    console.error(chalk7.red(`Refresh failed: ${msg}`));
     process.exit(3);
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentvalet/register",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Self-register AI agents with AgentValet",
   "type": "module",
   "bin": {