@codemap-ai/cli 0.1.0

package/dist/chunk-A2QHID6K.js

@@ -0,0 +1,34 @@
+import{createRequire as __cmr}from"node:module";import{fileURLToPath as __f2p}from"node:url";import{dirname as __dn}from"node:path";var require=__cmr(import.meta.url);var __filename=__f2p(import.meta.url);var __dirname=__dn(__filename);
+
+// src/cli-agent/chat/ui/stderr-interceptor.ts
+var _gatewayOffline = false;
+function isGatewayOffline() {
+  return _gatewayOffline;
+}
+function installStderrInterceptor() {
+  const original = process.stderr.write.bind(process.stderr);
+  process.stderr.write = function(chunk, encodingOrCb, cb) {
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    if (isGatewayNoise(text)) {
+      _gatewayOffline = true;
+      const callback = typeof encodingOrCb === "function" ? encodingOrCb : cb;
+      callback?.();
+      return true;
+    }
+    return original(chunk, encodingOrCb, cb);
+  };
+  return () => {
+    process.stderr.write = original;
+  };
+}
+function isGatewayNoise(text) {
+  return text.includes("[GatewayRegistry]") || text.includes("[GatewaySync]") || text.includes("models.dev") && (text.includes("fetch failed") || text.includes("ENOTFOUND")) || // Mastra logs raw LLM API errors (timeout, connection refused, etc.) directly to
+  // stderr. The actual error propagates through the harness error event and is
+  // already surfaced as a UI message — swallow the redundant raw dump here.
+  text.includes("Upstream LLM API error");
+}
+
+export {
+  isGatewayOffline,
+  installStderrInterceptor
+};

package/dist/chunk-AXGGL47C.js

