owletto 1.2.0 → 1.3.0

package/dist/bin.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   parseGlobalFlags
-} from "./chunk-NG33L2S7.js";
+} from "./chunk-ZDMROF24.js";
 import {
   CliError
-} from "./chunk-LPKFXYXP.js";
+} from "./chunk-ANTW3P24.js";
 import {
   defineCommand,
   printError,
@@ -19,21 +19,22 @@ var main = defineCommand({
     description: "Unified CLI for Owletto"
   },
   subCommands: {
-    version: () => import("./version-6NLY47MV.js").then((m) => m.default),
-    context: () => import("./context-R36C4KTS.js").then((m) => m.default),
-    login: () => import("./openclaw-NN7EIOSB.js").then((m) => m.login),
-    token: () => import("./openclaw-NN7EIOSB.js").then((m) => m.token),
-    health: () => import("./openclaw-NN7EIOSB.js").then((m) => m.health),
-    configure: () => import("./openclaw-NN7EIOSB.js").then((m) => m.configure),
-    db: () => import("./db-APU4VTB6.js").then((m) => m.default),
-    dev: () => import("./dev-EVH2ITQ7.js").then((m) => m.default),
-    doctor: () => import("./doctor-XONDHUND.js").then((m) => m.default),
-    server: () => import("./server-5GYVVR2T.js").then((m) => m.default),
-    worker: () => import("./worker-ETZD3I3B.js").then((m) => m.default),
-    embeddings: () => import("./embeddings-AH3BLVFN.js").then((m) => m.default),
-    connector: () => import("./connector-WVYEJLPU.js").then((m) => m.default),
-    feed: () => import("./feed-QKU5LWE6.js").then((m) => m.default),
-    mcp: () => import("./mcp-M2P7KK4C.js").then((m) => m.default)
+    version: () => import("./version-4EIVIAAI.js").then((m) => m.default),
+    context: () => import("./context-ERFLLCQK.js").then((m) => m.default),
+    login: () => import("./openclaw-Q6VSZHKD.js").then((m) => m.login),
+    token: () => import("./openclaw-Q6VSZHKD.js").then((m) => m.token),
+    health: () => import("./openclaw-Q6VSZHKD.js").then((m) => m.health),
+    configure: () => import("./openclaw-Q6VSZHKD.js").then((m) => m.configure),
+    db: () => import("./db-ETXQBGO2.js").then((m) => m.default),
+    dev: () => import("./dev-5HZQGSMK.js").then((m) => m.default),
+    doctor: () => import("./doctor-QZEC2GKR.js").then((m) => m.default),
+    server: () => import("./server-S66FQJBP.js").then((m) => m.default),
+    worker: () => import("./worker-WPTOEUR2.js").then((m) => m.default),
+    embeddings: () => import("./embeddings-425LPWPY.js").then((m) => m.default),
+    connector: () => import("./connector-26KT2II4.js").then((m) => m.default),
+    feed: () => import("./feed-SV333DHN.js").then((m) => m.default),
+    run: () => import("./run-RZZFXJNG.js").then((m) => m.default),
+    "browser-auth": () => import("./browser-auth-5NM6CIN7.js").then((m) => m.default)
   }
 });
 

package/dist/browser-auth-5NM6CIN7.js

