@agentdocumentformat/cli 0.7.8 → 0.8.0

package/dist/chunks/chunk-MZRXFWPQ.mjs

@@ -0,0 +1,278 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+
+// src/main/providers/claude-subscription/auth-manager.ts
+import { execFile as execFile2, spawn } from "node:child_process";
+
+// src/main/providers/claude-subscription/claude-code.ts
+import { execFile } from "node:child_process";
+import { access, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { delimiter, dirname, join } from "node:path";
+var MIN_CLAUDE_CODE_VERSION = "2.1.248", CLAUDE_CODE_INSTALL_URL = "https://code.claude.com/docs/en/setup", isWindows = process.platform === "win32", exeName = isWindows ? "claude.exe" : "claude";
+async function exists(path) {
+  try {
+    return await access(path), !0;
+  } catch {
+    return !1;
+  }
+}
+async function candidatePaths() {
+  let out = [], override = process.env.ADF_CLAUDE_CODE_PATH;
+  override && out.push(override);
+  let home = homedir();
+  out.push(join(home, ".local", "bin", exeName)), out.push(join(home, ".claude", "local", exeName)), isWindows || out.push("/opt/homebrew/bin/claude", "/usr/local/bin/claude");
+  for (let dir of (process.env.PATH ?? "").split(delimiter))
+    if (dir)
+      if (isWindows) {
+        out.push(join(dir, "claude.exe"));
+        let target = await resolveNpmShim(join(dir, "claude.cmd"));
+        target && out.push(target);
+      } else
+        out.push(join(dir, "claude"));
+  let appData = process.env.APPDATA;
+  isWindows && appData && out.push(join(appData, "npm", "node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"));
+  let unique = [...new Set(out)], present = await Promise.all(unique.map(exists));
+  return unique.filter((_, i) => present[i]);
+}
+async function resolveNpmShim(shimPath) {
+  try {
+    let match = (await readFile(shimPath, "utf8")).match(/"%dp0%\\([^"]+?\.exe)"/i);
+    if (!match) return null;
+    let target = join(dirname(shimPath), match[1]);
+    return await exists(target) ? target : null;
+  } catch {
+    return null;
+  }
+}
+function runVersion(path) {
+  return new Promise((resolve) => {
+    execFile(path, ["--version"], { timeout: 15e3, windowsHide: !0 }, (err, stdout) => {
+      if (err) return resolve(null);
+      let match = String(stdout).match(/(\d+\.\d+\.\d+)/);
+      resolve(match ? match[1] : null);
+    });
+  });
+}
+function compareVersions(a, b) {
+  let pa = a.split(".").map(Number), pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    let d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+var cached = null, inflight = null, CACHE_MS = 6e4;
+async function runProbe() {
+  let paths = await candidatePaths(), versions = await Promise.all(paths.map(runVersion)), install = null;
+  for (let i = 0; i < paths.length; i++) {
+    let version = versions[i];
+    version && (!install || compareVersions(version, install.version) > 0) && (install = { path: paths[i], version });
+  }
+  return install ? { found: !0, install, supported: compareVersions(install.version, MIN_CLAUDE_CODE_VERSION) >= 0 } : { found: !1 };
+}
+function probeClaudeCode(force = !1) {
+  if (!force && cached && Date.now() - cached.at < CACHE_MS) return Promise.resolve(cached.probe);
+  if (!force && inflight) return inflight;
+  let run = runProbe().then((probe) => (cached = { probe, at: Date.now() }, probe)).finally(() => {
+    inflight === run && (inflight = null);
+  });
+  return inflight = run, run;
+}
+async function requireClaudeCode() {
+  let probe = await probeClaudeCode();
+  if (!probe.found)
+    throw new Error(`Claude Code is not installed. Install it (${CLAUDE_CODE_INSTALL_URL}), then sign in with Claude.`);
+  if (!probe.supported)
+    throw new Error(
+      `Claude Code ${probe.install.version} is installed; ADF needs ${MIN_CLAUDE_CODE_VERSION} or newer. Run \`claude update\`.`
+    );
+  return probe.install;
+}
+var CLAUDE_ENV_DENY = /^(CLAUDE_CODE_|ANTHROPIC_|CLAUDECODE$)/i;
+function claudeCodeEnv(extra) {
+  let env = {};
+  for (let [k, v] of Object.entries(process.env))
+    v === void 0 || CLAUDE_ENV_DENY.test(k) || k.toUpperCase() === "ELECTRON_RUN_AS_NODE" || (env[k] = v);
+  return { ...env, ...extra };
+}
+
+// src/main/providers/claude-subscription/auth-manager.ts
+var LOGIN_TIMEOUT_MS = 10 * 6e4, STATUS_CACHE_MS = 3e4;
+function stripAnsi(s) {
+  return s.replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "").replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+function extractLoginUrl(output) {
+  return output.match(/https:\/\/[^\s\u0007\u001b"']+\/oauth\/authorize\?[^\s\u0007\u001b"']+/)?.[0];
+}
+function runCli(path, args, timeoutMs = 2e4) {
+  return new Promise((resolve) => {
+    execFile2(path, args, { timeout: timeoutMs, windowsHide: !0, env: claudeCodeEnv() }, (err, stdout, stderr) => {
+      let code = err ? typeof err.code == "number" ? err.code : 1 : 0;
+      resolve({ stdout: String(stdout), stderr: String(stderr), code });
+    });
+  });
+}
+var ClaudeAuthManager = class {
+  active = null;
+  starting = null;
+  startGen = 0;
+  lastFlowError;
+  statusCache = null;
+  statusInflight = null;
+  statusGen = 0;
+  /**
+   * Claude Code's sign-in state. `claude auth status` is a process spawn and
+   * this is polled by every status view and agent preflight, so results are
+   * cached briefly and concurrent callers share one read. While a sign-in is
+   * pending nothing is cached. `fresh` re-detects Claude Code and re-reads.
+   */
+  getAuthStatus(opts) {
+    let fresh = opts?.fresh === !0;
+    if (!fresh && !this.active && this.statusCache && Date.now() - this.statusCache.at < STATUS_CACHE_MS)
+      return Promise.resolve(this.statusCache.status);
+    if (!fresh && this.statusInflight) return this.statusInflight;
+    let gen = this.statusGen, run = this.readAuthStatus(fresh).then((status) => (gen === this.statusGen && !this.active && !("flowPending" in status && status.flowPending) && (this.statusCache = { status, at: Date.now() }), status)).finally(() => {
+      this.statusInflight === run && (this.statusInflight = null);
+    });
+    return this.statusInflight = run, run;
+  }
+  invalidateStatus() {
+    this.statusGen++, this.statusCache = null, this.statusInflight = null;
+  }
+  async readAuthStatus(fresh) {
+    let probe = await probeClaudeCode(fresh);
+    if (!probe.found)
+      return { authenticated: !1, installed: !1, installUrl: CLAUDE_CODE_INSTALL_URL };
+    let { version: installed, path } = probe.install, version = { version: installed, minVersion: MIN_CLAUDE_CODE_VERSION };
+    if (!probe.supported)
+      return {
+        authenticated: !1,
+        installed: !0,
+        ...version,
+        updateRequired: !0,
+        flowError: `Claude Code ${installed} is installed; ADF needs ${MIN_CLAUDE_CODE_VERSION} or newer. Run \`claude update\`.`
+      };
+    let { stdout } = await runCli(path, ["auth", "status", "--json"]), pending = this.active ? { flowPending: !0, ...this.active.url ? { flowUrl: this.active.url } : {} } : {}, cli = {};
+    try {
+      cli = JSON.parse(stdout);
+    } catch {
+    }
+    return cli.loggedIn ? cli.authMethod !== "claude.ai" ? {
+      authenticated: !1,
+      installed: !0,
+      ...version,
+      ...pending,
+      flowError: "Claude Code is signed in with an Anthropic Console account, not a Claude plan. Sign in with Claude to use your subscription."
+    } : {
+      authenticated: !0,
+      installed: !0,
+      ...version,
+      ...pending,
+      // A failed re-sign-in (e.g. switching accounts) leaves the old account
+      // signed in; report the failure so callers don't mistake it for success.
+      ...this.lastFlowError ? { flowError: this.lastFlowError } : {},
+      ...cli.email ? { email: cli.email } : {},
+      ...cli.subscriptionType ? { plan: cli.subscriptionType } : {}
+    } : { authenticated: !1, installed: !0, ...version, ...pending, ...this.lastFlowError ? { flowError: this.lastFlowError } : {} };
+  }
+  async isAuthenticated() {
+    return (await this.getAuthStatus()).authenticated;
+  }
+  /**
+   * Start `claude auth login`. Claude Code opens the browser itself; the
+   * returned URL is the fallback for when it cannot (remote daemon, headless
+   * box). If the browser page shows a code instead of finishing on its own,
+   * the user pastes it and it is handed to Claude Code via `submitCode`.
+   */
+  startAuthFlowDetached() {
+    if (this.active) return this.active.ready;
+    if (!this.starting) {
+      let starting = this.spawnFlow().finally(() => {
+        this.starting === starting && (this.starting = null);
+      });
+      this.starting = starting;
+    }
+    return this.starting;
+  }
+  async spawnFlow() {
+    let gen = this.startGen, { path } = await requireClaudeCode();
+    if (gen !== this.startGen) throw new Error("Claude sign-in was cancelled.");
+    this.lastFlowError = void 0;
+    let child = spawn(path, ["auth", "login", "--claudeai"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: !0,
+      env: claudeCodeEnv()
+    }), resolveUrl, urlReady = new Promise((r) => {
+      resolveUrl = r;
+    }), state = { child, output: "", cancelled: !1, ready: void 0 }, onData = (d) => {
+      state.output += d.toString();
+      let url = extractLoginUrl(state.output);
+      url && (state.url ??= url, resolveUrl(url));
+    };
+    child.stdout.on("data", onData), child.stderr.on("data", onData);
+    let completion = new Promise((resolve, reject) => {
+      let timer = setTimeout(() => {
+        child.kill(), reject(new Error("Claude sign-in timed out. Try again."));
+      }, LOGIN_TIMEOUT_MS);
+      child.on("error", (err) => {
+        clearTimeout(timer), resolveUrl(void 0), reject(err);
+      }), child.on("exit", (code) => {
+        if (clearTimeout(timer), resolveUrl(void 0), code === 0) return resolve();
+        if (state.cancelled) return reject(new Error("Claude sign-in was cancelled."));
+        let tail = stripAnsi(state.output).trim().split(`
+`).filter(Boolean).pop();
+        reject(new Error(tail && !/paste code/i.test(tail) ? `Claude sign-in failed: ${tail}` : "Claude sign-in was cancelled."));
+      });
+    }).then(
+      () => {
+        this.active === state && (this.active = null), this.invalidateStatus();
+      },
+      (err) => {
+        throw this.active === state && (this.active = null, state.cancelled || (this.lastFlowError = err instanceof Error ? err.message : String(err))), this.invalidateStatus(), err;
+      }
+    );
+    return completion.catch(() => {
+    }), state.ready = Promise.race([urlReady, new Promise((r) => setTimeout(() => r(void 0), 15e3))]).then((url) => ({ url, completion })), this.active = state, this.invalidateStatus(), state.ready;
+  }
+  async startAuthFlow() {
+    await (await this.startAuthFlowDetached()).completion;
+  }
+  /** Hand the code shown on Claude's sign-in page to the waiting Claude Code. */
+  submitCode(code) {
+    let trimmed = code.trim();
+    if (!this.active) throw new Error("No Claude sign-in is in progress.");
+    if (!trimmed) throw new Error("Paste the code shown on the Claude sign-in page.");
+    this.active.child.stdin.write(`${trimmed}
+`);
+  }
+  cancelAuthFlow() {
+    this.startGen++, this.starting = null, this.active && (this.active.cancelled = !0, this.active.child.kill(), this.active = null), this.invalidateStatus();
+  }
+  /** Signs Claude Code out on this machine (shared with the user's own Claude Code use). */
+  async logout() {
+    this.cancelAuthFlow(), this.lastFlowError = void 0;
+    try {
+      let { path } = await requireClaudeCode(), { code, stderr } = await runCli(path, ["auth", "logout"]);
+      if (code !== 0) throw new Error(`Claude sign-out failed: ${stripAnsi(stderr).trim() || `exit ${code}`}`);
+    } finally {
+      this.invalidateStatus();
+    }
+  }
+}, instance = null;
+function getClaudeAuthManager() {
+  return instance || (instance = new ClaudeAuthManager()), instance;
+}
+
+export {
+  MIN_CLAUDE_CODE_VERSION,
+  requireClaudeCode,
+  claudeCodeEnv,
+  stripAnsi,
+  extractLoginUrl,
+  getClaudeAuthManager
+};

package/dist/chunks/{chunk-PRMGZZM5.mjs → chunk-NZLEPJ5M.mjs}

@@ -71,6 +71,7 @@ var import_react = __toESM(require_react(), 1), ADF_COLORS = {
   mark: "\u258C",
   hbar: "\u2500",
   ellipsis: "\u2026",
+  approx: "\u2248",
   collapsed: "\u25B8",
   expanded: "\u25BE",
   spinner: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
@@ -90,6 +91,7 @@ var import_react = __toESM(require_react(), 1), ADF_COLORS = {
   mark: ">",
   hbar: "-",
   ellipsis: "...",
+  approx: "~",
   collapsed: "+",
   expanded: "-",
   spinner: ["|", "/", "-", "\\"]

package/dist/chunks/{chunk-CD3ATSXE.mjs → chunk-NZO5O4VN.mjs}

@@ -141,7 +141,6 @@ var AGENT_DEFAULTS = {
     provider: "",
     model_id: "",
     temperature: 0.7,
-    max_tokens: 4096,
     vision: !1
   },
   context: {
@@ -292,6 +291,7 @@ export {
   META_PROTECTION_LEVELS,
   FILE_PROTECTION_LEVELS,
   DEFAULT_TOOLS,
+  AUDIT_DEFAULTS,
   AGENT_DEFAULTS,
   getDefaultDocumentContent,
   DEFAULT_MIND_CONTENT,

package/dist/chunks/{chunk-I3UYSITV.mjs → chunk-O7XKQ6CH.mjs}

@@ -32,7 +32,7 @@ function enabledAdapters(config) {
   return Object.entries(config?.adapters ?? {}).filter(([, c]) => c?.enabled !== !1).map(([type]) => type);
 }
 function welcomeFacts(state, extras = EMPTY_EXTRAS) {
-  let auth = state.auth, signedIn = !!auth?.chatgpt?.authenticated || !!auth?.grok?.authenticated, keyed = (auth?.providers ?? []).some((p) => p.hasApiKey === !0), ids = state.agentOrder.filter((id) => state.agents[id]), messaging = ids.some((id) => enabledAdapters(state.agents[id]?.config).length > 0 || (extras.adapters[id]?.length ?? 0) > 0), tasks = ids.some((id) => {
+  let auth = state.auth, signedIn = ["chatgpt", "grok", "claude"].some((p) => !!auth?.[p]?.authenticated), keyed = (auth?.providers ?? []).some((p) => p.hasApiKey === !0), ids = state.agentOrder.filter((id) => state.agents[id]), messaging = ids.some((id) => enabledAdapters(state.agents[id]?.config).length > 0 || (extras.adapters[id]?.length ?? 0) > 0), tasks = ids.some((id) => {
     let loops = state.agents[id]?.loops ?? [];
     return loops.some((l) => l.info.name !== "main") || loops.some((l) => l.info.name === "main" && (l.info.entryCount ?? 0) > 0) ? !0 : (extras.timers[id] ?? 0) > 0;
   });

package/dist/chunks/chunk-P3RG5LQA.mjs

@@ -0,0 +1,244 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  createSubscriptionTokenStore
+} from "./chunk-C2S64Y6F.mjs";
+import {
+  __require
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/providers/grok-subscription/token-store.ts
+var store = createSubscriptionTokenStore("grok-subscription");
+function readTokens() {
+  return store.readTokens();
+}
+function writeTokens(tokens) {
+  store.writeTokens(tokens);
+}
+function clearTokens() {
+  store.clearTokens();
+}
+function noteSignIn(accountId) {
+  store.signedIn(accountId);
+}
+
+// src/main/providers/grok-subscription/auth-manager.ts
+var CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828", DEVICE_AUTHORIZATION_URL = "https://auth.x.ai/oauth2/device/code", TOKEN_URL = "https://auth.x.ai/oauth2/token", DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code", SCOPE = "openid profile email offline_access grok-cli:access api:access", REFRESH_BUFFER_MS = 300 * 1e3, POLL_DEFAULT_INTERVAL_MS = 5e3, POLL_MIN_INTERVAL_MS = 1e3, POLL_SLOW_DOWN_INCREMENT_MS = 5e3, POLL_DEFAULT_EXPIRES_MS = 900 * 1e3;
+function decodeJwtPayload(token) {
+  let parts = token.split(".");
+  if (parts.length < 2) return {};
+  try {
+    let payload = Buffer.from(parts[1], "base64url").toString("utf-8");
+    return JSON.parse(payload);
+  } catch {
+    return {};
+  }
+}
+async function openExternal(url) {
+  try {
+    let electron = __require("electron");
+    if (electron.shell?.openExternal) {
+      await electron.shell.openExternal(url);
+      return;
+    }
+  } catch {
+  }
+  console.log(`[Grok Auth] Open this URL to sign in: ${url}`);
+}
+function positiveSecondsToMs(value, defaultMs) {
+  let seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : defaultMs;
+}
+async function pollDeviceCodeToken(device, deps = {}) {
+  let fetchFn = deps.fetchFn ?? globalThis.fetch, sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))), now = deps.now ?? (() => Date.now()), deadline = now() + positiveSecondsToMs(device.expires_in, POLL_DEFAULT_EXPIRES_MS), intervalMs = Math.max(
+    positiveSecondsToMs(device.interval, POLL_DEFAULT_INTERVAL_MS),
+    POLL_MIN_INTERVAL_MS
+  );
+  for (; now() < deadline; ) {
+    let response = await fetchFn(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: DEVICE_CODE_GRANT_TYPE,
+        client_id: CLIENT_ID,
+        device_code: device.device_code
+      }).toString()
+    });
+    if (response.ok) return await response.json();
+    let body = await response.json().catch(() => ({}));
+    if (body.error === "authorization_pending") {
+      await sleep(Math.min(intervalMs, Math.max(0, deadline - now())));
+      continue;
+    }
+    if (body.error === "slow_down") {
+      intervalMs += POLL_SLOW_DOWN_INCREMENT_MS, await sleep(Math.min(intervalMs, Math.max(0, deadline - now())));
+      continue;
+    }
+    if (body.error === "access_denied" || body.error === "authorization_denied")
+      throw new Error("Sign-in was denied");
+    if (body.error === "expired_token")
+      throw new Error("Device code expired \u2014 please sign in again");
+    let detail = body.error_description ?? body.error ?? "";
+    throw new Error(`Grok token exchange failed (${response.status})${detail ? `: ${detail}` : ""}`);
+  }
+  throw new Error("Sign-in timed out \u2014 please try again");
+}
+var GrokAuthManager = class {
+  refreshPromise = null;
+  cachedTokens = null;
+  email;
+  activeAuthFlow = null;
+  lastFlowError;
+  constructor() {
+    this.syncFromDisk();
+  }
+  /**
+   * Re-read the token file, picking up writes from the other process. Studio
+   * and the daemon share one file. See the ChatGPT manager for the full
+   * rationale on why this never trusts a cache.
+   */
+  syncFromDisk() {
+    let tokens = readTokens();
+    return tokens?.access_token !== this.cachedTokens?.access_token && (this.email = void 0), this.cachedTokens = tokens, tokens;
+  }
+  persist(tokens) {
+    writeTokens(tokens), this.cachedTokens = tokens;
+  }
+  async startAuthFlow() {
+    await (await this.startAuthFlowDetached()).completion;
+  }
+  async startAuthFlowDetached() {
+    if (this.activeAuthFlow) return this.activeAuthFlow;
+    this.lastFlowError = void 0;
+    let response = await fetch(DEVICE_AUTHORIZATION_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        client_id: CLIENT_ID,
+        scope: SCOPE,
+        referrer: "adf-studio"
+      }).toString()
+    });
+    if (!response.ok) {
+      let body = await response.text().catch(() => "");
+      throw new Error(`Grok device code request failed (${response.status})${body ? `: ${body}` : ""}`);
+    }
+    let device = await response.json();
+    if (!device.device_code || !device.user_code || !device.verification_uri)
+      throw new Error("Grok device code response is missing device_code / user_code / verification_uri");
+    let openUrl = device.verification_uri_complete ?? device.verification_uri;
+    await openExternal(openUrl);
+    let completion = (async () => {
+      try {
+        let tokenData = await pollDeviceCodeToken(device), accountId = "";
+        if (tokenData.id_token) {
+          let claims = decodeJwtPayload(tokenData.id_token);
+          this.email = claims.email, accountId = claims.sub ?? "";
+        }
+        if (accountId || (accountId = decodeJwtPayload(tokenData.access_token).sub ?? ""), !tokenData.refresh_token)
+          throw new Error("Grok sign-in did not return a refresh token \u2014 is offline_access granted?");
+        this.persist({
+          access_token: tokenData.access_token,
+          refresh_token: tokenData.refresh_token,
+          expires_at: Date.now() + positiveSecondsToMs(tokenData.expires_in, 3600 * 1e3),
+          account_id: accountId
+        }), noteSignIn(accountId);
+      } catch (err) {
+        throw this.lastFlowError = err instanceof Error ? err.message : String(err), err;
+      } finally {
+        this.activeAuthFlow = null;
+      }
+    })();
+    return completion.catch(() => {
+    }), this.activeAuthFlow = {
+      userCode: device.user_code,
+      verificationUri: device.verification_uri,
+      verificationUriComplete: device.verification_uri_complete,
+      expiresIn: positiveSecondsToMs(device.expires_in, POLL_DEFAULT_EXPIRES_MS) / 1e3,
+      completion
+    }, this.activeAuthFlow;
+  }
+  async getValidAccessToken() {
+    let tokens = this.syncFromDisk();
+    if (!tokens)
+      throw new Error("Not authenticated \u2014 sign in first");
+    return Date.now() + REFRESH_BUFFER_MS < tokens.expires_at ? tokens.access_token : this.refreshPromise ? this.refreshPromise : (this.refreshPromise = this.refreshIfStillNeeded(tokens).finally(() => {
+      this.refreshPromise = null;
+    }), this.refreshPromise);
+  }
+  getAccountId() {
+    return this.syncFromDisk()?.account_id;
+  }
+  /**
+   * Re-check the file after winning the in-process refresh lock — Studio may
+   * have refreshed while this call queued, and xAI may rotate the refresh
+   * token, which would leave our copy dead.
+   */
+  async refreshIfStillNeeded(tokens) {
+    let fresh = this.syncFromDisk();
+    return fresh && Date.now() + REFRESH_BUFFER_MS < fresh.expires_at ? fresh.access_token : this.refreshTokens(fresh ?? tokens);
+  }
+  async refreshTokens(tokens) {
+    let data, rejected = !1;
+    try {
+      let response = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          client_id: CLIENT_ID,
+          refresh_token: tokens.refresh_token
+        }).toString()
+      });
+      if (!response.ok)
+        throw rejected = response.status === 400 || response.status === 401, new Error(`Token refresh failed (${response.status})`);
+      data = await response.json();
+    } catch (err) {
+      let fresh = this.syncFromDisk();
+      if (fresh && fresh.refresh_token !== tokens.refresh_token && Date.now() + REFRESH_BUFFER_MS < fresh.expires_at)
+        return fresh.access_token;
+      throw rejected ? (clearTokens(), this.cachedTokens = null, this.email = void 0, new Error("Session expired \u2014 please sign in again")) : new Error(`Could not refresh the session (${err instanceof Error ? err.message : String(err)}) \u2014 still signed in, try again`);
+    }
+    if (data.id_token) {
+      let claims = decodeJwtPayload(data.id_token);
+      this.email = claims.email;
+    }
+    return this.persist({
+      access_token: data.access_token,
+      refresh_token: data.refresh_token || tokens.refresh_token,
+      expires_at: Date.now() + positiveSecondsToMs(data.expires_in, 3600 * 1e3),
+      account_id: tokens.account_id
+    }), data.access_token;
+  }
+  getAuthStatus() {
+    let tokens = this.syncFromDisk();
+    return tokens ? {
+      authenticated: !0,
+      email: this.email,
+      expiresAt: tokens.expires_at
+    } : {
+      authenticated: !1,
+      flowPending: this.activeAuthFlow !== null,
+      flowError: this.lastFlowError
+    };
+  }
+  isAuthenticated() {
+    return this.syncFromDisk() !== null;
+  }
+  logout() {
+    clearTokens(), this.cachedTokens = null, this.email = void 0, this.refreshPromise = null, this.lastFlowError = void 0;
+  }
+}, instance = null;
+function getGrokAuthManager() {
+  return instance || (instance = new GrokAuthManager()), instance;
+}
+
+export {
+  readTokens,
+  pollDeviceCodeToken,
+  getGrokAuthManager
+};

