@gravity-rail/cli 0.1.0 → 0.3.0

package/dist/chunk-OIFV7TAT.js

@@ -0,0 +1,773 @@
+// src/cli-utils/config.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+var ENVIRONMENTS = {
+  dev: {
+    apiUrl: "http://localhost:5050",
+    frontendUrl: "http://localhost:3000"
+  },
+  prod: {
+    apiUrl: "https://api.gravityrail.com",
+    frontendUrl: "https://app.gravityrail.com"
+  },
+  staging: {
+    apiUrl: "https://api.gr-staging.com",
+    frontendUrl: "https://app.gr-staging.com"
+  }
+};
+var CALLBACK_PORT = 31337;
+var CALLBACK_PATH = "/oauth/callback";
+var REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+function detectWorktreePorts() {
+  let dir = resolve(process.cwd());
+  let overridePath;
+  while (true) {
+    const candidate = join(dir, "docker-compose.override.yml");
+    if (existsSync(candidate)) {
+      overridePath = candidate;
+      break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (!overridePath) return {};
+  let content;
+  try {
+    content = readFileSync(overridePath, "utf-8");
+  } catch {
+    return {};
+  }
+  if (!content.includes("worktree-setup.sh")) return {};
+  let apiPort;
+  let frontendPort;
+  for (const match of content.matchAll(/-\s*'(\d+):(\d+)'/g)) {
+    const host = parseInt(match[1], 10);
+    const container = parseInt(match[2], 10);
+    if (container === 5050) apiPort = host;
+    if (container === 3e3) frontendPort = host;
+  }
+  return { apiPort, frontendPort };
+}
+function getEnvironmentConfig(env) {
+  if (env.startsWith("dev-cloud:")) {
+    const namespace = env.slice("dev-cloud:".length);
+    if (!namespace) {
+      throw new Error("dev-cloud environment requires a namespace: --env dev-cloud:NAMESPACE");
+    }
+    return {
+      apiUrl: `https://${namespace}-api.gravityrail-dev.com`,
+      frontendUrl: `https://${namespace}-app.gravityrail-dev.com`
+    };
+  }
+  const config = ENVIRONMENTS[env];
+  if (!config) {
+    throw new Error(
+      `Invalid environment: ${env}. Use 'dev', 'staging', 'prod', or 'dev-cloud:NAMESPACE'.`
+    );
+  }
+  const apiUrl = process.env.GRAVITY_RAIL_API_URL || config.apiUrl;
+  const frontendUrl = process.env.GRAVITY_RAIL_FRONTEND_URL || config.frontendUrl;
+  if (apiUrl !== config.apiUrl || frontendUrl !== config.frontendUrl) {
+    return { apiUrl, frontendUrl };
+  }
+  if (env === "dev") {
+    const ports = detectWorktreePorts();
+    if (ports.apiPort || ports.frontendPort) {
+      return {
+        apiUrl: ports.apiPort ? `http://localhost:${ports.apiPort}` : config.apiUrl,
+        frontendUrl: ports.frontendPort ? `http://localhost:${ports.frontendPort}` : config.frontendUrl
+      };
+    }
+  }
+  return config;
+}
+
+// src/cli-utils/auth.ts
+import { createServer } from "http";
+import { createHash, randomBytes } from "crypto";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync, chmodSync, unlinkSync } from "fs";
+import { join as join2 } from "path";
+import { exec } from "child_process";
+var CredentialsManager = class {
+  cacheDir;
+  apiUrl;
+  constructor(rootDir, apiUrl) {
+    this.cacheDir = join2(rootDir, ".gr-cli");
+    this.apiUrl = apiUrl;
+  }
+  getCredentialsPath(env) {
+    if (this.apiUrl) {
+      try {
+        const url = new URL(this.apiUrl);
+        if (url.hostname === "localhost" && url.port && url.port !== "5050") {
+          return join2(this.cacheDir, `credentials-${env}-${url.port}.json`);
+        }
+      } catch {
+      }
+    }
+    return join2(this.cacheDir, `credentials-${env}.json`);
+  }
+  load(env) {
+    const credsPath = this.getCredentialsPath(env);
+    if (!existsSync2(credsPath)) {
+      return null;
+    }
+    try {
+      const raw = JSON.parse(readFileSync2(credsPath, "utf-8"));
+      let creds;
+      if (raw.clientId !== void 0) {
+        creds = raw;
+      } else if (raw.default) {
+        creds = raw.default;
+        this.save(env, creds);
+      } else {
+        return null;
+      }
+      if (creds.expiresAt) {
+        const expiresAt = new Date(creds.expiresAt);
+        if (expiresAt <= /* @__PURE__ */ new Date()) {
+          if (creds.refreshToken) {
+            return creds;
+          }
+          return null;
+        }
+      }
+      return creds;
+    } catch {
+      return null;
+    }
+  }
+  save(env, creds) {
+    if (!existsSync2(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+    const credsPath = this.getCredentialsPath(env);
+    writeFileSync(credsPath, JSON.stringify(creds, null, 2));
+    try {
+      chmodSync(credsPath, 384);
+    } catch {
+    }
+  }
+  clear(env) {
+    const credsPath = this.getCredentialsPath(env);
+    if (!existsSync2(credsPath)) {
+      return;
+    }
+    try {
+      unlinkSync(credsPath);
+    } catch {
+    }
+  }
+  getCacheDir() {
+    return this.cacheDir;
+  }
+};
+function stderr(msg) {
+  process.stderr.write(msg + "\n");
+}
+function isOAuthError(body, errorCode) {
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.error === errorCode) return true;
+  } catch {
+  }
+  return body.includes(errorCode);
+}
+function validateTokenResponse(tokenData) {
+  if (!tokenData.access_token || typeof tokenData.access_token !== "string") {
+    throw new Error("Token response missing access_token");
+  }
+  if (tokenData.token_type && String(tokenData.token_type).toLowerCase() !== "bearer") {
+    throw new Error(`Unsupported token type: ${tokenData.token_type}`);
+  }
+  let expiresIn = 86400;
+  if (tokenData.expires_in != null) {
+    const raw = Number(tokenData.expires_in);
+    if (!Number.isFinite(raw) || raw < 60 || raw > 31536e3) {
+      stderr(`  Warning: unusual expires_in value (${tokenData.expires_in}), using default`);
+    } else {
+      expiresIn = raw;
+    }
+  }
+  return {
+    accessToken: tokenData.access_token,
+    refreshToken: typeof tokenData.refresh_token === "string" ? tokenData.refresh_token : void 0,
+    expiresIn
+  };
+}
+function generatePKCE() {
+  const codeVerifier = randomBytes(64).toString("base64url").slice(0, 128);
+  const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
+  return { codeVerifier, codeChallenge };
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+  if (platform === "darwin") {
+    cmd = `open "${url}"`;
+  } else if (platform === "win32") {
+    cmd = `start "" "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+  exec(cmd, (err) => {
+    if (err) {
+      stderr("  Could not open browser automatically.");
+    }
+  });
+}
+function startCallbackServer() {
+  return new Promise((resolve2, reject) => {
+    let authCode = null;
+    let error = null;
+    let receivedState = null;
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);
+      if (url.pathname !== CALLBACK_PATH) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      if (url.searchParams.has("error")) {
+        error = url.searchParams.get("error");
+        const errorDesc = url.searchParams.get("error_description") || "Unknown error";
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+          <head><title>Authorization Failed</title></head>
+          <body style="font-family: system-ui; text-align: center; padding: 50px;">
+            <h1 style="color: #dc2626;">Authorization Failed</h1>
+            <p>${errorDesc}</p>
+            <p>You can close this window.</p>
+          </body>
+          </html>
+        `);
+        server.close();
+        reject(new Error(`Authorization failed: ${error}`));
+      } else if (url.searchParams.has("code")) {
+        authCode = url.searchParams.get("code");
+        receivedState = url.searchParams.get("state");
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+          <head><title>Authorization Successful</title></head>
+          <body style="font-family: system-ui; text-align: center; padding: 50px;">
+            <h1 style="color: #16a34a;">Authorization Successful!</h1>
+            <p>You can close this window and return to the terminal.</p>
+            <script>setTimeout(() => window.close(), 2000);</script>
+          </body>
+          </html>
+        `);
+        server.close();
+        resolve2({ code: authCode, state: receivedState });
+      } else {
+        res.writeHead(400);
+        res.end("Missing code parameter");
+      }
+    });
+    server.listen(CALLBACK_PORT, "localhost", () => {
+    });
+    const timeout = setTimeout(
+      () => {
+        if (!authCode && !error) {
+          server.close();
+          reject(new Error("Authorization timeout - no response received"));
+        }
+      },
+      5 * 60 * 1e3
+    );
+    timeout.unref();
+  });
+}
+async function dynamicClientRegistration(envConfig, clientName = "Gravity CLI") {
+  stderr("  Registering OAuth client...");
+  const registrationUrl = `${envConfig.apiUrl}/api/v2/oauth/register`;
+  const registrationData = {
+    client_name: clientName,
+    redirect_uris: [REDIRECT_URI],
+    grant_types: ["authorization_code", "refresh_token"],
+    response_types: ["code"],
+    token_endpoint_auth_method: "client_secret_basic",
+    scope: "workspace:admin"
+  };
+  const response = await fetch(registrationUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(registrationData)
+  });
+  if (!response.ok) {
+    throw new Error(`Client registration failed: ${response.status} - ${await response.text()}`);
+  }
+  return await response.json();
+}
+async function performOAuthFlow(options) {
+  const { env, envConfig, credentialsManager, clientName = "Gravity CLI" } = options;
+  let hasRetried = false;
+  while (true) {
+    let creds = credentialsManager.load(env);
+    if (!creds || !creds.clientId) {
+      const registration = await dynamicClientRegistration(envConfig, clientName);
+      creds = {
+        clientId: registration.client_id,
+        clientSecret: registration.client_secret
+      };
+      credentialsManager.save(env, creds);
+    } else {
+      stderr("  Using cached client credentials");
+    }
+    const { codeVerifier, codeChallenge } = generatePKCE();
+    const state = randomBytes(32).toString("base64url");
+    const authParams = new URLSearchParams({
+      response_type: "code",
+      client_id: creds.clientId,
+      redirect_uri: REDIRECT_URI,
+      scope: "workspace:admin",
+      state,
+      code_challenge: codeChallenge,
+      code_challenge_method: "S256"
+    });
+    const authUrl = `${envConfig.apiUrl}/api/v2/oauth/authorize?${authParams}`;
+    const callbackPromise = startCallbackServer();
+    stderr("\n  Opening browser for authorization...");
+    stderr(`  If browser doesn't open, visit:
+  ${authUrl}
+`);
+    openBrowser(authUrl);
+    stderr("  Waiting for authorization (timeout: 5 minutes)...");
+    let code;
+    let receivedState;
+    try {
+      ({ code, state: receivedState } = await callbackPromise);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!hasRetried && isOAuthError(msg, "invalid_client")) {
+        stderr("  Cached client credentials expired, re-registering...");
+        credentialsManager.clear(env);
+        hasRetried = true;
+        continue;
+      }
+      throw err;
+    }
+    if (receivedState !== state) {
+      throw new Error("State mismatch - possible CSRF attack");
+    }
+    stderr("  Authorization code received!");
+    stderr("  Exchanging code for tokens...");
+    const tokenUrl = `${envConfig.apiUrl}/api/v2/oauth/token`;
+    const authHeader = Buffer.from(`${creds.clientId}:${creds.clientSecret}`).toString("base64");
+    const tokenResponse = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${authHeader}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        redirect_uri: REDIRECT_URI,
+        code_verifier: codeVerifier
+      })
+    });
+    if (!tokenResponse.ok) {
+      const body = await tokenResponse.text();
+      if (!hasRetried && isOAuthError(body, "invalid_client")) {
+        stderr("  Cached client credentials expired, re-registering...");
+        credentialsManager.clear(env);
+        hasRetried = true;
+        continue;
+      }
+      throw new Error(`Token exchange failed: ${tokenResponse.status} - ${body}`);
+    }
+    const tokenData = await tokenResponse.json();
+    const { accessToken, refreshToken, expiresIn } = validateTokenResponse(tokenData);
+    creds.accessToken = accessToken;
+    creds.refreshToken = refreshToken ?? creds.refreshToken;
+    creds.expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
+    credentialsManager.save(env, creds);
+    stderr("  Authentication successful!");
+    return { accessToken, credentials: creds };
+  }
+}
+async function refreshAccessToken(envConfig, creds, credentialsManager, env) {
+  if (!creds.refreshToken || !creds.clientId || !creds.clientSecret) {
+    stderr("  Cannot refresh: missing credentials (re-login required)");
+    return null;
+  }
+  const tokenUrl = `${envConfig.apiUrl}/api/v2/oauth/token`;
+  const authHeader = Buffer.from(`${creds.clientId}:${creds.clientSecret}`).toString("base64");
+  try {
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${authHeader}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: creds.refreshToken
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      const isExpiredRefresh = isOAuthError(body, "invalid_grant");
+      if (isExpiredRefresh) {
+        stderr("  Refresh token expired, re-login required");
+      } else {
+        stderr(`  Token refresh failed (${response.status}), clearing credentials`);
+      }
+      credentialsManager.clear(env);
+      return null;
+    }
+    const tokenData = await response.json();
+    const { accessToken, refreshToken, expiresIn } = validateTokenResponse(tokenData);
+    const updated = {
+      ...creds,
+      accessToken,
+      refreshToken: refreshToken ?? creds.refreshToken,
+      expiresAt: new Date(Date.now() + expiresIn * 1e3).toISOString()
+    };
+    credentialsManager.save(env, updated);
+    return updated;
+  } catch (err) {
+    stderr(`  Token refresh error: ${err instanceof Error ? err.message : "unknown"}`);
+    credentialsManager.clear(env);
+    return null;
+  }
+}
+
+// src/cli-utils/ui.ts
+import * as readline from "readline";
+var NEW_ITEM_MARKER = Symbol("NEW_ITEM");
+async function selectFromList(items, options = {}) {
+  const {
+    title = "Select an item",
+    labelFn = (item) => String(item.name || item.title || item),
+    detailFn = null,
+    env = null,
+    emptyMessage = "No items found.",
+    allowNew = false,
+    newLabel = "Create new..."
+  } = options;
+  if ((!items || items.length === 0) && !allowNew) {
+    console.log(`
+  ${emptyMessage}`);
+    return { item: null, isNew: false };
+  }
+  const displayItems = allowNew ? [NEW_ITEM_MARKER, ...items] : items;
+  return new Promise((resolve2) => {
+    let selectedIndex = allowNew ? 1 : 0;
+    let filterText = "";
+    const getFilteredItems = () => {
+      if (!filterText) return displayItems;
+      const lower = filterText.toLowerCase();
+      return displayItems.filter((item) => {
+        if (item === NEW_ITEM_MARKER) return true;
+        const label = labelFn(item);
+        return label.toLowerCase().includes(lower);
+      });
+    };
+    const render = () => {
+      const filtered = getFilteredItems();
+      process.stdout.write("\x1B[2J\x1B[H");
+      console.log("=".repeat(60));
+      console.log(`${title} (\u2191/\u2193 to move, Enter to select, Esc to cancel)`);
+      console.log("=".repeat(60));
+      if (env) {
+        console.log(`Environment: ${env}`);
+      }
+      console.log(`Filter: ${filterText}${filterText ? "" : "(type to filter)"}`);
+      console.log("");
+      if (filtered.length === 0) {
+        console.log(`  ${emptyMessage}`);
+        console.log("");
+        return;
+      }
+      const maxVisible = 15;
+      let startIdx = Math.max(0, selectedIndex - Math.floor(maxVisible / 2));
+      let endIdx = Math.min(filtered.length, startIdx + maxVisible);
+      if (endIdx - startIdx < maxVisible && startIdx > 0) {
+        startIdx = Math.max(0, endIdx - maxVisible);
+      }
+      if (startIdx > 0) {
+        console.log(`  ... ${startIdx} more above ...`);
+      }
+      for (let i = startIdx; i < endIdx; i++) {
+        const item = filtered[i];
+        const prefix = i === selectedIndex ? "> " : "  ";
+        let line;
+        if (item === NEW_ITEM_MARKER) {
+          line = `\x1B[32m${newLabel}\x1B[0m`;
+        } else {
+          const typedItem = item;
+          line = labelFn(typedItem);
+          if (detailFn) {
+            const detail = detailFn(typedItem);
+            if (detail) {
+              line = `${line}  \x1B[90m${detail}\x1B[0m`;
+            }
+          }
+        }
+        if (i === selectedIndex) {
+          console.log(`\x1B[7m${prefix}${line}\x1B[0m`);
+        } else {
+          console.log(`${prefix}${line}`);
+        }
+      }
+      if (endIdx < filtered.length) {
+        console.log(`  ... ${filtered.length - endIdx} more below ...`);
+      }
+      console.log("");
+      console.log(`  ${filtered.length} item(s)`);
+    };
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    render();
+    const handleKeypress = (str, key) => {
+      const filtered = getFilteredItems();
+      if (key.name === "up") {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        render();
+      } else if (key.name === "down") {
+        selectedIndex = Math.min(filtered.length - 1, selectedIndex + 1);
+        render();
+      } else if (key.name === "return") {
+        cleanup();
+        if (filtered.length > 0 && selectedIndex < filtered.length) {
+          const selected = filtered[selectedIndex];
+          if (selected === NEW_ITEM_MARKER) {
+            resolve2({ item: null, isNew: true });
+          } else {
+            resolve2({ item: selected, isNew: false });
+          }
+        } else {
+          resolve2({ item: null, isNew: false });
+        }
+      } else if (key.name === "escape" || key.ctrl && key.name === "c") {
+        cleanup();
+        resolve2({ item: null, isNew: false });
+      } else if (key.name === "backspace") {
+        filterText = filterText.slice(0, -1);
+        selectedIndex = allowNew ? 0 : 0;
+        render();
+      } else if (str && str.length === 1 && !key.ctrl && !key.meta) {
+        filterText += str;
+        selectedIndex = allowNew ? 0 : 0;
+        render();
+      }
+    };
+    const cleanup = () => {
+      process.stdin.removeListener("keypress", handleKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      process.stdout.write("\x1B[2J\x1B[H");
+    };
+    process.stdin.on("keypress", handleKeypress);
+    process.stdin.resume();
+  });
+}
+function printTable(items, columns, options = {}) {
+  if (!items || items.length === 0) {
+    console.log("\nNo items found.");
+    return;
+  }
+  if (options.title) {
+    console.log(`
+=== ${options.title} ===`);
+  }
+  if (options.env) {
+    console.log(`Environment: ${options.env}`);
+  }
+  console.log("");
+  const widths = columns.map((col) => {
+    const maxContent = Math.max(...items.map((item) => String(col.getValue(item) ?? "").length));
+    const width = Math.max(col.header.length, maxContent);
+    return col.maxWidth ? Math.min(width, col.maxWidth) : width;
+  });
+  const headerLine = columns.map((col, i) => col.header.padEnd(widths[i])).join("  ");
+  console.log(headerLine);
+  console.log(widths.map((w) => "-".repeat(w)).join("  "));
+  for (const item of items) {
+    const row = columns.map((col, i) => {
+      const value = String(col.getValue(item) ?? "");
+      const width = widths[i];
+      return value.slice(0, width).padEnd(width);
+    }).join("  ");
+    console.log(row);
+  }
+  console.log("");
+  console.log(`Total: ${items.length} item(s)`);
+}
+function formatTimestamp(isoString) {
+  if (!isoString) return "";
+  const date = new Date(isoString);
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - date.getTime();
+  if (diff < 6e4) return "just now";
+  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+  if (diff < 6048e5) return `${Math.floor(diff / 864e5)}d ago`;
+  return date.toLocaleDateString();
+}
+function wrapText(text, width = 70) {
+  const words = text.split(" ");
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    if (currentLine.length + word.length + 1 <= width) {
+      currentLine += (currentLine ? " " : "") + word;
+    } else {
+      if (currentLine) lines.push(currentLine);
+      currentLine = word;
+    }
+  }
+  if (currentLine) lines.push(currentLine);
+  return lines;
+}
+function printMessage(content, role, indent = "  ") {
+  const roleColors = {
+    user: "\x1B[34m",
+    // Blue
+    assistant: "\x1B[32m",
+    // Green
+    system: "\x1B[90m"
+    // Gray
+  };
+  const resetColor = "\x1B[0m";
+  const color = roleColors[role] || resetColor;
+  const label = role === "user" ? "You" : role === "assistant" ? "Assistant" : "System";
+  console.log(`${indent}${color}[${label}]${resetColor}`);
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const wrapped = wrapText(line, 70);
+    for (const wrappedLine of wrapped) {
+      console.log(`${indent}  ${wrappedLine}`);
+    }
+  }
+  console.log("");
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[H");
+}
+
+// src/cli-utils/agui.ts
+var AGUIClient = class {
+  endpointUrl;
+  accessToken;
+  debug;
+  model;
+  constructor(options) {
+    this.endpointUrl = options.endpointUrl ?? `${options.baseUrl}/api/v2/w/${options.workspaceUuid}/web-chat/${options.chatId}/chat/agui`;
+    this.accessToken = options.accessToken;
+    this.debug = options.debug ?? false;
+    this.model = "model" in options ? options.model : "manager";
+  }
+  /**
+   * Send messages and stream the response
+   */
+  async sendMessage(messages, onEvent, options) {
+    const body = JSON.stringify({
+      ...this.model ? { model: this.model } : {},
+      messages,
+      ...options?.autoApprove ? { context: { autoApprove: true } } : {}
+    });
+    if (this.debug) {
+      console.log(`
+[DEBUG] POST ${this.endpointUrl}`);
+      console.log(`[DEBUG] Body: ${messages.length} message(s)`);
+    }
+    const response = await fetch(this.endpointUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body
+    });
+    if (this.debug) {
+      console.log(`[DEBUG] Response status: ${response.status}`);
+    }
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      if (this.debug) {
+        console.log(`[DEBUG] Error response: ${errorText}`);
+      }
+      throw new Error(`Chat request failed: ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    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("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") {
+            onEvent({ type: "done" });
+            continue;
+          }
+          try {
+            const event = JSON.parse(data);
+            onEvent(event);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+function isTextContentEvent(event) {
+  const type = event.type.toLowerCase();
+  return type === "text_message_content";
+}
+function isErrorEvent(event) {
+  const type = event.type.toLowerCase();
+  return type === "run_error";
+}
+function getTextDelta(event) {
+  if (isTextContentEvent(event) && event.delta) {
+    return event.delta;
+  }
+  return null;
+}
+function getErrorMessage(event) {
+  if (isErrorEvent(event)) {
+    return event.message || event.code || "Unknown error";
+  }
+  return null;
+}
+
+export {
+  ENVIRONMENTS,
+  CALLBACK_PORT,
+  CALLBACK_PATH,
+  REDIRECT_URI,
+  getEnvironmentConfig,
+  CredentialsManager,
+  generatePKCE,
+  openBrowser,
+  startCallbackServer,
+  performOAuthFlow,
+  refreshAccessToken,
+  selectFromList,
+  printTable,
+  formatTimestamp,
+  wrapText,
+  printMessage,
+  clearScreen,
+  AGUIClient,
+  isTextContentEvent,
+  isErrorEvent,
+  getTextDelta,
+  getErrorMessage
+};
+//# sourceMappingURL=chunk-OIFV7TAT.js.map