@waniwani/cli 0.0.5

package/dist/index.js

@@ -0,0 +1,1234 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command15 } from "commander";
+
+// src/commands/login.ts
+import { spawn } from "child_process";
+import { createServer } from "http";
+import chalk3 from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+
+// src/lib/auth.ts
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+var CONFIG_DIR = join(homedir(), ".waniwani");
+var AUTH_FILE = join(CONFIG_DIR, "auth.json");
+var AuthStoreSchema = z.object({
+  accessToken: z.string().nullable().default(null),
+  refreshToken: z.string().nullable().default(null),
+  expiresAt: z.string().nullable().default(null)
+});
+var API_BASE_URL = process.env.WANIWANI_API_URL || "https://waniwani.com";
+async function ensureConfigDir() {
+  await mkdir(CONFIG_DIR, { recursive: true });
+}
+async function readAuthStore() {
+  await ensureConfigDir();
+  try {
+    await access(AUTH_FILE);
+    const content = await readFile(AUTH_FILE, "utf-8");
+    return AuthStoreSchema.parse(JSON.parse(content));
+  } catch {
+    return AuthStoreSchema.parse({});
+  }
+}
+async function writeAuthStore(store) {
+  await ensureConfigDir();
+  await writeFile(AUTH_FILE, JSON.stringify(store, null, 2), "utf-8");
+}
+var AuthManager = class {
+  storeCache = null;
+  async getStore() {
+    if (!this.storeCache) {
+      this.storeCache = await readAuthStore();
+    }
+    return this.storeCache;
+  }
+  async saveStore(store) {
+    this.storeCache = store;
+    await writeAuthStore(store);
+  }
+  async isLoggedIn() {
+    const store = await this.getStore();
+    return !!store.accessToken;
+  }
+  async getAccessToken() {
+    const store = await this.getStore();
+    return store.accessToken;
+  }
+  async getRefreshToken() {
+    const store = await this.getStore();
+    return store.refreshToken;
+  }
+  async setTokens(accessToken, refreshToken, expiresIn) {
+    const expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
+    const store = await this.getStore();
+    store.accessToken = accessToken;
+    store.refreshToken = refreshToken;
+    store.expiresAt = expiresAt;
+    await this.saveStore(store);
+  }
+  async clear() {
+    const emptyStore = AuthStoreSchema.parse({});
+    await this.saveStore(emptyStore);
+  }
+  async isTokenExpired() {
+    const store = await this.getStore();
+    if (!store.expiresAt) return true;
+    return new Date(store.expiresAt).getTime() - 5 * 60 * 1e3 < Date.now();
+  }
+  async tryRefreshToken() {
+    const refreshToken = await this.getRefreshToken();
+    if (!refreshToken) return false;
+    try {
+      const response = await fetch(`${API_BASE_URL}/api/auth/oauth2/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: refreshToken,
+          client_id: "waniwani-cli"
+        }).toString()
+      });
+      if (!response.ok) {
+        await this.clear();
+        return false;
+      }
+      const data = await response.json();
+      await this.setTokens(
+        data.access_token,
+        data.refresh_token,
+        data.expires_in
+      );
+      return true;
+    } catch {
+      await this.clear();
+      return false;
+    }
+  }
+};
+var auth = new AuthManager();
+
+// src/lib/errors.ts
+import chalk from "chalk";
+import { ZodError } from "zod";
+var CLIError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "CLIError";
+  }
+};
+var AuthError = class extends CLIError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", details);
+  }
+};
+var SandboxError = class extends CLIError {
+  constructor(message, details) {
+    super(message, "SANDBOX_ERROR", details);
+  }
+};
+var McpError = class extends CLIError {
+  constructor(message, details) {
+    super(message, "MCP_ERROR", details);
+  }
+};
+function handleError(error, json) {
+  if (error instanceof ZodError) {
+    const message = error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    outputError("VALIDATION_ERROR", `Invalid input: ${message}`, json);
+  } else if (error instanceof CLIError) {
+    outputError(error.code, error.message, json, error.details);
+  } else if (error instanceof Error) {
+    outputError("UNKNOWN_ERROR", error.message, json);
+  } else {
+    outputError("UNKNOWN_ERROR", String(error), json);
+  }
+}
+function outputError(code, message, json, details) {
+  if (json) {
+    console.error(
+      JSON.stringify({ success: false, error: { code, message, details } })
+    );
+  } else {
+    console.error(chalk.red(`Error [${code}]:`), message);
+    if (details) {
+      console.error(chalk.gray("Details:"), JSON.stringify(details, null, 2));
+    }
+  }
+}
+
+// src/lib/output.ts
+import chalk2 from "chalk";
+function formatOutput(data, json) {
+  if (json) {
+    console.log(JSON.stringify({ success: true, data }, null, 2));
+  } else {
+    prettyPrint(data);
+  }
+}
+function formatSuccess(message, json) {
+  if (json) {
+    console.log(JSON.stringify({ success: true, message }));
+  } else {
+    console.log(chalk2.green("\u2713"), message);
+  }
+}
+function formatTable(headers, rows, json) {
+  if (json) {
+    const data = rows.map(
+      (row) => Object.fromEntries(headers.map((header, i) => [header, row[i]]))
+    );
+    console.log(JSON.stringify({ success: true, data }, null, 2));
+  } else {
+    const colWidths = headers.map(
+      (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length))
+    );
+    const separator = colWidths.map((w) => "-".repeat(w + 2)).join("+");
+    const formatRow = (row) => row.map((cell, i) => ` ${(cell || "").padEnd(colWidths[i])} `).join("|");
+    console.log(chalk2.cyan(formatRow(headers)));
+    console.log(separator);
+    for (const row of rows) {
+      console.log(formatRow(row));
+    }
+  }
+}
+function formatList(items, json) {
+  if (json) {
+    const data = Object.fromEntries(
+      items.map((item) => [item.label, item.value])
+    );
+    console.log(JSON.stringify({ success: true, data }, null, 2));
+  } else {
+    const maxLabelLength = Math.max(...items.map((i) => i.label.length));
+    items.forEach((item) => {
+      console.log(
+        `${chalk2.gray(item.label.padEnd(maxLabelLength))}  ${chalk2.white(item.value)}`
+      );
+    });
+  }
+}
+function prettyPrint(data, indent = 0) {
+  const prefix = "  ".repeat(indent);
+  if (Array.isArray(data)) {
+    data.forEach((item, index) => {
+      console.log(`${prefix}${chalk2.gray(`[${index}]`)}`);
+      prettyPrint(item, indent + 1);
+    });
+  } else if (typeof data === "object" && data !== null) {
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value === "object" && value !== null) {
+        console.log(`${prefix}${chalk2.gray(key)}:`);
+        prettyPrint(value, indent + 1);
+      } else {
+        console.log(
+          `${prefix}${chalk2.gray(key)}: ${chalk2.white(String(value))}`
+        );
+      }
+    }
+  } else {
+    console.log(`${prefix}${chalk2.white(String(data))}`);
+  }
+}
+
+// src/commands/login.ts
+var API_BASE_URL2 = process.env.WANIWANI_API_URL || "https://waniwani.com";
+var CALLBACK_PORT = 54321;
+var CALLBACK_URL = `http://localhost:${CALLBACK_PORT}/callback`;
+var CLIENT_ID = "waniwani-cli";
+function generateCodeVerifier() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  return btoa(String.fromCharCode(...array)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return btoa(String.fromCharCode(...new Uint8Array(hash))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function generateState() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function openBrowser(url) {
+  const [cmd, ...args] = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", url] : ["xdg-open", url];
+  spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+}
+async function waitForCallback(expectedState, timeoutMs = 3e5) {
+  return new Promise((resolve, reject) => {
+    let server = null;
+    const timeout = setTimeout(() => {
+      server?.close();
+      reject(new CLIError("Login timed out", "LOGIN_TIMEOUT"));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      server?.close();
+    };
+    const htmlResponse = (title, message, color) => `<html>
+        <body style="font-family: system-ui; padding: 40px; text-align: center;">
+          <h1 style="color: ${color};">${title}</h1>
+          <p>${message}</p>
+          <p>You can close this window.</p>
+        </body>
+      </html>`;
+    try {
+      server = createServer((req, res) => {
+        const url = new URL(
+          req.url || "/",
+          `http://localhost:${CALLBACK_PORT}`
+        );
+        if (url.pathname === "/callback") {
+          const code = url.searchParams.get("code");
+          const state = url.searchParams.get("state");
+          const error = url.searchParams.get("error");
+          res.setHeader("Content-Type", "text/html");
+          if (error) {
+            res.statusCode = 400;
+            res.end(htmlResponse("Login Failed", `Error: ${error}`, "#ef4444"));
+            cleanup();
+            reject(new CLIError(`OAuth error: ${error}`, "OAUTH_ERROR"));
+            return;
+          }
+          if (state !== expectedState) {
+            res.statusCode = 400;
+            res.end(
+              htmlResponse(
+                "Login Failed",
+                "Invalid state parameter. Please try again.",
+                "#ef4444"
+              )
+            );
+            cleanup();
+            reject(new CLIError("Invalid state parameter", "INVALID_STATE"));
+            return;
+          }
+          if (!code) {
+            res.statusCode = 400;
+            res.end(
+              htmlResponse(
+                "Login Failed",
+                "No authorization code received.",
+                "#ef4444"
+              )
+            );
+            cleanup();
+            reject(new CLIError("No authorization code", "NO_CODE"));
+            return;
+          }
+          res.statusCode = 200;
+          res.end(
+            htmlResponse(
+              "Login Successful!",
+              "You can close this window and return to the terminal.",
+              "#22c55e"
+            )
+          );
+          setTimeout(() => {
+            cleanup();
+            resolve(code);
+          }, 100);
+          return;
+        }
+        res.statusCode = 404;
+        res.end("Not found");
+      });
+      server.on("error", (err) => {
+        cleanup();
+        if (err.code === "EADDRINUSE") {
+          reject(
+            new CLIError(
+              `Port ${CALLBACK_PORT} is already in use. Close any other WaniWani CLI instances and try again.`,
+              "PORT_IN_USE"
+            )
+          );
+        } else {
+          reject(err);
+        }
+      });
+      server.listen(CALLBACK_PORT);
+    } catch (err) {
+      cleanup();
+      reject(err);
+    }
+  });
+}
+async function exchangeCodeForToken(code, codeVerifier) {
+  const response = await fetch(`${API_BASE_URL2}/api/auth/oauth2/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: CALLBACK_URL,
+      client_id: CLIENT_ID,
+      code_verifier: codeVerifier
+    }).toString()
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new CLIError(
+      error.error_description || "Failed to exchange code for token",
+      "TOKEN_EXCHANGE_FAILED"
+    );
+  }
+  return response.json();
+}
+var loginCommand = new Command("login").description("Log in to WaniWani").option("--no-browser", "Don't open the browser automatically").action(async (options, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    if (await auth.isLoggedIn()) {
+      if (json) {
+        formatOutput({ alreadyLoggedIn: true }, true);
+      } else {
+        console.log(
+          chalk3.yellow(
+            "Already logged in. Use 'waniwani logout' to log out first."
+          )
+        );
+      }
+      return;
+    }
+    if (!json) {
+      console.log(chalk3.bold("\nWaniWani CLI Login\n"));
+    }
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = await generateCodeChallenge(codeVerifier);
+    const state = generateState();
+    const authUrl = new URL(`${API_BASE_URL2}/oauth/authorize`);
+    authUrl.searchParams.set("client_id", CLIENT_ID);
+    authUrl.searchParams.set("redirect_uri", CALLBACK_URL);
+    authUrl.searchParams.set("response_type", "code");
+    authUrl.searchParams.set("code_challenge", codeChallenge);
+    authUrl.searchParams.set("code_challenge_method", "S256");
+    authUrl.searchParams.set("state", state);
+    if (!json) {
+      console.log("Opening browser for authentication...\n");
+      console.log(`If the browser doesn't open, visit:
+`);
+      console.log(chalk3.cyan(`  ${authUrl.toString()}`));
+      console.log();
+    }
+    const callbackPromise = waitForCallback(state);
+    if (options.browser !== false) {
+      await openBrowser(authUrl.toString());
+    }
+    const spinner = ora("Waiting for authorization...").start();
+    const code = await callbackPromise;
+    spinner.text = "Exchanging code for token...";
+    const tokenResponse = await exchangeCodeForToken(code, codeVerifier);
+    await auth.setTokens(
+      tokenResponse.access_token,
+      tokenResponse.refresh_token,
+      tokenResponse.expires_in
+    );
+    spinner.succeed("Logged in successfully!");
+    if (json) {
+      formatOutput({ success: true, loggedIn: true }, true);
+    } else {
+      console.log();
+      formatSuccess("You're now logged in to WaniWani!", false);
+      console.log();
+      console.log("Get started:");
+      console.log(
+        "  waniwani mcp create my-server    Create a new MCP sandbox"
+      );
+      console.log('  waniwani task "Add a tool"       Send tasks to Claude');
+      console.log(
+        "  waniwani org list                View your organizations"
+      );
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/config.ts
+import { access as access2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+var CONFIG_DIR2 = join2(homedir2(), ".waniwani");
+var CONFIG_FILE = join2(CONFIG_DIR2, "config.json");
+var ConfigSchema = z2.object({
+  defaults: z2.object({
+    model: z2.string().default("claude-sonnet-4-20250514"),
+    maxSteps: z2.number().default(10)
+  }).default(() => ({ model: "claude-sonnet-4-20250514", maxSteps: 10 })),
+  activeMcpId: z2.string().nullable().default(null)
+});
+async function ensureConfigDir2() {
+  await mkdir2(CONFIG_DIR2, { recursive: true });
+}
+async function readConfig() {
+  await ensureConfigDir2();
+  try {
+    await access2(CONFIG_FILE);
+    const content = await readFile2(CONFIG_FILE, "utf-8");
+    return ConfigSchema.parse(JSON.parse(content));
+  } catch {
+    return ConfigSchema.parse({});
+  }
+}
+async function writeConfig(config2) {
+  await ensureConfigDir2();
+  await writeFile2(CONFIG_FILE, JSON.stringify(config2, null, 2), "utf-8");
+}
+var ConfigManager = class {
+  configCache = null;
+  async getConfig() {
+    if (!this.configCache) {
+      this.configCache = await readConfig();
+    }
+    return this.configCache;
+  }
+  async saveConfig(config2) {
+    this.configCache = config2;
+    await writeConfig(config2);
+  }
+  async getDefaults() {
+    const config2 = await this.getConfig();
+    return config2.defaults;
+  }
+  async setDefaults(defaults) {
+    const config2 = await this.getConfig();
+    config2.defaults = { ...config2.defaults, ...defaults };
+    await this.saveConfig(config2);
+  }
+  async getActiveMcpId() {
+    const config2 = await this.getConfig();
+    return config2.activeMcpId;
+  }
+  async setActiveMcpId(id) {
+    const config2 = await this.getConfig();
+    config2.activeMcpId = id;
+    await this.saveConfig(config2);
+  }
+  async clear() {
+    const emptyConfig = ConfigSchema.parse({});
+    await this.saveConfig(emptyConfig);
+  }
+};
+var config = new ConfigManager();
+
+// src/commands/logout.ts
+var logoutCommand = new Command2("logout").description("Log out from WaniWani").action(async (_, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    if (!await auth.isLoggedIn()) {
+      if (json) {
+        formatOutput({ alreadyLoggedOut: true }, true);
+      } else {
+        console.log("Not currently logged in.");
+      }
+      return;
+    }
+    await auth.clear();
+    await config.clear();
+    if (json) {
+      formatOutput({ success: true }, true);
+    } else {
+      formatSuccess("You have been logged out.", false);
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp/index.ts
+import { Command as Command10 } from "commander";
+
+// src/commands/mcp/create.ts
+import { Command as Command3 } from "commander";
+import ora2 from "ora";
+
+// src/lib/api.ts
+var API_BASE_URL3 = process.env.WANIWANI_API_URL || "https://waniwani.com";
+var ApiError = class extends CLIError {
+  constructor(message, code, statusCode, details) {
+    super(message, code, details);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+async function request(method, path, options) {
+  const {
+    body,
+    requireAuth = true,
+    headers: extraHeaders = {}
+  } = options || {};
+  const headers = {
+    "Content-Type": "application/json",
+    ...extraHeaders
+  };
+  if (requireAuth) {
+    const token = await auth.getAccessToken();
+    if (!token) {
+      throw new AuthError(
+        "Not logged in. Run 'waniwani login' to authenticate."
+      );
+    }
+    headers.Authorization = `Bearer ${token}`;
+  }
+  const url = `${API_BASE_URL3}${path}`;
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (response.status === 204) {
+    return void 0;
+  }
+  const data = await response.json();
+  if (!response.ok || data.error) {
+    const error = data.error || {
+      code: "API_ERROR",
+      message: `Request failed with status ${response.status}`
+    };
+    if (response.status === 401) {
+      const refreshed = await auth.tryRefreshToken();
+      if (refreshed) {
+        return request(method, path, options);
+      }
+      throw new AuthError(
+        "Session expired. Run 'waniwani login' to re-authenticate."
+      );
+    }
+    throw new ApiError(
+      error.message,
+      error.code,
+      response.status,
+      error.details
+    );
+  }
+  return data.data;
+}
+var api = {
+  get: (path, options) => request("GET", path, options),
+  post: (path, body, options) => request("POST", path, { body, ...options }),
+  delete: (path, options) => request("DELETE", path, options),
+  getBaseUrl: () => API_BASE_URL3
+};
+
+// src/commands/mcp/create.ts
+var createCommand = new Command3("create").description("Create a new MCP sandbox from template").argument("<name>", "Name for the MCP project").action(async (name, _, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    const spinner = ora2("Creating MCP sandbox...").start();
+    const result = await api.post("/api/admin/mcps", {
+      name
+    });
+    spinner.succeed("MCP sandbox created");
+    config.setActiveMcpId(result.id);
+    if (json) {
+      formatOutput(result, true);
+    } else {
+      console.log();
+      formatSuccess(`MCP sandbox "${name}" created successfully!`, false);
+      console.log();
+      console.log(`  MCP ID:      ${result.id}`);
+      console.log(`  Sandbox ID:  ${result.sandboxId}`);
+      console.log(`  Preview URL: ${result.previewUrl}`);
+      console.log();
+      console.log(`Next steps:`);
+      console.log(`  waniwani task "Add a tool that does X"`);
+      console.log(`  waniwani mcp test`);
+      console.log(`  waniwani mcp deploy`);
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp/deploy.ts
+import { Command as Command4 } from "commander";
+import ora3 from "ora";
+var deployCommand = new Command4("deploy").description("Deploy MCP server to GitHub + Vercel from sandbox").option("--repo <name>", "GitHub repository name").option("--org <name>", "GitHub organization").option("--private", "Create private repository").option("--mcp-id <id>", "Specific MCP ID").action(async (options, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    let mcpId = options.mcpId;
+    if (!mcpId) {
+      mcpId = await config.getActiveMcpId();
+      if (!mcpId) {
+        throw new McpError(
+          "No active MCP. Run 'waniwani mcp create <name>' or 'waniwani mcp use <name>'."
+        );
+      }
+    }
+    const spinner = ora3("Deploying to GitHub...").start();
+    const result = await api.post(
+      `/api/admin/mcps/${mcpId}/deploy`,
+      {
+        repoName: options.repo,
+        org: options.org,
+        private: options.private ?? false
+      }
+    );
+    spinner.succeed("Deployment complete!");
+    if (json) {
+      formatOutput(result, true);
+    } else {
+      console.log();
+      formatSuccess("MCP server deployed!", false);
+      console.log();
+      console.log(`  Repository: ${result.repository.url}`);
+      if (result.deployment.url) {
+        console.log(`  Deployment: ${result.deployment.url}`);
+      }
+      console.log();
+      if (result.deployment.note) {
+        console.log(`Note: ${result.deployment.note}`);
+      }
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp/list.ts
+import chalk4 from "chalk";
+import { Command as Command5 } from "commander";
+import ora4 from "ora";
+var listCommand = new Command5("list").description("List all MCPs in your organization").option("--all", "Include stopped/expired MCPs").action(async (options, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    const spinner = ora4("Fetching MCPs...").start();
+    const mcps = await api.get(
+      `/api/admin/mcps${options.all ? "?all=true" : ""}`
+    );
+    spinner.stop();
+    const activeMcpId = await config.getActiveMcpId();
+    if (json) {
+      formatOutput(
+        {
+          mcps: mcps.map((m) => ({
+            ...m,
+            isActive: m.id === activeMcpId
+          })),
+          activeMcpId
+        },
+        true
+      );
+    } else {
+      if (mcps.length === 0) {
+        console.log("No MCPs found.");
+        console.log("\nCreate a new MCP sandbox: waniwani mcp create <name>");
+        return;
+      }
+      console.log(chalk4.bold("\nMCPs:\n"));
+      const rows = mcps.map((m) => {
+        const isActive = m.id === activeMcpId;
+        const statusColor = m.status === "active" ? chalk4.green : m.status === "stopped" ? chalk4.red : chalk4.yellow;
+        return [
+          isActive ? chalk4.cyan(`* ${m.id.slice(0, 8)}`) : `  ${m.id.slice(0, 8)}`,
+          m.name,
+          statusColor(m.status),
+          m.previewUrl,
+          m.createdAt ? new Date(m.createdAt).toLocaleString() : "N/A"
+        ];
+      });
+      formatTable(
+        ["ID", "Name", "Status", "Preview URL", "Created"],
+        rows,
+        false
+      );
+      console.log();
+      if (activeMcpId) {
+        console.log(`Active MCP: ${chalk4.cyan(activeMcpId.slice(0, 8))}`);
+      }
+      console.log("\nSelect an MCP: waniwani mcp use <name>");
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp/status.ts
+import chalk5 from "chalk";
+import { Command as Command6 } from "commander";
+import ora5 from "ora";
+var statusCommand = new Command6("status").description("Show current MCP sandbox status").option("--mcp-id <id>", "Specific MCP ID").action(async (options, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    let mcpId = options.mcpId;
+    if (!mcpId) {
+      mcpId = await config.getActiveMcpId();
+      if (!mcpId) {
+        throw new McpError(
+          "No active MCP. Run 'waniwani mcp create <name>' to create one or 'waniwani mcp use <name>' to select one."
+        );
+      }
+    }
+    const spinner = ora5("Fetching MCP status...").start();
+    const result = await api.get(`/api/admin/mcps/${mcpId}`);
+    spinner.stop();
+    if (json) {
+      formatOutput(result, true);
+    } else {
+      const statusColor = result.status === "active" ? chalk5.green : chalk5.red;
+      formatList(
+        [
+          { label: "MCP ID", value: result.id },
+          { label: "Name", value: result.name },
+          { label: "Status", value: statusColor(result.status) },
+          { label: "Sandbox ID", value: result.sandboxId },
+          { label: "Preview URL", value: result.previewUrl },
+          { label: "Created", value: result.createdAt },
+          { label: "Expires", value: result.expiresAt ?? "N/A" }
+        ],
+        false
+      );
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp/stop.ts
+import { Command as Command7 } from "commander";
+import ora6 from "ora";
+var stopCommand = new Command7("stop").description("Stop and clean up the MCP sandbox").option("--mcp-id <id>", "Specific MCP ID").action(async (options, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    let mcpId = options.mcpId;
+    if (!mcpId) {
+      mcpId = await config.getActiveMcpId();
+      if (!mcpId) {
+        throw new McpError("No active MCP. Use --mcp-id to specify one.");
+      }
+    }
+    const spinner = ora6("Stopping MCP sandbox...").start();
+    await api.delete(`/api/admin/mcps/${mcpId}`);
+    spinner.succeed("MCP sandbox stopped");
+    if (await config.getActiveMcpId() === mcpId) {
+      await config.setActiveMcpId(null);
+    }
+    if (json) {
+      formatOutput({ stopped: mcpId }, true);
+    } else {
+      formatSuccess("MCP sandbox stopped and cleaned up.", false);
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp/test.ts
+import chalk6 from "chalk";
+import { Command as Command8 } from "commander";
+import ora7 from "ora";
+var testCommand = new Command8("test").description("Test MCP tools via the sandbox").argument("[tool]", "Tool name to test (lists tools if omitted)").argument("[args...]", "JSON arguments for the tool").option("--mcp-id <id>", "Specific MCP ID").action(
+  async (tool, args, options, command) => {
+    const globalOptions = command.optsWithGlobals();
+    const json = globalOptions.json ?? false;
+    try {
+      let mcpId = options.mcpId;
+      if (!mcpId) {
+        mcpId = await config.getActiveMcpId();
+        if (!mcpId) {
+          throw new McpError(
+            "No active MCP. Run 'waniwani mcp create <name>' or 'waniwani mcp use <name>'."
+          );
+        }
+      }
+      if (!tool) {
+        const spinner = ora7("Fetching available tools...").start();
+        const result = await api.post(
+          `/api/admin/mcps/${mcpId}/test`,
+          { action: "list" }
+        );
+        spinner.stop();
+        const tools = result.tools;
+        if (json) {
+          formatOutput({ tools }, true);
+        } else {
+          if (tools.length === 0) {
+            console.log("No tools available.");
+          } else {
+            console.log(chalk6.bold("\nAvailable Tools:\n"));
+            formatTable(
+              ["Name", "Description"],
+              tools.map((t) => [t.name, t.description || "No description"]),
+              false
+            );
+            console.log(
+              `
+Test a tool: waniwani mcp test <tool-name> '{"arg": "value"}'`
+            );
+          }
+        }
+      } else {
+        let toolArgs = {};
+        if (args.length > 0) {
+          try {
+            toolArgs = JSON.parse(args.join(" "));
+          } catch {
+            throw new SandboxError(
+              `Invalid JSON arguments. Expected format: '{"key": "value"}'`
+            );
+          }
+        }
+        const spinner = ora7(`Calling tool "${tool}"...`).start();
+        const startTime = Date.now();
+        const result = await api.post(
+          `/api/admin/mcps/${mcpId}/test`,
+          {
+            action: "call",
+            tool,
+            args: toolArgs
+          }
+        );
+        const duration = result.duration || Date.now() - startTime;
+        spinner.stop();
+        const output = {
+          tool,
+          input: toolArgs,
+          result: result.result,
+          duration
+        };
+        if (json) {
+          formatOutput(output, true);
+        } else {
+          console.log(chalk6.bold("\nTool Result:\n"));
+          console.log(chalk6.gray("Tool:"), tool);
+          console.log(chalk6.gray("Input:"), JSON.stringify(toolArgs));
+          console.log(chalk6.gray("Duration:"), `${duration}ms`);
+          console.log(chalk6.gray("Result:"));
+          console.log(JSON.stringify(result.result, null, 2));
+        }
+      }
+    } catch (error) {
+      handleError(error, json);
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/mcp/use.ts
+import { Command as Command9 } from "commander";
+import ora8 from "ora";
+var useCommand = new Command9("use").description("Select an MCP to use for subsequent commands").argument("<name>", "Name of the MCP to use").action(async (name, _, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    const spinner = ora8("Fetching MCPs...").start();
+    const mcps = await api.get("/api/admin/mcps");
+    spinner.stop();
+    const mcp = mcps.find((m) => m.name === name);
+    if (!mcp) {
+      throw new McpError(
+        `MCP "${name}" not found. Run 'waniwani mcp list' to see available MCPs.`
+      );
+    }
+    if (mcp.status !== "active") {
+      throw new McpError(
+        `MCP "${name}" is ${mcp.status}. Only active MCPs can be used.`
+      );
+    }
+    await config.setActiveMcpId(mcp.id);
+    if (json) {
+      formatOutput({ selected: mcp }, true);
+    } else {
+      formatSuccess(`Now using MCP "${name}"`, false);
+      console.log();
+      console.log(`  MCP ID:      ${mcp.id}`);
+      console.log(`  Preview URL: ${mcp.previewUrl}`);
+      console.log();
+      console.log("Next steps:");
+      console.log('  waniwani task "Add a tool"');
+      console.log("  waniwani mcp test");
+      console.log("  waniwani mcp status");
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp/index.ts
+var mcpCommand = new Command10("mcp").description("MCP sandbox management commands").addCommand(createCommand).addCommand(listCommand).addCommand(useCommand).addCommand(statusCommand).addCommand(stopCommand).addCommand(testCommand).addCommand(deployCommand);
+
+// src/commands/org/index.ts
+import { Command as Command13 } from "commander";
+
+// src/commands/org/list.ts
+import chalk7 from "chalk";
+import { Command as Command11 } from "commander";
+import ora9 from "ora";
+var listCommand2 = new Command11("list").description("List your organizations").action(async (_, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    const spinner = ora9("Fetching organizations...").start();
+    const result = await api.get("/api/oauth/orgs");
+    spinner.stop();
+    const { orgs, activeOrgId } = result;
+    if (json) {
+      formatOutput(
+        {
+          orgs: orgs.map((o) => ({
+            ...o,
+            isActive: o.id === activeOrgId
+          })),
+          activeOrgId
+        },
+        true
+      );
+    } else {
+      if (orgs.length === 0) {
+        console.log("No organizations found.");
+        return;
+      }
+      console.log(chalk7.bold("\nOrganizations:\n"));
+      const rows = orgs.map((o) => {
+        const isActive = o.id === activeOrgId;
+        return [
+          isActive ? chalk7.cyan(`* ${o.name}`) : `  ${o.name}`,
+          o.slug,
+          o.role
+        ];
+      });
+      formatTable(["Name", "Slug", "Role"], rows, false);
+      console.log();
+      if (activeOrgId) {
+        const activeOrg = orgs.find((o) => o.id === activeOrgId);
+        if (activeOrg) {
+          console.log(`Active organization: ${chalk7.cyan(activeOrg.name)}`);
+        }
+      }
+      console.log("\nSwitch organization: waniwani org switch <name>");
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/org/switch.ts
+import { Command as Command12 } from "commander";
+import ora10 from "ora";
+var switchCommand = new Command12("switch").description("Switch to a different organization").argument("<name>", "Name or slug of the organization to switch to").action(async (name, _, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    const spinner = ora10("Fetching organizations...").start();
+    const { orgs } = await api.get("/api/oauth/orgs");
+    const org = orgs.find((o) => o.name === name || o.slug === name);
+    if (!org) {
+      spinner.stop();
+      throw new CLIError(
+        `Organization "${name}" not found. Run 'waniwani org list' to see available organizations.`,
+        "ORG_NOT_FOUND"
+      );
+    }
+    spinner.text = "Switching organization...";
+    await api.post("/api/oauth/orgs/switch", {
+      orgId: org.id
+    });
+    spinner.succeed("Organization switched");
+    config.setActiveMcpId(null);
+    if (json) {
+      formatOutput({ switched: org }, true);
+    } else {
+      formatSuccess(`Switched to organization "${org.name}"`, false);
+      console.log();
+      console.log("Note: Active MCP selection has been cleared.");
+      console.log(
+        "Run 'waniwani mcp list' to see MCPs in this organization."
+      );
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/commands/org/index.ts
+var orgCommand = new Command13("org").description("Organization management commands").addCommand(listCommand2).addCommand(switchCommand);
+
+// src/commands/task.ts
+import chalk8 from "chalk";
+import { Command as Command14 } from "commander";
+import ora11 from "ora";
+var taskCommand = new Command14("task").description("Send a task to Claude running in the sandbox").argument("<prompt>", "Task description/prompt").option("--mcp-id <id>", "Specific MCP ID").option("--model <model>", "Claude model to use", "claude-sonnet-4-20250514").option("--max-steps <n>", "Maximum tool use steps", "10").action(async (prompt, options, command) => {
+  const globalOptions = command.optsWithGlobals();
+  const json = globalOptions.json ?? false;
+  try {
+    let mcpId = options.mcpId;
+    if (!mcpId) {
+      mcpId = await config.getActiveMcpId();
+      if (!mcpId) {
+        throw new McpError(
+          "No active MCP. Run 'waniwani mcp create <name>' or 'waniwani mcp use <name>'."
+        );
+      }
+    }
+    const token = await auth.getAccessToken();
+    if (!token) {
+      throw new AuthError(
+        "Not logged in. Run 'waniwani login' to authenticate."
+      );
+    }
+    const maxSteps = parseInt(options.maxSteps, 10);
+    if (!json) {
+      console.log();
+      console.log(chalk8.bold("Task:"), prompt);
+      console.log();
+    }
+    const spinner = ora11("Starting task...").start();
+    const baseUrl = api.getBaseUrl();
+    const response = await fetch(`${baseUrl}/api/admin/mcps/${mcpId}/task`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify({
+        prompt,
+        model: options.model,
+        maxSteps
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      spinner.fail("Task failed");
+      throw new Error(
+        error.message || `Request failed with status ${response.status}`
+      );
+    }
+    spinner.stop();
+    const steps = [];
+    let stepCount = 0;
+    let maxStepsReached = false;
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          continue;
+        }
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (!data || data === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.type === "text") {
+              const event = parsed;
+              steps.push({ type: "text", text: event.content });
+              if (!json && event.content) {
+                console.log(chalk8.white(event.content));
+              }
+            } else if (parsed.type === "tool_call") {
+              const event = parsed;
+              steps.push({
+                type: "tool_call",
+                tool: event.tool,
+                input: event.input,
+                output: event.output
+              });
+              if (!json) {
+                console.log(chalk8.cyan(`> Using tool: ${event.tool}`));
+                if (event.input?.command) {
+                  console.log(chalk8.gray(`  $ ${event.input.command}`));
+                }
+                if (event.output) {
+                  const outputLines = event.output.split("\n");
+                  if (outputLines.length > 10) {
+                    console.log(
+                      chalk8.gray(outputLines.slice(0, 5).join("\n"))
+                    );
+                    console.log(
+                      chalk8.gray(
+                        `  ... (${outputLines.length - 10} more lines)`
+                      )
+                    );
+                    console.log(chalk8.gray(outputLines.slice(-5).join("\n")));
+                  } else {
+                    console.log(chalk8.gray(event.output));
+                  }
+                }
+                console.log();
+              }
+            } else if (parsed.success !== void 0) {
+              const doneEvent = parsed;
+              stepCount = doneEvent.stepCount;
+              maxStepsReached = doneEvent.maxStepsReached || false;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    const result = {
+      success: true,
+      steps,
+      stepCount,
+      maxStepsReached
+    };
+    if (json) {
+      formatOutput(result, true);
+    } else {
+      console.log();
+      console.log(chalk8.green("\u2713"), `Task completed in ${stepCount} steps.`);
+      if (maxStepsReached) {
+        console.log(
+          chalk8.yellow("\u26A0"),
+          "Maximum steps reached. Task may be incomplete."
+        );
+      }
+    }
+  } catch (error) {
+    handleError(error, json);
+    process.exit(1);
+  }
+});
+
+// src/cli.ts
+var version = "0.1.0";
+var program = new Command15().name("waniwani").description("WaniWani CLI for MCP development workflow").version(version).option("--json", "Output results as JSON").option("--verbose", "Enable verbose logging");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(mcpCommand);
+program.addCommand(taskCommand);
+program.addCommand(orgCommand);
+
+// src/index.ts
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map