ima2-gen 1.1.13 → 1.1.16

package/node_modules/progrok/dist/index.js

@@ -0,0 +1,1142 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+
+// src/auth/pkce.ts
+import { randomBytes, createHash } from "crypto";
+
+// src/auth/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var XAI_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+var XAI_OAUTH_SCOPE = "openid profile email offline_access grok-cli:access api:access";
+var XAI_OAUTH_ISSUER = "https://auth.x.ai";
+var XAI_OAUTH_DISCOVERY_URL = `${XAI_OAUTH_ISSUER}/.well-known/openid-configuration`;
+var XAI_OAUTH_CALLBACK_HOST = "127.0.0.1";
+var XAI_OAUTH_CALLBACK_PORT = 56121;
+var XAI_OAUTH_CALLBACK_PATH = "/callback";
+var XAI_OAUTH_REDIRECT_URI = `http://${XAI_OAUTH_CALLBACK_HOST}:${XAI_OAUTH_CALLBACK_PORT}${XAI_OAUTH_CALLBACK_PATH}`;
+var XAI_OAUTH_CORS_ORIGINS = ["auth.x.ai", "accounts.x.ai"];
+var XAI_OAUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+var XAI_OAUTH_FETCH_TIMEOUT_MS = 30 * 1e3;
+var XAI_DEVICE_CODE_POLL_INTERVAL_MS = 5 * 1e3;
+var TOKEN_REFRESH_SKEW_MS = 2 * 60 * 1e3;
+var XAI_API_BASE_URL = "https://api.x.ai/v1";
+var DEFAULT_MODEL = "grok-4.3";
+var PROXY_DEFAULT_PORT = 18645;
+var PROXY_DEFAULT_HOST = "127.0.0.1";
+var CHAT_DEFAULT_PORT = 18646;
+var CONFIG_DIR = join(homedir(), ".progrok");
+var AUTH_FILE = join(CONFIG_DIR, "auth.json");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var GITHUB_REPO = "lidge-jun/progrok";
+var GITHUB_URL = `https://github.com/${GITHUB_REPO}`;
+
+// src/auth/discovery.ts
+function requireTrustedEndpoint(url, label) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:") {
+      throw new Error("not HTTPS");
+    }
+    if (parsed.hostname !== "x.ai" && !parsed.hostname.endsWith(".x.ai")) {
+      throw new Error("not *.x.ai");
+    }
+    return url;
+  } catch {
+    throw new Error(`OIDC discovery returned untrusted ${label}: ${url}`);
+  }
+}
+async function fetchOIDCDiscovery() {
+  const res = await fetch(XAI_OAUTH_DISCOVERY_URL, {
+    signal: AbortSignal.timeout(XAI_OAUTH_FETCH_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(`OIDC discovery failed: HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  const authorizationEndpoint = requireTrustedEndpoint(
+    data.authorization_endpoint,
+    "authorization_endpoint"
+  );
+  const tokenEndpoint = requireTrustedEndpoint(
+    data.token_endpoint,
+    "token_endpoint"
+  );
+  const deviceAuthorizationEndpoint = data.device_authorization_endpoint ? requireTrustedEndpoint(
+    data.device_authorization_endpoint,
+    "device_authorization_endpoint"
+  ) : void 0;
+  return { authorizationEndpoint, tokenEndpoint, deviceAuthorizationEndpoint };
+}
+
+// src/auth/callback-server.ts
+import { createServer } from "http";
+function startCallbackServer(expectedState) {
+  return new Promise((resolve, reject) => {
+    let server;
+    const timeout = setTimeout(() => {
+      server?.close();
+      reject(new Error("OAuth callback timed out (5 minutes)"));
+    }, XAI_OAUTH_TIMEOUT_MS);
+    server = createServer((req, res) => {
+      const url = new URL(
+        req.url || "/",
+        `http://${XAI_OAUTH_CALLBACK_HOST}`
+      );
+      if (req.method === "OPTIONS") {
+        const origin = req.headers.origin || "";
+        try {
+          const originHost = new URL(origin).hostname;
+          if (XAI_OAUTH_CORS_ORIGINS.includes(originHost)) {
+            res.writeHead(204, {
+              "Access-Control-Allow-Origin": origin,
+              "Access-Control-Allow-Methods": "GET",
+              "Access-Control-Allow-Headers": "Content-Type"
+            });
+          } else {
+            res.writeHead(204);
+          }
+        } catch {
+          res.writeHead(204);
+        }
+        res.end();
+        return;
+      }
+      if (url.pathname !== XAI_OAUTH_CALLBACK_PATH) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      if (error) {
+        const desc = url.searchParams.get("error_description") || error;
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<html><body><h2>Login failed</h2><p>${desc}</p><p>You can close this tab.</p></body></html>`
+        );
+        clearTimeout(timeout);
+        server?.close();
+        reject(new Error(`OAuth error: ${desc}`));
+        return;
+      }
+      if (!code || state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Invalid callback</h2></body></html>");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        `<html><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Logged in to progrok</h2><p>You can close this tab and return to the terminal.</p></body></html>`
+      );
+      clearTimeout(timeout);
+      server?.close();
+      resolve({ code, state });
+    });
+    server.listen(XAI_OAUTH_CALLBACK_PORT, XAI_OAUTH_CALLBACK_HOST, () => {
+    });
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Callback server failed: ${err.message}`));
+    });
+  });
+}
+
+// src/auth/token-store.ts
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  unlinkSync
+} from "fs";
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var log = {
+  info: (msg) => {
+    console.log(msg);
+  },
+  success: (msg) => {
+    console.log(`${GREEN}${msg}${RESET}`);
+  },
+  error: (msg) => {
+    console.error(`${RED}${msg}${RESET}`);
+  },
+  dim: (msg) => {
+    console.log(`${DIM}${msg}${RESET}`);
+  },
+  bold: (msg) => {
+    console.log(`${BOLD}${msg}${RESET}`);
+  }
+};
+
+// src/auth/token-store.ts
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+async function saveTokens(input) {
+  ensureConfigDir();
+  const data = {
+    accessToken: input.accessToken,
+    refreshToken: input.refreshToken,
+    expiresAt: input.expiresIn ? Date.now() + input.expiresIn * 1e3 : void 0,
+    tokenEndpoint: input.tokenEndpoint,
+    idToken: input.idToken
+  };
+  if (input.idToken) {
+    try {
+      const parts = input.idToken.split(".");
+      if (parts[1]) {
+        const payload = JSON.parse(
+          Buffer.from(parts[1], "base64url").toString()
+        );
+        if (typeof payload.email === "string") {
+          data.email = payload.email;
+        }
+      }
+    } catch {
+    }
+  }
+  writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function loadTokens() {
+  try {
+    const raw = readFileSync(AUTH_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function deleteTokens() {
+  try {
+    unlinkSync(AUTH_FILE);
+  } catch {
+  }
+}
+async function getValidBearer() {
+  const tokens = loadTokens();
+  if (!tokens?.accessToken) {
+    throw new Error("Not logged in. Run `progrok login` first.");
+  }
+  if (tokens.expiresAt && Date.now() + TOKEN_REFRESH_SKEW_MS >= tokens.expiresAt) {
+    if (!tokens.refreshToken || !tokens.tokenEndpoint) {
+      throw new Error(
+        "Token expired and no refresh token available. Run `progrok login` again."
+      );
+    }
+    log.dim("Refreshing access token...");
+    const res = await fetch(tokens.tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: XAI_OAUTH_CLIENT_ID,
+        refresh_token: tokens.refreshToken
+      }),
+      signal: AbortSignal.timeout(XAI_OAUTH_FETCH_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      throw new Error("Token refresh failed. Run `progrok login` again.");
+    }
+    const refreshed = await res.json();
+    if (typeof refreshed.access_token !== "string" || !refreshed.access_token) {
+      throw new Error(
+        "Token refresh returned invalid access_token. Run `progrok login` again."
+      );
+    }
+    await saveTokens({
+      accessToken: refreshed.access_token,
+      refreshToken: (typeof refreshed.refresh_token === "string" ? refreshed.refresh_token : void 0) || tokens.refreshToken,
+      expiresIn: typeof refreshed.expires_in === "number" ? refreshed.expires_in : void 0,
+      tokenEndpoint: tokens.tokenEndpoint
+    });
+    return refreshed.access_token;
+  }
+  return tokens.accessToken;
+}
+
+// src/utils/open-url.ts
+import open from "open";
+async function openUrl(url) {
+  try {
+    await open(url);
+  } catch {
+  }
+}
+
+// src/auth/pkce.ts
+function generatePKCE() {
+  const verifier = randomBytes(32).toString("hex");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+async function loginWithPKCE() {
+  const discovery = await fetchOIDCDiscovery();
+  const pkce = generatePKCE();
+  const state = randomBytes(16).toString("hex");
+  const authorizeUrl = new URL(discovery.authorizationEndpoint);
+  authorizeUrl.searchParams.set("client_id", XAI_OAUTH_CLIENT_ID);
+  authorizeUrl.searchParams.set("redirect_uri", XAI_OAUTH_REDIRECT_URI);
+  authorizeUrl.searchParams.set("response_type", "code");
+  authorizeUrl.searchParams.set("scope", XAI_OAUTH_SCOPE);
+  authorizeUrl.searchParams.set("state", state);
+  authorizeUrl.searchParams.set("code_challenge", pkce.challenge);
+  authorizeUrl.searchParams.set("code_challenge_method", "S256");
+  log.info("Opening browser for xAI login...");
+  log.dim(
+    `If the browser doesn't open, visit:
+${authorizeUrl.toString()}`
+  );
+  const callbackPromise = startCallbackServer(state);
+  await openUrl(authorizeUrl.toString());
+  const { code } = await callbackPromise;
+  log.info("Exchanging authorization code...");
+  const tokenRes = await fetch(discovery.tokenEndpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: XAI_OAUTH_CLIENT_ID,
+      code,
+      redirect_uri: XAI_OAUTH_REDIRECT_URI,
+      code_verifier: pkce.verifier
+    }),
+    signal: AbortSignal.timeout(XAI_OAUTH_FETCH_TIMEOUT_MS)
+  });
+  if (!tokenRes.ok) {
+    const err = await tokenRes.text();
+    throw new Error(`Token exchange failed: ${err}`);
+  }
+  const tokens = await tokenRes.json();
+  await saveTokens({
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresIn: tokens.expires_in,
+    idToken: tokens.id_token,
+    tokenEndpoint: discovery.tokenEndpoint
+  });
+  log.success("Logged in to xAI successfully!");
+}
+
+// src/auth/device-code.ts
+async function loginWithDeviceCode() {
+  const discovery = await fetchOIDCDiscovery();
+  if (!discovery.deviceAuthorizationEndpoint) {
+    throw new Error(
+      "xAI does not support device code flow via OIDC discovery"
+    );
+  }
+  log.info("Requesting device code...");
+  const dcRes = await fetch(discovery.deviceAuthorizationEndpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: XAI_OAUTH_CLIENT_ID,
+      scope: XAI_OAUTH_SCOPE
+    }),
+    signal: AbortSignal.timeout(XAI_OAUTH_FETCH_TIMEOUT_MS)
+  });
+  if (!dcRes.ok) {
+    throw new Error(`Device code request failed: ${await dcRes.text()}`);
+  }
+  const dc = await dcRes.json();
+  const url = dc.verification_uri_complete || dc.verification_uri;
+  log.info(`
+Open this URL in your browser:
+  ${url}
+`);
+  log.info(`Enter code: ${dc.user_code}
+`);
+  const intervalMs = Math.max(
+    (dc.interval || 5) * 1e3,
+    XAI_DEVICE_CODE_POLL_INTERVAL_MS
+  );
+  const deadline = Date.now() + dc.expires_in * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, intervalMs));
+    const pollRes = await fetch(discovery.tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        client_id: XAI_OAUTH_CLIENT_ID,
+        device_code: dc.device_code
+      }),
+      signal: AbortSignal.timeout(XAI_OAUTH_FETCH_TIMEOUT_MS)
+    });
+    if (pollRes.ok) {
+      const tokens = await pollRes.json();
+      await saveTokens({
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresIn: tokens.expires_in,
+        idToken: tokens.id_token,
+        tokenEndpoint: discovery.tokenEndpoint
+      });
+      log.success("Logged in to xAI successfully!");
+      return;
+    }
+    const err = await pollRes.json();
+    if (err.error === "authorization_pending") continue;
+    if (err.error === "slow_down") {
+      await new Promise((r) => setTimeout(r, 5e3));
+      continue;
+    }
+    throw new Error(
+      `Device code poll failed: ${err.error_description || err.error}`
+    );
+  }
+  throw new Error("Device code expired. Please try again.");
+}
+
+// src/commands/login.ts
+function loginCommand() {
+  const cmd = new Command("login").description(
+    `Log in to xAI via OAuth (SuperGrok subscription required).
+  Default: PKCE flow \u2014 opens browser, callback on 127.0.0.1:56121.
+  Remote:  --device-code \u2014 displays URL + code for manual entry.
+  Tokens saved to ~/.progrok/auth.json, auto-refreshed before expiry.`
+  ).option(
+    "--device-code",
+    "Use device code flow (for SSH/remote environments)"
+  ).action(async (opts) => {
+    try {
+      if (opts.deviceCode) {
+        await loginWithDeviceCode();
+      } else {
+        await loginWithPKCE();
+      }
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+function logoutCommand() {
+  return new Command2("logout").description("Remove stored xAI credentials").action(() => {
+    deleteTokens();
+    log.success("Logged out. Credentials removed.");
+  });
+}
+
+// src/commands/proxy.ts
+import { Command as Command3 } from "commander";
+
+// src/proxy/server.ts
+import express from "express";
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "host",
+  "content-length",
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailers",
+  "transfer-encoding",
+  "upgrade",
+  "authorization"
+]);
+function filterHeaders(headers) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (!HOP_BY_HOP.has(key.toLowerCase()) && value) {
+      out[key] = Array.isArray(value) ? value[0] : value;
+    }
+  }
+  return out;
+}
+function createProxyApp() {
+  const app = express();
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", upstream: "xAI Grok", proxy: "progrok" });
+  });
+  app.all("/v1/*", (req, res) => {
+    void handleProxy(req, res);
+  });
+  return app;
+}
+async function handleProxy(req, res) {
+  const relPath = req.path.replace(/^\/v1/, "");
+  let bearer;
+  try {
+    bearer = await getValidBearer();
+  } catch (err) {
+    res.status(401).json({
+      error: { message: err.message, type: "auth_error" }
+    });
+    return;
+  }
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const body = Buffer.concat(chunks);
+  const qs = req.url.includes("?") ? "?" + req.url.split("?")[1] : "";
+  const upstreamUrl = `${XAI_API_BASE_URL}${relPath}${qs}`;
+  const fwdHeaders = filterHeaders(
+    req.headers
+  );
+  fwdHeaders["Authorization"] = `Bearer ${bearer}`;
+  try {
+    const upstream = await fetch(upstreamUrl, {
+      method: req.method,
+      headers: fwdHeaders,
+      body: body.length > 0 ? body : void 0
+    });
+    res.status(upstream.status);
+    for (const [key, value] of upstream.headers) {
+      const lower = key.toLowerCase();
+      if (!HOP_BY_HOP.has(lower) && lower !== "content-encoding" && lower !== "content-length") {
+        res.setHeader(key, value);
+      }
+    }
+    if (upstream.body) {
+      const reader = upstream.body.getReader();
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(value);
+        }
+      } catch {
+      }
+    }
+    res.end();
+  } catch (err) {
+    if (!res.headersSent) {
+      res.status(502).json({
+        error: {
+          message: `Upstream error: ${err.message}`,
+          type: "upstream_error"
+        }
+      });
+    }
+  }
+}
+async function startProxy(port = PROXY_DEFAULT_PORT, host = PROXY_DEFAULT_HOST) {
+  const app = createProxyApp();
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, host, () => {
+      log.success("progrok proxy running");
+      log.info(`  Listening:    http://${host}:${port}/v1`);
+      log.info(`  Forwarding:   ${XAI_API_BASE_URL}`);
+      log.dim(
+        "  Client auth:  any bearer token (proxy injects your OAuth credential)"
+      );
+      log.info("\nPress Ctrl+C to stop.\n");
+      resolve();
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Proxy failed to start: ${err.message}`));
+    });
+    process.on("SIGINT", () => {
+      log.info("\nprogrok proxy stopped.");
+      server.close();
+      process.exit(0);
+    });
+  });
+}
+
+// src/commands/proxy.ts
+function proxyCommand() {
+  return new Command3("proxy").description(
+    `Start OpenAI-compatible proxy server for Grok.
+  Forwards ALL /v1/* requests to api.x.ai with your OAuth token injected.
+  Any client (curl, OpenAI SDK, LangChain, etc.) can connect \u2014 no API key needed.
+  Supports streaming (SSE), multipart (stt), and binary responses (tts).`
+  ).option("-p, --port <port>", "Port number", String(PROXY_DEFAULT_PORT)).option("--host <host>", "Host to bind", PROXY_DEFAULT_HOST).action(async (opts) => {
+    const tokens = loadTokens();
+    if (!tokens?.accessToken) {
+      log.error("Not logged in. Run `progrok login` first.");
+      process.exit(1);
+    }
+    try {
+      await startProxy(parseInt(opts.port, 10), opts.host);
+      await new Promise(() => {
+      });
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/chat.ts
+import { Command as Command4 } from "commander";
+
+// src/chat/server.ts
+import express2 from "express";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+async function startChat(port = CHAT_DEFAULT_PORT, host = PROXY_DEFAULT_HOST) {
+  const app = createProxyApp();
+  const publicDir = join2(__dirname, "public");
+  app.use(express2.static(publicDir));
+  app.get("/", (_req, res) => {
+    res.sendFile(join2(publicDir, "index.html"));
+  });
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, host, () => {
+      const url = `http://${host}:${port}`;
+      log.success(`progrok chat running at ${url}`);
+      log.dim(`Proxy also available at ${url}/v1`);
+      log.info("Press Ctrl+C to stop.\n");
+      void openUrl(url);
+      resolve();
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Chat server failed: ${err.message}`));
+    });
+    process.on("SIGINT", () => {
+      log.info("\nprogrok chat stopped.");
+      server.close();
+      process.exit(0);
+    });
+  });
+}
+
+// src/commands/chat.ts
+function chatCommand() {
+  return new Command4("chat").description(
+    `Open Grok chat in your browser.
+  Starts a web UI + proxy server on the same port.
+  Features: sessions, markdown, code highlighting, tool results, model switching.
+  Proxy is also available at the same port under /v1/*.`
+  ).option("-p, --port <port>", "Port number", String(CHAT_DEFAULT_PORT)).option("--host <host>", "Host to bind", PROXY_DEFAULT_HOST).action(async (opts) => {
+    const tokens = loadTokens();
+    if (!tokens?.accessToken) {
+      log.error("Not logged in. Run `progrok login` first.");
+      process.exit(1);
+    }
+    try {
+      await startChat(parseInt(opts.port, 10), opts.host);
+      await new Promise(() => {
+      });
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/models.ts
+import { Command as Command5 } from "commander";
+function formatPrice(ticks) {
+  if (!ticks) return "-";
+  return `$${(ticks / 1e4).toFixed(2)}`;
+}
+function modelsCommand() {
+  return new Command5("models").description("List available Grok models").option("--detail", "Show pricing and aliases from /v1/language-models").action(async (opts) => {
+    try {
+      const bearer = await getValidBearer();
+      if (opts.detail) {
+        const res2 = await fetch(`${XAI_API_BASE_URL}/language-models`, {
+          headers: { Authorization: `Bearer ${bearer}` }
+        });
+        if (!res2.ok) throw new Error(`HTTP ${res2.status}`);
+        const data2 = await res2.json();
+        log.info("Grok Models (detailed)\n");
+        for (const m of data2.models) {
+          const input = (m.input_modalities || []).join(", ");
+          const inPrice = formatPrice(m.prompt_text_token_price);
+          const outPrice = formatPrice(m.completion_text_token_price);
+          console.log(`  ${m.id}`);
+          console.log(`    Input: ${input}  |  Price: ${inPrice}/1M in, ${outPrice}/1M out`);
+          if (m.aliases && m.aliases.length > 0) {
+            console.log(`    Aliases: ${m.aliases.slice(0, 5).join(", ")}${m.aliases.length > 5 ? ` (+${m.aliases.length - 5} more)` : ""}`);
+          }
+          console.log();
+        }
+        return;
+      }
+      const res = await fetch(`${XAI_API_BASE_URL}/models`, {
+        headers: { Authorization: `Bearer ${bearer}` }
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      log.info("Available Grok models:\n");
+      for (const m of data.data) {
+        const tag = m.id.includes("reasoning") ? " [reasoning]" : m.id.includes("non-reasoning") ? " [fast]" : m.id.includes("build") || m.id.includes("code") ? " [code]" : m.id.includes("imagine-video") ? " [video]" : m.id.includes("imagine") ? " [image]" : "";
+        console.log(`  ${m.id}${tag}`);
+      }
+      log.dim("\n  Use --detail for pricing and aliases");
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/status.ts
+import { Command as Command6 } from "commander";
+function statusCommand() {
+  return new Command6("status").description("Show authentication status").action(() => {
+    const tokens = loadTokens();
+    if (!tokens?.accessToken) {
+      log.info("Status: Not logged in");
+      log.dim("Run `progrok login` to authenticate.");
+      return;
+    }
+    const expired = tokens.expiresAt !== void 0 && Date.now() >= tokens.expiresAt;
+    const hasRefresh = !!tokens.refreshToken;
+    log.info("Status: Logged in");
+    if (tokens.email) log.info(`  Account: ${tokens.email}`);
+    if (tokens.expiresAt) {
+      const remaining = Math.max(
+        0,
+        Math.floor((tokens.expiresAt - Date.now()) / 6e4)
+      );
+      log.info(
+        `  Token:   ${expired ? "expired" : `valid (${remaining} min remaining)`}`
+      );
+    }
+    log.info(`  Refresh: ${hasRefresh ? "available" : "none"}`);
+  });
+}
+
+// src/commands/skill.ts
+import { Command as Command7 } from "commander";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join3, relative } from "path";
+var ROOT = join3(dirname2(fileURLToPath2(import.meta.url)), "..");
+var SKILL_PATH = join3(ROOT, "skills", "progrok", "SKILL.md");
+var PACKAGE_PATH = join3(ROOT, "package.json");
+function readPackageVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync2(PACKAGE_PATH, "utf-8"));
+    return pkg.version || "?";
+  } catch {
+    return "?";
+  }
+}
+function readSkill() {
+  if (!existsSync2(SKILL_PATH)) {
+    console.error(`packaged skill not found: ${SKILL_PATH}`);
+    process.exit(5);
+  }
+  return readFileSync2(SKILL_PATH, "utf-8");
+}
+function skillCommand() {
+  return new Command7("skill").description(
+    `Print the packaged progrok Markdown skill for agents.
+  Designed to be piped into agent context or read programmatically.`
+  ).argument("[subcommand]", '"path" to print the resolved skill file path').option("--json", "Output as JSON wrapper around the Markdown skill").action((subcommand2, opts) => {
+    if (subcommand2 === "path") {
+      console.log(SKILL_PATH);
+      return;
+    }
+    const content = readSkill();
+    if (opts.json) {
+      console.log(
+        JSON.stringify(
+          {
+            name: "progrok",
+            format: "markdown-skill",
+            formatVersion: "1",
+            packageVersion: readPackageVersion(),
+            path: relative(ROOT, SKILL_PATH),
+            source: "package",
+            content
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(content.replace(/\n$/, ""));
+  });
+}
+
+// src/commands/capabilities.ts
+import { Command as Command8 } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname3, join as join4 } from "path";
+var ROOT2 = join4(dirname3(fileURLToPath3(import.meta.url)), "..");
+function readPackageVersion2() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync3(join4(ROOT2, "package.json"), "utf-8")
+    );
+    return pkg.version || "?";
+  } catch {
+    return "?";
+  }
+}
+function buildCapabilities() {
+  return {
+    ok: true,
+    name: "progrok",
+    version: readPackageVersion2(),
+    source: "local",
+    upstream: XAI_API_BASE_URL,
+    commands: [
+      "login",
+      "logout",
+      "proxy",
+      "chat",
+      "models",
+      "status",
+      "skill",
+      "capabilities"
+    ],
+    proxy: {
+      host: PROXY_DEFAULT_HOST,
+      port: PROXY_DEFAULT_PORT,
+      baseUrl: `http://${PROXY_DEFAULT_HOST}:${PROXY_DEFAULT_PORT}/v1`,
+      forwarding: "all /v1/* paths \u2014 no whitelist"
+    },
+    chat: {
+      port: CHAT_DEFAULT_PORT,
+      url: `http://${PROXY_DEFAULT_HOST}:${CHAT_DEFAULT_PORT}`
+    },
+    defaults: {
+      model: DEFAULT_MODEL
+    },
+    endpoints: [
+      {
+        path: "/v1/responses",
+        method: "POST",
+        type: "streaming",
+        description: "Responses API \u2014 tools, reasoning, citations"
+      },
+      {
+        path: "/v1/chat/completions",
+        method: "POST",
+        type: "streaming",
+        description: "OpenAI-compatible chat"
+      },
+      {
+        path: "/v1/models",
+        method: "GET",
+        type: "sync",
+        description: "List models"
+      },
+      {
+        path: "/v1/language-models",
+        method: "GET",
+        type: "sync",
+        description: "Detailed models: pricing, aliases, modalities"
+      },
+      {
+        path: "/v1/images/generations",
+        method: "POST",
+        type: "sync",
+        description: "Image generation (returns URL)"
+      },
+      {
+        path: "/v1/videos/generations",
+        method: "POST",
+        type: "async",
+        description: "Video generation (returns request_id)"
+      },
+      {
+        path: "/v1/videos/{id}",
+        method: "GET",
+        type: "poll",
+        description: "Video status: pending \u2192 done"
+      },
+      {
+        path: "/v1/tts",
+        method: "POST",
+        type: "binary",
+        description: "Text-to-speech (MP3)"
+      },
+      {
+        path: "/v1/stt",
+        method: "POST",
+        type: "multipart",
+        description: "Speech-to-text"
+      },
+      {
+        path: "/v1/embeddings",
+        method: "POST",
+        type: "sync",
+        description: "Text embeddings"
+      },
+      {
+        path: "/v1/*",
+        method: "*",
+        type: "passthrough",
+        description: "All paths forwarded to api.x.ai"
+      }
+    ],
+    models: [
+      {
+        id: "grok-4.3",
+        type: "reasoning",
+        use: "General chat, analysis, search",
+        input: ["text", "image"],
+        context: "1M tokens",
+        reasoning: {
+          effort: ["none", "low", "medium", "high"],
+          default: "low",
+          note: "none disables reasoning entirely for instant responses"
+        },
+        structuredOutput: true,
+        functionCalling: true,
+        tools: ["web_search", "x_search", "code_interpreter", "file_search"]
+      },
+      {
+        id: "grok-4.20-0309-reasoning",
+        type: "deep-reasoning",
+        use: "Complex coding, planning",
+        input: ["text", "image"],
+        context: "128K standard, long-context above",
+        reasoning: {
+          effort: ["low", "medium", "high"],
+          default: "low"
+        },
+        structuredOutput: true,
+        functionCalling: true,
+        tools: ["web_search", "x_search"]
+      },
+      {
+        id: "grok-4.20-0309-non-reasoning",
+        type: "fast",
+        use: "Quick tasks, no thinking overhead",
+        input: ["text", "image"],
+        context: "128K standard, long-context above",
+        reasoning: false,
+        structuredOutput: true,
+        functionCalling: true,
+        tools: ["web_search", "x_search"]
+      },
+      {
+        id: "grok-4.20-multi-agent-0309",
+        type: "multi-agent",
+        use: "Deep research (4 or 16 parallel agents)",
+        input: ["text", "image"],
+        context: "128K standard",
+        reasoning: {
+          effort: ["low", "medium", "high", "xhigh"],
+          default: "medium",
+          note: "Controls agent count, not reasoning depth. low/medium=4 agents, high/xhigh=16 agents."
+        },
+        structuredOutput: true,
+        functionCalling: true,
+        tools: ["web_search", "x_search"],
+        multiAgent: {
+          agentCount: [4, 16],
+          effortToAgents: { low: 4, medium: 4, high: 16, xhigh: 16 },
+          perAgentConfig: false
+        }
+      },
+      {
+        id: "grok-build-0.1",
+        type: "code",
+        use: "Code generation, agentic coding",
+        input: ["text", "image"],
+        context: "256K tokens",
+        reasoning: {
+          effort: ["low", "medium", "high"],
+          default: "low"
+        },
+        structuredOutput: false,
+        functionCalling: false,
+        tools: []
+      },
+      {
+        id: "grok-imagine-image",
+        type: "image",
+        use: "Fast image gen",
+        input: ["text"],
+        reasoning: false,
+        structuredOutput: false,
+        functionCalling: false,
+        tools: []
+      },
+      {
+        id: "grok-imagine-image-quality",
+        type: "image-hq",
+        use: "High-quality image gen",
+        input: ["text"],
+        reasoning: false,
+        structuredOutput: false,
+        functionCalling: false,
+        tools: []
+      },
+      {
+        id: "grok-imagine-video",
+        type: "video",
+        use: "Video gen (async)",
+        input: ["text"],
+        reasoning: false,
+        structuredOutput: false,
+        functionCalling: false,
+        tools: []
+      }
+    ],
+    tools: [
+      { type: "web_search", description: "Web search with citations" },
+      { type: "x_search", description: "X (Twitter) search with citations" },
+      {
+        type: "code_interpreter",
+        description: "Server-side code execution"
+      },
+      {
+        type: "file_search",
+        description: "Vector store search (needs vector_store_ids)"
+      },
+      { type: "function", description: "Custom function calling" }
+    ],
+    guidance: {
+      auth: "Run progrok login once. No API key needed \u2014 OAuth only.",
+      proxy: "progrok proxy forwards all /v1/* paths. Set OPENAI_BASE_URL=http://127.0.0.1:18645/v1 and OPENAI_API_KEY=anything.",
+      streaming: "Use stream:true for responses/chat. Proxy passes through SSE events verbatim.",
+      video: "Video gen is async: POST /v1/videos/generations \u2192 poll GET /v1/videos/{id} until done."
+    }
+  };
+}
+function printText(cap) {
+  console.log(`progrok capabilities (${cap.source})`);
+  console.log(`version: ${cap.version}`);
+  console.log(`upstream: ${cap.upstream}`);
+  console.log("");
+  console.log(`proxy: ${cap.proxy.baseUrl}`);
+  console.log(`chat:  ${cap.chat.url}`);
+  console.log(`model: ${cap.defaults.model}`);
+  console.log("");
+  console.log("endpoints:");
+  for (const ep of cap.endpoints) {
+    const label = `  ${ep.method.padEnd(5)} ${ep.path.padEnd(28)}`;
+    console.log(`${label} ${ep.description}`);
+  }
+  console.log("");
+  console.log("models:");
+  for (const m of cap.models) {
+    console.log(`  ${m.id.padEnd(38)} ${m.use}`);
+  }
+  console.log("");
+  console.log("tools:");
+  for (const t of cap.tools) {
+    console.log(`  ${t.type.padEnd(20)} ${t.description}`);
+  }
+  console.log("");
+  console.log(`commands: ${cap.commands.join(", ")}`);
+}
+function capabilitiesCommand() {
+  return new Command8("capabilities").description("Print agent-friendly capability metadata.").option("--json", "Output as JSON").action((opts) => {
+    const cap = buildCapabilities();
+    if (opts.json) {
+      console.log(JSON.stringify(cap, null, 2));
+    } else {
+      printText(cap);
+    }
+  });
+}
+
+// src/utils/config.ts
+import {
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2
+} from "fs";
+function ensureConfigDir2() {
+  if (!existsSync3(CONFIG_DIR)) {
+    mkdirSync2(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync4(CONFIG_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  ensureConfigDir2();
+  writeFileSync2(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+}
+
+// src/utils/star-prompt.ts
+async function showStarPrompt() {
+  const config = readConfig();
+  if (config.onboarding?.starPrompted) return;
+  log.dim("\u2500".repeat(50));
+  log.info("\u2B50 If progrok is useful, star the repo!");
+  log.dim(`   ${GITHUB_URL}`);
+  log.dim("\u2500".repeat(50) + "\n");
+  writeConfig({
+    ...config,
+    onboarding: { ...config.onboarding, starPrompted: true }
+  });
+}
+
+// src/index.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname4, join as join5 } from "path";
+var __dirname2 = dirname4(fileURLToPath4(import.meta.url));
+function getVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync5(join5(__dirname2, "..", "package.json"), "utf8")
+    );
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var program = new Command9();
+program.name("progrok").description(
+  `Use Grok models for free via OAuth proxy. No API key needed.
+
+  SuperGrok OAuth \u2192 local proxy \u2192 OpenAI-compatible API for any client.
+  All xAI endpoints forwarded: responses, chat, images, video, tts, stt.
+
+  Quick start:
+    $ progrok login          # OAuth via browser (or --device-code for SSH)
+    $ progrok proxy          # Start proxy on 127.0.0.1:18645
+    $ curl localhost:18645/v1/chat/completions -d '{"model":"grok-4.3",...}'
+
+  Proxy forwards ALL /v1/* paths to api.x.ai \u2014 no whitelist.
+  Supported xAI surfaces:
+    /v1/responses            Responses API (streaming, tools, reasoning)
+    /v1/chat/completions     OpenAI-compatible chat
+    /v1/models               Model list
+    /v1/language-models      Detailed models (pricing, aliases, modalities)
+    /v1/images/generations   Image generation (grok-imagine-image)
+    /v1/videos/generations   Video generation (async, poll /v1/videos/{id})
+    /v1/tts                  Text-to-speech
+    /v1/stt                  Speech-to-text
+    /v1/batch/completions    Batch processing
+    /v1/embeddings           Embeddings`
+).version(getVersion());
+program.addCommand(loginCommand());
+program.addCommand(logoutCommand());
+program.addCommand(proxyCommand());
+program.addCommand(chatCommand());
+program.addCommand(modelsCommand());
+program.addCommand(statusCommand());
+program.addCommand(skillCommand());
+program.addCommand(capabilitiesCommand());
+var REAL_COMMANDS = /* @__PURE__ */ new Set(["login", "logout", "proxy", "chat", "models", "status", "skill", "capabilities"]);
+var subcommand = process.argv[2];
+if (subcommand && REAL_COMMANDS.has(subcommand)) {
+  await showStarPrompt();
+}
+program.parse();
+//# sourceMappingURL=index.js.map