@naia-team/cli 0.1.0 → 0.1.2

package/README.md

@@ -1,36 +1,42 @@
-# @naia/cli
+# @naia-team/cli
 
 Naia platform CLI for local agents (Codex, Claude Code, Claude Desktop via MCP).
 
 ## Install
 
 ```bash
-npx @naia/cli install
+npx @naia-team/cli install
 ```
 
 ## Login
 
 ```bash
-npx @naia/cli auth login --org-slug <org-slug> --webapp-url <webapp-url>
+npx @naia-team/cli auth login --org-slug <org-slug> --webapp-url <webapp-url>
+npx @naia-team/cli auth logout --profile default
 ```
 
 ## Verify
 
 ```bash
-npx @naia/cli doctor --runtime-url <runtime-url>
+npx @naia-team/cli doctor --runtime-url <runtime-url>
 ```
 
 ## Platform commands
 
 ```bash
-npx @naia/cli platform invoices list
-npx @naia/cli platform invoices create-draft --issue-date 2026-04-06 --description "CLI draft" --amount 100 --entity-id <id>
-npx @naia/cli platform invoices issue --invoice-id <id>
+npx @naia-team/cli platform invoices list
+npx @naia-team/cli platform invoices create-draft --issue-date 2026-04-06 --description "CLI draft" --amount 100 --entity-id <id>
+npx @naia-team/cli platform invoices issue --invoice-id <id>
 ```
 
 ## MCP server
 
 ```bash
-npx @naia/cli mcp serve
+npx @naia-team/cli mcp serve
 ```
 
