@codelia/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,918 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/args.ts
+var import_cac = require("cac");
+var parseWithCac = (values) => {
+  const cli = (0, import_cac.cac)("codelia-args");
+  cli.command("[...positionals]").allowUnknownOptions();
+  const parsed = cli.parse(["node", "codelia-args", ...values], {
+    run: false
+  });
+  return {
+    args: [...parsed.args],
+    options: parsed.options
+  };
+};
+var parseBoolean = (value, flagName) => {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  throw new Error(`${flagName} must be true|false`);
+};
+var parseTimeout = (value) => {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error("--request-timeout-ms must be a positive integer");
+  }
+  return parsed;
+};
+var parseEpochMs = (value, flagName) => {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flagName} must be a positive integer (epoch ms)`);
+  }
+  return parsed;
+};
+var parseKeyValue = (raw, flagName) => {
+  const [key, ...rest] = raw.split("=");
+  const value = rest.join("=");
+  if (!key || !value) {
+    throw new Error(`${flagName} must be key=value`);
+  }
+  return [key, value];
+};
+var parseCliArgs = (values) => {
+  const parsed = parseWithCac(values);
+  return {
+    positionals: parsed.args,
+    options: parsed.options
+  };
+};
+var readOptionValues = (parsed, flagName) => {
+  const value = parsed.options[flagName];
+  if (value == null || value === false || value === true) return [];
+  const entries = Array.isArray(value) ? value : [value];
+  return entries.map((entry) => String(entry));
+};
+var getLastFlagValue = (parsed, flagName) => {
+  const values = readOptionValues(parsed, flagName);
+  if (!values || values.length === 0) return void 0;
+  return values[values.length - 1];
+};
+var getAllFlagValues = (parsed, flagName) => readOptionValues(parsed, flagName);
+var hasBooleanFlag = (parsed, flagName) => parsed.options[flagName] === true;
+
+// src/mcp/auth-file.ts
+var import_storage = require("@codelia/storage");
+var authStore = new import_storage.McpAuthStore();
+var readMcpAuth = async () => {
+  return authStore.load();
+};
+var writeMcpAuth = async (auth) => {
+  await authStore.save(auth);
+};
+
+// src/commands/mcp-auth.ts
+var runMcpAuthCommand = async (values) => {
+  const [subcommand, ...rest] = values;
+  const parsed = parseCliArgs(rest);
+  if (!subcommand) {
+    console.error("usage: codelia mcp auth <list|set|clear> ...");
+    return 1;
+  }
+  if (subcommand === "list") {
+    const auth = await readMcpAuth();
+    const entries = Object.entries(auth.servers).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    if (!entries.length) {
+      console.log("no MCP auth tokens configured");
+      return 0;
+    }
+    console.log("server_id	has_refresh	expires_at");
+    for (const [serverId, tokens] of entries) {
+      console.log(
+        `${serverId}	${tokens.refresh_token ? "yes" : "no"}	${tokens.expires_at ?? "-"}`
+      );
+    }
+    return 0;
+  }
+  if (subcommand === "set") {
+    const serverId = parsed.positionals[0];
+    if (!serverId) {
+      console.error(
+        "usage: codelia mcp auth set <server-id> --access-token <token> [--refresh-token <token>] [--expires-at <epoch_ms>] [--expires-in <sec>] [--scope <scope>] [--token-type <type>]"
+      );
+      return 1;
+    }
+    const accessToken = getLastFlagValue(parsed, "access-token");
+    if (!accessToken) {
+      console.error("--access-token is required");
+      return 1;
+    }
+    const refreshToken = getLastFlagValue(parsed, "refresh-token");
+    const expiresAtRaw = getLastFlagValue(parsed, "expires-at");
+    const expiresInRaw = getLastFlagValue(parsed, "expires-in");
+    let expiresAt;
+    if (expiresAtRaw) {
+      expiresAt = parseEpochMs(expiresAtRaw, "--expires-at");
+    } else if (expiresInRaw) {
+      expiresAt = Date.now() + parseTimeout(expiresInRaw) * 1e3;
+    }
+    const scope = getLastFlagValue(parsed, "scope");
+    const tokenType = getLastFlagValue(parsed, "token-type");
+    const auth = await readMcpAuth();
+    auth.servers[serverId] = {
+      access_token: accessToken,
+      ...refreshToken ? { refresh_token: refreshToken } : {},
+      ...expiresAt ? { expires_at: expiresAt } : {},
+      ...scope ? { scope } : {},
+      ...tokenType ? { token_type: tokenType } : {}
+    };
+    await writeMcpAuth(auth);
+    console.log(`stored MCP auth token for '${serverId}'`);
+    return 0;
+  }
+  if (subcommand === "clear") {
+    const serverId = parsed.positionals[0];
+    if (!serverId) {
+      console.error("usage: codelia mcp auth clear <server-id>");
+      return 1;
+    }
+    const auth = await readMcpAuth();
+    if (!auth.servers[serverId]) {
+      console.error(`no token found for server: ${serverId}`);
+      return 1;
+    }
+    delete auth.servers[serverId];
+    await writeMcpAuth(auth);
+    console.log(`cleared MCP auth token for '${serverId}'`);
+    return 0;
+  }
+  console.error(`unknown auth subcommand: ${subcommand}`);
+  return 1;
+};
+
+// src/commands/mcp-config.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_config_loader = require("@codelia/config-loader");
+var import_storage2 = require("@codelia/storage");
+var import_zod = require("zod");
+
+// src/mcp/probe.ts
+var import_node_child_process = require("child_process");
+var import_node_readline = require("readline");
+
+// src/mcp/protocol.ts
+var import_protocol = require("@codelia/protocol");
+var assertSupportedProtocolVersion = (value) => {
+  (0, import_protocol.assertSupportedMcpProtocolVersion)(value);
+};
+
+// src/mcp/probe.ts
+var DEFAULT_MCP_TIMEOUT_MS = 3e4;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var describeError = (error) => error instanceof Error ? error.message : String(error);
+var postHttpJson = async (url, body, headers, timeoutMs) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const bodyText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${bodyText.slice(0, 300)}`);
+    }
+    const text = await response.text();
+    const sessionId = response.headers.get("MCP-Session-Id") ?? void 0;
+    if (!text.trim()) return { body: null, sessionId };
+    return { body: JSON.parse(text), sessionId };
+  } catch (error) {
+    if (controller.signal.aborted) {
+      throw new Error(`request timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var parseRpcResult = (raw, requestId) => {
+  if (Array.isArray(raw)) {
+    const found = raw.find(
+      (entry) => isRecord(entry) && String(entry.id ?? "") === requestId
+    );
+    if (!found) {
+      throw new Error(`missing response id=${requestId}`);
+    }
+    return parseRpcResult(found, requestId);
+  }
+  if (!isRecord(raw)) {
+    throw new Error("invalid JSON-RPC response");
+  }
+  if (isRecord(raw.error)) {
+    throw new Error(
+      `RPC ${String(raw.error.code)}: ${String(raw.error.message)}`
+    );
+  }
+  return raw.result;
+};
+var parseToolsResponse = (raw) => {
+  if (!isRecord(raw)) return { count: 0 };
+  const tools = Array.isArray(raw.tools) ? raw.tools.length : 0;
+  const nextCursor = typeof raw.nextCursor === "string" ? raw.nextCursor : typeof raw.next_cursor === "string" ? raw.next_cursor : void 0;
+  return { count: tools, nextCursor };
+};
+var probeHttpServer = async (config) => {
+  let seq = 0;
+  let sessionId;
+  const timeoutMs = config.request_timeout_ms ?? DEFAULT_MCP_TIMEOUT_MS;
+  const protocolVersion = (0, import_protocol.getMcpProtocolVersion)();
+  const baseHeaders = {
+    "Content-Type": "application/json",
+    Accept: "application/json, text/event-stream",
+    "MCP-Protocol-Version": protocolVersion,
+    ...config.headers ?? {}
+  };
+  const request = async (method, params) => {
+    seq += 1;
+    const requestId = `cli-${seq}`;
+    const headers = {
+      ...baseHeaders,
+      ...sessionId ? { "MCP-Session-Id": sessionId } : {}
+    };
+    const raw = await postHttpJson(
+      config.url ?? "",
+      {
+        jsonrpc: "2.0",
+        id: requestId,
+        method,
+        params
+      },
+      headers,
+      timeoutMs
+    );
+    if (raw.sessionId) {
+      sessionId = raw.sessionId;
+    }
+    return parseRpcResult(raw.body, requestId);
+  };
+  const notify = async (method, params) => {
+    const headers = {
+      ...baseHeaders,
+      ...sessionId ? { "MCP-Session-Id": sessionId } : {}
+    };
+    const raw = await postHttpJson(
+      config.url ?? "",
+      {
+        jsonrpc: "2.0",
+        method,
+        params
+      },
+      headers,
+      timeoutMs
+    );
+    if (raw.sessionId) {
+      sessionId = raw.sessionId;
+    }
+  };
+  const initResult = await request("initialize", {
+    protocolVersion,
+    clientInfo: { name: "codelia-cli", version: "0.1.0" },
+    capabilities: {}
+  });
+  assertSupportedProtocolVersion(initResult);
+  await notify("notifications/initialized", {});
+  let total = 0;
+  let cursor;
+  for (let page = 0; page < 100; page += 1) {
+    const result = await request("tools/list", cursor ? { cursor } : {});
+    const parsed = parseToolsResponse(result);
+    total += parsed.count;
+    if (!parsed.nextCursor) break;
+    cursor = parsed.nextCursor;
+  }
+  return total;
+};
+var probeStdioServer = async (config) => {
+  const timeoutMs = config.request_timeout_ms ?? DEFAULT_MCP_TIMEOUT_MS;
+  const child = (0, import_node_child_process.spawn)(config.command ?? "", config.args ?? [], {
+    cwd: config.cwd,
+    env: {
+      ...process.env,
+      ...config.env ?? {}
+    },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let seq = 0;
+  const pending = /* @__PURE__ */ new Map();
+  const stdoutReader = (0, import_node_readline.createInterface)({ input: child.stdout });
+  stdoutReader.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (!isRecord(parsed) || parsed.id === void 0 || parsed.id === null) {
+      return;
+    }
+    const id = String(parsed.id);
+    const entry = pending.get(id);
+    if (!entry) return;
+    pending.delete(id);
+    clearTimeout(entry.timeout);
+    if (isRecord(parsed.error)) {
+      entry.reject(
+        new Error(
+          `RPC ${String(parsed.error.code)}: ${String(parsed.error.message)}`
+        )
+      );
+      return;
+    }
+    entry.resolve(parsed.result);
+  });
+  const stderrReader = (0, import_node_readline.createInterface)({ input: child.stderr });
+  stderrReader.on("line", () => void 0);
+  const failPending = (error) => {
+    for (const [id, entry] of pending) {
+      pending.delete(id);
+      clearTimeout(entry.timeout);
+      entry.reject(error);
+    }
+  };
+  child.once("error", (error) => {
+    failPending(new Error(`stdio process error: ${describeError(error)}`));
+  });
+  child.once("exit", (code, signal) => {
+    failPending(
+      new Error(`stdio exited: code=${String(code)} signal=${String(signal)}`)
+    );
+  });
+  const send = (payload) => new Promise((resolve, reject) => {
+    child.stdin.write(`${JSON.stringify(payload)}
+`, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+  const request = (method, params) => {
+    seq += 1;
+    const requestId = `cli-${seq}`;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        pending.delete(requestId);
+        reject(new Error(`request timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      pending.set(requestId, { resolve, reject, timeout });
+      void send({
+        jsonrpc: "2.0",
+        id: requestId,
+        method,
+        params
+      }).catch((error) => {
+        const entry = pending.get(requestId);
+        if (!entry) return;
+        pending.delete(requestId);
+        clearTimeout(entry.timeout);
+        reject(new Error(`failed to send request: ${describeError(error)}`));
+      });
+    });
+  };
+  const notify = async (method, params) => {
+    await send({ jsonrpc: "2.0", method, params });
+  };
+  try {
+    const initResult = await request("initialize", {
+      protocolVersion: (0, import_protocol.getMcpProtocolVersion)(),
+      clientInfo: { name: "codelia-cli", version: "0.1.0" },
+      capabilities: {}
+    });
+    assertSupportedProtocolVersion(initResult);
+    await notify("notifications/initialized", {});
+    let total = 0;
+    let cursor;
+    for (let page = 0; page < 100; page += 1) {
+      const result = await request("tools/list", cursor ? { cursor } : {});
+      const parsed = parseToolsResponse(result);
+      total += parsed.count;
+      if (!parsed.nextCursor) break;
+      cursor = parsed.nextCursor;
+    }
+    return total;
+  } finally {
+    child.kill("SIGTERM");
+    stdoutReader.close();
+    stderrReader.close();
+  }
+};
+var probeServer = async (config) => {
+  if (config.transport === "http") {
+    return probeHttpServer(config);
+  }
+  return probeStdioServer(config);
+};
+
+// src/commands/mcp-config.ts
+var TIMEOUT_SCHEMA = import_zod.z.number().positive().transform((value) => Math.round(value));
+var OAUTH_SCHEMA = import_zod.z.object({
+  authorization_url: import_zod.z.string(),
+  token_url: import_zod.z.string(),
+  registration_url: import_zod.z.string(),
+  client_id: import_zod.z.string(),
+  client_secret: import_zod.z.string(),
+  scope: import_zod.z.string()
+}).partial();
+var HTTP_SERVER_CONFIG_SCHEMA = import_zod.z.object({
+  transport: import_zod.z.literal("http"),
+  enabled: import_zod.z.boolean().optional(),
+  url: import_zod.z.string(),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  request_timeout_ms: TIMEOUT_SCHEMA.optional(),
+  oauth: OAUTH_SCHEMA.optional()
+});
+var STDIO_SERVER_CONFIG_SCHEMA = import_zod.z.object({
+  transport: import_zod.z.literal("stdio"),
+  enabled: import_zod.z.boolean().optional(),
+  command: import_zod.z.string(),
+  args: import_zod.z.array(import_zod.z.string()).optional(),
+  cwd: import_zod.z.string().optional(),
+  env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  request_timeout_ms: TIMEOUT_SCHEMA.optional(),
+  oauth: OAUTH_SCHEMA.optional()
+});
+var MCP_SERVER_CONFIG_SCHEMA = import_zod.z.union([
+  HTTP_SERVER_CONFIG_SCHEMA,
+  STDIO_SERVER_CONFIG_SCHEMA
+]);
+var describeError2 = (error) => error instanceof Error ? error.message : String(error);
+var readEnvValue = (key) => {
+  const value = process.env[key];
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+};
+var resolveGlobalConfigPath = () => {
+  const envPath = readEnvValue("CODELIA_CONFIG_PATH");
+  if (envPath) return import_node_path.default.resolve(envPath);
+  const storage = (0, import_storage2.resolveStoragePaths)();
+  return storage.configFile;
+};
+var resolveProjectConfigPath = () => import_node_path.default.resolve(process.cwd(), ".codelia", "config.json");
+var normalizeServerConfig = (value) => {
+  const parsed = MCP_SERVER_CONFIG_SCHEMA.safeParse(value);
+  return parsed.success ? parsed.data : null;
+};
+var normalizeEntries = (servers, source) => {
+  const entries = [];
+  for (const [id, rawConfig] of Object.entries(servers)) {
+    const config = normalizeServerConfig(rawConfig);
+    if (!config) continue;
+    entries.push({ id, config, source });
+  }
+  return entries.sort((left, right) => left.id.localeCompare(right.id));
+};
+var loadEntriesByScope = async (scope) => {
+  const globalServers = await (0, import_config_loader.loadMcpServers)(resolveGlobalConfigPath());
+  const projectServers = await (0, import_config_loader.loadMcpServers)(resolveProjectConfigPath());
+  if (scope === "global") {
+    return normalizeEntries(globalServers, "global");
+  }
+  if (scope === "project") {
+    return normalizeEntries(projectServers, "project");
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of normalizeEntries(globalServers, "global")) {
+    merged.set(entry.id, entry);
+  }
+  for (const entry of normalizeEntries(projectServers, "project")) {
+    merged.set(entry.id, entry);
+  }
+  return Array.from(merged.values()).sort(
+    (left, right) => left.id.localeCompare(right.id)
+  );
+};
+var resolveMutableScope = (parsed) => {
+  const scopeRaw = getLastFlagValue(parsed, "scope") ?? "project";
+  if (scopeRaw === "project" || scopeRaw === "global") {
+    return scopeRaw;
+  }
+  throw new Error("--scope must be project|global");
+};
+var resolveListScope = (parsed) => {
+  const scopeRaw = getLastFlagValue(parsed, "scope") ?? "effective";
+  if (scopeRaw === "project" || scopeRaw === "global" || scopeRaw === "effective") {
+    return scopeRaw;
+  }
+  throw new Error("--scope must be effective|project|global");
+};
+var buildServerConfigFromAdd = (parsed) => {
+  const transport = getLastFlagValue(parsed, "transport");
+  if (transport !== "http" && transport !== "stdio") {
+    throw new Error("--transport must be http|stdio");
+  }
+  const enabledRaw = getLastFlagValue(parsed, "enabled");
+  const enabled = enabledRaw ? parseBoolean(enabledRaw, "--enabled") : true;
+  const timeoutRaw = getLastFlagValue(parsed, "request-timeout-ms");
+  const requestTimeoutMs = timeoutRaw ? parseTimeout(timeoutRaw) : void 0;
+  const oauth = {
+    authorization_url: getLastFlagValue(parsed, "oauth-authorization-url"),
+    token_url: getLastFlagValue(parsed, "oauth-token-url"),
+    registration_url: getLastFlagValue(parsed, "oauth-registration-url"),
+    client_id: getLastFlagValue(parsed, "oauth-client-id"),
+    client_secret: getLastFlagValue(parsed, "oauth-client-secret"),
+    scope: getLastFlagValue(parsed, "oauth-scope")
+  };
+  const oauthConfig = Object.fromEntries(
+    Object.entries(oauth).filter(([, value]) => !!value)
+  );
+  if (transport === "http") {
+    const url = getLastFlagValue(parsed, "url");
+    if (!url) throw new Error("--url is required when --transport=http");
+    const headers = Object.fromEntries(
+      getAllFlagValues(parsed, "header").map(
+        (value) => parseKeyValue(value, "--header")
+      )
+    );
+    return {
+      transport,
+      ...enabled !== true ? { enabled } : {},
+      url,
+      ...Object.keys(headers).length ? { headers } : {},
+      ...requestTimeoutMs ? { request_timeout_ms: requestTimeoutMs } : {},
+      ...oauthConfig && Object.keys(oauthConfig).length ? { oauth: oauthConfig } : {}
+    };
+  }
+  const command = getLastFlagValue(parsed, "command");
+  if (!command) {
+    throw new Error("--command is required when --transport=stdio");
+  }
+  const env = Object.fromEntries(
+    getAllFlagValues(parsed, "env").map(
+      (value) => parseKeyValue(value, "--env")
+    )
+  );
+  const args2 = getAllFlagValues(parsed, "arg");
+  const cwd = getLastFlagValue(parsed, "cwd");
+  return {
+    transport,
+    ...enabled !== true ? { enabled } : {},
+    command,
+    ...args2.length ? { args: args2 } : {},
+    ...cwd ? { cwd } : {},
+    ...Object.keys(env).length ? { env } : {},
+    ...requestTimeoutMs ? { request_timeout_ms: requestTimeoutMs } : {},
+    ...oauthConfig && Object.keys(oauthConfig).length ? { oauth: oauthConfig } : {}
+  };
+};
+var printStaticList = (entries) => {
+  if (!entries.length) {
+    console.log("no MCP servers configured");
+    return;
+  }
+  console.log("id	transport	source	enabled");
+  for (const entry of entries) {
+    const enabled = entry.config.enabled !== false;
+    console.log(
+      `${entry.id}	${entry.config.transport}	${entry.source}	${enabled}`
+    );
+  }
+};
+var runMcpConfigCommand = async (subcommand, rest) => {
+  const parsed = parseCliArgs(rest);
+  if (subcommand === "list") {
+    const scope = resolveListScope(parsed);
+    const entries = await loadEntriesByScope(scope);
+    printStaticList(entries);
+    return 0;
+  }
+  if (subcommand === "add") {
+    const serverId = parsed.positionals[0];
+    if (!serverId) {
+      console.error(
+        "usage: codelia mcp add <server-id> --transport <http|stdio> ..."
+      );
+      return 1;
+    }
+    const scope = resolveMutableScope(parsed);
+    const configPath = scope === "global" ? resolveGlobalConfigPath() : resolveProjectConfigPath();
+    const servers = await (0, import_config_loader.loadMcpServers)(configPath);
+    const replace = hasBooleanFlag(parsed, "replace");
+    if (servers[serverId] !== void 0 && !replace) {
+      console.error(`server already exists in ${scope} scope: ${serverId}`);
+      console.error("pass --replace to overwrite");
+      return 1;
+    }
+    const serverConfig = buildServerConfigFromAdd(parsed);
+    await (0, import_config_loader.upsertMcpServerConfig)(configPath, serverId, serverConfig);
+    console.log(`added MCP server '${serverId}' (${scope})`);
+    return 0;
+  }
+  if (subcommand === "remove" || subcommand === "enable" || subcommand === "disable") {
+    const serverId = parsed.positionals[0];
+    if (!serverId) {
+      console.error(
+        `usage: codelia mcp ${subcommand} <server-id> [--scope project|global]`
+      );
+      return 1;
+    }
+    const scope = resolveMutableScope(parsed);
+    const configPath = scope === "global" ? resolveGlobalConfigPath() : resolveProjectConfigPath();
+    if (subcommand === "remove") {
+      const removed = await (0, import_config_loader.removeMcpServerConfig)(configPath, serverId);
+      if (!removed) {
+        console.error(`server not found in ${scope} scope: ${serverId}`);
+        return 1;
+      }
+    } else {
+      const updated = await (0, import_config_loader.setMcpServerEnabled)(
+        configPath,
+        serverId,
+        subcommand === "enable"
+      );
+      if (!updated) {
+        console.error(`server not found in ${scope} scope: ${serverId}`);
+        return 1;
+      }
+    }
+    console.log(`${subcommand}d MCP server '${serverId}' (${scope})`);
+    return 0;
+  }
+  if (subcommand === "test") {
+    const serverId = parsed.positionals[0];
+    if (!serverId) {
+      console.error(
+        "usage: codelia mcp test <server-id> [--scope effective|project|global]"
+      );
+      return 1;
+    }
+    const scope = resolveListScope(parsed);
+    const entries = await loadEntriesByScope(scope);
+    const target = entries.find((entry) => entry.id === serverId);
+    if (!target) {
+      console.error(`server not found: ${serverId} (scope=${scope})`);
+      return 1;
+    }
+    try {
+      const auth = await readMcpAuth();
+      const accessToken = auth.servers[target.id]?.access_token;
+      const configForTest = target.config.transport === "http" && accessToken ? {
+        ...target.config,
+        headers: {
+          ...target.config.headers ?? {},
+          Authorization: `Bearer ${accessToken}`
+        }
+      } : target.config;
+      const tools = await probeServer(configForTest);
+      console.log(
+        `MCP test succeeded: id=${target.id} transport=${target.config.transport} source=${target.source} tools=${tools}`
+      );
+      return 0;
+    } catch (error) {
+      console.error(
+        `MCP test failed: id=${target.id} transport=${target.config.transport}: ${describeError2(error)}`
+      );
+      return 1;
+    }
+  }
+  return -1;
+};
+
+// src/commands/mcp.ts
+var runMcpCommand = async (values) => {
+  const [subcommand, ...rest] = values;
+  if (!subcommand) {
+    console.error(
+      "usage: codelia mcp <add|list|remove|enable|disable|test|auth> ..."
+    );
+    return 1;
+  }
+  if (subcommand === "auth") {
+    return runMcpAuthCommand(rest);
+  }
+  const handled = await runMcpConfigCommand(subcommand, rest);
+  if (handled >= 0) {
+    return handled;
+  }
+  console.error(`unknown subcommand: ${subcommand}`);
+  return 1;
+};
+
+// src/tui/launcher.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_module = require("module");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_storage3 = require("@codelia/storage");
+var resolveTuiBinaryName = (platform) => platform === "win32" ? "codelia-tui.exe" : "codelia-tui";
+var TUI_PACKAGE_BY_TARGET = {
+  "darwin-arm64": "@codelia/tui-darwin-arm64",
+  "darwin-x64": "@codelia/tui-darwin-x64",
+  "linux-arm64": "@codelia/tui-linux-arm64",
+  "linux-x64": "@codelia/tui-linux-x64",
+  "win32-x64": "@codelia/tui-win32-x64"
+};
+var describeError3 = (error) => error instanceof Error ? error.message : String(error);
+var splitArgs = (value) => value.split(/\s+/).map((part) => part.trim()).filter((part) => part.length > 0);
+var quoteShellWord = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+var isExecutable = (candidate) => {
+  try {
+    import_node_fs.default.accessSync(candidate, import_node_fs.default.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var initStorage = async () => {
+  try {
+    const paths = (0, import_storage3.resolveStoragePaths)();
+    await (0, import_storage3.ensureStorageDirs)(paths);
+  } catch (error) {
+    console.warn(
+      `Failed to initialize storage directories: ${describeError3(error)}`
+    );
+  }
+};
+var resolveCliPackageRoot = () => {
+  const scriptPath = process.argv[1];
+  if (!scriptPath) return null;
+  try {
+    const resolvedScriptPath = import_node_fs.default.realpathSync(scriptPath);
+    const scriptDir = import_node_path2.default.dirname(resolvedScriptPath);
+    if (import_node_path2.default.basename(scriptDir) === "dist") {
+      return import_node_path2.default.dirname(scriptDir);
+    }
+    return scriptDir;
+  } catch {
+    return null;
+  }
+};
+var resolveRuntimeRequireBase = () => {
+  const cliPackageRoot = resolveCliPackageRoot();
+  if (cliPackageRoot) {
+    return import_node_path2.default.resolve(cliPackageRoot, "package.json");
+  }
+  return import_node_path2.default.resolve(process.cwd(), "package.json");
+};
+var runtimeRequire = (0, import_node_module.createRequire)(resolveRuntimeRequireBase());
+var resolveBundledRuntimeEntry = () => {
+  try {
+    return runtimeRequire.resolve("@codelia/runtime");
+  } catch {
+    return null;
+  }
+};
+var resolveInstalledPackageJson = (packageName) => {
+  try {
+    return runtimeRequire.resolve(`${packageName}/package.json`);
+  } catch {
+    return null;
+  }
+};
+var resolvePlatformTuiPackageName = (platform = process.platform, arch = process.arch) => TUI_PACKAGE_BY_TARGET[`${platform}-${arch}`] ?? null;
+var resolveOptionalTuiBinaryPath = (platform = process.platform, arch = process.arch, resolvePackageJson = resolveInstalledPackageJson) => {
+  const packageName = resolvePlatformTuiPackageName(platform, arch);
+  if (!packageName) {
+    return null;
+  }
+  const packageJsonPath = resolvePackageJson(packageName);
+  if (!packageJsonPath) {
+    return null;
+  }
+  return import_node_path2.default.resolve(
+    import_node_path2.default.dirname(packageJsonPath),
+    "bin",
+    resolveTuiBinaryName(platform)
+  );
+};
+var resolveRuntimeEnvForTui = (env, resolveRuntimeEntry = resolveBundledRuntimeEntry) => {
+  if (env.CODELIA_RUNTIME_CMD || env.CODELIA_RUNTIME_ARGS) {
+    return env;
+  }
+  const runtimeEntry = resolveRuntimeEntry();
+  if (!runtimeEntry) {
+    return env;
+  }
+  return {
+    ...env,
+    CODELIA_RUNTIME_CMD: process.execPath,
+    CODELIA_RUNTIME_ARGS: quoteShellWord(runtimeEntry)
+  };
+};
+var resolveTuiCommand = (options = {}) => {
+  const env = options.env ?? process.env;
+  if (env.CODELIA_TUI_CMD) {
+    return env.CODELIA_TUI_CMD;
+  }
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const resolveOptionalBinary = options.resolveOptionalTuiBinary ?? resolveOptionalTuiBinaryPath;
+  const isExecutableCandidate = options.isExecutableCandidate ?? isExecutable;
+  const tuiBinaryName = resolveTuiBinaryName(platform);
+  const cwd = options.cwd ?? process.cwd();
+  const cliPackageRoot = options.cliPackageRoot === void 0 ? resolveCliPackageRoot() : options.cliPackageRoot;
+  const seen = /* @__PURE__ */ new Set();
+  const optionalTuiBinary = resolveOptionalBinary(platform, arch);
+  const candidates = [
+    ...optionalTuiBinary ? [optionalTuiBinary] : [],
+    ...cliPackageRoot ? [
+      import_node_path2.default.resolve(cliPackageRoot, "dist/bin", tuiBinaryName),
+      import_node_path2.default.resolve(
+        cliPackageRoot,
+        "../../crates/tui/target/release",
+        tuiBinaryName
+      ),
+      import_node_path2.default.resolve(
+        cliPackageRoot,
+        "../../crates/tui/target/debug",
+        tuiBinaryName
+      )
+    ] : [],
+    import_node_path2.default.resolve(cwd, "target/release", tuiBinaryName),
+    import_node_path2.default.resolve(cwd, "target/debug", tuiBinaryName),
+    import_node_path2.default.resolve(cwd, "crates/tui/target/release", tuiBinaryName),
+    import_node_path2.default.resolve(cwd, "crates/tui/target/debug", tuiBinaryName)
+  ];
+  for (const candidate of candidates) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (isExecutableCandidate(candidate)) {
+      return candidate;
+    }
+  }
+  return tuiBinaryName;
+};
+var runTui = (args2) => {
+  void initStorage();
+  const tuiCmd = resolveTuiCommand();
+  const tuiArgs = process.env.CODELIA_TUI_ARGS ? splitArgs(process.env.CODELIA_TUI_ARGS) : [];
+  const child = (0, import_node_child_process2.spawn)(tuiCmd, [...tuiArgs, ...args2], {
+    stdio: "inherit",
+    env: resolveRuntimeEnvForTui(process.env)
+  });
+  child.on("exit", (code) => {
+    process.exitCode = code ?? 0;
+  });
+  child.on("error", (error) => {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code ?? "") : "";
+    const expectedPackage = resolvePlatformTuiPackageName();
+    console.error(`Failed to launch TUI (${tuiCmd}): ${describeError3(error)}`);
+    if (code === "EACCES") {
+      console.error(
+        "Permission denied while launching TUI. Verify execute permission and PATH entries."
+      );
+    } else if (code === "ENOENT") {
+      console.error(
+        expectedPackage ? `TUI binary not found. Ensure \`${expectedPackage}\` is installed, or run \`bun run build\` (or \`bun run tui:build\`) and retry.` : "TUI binary not found. Run `bun run build` (or `bun run tui:build`) and retry."
+      );
+    }
+    console.error(
+      "Set CODELIA_TUI_CMD/CODELIA_TUI_ARGS to use a custom TUI command."
+    );
+    process.exitCode = 1;
+  });
+};
+
+// src/index.ts
+var args = process.argv.slice(2);
+var main = async () => {
+  if (args[0] === "mcp") {
+    const exitCode = await runMcpCommand(args.slice(1));
+    process.exitCode = exitCode;
+    return;
+  }
+  runTui(args);
+};
+void main();