@@ -0,0 +1,470 @@
+import {
+  getProfile
+} from "./chunk-ZDMROF24.js";
+import "./chunk-ANTW3P24.js";
+import {
+  defineCommand,
+  printText
+} from "./chunk-TMPMAYY4.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/commands/browser-auth.ts
+import { execSync, spawn } from "child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { get as httpGet } from "http";
+import { createServer } from "net";
+import { join } from "path";
+function getChromePaths() {
+  if (process.platform === "darwin") {
+    return {
+      binary: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      profileDir: join(process.env.HOME, "Library/Application Support/Google/Chrome")
+    };
+  }
+  if (process.platform === "linux") {
+    return {
+      binary: "/usr/bin/google-chrome",
+      profileDir: join(process.env.HOME, ".config/google-chrome")
+    };
+  }
+  throw new Error(`Unsupported platform: ${process.platform}`);
+}
+function listProfiles(profileDir) {
+  const localStatePath = join(profileDir, "Local State");
+  if (!existsSync(localStatePath)) {
+    throw new Error(`Chrome Local State not found at ${localStatePath}`);
+  }
+  const localState = JSON.parse(readFileSync(localStatePath, "utf8"));
+  const infoCache = localState.profile?.info_cache ?? {};
+  const lastUsed = localState.profile?.last_used ?? "";
+  return Object.entries(infoCache).map(([dir, info]) => ({
+    dir,
+    name: info.name ?? dir,
+    email: info.user_name ?? "",
+    isLastUsed: dir === lastUsed
+  }));
+}
+async function extractCookies(chromeBinary, profileDir, chromeProfileDir, domains) {
+  if (process.platform === "darwin") {
+    return extractCookiesMacOS(profileDir, chromeProfileDir, domains);
+  }
+  return extractCookiesCDP(chromeBinary, profileDir, chromeProfileDir, domains);
+}
+var BROWSER_KEYCHAIN = [
+  { service: "Chrome Safe Storage", account: "Chrome" },
+  { service: "Chromium Safe Storage", account: "Chromium" },
+  { service: "Brave Safe Storage", account: "Brave" },
+  { service: "Microsoft Edge Safe Storage", account: "Microsoft Edge" }
+];
+async function extractCookiesMacOS(profileDir, chromeProfileDir, domains) {
+  const { pbkdf2Sync, createDecipheriv } = await import("crypto");
+  const { DatabaseSync } = await import("sqlite");
+  const cookiePath = join(profileDir, chromeProfileDir, "Cookies");
+  if (!existsSync(cookiePath)) {
+    throw new Error(`No Cookies file found in Chrome profile: ${chromeProfileDir}`);
+  }
+  const tmpDir = mkdtempSync("/tmp/owletto-auth-");
+  const tmpCookiePath = join(tmpDir, "Cookies");
+  copyFileSync(cookiePath, tmpCookiePath);
+  const journalSrc = join(profileDir, chromeProfileDir, "Cookies-journal");
+  if (existsSync(journalSrc)) {
+    copyFileSync(journalSrc, join(tmpDir, "Cookies-journal"));
+  }
+  try {
+    printText(
+      `macOS will ask to access your browser's cookie encryption key.
+A system dialog from "security" will appear \u2014 click "Always Allow" to avoid future prompts.`
+    );
+    let keychainKey = null;
+    for (const { service, account } of BROWSER_KEYCHAIN) {
+      try {
+        keychainKey = execSync(
+          `security find-generic-password -w -s "${service}" -a "${account}"`,
+          { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+        ).trim();
+        if (keychainKey) break;
+      } catch {
+      }
+    }
+    if (!keychainKey) {
+      throw new Error(
+        'Could not read browser encryption key from macOS Keychain.\nIf a system dialog appeared, click "Always Allow" and retry.\nIf no dialog appeared, your Keychain may be locked \u2014 run: security unlock-keychain'
+      );
+    }
+    const derivedKey = pbkdf2Sync(keychainKey, "saltysalt", 1003, 16, "sha1");
+    const domainClauses = domains.map((d) => {
+      const clean = d.replace(/^\./, "");
+      return `host_key = '.${clean}' OR host_key = '${clean}' OR host_key LIKE '%.${clean}'`;
+    }).join(" OR ");
+    const db = new DatabaseSync(tmpCookiePath, { readOnly: true });
+    const rows = db.prepare(
+      `SELECT name, host_key, path, encrypted_value, CAST(expires_utc AS TEXT) as expires_utc_text, is_httponly, is_secure, samesite
+       FROM cookies WHERE ${domainClauses}`
+    ).all();
+    db.close();
+    const cookies = [];
+    const chromeEpochOffset = 11644473600n;
+    const iv = Buffer.alloc(16, " ");
+    for (const row of rows) {
+      const raw = row.encrypted_value;
+      const encrypted = raw instanceof Buffer ? raw : Buffer.from(raw);
+      let value = "";
+      if (encrypted && encrypted.length > 3) {
+        const version = encrypted.slice(0, 3).toString("utf-8");
+        if (version === "v10" || version === "v11") {
+          const ciphertext = encrypted.slice(3);
+          try {
+            const decipher = createDecipheriv("aes-128-cbc", derivedKey, iv);
+            const dec = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+            value = extractPrintableSuffix(dec);
+          } catch {
+            continue;
+          }
+        } else {
+          value = encrypted.toString("utf-8");
+        }
+      }
+      if (!value && !row.name) continue;
+      const expiresUtc = BigInt(row.expires_utc_text ?? "0");
+      const expiresUnix = expiresUtc > 0n ? Number(expiresUtc / 1000000n - chromeEpochOffset) : -1;
+      cookies.push({
+        name: row.name,
+        value,
+        domain: row.host_key,
+        path: row.path ?? "/",
+        expires: expiresUnix,
+        httpOnly: row.is_httponly === 1,
+        secure: row.is_secure === 1,
+        sameSite: row.samesite === 0 ? "None" : row.samesite === 1 ? "Lax" : "Strict"
+      });
+    }
+    return cookies;
+  } finally {
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function extractPrintableSuffix(buf) {
+  let boundary = buf.length;
+  for (let i = buf.length - 1; i >= 0; i--) {
+    const b = buf[i];
+    if (b >= 32 && b <= 126) {
+      boundary = i;
+    } else {
+      break;
+    }
+  }
+  return buf.slice(boundary).toString("utf-8");
+}
+async function extractCookiesCDP(chromeBinary, profileDir, chromeProfileDir, domains) {
+  const { chromium } = await import("playwright");
+  const port = await new Promise((resolve) => {
+    const srv = createServer();
+    srv.listen(0, () => {
+      const p = srv.address().port;
+      srv.close(() => resolve(p));
+    });
+  });
+  const tmpDir = mkdtempSync("/tmp/owletto-auth-");
+  mkdirSync(join(tmpDir, "Default"), { recursive: true });
+  const cookieSrc = join(profileDir, chromeProfileDir, "Cookies");
+  const journalSrc = join(profileDir, chromeProfileDir, "Cookies-journal");
+  if (!existsSync(cookieSrc)) {
+    rmSync(tmpDir, { recursive: true, force: true });
+    throw new Error(`No Cookies file found in Chrome profile: ${chromeProfileDir}`);
+  }
+  copyFileSync(cookieSrc, join(tmpDir, "Default/Cookies"));
+  if (existsSync(journalSrc)) {
+    copyFileSync(journalSrc, join(tmpDir, "Default/Cookies-journal"));
+  }
+  const chrome = spawn(
+    chromeBinary,
+    [
+      "--headless=new",
+      `--remote-debugging-port=${port}`,
+      "--remote-allow-origins=*",
+      "--user-data-dir=" + tmpDir,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-background-networking",
+      "--disable-sync",
+      "--profile-directory=Default"
+    ],
+    { detached: true, stdio: "ignore" }
+  );
+  chrome.unref();
+  try {
+    for (let i = 0; i < 15; i++) {
+      try {
+        await new Promise((resolve, reject) => {
+          httpGet(`http://localhost:${port}/json/version`, (res) => {
+            let d = "";
+            res.on("data", (c) => d += c);
+            res.on("end", () => resolve());
+          }).on("error", reject);
+        });
+        break;
+      } catch {
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+    }
+    const browser = await chromium.connectOverCDP(`http://localhost:${port}`);
+    const context = browser.contexts()[0];
+    const page = context.pages()[0] || await context.newPage();
+    const primaryDomain = domains[0];
+    const url = primaryDomain.startsWith("http") ? primaryDomain : `https://${primaryDomain}`;
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15e3 });
+    await page.waitForTimeout(2e3);
+    const cookieUrls = domains.map((d) => d.startsWith("http") ? d : `https://${d}`);
+    const cookies = await context.cookies(cookieUrls);
+    await browser.close();
+    return cookies;
+  } finally {
+    try {
+      process.kill(chrome.pid);
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function parseToolJson(text) {
+  if (!text.trim()) return {};
+  const normalized = text.trim().replace(/^```json\s*/, "").replace(/\s*```$/, "");
+  return JSON.parse(normalized);
+}
+function scoreAuthCookie(cookie) {
+  const name = cookie.name?.toLowerCase() ?? "";
+  if (!name) return Number.NEGATIVE_INFINITY;
+  if (/^(lang|li_theme|timezone|theme|locale|tz|visitor_id|guest_id)$/.test(name)) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  let score = 0;
+  if (/(auth|token|session|sess|sid|jwt)/.test(name)) score += 100;
+  if (/_at$/.test(name)) score += 80;
+  if (cookie.httpOnly) score += 20;
+  if (cookie.secure) score += 10;
+  if ((cookie.value?.length ?? 0) >= 20) score += 5;
+  if ((cookie.expires ?? 0) > 0) score += 5;
+  return score;
+}
+function findLikelyAuthCookie(cookies) {
+  const sorted = [...cookies].sort((a, b) => scoreAuthCookie(b) - scoreAuthCookie(a));
+  const best = sorted[0];
+  return best && scoreAuthCookie(best) > 0 ? best : null;
+}
+async function resolveConnectorDomains(connectorKey, domainsOverride, cliProfile) {
+  if (domainsOverride) {
+    return domainsOverride.split(",").map((d) => d.trim());
+  }
+  const { resolveMcpEndpoint, mcpRpc } = await import("./mcp-3EIPOE4A.js");
+  const mcpUrl = resolveMcpEndpoint(cliProfile.config);
+  if (!mcpUrl) {
+    printText("No MCP URL configured. Use --domains to specify cookie domains manually.");
+    return null;
+  }
+  const result = await mcpRpc(mcpUrl, "tools/call", {
+    name: "manage_connections",
+    arguments: { action: "list_connector_definitions" }
+  });
+  const text = result?.content?.[0]?.text ?? "";
+  const parsed = parseToolJson(text);
+  const connectors = Array.isArray(parsed) ? parsed : parsed?.connector_definitions ?? parsed?.connectors ?? [];
+  const connector = connectors.find((c) => c.key === connectorKey);
+  if (!connector) {
+    printText(`Unknown connector: ${connectorKey}`);
+    return null;
+  }
+  const faviconDomain = connector.favicon_domain;
+  if (!faviconDomain) {
+    printText(
+      `Connector "${connectorKey}" has no favicon_domain. Use --domains to specify cookie domains manually.`
+    );
+    return null;
+  }
+  return [faviconDomain, `.${faviconDomain}`];
+}
+var browserAuth = defineCommand({
+  meta: {
+    name: "browser-auth",
+    description: "Capture auth cookies from your local Chrome browser for a connector"
+  },
+  args: {
+    connector: {
+      type: "string",
+      description: 'Connector key (e.g., "x")',
+      required: true
+    },
+    domains: {
+      type: "string",
+      description: 'Comma-separated cookie domains (overrides server lookup, e.g., "x.com,.x.com")'
+    },
+    chromeProfile: {
+      type: "string",
+      alias: "cp",
+      description: "Chrome profile name (interactive prompt if not specified)"
+    },
+    authProfileSlug: {
+      type: "string",
+      alias: "p",
+      description: "Browser auth profile slug to store cookies on"
+    },
+    check: {
+      type: "boolean",
+      description: "Check if stored cookies for a browser auth profile are still valid"
+    }
+  },
+  async run({ args }) {
+    const cliProfile = getProfile();
+    const connectorKey = args.connector;
+    if (args.check) {
+      if (!args.authProfileSlug) {
+        printText("--check requires --authProfileSlug");
+        process.exitCode = 1;
+        return;
+      }
+      const { resolveMcpEndpoint, mcpRpc } = await import("./mcp-3EIPOE4A.js");
+      const mcpUrl = resolveMcpEndpoint(cliProfile.config);
+      if (!mcpUrl) {
+        printText("No MCP URL configured.");
+        process.exitCode = 1;
+        return;
+      }
+      const result = await mcpRpc(mcpUrl, "tools/call", {
+        name: "manage_auth_profiles",
+        arguments: { action: "test_auth_profile", auth_profile_slug: args.authProfileSlug }
+      });
+      const text = result?.content?.[0]?.text ?? "";
+      const parsed = parseToolJson(text);
+      if (parsed?.error) {
+        printText(`Error: ${parsed.error}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (parsed?.status === "ok") {
+        const expiresAt = parsed.expires_at ? new Date(parsed.expires_at) : null;
+        const daysLeft = expiresAt ? Math.floor((expiresAt.getTime() - Date.now()) / 864e5) : null;
+        printText(
+          `${parsed.auth_cookie_name || "Auth cookie"} valid${daysLeft !== null ? ` (expires in ${daysLeft} days)` : ""}.`
+        );
+        if (typeof parsed.cookie_count === "number") {
+          printText(`${parsed.cookie_count} cookies stored.`);
+        }
+      } else {
+        printText(parsed?.message || "Browser auth profile is not valid.");
+        process.exitCode = 1;
+      }
+      return;
+    }
+    const { binary, profileDir } = getChromePaths();
+    if (!existsSync(binary)) {
+      printText(`Chrome not found at ${binary}`);
+      process.exitCode = 1;
+      return;
+    }
+    const profiles = listProfiles(profileDir);
+    if (profiles.length === 0) {
+      printText("No Chrome profiles found");
+      process.exitCode = 1;
+      return;
+    }
+    let selectedProfile;
+    if (args.chromeProfile) {
+      const match = profiles.find(
+        (p) => p.name.toLowerCase() === args.chromeProfile.toLowerCase() || p.dir.toLowerCase() === args.chromeProfile.toLowerCase()
+      );
+      if (!match) {
+        printText(`Profile "${args.chromeProfile}" not found. Available:`);
+        for (const p of profiles) {
+          printText(`  [${p.dir}] ${p.name} (${p.email})${p.isLastUsed ? " <- last used" : ""}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+      selectedProfile = match;
+    } else {
+      printText("Chrome Profiles:");
+      for (let i = 0; i < profiles.length; i++) {
+        const p = profiles[i];
+        printText(`  [${i + 1}] ${p.name} (${p.email})${p.isLastUsed ? " <- last used" : ""}`);
+      }
+      const readline = await import("readline");
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve) => {
+        rl.question("\nPick a profile: ", resolve);
+      });
+      rl.close();
+      const idx = parseInt(answer, 10) - 1;
+      if (Number.isNaN(idx) || idx < 0 || idx >= profiles.length) {
+        printText("Invalid selection");
+        process.exitCode = 1;
+        return;
+      }
+      selectedProfile = profiles[idx];
+    }
+    printText(`
+Using profile: ${selectedProfile.name} (${selectedProfile.email})`);
+    printText("Resolving connector domains...");
+    const domains = await resolveConnectorDomains(connectorKey, args.domains, cliProfile);
+    if (!domains) {
+      process.exitCode = 1;
+      return;
+    }
+    printText(`Cookie domains: ${domains.join(", ")}`);
+    printText("Extracting cookies...");
+    const cookies = await extractCookies(binary, profileDir, selectedProfile.dir, domains);
+    if (cookies.length === 0) {
+      printText("No cookies found. Are you logged into the site in this Chrome profile?");
+      process.exitCode = 1;
+      return;
+    }
+    const authCookie = findLikelyAuthCookie(cookies);
+    if (!authCookie) {
+      printText("Warning: No likely auth cookie found. You may not be logged in.");
+    }
+    printText(`Captured ${cookies.length} cookies`);
+    if (args.authProfileSlug) {
+      printText("Saving cookies to auth profile...");
+      const { resolveMcpEndpoint, mcpRpc } = await import("./mcp-3EIPOE4A.js");
+      const mcpUrl = resolveMcpEndpoint(cliProfile.config);
+      if (!mcpUrl) {
+        printText("No MCP URL configured. Store cookies manually.");
+      } else {
+        const result = await mcpRpc(mcpUrl, "tools/call", {
+          name: "manage_auth_profiles",
+          arguments: {
+            action: "update_auth_profile",
+            auth_profile_slug: args.authProfileSlug,
+            auth_data: {
+              cookies,
+              captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+              captured_via: "cli",
+              browser_profile: selectedProfile.name
+            }
+          }
+        });
+        const responseText = result?.content?.[0]?.text ?? "";
+        const parsed = parseToolJson(responseText);
+        if (parsed?.error) {
+          printText(`Error: ${parsed.error}`);
+        } else {
+          printText(`Cookies stored on auth profile ${args.authProfileSlug}.`);
+        }
+      }
+    } else {
+      printText("\nCookies ready. To store on a browser auth profile:");
+      printText(
+        `  owletto browser-auth --connector ${connectorKey} --authProfileSlug <SLUG> --chromeProfile "${selectedProfile.name}"`
+      );
+    }
+  }
+});
+var browser_auth_default = browserAuth;
+export {
+  browser_auth_default as default
+};

package/dist/{mcp-M2P7KK4C.js → chunk-6USNZB7E.js}

@@ -1,21 +1,11 @@
-import {
-  getProfile
-} from "./chunk-NG33L2S7.js";
 import {
   ApiError,
-  ValidationError,
+  deriveMcpUrl,
   getUsableToken
-} from "./chunk-LPKFXYXP.js";
-import {
-  defineCommand,
-  isJson,
-  printContextHeader,
-  printJson,
-  printText
-} from "./chunk-TMPMAYY4.js";
-import "./chunk-QGM4M3NI.js";
+} from "./chunk-ANTW3P24.js";
 
 // src/commands/mcp.ts
+var JSON_MCP_ACCEPT = "application/json";
 function uniqueStrings(values) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -62,19 +52,25 @@ async function fetchMcpWithFallback(mcpUrl, init) {
   }
   throw new Error(formatNetworkErrorMessage(lastError, candidates));
 }
-async function mcpRpc(apiUrl, method, params) {
-  const body = {
-    jsonrpc: "2.0",
-    id: 1,
-    method,
-    params: params || {}
-  };
+function resolveMcpEndpoint(config) {
+  if (typeof config.mcpUrl === "string" && config.mcpUrl.trim().length > 0) {
+    return config.mcpUrl;
+  }
+  if (typeof config.apiUrl === "string" && config.apiUrl.trim().length > 0) {
+    return deriveMcpUrl(config.apiUrl);
+  }
+  return null;
+}
+async function mcpFetch(mcpUrl, body, sessionId) {
   const headers = { "Content-Type": "application/json" };
   const tokenResult = await getUsableToken();
   if (tokenResult) {
     headers.Authorization = `Bearer ${tokenResult.token}`;
   }
-  const mcpUrl = `${apiUrl}/mcp`;
+  headers.Accept = JSON_MCP_ACCEPT;
+  if (sessionId) {
+    headers["mcp-session-id"] = sessionId;
+  }
   const { response: res, usedUrl } = await fetchMcpWithFallback(mcpUrl, {
     method: "POST",
     headers,
@@ -86,63 +82,57 @@ async function mcpRpc(apiUrl, method, params) {
       res.status
     );
   }
-  const data = await res.json();
+  const raw = await res.text();
+  const data = raw.length > 0 ? JSON.parse(raw) : {};
+  return { data, usedUrl, response: res };
+}
+async function initializeMcpSession(mcpUrl) {
+  const { data, usedUrl, response } = await mcpFetch(mcpUrl, {
+    jsonrpc: "2.0",
+    id: "__init__",
+    method: "initialize",
+    params: {
+      protocolVersion: "2025-03-26",
+      capabilities: {},
+      clientInfo: { name: "owletto-cli", version: "1.0.0" }
+    }
+  });
   if (data.error) {
     throw new ApiError(`MCP error: ${data.error.message} (code ${data.error.code})`);
   }
-  return data.result;
-}
-var tools = defineCommand({
-  meta: { name: "tools", description: "List available MCP tools" },
-  async run() {
-    const profile = getProfile();
-    printContextHeader(profile.name, "mcp tools");
-    const apiUrl = profile.config.apiUrl;
-    if (!apiUrl) throw new ValidationError("apiUrl required in profile");
-    const result = await mcpRpc(apiUrl, "tools/list");
-    const resultObj = result;
-    const toolList = resultObj.tools ?? (Array.isArray(result) ? result : []);
-    if (isJson()) {
-      printJson({ tools: toolList }, profile);
-    } else {
-      for (const tool of toolList) {
-        printText(`  ${tool.name}${tool.description ? ` \u2014 ${tool.description}` : ""}`);
-      }
-      printText(`
-${toolList.length} tool(s)`);
-    }
+  const sessionId = response.headers.get("mcp-session-id");
+  if (!sessionId) {
+    throw new ApiError(`MCP initialize via ${usedUrl} did not return an mcp-session-id header`);
   }
-});
-var call = defineCommand({
-  meta: { name: "call", description: "Call an MCP tool" },
-  args: {
-    tool: { type: "positional", description: "Tool name to call", required: true },
-    params: { type: "string", description: "JSON parameters for the tool call" }
-  },
-  async run({ args }) {
-    const profile = getProfile();
-    printContextHeader(profile.name, `mcp call ${args.tool}`);
-    const apiUrl = profile.config.apiUrl;
-    if (!apiUrl) throw new ValidationError("apiUrl required in profile");
-    const params = args.params ? JSON.parse(args.params) : {};
-    const result = await mcpRpc(apiUrl, "tools/call", {
-      name: args.tool,
-      arguments: params
-    });
-    if (isJson()) {
-      printJson({ result }, profile);
-    } else {
-      printText(JSON.stringify(result, null, 2));
-    }
+  await mcpFetch(
+    mcpUrl,
+    {
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    },
+    sessionId
+  );
+  return { sessionId, usedUrl };
+}
+async function mcpRpc(mcpUrl, method, params) {
+  const { sessionId } = await initializeMcpSession(mcpUrl);
+  const { data } = await mcpFetch(
+    mcpUrl,
+    {
+      jsonrpc: "2.0",
+      id: 1,
+      method,
+      params: params || {}
+    },
+    sessionId
+  );
+  if (data.error) {
+    throw new ApiError(`MCP error: ${data.error.message} (code ${data.error.code})`);
   }
-});
-var mcp_default = defineCommand({
-  meta: {
-    name: "mcp",
-    description: "Interact with the MCP endpoint"
-  },
-  subCommands: { tools, call }
-});
+  return data.result;
+}
+
 export {
-  mcp_default as default
+  resolveMcpEndpoint,
+  mcpRpc
 };