+## Uninstall
+
+```bash
+npx @naia-team/cli uninstall
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naia-team/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "bin": {

package/src/commands/auth-login.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { URL } from "node:url";
-import { writeAuthProfile } from "../lib/auth-store.js";
+import { removeAuthProfile, writeAuthProfile } from "../lib/auth-store.js";
 import { parseArgVector } from "../lib/args.js";
 import { readCliConfig } from "../lib/config-store.js";
 
@@ -27,6 +27,18 @@ export async function runAuthLogin(args) {
   console.log(`memberId: ${callback.memberId}`);
 }
 
+export async function runAuthLogout(args) {
+  const { options } = parseArgVector(args);
+  const defaults = await readCliConfig();
+  const profile = options.profile ?? defaults.defaultProfile ?? "default";
+  const removed = await removeAuthProfile(profile);
+  if (!removed) {
+    console.log(`No auth profile found for '${profile}'.`);
+    return;
+  }
+  console.log(`Logged out profile '${profile}'.`);
+}
+
 async function waitForCallback(config, state) {
   return new Promise((resolve, reject) => {
     const server = createServer((req, res) => {
@@ -94,7 +106,7 @@ async function waitForCallback(config, state) {
 async function parseConfig(args) {
   const { options } = parseArgVector(args);
   const defaults = await readCliConfig();
-  const webappBaseUrl = options.webappUrl ?? process.env.NAIA_WEBAPP_URL ?? defaults.webappUrl ?? "http://localhost:5173";
+  const webappBaseUrl = options.webappUrl ?? process.env.NAIA_WEBAPP_URL ?? defaults.webappUrl ?? "https://app.naia.team";
   const orgSlug = options.orgSlug ?? "";
   const profile = options.profile ?? defaults.defaultProfile ?? "default";
   const timeoutMs = Number.parseInt(options.timeoutMs ?? "180000", 10);

package/src/commands/install.js

@@ -6,14 +6,31 @@ import { homedir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { parseArgVector } from "../lib/args.js";
 import { defaultCliConfig, getConfigPath, readCliConfig, writeCliConfig } from "../lib/config-store.js";
-import { getAuthStorePath } from "../lib/auth-store.js";
+import { getAuthStorePath, readAuthProfile } from "../lib/auth-store.js";
 import { buildClaudeDesktopJsonSnippet, buildCodexTomlSnippet, buildMcpServerDefinition } from "../lib/mcp-config.js";
+import { runAuthLogin } from "./auth-login.js";
 
-const INSTALL_TARGETS = [
-  { id: "codex", label: "Codex CLI" },
-  { id: "claude-code", label: "Claude Code" },
-  { id: "claude-desktop", label: "Claude Desktop" },
-  { id: "manual", label: "Manual config only" },
+const TARGETS = [
+  {
+    id: "codex",
+    label: "Codex CLI",
+    executor: { id: "codex-cli", name: "Codex", type: "agent" },
+  },
+  {
+    id: "claude-code",
+    label: "Claude Code",
+    executor: { id: "claude-code", name: "Claude Code", type: "agent" },
+  },
+  {
+    id: "claude-desktop",
+    label: "Claude Desktop",
+    executor: { id: "claude-desktop", name: "Claude Desktop", type: "agent" },
+  },
+  {
+    id: "manual",
+    label: "Manual config only",
+    executor: { id: "naia-cli", name: "Naia CLI", type: "agent" },
+  },
 ];
 
 export async function runInstall(args) {
@@ -22,53 +39,54 @@ export async function runInstall(args) {
   const current = await readCliConfig();
   const base = defaultCliConfig();
 
-  let runtimeUrl = options.runtimeUrl ?? current.runtimeUrl ?? base.runtimeUrl;
-  let webappUrl = options.webappUrl ?? current.webappUrl ?? base.webappUrl;
+  const localMode = options.local === "true";
+  let runtimeUrl = options.runtimeUrl
+    ?? (localMode ? "http://localhost:4310" : base.runtimeUrl);
+  let webappUrl = options.webappUrl
+    ?? (localMode ? "http://localhost:5173" : base.webappUrl);
   let profile = options.profile ?? current.defaultProfile ?? base.defaultProfile;
-  let executorName = options.executorName ?? current.executor.name;
-  let executorId = options.executorId ?? current.executor.id;
-  let executorType = options.executorType === "user" ? "user" : current.executor.type;
   let targets = parseTargets(options.targets);
+  const nonInteractive = options.nonInteractive === "true";
 
-  if (shouldPrompt(options, targets)) {
-    const interactive = await runInteractiveWizard({
-      runtimeUrl,
-      webappUrl,
-      profile,
-      executorName,
-      executorId,
-      executorType,
-      targets,
-    });
+  if (!nonInteractive && targets.length === 0) {
+    const interactive = await runWizard({ profile });
     runtimeUrl = interactive.runtimeUrl;
     webappUrl = interactive.webappUrl;
     profile = interactive.profile;
-    executorName = interactive.executorName;
-    executorId = interactive.executorId;
-    executorType = interactive.executorType;
     targets = interactive.targets;
   }
+  if (targets.length === 0) {
+    targets = ["manual"];
+  }
 
+  const defaultExecutor = resolveExecutor(targets[0]);
   const config = {
     ...current,
     runtimeUrl,
     webappUrl,
     defaultProfile: profile,
     executor: {
-      id: executorId,
-      name: executorName,
-      type: executorType === "user" ? "user" : "agent",
+      id: options.executorId ?? defaultExecutor.id,
+      name: options.executorName ?? defaultExecutor.name,
+      type: options.executorType === "user" ? "user" : defaultExecutor.type,
     },
   };
   await writeCliConfig(config);
 
-  const installResult = await applyIntegrationTargets(targets, config);
-  printSummary(config, targets, installResult);
-}
+  const authResult = await ensureAuthProfile({
+    profile,
+    webappUrl,
+    orgSlug: options.orgSlug,
+    nonInteractive,
+  });
 
-function shouldPrompt(options, targets) {
-  if (options.nonInteractive === "true") return false;
-  return !options.runtimeUrl && !options.webappUrl && !options.targets && targets.length === 0;
+  const installResult = await applyTargets(targets, config);
+  printSummary({
+    config,
+    targets,
+    installResult,
+    authResult,
+  });
 }
 
 function parseTargets(raw) {
@@ -76,37 +94,43 @@ function parseTargets(raw) {
   return raw
     .split(",")
     .map((item) => item.trim().toLowerCase())
-    .filter((item) => INSTALL_TARGETS.some((target) => target.id === item));
+    .filter((item) => TARGETS.some((target) => target.id === item));
 }
 
-async function runInteractiveWizard(defaults) {
+async function runWizard(defaults) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
-    console.log("Naia CLI installer");
-    console.log("");
-    const runtimeUrl = (await rl.question(`Runtime URL (${defaults.runtimeUrl}): `)).trim() || defaults.runtimeUrl;
-    const webappUrl = (await rl.question(`Webapp URL (${defaults.webappUrl}): `)).trim() || defaults.webappUrl;
-    const profile = (await rl.question(`Default profile (${defaults.profile}): `)).trim() || defaults.profile;
-    const executorName = (await rl.question(`Executor display name (${defaults.executorName}): `)).trim() || defaults.executorName;
-    const executorId = (await rl.question(`Executor id (${defaults.executorId}): `)).trim() || defaults.executorId;
-    const executorTypeInput = (await rl.question(`Executor type [agent|user] (${defaults.executorType}): `)).trim().toLowerCase();
-    const executorType = executorTypeInput === "user" ? "user" : defaults.executorType;
+    printHeader();
+    const mode = (await rl.question("Mode [1=production, 2=local] (1): ")).trim();
+    const production = mode !== "2";
+    const runtimeUrl = production ? "https://naia-agent.fly.dev" : "http://localhost:4310";
+    const webappUrl = production ? "https://app.naia.team" : "http://localhost:5173";
+    const profile = (await rl.question(`Profile name (${defaults.profile}): `)).trim() || defaults.profile;
+
+    console.log(`Runtime: ${runtimeUrl}`);
+    console.log(`Webapp:  ${webappUrl}`);
 
     console.log("");
-    console.log("Select targets (comma-separated numbers):");
-    INSTALL_TARGETS.forEach((target, index) => {
-      console.log(`${index + 1}) ${target.label}`);
+    console.log("Select agent clients (comma-separated numbers):");
+    TARGETS.forEach((target, index) => {
+      const marker = index < 2 ? "[x]" : "[ ]";
+      console.log(`  ${marker} ${index + 1}. ${target.label}`);
     });
-    const selection = (await rl.question("Targets (1,2): ")).trim();
-    const targets = parseTargetSelection(selection);
+    const rawSelection = (await rl.question("Targets (default 1,2): ")).trim();
+    const targets = parseTargetSelection(rawSelection || "1,2");
+
+    console.log("");
+    console.log("Selected:");
+    for (const target of targets) {
+      const meta = TARGETS.find((item) => item.id === target);
+      if (!meta) continue;
+      console.log(`  [x] ${meta.label} -> ${meta.executor.name} (${meta.executor.id})`);
+    }
 
     return {
       runtimeUrl,
       webappUrl,
       profile,
-      executorName,
-      executorId,
-      executorType,
       targets: targets.length > 0 ? targets : ["manual"],
     };
   } finally {
@@ -115,47 +139,104 @@ async function runInteractiveWizard(defaults) {
 }
 
 function parseTargetSelection(input) {
-  if (!input) return [];
   const picked = new Set();
   for (const token of input.split(",")) {
     const index = Number.parseInt(token.trim(), 10);
-    if (!Number.isFinite(index) || index < 1 || index > INSTALL_TARGETS.length) continue;
-    picked.add(INSTALL_TARGETS[index - 1].id);
+    if (!Number.isFinite(index) || index < 1 || index > TARGETS.length) continue;
+    picked.add(TARGETS[index - 1].id);
   }
   return [...picked];
 }
 
-async function applyIntegrationTargets(targets, config) {
+function printHeader() {
+  console.log("╔═══════════════════════════════════════╗");
+  console.log("║         Naia CLI Installer            ║");
+  console.log("║   Connect Codex/Claude to Naia MCP    ║");
+  console.log("╚═══════════════════════════════════════╝");
+  console.log("");
+}
+
+function resolveExecutor(target) {
+  return TARGETS.find((item) => item.id === target)?.executor ?? TARGETS[0].executor;
+}
+
+async function ensureAuthProfile(input) {
+  const existing = await readAuthProfile(input.profile);
+  if (existing) {
+    return {
+      status: "existing",
+      profile: input.profile,
+      organizationId: existing.organizationId,
+      memberId: existing.memberId,
+    };
+  }
+  if (input.nonInteractive) {
+    return {
+      status: "missing",
+      profile: input.profile,
+    };
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question("No login for this profile. Login now? [Y/n]: ")).trim().toLowerCase();
+    if (answer === "n" || answer === "no") {
+      return {
+        status: "missing",
+        profile: input.profile,
+      };
+    }
+    const orgSlug = (input.orgSlug ?? (await rl.question("Organization slug: ")).trim());
+    if (!orgSlug) {
+      return {
+        status: "missing",
+        profile: input.profile,
+      };
+    }
+    await runAuthLogin(["--profile", input.profile, "--org-slug", orgSlug, "--webapp-url", input.webappUrl]);
+    const fresh = await readAuthProfile(input.profile);
+    if (!fresh) {
+      return { status: "missing", profile: input.profile };
+    }
+    return {
+      status: "created",
+      profile: input.profile,
+      organizationId: fresh.organizationId,
+      memberId: fresh.memberId,
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+async function applyTargets(targets, config) {
   const result = [];
-  const selected = targets.length > 0 ? targets : ["manual"];
-  for (const target of selected) {
+  for (const target of targets) {
+    const executor = resolveExecutor(target);
     if (target === "codex") {
-      result.push(await installCodex(config));
+      result.push(await installCodex(config.runtimeUrl, executor));
       continue;
     }
     if (target === "claude-code") {
-      result.push(await installClaudeCode(config));
+      result.push(await installClaudeCode(config.runtimeUrl, executor));
       continue;
     }
     if (target === "claude-desktop") {
-      result.push(await installClaudeDesktop(config));
-      continue;
-    }
-    if (target === "manual") {
-      result.push({ target, status: "manual", detail: "No file changes applied." });
+      result.push(await installClaudeDesktop(config.runtimeUrl, executor));
       continue;
     }
+    result.push({ target: "manual", status: "manual", detail: "No file changes applied.", executor });
   }
   return result;
 }
 
-async function installCodex(config) {
+async function installCodex(runtimeUrl, executor) {
   const filePath = join(homedir(), ".codex", "config.toml");
   const snippet = buildCodexTomlSnippet({
-    runtimeUrl: config.runtimeUrl,
-    executorName: config.executor.name,
-    executorId: config.executor.id,
-    executorType: config.executor.type,
+    runtimeUrl,
+    executorName: executor.name,
+    executorId: executor.id,
+    executorType: executor.type,
   });
   await ensureDir(dirname(filePath));
   const existing = existsSync(filePath) ? await readFile(filePath, "utf8") : "";
@@ -165,10 +246,10 @@ async function installCodex(config) {
     await backupFile(filePath);
   }
   await writeFile(filePath, merged, "utf8");
-  return { target: "codex", status: "updated", detail: filePath };
+  return { target: "codex", status: "updated", detail: filePath, executor };
 }
 
-async function installClaudeDesktop(config) {
+async function installClaudeDesktop(runtimeUrl, executor) {
   const filePath = resolveClaudeDesktopPath();
   await ensureDir(dirname(filePath));
   const existing = existsSync(filePath) ? JSON.parse(await readFile(filePath, "utf8")) : {};
@@ -176,38 +257,64 @@ async function installClaudeDesktop(config) {
     existing.mcpServers = {};
   }
   existing.mcpServers.naia = buildMcpServerDefinition({
-    runtimeUrl: config.runtimeUrl,
-    executorName: config.executor.name,
-    executorId: config.executor.id,
-    executorType: config.executor.type,
+    runtimeUrl,
+    executorName: executor.name,
+    executorId: executor.id,
+    executorType: executor.type,
   });
   if (existsSync(filePath)) {
     await backupFile(filePath);
   }
   await writeFile(filePath, JSON.stringify(existing, null, 2), "utf8");
-  return { target: "claude-desktop", status: "updated", detail: filePath };
+  return { target: "claude-desktop", status: "updated", detail: filePath, executor };
 }
 
-async function installClaudeCode(config) {
-  const env = {
-    ...process.env,
-    NAIA_RUNTIME_URL: config.runtimeUrl,
-    NAIA_EXECUTOR_NAME: config.executor.name,
-    NAIA_EXECUTOR_ID: config.executor.id,
-    NAIA_EXECUTOR_TYPE: config.executor.type,
-  };
-  const result = spawnSync("claude", ["mcp", "add", "naia", "--", "naia", "mcp", "serve"], {
+async function installClaudeCode(runtimeUrl, executor) {
+  const remove = spawnSync("claude", ["mcp", "remove", "-s", "user", "naia"], {
     stdio: "pipe",
     encoding: "utf8",
-    env,
   });
-  if (result.status === 0) {
-    return { target: "claude-code", status: "updated", detail: "Registered with `claude mcp add`." };
+  const definition = {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@naia-team/cli", "mcp", "serve"],
+    env: {
+      NAIA_RUNTIME_URL: runtimeUrl,
+      NAIA_EXECUTOR_NAME: executor.name,
+      NAIA_EXECUTOR_ID: executor.id,
+      NAIA_EXECUTOR_TYPE: executor.type,
+    },
+  };
+  const add = spawnSync(
+    "claude",
+    [
+      "mcp",
+      "add-json",
+      "-s",
+      "user",
+      "naia",
+      JSON.stringify(definition),
+    ],
+    {
+      stdio: "pipe",
+      encoding: "utf8",
+      env: process.env,
+    }
+  );
+  if (add.status === 0) {
+    return {
+      target: "claude-code",
+      status: "updated",
+      detail: "Registered with `claude mcp add -s user`.",
+      executor,
+      notes: remove.status === 0 ? "Replaced existing naia MCP server." : undefined,
+    };
   }
   return {
     target: "claude-code",
     status: "manual",
-    detail: "Could not run `claude mcp add`. Run manually:\nclaude mcp add naia -- naia mcp serve",
+    detail: "Could not run `claude mcp add`. Run manually:\nclaude mcp add -s user -e NAIA_RUNTIME_URL=... -e NAIA_EXECUTOR_NAME=... -e NAIA_EXECUTOR_ID=... -e NAIA_EXECUTOR_TYPE=agent naia -- npx -y @naia-team/cli mcp serve",
+    executor,
   };
 }
 
@@ -251,46 +358,64 @@ async function backupFile(path) {
   await copyFile(path, `${path}.${timestamp}.bak`);
 }
 
-function printSummary(config, targets, installResult) {
+function printSummary(input) {
   const configPath = getConfigPath();
   const authPath = getAuthStorePath();
 
-  console.log("Naia CLI install completed.");
-  console.log(`config: ${configPath}`);
-  console.log(`auth store: ${authPath}`);
   console.log("");
-  console.log("Configured values:");
-  console.log(`- runtime: ${config.runtimeUrl}`);
-  console.log(`- webapp: ${config.webappUrl}`);
-  console.log(`- profile: ${config.defaultProfile}`);
-  console.log(`- executor: ${config.executor.name} (${config.executor.id}, ${config.executor.type})`);
+  console.log("Install completed.");
+  console.log(`- config: ${configPath}`);
+  console.log(`- auth store: ${authPath}`);
+  console.log("");
+  console.log("Runtime profile:");
+  console.log(`- runtime: ${input.config.runtimeUrl}`);
+  console.log(`- webapp: ${input.config.webappUrl}`);
+  console.log(`- profile: ${input.config.defaultProfile}`);
+  console.log(`- default executor: ${input.config.executor.name} (${input.config.executor.id}, ${input.config.executor.type})`);
+
+  if (input.authResult.status === "existing" || input.authResult.status === "created") {
+    console.log("");
+    console.log("Auth:");
+    console.log(`- status: ${input.authResult.status}`);
+    console.log(`- organizationId: ${input.authResult.organizationId}`);
+    console.log(`- memberId: ${input.authResult.memberId}`);
+  } else {
+    console.log("");
+    console.log("Auth:");
+    console.log("- status: missing (run auth login before using platform commands)");
+  }
+
   console.log("");
-  console.log(`Targets: ${(targets.length > 0 ? targets : ["manual"]).join(", ")}`);
-  for (const item of installResult) {
-    console.log(`- ${item.target}: ${item.status}${item.detail ? ` -> ${item.detail}` : ""}`);
+  console.log("Targets:");
+  for (const item of input.installResult) {
+    console.log(`- ${item.target}: ${item.status} -> ${item.detail}`);
+    console.log(`  executor: ${item.executor.name} (${item.executor.id}, ${item.executor.type})`);
+    if (item.notes) {
+      console.log(`  note: ${item.notes}`);
+    }
   }
+
   console.log("");
   console.log("Next steps:");
-  console.log(`1) naia auth login --org-slug <orgSlug> --webapp-url ${config.webappUrl}`);
-  console.log(`2) naia doctor --runtime-url ${config.runtimeUrl}`);
-  console.log(`3) naia platform invoices list --runtime-url ${config.runtimeUrl}`);
+  console.log("1) npx @naia-team/cli doctor");
+  console.log("2) npx @naia-team/cli platform invoices list");
+  console.log("3) In Claude Code run: /mcp (verify server `naia` is enabled)");
   console.log("");
   console.log("Manual snippets:");
   console.log("");
   console.log("Codex (~/.codex/config.toml):");
   console.log(buildCodexTomlSnippet({
-    runtimeUrl: config.runtimeUrl,
-    executorName: config.executor.name,
-    executorId: config.executor.id,
-    executorType: config.executor.type,
+    runtimeUrl: input.config.runtimeUrl,
+    executorName: resolveExecutor("codex").name,
+    executorId: resolveExecutor("codex").id,
+    executorType: resolveExecutor("codex").type,
   }));
   console.log("");
   console.log("Claude Desktop (claude_desktop_config.json):");
   console.log(buildClaudeDesktopJsonSnippet({
-    runtimeUrl: config.runtimeUrl,
-    executorName: config.executor.name,
-    executorId: config.executor.id,
-    executorType: config.executor.type,
+    runtimeUrl: input.config.runtimeUrl,
+    executorName: resolveExecutor("claude-desktop").name,
+    executorId: resolveExecutor("claude-desktop").id,
+    executorType: resolveExecutor("claude-desktop").type,
   }));
 }
-

package/src/commands/session-run.js

@@ -61,7 +61,7 @@ async function parseConfig(args) {
   const profile = options.profile ?? defaults.defaultProfile ?? "default";
   const stored = await readAuthProfile(profile);
 
-  const runtimeUrl = (options.runtimeUrl ?? process.env.NAIA_RUNTIME_URL ?? defaults.runtimeUrl ?? "http://localhost:4310").replace(/\/+$/, "");
+  const runtimeUrl = (options.runtimeUrl ?? process.env.NAIA_RUNTIME_URL ?? defaults.runtimeUrl ?? "https://naia-agent.fly.dev").replace(/\/+$/, "");
   const organizationId = options.organizationId ?? process.env.NAIA_ORGANIZATION_ID ?? stored?.organizationId ?? "";
   const memberId = options.memberId ?? process.env.NAIA_MEMBER_ID ?? stored?.memberId ?? "";
   const bearerToken = options.token ?? process.env.NAIA_BEARER_TOKEN ?? stored?.token;
@@ -247,4 +247,3 @@ function log(message) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-

package/src/commands/uninstall.js

@@ -0,0 +1,127 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile, copyFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { parseArgVector } from "../lib/args.js";
+import { ensureDir } from "./utils.js";
+
+const ALL_TARGETS = ["codex", "claude-code", "claude-desktop"];
+
+export async function runUninstall(args) {
+  const { options } = parseArgVector(args);
+  const targets = parseTargets(options.targets);
+  const selected = targets.length > 0 ? targets : ALL_TARGETS;
+  const results = [];
+
+  for (const target of selected) {
+    if (target === "codex") {
+      results.push(await uninstallCodex());
+      continue;
+    }
+    if (target === "claude-code") {
+      results.push(await uninstallClaudeCode());
+      continue;
+    }
+    if (target === "claude-desktop") {
+      results.push(await uninstallClaudeDesktop());
+      continue;
+    }
+  }
+
+  console.log("Naia CLI uninstall completed.");
+  for (const item of results) {
+    console.log(`- ${item.target}: ${item.status}${item.detail ? ` -> ${item.detail}` : ""}`);
+  }
+  console.log("");
+  console.log("Optional cleanup:");
+  console.log("- npx @naia-team/cli auth logout --profile default");
+}
+
+function parseTargets(raw) {
+  if (!raw) return [];
+  return raw
+    .split(",")
+    .map((item) => item.trim().toLowerCase())
+    .filter((item) => ALL_TARGETS.includes(item));
+}
+
+async function uninstallCodex() {
+  const filePath = join(homedir(), ".codex", "config.toml");
+  if (!existsSync(filePath)) {
+    return { target: "codex", status: "skipped", detail: "No ~/.codex/config.toml" };
+  }
+  const existing = await readFile(filePath, "utf8");
+  const cleaned = stripCodexNaiaBlock(existing);
+  if (cleaned === existing) {
+    return { target: "codex", status: "skipped", detail: "No naia MCP block found." };
+  }
+  await backupFile(filePath);
+  await writeFile(filePath, cleaned.trimEnd() + "\n", "utf8");
+  return { target: "codex", status: "removed", detail: filePath };
+}
+
+async function uninstallClaudeCode() {
+  const remove = await import("node:child_process").then(({ spawnSync }) =>
+    spawnSync("claude", ["mcp", "remove", "-s", "user", "naia"], {
+      stdio: "pipe",
+      encoding: "utf8",
+    })
+  );
+  if (remove.status === 0) {
+    return { target: "claude-code", status: "removed", detail: "Removed user-scope MCP server 'naia'." };
+  }
+  return { target: "claude-code", status: "skipped", detail: "Could not remove (not configured or CLI unavailable)." };
+}
+
+async function uninstallClaudeDesktop() {
+  const filePath = resolveClaudeDesktopPath();
+  if (!existsSync(filePath)) {
+    return { target: "claude-desktop", status: "skipped", detail: "No desktop config file found." };
+  }
+  const existing = JSON.parse(await readFile(filePath, "utf8"));
+  if (!existing?.mcpServers?.naia) {
+    return { target: "claude-desktop", status: "skipped", detail: "No naia MCP server found." };
+  }
+  delete existing.mcpServers.naia;
+  await ensureDir(dirname(filePath));
+  await backupFile(filePath);
+  await writeFile(filePath, JSON.stringify(existing, null, 2), "utf8");
+  return { target: "claude-desktop", status: "removed", detail: filePath };
+}
+
+function resolveClaudeDesktopPath() {
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+    return join(appData, "Claude", "claude_desktop_config.json");
+  }
+  return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+
+function stripCodexNaiaBlock(source) {
+  const lines = source.split("\n");
+  const result = [];
+  let skipping = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "[mcp_servers.naia]" || trimmed === "[mcp_servers.naia.env]") {
+      skipping = true;
+      continue;
+    }
+    if (skipping && trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      skipping = false;
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+
+async function backupFile(path) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  await copyFile(path, `${path}.${timestamp}.bak`);
+}
+

package/src/commands/utils.js

@@ -0,0 +1,6 @@
+import { mkdir } from "node:fs/promises";
+
+export async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+

package/src/lib/auth-store.js

@@ -39,6 +39,34 @@ export async function writeAuthProfile(input) {
   await writeFile(filePath, JSON.stringify(next, null, 2), { mode: 0o600 });
 }
 
+export async function removeAuthProfile(profile = "default") {
+  const filePath = getAuthStorePath();
+  const existing = await readStore(filePath);
+  if (!existing?.profiles || typeof existing.profiles !== "object") {
+    return false;
+  }
+  const resolvedProfile = profile === "default"
+    ? (existing.defaultProfile || "default")
+    : profile;
+  if (!existing.profiles[resolvedProfile]) {
+    return false;
+  }
+  const nextProfiles = { ...existing.profiles };
+  delete nextProfiles[resolvedProfile];
+
+  const nextDefault = existing.defaultProfile === resolvedProfile
+    ? (Object.keys(nextProfiles)[0] ?? "default")
+    : (existing.defaultProfile || "default");
+
+  const next = {
+    defaultProfile: nextDefault,
+    profiles: nextProfiles,
+  };
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(next, null, 2), { mode: 0o600 });
+  return true;
+}
+
 async function readStore(filePath) {
   try {
     const raw = await readFile(filePath, "utf8");

package/src/lib/config-store.js

@@ -4,8 +4,8 @@ import { homedir } from "node:os";
 
 const DEFAULT_CONFIG = {
   defaultProfile: "default",
-  runtimeUrl: "http://localhost:4310",
-  webappUrl: "http://localhost:5173",
+  runtimeUrl: "https://naia-agent.fly.dev",
+  webappUrl: "https://app.naia.team",
   executor: {
     id: "naia-cli",
     name: "CLI",

package/src/lib/mcp-config.js

@@ -1,7 +1,7 @@
 export function buildMcpServerDefinition(input) {
   return {
-    command: "naia",
-    args: ["mcp", "serve"],
+    command: "npx",
+    args: ["-y", "@naia-team/cli", "mcp", "serve"],
     env: {
       NAIA_RUNTIME_URL: input.runtimeUrl,
       NAIA_EXECUTOR_NAME: input.executorName,
@@ -14,8 +14,8 @@ export function buildMcpServerDefinition(input) {
 export function buildCodexTomlSnippet(input) {
   return [
     `[mcp_servers.naia]`,
-    `command = "naia"`,
-    `args = ["mcp", "serve"]`,
+    `command = "npx"`,
+    `args = ["-y", "@naia-team/cli", "mcp", "serve"]`,
     `[mcp_servers.naia.env]`,
     `NAIA_RUNTIME_URL = "${input.runtimeUrl}"`,
     `NAIA_EXECUTOR_NAME = "${input.executorName}"`,
@@ -31,4 +31,3 @@ export function buildClaudeDesktopJsonSnippet(input) {
     },
   }, null, 2);
 }
-

package/src/main.js

@@ -1,9 +1,10 @@
-import { runAuthLogin } from "./commands/auth-login.js";
+import { runAuthLogin, runAuthLogout } from "./commands/auth-login.js";
 import { runInstall } from "./commands/install.js";
 import { runDoctor } from "./commands/doctor.js";
 import { runPlatform } from "./commands/platform.js";
 import { runMcpServe } from "./commands/mcp-serve.js";
 import { runSession } from "./commands/session-run.js";
+import { runUninstall } from "./commands/uninstall.js";
 
 export async function main() {
   const args = process.argv.slice(2);
@@ -17,10 +18,18 @@ export async function main() {
     await runAuthLogin(rest);
     return;
   }
+  if (group === "auth" && action === "logout") {
+    await runAuthLogout(rest);
+    return;
+  }
   if (group === "install") {
     await runInstall([action, ...rest].filter(Boolean));
     return;
   }
+  if (group === "uninstall") {
+    await runUninstall([action, ...rest].filter(Boolean));
+    return;
+  }
   if (group === "doctor") {
     await runDoctor([action, ...rest].filter(Boolean));
     return;
@@ -48,12 +57,13 @@ export async function main() {
 
 function printUsage() {
   console.log(`Usage:
-  naia install [--runtime-url <url>] [--webapp-url <url>] [--targets codex,claude-code]
+  naia install [--targets codex,claude-code,claude-desktop,manual] [--local true]
+  naia uninstall [--targets codex,claude-code,claude-desktop]
   naia doctor [--runtime-url <url>] [--profile default]
   naia auth login --org-slug <slug> [--webapp-url <url>] [--profile default]
+  naia auth logout [--profile default]
   naia session run --message "hola" [--runtime-url <url>]
   naia platform invoices list [--runtime-url <url>]
   naia mcp serve
 `);
 }
-