@@ -0,0 +1,457 @@
+import{createRequire as __cmr}from"node:module";import{fileURLToPath as __f2p}from"node:url";import{dirname as __dn}from"node:path";var require=__cmr(import.meta.url);var __filename=__f2p(import.meta.url);var __dirname=__dn(__filename);
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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/config.ts
+import { homedir } from "os";
+import path from "path";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+var DEFAULT_API_URL = "https://api.codemap.dev";
+function readOptionalEnv(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : null;
+}
+function normalizeConfigFile(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return {};
+  }
+  const record = input;
+  const apiUrl = typeof record.apiUrl === "string" && record.apiUrl.trim() ? record.apiUrl.trim() : null;
+  const apiToken = typeof record.apiToken === "string" && record.apiToken.trim() ? record.apiToken.trim() : null;
+  const userRecord = record.user && typeof record.user === "object" && !Array.isArray(record.user) ? record.user : null;
+  const authRecord = record.auth && typeof record.auth === "object" && !Array.isArray(record.auth) ? record.auth : null;
+  const user = userRecord ? {
+    id: typeof userRecord.id === "string" && userRecord.id.trim() ? userRecord.id.trim() : void 0,
+    email: typeof userRecord.email === "string" && userRecord.email.trim() ? userRecord.email.trim() : void 0,
+    name: typeof userRecord.name === "string" && userRecord.name.trim() ? userRecord.name.trim() : void 0
+  } : null;
+  const auth = authRecord ? {
+    method: "api_key",
+    createdAt: typeof authRecord.createdAt === "string" && authRecord.createdAt.trim() ? authRecord.createdAt.trim() : void 0,
+    lastValidatedAt: typeof authRecord.lastValidatedAt === "string" && authRecord.lastValidatedAt.trim() ? authRecord.lastValidatedAt.trim() : void 0
+  } : null;
+  return {
+    ...apiUrl ? { apiUrl } : {},
+    ...apiToken ? { apiToken } : {},
+    ...user ? { user } : {},
+    ...auth ? { auth } : {}
+  };
+}
+async function readConfigFile(configPath) {
+  try {
+    const rawContent = await readFile(configPath, "utf8");
+    return normalizeConfigFile(JSON.parse(rawContent));
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function getConfigPaths(cwd = process.cwd()) {
+  return {
+    projectConfigPath: path.join(cwd, ".codemap", "mcp.json"),
+    globalConfigPath: path.join(homedir(), ".codemap", "mcp.json")
+  };
+}
+function applyLayer(resolved, layer) {
+  if (!layer) {
+    return resolved;
+  }
+  const nextResolved = { ...resolved };
+  const nextApiUrl = layer.apiUrl?.trim() || null;
+  if (nextApiUrl && nextApiUrl !== nextResolved.apiUrl) {
+    nextResolved.apiUrl = nextApiUrl;
+    if (!layer.apiToken) {
+      nextResolved.apiToken = null;
+      nextResolved.user = null;
+      nextResolved.auth = null;
+    }
+  }
+  if (layer.apiToken !== void 0) {
+    nextResolved.apiToken = layer.apiToken ?? null;
+  }
+  if (layer.user !== void 0) {
+    nextResolved.user = layer.user ?? null;
+  }
+  if (layer.auth !== void 0) {
+    nextResolved.auth = layer.auth ?? null;
+  }
+  return nextResolved;
+}
+async function loadConfig(cwd = process.cwd()) {
+  const { projectConfigPath, globalConfigPath } = getConfigPaths(cwd);
+  const [projectConfig, globalConfig] = await Promise.all([
+    readConfigFile(projectConfigPath),
+    readConfigFile(globalConfigPath)
+  ]);
+  const envConfig = {
+    apiUrl: readOptionalEnv("CODEMAP_API_URL"),
+    apiToken: readOptionalEnv("CODEMAP_API_KEY")
+  };
+  const toolModeRaw = readOptionalEnv("CODEMAP_TOOL_MODE");
+  const toolMode = toolModeRaw === "lite" || toolModeRaw === "full" ? toolModeRaw : "standard";
+  let resolved = {
+    apiUrl: DEFAULT_API_URL,
+    apiToken: null,
+    user: null,
+    auth: null,
+    projectConfigPath,
+    globalConfigPath,
+    toolMode
+  };
+  resolved = applyLayer(resolved, envConfig);
+  resolved = applyLayer(resolved, globalConfig);
+  resolved = applyLayer(resolved, projectConfig);
+  return resolved;
+}
+async function writeConfigFile(configPath, config) {
+  await mkdir(path.dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function saveGlobalConfig(config) {
+  await writeConfigFile(config.globalConfigPath, {
+    apiUrl: config.apiUrl,
+    apiToken: config.apiToken,
+    user: config.user,
+    auth: config.auth
+  });
+}
+async function clearGlobalAuthConfig(config) {
+  const existingConfig = await readConfigFile(config.globalConfigPath);
+  if (!existingConfig) {
+    return;
+  }
+  const nextConfig = {
+    apiUrl: existingConfig.apiUrl ?? null
+  };
+  await writeConfigFile(config.globalConfigPath, nextConfig);
+}
+
+// src/lib/mcp-auth.ts
+import os from "os";
+
+// src/lib/codemap-api.ts
+function createCodeMapClient(config) {
+  function buildUrl(path2, query) {
+    const url = new URL(path2, config.apiUrl);
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value !== void 0) url.searchParams.set(key, value);
+    }
+    return url;
+  }
+  function buildAuthHeaders(extra) {
+    const headers = { ...extra };
+    if (config.apiToken) {
+      headers["x-api-key"] = config.apiToken;
+      headers["Authorization"] = `Bearer ${config.apiToken}`;
+    }
+    return headers;
+  }
+  async function handleResponse(response) {
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(
+        `CodeMap API returned ${response.status} ${response.statusText}. ${body}`.trim()
+      );
+    }
+    const json = await response.json();
+    if (json.data === void 0) throw new Error("Unexpected response from API.");
+    return json.data;
+  }
+  function checkAuth(required) {
+    if (required && !config.apiToken) {
+      throw new Error("Not authenticated. Run `codemap login`.");
+    }
+  }
+  async function request(path2, options) {
+    checkAuth(options?.authRequired);
+    const url = buildUrl(path2, options?.query);
+    const hasBody = options?.body !== void 0;
+    const headers = buildAuthHeaders(hasBody ? { "Content-Type": "application/json" } : void 0);
+    let response;
+    try {
+      response = await fetch(url.toString(), {
+        method: options?.method ?? "GET",
+        headers,
+        body: hasBody ? JSON.stringify(options.body) : void 0
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to reach CodeMap API at ${config.apiUrl}. ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return handleResponse(response);
+  }
+  async function upload(path2, buffer, options) {
+    checkAuth(options?.authRequired);
+    const url = buildUrl(path2, options?.query);
+    const headers = buildAuthHeaders({ "Content-Type": "application/zip" });
+    let response;
+    try {
+      response = await fetch(url.toString(), {
+        method: "POST",
+        headers,
+        body: Buffer.from(buffer)
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to reach CodeMap API at ${config.apiUrl}. ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return handleResponse(response);
+  }
+  return { request, upload };
+}
+
+// src/lib/open-url.ts
+import { spawn } from "child_process";
+function getOpenCommand(url) {
+  switch (process.platform) {
+    case "darwin":
+      return {
+        command: "open",
+        args: [url]
+      };
+    case "win32":
+      return {
+        command: "cmd",
+        args: ["/c", "start", "", url]
+      };
+    default:
+      return {
+        command: "xdg-open",
+        args: [url]
+      };
+  }
+}
+async function openUrlInBrowser(url) {
+  const launcher = getOpenCommand(url);
+  const child = spawn(launcher.command, launcher.args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+
+// src/lib/mcp-auth.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function startMcpLogin(client) {
+  return client.request("/mcp/auth/start", {
+    method: "POST",
+    body: {
+      clientName: "CodeMap MCP",
+      deviceName: os.hostname()
+    }
+  });
+}
+async function getMcpAuthStatus(client, sessionId) {
+  return client.request("/mcp/auth/status", {
+    query: { sessionId }
+  });
+}
+async function getMcpWhoAmI(client) {
+  return client.request("/mcp/auth/me", {
+    authRequired: true
+  });
+}
+async function claimMcpAuthSession(client, sessionId) {
+  return client.request("/mcp/auth/claim", {
+    method: "POST",
+    body: { sessionId }
+  });
+}
+async function persistAuthorizedSession(config, status) {
+  if (!status.apiKey) {
+    throw new Error("Cannot persist MCP auth session without an API key.");
+  }
+  const auth = {
+    method: "api_key",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const apiUrl = status.apiUrl || config.apiUrl;
+  await saveGlobalConfig({
+    globalConfigPath: config.globalConfigPath,
+    apiUrl,
+    apiToken: status.apiKey,
+    user: status.user ?? null,
+    auth
+  });
+  config.apiUrl = apiUrl;
+  config.apiToken = status.apiKey;
+  config.user = status.user ?? null;
+  config.auth = auth;
+}
+async function pollMcpAuthUntilDone(config, sessionId, options) {
+  const client = createCodeMapClient(config);
+  const pollIntervalMs = options?.pollIntervalMs && options.pollIntervalMs > 0 ? options.pollIntervalMs : 2e3;
+  let effectiveExpiresAt = options?.expiresAt ?? null;
+  const startedAtMs = Date.now();
+  const maxWaitMs = options?.maxWaitMs !== void 0 && options.maxWaitMs !== null ? Math.max(0, options.maxWaitMs) : null;
+  while (true) {
+    const status = await getMcpAuthStatus(client, sessionId);
+    if (!effectiveExpiresAt && status.expiresAt) {
+      effectiveExpiresAt = status.expiresAt;
+    }
+    const expiresAtMs = effectiveExpiresAt ? new Date(effectiveExpiresAt).getTime() : null;
+    if (status.status === "authorized") {
+      try {
+        const claimResult = await claimMcpAuthSession(client, sessionId);
+        await persistAuthorizedSession(config, claimResult);
+        return {
+          authenticated: true,
+          status: "authorized",
+          apiUrl: claimResult.apiUrl || config.apiUrl,
+          user: claimResult.user ?? null,
+          expiresAt: claimResult.expiresAt ?? effectiveExpiresAt
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("already been claimed")) {
+          throw new Error(
+            "Authorization completed, but the CodeMap MCP API key was already claimed by another client or request."
+          );
+        }
+        throw error;
+      }
+    }
+    if (status.status === "expired") {
+      return {
+        authenticated: false,
+        status: "expired",
+        apiUrl: status.apiUrl || config.apiUrl,
+        user: status.user ?? null,
+        expiresAt: effectiveExpiresAt
+      };
+    }
+    if (status.status === "denied") {
+      return {
+        authenticated: false,
+        status: "denied",
+        apiUrl: status.apiUrl || config.apiUrl,
+        user: status.user ?? null,
+        expiresAt: effectiveExpiresAt
+      };
+    }
+    const nowMs = Date.now();
+    if (expiresAtMs !== null && nowMs >= expiresAtMs) {
+      return {
+        authenticated: false,
+        status: "expired",
+        apiUrl: status.apiUrl || config.apiUrl,
+        user: status.user ?? null,
+        expiresAt: effectiveExpiresAt
+      };
+    }
+    if (maxWaitMs !== null && nowMs - startedAtMs >= maxWaitMs) {
+      return {
+        authenticated: false,
+        status: "pending",
+        apiUrl: status.apiUrl || config.apiUrl,
+        user: status.user ?? null,
+        expiresAt: effectiveExpiresAt,
+        timedOut: true
+      };
+    }
+    const sleepMs = Math.min(
+      pollIntervalMs,
+      expiresAtMs !== null ? Math.max(0, expiresAtMs - nowMs) : pollIntervalMs,
+      maxWaitMs !== null ? Math.max(0, maxWaitMs - (nowMs - startedAtMs)) : pollIntervalMs
+    );
+    if (sleepMs <= 0) {
+      continue;
+    }
+    await sleep(sleepMs);
+  }
+}
+async function runLoginFlow(config) {
+  const client = createCodeMapClient(config);
+  const startResponse = await startMcpLogin(client);
+  const openedBrowser = await tryOpenLoginBrowser(startResponse.authorizeUrl);
+  const result = await waitForLoginAuthorization(config, startResponse);
+  return {
+    openedBrowser,
+    authorizeUrl: startResponse.authorizeUrl,
+    user: result.user ?? null,
+    apiUrl: result.apiUrl || config.apiUrl
+  };
+}
+async function tryOpenLoginBrowser(authorizeUrl) {
+  try {
+    await openUrlInBrowser(authorizeUrl);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForLoginAuthorization(config, startResponse) {
+  const result = await pollMcpAuthUntilDone(config, startResponse.sessionId, {
+    expiresAt: startResponse.expiresAt,
+    pollIntervalMs: startResponse.pollIntervalMs
+  });
+  if (result.status === "authorized") {
+    return {
+      sessionId: startResponse.sessionId,
+      status: "authorized",
+      expiresAt: result.expiresAt,
+      apiUrl: result.apiUrl,
+      user: result.user
+    };
+  }
+  if (result.status === "expired") {
+    throw new Error("MCP login session expired before authorization completed.");
+  }
+  if (result.status === "denied") {
+    throw new Error("MCP login was denied.");
+  }
+  throw new Error("MCP login timed out before authorization completed.");
+}
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  loadConfig,
+  clearGlobalAuthConfig,
+  createCodeMapClient,
+  openUrlInBrowser,
+  startMcpLogin,
+  getMcpWhoAmI,
+  pollMcpAuthUntilDone,
+  runLoginFlow,
+  tryOpenLoginBrowser,
+  waitForLoginAuthorization
+};