package/dist/chunks/chunk-PAK5JCO2.mjs

@@ -0,0 +1,48 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  __require
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/utils/user-data-path.ts
+import { homedir } from "node:os";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+var PRODUCT_NAME = "ADF Studio", PACKAGE_NAME = "adf-studio", SETTINGS_FILE = "adf-settings.json";
+function getUserDataPath() {
+  if (process.env.ADF_USER_DATA_DIR) return process.env.ADF_USER_DATA_DIR;
+  let electronApp = getElectronApp();
+  return electronApp?.getPath ? electronApp.getPath("userData") : defaultUserDataPath();
+}
+function getTempPath() {
+  if (process.env.ADF_TEMP_DIR) return process.env.ADF_TEMP_DIR;
+  let electronApp = getElectronApp();
+  return electronApp?.getPath ? electronApp.getPath("temp") : tmpdir();
+}
+function platformConfigBase() {
+  return process.platform === "darwin" ? join(homedir(), "Library", "Application Support") : process.platform === "win32" ? process.env.APPDATA ?? join(homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+}
+var loggedDefaultPath = null;
+function defaultUserDataPath(options = {}) {
+  if (process.env.ADF_USER_DATA_DIR) return process.env.ADF_USER_DATA_DIR;
+  let base = platformConfigBase(), productDir = join(base, PRODUCT_NAME), packageDir = join(base, PACKAGE_NAME), chosen = existsSync(join(productDir, SETTINGS_FILE)) ? productDir : packageDir;
+  return !options.quiet && loggedDefaultPath !== chosen && (loggedDefaultPath = chosen, console.log(`[UserDataPath] Using user data directory: ${chosen}`)), chosen;
+}
+function getElectronApp() {
+  try {
+    return __require("electron").app ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  getUserDataPath,
+  getTempPath,
+  defaultUserDataPath
+};

package/dist/chunks/chunk-PC63YFB7.mjs

@@ -0,0 +1,34 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+
+// src/main/cli/prompt.ts
+import { createInterface } from "node:readline";
+function stdinPrompt(input = process.stdin, output = process.stderr) {
+  let rl = null, ended = !1, lines = [], waiting = [], open = () => {
+    rl || ended || (rl = createInterface({ input, terminal: !1 }), rl.on("line", (line) => {
+      let next = waiting.shift();
+      next ? next(line) : lines.push(line);
+    }), rl.on("close", () => {
+      ended = !0;
+      for (let w of waiting.splice(0)) w(null);
+    }));
+  };
+  return {
+    ask(question) {
+      output.write(question), open();
+      let buffered = lines.shift();
+      return buffered !== void 0 ? Promise.resolve(buffered) : ended ? Promise.resolve(null) : new Promise((resolve) => waiting.push(resolve));
+    },
+    close() {
+      rl?.close(), rl = null;
+    }
+  };
+}
+
+export {
+  stdinPrompt
+};