@gravity-rail/cli 0.7.0 → 0.7.2

package/dist/{chunk-QVG4L6BE.js → register-special-commands.js}

@@ -1,39 +1,1103 @@
-#!/usr/bin/env node
-import { AGUIClient, clearScreen, printMessage, requireAuth, originateConciergeCall, originateConciergeSms, getConciergeChatMessages, getConciergeChat, createConciergeChat, listConciergeChats, selectFromList, formatTimestamp, getTextDelta, getErrorMessage } from './chunk-3EO4COHB.js';
-import { CLIError } from './chunk-XRBVAFCB.js';
-import path3 from 'path';
-import * as readline from 'readline';
-import readline__default from 'readline';
-import fs, { createWriteStream } from 'fs';
-import os from 'os';
-import { EventEmitter } from 'events';
-import { execSync, spawn, spawnSync } from 'child_process';
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli-utils/config.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+var CALLBACK_PORT, CALLBACK_PATH, REDIRECT_URI;
+var init_config = __esm({
+  "src/cli-utils/config.ts"() {
+    "use strict";
+    CALLBACK_PORT = 31337;
+    CALLBACK_PATH = "/oauth/callback";
+    REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+  }
+});
+
+// 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";
+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 };
+  }
+}
+var init_auth = __esm({
+  "src/cli-utils/auth.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/cli-utils/ui.ts
+import * as readline from "readline";
+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");
+}
+var NEW_ITEM_MARKER;
+var init_ui = __esm({
+  "src/cli-utils/ui.ts"() {
+    "use strict";
+    NEW_ITEM_MARKER = Symbol("NEW_ITEM");
+  }
+});
+
+// src/cli-utils/agui.ts
+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;
+}
+var AGUIClient;
+var init_agui = __esm({
+  "src/cli-utils/agui.ts"() {
+    "use strict";
+    AGUIClient = class {
+      endpointUrl;
+      baseUrl;
+      workspaceUuid;
+      chatId;
+      accessToken;
+      debug;
+      model;
+      appContext;
+      constructor(options) {
+        this.baseUrl = options.baseUrl;
+        this.workspaceUuid = options.workspaceUuid ?? "";
+        this.chatId = options.chatId ?? 0;
+        if (!options.endpointUrl && (!options.workspaceUuid || options.chatId === void 0)) {
+          throw new Error("AGUIClient requires workspaceUuid and chatId, or endpointUrl");
+        }
+        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";
+        this.appContext = options.appContext;
+      }
+      inferenceStatusUrl() {
+        if (!this.workspaceUuid || this.chatId <= 0) return null;
+        return `${this.baseUrl}/api/v2/w/${this.workspaceUuid}/chats/${this.chatId}/inference/status`;
+      }
+      async waitForInferenceInactive(maxWaitMs = 6e4) {
+        const url = this.inferenceStatusUrl();
+        if (!url) return false;
+        const deadline = Date.now() + maxWaitMs;
+        while (Date.now() < deadline) {
+          try {
+            const res = await fetch(url, {
+              headers: { Authorization: `Bearer ${this.accessToken}` }
+            });
+            if (res.ok) {
+              const body = await res.json();
+              if (!body.active) return true;
+            }
+          } catch (err) {
+            if (this.debug) {
+              console.log(
+                `[DEBUG] waitForInferenceInactive fetch failed: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+          await new Promise((r) => setTimeout(r, 2e3));
+        }
+        return false;
+      }
+      /**
+       * Send messages and stream the response
+       */
+      async sendMessage(messages, onEvent, options) {
+        return this.streamRequest({ messages }, onEvent, options);
+      }
+      /**
+       * Stream an AG-UI request (initial messages or HITL resume).
+       */
+      async streamRequest(request, onEvent, options) {
+        const body = JSON.stringify({
+          ...this.model ? { model: this.model } : {},
+          messages: request.messages ?? [],
+          ...this.appContext ? { appContext: this.appContext } : {},
+          ...request.resumeValue !== void 0 ? { resumeValue: request.resumeValue } : {},
+          ...request.resumeInterruptId ? { resumeInterruptId: request.resumeInterruptId } : {},
+          ...options?.autoApprove ? { context: { autoApprove: true } } : {}
+        });
+        if (this.debug) {
+          console.log(`
+[DEBUG] POST ${this.endpointUrl}`);
+          console.log(
+            `[DEBUG] Body: ${request.resumeValue !== void 0 ? "resume" : `${(request.messages ?? []).length} message(s)`}`
+          );
+        }
+        await this.postStream(body, onEvent, options);
+      }
+      async postStream(body, onEvent, options, conflictRetries = 0) {
+        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.status === 409 && conflictRetries < 3) {
+          const ready = await this.waitForInferenceInactive();
+          if (ready) {
+            await this.postStream(body, onEvent, options, conflictRetries + 1);
+            return;
+          }
+        }
+        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}${errorText ? `: ${errorText.slice(0, 200)}` : ""}`
+          );
+        }
+        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 {
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/cli-utils/index.ts
+var init_cli_utils = __esm({
+  "src/cli-utils/index.ts"() {
+    "use strict";
+    init_config();
+    init_auth();
+    init_ui();
+    init_agui();
+  }
+});
+
+// src/lib/errors.ts
+var CLIError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    CLIError = class extends Error {
+      constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CLIError";
+      }
+    };
+  }
+});
+
+// src/lib/pagination.ts
+function isListResult(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+  const obj = data;
+  return Array.isArray(obj.items) && ("supportsAll" in obj || "meta" in obj && (obj.meta === void 0 || typeof obj.meta === "object"));
+}
+function isPagePaginatedResponse(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  if (!Array.isArray(obj.items) || typeof obj.page !== "number") return false;
+  if (typeof obj.totalPages === "number") return true;
+  if (typeof obj.total === "number" && typeof obj.pageSize === "number") return true;
+  return false;
+}
+function isCursorPaginatedResponse(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  return Array.isArray(obj.items) && typeof obj.hasMore === "boolean";
+}
+function extractPaginationMeta(data) {
+  if (isPagePaginatedResponse(data)) {
+    const totalPages = data.totalPages ?? (data.pageSize ? Math.ceil(data.total / data.pageSize) : void 0);
+    return {
+      total: data.total,
+      page: data.page,
+      totalPages
+    };
+  }
+  if (isCursorPaginatedResponse(data)) {
+    return {
+      hasMore: data.hasMore,
+      nextCursor: data.nextCursor
+    };
+  }
+  return void 0;
+}
+function formatPaginationWarning(meta, supportsAll = true) {
+  if (!meta) return void 0;
+  const allHint = supportsAll ? " Use --all to fetch all pages." : "";
+  if (meta.totalPages !== void 0 && meta.totalPages > 1) {
+    const pageNum = meta.page ?? 1;
+    return `Showing page ${pageNum} of ${meta.totalPages} (${meta.total} total items).${allHint}`;
+  }
+  if (meta.hasMore === true) {
+    return `More results available.${allHint}`;
+  }
+  return void 0;
+}
+function unwrapItems(data) {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object" && "items" in data && Array.isArray(data.items)) {
+    return data.items;
+  }
+  return [data];
+}
+var init_pagination = __esm({
+  "src/lib/pagination.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/lib/output.ts
+function outputData(data, opts, columns, paginationMeta, supportsAll) {
+  let items;
+  let meta;
+  let allSupported;
+  if (isListResult(data)) {
+    items = data.items;
+    meta = data.meta;
+    allSupported = data.supportsAll ?? false;
+  } else {
+    items = unwrapItems(data);
+    meta = paginationMeta ?? extractPaginationMeta(data);
+    allSupported = supportsAll ?? false;
+  }
+  const warning = formatPaginationWarning(meta, allSupported);
+  if (warning) {
+    process.stderr.write(warning + "\n");
+  }
+  switch (opts.outputFormat) {
+    case "json":
+      process.stdout.write(JSON.stringify(items, null, 2) + "\n");
+      break;
+    case "jsonl":
+      for (const item of items) {
+        process.stdout.write(JSON.stringify(item) + "\n");
+      }
+      break;
+    case "table":
+      if (columns) {
+        printTable(items, columns);
+      } else {
+        process.stdout.write(JSON.stringify(items, null, 2) + "\n");
+      }
+      break;
+  }
+}
+function outputSingle(data, opts, columns) {
+  switch (opts.outputFormat) {
+    case "json":
+      process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+      break;
+    case "jsonl":
+      process.stdout.write(JSON.stringify(data) + "\n");
+      break;
+    case "table":
+      if (columns) {
+        printTable([data], columns);
+      } else {
+        process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+      }
+      break;
+  }
+}
+function stderr2(msg) {
+  process.stderr.write(msg + "\n");
+}
+var init_output = __esm({
+  "src/lib/output.ts"() {
+    "use strict";
+    init_cli_utils();
+    init_pagination();
+  }
+});
+
+// src/lib/realm.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+var CACHE_MAX_AGE_MS;
+var init_realm = __esm({
+  "src/lib/realm.ts"() {
+    "use strict";
+    CACHE_MAX_AGE_MS = 60 * 60 * 1e3;
+  }
+});
+
+// src/lib/org-auth.ts
+import { execFile as execFile2 } from "child_process";
+var ORG_AUTH_TIMEOUT_MS;
+var init_org_auth = __esm({
+  "src/lib/org-auth.ts"() {
+    "use strict";
+    init_output();
+    ORG_AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/lib/pinned-fetch.ts
+import { Agent, fetch as undiciFetch } from "undici";
+var init_pinned_fetch = __esm({
+  "src/lib/pinned-fetch.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/context.ts
+import { GravityRailClient } from "@gravity-rail/sdk";
+import { homedir } from "os";
+function requireAuth(ctx) {
+  if (!("apiClient" in ctx)) {
+    throw new Error("Command handler accessed apiClient without declaring requiresAuth");
+  }
+  return ctx;
+}
+var init_context = __esm({
+  "src/lib/context.ts"() {
+    "use strict";
+    init_cli_utils();
+    init_output();
+    init_realm();
+    init_errors();
+    init_org_auth();
+    init_pinned_fetch();
+  }
+});
+
+// src/lib/concierge-api.ts
+function baseUrl(ctx) {
+  return `${ctx.envConfig.apiUrl}/api/v2/concierge`;
+}
+function authHeaders(ctx) {
+  return {
+    Authorization: `Bearer ${ctx.accessToken}`,
+    "Content-Type": "application/json"
+  };
+}
+function toCamelChat(raw) {
+  return {
+    id: raw.id,
+    uuid: raw.uuid,
+    chatType: raw.chat_type,
+    title: raw.title,
+    threadId: raw.thread_id,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+}
+function toCamelMessage(raw) {
+  return {
+    id: raw.id,
+    role: raw.role,
+    content: raw.content ?? "",
+    createdAt: raw.createdAt ?? raw.created_at ?? null,
+    toolCalls: raw.toolCalls ?? raw.tool_calls ?? null,
+    toolCallId: raw.toolCallId ?? raw.tool_call_id ?? null
+  };
+}
+async function listConciergeChats(ctx) {
+  const res = await fetch(`${baseUrl(ctx)}/chats`, { headers: authHeaders(ctx) });
+  if (!res.ok) throw new Error(`Failed to list concierge chats: ${res.status}`);
+  const data = await res.json();
+  return data.map(toCamelChat);
+}
+async function createConciergeChat(ctx, title) {
+  const res = await fetch(`${baseUrl(ctx)}/chats`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ title: title ?? null })
+  });
+  if (!res.ok) throw new Error(`Failed to create concierge chat: ${res.status}`);
+  return toCamelChat(await res.json());
+}
+async function getConciergeChat(ctx, chatId) {
+  const res = await fetch(`${baseUrl(ctx)}/chats/${chatId}`, { headers: authHeaders(ctx) });
+  if (!res.ok) throw new Error(`Failed to get concierge chat ${chatId}: ${res.status}`);
+  return toCamelChat(await res.json());
+}
+async function originateConciergeCall(ctx, kind = "concierge_setup") {
+  const res = await fetch(`${baseUrl(ctx)}/calls`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ kind })
+  });
+  if (res.status === 412) {
+    throw new Error("Your account phone is not verified. Run `gr account verify-phone` first.");
+  }
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to start concierge call: ${res.status} ${detail}`);
+  }
+  return await res.json();
+}
+async function originateConciergeSms(ctx, kind = "concierge_setup") {
+  const res = await fetch(`${baseUrl(ctx)}/sms`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ kind })
+  });
+  if (res.status === 412) {
+    throw new Error("Your account phone is not verified. Run `gr account verify-phone` first.");
+  }
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to start concierge SMS: ${res.status} ${detail}`);
+  }
+  return await res.json();
+}
+async function startAccountPhoneVerify(ctx, phone) {
+  const res = await fetch(`${ctx.envConfig.apiUrl}/api/v2/account/phone/verify/start`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ phone })
+  });
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to send verification code: ${res.status} ${detail}`);
+  }
+}
+async function confirmAccountPhoneVerify(ctx, code) {
+  const res = await fetch(`${ctx.envConfig.apiUrl}/api/v2/account/phone/verify/confirm`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify({ code })
+  });
+  if (!res.ok) {
+    const detail = await res.text();
+    throw new Error(`Failed to confirm verification code: ${res.status} ${detail}`);
+  }
+}
+async function getConciergeChatMessages(ctx, chatId) {
+  const res = await fetch(`${baseUrl(ctx)}/chats/${chatId}/messages`, {
+    headers: authHeaders(ctx)
+  });
+  if (!res.ok)
+    throw new Error(`Failed to get concierge messages for chat ${chatId}: ${res.status}`);
+  const data = await res.json();
+  return data.map(toCamelMessage);
+}
+var init_concierge_api = __esm({
+  "src/lib/concierge-api.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/account-verify-phone.ts
+var account_verify_phone_exports = {};
+__export(account_verify_phone_exports, {
+  accountVerifyPhoneCommand: () => accountVerifyPhoneCommand
+});
+import * as readline6 from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+async function accountVerifyPhoneCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const phoneArg = typeof hctx.args.phone === "string" ? hctx.args.phone : void 0;
+  process.stderr.write(`${TCPA_NOTICE}
+`);
+  const phone = phoneArg ?? await promptLine("Phone number (E.164, e.g. +15551234567): ");
+  if (!phone.trim()) {
+    throw new Error("Phone number is required");
+  }
+  await startAccountPhoneVerify(ctx, phone.trim());
+  process.stderr.write("Verification code sent via SMS.\n");
+  const code = await promptLine("Enter 6-digit code: ");
+  await confirmAccountPhoneVerify(ctx, code.trim());
+  process.stderr.write(
+    "Phone verified. You can use `gr concierge chat --call` or `gr concierge chat --sms`.\n"
+  );
+}
+async function promptLine(question) {
+  const rl = readline6.createInterface({ input, output });
+  try {
+    return await rl.question(question) ?? "";
+  } finally {
+    rl.close();
+  }
+}
+var TCPA_NOTICE;
+var init_account_verify_phone = __esm({
+  "src/commands/account-verify-phone.ts"() {
+    "use strict";
+    init_concierge_api();
+    init_context();
+    TCPA_NOTICE = "By verifying you agree to receive calls and SMS from Gravity Rail at this number.";
+  }
+});
 
+// src/commands/auth-browser.ts
+init_output();
+import { execFile } from "child_process";
+async function authBrowserCommand(ctx, args) {
+  const noOpen = Boolean(args["no-open"]);
+  const account = await ctx.apiClient.getUserAccount();
+  if (!account.email) {
+    process.stderr.write("Error: No email associated with current account\n");
+    process.exit(1);
+  }
+  const response = await ctx.apiClient.requestMagicLink(account.email);
+  if (!response.success || !response.magicLinkUrl) {
+    process.stderr.write("Error: Failed to create magic link\n");
+    process.exit(1);
+  }
+  const url = response.magicLinkUrl;
+  if (noOpen) {
+    process.stdout.write(url + "\n");
+    return;
+  }
+  stderr2(`Opening browser for ${account.email} (${ctx.env})...`);
+  openUrl(url);
+  stderr2("Browser opened. Link expires in 15 minutes.");
+}
+function openUrl(url) {
+  const platform = process.platform;
+  let command;
+  let args;
+  if (platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    command = "cmd.exe";
+    args = ["/c", "start", "", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  execFile(command, args, (err) => {
+    if (err) {
+      process.stderr.write("Warning: Could not open browser automatically\n");
+    }
+  });
+}
+
+// src/commands/manage.ts
+init_cli_utils();
+init_errors();
+init_context();
+
+// src/lib/cli-client-context.ts
+import path from "path";
 function buildCliConciergeAppContext() {
-  const shell = process.env.SHELL ? path3.basename(process.env.SHELL) : void 0;
+  const shell = process.env.SHELL ? path.basename(process.env.SHELL) : void 0;
   return {
     clientSurface: "cli",
     channel: "text",
     cliContext: {
       shell,
       os: process.platform,
-      cwdBasename: path3.basename(process.cwd())
+      cwdBasename: path.basename(process.cwd())
     }
   };
 }
+
+// src/lib/chat-session.ts
+init_cli_utils();
+
+// src/lib/concierge-agui-loop.ts
+init_agui();
+
+// src/lib/cli-hitl.ts
+import readline3 from "readline";
+
+// src/lib/local-files.ts
+import fs from "fs";
+import path2 from "path";
 var DEFAULT_MAX_READ_BYTES = 5e4;
 var ABSOLUTE_MAX_READ_BYTES = 1e6;
 function resolveSafePath(root, relativePath) {
-  const rootResolved = path3.resolve(root);
-  const target = path3.resolve(rootResolved, relativePath || ".");
-  if (target !== rootResolved && !target.startsWith(rootResolved + path3.sep)) {
+  const rootResolved = path2.resolve(root);
+  const target = path2.resolve(rootResolved, relativePath || ".");
+  if (target !== rootResolved && !target.startsWith(rootResolved + path2.sep)) {
     return null;
   }
   let cursor = rootResolved;
-  const rest = path3.relative(rootResolved, target);
+  const rest = path2.relative(rootResolved, target);
   if (rest && rest !== ".") {
-    for (const segment of rest.split(path3.sep)) {
-      cursor = path3.join(cursor, segment);
+    for (const segment of rest.split(path2.sep)) {
+      cursor = path2.join(cursor, segment);
       try {
         const lstat = fs.lstatSync(cursor);
         if (lstat.isSymbolicLink()) {
@@ -94,7 +1158,7 @@ function executeCliLocalFileAction(root, interrupt, opts) {
         if (interrupt.content === void 0) {
           return { ok: false, error: "Missing content for write_file" };
         }
-        fs.mkdirSync(path3.dirname(safe), { recursive: true });
+        fs.mkdirSync(path2.dirname(safe), { recursive: true });
         fs.writeFileSync(safe, interrupt.content, "utf8");
         return { ok: true, content: "written" };
       }
@@ -120,6 +1184,12 @@ function isCliLocalFileInterrupt(value) {
   const v = value;
   return v.type === "cli_local_file" && typeof v.action === "string" && typeof v.path === "string";
 }
+
+// src/lib/trusted-dirs.ts
+import fs2 from "fs";
+import os from "os";
+import path3 from "path";
+import readline2 from "readline";
 var STORE_VERSION = 1;
 function storePath() {
   const base = process.env.XDG_CONFIG_HOME ?? (process.platform === "win32" ? path3.join(process.env.APPDATA ?? os.homedir(), "gravityrail") : path3.join(os.homedir(), ".config", "gravityrail"));
@@ -128,7 +1198,7 @@ function storePath() {
 function loadTrustedDirsStore() {
   const file = storePath();
   try {
-    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs2.readFileSync(file, "utf8"));
     if (raw?.version === STORE_VERSION && Array.isArray(raw.always)) {
       return { version: STORE_VERSION, always: raw.always.map((p) => path3.resolve(p)) };
     }
@@ -139,8 +1209,8 @@ function loadTrustedDirsStore() {
 function saveTrustedDirsStore(store) {
   const file = storePath();
   const dir = path3.dirname(file);
-  fs.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs.writeFileSync(file, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs2.writeFileSync(file, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
 }
 function isDirectoryTrusted(dirPath, opts) {
   if (opts?.trustCwdFlag) return true;
@@ -149,8 +1219,8 @@ function isDirectoryTrusted(dirPath, opts) {
   return store.always.includes(resolved);
 }
 async function promptTrustInteractive(dirPath) {
-  const rl = readline__default.createInterface({ input: process.stdin, output: process.stderr });
-  const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stderr });
+  const question = (q) => new Promise((resolve2) => rl.question(q, resolve2));
   process.stderr.write(
     `
 Gravity Rail may read files in:
@@ -270,9 +1340,9 @@ ${prompt}
       resumeInterruptId: typeof payload.interrupt_id === "string" ? payload.interrupt_id : void 0
     };
   }
