@gravity-rail/cli 0.7.2 → 0.8.0

package/dist/chunk-L5YCPUAM.js

@@ -0,0 +1,761 @@
+import {
+  CredentialsManager,
+  getEnvironmentConfig,
+  printTable,
+  refreshAccessToken
+} from "./chunk-H62EC2CF.js";
+import {
+  AuthRequiredError,
+  CLIError
+} from "./chunk-7VZ4JLAJ.js";
+
+// 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 isPaginatedResponse(data) {
+  return isPagePaginatedResponse(data) || isCursorPaginatedResponse(data);
+}
+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 LIST_PAGINATION_ARGS = [
+  { name: "page", description: "Page number" },
+  { name: "page-size", description: "Page size" },
+  { name: "all", description: "Fetch all pages and return combined results", isFlag: true }
+];
+function parsePaginationArgs(args) {
+  const result = {};
+  if (args.all === true) {
+    result.all = true;
+  }
+  if (args.page !== void 0) {
+    const num = Number(args.page);
+    if (isNaN(num) || num < 1) throw new CLIError("--page must be a positive integer");
+    result.page = num;
+  }
+  if (args["page-size"] !== void 0) {
+    const num = Number(args["page-size"]);
+    if (isNaN(num) || num < 1) throw new CLIError("--page-size must be a positive integer");
+    if (num > 100) throw new CLIError("--page-size must be at most 100 (API limit)");
+    result.pageSize = num;
+  }
+  return result;
+}
+var MAX_PAGE_SIZE = 100;
+var MAX_PAGES = 200;
+async function fetchAllPages(fetcher) {
+  const allItems = [];
+  let page = 1;
+  while (page <= MAX_PAGES) {
+    const result = await fetcher({ page, pageSize: MAX_PAGE_SIZE });
+    const items = unwrapItems(result);
+    allItems.push(...items);
+    const meta = extractPaginationMeta(result);
+    if (meta?.totalPages !== void 0) {
+      if (page >= meta.totalPages) break;
+    } else if (!isPagePaginatedResponse(result)) {
+      if (items.length < MAX_PAGE_SIZE) break;
+    }
+    if (page === MAX_PAGES) {
+      throw new CLIError(
+        `Reached maximum page limit (${MAX_PAGES}). Results may be incomplete.`
+      );
+    }
+    page++;
+  }
+  return allItems;
+}
+async function fetchAllCursorPages(fetcher) {
+  const allItems = [];
+  let cursor;
+  let pages = 0;
+  while (pages < MAX_PAGES) {
+    const result = await fetcher({ cursor });
+    const items = unwrapItems(result);
+    allItems.push(...items);
+    pages++;
+    if (isCursorPaginatedResponse(result) && result.hasMore && result.nextCursor) {
+      cursor = result.nextCursor;
+    } else {
+      break;
+    }
+    if (pages === MAX_PAGES) {
+      throw new CLIError(
+        `Reached maximum page limit (${MAX_PAGES}). Results may be incomplete.`
+      );
+    }
+  }
+  return allItems;
+}
+function listResult(data, supportsAll = false) {
+  return {
+    items: unwrapItems(data),
+    meta: extractPaginationMeta(data),
+    supportsAll
+  };
+}
+
+// src/lib/output.ts
+function detectOutputFormat(explicit) {
+  if (explicit) return explicit;
+  return process.stdout.isTTY ? "table" : "json";
+}
+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;
+  }
+}
+var COL = {
+  id: () => ({ header: "ID", getValue: (item) => String(item.id ?? "") }),
+  uuid: () => ({ header: "UUID", getValue: (item) => item.uuid ?? "" }),
+  name: () => ({ header: "NAME", getValue: (item) => item.name ?? "" }),
+  status: () => ({ header: "STATUS", getValue: (item) => item.status ?? "" }),
+  created: () => ({
+    header: "CREATED",
+    getValue: (item) => item.created_at ?? ""
+  }),
+  updated: () => ({
+    header: "UPDATED",
+    getValue: (item) => item.updated_at ?? ""
+  }),
+  description: () => ({
+    header: "DESCRIPTION",
+    getValue: (item) => item.description ?? ""
+  }),
+  enabled: () => ({
+    header: "ENABLED",
+    getValue: (item) => String(item.enabled ?? "")
+  })
+};
+function stderr(msg) {
+  process.stderr.write(msg + "\n");
+}
+
+// src/lib/context.ts
+import { GravityRailClient } from "@gravity-rail/sdk";
+import { homedir } from "os";
+
+// src/lib/realm.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function findDevRealmsFile() {
+  let dir = process.cwd();
+  while (dir !== dirname(dir)) {
+    const candidate = join(dir, "dev-realms.json");
+    if (existsSync(candidate)) return candidate;
+    dir = dirname(dir);
+  }
+  throw new Error("Cannot find dev-realms.json in any parent directory");
+}
+var DEV_CLOUD_CACHE_DIR = ".dev-cloud";
+var CACHE_MAX_AGE_MS = 60 * 60 * 1e3;
+function findRepoRoot() {
+  let dir = process.cwd();
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, ".git"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return void 0;
+}
+function getDevCloudCacheDir(namespace) {
+  const repoRoot = findRepoRoot();
+  const base = repoRoot ?? process.cwd();
+  return join(base, DEV_CLOUD_CACHE_DIR, namespace);
+}
+function fetchDevCloudRealms(namespace) {
+  const k8sNamespace = `dev-cloud-${namespace}`;
+  const cmd = `kubectl exec -n ${k8sNamespace} deploy/env -c devbox -- cat /workspace/dev-realms.json`;
+  try {
+    return execSync(cmd, { encoding: "utf-8", timeout: 3e4 });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Failed to fetch dev-realms.json from dev-cloud pod "${namespace}": ${message}`
+    );
+  }
+}
+function loadDevCloudRealmFile(namespace) {
+  const cacheDir = getDevCloudCacheDir(namespace);
+  const cachePath = join(cacheDir, "dev-realms.json");
+  if (existsSync(cachePath)) {
+    const stat = statSync(cachePath);
+    const age = Date.now() - stat.mtimeMs;
+    if (age < CACHE_MAX_AGE_MS) {
+      return cachePath;
+    }
+  }
+  const content = fetchDevCloudRealms(namespace);
+  mkdirSync(cacheDir, { recursive: true });
+  writeFileSync(cachePath, content, "utf-8");
+  return cachePath;
+}
+function loadRealmCredentials(realm, devRealmsPath) {
+  const filePath = devRealmsPath ?? findDevRealmsFile();
+  let data;
+  try {
+    data = JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    throw new Error(`Cannot read dev-realms.json at ${filePath}`);
+  }
+  const parts = realm.split("/");
+  if (parts.length === 1) {
+    const accounts = data._accounts;
+    const account = accounts?.[parts[0]];
+    if (!account?.token) {
+      throw new Error(`Realm account "${parts[0]}" not found in dev-realms.json`);
+    }
+    return { token: account.token };
+  } else {
+    const [wsName, memberName] = parts;
+    const ws = data[wsName];
+    if (!ws) {
+      throw new Error(`Realm workspace "${wsName}" not found in dev-realms.json`);
+    }
+    const member = ws.members?.[memberName];
+    if (!member?.token) {
+      throw new Error(`Realm member "${memberName}" not found in workspace "${wsName}"`);
+    }
+    return { token: member.token, workspaceUuid: ws.workspaceUuid };
+  }
+}
+
+// src/lib/org-auth.ts
+import { execFile } from "child_process";
+var ORG_AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+function extractOrgTokenFromSetCookies(setCookieValues, preferredCookieName) {
+  let fallback;
+  for (const value of setCookieValues) {
+    const nameValue = value.split(";")[0]?.trim() ?? "";
+    const eqIdx = nameValue.indexOf("=");
+    if (eqIdx === -1) continue;
+    const name = nameValue.slice(0, eqIdx).trim();
+    const tokenValue = nameValue.slice(eqIdx + 1).trim() || void 0;
+    if (!tokenValue) continue;
+    if (name === preferredCookieName) return tokenValue;
+    if (!fallback && (name.startsWith("orgToken") || name.startsWith("orgSession"))) {
+      fallback = tokenValue;
+    }
+  }
+  return fallback;
+}
+async function tryDirectJoin(apiUrl, accessToken, orgAuthInfo) {
+  const response = await fetch(`${apiUrl}/api/v2/o/${orgAuthInfo.orgUuid}/join`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`
+    },
+    body: "{}"
+  });
+  if (response.status === 400) {
+    return null;
+  }
+  if (!response.ok) {
+    throw new Error(`Org join failed (HTTP ${response.status})`);
+  }
+  const rawHeaders = response.headers;
+  const setCookies = rawHeaders.getSetCookie?.() ?? (rawHeaders.get("set-cookie") ? [rawHeaders.get("set-cookie")] : []);
+  if (setCookies.length === 0) {
+    throw new Error("Org join succeeded but no Set-Cookie header returned");
+  }
+  const orgToken = extractOrgTokenFromSetCookies(setCookies, orgAuthInfo.cookieName);
+  if (!orgToken) {
+    throw new Error("Org join succeeded but org token cookie not found in Set-Cookie");
+  }
+  return orgToken;
+}
+function isAllowedAuthUrl(url, apiUrl) {
+  try {
+    const parsed = new URL(url);
+    const api = new URL(apiUrl);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
+    if (parsed.hostname === api.hostname) return true;
+    const lastTwo = (host) => {
+      const parts = host.split(".").filter(Boolean);
+      return parts.length >= 2 ? parts.slice(-2).join(".") : host;
+    };
+    const isIp = /^[0-9.]+$|^\[.*\]$/.test(parsed.hostname);
+    if (isIp) return false;
+    return lastTwo(parsed.hostname) === lastTwo(api.hostname);
+  } catch {
+    return false;
+  }
+}
+function openBrowser(url) {
+  let command;
+  let args;
+  if (process.platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    command = "cmd.exe";
+    args = ["/c", "start", "", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  execFile(command, args, (_err) => {
+  });
+}
+function registerOrgAuthHandler(apiClient, apiUrl, accessToken) {
+  apiClient.setOrgAuthHandler(async (orgAuthInfo) => {
+    try {
+      const orgToken = await tryDirectJoin(apiUrl, accessToken, orgAuthInfo);
+      if (orgToken !== null) {
+        apiClient.setOrgToken(orgToken, orgAuthInfo.orgUuid);
+        return;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      stderr(`Warning: org direct-join failed (${msg}); trying browser auth`);
+    }
+    if (!isAllowedAuthUrl(orgAuthInfo.authUrl, apiUrl)) {
+      throw new Error(
+        `Refusing to open organization auth URL: scheme/host does not match the configured API host. Re-run with the expected --api-url, or contact support.`
+      );
+    }
+    stderr(`
+This workspace requires organization SSO authentication.`);
+    stderr(`Opening browser to complete authentication...`);
+    stderr(`  ${orgAuthInfo.authUrl}
+`);
+    stderr(`If the browser does not open, visit the URL above manually.`);
+    stderr(
+      `After signing in, re-run the command \u2014 the CLI cannot receive the SSO token directly.`
+    );
+    openBrowser(orgAuthInfo.authUrl);
+    await new Promise((_, reject) => {
+      const t = setTimeout(
+        () => reject(
+          new Error(
+            "Organization authentication timed out.\nPlease complete authentication in the browser, then re-run the command."
+          )
+        ),
+        ORG_AUTH_TIMEOUT_MS
+      );
+      t.unref?.();
+    });
+  });
+}
+
+// src/lib/pinned-fetch.ts
+import { Agent, fetch as undiciFetch } from "undici";
+function createPinnedFetch(apiUrl, apiIp) {
+  if (!apiIp) return fetch;
+  let parsed;
+  try {
+    parsed = new URL(apiUrl);
+  } catch {
+    return fetch;
+  }
+  const hostname = parsed.hostname;
+  const dispatcher = new Agent({
+    connect: {
+      servername: hostname
+    }
+  });
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    let reqUrl;
+    try {
+      reqUrl = new URL(url, apiUrl);
+    } catch {
+      return fetch(input, init);
+    }
+    const headers = new Headers(init?.headers);
+    if (reqUrl.hostname === hostname) {
+      headers.set("Host", hostname);
+      reqUrl = new URL(reqUrl.href);
+      reqUrl.hostname = apiIp;
+    }
+    return undiciFetch(reqUrl, {
+      ...init,
+      headers,
+      dispatcher
+    });
+  };
+}
+function withAuditHeaders(fetchFn, headers) {
+  const { chatId, sessionId, toolCallId } = headers;
+  return async (input, init) => {
+    const reqHeaders = new Headers(init?.headers);
+    const dynamicToolCallId = globalThis.__GRAVITY_RAIL_TOOL_CALL_ID__ || (typeof process !== "undefined" ? process.env.GRAVITY_RAIL_TOOL_CALL_ID : void 0);
+    if (chatId !== void 0) {
+      reqHeaders.set("X-GR-Chat-Id", String(chatId));
+    }
+    if (sessionId) {
+      reqHeaders.set("X-GR-Session-Id", sessionId);
+    }
+    if (dynamicToolCallId || toolCallId) {
+      reqHeaders.set("X-GR-Tool-Call-Id", dynamicToolCallId || toolCallId || "");
+    }
+    return fetchFn(input, { ...init, headers: reqHeaders });
+  };
+}
+function createSandboxFetchFromEnv(apiUrl) {
+  const env = typeof process !== "undefined" ? process.env : {};
+  const apiIp = env.GRAVITY_RAIL_API_IP;
+  let fetchFn = createPinnedFetch(apiUrl, apiIp);
+  const chatIdRaw = env.GRAVITY_RAIL_CHAT_ID;
+  const chatId = chatIdRaw ? Number(chatIdRaw) : void 0;
+  return withAuditHeaders(fetchFn, {
+    chatId: chatId !== void 0 && Number.isFinite(chatId) ? chatId : void 0,
+    sessionId: env.GRAVITY_RAIL_SESSION_ID,
+    toolCallId: env.GRAVITY_RAIL_TOOL_CALL_ID
+  });
+}
+
+// src/lib/context.ts
+function makeApiClient(accessToken, apiUrl) {
+  const fetchFn = createSandboxFetchFromEnv(apiUrl);
+  const apiClient = new GravityRailClient(accessToken, apiUrl, fetchFn);
+  registerOrgAuthHandler(apiClient, apiUrl, accessToken);
+  return apiClient;
+}
+async function tryTokenRefresh(ctx, creds) {
+  if (!creds.refreshToken) return null;
+  const refreshed = await refreshAccessToken(
+    ctx.envConfig,
+    creds,
+    ctx.credentialsManager,
+    ctx.env
+  );
+  if (!refreshed?.accessToken) return null;
+  const apiClient = makeApiClient(refreshed.accessToken, ctx.envConfig.apiUrl);
+  return { ...ctx, accessToken: refreshed.accessToken, apiClient };
+}
+function createContext(opts) {
+  const baseConfig = getEnvironmentConfig(opts.env);
+  const apiUrl = opts.apiUrl || process.env.GRAVITY_RAIL_API_URL || baseConfig.apiUrl;
+  const envConfig = apiUrl === baseConfig.apiUrl ? baseConfig : { ...baseConfig, apiUrl };
+  const credentialsManager = new CredentialsManager(homedir(), envConfig.apiUrl);
+  return {
+    env: opts.env,
+    envConfig,
+    outputFormat: detectOutputFormat(opts.outputFormat),
+    verbose: opts.verbose ?? false,
+    allowWrite: opts.allowWrite ?? false,
+    credentialsManager
+  };
+}
+async function createAuthenticatedContext(opts) {
+  const ctx = createContext(opts);
+  if (opts.realm) {
+    let devRealmsPath;
+    if (opts.env.startsWith("dev-cloud:")) {
+      const namespace = opts.env.slice("dev-cloud:".length);
+      devRealmsPath = loadDevCloudRealmFile(namespace);
+    }
+    const { token, workspaceUuid } = loadRealmCredentials(opts.realm, devRealmsPath);
+    const apiClient = makeApiClient(token, ctx.envConfig.apiUrl);
+    return { ...ctx, accessToken: token, apiClient, realmWorkspace: workspaceUuid };
+  }
+  const apiKey = process.env.GRAVITY_RAIL_API_KEY;
+  if (apiKey) {
+    const apiClient = makeApiClient(apiKey, ctx.envConfig.apiUrl);
+    return { ...ctx, accessToken: apiKey, apiClient };
+  }
+  const creds = ctx.credentialsManager.load(ctx.env);
+  if (creds?.accessToken) {
+    const buffer = 5 * 60 * 1e3;
+    const notExpired = !creds.expiresAt || new Date(creds.expiresAt) > new Date(Date.now() + buffer);
+    if (notExpired) {
+      const apiClient = makeApiClient(creds.accessToken, ctx.envConfig.apiUrl);
+      return { ...ctx, accessToken: creds.accessToken, apiClient };
+    }
+    const refreshed = await tryTokenRefresh(ctx, creds);
+    if (refreshed) return refreshed;
+  }
+  throw new AuthRequiredError();
+}
+function requireAuth(ctx) {
+  if (!("apiClient" in ctx)) {
+    throw new Error("Command handler accessed apiClient without declaring requiresAuth");
+  }
+  return ctx;
+}
+function createPublicContext(opts) {
+  const env = opts.env ?? "prod";
+  const envConfig = opts.apiUrl ? {
+    apiUrl: opts.apiUrl,
+    frontendUrl: opts.frontendUrl || process.env.GRAVITY_RAIL_FRONTEND_URL || "https://app.gravityrail.com"
+  } : getEnvironmentConfig(env);
+  const credentialsManager = new CredentialsManager(homedir(), envConfig.apiUrl);
+  return {
+    env,
+    envConfig,
+    outputFormat: detectOutputFormat(opts.outputFormat),
+    verbose: opts.verbose ?? false,
+    allowWrite: opts.allowWrite ?? false,
+    credentialsManager
+  };
+}
+async function createPublicAuthenticatedContext(opts) {
+  const ctx = createPublicContext(opts);
+  const apiKey = process.env.GRAVITY_RAIL_API_KEY;
+  if (apiKey) {
+    const apiClient = makeApiClient(apiKey, ctx.envConfig.apiUrl);
+    return { ...ctx, accessToken: apiKey, apiClient };
+  }
+  const creds = ctx.credentialsManager.load(ctx.env);
+  if (creds?.accessToken) {
+    const buffer = 5 * 60 * 1e3;
+    const notExpired = !creds.expiresAt || new Date(creds.expiresAt) > new Date(Date.now() + buffer);
+    if (notExpired) {
+      const apiClient = makeApiClient(creds.accessToken, ctx.envConfig.apiUrl);
+      return { ...ctx, accessToken: creds.accessToken, apiClient };
+    }
+    const refreshed = await tryTokenRefresh(ctx, creds);
+    if (refreshed) return refreshed;
+  }
+  throw new AuthRequiredError();
+}
+
+// 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", outboundMessage, clientSurface) {
+  const body = { kind };
+  if (outboundMessage) body.outbound_message = outboundMessage;
+  if (clientSurface) body.client_surface = clientSurface;
+  const res = await fetch(`${baseUrl(ctx)}/calls`, {
+    method: "POST",
+    headers: authHeaders(ctx),
+    body: JSON.stringify(body)
+  });
+  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);
+}
+
+export {
+  isListResult,
+  isPagePaginatedResponse,
+  isCursorPaginatedResponse,
+  isPaginatedResponse,
+  extractPaginationMeta,
+  formatPaginationWarning,
+  unwrapItems,
+  LIST_PAGINATION_ARGS,
+  parsePaginationArgs,
+  fetchAllPages,
+  fetchAllCursorPages,
+  listResult,
+  detectOutputFormat,
+  outputData,
+  outputSingle,
+  COL,
+  stderr,
+  createContext,
+  createAuthenticatedContext,
+  requireAuth,
+  createPublicContext,
+  createPublicAuthenticatedContext,
+  listConciergeChats,
+  createConciergeChat,
+  getConciergeChat,
+  originateConciergeCall,
+  originateConciergeSms,
+  startAccountPhoneVerify,
+  confirmAccountPhoneVerify,
+  getConciergeChatMessages
+};
+//# sourceMappingURL=chunk-L5YCPUAM.js.map