-  const rl = readline__default.createInterface({ input: process.stdin, output: process.stderr });
-  const answer = await new Promise((resolve) => {
-    rl.question("Your choice (value): ", resolve);
+  const rl = readline3.createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await new Promise((resolve2) => {
+    rl.question("Your choice (value): ", resolve2);
   });
   rl.close();
   return {
@@ -330,6 +1400,13 @@ async function runConciergeAguiLoop(client, initialMessages, onEvent, opts) {
   }
   return { streamText, hasToolCalls };
 }
+
+// src/lib/chat-session.ts
+init_errors();
+import * as readline5 from "readline";
+
+// src/lib/realtime-client.ts
+import { EventEmitter } from "events";
 var RealtimeClient = class extends EventEmitter {
   ws = null;
   connected = false;
@@ -349,7 +1426,7 @@ var RealtimeClient = class extends EventEmitter {
         new Error("WebSocket not available. Node.js 22+ is required for realtime mode.")
       );
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const params = new URLSearchParams();
       if (this.options.vadMode) {
         params.append("vad", this.options.vadMode);
@@ -404,7 +1481,7 @@ var RealtimeClient = class extends EventEmitter {
       }, 1e4);
       this.once("connected", () => {
         clearTimeout(timeout);
-        resolve();
+        resolve2();
       });
       this.once("error", () => {
         clearTimeout(timeout);
@@ -578,6 +1655,9 @@ var RealtimeClient = class extends EventEmitter {
     }
   }
 };
+
+// src/lib/chat-tui.ts
+import { createWriteStream } from "fs";
 function isToolCall(item) {
   return "kind" in item && item.kind === "tool_call";
 }
@@ -1352,11 +2432,16 @@ function buildDebugSummary(_direction, msg) {
   }
   return type;
 }
+
+// src/lib/audio.ts
+import { spawn, execSync as execSync2, spawnSync } from "child_process";
+import { EventEmitter as EventEmitter2 } from "events";
+import * as readline4 from "readline";
 var SAMPLE_RATE = 24e3;
 var MIC_CHUNK_BYTES = 4800;
 function checkSoxAvailable() {
   try {
-    execSync("which sox", { stdio: "pipe" });
+    execSync2("which sox", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -1369,16 +2454,16 @@ async function listOutputDevices() {
   return listDevices("play");
 }
 function listDevices(command) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     try {
       const proc = spawnSync(command, ["--list-devices"], {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 5e3
       });
-      const output = (proc.stdout ?? "") + (proc.stderr ?? "");
+      const output2 = (proc.stdout ?? "") + (proc.stderr ?? "");
       const devices = [];
-      const lines = output.split("\n");
+      const lines = output2.split("\n");
       for (const line of lines) {
         const match = line.match(/(?:Input|Output)\s+Device\s+(\d+)\s*:\s*(.+)/i);
         if (match && match[1] && match[2]) {
@@ -1393,9 +2478,9 @@ function listDevices(command) {
       if (devices.length === 0) {
         devices.push({ id: "default", name: "System Default", isDefault: true });
       }
-      resolve(devices);
+      resolve2(devices);
     } catch {
-      resolve([{ id: "default", name: "System Default", isDefault: true }]);
+      resolve2([{ id: "default", name: "System Default", isDefault: true }]);
     }
   });
 }
@@ -1403,7 +2488,7 @@ async function selectDevice(devices, label) {
   if (devices.length <= 1) {
     return devices[0];
   }
-  const rl = readline.createInterface({
+  const rl = readline4.createInterface({
     input: process.stdin,
     output: process.stderr,
     terminal: true
@@ -1417,14 +2502,14 @@ async function selectDevice(devices, label) {
     process.stderr.write(`    ${i + 1}. ${dev.name}${marker}
 `);
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const defaultIdx = devices.findIndex((d) => d.isDefault);
     const defaultNum = defaultIdx >= 0 ? defaultIdx + 1 : 1;
     rl.question(`  Select [${defaultNum}]: `, (answer) => {
       rl.close();
       const num = answer.trim() ? parseInt(answer.trim(), 10) : defaultNum;
       const idx = Math.max(0, Math.min(devices.length - 1, num - 1));
-      resolve(devices[idx]);
+      resolve2(devices[idx]);
     });
   });
 }
@@ -1495,7 +2580,7 @@ var MicCapture = class {
     this.buffer = Buffer.alloc(0);
   }
 };
-var AudioPlayer = class extends EventEmitter {
+var AudioPlayer = class extends EventEmitter2 {
   process = null;
   deviceId;
   // When true, we own the SoX process's stdin and are actively streaming to it.
@@ -1722,6 +2807,7 @@ async function singleTurnChatSession(session, message, debug, autoApprove = fals
     {
       autoApprove,
       allowWrite: allowWrite || !!session.allowWrite,
+      debug,
       trustCwd: session.trustCwd,
       trustDir: session.trustDir,
       nonInteractive: true
@@ -1797,11 +2883,11 @@ async function interactiveChatSession(session, debug, autoApprove, allowWrite) {
       conversationMessages.push({ role: msg.role, content: text });
     }
   }
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
+  const rl = readline5.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
     const prompt = () => {
-      rl.question("\x1B[34mYou:\x1B[0m ", async (input) => {
-        const trimmed = input.trim();
+      rl.question("\x1B[34mYou:\x1B[0m ", async (input2) => {
+        const trimmed = input2.trim();
         if (!trimmed) {
           prompt();
           return;
@@ -1856,7 +2942,7 @@ async function interactiveChatSession(session, debug, autoApprove, allowWrite) {
     };
     rl.on("close", () => {
       console.log("\nGoodbye!");
-      resolve();
+      resolve2();
     });
     prompt();
   });
@@ -1953,8 +3039,8 @@ async function realtimeChatSession(session, vad, debug) {
   });
   tui.loadHistory(history);
   tui.start();
-  await new Promise((resolve) => {
-    client.once("closed", resolve);
+  await new Promise((resolve2) => {
+    client.once("closed", resolve2);
   });
 }
 async function voiceChatSession(session, vad, args, debug) {
@@ -2071,8 +3157,8 @@ Connecting to ${session.label.toLowerCase()}...
   tui.loadHistory(history);
   tui.start();
   mic.start(inputDeviceId);
-  await new Promise((resolve) => {
-    client.once("closed", resolve);
+  await new Promise((resolve2) => {
+    client.once("closed", resolve2);
   });
 }
 async function listAudioDevices() {
@@ -2095,7 +3181,148 @@ async function listAudioDevices() {
   }
 }
 
+// src/commands/manage.ts
+async function manageCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const { workspace, args } = hctx;
+  const asMember = typeof args["as-member"] === "string" ? args["as-member"] : void 0;
+  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
+  const message = typeof args.message === "string" ? args.message : void 0;
+  const chat = await getOrCreateChat(ctx, workspace, chatIdArg, asMember, "manager", !!message);
+  const session = buildWorkspaceSession(ctx, workspace, chat, "Workspace Manager", {
+    appContext: buildCliConciergeAppContext(),
+    allowWrite: true,
+    trustCwd: !!args["trust-cwd"],
+    trustDir: typeof args["trust-dir"] === "string" ? args["trust-dir"] : void 0
+  });
+  process.stderr.write(`Chat #${session.chatId}
+`);
+  await runChatSession(session, args);
+  process.stderr.write(`Chat #${session.chatId}
+`);
+}
+async function chatCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const { workspace, args } = hctx;
+  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
+  const workflowId = typeof args.workflow === "string" ? args.workflow : void 0;
+  const memberId = typeof args.member === "string" ? args.member : void 0;
+  let chat;
+  if (chatIdArg) {
+    const id = Number(chatIdArg);
+    if (isNaN(id)) throw new CLIError("--chat-id must be a number");
+    chat = await ctx.apiClient.getChat(workspace, id);
+  } else if (workflowId) {
+    chat = await createAssignmentChat(ctx.apiClient, workspace, Number(workflowId), memberId);
+  } else if (memberId) {
+    chat = await createMemberChat(ctx.apiClient, workspace, memberId);
+  } else {
+    throw new CLIError(
+      'Specify --workflow <id>, --member <id>, or --chat-id <id>.\nUse "gr manage" for workspace manager chats.'
+    );
+  }
+  const session = buildWorkspaceSession(ctx, workspace, chat, "Chat");
+  await runChatSession(session, args);
+}
+function buildWorkspaceSession(ctx, workspace, chat, label, extra) {
+  const wsBase = ctx.envConfig.apiUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+  return {
+    ctx,
+    workspaceUuid: workspace,
+    chatId: chat.id,
+    chatUuid: chat.uuid,
+    chatTitle: chat.title || chat.uuid,
+    aguiEndpointUrl: `${ctx.envConfig.apiUrl}/api/v2/w/${workspace}/web-chat/${chat.id}/chat/agui`,
+    wsUrl: `${wsBase}/api/v2/w/${workspace}/realtime/stream-ws`,
+    loadMessages: () => ctx.apiClient.getChatMessages(workspace, chat.id, 50).catch(() => []),
+    label,
+    model: "manager",
+    ...extra
+  };
+}
+async function getOrCreateChat(ctx, workspace, chatIdArg, asMemberId, chatType, skipSelection = false) {
+  if (chatIdArg) {
+    const chatId = Number(chatIdArg);
+    if (isNaN(chatId)) throw new CLIError("--chat-id must be a number");
+    return ctx.apiClient.getChat(workspace, chatId);
+  }
+  if (skipSelection) {
+    return createManagerChat(ctx.apiClient, workspace, asMemberId);
+  }
+  const chatsResponse = await ctx.apiClient.getChats(workspace, {
+    chatType,
+    sortBy: "updatedAt",
+    sortOrder: "desc",
+    pageSize: 20
+  });
+  const chats = chatsResponse.items || [];
+  const { item: selectedChat, isNew } = await selectFromList(chats, {
+    title: "Select a chat or create a new one",
+    labelFn: (chat) => chat.title || `Chat ${chat.uuid.slice(0, 8)}...`,
+    detailFn: (chat) => {
+      const time = formatTimestamp(chat.updatedAt);
+      const msgCount = chat.messageCount || 0;
+      return `${msgCount} msg${msgCount !== 1 ? "s" : ""} - ${time}`;
+    },
+    emptyMessage: "No existing chats.",
+    allowNew: true,
+    newLabel: "+ Start new chat"
+  });
+  if (!selectedChat && !isNew) {
+    throw new CLIError("No chat selected.");
+  }
+  if (isNew) {
+    return createManagerChat(ctx.apiClient, workspace, asMemberId);
+  }
+  return selectedChat;
+}
+async function createManagerChat(apiClient, workspace, asMemberId) {
+  const data = {
+    chatType: "manager",
+    channel: "web-chat"
+  };
+  if (asMemberId) {
+    data.memberId = Number(asMemberId);
+  }
+  const chat = await apiClient.createChat(workspace, data);
+  process.stderr.write(`Created chat #${chat.id}
+`);
+  return chat;
+}
+async function createAssignmentChat(apiClient, workspace, workflowId, asMemberId) {
+  if (isNaN(workflowId)) throw new CLIError("--workflow must be a number");
+  const data = {
+    chatType: "assignment",
+    channel: "web-chat",
+    workflowId
+  };
+  if (asMemberId) {
+    data.memberId = Number(asMemberId);
+  }
+  const chat = await apiClient.createChat(workspace, data);
+  process.stderr.write(`Created assignment chat #${chat.id} (workflow ${workflowId})
+`);
+  return chat;
+}
+async function createMemberChat(apiClient, workspace, memberId) {
+  const id = Number(memberId);
+  if (isNaN(id)) throw new CLIError("--member must be a number");
+  const data = {
+    chatType: "member",
+    channel: "web-chat",
+    memberId: id
+  };
+  const chat = await apiClient.createChat(workspace, data);
+  process.stderr.write(`Created DM chat #${chat.id} (member ${memberId})
+`);
+  return chat;
+}
+
 // src/commands/concierge.ts
+init_cli_utils();
+init_concierge_api();
+init_context();
+init_errors();
 async function conciergeOutboundCommand(hctx) {
   const ctx = requireAuth(hctx.ctx);
   const { args } = hctx;
@@ -2194,6 +3421,436 @@ async function getOrCreateConciergeChat(ctx, chatIdArg, skipSelection) {
   return selectedChat;
 }
 
-export { buildCliConciergeAppContext, conciergeCommand, conciergeOutboundCommand, runChatSession };
-//# sourceMappingURL=chunk-QVG4L6BE.js.map
-//# sourceMappingURL=chunk-QVG4L6BE.js.map
+// src/commands/dev.ts
+init_errors();
+init_output();
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import { join as join4 } from "path";
+async function devImportLocalCommand(ctx, workspace) {
+  stderr2(`Exporting workspace ${workspace}...`);
+  const exportData = await ctx.apiClient.exportWorkspace(workspace);
+  stderr2("Export successful!");
+  stderr2(`  Workflows: ${(exportData.workflows || []).length}`);
+  stderr2(`  Tasks: ${(exportData.tasks || []).length}`);
+  stderr2(`  Data Types: ${(exportData.dataTypes || []).length}`);
+  stderr2(`  Sites: ${(exportData.sites || []).length}`);
+  const slug = workspace.slice(0, 8);
+  const importCacheDir = join4(ctx.credentialsManager.getCacheDir(), "imports");
+  if (!existsSync4(importCacheDir)) {
+    mkdirSync3(importCacheDir, { recursive: true });
+  }
+  const filename = `ws-${slug}-${workspace}.json`;
+  const filepath = join4(importCacheDir, filename);
+  writeFileSync3(filepath, JSON.stringify(exportData, null, 2));
+  stderr2(`Saved to: ${filepath}`);
+  stderr2("Running dev:restore...");
+  const rootDir = findProjectRoot();
+  const relativePath = filepath.replace(rootDir + "/", "");
+  try {
+    const result = execSync3(`yarn dev:restore ${relativePath}`, {
+      cwd: rootDir,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    process.stderr.write(result);
+    const failed = result.includes("Failed/Skipped: ") && !result.includes("Failed/Skipped: 0") || result.includes("Successfully restored: 0");
+    if (failed) throw new CLIError("Import failed");
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    const execError = error;
+    if (execError.stdout) process.stderr.write(execError.stdout);
+    if (execError.stderr) process.stderr.write(execError.stderr);
+    throw new CLIError("dev:restore failed");
+  }
+  stderr2(`Import complete: ${workspace}`);
+}
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== "/") {
+    const pkgPath = join4(dir, "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        if (pkg.workspaces) return dir;
+      } catch {
+      }
+    }
+    dir = join4(dir, "..");
+  }
+  return process.cwd();
+}
+
+// src/commands/get-started.ts
+init_context();
+var WEB_SETUP = "https://app.gravityrail.com/setup";
+var WEB_GET_STARTED = "https://app.gravityrail.com/get-started";
+var HUMAN_GUIDE = `Gravity Rail \u2014 getting started
+
+1. Authenticate:  gr login --env prod
+   Confirm:       gr whoami
+
+2. Recommended path \u2014 concierge (no workspace required):
+   gr concierge chat --allow-write
+   The concierge can create your org (auto-created on first login), list products,
+   start Stripe checkout, and create your first workspace.
+
+3. Verify workspaces:  gr workspaces list
+
+4. Web wizards (human-friendly):  ${WEB_SETUP}  and  ${WEB_GET_STARTED}
+
+Headless boundary: Stripe checkout needs a human in a browser \u2014 the concierge returns
+a checkout URL; an agent should hand that link to the user, not loop on payment.
+
+Agent-readable steps:  gr get-started --format llm
+`;
+var LLM_GUIDE = `# Gravity Rail CLI bootstrap (agent instructions)
+
+## Preconditions
+- Install: \`npm install -g @gravity-rail/cli\` or \`npx @gravity-rail/cli\`
+- Authenticate: \`gr login --env prod\` (interactive OAuth). Verify with \`gr whoami\`.
+- **Monorepo dev:** from gravity-team with Docker dev up, use \`yarn gr <cmd> --realm superadmin\` (reads \`dev-realms.json\`; no browser). Rebuild: \`yarn workspace @gravity-rail/gr-cli build\`.
+
+## Important facts
+- **Agents/CI:** do not leave stdin open on read-only commands; use \`GRAVITY_RAIL_API_KEY\` or redirect stdin from /dev/null. Commands only read stdin when \`--data\`/\`--file\` is passed.
+- Use \`--env dev|staging|prod\` (default prod) so credentials match the target; \`gr whoami\` shows the active env.
+- After login, an **organization is created automatically** \u2014 do not create a duplicate org unless \`gr organizations list\` is empty.
+- **Workspace is required** for workflow/agent/task commands (\`-w <workspace-uuid>\`).
+- **Concierge does not require \`-w\`** \u2014 use it for first-run setup.
+
+## Recommended path (concierge-driven)
+\`\`\`bash
+gr concierge chat --allow-write --message "Help me set up my first Gravity Rail workspace"
+\`\`\`
+Flags for unattended turns:
+- \`--message\` / \`-m\`: single-turn (non-interactive)
+- \`--auto-approve\`: skip HITL tool approval where policy allows
+- \`--allow-write\`: required for create/update tools
+
+The concierge can: list/create orgs, list org/workspace products, create Stripe checkout sessions, create workspace specs, and \`create_workspace\`.
+
+## Manual CLI path (if not using concierge)
+1. \`gr whoami\` \u2014 confirm account
+2. \`gr organizations list\` \u2014 note org slug/UUID
+3. \`gr concierge chat\` OR web: ${WEB_GET_STARTED}
+4. Product purchase: concierge returns Stripe checkout URL \u2192 **human must complete in browser**
+5. \`gr workspaces list\` \u2014 pick workspace UUID for \`-w\`
+
+## Support (account-level, no workspace)
+\`\`\`bash
+gr support create --type question --title "..." --description "..." --allow-write
+gr support list
+\`\`\`
+
+## Web fallbacks
+- Concierge / setup: ${WEB_SETUP}
+- Wizard: ${WEB_GET_STARTED}
+
+## Headless limits (do not retry forever)
+- Stripe payment / checkout: requires human browser
+- OAuth login: requires human browser
+- Directory trust for future local-file tools: use \`--trust-cwd\` only after user confirms files are safe
+
+## Local project files (CLI only)
+After directory trust + \`--allow-write\`, the concierge can use \`read_local_file\`, \`list_local_dir\`, \`write_local_file\` (client-executed via HITL).
+
+## Verify success
+\`gr workspaces list\` then \`gr workflows list -w <uuid>\` or \`gr agents list -w <uuid>\`
+
+## Local phone / voice QA (monorepo dev)
+\`\`\`bash
+yarn dev:twilio-ngrok --start-ngrok --url gravityrail.ngrok.io dev.<you> -w acme-demo
+yarn gr phone setup
+yarn gr account verify-phone --phone +1\u2026 --allow-write --realm superadmin
+yarn gr concierge chat --call --allow-write --realm superadmin
+yarn gr phone outbound --realm acme-demo/acme-admin --workflow-id 1 --allow-write
+\`\`\`
+See \`.claude/skills/phone-voice-qa/SKILL.md\` and \`./scripts/e2e-voice-phone-matrix.sh\`.
+`;
+async function getStartedCommand(hctx) {
+  const format = hctx.args.format ?? hctx.args.agent;
+  const isLlm = format === "llm" || format === "agent" || hctx.args["format"] === "llm" || !!hctx.args.agent;
+  if (!isLlm) {
+    try {
+      requireAuth(hctx.ctx);
+    } catch {
+    }
+    process.stdout.write(HUMAN_GUIDE);
+    return;
+  }
+  process.stdout.write(LLM_GUIDE);
+}
+
+// src/commands/login.ts
+init_cli_utils();
+init_output();
+import { GravityRailClient as GravityRailClient2 } from "@gravity-rail/sdk";
+async function loginCommand(ctx) {
+  const { accessToken } = await performOAuthFlow({
+    env: ctx.env,
+    envConfig: ctx.envConfig,
+    credentialsManager: ctx.credentialsManager
+  });
+  const apiClient = new GravityRailClient2(accessToken, ctx.envConfig.apiUrl);
+  const account = await apiClient.getUserAccount();
+  stderr2(`Logged in as ${account.name} (${account.email})`);
+}
+async function logoutCommand(ctx) {
+  ctx.credentialsManager.clear(ctx.env);
+  stderr2(`Credentials cleared for ${ctx.env}`);
+}
+
+// src/commands/organizations.ts
+init_output();
+var COLUMNS = [
+  { header: "NAME", getValue: (o) => o.organizationName || "", maxWidth: 35 },
+  { header: "SLUG", getValue: (o) => o.organizationSlug || "", maxWidth: 25 },
+  { header: "UUID", getValue: (o) => o.organizationUuid },
+  { header: "ROLE", getValue: (o) => o.role || "" }
+];
+async function organizationsListCommand(ctx) {
+  const organizations = await ctx.apiClient.getMyOrganizations();
+  outputData(organizations, ctx, COLUMNS);
+}
+
+// src/commands/whoami.ts
+init_output();
+var COLUMNS2 = [
+  { header: "NAME", getValue: (a) => a.name || "", maxWidth: 30 },
+  { header: "EMAIL", getValue: (a) => a.email || "", maxWidth: 40 },
+  { header: "UUID", getValue: (a) => a.uuid },
+  { header: "ENV", getValue: () => "" },
+  { header: "SUPERUSER", getValue: (a) => a.isSuperuser ? "yes" : "no" }
+];
+async function whoamiCommand(ctx) {
+  const account = await ctx.apiClient.getUserAccount();
+  const columns = COLUMNS2.map(
+    (col) => col.header === "ENV" ? { ...col, getValue: () => ctx.env } : col
+  );
+  outputSingle(account, ctx, columns);
+}
+
+// src/register-special-commands.ts
+init_context();
+function registerSpecialCommands(registry) {
+  registry.registerCommand({
+    path: ["login"],
+    description: "Authenticate via OAuth",
+    requiresAuth: false,
+    handler: async ({ ctx }) => {
+      await loginCommand(ctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["logout"],
+    description: "Clear cached credentials",
+    requiresAuth: false,
+    handler: async ({ ctx }) => {
+      await logoutCommand(ctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["auth", "browser"],
+    description: "Open an authenticated browser session using CLI credentials",
+    args: [
+      { name: "no-open", description: "Print the URL instead of opening browser", isFlag: true }
+    ],
+    handler: async ({ ctx, args }) => {
+      await authBrowserCommand(requireAuth(ctx), args);
+    }
+  });
+  registry.registerCommand({
+    path: ["manage"],
+    description: "Interactive workspace manager chat (text, realtime, or voice)",
+    requiresWorkspace: true,
+    mutates: true,
+    args: [
+      { name: "realtime", description: "Use WebSocket realtime connection", isFlag: true },
+      { name: "voice", description: "Enable voice mode (microphone + speaker)", isFlag: true },
+      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
+      { name: "as-member", description: "Chat as a specific member (by numeric ID)" },
+      { name: "chat-id", description: "Resume an existing chat by numeric ID" },
+      { name: "vad", description: "Voice activity detection: server (default) or client" },
+      { name: "list-devices", description: "List audio devices and exit", isFlag: true },
+      { name: "input-device", description: "Microphone device name or ID" },
+      { name: "output-device", description: "Speaker device name or ID" },
+      { name: "debug", description: "Enable debug logging", isFlag: true },
+      {
+        name: "auto-approve",
+        description: "Auto-approve all tool calls (skip HITL)",
+        isFlag: true
+      },
+      {
+        name: "trust-cwd",
+        description: "Trust files in the current working directory (non-interactive)",
+        isFlag: true
+      },
+      {
+        name: "trust-dir",
+        description: "Trust files in this directory (non-interactive; absolute path)"
+      }
+    ],
+    handler: async (hctx) => {
+      await manageCommand(hctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["chat"],
+    description: "Chat with a workflow, member, or existing chat (text, realtime, or voice)",
+    requiresWorkspace: true,
+    mutates: true,
+    args: [
+      { name: "workflow", description: "Start assignment chat with workflow (by numeric ID)" },
+      { name: "member", description: "Start DM with a member (by numeric ID)" },
+      { name: "chat-id", description: "Resume an existing chat by numeric ID" },
+      { name: "realtime", description: "Use WebSocket realtime connection", isFlag: true },
+      { name: "voice", description: "Enable voice mode (microphone + speaker)", isFlag: true },
+      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
+      { name: "vad", description: "Voice activity detection: server (default) or client" },
+      { name: "list-devices", description: "List audio devices and exit", isFlag: true },
+      { name: "input-device", description: "Microphone device name or ID" },
+      { name: "output-device", description: "Speaker device name or ID" },
+      { name: "debug", description: "Enable debug logging", isFlag: true },
+      {
+        name: "auto-approve",
+        description: "Auto-approve all tool calls (skip HITL)",
+        isFlag: true
+      }
+    ],
+    handler: async (hctx) => {
+      await chatCommand(hctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["get-started"],
+    description: "Bootstrap instructions for new users and LLM agents",
+    requiresAuth: false,
+    args: [
+      {
+        name: "format",
+        description: "Output format: llm (agent-readable) or default (human)"
+      },
+      {
+        name: "agent",
+        description: "Alias for --format llm",
+        isFlag: true
+      }
+    ],
+    handler: async (hctx) => {
+      await getStartedCommand(hctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["setup"],
+    description: "Alias for get-started \u2014 bootstrap instructions",
+    requiresAuth: false,
+    args: [
+      { name: "format", description: "Output format: llm or default" },
+      { name: "agent", description: "Alias for --format llm", isFlag: true }
+    ],
+    handler: async (hctx) => {
+      await getStartedCommand(hctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["concierge"],
+    description: "Call or SMS your verified phone via the Concierge (server-side)",
+    requiresWorkspace: false,
+    mutates: true,
+    args: [
+      { name: "call", description: "Ring your verified account phone", isFlag: true },
+      { name: "sms", description: "Start an SMS thread on your verified phone", isFlag: true }
+    ],
+    handler: async (hctx) => {
+      await conciergeOutboundCommand(hctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["account", "verify-phone"],
+    description: "Verify your account phone for concierge chat --call / --sms",
+    requiresWorkspace: false,
+    mutates: true,
+    args: [{ name: "phone", description: "E.164 phone number (optional; prompts if omitted)" }],
+    handler: async (hctx) => {
+      const { accountVerifyPhoneCommand: accountVerifyPhoneCommand2 } = await Promise.resolve().then(() => (init_account_verify_phone(), account_verify_phone_exports));
+      await accountVerifyPhoneCommand2(hctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["concierge", "chat"],
+    description: "Interactive concierge chat (text, realtime, or voice)",
+    requiresWorkspace: false,
+    mutates: true,
+    args: [
+      { name: "realtime", description: "Use WebSocket realtime connection", isFlag: true },
+      { name: "voice", description: "Enable voice mode (microphone + speaker)", isFlag: true },
+      {
+        name: "call",
+        description: "Ring your verified account phone (server-side)",
+        isFlag: true
+      },
+      {
+        name: "sms",
+        description: "SMS your verified account phone (server-side)",
+        isFlag: true
+      },
+      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
+      { name: "chat-id", description: "Resume an existing chat by numeric ID" },
+      { name: "vad", description: "Voice activity detection: server (default) or client" },
+      { name: "list-devices", description: "List audio devices and exit", isFlag: true },
+      { name: "input-device", description: "Microphone device name or ID" },
+      { name: "output-device", description: "Speaker device name or ID" },
+      { name: "debug", description: "Enable debug logging", isFlag: true },
+      {
+        name: "auto-approve",
+        description: "Auto-approve all tool calls (skip HITL)",
+        isFlag: true
+      },
+      {
+        name: "trust-cwd",
+        description: "Trust files in the current working directory (non-interactive)",
+        isFlag: true
+      },
+      {
+        name: "trust-dir",
+        description: "Trust files in this directory (non-interactive; absolute path)"
+      }
+    ],
+    handler: async (hctx) => {
+      await conciergeCommand(hctx);
+    }
+  });
+  registry.registerCommand({
+    path: ["dev", "import-local"],
+    description: "Import remote workspace locally",
+    requiresWorkspace: true,
+    handler: async ({ ctx, workspace }) => {
+      await devImportLocalCommand(requireAuth(ctx), workspace);
+    }
+  });
+  registry.registerCommand({
+    path: ["whoami"],
+    description: "Show current user info",
+    handler: async ({ ctx }) => {
+      await whoamiCommand(requireAuth(ctx));
+    }
+  });
+  registry.registerCommand({
+    path: ["organizations", "list"],
+    description: "List organizations",
+    handler: async ({ ctx }) => {
+      await organizationsListCommand(requireAuth(ctx));
+    }
+  });
+  registry.registerCommand({
+    path: ["orgs", "list"],
+    description: "List organizations",
+    handler: async ({ ctx }) => {
+      await organizationsListCommand(requireAuth(ctx));
+    }
+  });
+}
+export {
+  registerSpecialCommands
+};
+//# sourceMappingURL=register-special-commands.js.map