0sec-cli 0.24.1 → 0.26.0

package/chunks/chunk-ZPVSDB63.js

@@ -0,0 +1,3839 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+import {
+  getRuntimeAvailability
+} from "./chunk-MNK373HF.js";
+import {
+  ServicePluginServices,
+  consoleExecutionProfile
+} from "./chunk-KCABBZHN.js";
+import {
+  accountEnvPatch,
+  addAccount,
+  connectionConfigEnvPatch,
+  credentialEnvPatch,
+  defaultWriteLayer,
+  getSettingSources,
+  getSettings,
+  listAccounts,
+  loadAccountStore,
+  loadConnectionConfigs,
+  loadCredentials,
+  logoutProvider,
+  maybeLoadCodexAuth,
+  removeAccount,
+  resetSettings,
+  saveAccountStore,
+  saveConnectionConfig,
+  setActiveAccount,
+  updateSetting,
+  validateConnectionConfig
+} from "./chunk-OILVEROI.js";
+import {
+  DEFAULT_SETTINGS,
+  PROVIDERS,
+  SETTING_DEFS,
+  allThemeNames,
+  appendFeedback,
+  buildSubmitPreview,
+  getThemeEntry,
+  installedThemeEntries,
+  isKnownTheme,
+  isOperatorSetting,
+  isSafeThemeId,
+  providerStates,
+  reloadInstalledThemes,
+  submitFeedback,
+  syncThemeChoices,
+  validateTheme,
+  writeInstalledTheme
+} from "./chunk-V2KJQVYE.js";
+import {
+  DEFAULT_REGISTRY_URL,
+  createConsoleRuntime,
+  listProjectReviewChecks,
+  updateProjectReviewChecks
+} from "./chunk-3MWQNNJU.js";
+import {
+  getRuntimeMetadata
+} from "./chunk-VWE36MUN.js";
+import {
+  TOOL_DEFINITIONS,
+  getToolsForRole
+} from "./chunk-SIR7XW2S.js";
+import {
+  CodexCatalogRefreshError
+} from "./chunk-PAMJEXE2.js";
+import {
+  LlmApiRuntime
+} from "./chunk-HS2NQ7K6.js";
+import {
+  aggregateCapabilities,
+  disable,
+  isSafePluginId,
+  listInstalledPluginIds,
+  pluginsRootDir,
+  readEnablement,
+  readInstalledPlugin,
+  writeEnablement
+} from "./chunk-RZZ6VPRY.js";
+import {
+  MODEL_PRICING,
+  VERSION,
+  getRates,
+  homeStateDir,
+  modelProvider,
+  registerModelPricing
+} from "./chunk-GYEYTNHK.js";
+
+// packages/cli/src/web/operator-services.ts
+import { execFileSync } from "node:child_process";
+import { realpathSync, statSync } from "node:fs";
+import { basename, resolve as resolve3 } from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// packages/cli/src/tui/chatgpt-plan-store.ts
+import { randomUUID } from "node:crypto";
+import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// packages/cli/src/tui/chatgpt-plan-auth.ts
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/buffer_utils.js
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var strictDecoder = new TextDecoder("utf-8", { fatal: true });
+var MAX_INT32 = 2 ** 32;
+function concat(...buffers) {
+  const size = buffers.reduce((acc, { length }) => acc + length, 0), buf = new Uint8Array(size);
+  let i = 0;
+  for (const buffer of buffers)
+    buf.set(buffer, i), i += buffer.length;
+  return buf;
+}
+var NON_ASCII = /[^\x00-\x7f]/;
+function encode(string) {
+  if (typeof string == "string" && string.length >= 128) {
+    if (NON_ASCII.test(string))
+      throw new TypeError("non-ASCII string encountered in encode()");
+    return encoder.encode(string);
+  }
+  const bytes = new Uint8Array(string.length);
+  for (let i = 0; i < string.length; i++) {
+    const code = string.charCodeAt(i);
+    if (code > 127)
+      throw new TypeError("non-ASCII string encountered in encode()");
+    bytes[i] = code;
+  }
+  return bytes;
+}
+function decodeBase64(encoded, url = false) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(encoded, { alphabet: url ? "base64url" : "base64" });
+  if (url) {
+    if (encoded.includes("+") || encoded.includes("/"))
+      throw new TypeError("Invalid base64url");
+    encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  }
+  const binary = atob(encoded), bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/util/errors.js
+var JOSEError = class extends Error {
+  static code = "ERR_JOSE_GENERIC";
+  code = "ERR_JOSE_GENERIC";
+  constructor(message2, options) {
+    super(message2, options), this.name = this.constructor.name, Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var JWTClaimValidationFailed = class extends JOSEError {
+  static code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
+  code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
+  claim;
+  reason;
+  payload;
+  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
+    super(message2, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload;
+  }
+};
+var JWTExpired = class extends JOSEError {
+  static code = "ERR_JWT_EXPIRED";
+  code = "ERR_JWT_EXPIRED";
+  claim;
+  reason;
+  payload;
+  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
+    super(message2, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload;
+  }
+};
+var JOSEAlgNotAllowed = class extends JOSEError {
+  static code = "ERR_JOSE_ALG_NOT_ALLOWED";
+  code = "ERR_JOSE_ALG_NOT_ALLOWED";
+};
+var JOSENotSupported = class extends JOSEError {
+  static code = "ERR_JOSE_NOT_SUPPORTED";
+  code = "ERR_JOSE_NOT_SUPPORTED";
+};
+var JWSInvalid = class extends JOSEError {
+  static code = "ERR_JWS_INVALID";
+  code = "ERR_JWS_INVALID";
+};
+var JWTInvalid = class extends JOSEError {
+  static code = "ERR_JWT_INVALID";
+  code = "ERR_JWT_INVALID";
+};
+var JWKSInvalid = class extends JOSEError {
+  static code = "ERR_JWKS_INVALID";
+  code = "ERR_JWKS_INVALID";
+};
+var JWKSNoMatchingKey = class extends JOSEError {
+  static code = "ERR_JWKS_NO_MATCHING_KEY";
+  code = "ERR_JWKS_NO_MATCHING_KEY";
+  constructor(message2 = "no applicable key found in the JSON Web Key Set", options) {
+    super(message2, options);
+  }
+};
+var JWKSMultipleMatchingKeys = class extends JOSEError {
+  [Symbol.asyncIterator] = async function* () {
+  };
+  static code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
+  code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
+  constructor(message2 = "multiple matching keys found in the JSON Web Key Set", options) {
+    super(message2, options);
+  }
+};
+var JWKSTimeout = class extends JOSEError {
+  static code = "ERR_JWKS_TIMEOUT";
+  code = "ERR_JWKS_TIMEOUT";
+  constructor(message2 = "request timed out", options) {
+    super(message2, options);
+  }
+};
+var JWSSignatureVerificationFailed = class extends JOSEError {
+  static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
+  code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
+  constructor(message2 = "signature verification failed", options) {
+    super(message2, options);
+  }
+};
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/util/base64url.js
+var invalid = "The input to be decoded is not correctly encoded.";
+function decode(input) {
+  try {
+    return decodeBase64(typeof input == "string" ? input : decoder.decode(input), true);
+  } catch (cause) {
+    throw new TypeError(invalid, { cause });
+  }
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/validate.js
+function isObject(input) {
+  if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]")
+    return false;
+  const prototype = Object.getPrototypeOf(input);
+  return prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+function isJwkSet(input) {
+  return isObject(input) && Array.isArray(input.keys) && Array.from(input.keys).every(isObject);
+}
+function isDisjoint(...headers) {
+  const parameters = /* @__PURE__ */ new Set();
+  for (const header of headers)
+    if (header)
+      for (const parameter of Object.keys(header)) {
+        if (parameters.has(parameter))
+          return false;
+        parameters.add(parameter);
+      }
+  return true;
+}
+function decodeBase64url(value, label, ErrorClass) {
+  try {
+    return decode(value);
+  } catch {
+    throw new ErrorClass(`Failed to base64url decode the ${label}`);
+  }
+}
+function encodeBase64url(value, label, ErrorClass) {
+  try {
+    return encode(value);
+  } catch {
+    throw new ErrorClass(`The ${label} is not a valid base64url string`);
+  }
+}
+function parseJoseHeader(b64, ErrorClass, message2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
+  } catch {
+    throw new ErrorClass(message2);
+  }
+  if (!isObject(parsed))
+    throw new ErrorClass(message2);
+  return parsed;
+}
+var JWS_RECOGNIZED = { __proto__: null, b64: true };
+function validateAlgorithms(option, algorithms) {
+  if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s != "string")))
+    throw new TypeError(`"${option}" option must be an array of strings`);
+  return algorithms === void 0 ? void 0 : new Set(algorithms);
+}
+function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
+  if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0)
+    throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
+  if (!protectedHeader || protectedHeader.crit === void 0)
+    return [];
+  if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input != "string" || input.length === 0))
+    throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
+  const recognized = recognizedOption === void 0 ? recognizedDefault : { __proto__: null, ...recognizedOption, ...recognizedDefault };
+  for (const parameter of protectedHeader.crit) {
+    if (!(parameter in recognized))
+      throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
+    if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === void 0)
+      throw new Err(`Extension Header Parameter "${parameter}" is missing`);
+    if (recognized[parameter] && (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === void 0))
+      throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
+  }
+  return protectedHeader.crit;
+}
+function validateB64(protectedHeader, extensions) {
+  if (extensions.includes("b64")) {
+    const b64 = protectedHeader.b64;
+    if (typeof b64 != "boolean")
+      throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
+    return b64;
+  }
+  return true;
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/key.js
+var tag = (key) => key[Symbol.toStringTag];
+var jwkMatchesOp = (entry, key, usage) => {
+  const { alg } = entry;
+  if (key.use !== void 0) {
+    const expected = usage === "sign" || usage === "verify" ? "sig" : "enc";
+    if (key.use !== expected)
+      throw new TypeError(`Invalid key for this operation, its "use" must be "${expected}" when present`);
+  }
+  if (key.alg !== void 0 && key.alg !== alg)
+    throw new TypeError(`Invalid key for this operation, its "alg" must be "${alg}" when present`);
+  if (Array.isArray(key.key_ops)) {
+    const expectedKeyOp = usage === "encrypt" || usage === "decrypt" ? entry.ops?.[usage === "encrypt" ? 0 : 1] : usage;
+    if (expectedKeyOp && !key.key_ops.includes(expectedKeyOp))
+      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${expectedKeyOp}" when present`);
+  }
+};
+async function prepareKey(entry, key, usage) {
+  const { alg, secret } = entry, privateKey = usage === "decrypt" || usage === "sign";
+  if (secret && key instanceof Uint8Array)
+    return key;
+  let normalized, keyObject;
+  if (isObject(key)) {
+    if (normalized = normalizeJwk(key), typeof normalized.kty != "string")
+      throw invalidKeyType(alg, key, secret);
+    if (!(secret ? normalized.kty === "oct" && typeof normalized.k == "string" : normalized.kty !== "oct" && (privateKey ? normalized.kty === "AKP" && typeof normalized.priv == "string" || typeof normalized.d == "string" : normalized.d === void 0 && normalized.priv === void 0)))
+      throw new TypeError(secret ? 'JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present' : `JSON Web Key for this operation must be a ${privateKey ? "private" : "public"} JWK`);
+    if (jwkMatchesOp(entry, normalized, usage), normalized.kty === "oct")
+      return decode(normalized.k);
+    if (!Object.isFrozen(key)) {
+      const { key_ops } = key;
+      Array.isArray(key_ops) && Object.freeze(key_ops), Object.freeze(key);
+    }
+  } else {
+    if (!isKeyLike(key))
+      throw invalidKeyType(alg, key, secret);
+    const expectedType = secret ? "secret" : privateKey ? "private" : "public";
+    if (key.type !== expectedType && (secret || ["secret", "public", "private"].includes(key.type)))
+      throw new TypeError(`${tag(key)} instances must be of type "${expectedType}" for the ${alg} algorithm`);
+    if (isCryptoKey(key))
+      return key;
+    if (keyObject = key, keyObject.type === "secret")
+      return keyObject.export();
+  }
+  cache ||= /* @__PURE__ */ new WeakMap();
+  const cacheKey = key;
+  let cached = cache.get(cacheKey);
+  if (cached?.[alg])
+    return cached[alg];
+  if (cached || cache.set(cacheKey, cached = {}), keyObject && typeof keyObject.toCryptoKey == "function") {
+    const isPublic = keyObject.type === "public", crv = nist[keyObject.asymmetricKeyDetails?.namedCurve], params = entry.resolve?.({ crv, asymmetricKeyType: keyObject.asymmetricKeyType }) ?? entry.subtle;
+    return cached[alg] = keyObject.toCryptoKey(params, isPublic, entry.usages[isPublic ? 0 : 1]);
+  }
+  return normalized ??= keyObject.export({ format: "jwk" }), normalized.alg = alg, cached[alg] = await jwkToKey(entry, normalized);
+}
+var cache;
+var nist = {
+  __proto__: null,
+  prime256v1: "P-256",
+  secp384r1: "P-384",
+  secp521r1: "P-521"
+};
+var isCryptoKey = (key) => {
+  if (key?.[Symbol.toStringTag] === "CryptoKey")
+    return true;
+  try {
+    return key instanceof CryptoKey;
+  } catch {
+    return false;
+  }
+};
+var isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject";
+var isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
+function message(msg, actual, ...types) {
+  if (types.length > 2) {
+    const last = types.pop();
+    msg += `one of type ${types.join(", ")}, or ${last}.`;
+  } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`;
+  return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg;
+}
+function invalidKeyType(alg, actual, secret) {
+  const types = ["CryptoKey", "KeyObject", "JSON Web Key"];
+  return secret && types.push("Uint8Array"), new TypeError(message(`Key for the ${alg} algorithm must be `, actual, ...types));
+}
+var unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
+function checkUsage(key, usage) {
+  if (usage && !key.usages.includes(usage))
+    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
+}
+function checkModulusLength(alg, key) {
+  const { modulusLength } = key.algorithm;
+  if (typeof modulusLength != "number" || modulusLength < 2048)
+    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
+}
+function checkCryptoKey(key, expected, usage) {
+  const algorithm = key.algorithm;
+  if (algorithm.name !== expected.name)
+    throw unusable(expected.name);
+  if (expected.hash && algorithm.hash?.name !== expected.hash)
+    throw unusable(expected.hash, "algorithm.hash");
+  if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve)
+    throw unusable(expected.namedCurve, "algorithm.namedCurve");
+  if (expected.length !== void 0 && algorithm.length !== expected.length)
+    throw unusable(expected.length, "algorithm.length");
+  checkUsage(key, usage);
+}
+function snapshotJwk(jwk) {
+  return { __proto__: null, ...jwk };
+}
+function normalizeJwk(jwk) {
+  const normalized = snapshotJwk(jwk);
+  if (normalized.ext !== void 0 && typeof normalized.ext != "boolean")
+    throw new TypeError('"ext" (Extractable) Parameter must be a boolean');
+  if (normalized.key_ops !== void 0) {
+    const value = normalized.key_ops, keyOps = Array.isArray(value) ? [...value] : void 0;
+    if (!keyOps || keyOps.some((operation) => typeof operation != "string") || new Set(keyOps).size !== keyOps.length)
+      throw new TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');
+    normalized.key_ops = keyOps;
+  }
+  return normalized;
+}
+async function jwkToKey(entry, jwk, extractable) {
+  if (!entry.kty.includes(jwk.kty))
+    throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+  const algorithm = entry.resolve?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle, isPrivate = !!(jwk.d || jwk.priv), keyData = { ...jwk, ext: extractable ?? jwk.ext };
+  return keyData.kty !== "AKP" && delete keyData.alg, delete keyData.use, crypto.subtle.importKey("jwk", keyData, algorithm, keyData.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]);
+}
+async function rawKey(key, expected, usage, extractable = false) {
+  return key instanceof Uint8Array && (key = await crypto.subtle.importKey("raw", key, expected, extractable, [usage])), checkCryptoKey(key, expected, usage), key;
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/key_descriptor.js
+function table(entries) {
+  const out = { __proto__: null };
+  for (const alg in entries)
+    out[alg] = { ...entries[alg], alg };
+  return out;
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/jws_algorithms.js
+var sig = [["verify"], ["sign"]];
+function hmac(bits) {
+  const subtle = { name: "HMAC", hash: `SHA-${bits}` };
+  return { kty: ["oct"], secret: true, subtle, signing: subtle, usages: sig };
+}
+function rsa(bits, saltLength) {
+  const subtle = { name: saltLength ? "RSA-PSS" : "RSASSA-PKCS1-v1_5", hash: `SHA-${bits}` };
+  return {
+    kty: ["RSA"],
+    subtle,
+    signing: saltLength ? { ...subtle, saltLength } : subtle,
+    usages: sig,
+    minRsaBits: 2048
+  };
+}
+function ecdsa(crv, bits) {
+  return {
+    kty: ["EC"],
+    crv,
+    subtle: { name: "ECDSA", namedCurve: crv },
+    signing: { name: "ECDSA", hash: `SHA-${bits}` },
+    usages: sig
+  };
+}
+function eddsa() {
+  const subtle = { name: "Ed25519" };
+  return {
+    kty: ["OKP"],
+    crv: "Ed25519",
+    subtle,
+    signing: subtle,
+    usages: sig
+  };
+}
+function mldsa(bits) {
+  const subtle = { name: `ML-DSA-${bits}` };
+  return {
+    kty: ["AKP"],
+    subtle,
+    signing: subtle,
+    usages: sig
+  };
+}
+var JWS = table({
+  HS256: hmac(256),
+  HS384: hmac(384),
+  HS512: hmac(512),
+  RS256: rsa(256),
+  RS384: rsa(384),
+  RS512: rsa(512),
+  PS256: rsa(256, 32),
+  PS384: rsa(384, 48),
+  PS512: rsa(512, 64),
+  ES256: ecdsa("P-256", 256),
+  ES384: ecdsa("P-384", 384),
+  ES512: ecdsa("P-521", 512),
+  EdDSA: eddsa(),
+  Ed25519: eddsa(),
+  "ML-DSA-44": mldsa(44),
+  "ML-DSA-65": mldsa(65),
+  "ML-DSA-87": mldsa(87)
+});
+function jwsAlgorithm(alg) {
+  const entry = typeof alg == "string" ? JWS[alg] : void 0;
+  if (!entry)
+    throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
+  return entry;
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/jws_verify.js
+function prepareVerify(options) {
+  return [options && validateAlgorithms("algorithms", options.algorithms), options?.crit];
+}
+function parseProtectedHeader(encodedProtected) {
+  return encodedProtected === void 0 ? {} : parseJoseHeader(encodedProtected, JWSInvalid, "JWS Protected Header is invalid");
+}
+function encodeCompactUnencodedPayload(payload) {
+  try {
+    return encode(payload);
+  } catch {
+    throw new JWSInvalid("JWS Compact Serialization payload must use only ASCII characters");
+  }
+}
+async function verifySignature(jws, shared, key, encodeUnencodedPayload, parsedProtected) {
+  const { protected: encodedProtected, header, payload: inputPayload } = jws, parsedProt = parsedProtected ?? parseProtectedHeader(encodedProtected);
+  if (!isDisjoint(parsedProt, header))
+    throw new JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
+  const joseHeader = { ...parsedProt, ...header }, b64 = validateB64(parsedProt, validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader)), { alg } = joseHeader;
+  if (typeof alg != "string" || !alg)
+    throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
+  if (shared[0] && !shared[0].has(alg))
+    throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
+  if (b64) {
+    if (typeof inputPayload != "string")
+      throw new JWSInvalid("JWS Payload must be a string");
+  } else if (typeof inputPayload != "string" && !(inputPayload instanceof Uint8Array))
+    throw new JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
+  const signingPayload = b64 || typeof inputPayload != "string" ? inputPayload : encodeUnencodedPayload(inputPayload);
+  let resolvedKey = false;
+  typeof key == "function" && (key = await key(parsedProt, jws), resolvedKey = true);
+  const entry = jwsAlgorithm(alg), data = concat(encodedProtected !== void 0 ? encode(encodedProtected) : new Uint8Array(), encode("."), typeof signingPayload == "string" ? shared[2] ??= encodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload), signature = decodeBase64url(jws.signature, "signature", JWSInvalid), k = await prepareKey(entry, key, "verify"), cryptoKey = await rawKey(k, entry.subtle, "verify");
+  entry.minRsaBits && checkModulusLength(entry.alg, cryptoKey);
+  let verified = false;
+  try {
+    verified = await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
+  } catch {
+  }
+  if (!verified)
+    throw new JWSSignatureVerificationFailed();
+  const result = { payload: typeof signingPayload == "string" ? decodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload };
+  return encodedProtected !== void 0 && (result.protectedHeader = parsedProt), header !== void 0 && (result.unprotectedHeader = header), resolvedKey ? [{ ...result, key: k }, b64] : [result, b64];
+}
+async function verifyCompact(jws, shared, key) {
+  if (jws instanceof Uint8Array && (jws = decoder.decode(jws)), typeof jws != "string")
+    throw new JWSInvalid("Compact JWS must be a string or Uint8Array");
+  const { 0: protectedHeader, 1: payload, 2: signature, length } = jws.split(".");
+  if (length !== 3)
+    throw new JWSInvalid("Invalid Compact JWS");
+  return verifySignature({ payload, protected: protectedHeader, signature }, shared, key, encodeCompactUnencodedPayload);
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/jwt_claims_set.js
+var epoch = (date) => Math.floor(date.getTime() / 1e3);
+var multipliers = {
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400,
+  w: 604800,
+  y: 31557600
+};
+var REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
+var checkFailed = "check_failed";
+function invalidDuration() {
+  throw new TypeError("Invalid time period format");
+}
+function secs(str) {
+  typeof str != "string" && invalidDuration();
+  const matched = REGEX.exec(str);
+  (!matched || matched[4] && matched[1]) && invalidDuration();
+  const value = parseFloat(matched[2]), numericDate2 = Math.round(value * multipliers[matched[3][0].toLowerCase()]);
+  return Number.isFinite(numericDate2) || invalidDuration(), matched[1] === "-" || matched[4] === "ago" ? -numericDate2 : numericDate2;
+}
+function validateInput(label, input) {
+  if (!Number.isFinite(input))
+    throw new TypeError(`Invalid ${label} input`);
+  return input;
+}
+var normalizeTyp = (value) => {
+  const normalized = value.toLowerCase();
+  return value.includes("/") ? normalized : `application/${normalized}`;
+};
+var checkAudiencePresence = (audPayload, audOption) => typeof audPayload == "string" ? audOption.includes(audPayload) : Array.isArray(audPayload) ? audOption.some((aud) => audPayload.includes(aud)) : false;
+function validateNumericDate(payload, claim, required = false) {
+  const value = payload[claim];
+  if (!(value === void 0 && !required)) {
+    if (typeof value != "number")
+      throw new JWTClaimValidationFailed(`"${claim}" claim must be a number`, payload, claim, "invalid");
+    return value;
+  }
+}
+function unexpectedClaim(payload, claim) {
+  throw new JWTClaimValidationFailed(`unexpected "${claim}" claim value`, payload, claim, checkFailed);
+}
+function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
+  let payload;
+  try {
+    payload = JSON.parse(strictDecoder.decode(encodedPayload));
+  } catch {
+  }
+  if (!isObject(payload))
+    throw new JWTInvalid("JWT Claims Set must be a top-level JSON object");
+  const { typ } = options;
+  if (typ !== void 0 && (typeof protectedHeader.typ != "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ)))
+    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", checkFailed);
+  const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options, presenceCheck = [...requiredClaims];
+  maxTokenAge !== void 0 && presenceCheck.push("iat"), audience !== void 0 && presenceCheck.push("aud"), subject !== void 0 && presenceCheck.push("sub"), issuer !== void 0 && presenceCheck.push("iss");
+  for (const claim of new Set(presenceCheck.reverse()))
+    if (!Object.hasOwn(payload, claim))
+      throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing");
+  issuer !== void 0 && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss) && unexpectedClaim(payload, "iss"), subject !== void 0 && payload.sub !== subject && unexpectedClaim(payload, "sub"), audience !== void 0 && !checkAudiencePresence(payload.aud, typeof audience == "string" ? [audience] : audience) && unexpectedClaim(payload, "aud");
+  const { clockTolerance } = options;
+  let tolerance = 0;
+  if (typeof clockTolerance == "string")
+    tolerance = secs(clockTolerance);
+  else if (clockTolerance !== void 0) {
+    if (typeof clockTolerance != "number")
+      throw new TypeError("Invalid clockTolerance option type");
+    tolerance = clockTolerance;
+  }
+  validateInput("clockTolerance option", tolerance);
+  const { currentDate } = options, now = validateInput("currentDate option", epoch(currentDate === void 0 ? /* @__PURE__ */ new Date() : currentDate)), iat = validateNumericDate(payload, "iat", maxTokenAge !== void 0), nbf = validateNumericDate(payload, "nbf");
+  if (nbf !== void 0 && nbf > now + tolerance)
+    throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", checkFailed);
+  const exp = validateNumericDate(payload, "exp");
+  if (exp !== void 0 && exp <= now - tolerance)
+    throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", checkFailed);
+  if (maxTokenAge !== void 0) {
+    const age = now - iat, max = validateInput("maxTokenAge option", typeof maxTokenAge == "number" ? maxTokenAge : secs(maxTokenAge));
+    if (age - tolerance > max)
+      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", checkFailed);
+    if (age < -tolerance)
+      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", checkFailed);
+  }
+  return payload;
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/jwt/verify.js
+async function jwtVerify(jwt, key, options) {
+  const [verified, b64] = await verifyCompact(jwt, prepareVerify(options), key);
+  if (!b64)
+    throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
+  const payload = validateClaimsSet(verified.protectedHeader, verified.payload, options);
+  return { ...verified, payload };
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/jwks/local.js
+function isUsableJWK(jwk, entry, alg, kid) {
+  const { kty, key_ops: keyOps, ext, kid: jwkKid, alg: jwkAlg, use, crv } = jwk;
+  return (ext === void 0 || typeof ext == "boolean") && (keyOps === void 0 || Array.isArray(keyOps) && keyOps.every((operation, index) => typeof operation == "string" && keyOps.indexOf(operation) === index) && keyOps.includes("verify")) && entry.kty.includes(kty) && (kid === void 0 || typeof kid == "string" && kid === jwkKid) && (jwkAlg === void 0 ? kty !== "AKP" : alg === jwkAlg) && (use === void 0 || use === "sig") && (!entry.crv || crv === entry.crv);
+}
+async function importWithAlgCache(cache2, jwk, entry) {
+  const cached = cache2.get(jwk) || cache2.set(jwk, {}).get(jwk), { alg } = entry;
+  if (cached[alg] === void 0) {
+    const pending = jwkToKey(entry, jwk, true).then((key) => {
+      if (key.type !== "public")
+        throw new JWKSInvalid("JSON Web Key Set members must be public keys");
+      return cached[alg] = key, key;
+    }).catch((error) => {
+      throw cached[alg] === pending && delete cached[alg], error;
+    });
+    cached[alg] = pending;
+  }
+  return cached[alg];
+}
+function createLocalJWKSet(jwks) {
+  let snapshot;
+  try {
+    snapshot = structuredClone(jwks);
+  } catch {
+  }
+  if (!isJwkSet(snapshot))
+    throw new JWKSInvalid("JSON Web Key Set malformed");
+  const metadata = snapshot.keys.map((jwk) => {
+    const normalized = snapshotJwk(jwk);
+    return Array.isArray(normalized.key_ops) && (normalized.key_ops = [...normalized.key_ops]), normalized;
+  }), cached = /* @__PURE__ */ new WeakMap();
+  return Object.defineProperty(async (protectedHeader, token) => {
+    const { alg, kid } = { ...protectedHeader, ...token?.header }, entry = typeof alg == "string" ? JWS[alg] : void 0;
+    if (!entry || entry.secret)
+      throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
+    const candidates = snapshot.keys.filter((_, index) => isUsableJWK(metadata[index], entry, alg, kid)), { 0: jwk, length } = candidates;
+    if (!length)
+      throw new JWKSNoMatchingKey();
+    if (length !== 1) {
+      const error = new JWKSMultipleMatchingKeys();
+      throw error[Symbol.asyncIterator] = async function* () {
+        for (const jwk2 of candidates)
+          try {
+            yield await importWithAlgCache(cached, jwk2, entry);
+          } catch {
+          }
+      }, error;
+    }
+    return importWithAlgCache(cached, jwk, entry);
+  }, "jwks", {
+    value: () => structuredClone(snapshot)
+  });
+}
+
+// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/jwks/remote.js
+function isCloudflareWorkers() {
+  return typeof WebSocketPair < "u" || typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime < "u" && EdgeRuntime === "vercel";
+}
+var USER_AGENT;
+(typeof navigator > "u" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) && (USER_AGENT = "jose/v6.2.12");
+var customFetch = /* @__PURE__ */ Symbol();
+async function fetchJwks(url, headers, signal, fetchImpl = fetch) {
+  const response = await fetchImpl(url, {
+    method: "GET",
+    signal,
+    redirect: "manual",
+    headers
+  }).catch((err) => {
+    throw err.name === "TimeoutError" ? new JWKSTimeout() : err;
+  });
+  if (response.status !== 200)
+    throw new JOSEError("Expected 200 OK from the JSON Web Key Set HTTP response");
+  try {
+    return await response.json();
+  } catch {
+    throw new JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON");
+  }
+}
+var jwksCache = /* @__PURE__ */ Symbol();
+function isFreshFor(timestamp, duration) {
+  return Number.isFinite(timestamp) && Date.now() < timestamp + duration;
+}
+function validateDuration(value, fallback, option) {
+  if (Number.isNaN(value))
+    throw new TypeError(`"${option}" option must not be NaN`);
+  return typeof value == "number" ? value : fallback;
+}
+function createRemoteJWKSet(url, options) {
+  if (!(url instanceof URL))
+    throw new TypeError("url must be an instance of URL");
+  const href = new URL(url.href).href, opts = options ?? {}, timeoutOption = opts.timeoutDuration;
+  if (typeof timeoutOption == "number" && (!Number.isInteger(timeoutOption) || timeoutOption < 0))
+    throw new TypeError('"timeoutDuration" option must be a non-negative integer');
+  const timeoutDuration = typeof timeoutOption == "number" ? timeoutOption : 5e3, cooldownDuration = validateDuration(opts.cooldownDuration, 3e4, "cooldownDuration"), cacheMaxAge = validateDuration(opts.cacheMaxAge, 6e5, "cacheMaxAge"), headers = new Headers(opts.headers);
+  USER_AGENT && !headers.has("User-Agent") && headers.set("User-Agent", USER_AGENT), headers.has("accept") || headers.set("accept", "application/json, application/jwk-set+json");
+  const fetchImpl = opts[customFetch], cache2 = opts[jwksCache];
+  let jwksTimestamp, pendingFetch, reloadSequence = 0, appliedSequence = 0, local;
+  if (cache2 && typeof cache2 == "object") {
+    const { uat, jwks } = cache2;
+    isFreshFor(uat, cacheMaxAge) && isJwkSet(jwks) && (jwksTimestamp = uat, local = createLocalJWKSet(jwks));
+  }
+  const reload = async () => {
+    if (pendingFetch && isCloudflareWorkers() && (pendingFetch = void 0), !pendingFetch) {
+      const sequence = ++reloadSequence, current = pendingFetch = fetchJwks(href, headers, AbortSignal.timeout(timeoutDuration), fetchImpl).then((json) => {
+        const next = createLocalJWKSet(json);
+        if (sequence <= appliedSequence)
+          return;
+        local = next;
+        const updatedAt = Date.now();
+        cache2 && (cache2.uat = updatedAt, cache2.jwks = json), jwksTimestamp = updatedAt, appliedSequence = sequence;
+      }).finally(() => {
+        pendingFetch === current && (pendingFetch = void 0);
+      });
+    }
+    await pendingFetch;
+  };
+  return Object.defineProperties(async (protectedHeader, token) => {
+    (!local || !isFreshFor(jwksTimestamp, cacheMaxAge)) && await reload();
+    try {
+      return await local(protectedHeader, token);
+    } catch (err) {
+      if (err instanceof JWKSNoMatchingKey && !isFreshFor(jwksTimestamp, cooldownDuration))
+        return await reload(), local(protectedHeader, token);
+      throw err;
+    }
+  }, {
+    coolingDown: {
+      get: () => isFreshFor(jwksTimestamp, cooldownDuration),
+      enumerable: true
+    },
+    fresh: {
+      get: () => isFreshFor(jwksTimestamp, cacheMaxAge),
+      enumerable: true
+    },
+    reload: {
+      value: reload,
+      enumerable: true
+    },
+    reloading: {
+      get: () => !!pendingFetch,
+      enumerable: true
+    },
+    jwks: {
+      value: () => local?.jwks(),
+      enumerable: true
+    }
+  });
+}
+
+// packages/cli/src/tui/chatgpt-plan-auth.ts
+var SIWC_ISSUER = "https://auth.openai.com";
+var SIWC_RESOURCE = "https://api.openai.com/v1";
+var SIWC_SCOPES = ["openid", "profile", "email", "offline_access", "resource.invoke", "chatgpt.tokens.use.direct"];
+var PATH = "/auth/callback";
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+function credential(value) {
+  if (typeof value !== "string" || !value || value.length > 65536 || /[^\x21-\x7e]/.test(value)) throw new Error("The provider returned invalid authentication data.");
+  return value;
+}
+async function readSiwcJson(url, init, transport = {}) {
+  const signal = init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(3e4)]) : AbortSignal.timeout(3e4);
+  let response;
+  try {
+    response = await (transport.fetch ?? fetch)(url, { ...init, signal, redirect: "error" });
+  } catch {
+    throw new Error("ChatGPT sign-in could not reach its authentication service. Retry the connection.");
+  }
+  if (!response.ok) throw new Error(response.status === 400 || response.status === 401 ? "ChatGPT authentication was rejected. Sign in again." : `ChatGPT authentication is unavailable (HTTP ${response.status}).`);
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("ChatGPT returned an empty authentication response.");
+  let bytes = 0, raw = "";
+  const decoder2 = new TextDecoder("utf-8", { fatal: true });
+  try {
+    for (; ; ) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > 1048576) throw new Error("ChatGPT authentication response exceeded its limit.");
+      raw += decoder2.decode(chunk.value, { stream: true });
+    }
+    raw += decoder2.decode();
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new Error("ChatGPT returned an invalid authentication response.");
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function trustedEndpoint(value) {
+  if (typeof value !== "string") throw new Error("ChatGPT authentication configuration is incomplete.");
+  const url = new URL(value);
+  if (url.origin !== SIWC_ISSUER || url.username || url.password || url.hash || url.search) throw new Error("ChatGPT authentication configuration contains an untrusted endpoint.");
+  return url.href;
+}
+async function siwcMetadata(transport, signal) {
+  const data = object(await readSiwcJson(`${SIWC_ISSUER}/.well-known/openid-configuration`, { signal }, transport));
+  if (data.issuer !== SIWC_ISSUER) throw new Error("ChatGPT authentication issuer did not match.");
+  return { token: trustedEndpoint(data.token_endpoint), jwks: trustedEndpoint(data.jwks_uri), revoke: trustedEndpoint(data.revocation_endpoint) };
+}
+async function validateSiwcTokens(value, clientId, metadata, transport, signal, expected) {
+  const data = object(value), previous = expected?.previous;
+  const idToken = data.id_token === void 0 && previous ? previous.idToken : credential(data.id_token);
+  const now = transport.now?.() ?? Date.now();
+  let identity;
+  if (data.id_token === void 0 && previous && previous.clientId === clientId && previous.issuer === SIWC_ISSUER) {
+    identity = { sub: previous.subject, email: previous.email, iat: Math.floor(now / 1e3) };
+  } else {
+    const keys = object(await readSiwcJson(metadata.jwks, { signal }, transport));
+    if (!Array.isArray(keys.keys)) throw new Error("ChatGPT returned invalid signing keys.");
+    try {
+      identity = (await jwtVerify(idToken, createLocalJWKSet(keys), { issuer: SIWC_ISSUER, audience: clientId, algorithms: ["RS256", "ES256"], currentDate: new Date(now), requiredClaims: ["sub", "iat", "exp"] })).payload;
+    } catch {
+      throw new Error("ChatGPT identity verification failed. Sign in again.");
+    }
+  }
+  if (typeof identity.sub !== "string" || !identity.sub || typeof identity.iat !== "number" || identity.iat > now / 1e3 + 60 || expected?.nonce !== void 0 && identity.nonce !== expected.nonce || expected?.subject !== void 0 && identity.sub !== expected.subject || identity.azp !== void 0 && identity.azp !== clientId || Array.isArray(identity.aud) && identity.aud.length > 1 && identity.azp !== clientId) throw new Error("ChatGPT identity did not match this sign-in.");
+  const scopes = typeof data.scope === "string" ? [...new Set(data.scope.split(/\s+/).filter(Boolean))] : data.scope === void 0 ? expected?.scopes : void 0;
+  if (!scopes || !scopes.includes("openid")) throw new Error("ChatGPT did not return the granted identity permissions.");
+  const sharing = scopes.includes("chatgpt.tokens.use.direct");
+  const accessToken = data.access_token !== void 0 ? credential(data.access_token) : void 0;
+  const refreshToken = data.refresh_token !== void 0 ? credential(data.refresh_token) : previous?.refreshToken;
+  if (data.token_type !== "Bearer" || sharing && (!accessToken || !refreshToken || !scopes.includes("resource.invoke") || !scopes.includes("offline_access")) || typeof data.expires_in !== "number" || !Number.isFinite(data.expires_in) || data.expires_in <= 0 || data.expires_in > 86400) throw new Error("ChatGPT did not return a usable token grant.");
+  const earliest = data.earliest_refresh_at;
+  const earliestRefreshAt = typeof earliest === "number" ? earliest * 1e3 : typeof earliest === "string" ? Date.parse(earliest) : void 0;
+  if (earliestRefreshAt !== void 0 && !Number.isFinite(earliestRefreshAt)) throw new Error("ChatGPT returned an invalid refresh schedule.");
+  const email = typeof identity.email === "string" && identity.email.length <= 320 && !/[\x00-\x1f\x7f]/.test(identity.email) ? identity.email : void 0;
+  return { clientId, subject: identity.sub, issuer: SIWC_ISSUER, ...email ? { email } : {}, scopes, idToken, ...accessToken ? { accessToken } : {}, ...refreshToken ? { refreshToken } : {}, expiresAt: now + data.expires_in * 1e3, ...earliestRefreshAt !== void 0 ? { earliestRefreshAt } : {}, status: "connected" };
+}
+async function refreshSiwcProfile(profile, transport = {}, signal, checkpoint) {
+  if (!profile.refreshToken || profile.status !== "connected") throw new Error("Sign in with ChatGPT again before continuing.");
+  const metadata = await siwcMetadata(transport, signal);
+  const value = await readSiwcJson(metadata.token, { method: "POST", signal, headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ grant_type: "refresh_token", client_id: profile.clientId, refresh_token: profile.refreshToken, resource: SIWC_RESOURCE }).toString() }, transport);
+  const body = object(value), receipt = {};
+  for (const key of ["access_token", "refresh_token", "id_token", "token_type", "expires_in", "scope", "earliest_refresh_at"]) {
+    const field = body[key];
+    if (field !== void 0) receipt[key] = typeof field === "string" && field.length <= 65536 || typeof field === "number" || typeof field === "boolean" || field === null ? field : null;
+  }
+  await checkpoint?.(receipt);
+  return { id: profile.id, ...await validateSiwcTokens(value, profile.clientId, metadata, transport, signal, { subject: profile.subject, scopes: profile.scopes, previous: profile }) };
+}
+async function loginSiwc(options) {
+  if (!/^urn:uuid:[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(options.hostId)) throw new Error("ChatGPT sign-in requires this installation's stable host identity.");
+  const abort = new AbortController();
+  const signal = options.signal ? AbortSignal.any([options.signal, abort.signal, AbortSignal.timeout(3e5)]) : AbortSignal.any([abort.signal, AbortSignal.timeout(3e5)]);
+  const state = randomBytes(32).toString("base64url"), nonce = randomBytes(32).toString("base64url"), verifier = randomBytes(64).toString("base64url");
+  let resolveCallback, rejectCallback;
+  const callback = new Promise((resolve4, reject) => {
+    resolveCallback = resolve4;
+    rejectCallback = reject;
+  });
+  void callback.catch(() => void 0);
+  let consumed = false, redirect = "";
+  const server = createServer((req, res) => {
+    let url;
+    try {
+      if (!redirect) throw new Error();
+      url = new URL(req.url ?? "/", redirect);
+    } catch {
+      res.writeHead(400);
+      res.end("Invalid callback.");
+      return;
+    }
+    if (consumed || req.method !== "GET" || req.headers.host !== new URL(redirect).host || url.origin !== new URL(redirect).origin || url.pathname !== PATH || url.searchParams.getAll("state").length !== 1 || url.searchParams.get("state") !== state) {
+      res.writeHead(400, { "Cache-Control": "no-store" });
+      res.end("This sign-in callback is not valid.");
+      return;
+    }
+    consumed = true;
+    res.writeHead(200, { "Cache-Control": "no-store", "Content-Type": "text/plain; charset=utf-8", "Content-Security-Policy": "default-src 'none'", "Referrer-Policy": "no-referrer" });
+    res.end("Return to 0 to finish connecting ChatGPT.");
+    resolveCallback(url.searchParams);
+  });
+  const stopped = () => rejectCallback(new Error("ChatGPT sign-in was cancelled or timed out."));
+  signal.addEventListener("abort", stopped, { once: true });
+  try {
+    signal.throwIfAborted();
+    await new Promise((resolve4, reject) => {
+      server.once("error", () => reject(new Error("The local sign-in callback could not start.")));
+      server.listen(0, "127.0.0.1", resolve4);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") throw new Error("The local sign-in callback could not start.");
+    redirect = `http://127.0.0.1:${address.port}${PATH}`;
+    const url = new URL(`${SIWC_ISSUER}/api/accounts/authorize`);
+    const previous = options.previous;
+    const parameters = { client_id: previous?.clientId ?? "dynamic_agent_client", ...previous ? {} : { agent_name_hint: "0" }, ext_agent_host_id: options.hostId, response_type: "code", redirect_uri: redirect, scope: SIWC_SCOPES.join(" "), resource: SIWC_RESOURCE, state, nonce, code_challenge_method: "S256", code_challenge: createHash("sha256").update(verifier).digest("base64url") };
+    for (const [key, value2] of Object.entries(parameters)) url.searchParams.set(key, value2);
+    void Promise.resolve().then(() => options.onAuthorize(url.href)).catch(() => rejectCallback(new Error("The browser sign-in could not be opened.")));
+    const params = await callback;
+    signal.throwIfAborted();
+    if (params.has("error")) throw new Error("ChatGPT sign-in was not authorized. No account was changed.");
+    const clientId = params.has("client_id") ? credential(params.get("client_id")) : previous?.clientId;
+    if (!clientId || clientId === "dynamic_agent_client" || params.getAll("client_id").length > 1 || previous && clientId !== previous.clientId || params.getAll("code").length !== 1) throw new Error("ChatGPT registration did not match this sign-in.");
+    const code = credential(params.get("code")), metadata = await siwcMetadata(options, signal);
+    const value = await readSiwcJson(metadata.token, { method: "POST", signal, headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ grant_type: "authorization_code", client_id: clientId, code, code_verifier: verifier, redirect_uri: redirect, resource: SIWC_RESOURCE }).toString() }, options);
+    return await validateSiwcTokens(value, clientId, metadata, options, signal, { nonce, ...previous ? { subject: previous.subject } : {} });
+  } finally {
+    abort.abort();
+    signal.removeEventListener("abort", stopped);
+    server.closeAllConnections();
+    await new Promise((resolve4) => {
+      if (!server.listening) resolve4();
+      else server.close(() => resolve4());
+    });
+  }
+}
+
+// packages/cli/src/tui/chatgpt-plan-store.ts
+function paths(homeDir) {
+  const directory = join(homeStateDir(homeDir), "chatgpt-plan");
+  return { directory, file: join(directory, "accounts.json"), lock: join(directory, "write.lock") };
+}
+function checkPrivate(path, directory) {
+  const stat3 = lstatSync(path);
+  if (stat3.isSymbolicLink() || (directory ? !stat3.isDirectory() : !stat3.isFile()) || process.platform !== "win32" && ((stat3.mode & 63) !== 0 || process.getuid && stat3.uid !== process.getuid())) throw new Error("ChatGPT connection storage must be private and owned by this user.");
+}
+function read(homeDir) {
+  const { directory, file } = paths(homeDir);
+  if (!existsSync(directory)) return void 0;
+  checkPrivate(directory, true);
+  if (!existsSync(file)) return void 0;
+  checkPrivate(file, false);
+  if (lstatSync(file).size > 4194304) throw new Error("ChatGPT connection storage exceeded its limit.");
+  let data;
+  try {
+    data = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    throw new Error("ChatGPT connection storage is invalid.");
+  }
+  if (data.version !== 1 || !Number.isSafeInteger(data.revision) || data.revision < 0 || !/^urn:uuid:[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(data.hostId) || !Array.isArray(data.profiles) || data.profiles.length > 100) throw new Error("ChatGPT connection storage is invalid.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const p of data.profiles) {
+    if (!p || typeof p.id !== "string" || ids.has(p.id) || typeof p.subject !== "string" || !p.subject || p.issuer !== SIWC_ISSUER || !["connected", "signed-out", "reauth-required"].includes(p.status) || !Array.isArray(p.scopes) || !p.scopes.every((scope) => typeof scope === "string") || typeof p.expiresAt !== "number" || !Number.isFinite(p.expiresAt) || typeof p.idToken !== "string") throw new Error("ChatGPT connection storage is invalid.");
+    if (p.epoch !== void 0 && (!Number.isSafeInteger(p.epoch) || p.epoch < 0)) throw new Error("ChatGPT connection generation is invalid.");
+    credential(p.clientId);
+    if (p.clientId === "dynamic_agent_client") throw new Error("ChatGPT connection storage has no issued registration.");
+    if (p.accessToken !== void 0) credential(p.accessToken);
+    if (p.refreshToken !== void 0) credential(p.refreshToken);
+    ids.add(p.id);
+  }
+  if (data.activeId !== void 0 && !ids.has(data.activeId)) throw new Error("ChatGPT connection selection is invalid.");
+  return data;
+}
+function write(store, homeDir) {
+  const { directory, file } = paths(homeDir);
+  checkPrivate(directory, true);
+  const disk = read(homeDir);
+  if ((disk?.revision ?? 0) !== store.revision) throw new Error("ChatGPT connection storage changed. Retry the operation.");
+  const next = { ...store, revision: store.revision + 1 }, temp = join(directory, `${randomUUID()}.tmp`);
+  const bytes = JSON.stringify(next);
+  if (Buffer.byteLength(bytes) > 4194304) throw new Error("ChatGPT connection storage exceeded its limit.");
+  const fd = openSync(temp, "wx", 384);
+  try {
+    writeFileSync(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  try {
+    renameSync(temp, file);
+    store.revision = next.revision;
+    if (process.platform !== "win32") {
+      const parent = openSync(directory, "r");
+      try {
+        fsyncSync(parent);
+      } finally {
+        closeSync(parent);
+      }
+    }
+  } finally {
+    if (existsSync(temp)) unlinkSync(temp);
+  }
+}
+async function locked(homeDir, operation) {
+  const { directory, lock } = paths(homeDir);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  checkPrivate(directory, true);
+  let fd;
+  const deadline = Date.now() + 5e3;
+  for (; ; ) {
+    try {
+      fd = openSync(lock, "wx", 384);
+      writeFileSync(fd, String(process.pid));
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST" || Date.now() >= deadline) throw new Error("ChatGPT connection storage is busy. Close other connection operations and retry; an interrupted operation may require removing its stale lock.");
+      await new Promise((resolve4) => setTimeout(resolve4, 25));
+    }
+  }
+  try {
+    return await operation(read(homeDir) ?? { version: 1, revision: 0, hostId: `urn:uuid:${randomUUID()}`, profiles: [] });
+  } finally {
+    closeSync(fd);
+    unlinkSync(lock);
+  }
+}
+function listChatGptPlanProfiles(homeDir) {
+  const store = read(homeDir);
+  return store?.profiles.map((p, index) => ({ id: p.id, label: `${p.email ?? "ChatGPT account"} \xB7 Connection ${index + 1}`, active: store.activeId === p.id, status: p.status, sharing: p.status === "connected" && p.scopes.includes("chatgpt.tokens.use.direct") && p.scopes.includes("resource.invoke") })) ?? [];
+}
+async function signInChatGptPlan(options) {
+  const prepared = await locked(options.homeDir, async (store) => {
+    const previous = options.profileId ? store.profiles.find((p) => p.id === options.profileId) : void 0;
+    if (options.profileId && !previous) throw new Error("The selected ChatGPT connection no longer exists.");
+    if (!previous && store.profiles.length >= 100) throw new Error("This host already has 100 ChatGPT registrations. Reconnect an existing connection.");
+    write(store, options.homeDir);
+    return { hostId: store.hostId, previous };
+  });
+  const result = await loginSiwc({ ...options, ...prepared });
+  options.signal?.throwIfAborted();
+  await locked(options.homeDir, async (store) => {
+    options.signal?.throwIfAborted();
+    const existing = options.profileId ? store.profiles.find((p) => p.id === options.profileId) : void 0;
+    if (options.profileId && (!existing || existing.clientId !== result.clientId || existing.subject !== result.subject || (existing.epoch ?? 0) !== (prepared.previous?.epoch ?? 0))) throw new Error("The selected ChatGPT registration changed during sign-in.");
+    const profile = { id: existing?.id ?? randomUUID(), ...result, epoch: (existing?.epoch ?? 0) + 1 };
+    store.profiles = [...store.profiles.filter((p) => p.id !== profile.id), profile];
+    store.activeId = profile.id;
+    write(store, options.homeDir);
+  });
+}
+async function selectChatGptPlanProfile(profileId, homeDir) {
+  await locked(homeDir, async (store) => {
+    if (!store.profiles.some((p) => p.id === profileId && p.status === "connected")) throw new Error("Sign in to this ChatGPT connection before selecting it.");
+    store.activeId = profileId;
+    write(store, homeDir);
+  });
+}
+function getSiwcConnection(homeDir, profileId, transport = {}) {
+  const current = read(homeDir), selected = profileId ?? current?.activeId, profile = current?.profiles.find((p) => p.id === selected);
+  if (!current || !profile || profile.status !== "connected") throw new Error("Connect your ChatGPT plan in Connections before choosing this provider.");
+  const binding = { accountId: profile.subject, clientId: profile.clientId, hostId: current.hostId };
+  return { ...binding, resolveCredentials: async (signal) => {
+    signal?.throwIfAborted();
+    const result = await locked(homeDir, async (store) => {
+      signal?.throwIfAborted();
+      let p = store.profiles.find((p2) => p2.id === selected);
+      if (!p || p.status !== "connected" || p.subject !== binding.accountId || p.clientId !== binding.clientId || store.hostId !== binding.hostId) throw new Error("This ChatGPT registration is no longer available. Reconnect it.");
+      if (p.pendingRotation !== void 0) {
+        const next = await validateSiwcTokens(p.pendingRotation, p.clientId, await siwcMetadata(transport), transport, void 0, { subject: p.subject, scopes: p.scopes, previous: p });
+        p = { id: p.id, ...next, epoch: p.epoch };
+        store.profiles = store.profiles.map((row) => row.id === p.id ? p : row);
+        write(store, homeDir);
+      }
+      if (!p.scopes.includes("chatgpt.tokens.use.direct") || !p.scopes.includes("resource.invoke")) throw new Error("ChatGPT plan usage is not enabled for this connection. Sign in and grant plan usage, or use an API key.");
+      signal?.throwIfAborted();
+      const now = transport.now?.() ?? Date.now();
+      if (p.expiresAt <= now + 6e4 && (p.earliestRefreshAt === void 0 || p.earliestRefreshAt <= now)) {
+        if (Buffer.byteLength(JSON.stringify(store)) + 1048576 > 4194304) throw new Error("ChatGPT connection storage is full. Sign out of unused connections before refreshing.");
+        const next = await refreshSiwcProfile(p, transport, void 0, async (value) => {
+          p.pendingRotation = value;
+          write(store, homeDir);
+        });
+        p = { ...next, epoch: p.epoch };
+        store.profiles = store.profiles.map((row) => row.id === p.id ? p : row);
+        write(store, homeDir);
+      }
+      if (p.expiresAt <= now || !p.accessToken || !p.scopes.includes("chatgpt.tokens.use.direct") || !p.scopes.includes("resource.invoke")) throw new Error("ChatGPT plan usage is not enabled for this connection. Sign in and grant plan usage, or use an API key.");
+      return { accessToken: p.accessToken, scopes: [...p.scopes] };
+    });
+    signal?.throwIfAborted();
+    return result;
+  } };
+}
+async function signOutChatGptPlan(profileId, homeDir, transport = {}) {
+  return locked(homeDir, async (store) => {
+    const p = store.profiles.find((row) => row.id === profileId);
+    if (!p) throw new Error("ChatGPT connection not found.");
+    const pending = p.pendingRotation && typeof p.pendingRotation === "object" ? p.pendingRotation : void 0;
+    let refreshToken = p.refreshToken, unknownRotation = false;
+    if (pending?.refresh_token !== void 0) {
+      try {
+        refreshToken = credential(pending.refresh_token);
+      } catch {
+        unknownRotation = true;
+      }
+    }
+    let revoked = !refreshToken && !unknownRotation;
+    if (refreshToken) {
+      try {
+        const metadata2 = await siwcMetadata(transport);
+        const response = await (transport.fetch ?? fetch)(metadata2.revoke, { method: "POST", redirect: "error", signal: AbortSignal.timeout(15e3), headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ token: refreshToken, token_type_hint: "refresh_token", client_id: p.clientId }).toString() });
+        revoked = response.ok && !unknownRotation;
+      } catch {
+      }
+    }
+    const { accessToken: _access, refreshToken: _refresh, pendingRotation: _pending, ...metadata } = p;
+    store.profiles = store.profiles.map((row) => row.id === p.id ? { ...metadata, epoch: (p.epoch ?? 0) + 1, idToken: "", scopes: [], expiresAt: 0, status: "signed-out" } : row);
+    write(store, homeDir);
+    return { revoked };
+  });
+}
+
+// packages/cli/src/tui/model-preference.ts
+async function createSelectedRuntime(config, allowChatGptPlan = true) {
+  if (config.provider !== "chatgpt-plan") return createConsoleRuntime(config);
+  if (!allowChatGptPlan) throw new Error("Native ChatGPT plan sign-in is available only in a user-controlled local open-source runtime. Use an API key for hosted or shared workspaces.");
+  const connection = config.siwcConnection ?? getSiwcConnection(config.env?.HOME);
+  if (config.model) return createConsoleRuntime({ ...config, siwcConnection: connection });
+  const probe = createConsoleRuntime({ ...config, model: "probe", siwcConnection: connection });
+  const catalog = await probe.availableModelCatalog(AbortSignal.timeout(1e4));
+  if (!catalog.length) throw new Error("This ChatGPT connection returned no models. Check plan sharing in ChatGPT Settings.");
+  probe.reconfigure({ model: catalog[0].id });
+  return probe;
+}
+async function createPreferredConsoleRuntime(config, options = {}) {
+  const env = config.env ?? process.env;
+  const envModel = env["ZERO_MODEL"]?.trim();
+  const envProvider = env["ZERO_SELECTED_PROVIDER"]?.trim() || env["ZERO_PROVIDER"]?.trim() || env["ZERO_FORCE_PROVIDER"]?.trim();
+  const inherited = options.inheritedConnectionIdentity !== void 0;
+  const explicitChoice = !inherited && config.model !== void 0 || Boolean(envModel);
+  if (inherited && (envModel || envProvider)) config = { ...config, model: void 0, provider: void 0 };
+  if (config.provider === void 0 && envProvider) config = { ...config, provider: envProvider };
+  let runtime;
+  let retainedModel = false;
+  if (inherited && !envModel && !envProvider) {
+    runtime = await createSelectedRuntime({ ...config, model: void 0 }, options.allowChatGptPlan);
+    if (runtime.connectionIdentity() === options.inheritedConnectionIdentity) {
+      runtime.reconfigure({ model: config.model });
+      retainedModel = config.model !== void 0;
+    }
+  }
+  if (!explicitChoice && !retainedModel) {
+    const saved = getSettings().modelPreference;
+    if (saved && (config.provider === void 0 || config.provider === saved.providerId)) {
+      try {
+        const candidate = await createSelectedRuntime({ ...config, model: saved.model, provider: saved.providerId }, options.allowChatGptPlan);
+        if (candidate.connectionIdentity() === saved.connectionIdentity) {
+          runtime = candidate;
+          retainedModel = true;
+        }
+      } catch {
+      }
+    }
+  }
+  runtime ??= await createSelectedRuntime(config, options.allowChatGptPlan);
+  if (!explicitChoice && runtime.getConfigurationDiagnostics().provider === "chatgpt-codex") {
+    let catalog;
+    try {
+      catalog = await runtime.codexModelCatalog(AbortSignal.timeout(1e4));
+    } catch (error) {
+      options.onDiscoveryError?.(error);
+      if (error instanceof CodexCatalogRefreshError) catalog = error.cachedModels;
+      else if (!retainedModel) throw error;
+    }
+    if (catalog) {
+      if (!catalog.length) throw new Error("This ChatGPT subscription returned no available models.");
+      const currentModel = runtime.resolvedModel();
+      if (!retainedModel || !catalog.some((model) => model.id === currentModel)) {
+        runtime.reconfigure({ model: catalog[0].id });
+      }
+    }
+  }
+  return { runtime, explicitChoice };
+}
+function saveAppliedModelPreference(runtime) {
+  const connectionIdentity = runtime.connectionIdentity();
+  if (!connectionIdentity) return false;
+  const preference = {
+    providerId: runtime.getConfigurationDiagnostics().provider,
+    model: runtime.resolvedModel(),
+    connectionIdentity
+  };
+  return updateSetting("modelPreference", preference, { scope: "global" });
+}
+
+// packages/cli/src/tui/model-catalog-sync.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// packages/cli/src/tui/model-catalog.offline.ts
+var OFFLINE_MODEL_CATALOG = [
+  // Anthropic
+  { id: "claude-fable-5-1", provider: "anthropic", contextTokens: 1e6, input: 10, output: 50 },
+  { id: "claude-opus-5", provider: "anthropic", contextTokens: 1e6, input: 5, output: 25 },
+  { id: "claude-sonnet-5", provider: "anthropic", contextTokens: 1e6, input: 2, output: 10 },
+  { id: "claude-opus-4-7", provider: "anthropic", contextTokens: 2e5, input: 5, output: 25 },
+  { id: "claude-sonnet-4-6", provider: "anthropic", contextTokens: 1e6, input: 3, output: 15 },
+  { id: "claude-haiku-4-5", provider: "anthropic", contextTokens: 2e5, input: 0.8, output: 4 },
+  // OpenAI
+  // Astra standard short-context rates; >272K input has a separate price tier.
+  { id: "gpt-6-astra", provider: "openai", contextTokens: 105e4, input: 10, output: 50 },
+  { id: "gpt-6.1-sol", provider: "openai", contextTokens: 105e4, input: 2, output: 10 },
+  { id: "gpt-6-sol", provider: "openai", contextTokens: 105e4, input: 2, output: 10 },
+  { id: "gpt-6-luna", provider: "openai", contextTokens: 105e4, input: 0.1, output: 0.5 },
+  { id: "gpt-5.5", provider: "openai", contextTokens: 4e5, input: 5, output: 30 },
+  { id: "gpt-5.6-sol", provider: "openai", contextTokens: 105e4 },
+  { id: "gpt-5.6-terra", provider: "openai", contextTokens: 105e4 },
+  { id: "gpt-5.6-luna", provider: "openai", contextTokens: 105e4 },
+  // Google
+  { id: "gemini-3.8-flash", provider: "google", contextTokens: 1048576, input: 0.75, output: 3.75 },
+  { id: "gemini-3.5-flash-lite", provider: "google", contextTokens: 1048576, input: 0.3, output: 2.5 },
+  { id: "gemini-3.1-pro-preview", provider: "google", contextTokens: 1048576, input: 2, output: 12 },
+  // DeepSeek
+  { id: "deepseek-flash", provider: "deepseek", contextTokens: 1e6, input: 0.3, output: 1.2 },
+  // Meta (hosted)
+  { id: "llama-4-maverick", provider: "meta", contextTokens: 1e6, input: 0.5, output: 0.77 },
+  { id: "llama-4-scout", provider: "meta", contextTokens: 1e7, input: 0.2, output: 0.35 },
+  // Mistral
+  { id: "mistral-large", provider: "mistral", contextTokens: 128e3, input: 2, output: 6 },
+  // Alibaba Qwen
+  { id: "qwen3.8-max", provider: "qwen", contextTokens: 1e6, input: 2, output: 6 },
+  { id: "qwen3.8-flash", provider: "qwen", contextTokens: 1e6, input: 0.15, output: 0.47 },
+  { id: "qwen3.8-max-preview", provider: "qwen", contextTokens: 1e6 },
+  { id: "qwen3.7-max", provider: "qwen", contextTokens: 1e6, input: 2.5, output: 7.5 },
+  { id: "qwen3.7-plus", provider: "qwen", contextTokens: 1e6, input: 0.5, output: 3 },
+  { id: "qwen3.6-plus", provider: "qwen", contextTokens: 1e6, input: 0.5, output: 3 },
+  { id: "qwen3.6-flash", provider: "qwen", contextTokens: 1e6, input: 0.1875, output: 1.125 },
+  // xAI
+  { id: "grok-4.6", provider: "xai", contextTokens: 5e5, input: 2, output: 6 },
+  // Moonshot
+  { id: "k3", provider: "moonshot", contextTokens: 1048576, input: 3, output: 15 },
+  // Z.AI
+  { id: "glm-5.3", provider: "z-ai", contextTokens: 1e6, input: 1.4, output: 4.4 },
+  { id: "glm-5.3-flash", provider: "z-ai", contextTokens: 1e6, input: 0.15, output: 0.5 }
+];
+
+// packages/cli/src/tui/model-catalog-sync.ts
+var MODELS_DEV_URL = "https://models.dev/api.json";
+var CATALOG_CACHE_FILENAME = "model-catalog.json";
+var CATALOG_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 8e3;
+var CATALOG_PROVIDER_IDS = {
+  "alibaba-token-plan": "qwen",
+  "kimi-code-plan-cn": "kimi",
+  "github-copilot": "copilot",
+  zai: "z-ai",
+  "cline-pass": "cline"
+};
+var METERED_CATALOG_PROVIDERS = {
+  anthropic: true,
+  openai: true,
+  deepseek: true,
+  openrouter: true,
+  xai: true,
+  opencode: true,
+  cline: true
+};
+function catalogId(value) {
+  return typeof value === "string" && value.length > 0 && !/[\s\x00-\x1f\x7f-\x9f]/.test(value);
+}
+function finiteRate(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function contextTokens(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function normalizedModel(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const row = value;
+  if (!catalogId(row.id) || !catalogId(row.provider) || row.provider === "chatgpt-codex") return null;
+  const provider2 = Object.hasOwn(CATALOG_PROVIDER_IDS, row.provider) ? CATALOG_PROVIDER_IDS[row.provider] ?? row.provider : row.provider;
+  const model = {
+    id: row.provider === "cline-pass" && !row.id.startsWith("cline-pass/") ? `cline-pass/${row.id}` : row.id,
+    provider: provider2,
+    ...finiteRate(row.input) ? { input: row.input } : {},
+    ...finiteRate(row.output) ? { output: row.output } : {},
+    ...finiteRate(row.cachedInput) ? { cachedInput: row.cachedInput } : {},
+    ...contextTokens(row.contextTokens) ? { contextTokens: row.contextTokens } : {}
+  };
+  if (!(provider2 === "cline" && model.id.startsWith("cline-pass/")) && Object.hasOwn(METERED_CATALOG_PROVIDERS, provider2) && model.input !== void 0 && model.output !== void 0) {
+    const rates = { input: model.input, output: model.output, cachedInput: model.cachedInput };
+    registerModelPricing(`${provider2}/${model.id}`, rates);
+    if (provider2 === modelProvider(model.id)) registerModelPricing(model.id, rates);
+  }
+  return model;
+}
+function catalogCachePath(opts = {}) {
+  return opts.cachePath ?? join2(homeStateDir(), CATALOG_CACHE_FILENAME);
+}
+function normalizeModelsDev(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return [];
+  const out = [];
+  for (const [providerId, providerVal] of Object.entries(raw)) {
+    if (!catalogId(providerId) || typeof providerVal !== "object" || providerVal === null || Array.isArray(providerVal)) continue;
+    const models = providerVal["models"];
+    if (typeof models !== "object" || models === null || Array.isArray(models)) continue;
+    for (const [modelId, modelVal] of Object.entries(models)) {
+      if (!catalogId(modelId) || typeof modelVal !== "object" || modelVal === null || Array.isArray(modelVal)) continue;
+      const m = modelVal;
+      const cost = typeof m["cost"] === "object" && m["cost"] !== null ? m["cost"] : {};
+      const limit = typeof m["limit"] === "object" && m["limit"] !== null ? m["limit"] : {};
+      const entry = normalizedModel({
+        id: modelId,
+        provider: providerId,
+        input: cost["input"],
+        output: cost["output"],
+        cachedInput: cost["cache_read"],
+        contextTokens: limit["context"]
+      });
+      if (entry) out.push(entry);
+    }
+  }
+  return out;
+}
+function readCache(path) {
+  try {
+    if (!existsSync2(path)) return null;
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.models) || !Number.isFinite(parsed.fetchedAt) || parsed.fetchedAt < 0 || typeof parsed.source !== "string") {
+      return null;
+    }
+    const cache2 = parsed;
+    const models = cache2.models.flatMap((row) => {
+      const model = normalizedModel(row);
+      return model ? [model] : [];
+    });
+    return { fetchedAt: cache2.fetchedAt, source: cache2.source, models };
+  } catch {
+    return null;
+  }
+}
+function writeCache(path, cache2) {
+  try {
+    mkdirSync2(dirname(path), { recursive: true });
+    writeFileSync2(path, JSON.stringify(cache2, null, 2), { mode: 384 });
+  } catch {
+  }
+}
+function isCacheFresh(cache2, opts = {}) {
+  if (!cache2) return false;
+  const now = (opts.now ?? Date.now)();
+  const ttl = opts.ttlMs ?? CATALOG_TTL_MS;
+  const age = now - cache2.fetchedAt;
+  return Number.isFinite(age) && age >= 0 && age < ttl;
+}
+function loadCatalogModels(opts = {}) {
+  const cache2 = readCache(catalogCachePath(opts));
+  if (cache2 && cache2.models.length > 0) return cache2;
+  return { fetchedAt: 0, source: "offline", models: OFFLINE_MODEL_CATALOG };
+}
+async function syncModelCatalog(opts = {}) {
+  const path = catalogCachePath(opts);
+  const existing = readCache(path);
+  if (!opts.force && isCacheFresh(existing, opts) && (existing?.models.length ?? 0) > 0) {
+    return existing;
+  }
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") return null;
+  const url = opts.url ?? MODELS_DEV_URL;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetchImpl(url, { signal: controller.signal });
+    if (!res.ok) return null;
+    const json = await res.json();
+    const models = normalizeModelsDev(json);
+    if (models.length === 0) return null;
+    const cache2 = {
+      fetchedAt: (opts.now ?? Date.now)(),
+      source: url,
+      models
+    };
+    writeCache(path, cache2);
+    return cache2;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// packages/cli/src/tui/model-catalog.ts
+var NON_MODEL_PRICING_KEYS = /* @__PURE__ */ new Set(["default"]);
+function compareStrings(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+function formatRate(value) {
+  return String(Number(value.toFixed(4)));
+}
+function formatModelPrice(input, output) {
+  if (input === 0 && output === 0) return "free";
+  return `$${formatRate(input)}/${formatRate(output)} per M`;
+}
+function buildModelCatalog(currentModel) {
+  const models = Object.keys(MODEL_PRICING).filter((id) => !NON_MODEL_PRICING_KEYS.has(id)).map((id) => {
+    const provider2 = modelProvider(id);
+    const rates = getRates(Object.hasOwn(METERED_CATALOG_PROVIDERS, provider2) ? `${provider2}/${id}` : id);
+    return { id, provider: provider2, price: provider2 === "cline" && id.startsWith("cline-pass/") ? "ClinePass plan (access unverified)" : formatModelPrice(rates.input, rates.output) };
+  });
+  return models.sort((a, b) => {
+    if (a.id === currentModel) return b.id === currentModel ? 0 : -1;
+    if (b.id === currentModel) return 1;
+    return compareStrings(a.provider, b.provider) || compareStrings(a.id, b.id);
+  });
+}
+var PLAN_PROVIDERS = {
+  kimi: true,
+  qwen: true,
+  "z-ai": true,
+  copilot: true,
+  google: true
+};
+function compareCatalogRows(currentModel) {
+  return (a, b) => {
+    if (a.id === currentModel) return b.id === currentModel ? 0 : -1;
+    if (b.id === currentModel) return 1;
+    return compareStrings(a.provider, b.provider) || compareStrings(a.id, b.id);
+  };
+}
+function catalogExtras(opts = {}) {
+  const priced = new Set(Object.keys(MODEL_PRICING).map((k) => k.toLowerCase()));
+  const out = [];
+  for (const m of loadCatalogModels(opts).models) {
+    if (priced.has(m.id.toLowerCase()) && m.provider === modelProvider(m.id)) continue;
+    const plan = Object.hasOwn(PLAN_PROVIDERS, m.provider) || m.provider === "cline" && m.id.startsWith("cline-pass/");
+    let price = m.provider === "cline" && plan ? "ClinePass plan (access unverified)" : plan ? "subscription" : "\u2014";
+    if (!plan && m.input !== void 0 && m.output !== void 0) {
+      const rates = Object.hasOwn(METERED_CATALOG_PROVIDERS, m.provider) ? getRates(`${m.provider}/${m.id}`) : { input: m.input, output: m.output };
+      price = formatModelPrice(rates.input, rates.output);
+    }
+    out.push({ id: m.id, provider: m.provider, price });
+  }
+  return out;
+}
+function buildFullModelCatalog(currentModel, opts = {}) {
+  const extras = catalogExtras(opts);
+  const priced = buildModelCatalog(currentModel);
+  const models = [...priced, ...extras];
+  if (currentModel && !models.some((model) => model.id === currentModel)) {
+    models.push({ id: currentModel, provider: modelProvider(currentModel), price: "\u2014" });
+  }
+  return models.sort(compareCatalogRows(currentModel));
+}
+
+// packages/cli/src/tui/available-models.ts
+var DISCOVERY_TIMEOUT_MS = 1e4;
+async function boundedCatalog(operation, callerSignal) {
+  const deadline = new AbortController();
+  const signal = callerSignal ? AbortSignal.any([callerSignal, deadline.signal]) : deadline.signal;
+  const timer = setTimeout(() => deadline.abort(), DISCOVERY_TIMEOUT_MS);
+  let onAbort;
+  try {
+    return await new Promise((resolve4, reject) => {
+      onAbort = () => reject(new Error(deadline.signal.aborted ? "Model discovery timed out. Retry this connection." : "Model discovery cancelled."));
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return operation(signal);
+      }).then(resolve4, reject);
+    });
+  } finally {
+    clearTimeout(timer);
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+async function discoverConnectionModels(env, providerIds, signal) {
+  const results = await Promise.all(providerIds.map(async (providerId) => {
+    try {
+      const models = await boundedCatalog(async (discoverySignal) => {
+        const runtime = new LlmApiRuntime({
+          type: "api",
+          timeout: DISCOVERY_TIMEOUT_MS,
+          provider: providerId,
+          model: "probe",
+          ...providerId === "chatgpt-plan" ? { siwcConnection: getSiwcConnection(env.HOME) } : {},
+          env: { ...env, ZERO_SKIP_PROVIDER_BANNER: "1" }
+        });
+        return runtime.availableModelCatalog(discoverySignal);
+      }, signal);
+      return { models: models.map((model) => ({ ...model, provider: providerId })), diagnostics: [] };
+    } catch (error) {
+      let message2 = error instanceof Error ? error.message : "Model discovery failed.";
+      for (const [name, value] of Object.entries(env)) {
+        if (value && /KEY|TOKEN|SECRET|PASSWORD/i.test(name)) message2 = message2.split(value).join("[redacted]");
+      }
+      return { models: [], diagnostics: [{ providerId, message: message2.slice(0, 1e3) }] };
+    }
+  }));
+  return { models: results.flatMap((result) => result.models), diagnostics: results.flatMap((result) => result.diagnostics) };
+}
+
+// packages/cli/src/tui/context-window.ts
+var KNOWN_FAMILY_WINDOWS = [
+  ["gpt-5", 272e3],
+  ["gpt-4.1", 1047576],
+  ["gpt-4o", 128e3],
+  ["o3", 2e5],
+  ["o4", 2e5],
+  ["claude", 2e5],
+  ["glm-5", 2e5],
+  ["glm-4", 128e3],
+  ["gemini-2.5", 1048576],
+  ["gemini-2", 1e6],
+  ["deepseek", 128e3],
+  ["qwen", 128e3]
+];
+function knownFamilyWindow(modelId) {
+  const id = modelId.toLowerCase();
+  let best = null;
+  let bestLen = -1;
+  for (const [prefix, tokens] of KNOWN_FAMILY_WINDOWS) {
+    if (id.startsWith(prefix) && prefix.length > bestLen) {
+      best = tokens;
+      bestLen = prefix.length;
+    }
+  }
+  return best;
+}
+function positiveTokens(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function sameByokModel(row, identity) {
+  return row.id === identity.modelId && row.provider === identity.providerId;
+}
+function resolveContextLimit(identity, opts = {}) {
+  if (!identity.modelId || !identity.providerId) return null;
+  const familyFallback = () => {
+    const family = knownFamilyWindow(identity.modelId);
+    return family === null ? null : { tokens: family, source: "known-family" };
+  };
+  const load = opts.loadModels ?? loadCatalogModels;
+  const cache2 = load(opts.sync ?? {});
+  const row = cache2.models.find((model) => sameByokModel(model, identity));
+  const tokens = row ? positiveTokens(row.contextTokens) : null;
+  if (tokens !== null) {
+    return { tokens, source: cache2.source === "offline" ? "offline-catalog" : "synced-catalog" };
+  }
+  return familyFallback();
+}
+
+// packages/cli/src/tui/device-auth.ts
+import { createHash as createHash2, randomBytes as randomBytes2, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { createServer as createServer2 } from "node:http";
+import { arch, hostname, platform as platform2, release, version as osVersion } from "node:os";
+import { join as join3 } from "node:path";
+
+// packages/cli/src/open-browser.ts
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+function defaultOpenBrowser(url) {
+  const plat = platform();
+  return new Promise((resolve4, reject) => {
+    const options = { detached: true, stdio: "ignore", shell: false };
+    const child = plat === "darwin" ? spawn("open", [url], options) : plat === "win32" ? spawn("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      "Start-Process -FilePath $env:OSEC_BROWSER_LOGIN_URL"
+    ], { ...options, env: { ...process.env, OSEC_BROWSER_LOGIN_URL: url } }) : spawn("xdg-open", [url], options);
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve4();
+    });
+  });
+}
+
+// packages/cli/src/tui/text.ts
+var DEFAULT_ENCODED_RUN_MAX = 140;
+var ENCODED_RUN_MAX_CAP = 1e6;
+var ENCODED_PLACEHOLDER = "[encoded payload omitted]";
+var DEFAULT_ENCODED_SEGMENT = new RegExp(`[A-Za-z0-9+_-]{${DEFAULT_ENCODED_RUN_MAX},}={0,2}`, "g");
+var DEFAULT_ENCODED_DATA_URI = new RegExp(`(data:[^\\s,]*;base64,)[A-Za-z0-9+/_-]{${DEFAULT_ENCODED_RUN_MAX},}={0,2}`, "gi");
+function stripTerminalControl(text2) {
+  return text2.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+}
+function replaceLargeEncodedChunks(text2, maxEncodedRun) {
+  const normalized = Number.isFinite(maxEncodedRun) ? Math.trunc(maxEncodedRun) : DEFAULT_ENCODED_RUN_MAX;
+  const minRun = Math.min(Math.max(32, normalized), ENCODED_RUN_MAX_CAP);
+  if (text2.length < minRun) return text2;
+  const segment = minRun === DEFAULT_ENCODED_RUN_MAX ? DEFAULT_ENCODED_SEGMENT : new RegExp(`[A-Za-z0-9+_-]{${minRun},}={0,2}`, "g");
+  const dataUri = minRun === DEFAULT_ENCODED_RUN_MAX ? DEFAULT_ENCODED_DATA_URI : new RegExp(`(data:[^\\s,]*;base64,)[A-Za-z0-9+/_-]{${minRun},}={0,2}`, "gi");
+  return text2.replace(dataUri, `$1${ENCODED_PLACEHOLDER}`).replace(segment, ENCODED_PLACEHOLDER);
+}
+function sanitizeTuiText(value, options = {}) {
+  return stripTerminalControl(replaceLargeEncodedChunks(String(value ?? ""), options.maxEncodedRun ?? DEFAULT_ENCODED_RUN_MAX)).replace(/\s+/g, " ").trim();
+}
+function sanitizeComposerText(value) {
+  return stripTerminalControl(String(value ?? ""));
+}
+
+// packages/cli/src/tui/device-auth.ts
+var MAX_VISIBLE_LINES = 8;
+var DEFAULT_INTERVAL_SECONDS = 5;
+var SLOW_DOWN_INCREMENT_SECONDS = 5;
+var DEFAULT_EXPIRES_IN_SECONDS = 900;
+var defaultFetch = (url, init) => globalThis.fetch(url, init);
+var defaultSleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+var PKCE_TIMEOUT_SECONDS = 300;
+var base64url = (buffer) => buffer.toString("base64url");
+var defaultCreatePkcePair = () => {
+  const verifier = base64url(randomBytes2(32));
+  const challenge = base64url(createHash2("sha256").update(verifier).digest());
+  return { verifier, challenge };
+};
+var defaultServerFactory = async ({ onRedirect }) => {
+  let delivered = false;
+  const server = createServer2((req, res) => {
+    const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (requestUrl.pathname !== "/callback") {
+      res.statusCode = 404;
+      res.end("Not found");
+      return;
+    }
+    const code = requestUrl.searchParams.get("code") ?? void 0;
+    const error = requestUrl.searchParams.get("error") ?? void 0;
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.end("<!doctype html><meta charset=utf-8><title>0</title><body>Sign-in complete \u2014 you can close this tab and return to 0.</body>");
+    if (delivered) return;
+    delivered = true;
+    onRedirect({ code, error });
+  });
+  await new Promise((resolve4, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve4());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address !== null ? address.port : 0;
+  return { port, close: () => server.close() };
+};
+function providerLabel(providerId) {
+  return PROVIDERS.find((provider2) => provider2.id === providerId)?.label ?? providerId;
+}
+function positiveInt(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : fallback;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function startDeviceAuth(config, options) {
+  const env = options.env ?? process.env;
+  const transport = options.fetch ?? defaultFetch;
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? defaultSleep;
+  const openBrowser = options.openBrowser ?? defaultOpenBrowser;
+  const label = providerLabel(config.providerId);
+  const lines = [];
+  let settled = false;
+  let cancelled = false;
+  const controller = new AbortController();
+  let deadlineTimer;
+  const bounded = (work) => new Promise((resolve4, reject) => {
+    const abort = () => {
+      cleanup();
+      reject(controller.signal.reason);
+    };
+    const cleanup = () => controller.signal.removeEventListener("abort", abort);
+    if (controller.signal.aborted) {
+      abort();
+      return;
+    }
+    controller.signal.addEventListener("abort", abort, { once: true });
+    work.then((value) => {
+      cleanup();
+      resolve4(value);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+  const doFetch = async (url, init) => {
+    controller.signal.throwIfAborted();
+    const response = await bounded(transport(url, { ...init, signal: controller.signal }));
+    return { ...response, ok: response.ok, status: response.status, json: () => bounded(response.json()) };
+  };
+  const armDeadline = (ms) => {
+    if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+    deadlineTimer = setTimeout(() => {
+      finish("failed", `${label} sign-in timed out. Start again.`);
+      controller.abort(new Error("Sign-in timed out"));
+      cancelWaiter?.();
+    }, ms);
+    deadlineTimer.unref?.();
+  };
+  const pushLine = (text2) => {
+    const value = sanitizeTuiText(text2);
+    if (value.length === 0) return;
+    lines.push(value);
+    if (lines.length > MAX_VISIBLE_LINES) lines.shift();
+  };
+  const publish = (phase, message2) => {
+    if (settled && phase === "running") return;
+    options.onUpdate({ phase, lines: [...lines], message: message2 });
+  };
+  const finish = (phase, message2) => {
+    if (settled) return;
+    settled = true;
+    if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+    publish(phase, message2);
+  };
+  const requestDeviceCode = async (cfg) => {
+    const params = new URLSearchParams({ client_id: cfg.clientId });
+    if (cfg.scopes.length > 0) params.set("scope", cfg.scopes.join(" "));
+    const response = await doFetch(cfg.deviceCodeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        ...cfg.buildHeaders?.(options.homeDir)
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      throw new Error(`Device code request failed (HTTP ${response.status}).`);
+    }
+    const parsed = await response.json();
+    if (!isPlainObject(parsed) || typeof parsed.device_code !== "string" || typeof parsed.user_code !== "string") {
+      throw new Error("Device code response was missing a device_code or user_code.");
+    }
+    const verificationUri = typeof parsed.verification_uri === "string" ? parsed.verification_uri : typeof parsed.verification_uri_complete === "string" ? parsed.verification_uri_complete : void 0;
+    if (verificationUri === void 0) {
+      throw new Error("Device code response was missing a verification URL.");
+    }
+    return {
+      device_code: parsed.device_code,
+      user_code: parsed.user_code,
+      verification_uri: verificationUri,
+      verification_uri_complete: typeof parsed.verification_uri_complete === "string" ? parsed.verification_uri_complete : void 0,
+      interval: positiveInt(parsed.interval, DEFAULT_INTERVAL_SECONDS),
+      expires_in: positiveInt(parsed.expires_in, DEFAULT_EXPIRES_IN_SECONDS)
+    };
+  };
+  const pollTokenOnce = async (cfg, deviceCode) => {
+    const body = new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCode,
+      client_id: cfg.clientId
+    }).toString();
+    let response;
+    try {
+      response = await doFetch(cfg.tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json",
+          ...cfg.buildHeaders?.(options.homeDir)
+        },
+        body
+      });
+    } catch (error) {
+      return { kind: "failed", message: error instanceof Error ? error.message : String(error) };
+    }
+    let parsed;
+    try {
+      parsed = await response.json();
+    } catch {
+      return { kind: "failed", message: `Token response was not valid JSON (HTTP ${response.status}).` };
+    }
+    if (response.ok && isPlainObject(parsed) && typeof parsed.access_token === "string") {
+      return { kind: "token", response: parsed };
+    }
+    const oauthError = isPlainObject(parsed) && typeof parsed.error === "string" ? parsed.error : void 0;
+    switch (oauthError) {
+      case "authorization_pending":
+        return { kind: "pending" };
+      case "slow_down":
+        return { kind: "slow_down" };
+      case "expired_token":
+        return { kind: "failed", message: `${label} device sign-in code expired. Start again.` };
+      case "access_denied":
+        return { kind: "failed", message: `${label} device sign-in was denied.` };
+      default:
+        return {
+          kind: "failed",
+          message: oauthError ? `${label} device sign-in failed: ${oauthError}.` : `${label} device sign-in failed (HTTP ${response.status}).`
+        };
+    }
+  };
+  const persist = (record, connectedMessage) => {
+    if (settled || cancelled || controller.signal.aborted) return;
+    const { store } = addAccount(loadAccountStore(options.homeDir), config.providerId, record);
+    if (!saveAccountStore(store, options.homeDir)) {
+      finish("failed", "Sign-in completed, but the private credential account store could not be saved. Try again after restoring access to the local state directory.");
+      return;
+    }
+    const patch = accountEnvPatch(store, env);
+    for (const [key, value] of Object.entries(patch)) env[key] = value;
+    finish("connected", connectedMessage);
+    options.onConnected();
+  };
+  const runDeviceCode = async (cfg) => {
+    publish("running", `Starting ${label} device sign-in\u2026`);
+    let device;
+    try {
+      device = await requestDeviceCode(cfg);
+    } catch (error) {
+      finish("failed", error instanceof Error ? error.message : String(error));
+      return;
+    }
+    if (cancelled) {
+      finish("cancelled", `${label} device sign-in cancelled.`);
+      return;
+    }
+    const openUrl = device.verification_uri_complete ?? device.verification_uri;
+    pushLine(`Enter code: ${device.user_code}`);
+    pushLine(`Visit: ${device.verification_uri}`);
+    publish("running", `Complete the ${label} device sign-in in your browser.`);
+    try {
+      await bounded(Promise.resolve(openBrowser(openUrl)));
+    } catch {
+      pushLine("Could not open a browser automatically; open the URL above.");
+      publish("running", `Complete the ${label} device sign-in in your browser.`);
+    }
+    if (settled) return;
+    let intervalSeconds = device.interval ?? DEFAULT_INTERVAL_SECONDS;
+    const deadline = now() + (device.expires_in ?? DEFAULT_EXPIRES_IN_SECONDS) * 1e3;
+    armDeadline(Math.max(0, deadline - now()));
+    while (!cancelled) {
+      if (options.sleep) await bounded(sleep(intervalSeconds * 1e3));
+      else await bounded(new Promise((resolve4, reject) => {
+        const abort = () => {
+          clearTimeout(timer);
+          reject(controller.signal.reason);
+        };
+        const timer = setTimeout(() => {
+          controller.signal.removeEventListener("abort", abort);
+          resolve4();
+        }, intervalSeconds * 1e3);
+        controller.signal.addEventListener("abort", abort, { once: true });
+      }));
+      if (cancelled) break;
+      if (now() >= deadline) {
+        finish("failed", `${label} device sign-in timed out. Start again.`);
+        return;
+      }
+      const result = await pollTokenOnce(cfg, device.device_code);
+      if (cancelled) break;
+      if (result.kind === "token") {
+        persist(cfg.toAccountRecord(result.response), `${label} connected through device sign-in.`);
+        return;
+      }
+      if (result.kind === "failed") {
+        finish("failed", result.message);
+        return;
+      }
+      if (result.kind === "slow_down") {
+        intervalSeconds += SLOW_DOWN_INCREMENT_SECONDS;
+      }
+    }
+    finish("cancelled", `${label} device sign-in cancelled.`);
+  };
+  const exchangeCode = async (cfg, code, verifier, redirectUri) => {
+    const useForm = cfg.exchangeBodyMode === "form";
+    const headers = useForm ? { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" } : { "Content-Type": "application/json", Accept: "application/json" };
+    const body = useForm ? new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      code_verifier: verifier,
+      redirect_uri: redirectUri,
+      ...cfg.clientId !== void 0 ? { client_id: cfg.clientId } : {},
+      ...cfg.clientSecret !== void 0 ? { client_secret: cfg.clientSecret } : {}
+    }).toString() : JSON.stringify({ code, code_verifier: verifier, code_challenge_method: "S256" });
+    let response;
+    try {
+      response = await doFetch(cfg.keysUrl, {
+        method: "POST",
+        headers,
+        body
+      });
+    } catch (error) {
+      return { kind: "failed", message: error instanceof Error ? error.message : String(error) };
+    }
+    let parsed;
+    try {
+      parsed = await response.json();
+    } catch {
+      return { kind: "failed", message: `${label} sign-in exchange was not valid JSON (HTTP ${response.status}).` };
+    }
+    if (!response.ok) {
+      const oauthError = isPlainObject(parsed) && typeof parsed.error === "string" ? parsed.error : void 0;
+      return {
+        kind: "failed",
+        message: oauthError ? `${label} browser sign-in failed: ${oauthError}.` : `${label} browser sign-in failed (HTTP ${response.status}).`
+      };
+    }
+    if (!isPlainObject(parsed)) {
+      return { kind: "failed", message: `${label} sign-in exchange returned an unexpected body.` };
+    }
+    return { kind: "ok", response: parsed };
+  };
+  const runPkceLoopback = async (cfg) => {
+    publish("running", `Starting ${label} browser sign-in\u2026`);
+    const { verifier, challenge } = (options.createPkcePair ?? defaultCreatePkcePair)();
+    const serverFactory = options.serverFactory ?? defaultServerFactory;
+    let resolveOutcome = () => {
+    };
+    const outcomePromise = new Promise((resolve4) => {
+      resolveOutcome = resolve4;
+    });
+    let server;
+    try {
+      server = await serverFactory({
+        onRedirect: (redirect) => resolveOutcome({ type: "redirect", redirect })
+      });
+    } catch (error2) {
+      finish("failed", `${label} browser sign-in could not start a local server: ${error2 instanceof Error ? error2.message : String(error2)}.`);
+      return;
+    }
+    cancelWaiter = () => resolveOutcome({ type: "cancelled" });
+    if (cancelled || settled) {
+      server.close();
+      finish("cancelled", `${label} browser sign-in cancelled.`);
+      return;
+    }
+    const redirectUri = `http://localhost:${server.port}/callback`;
+    const state = base64url(randomBytes2(16)).replace(/[^a-zA-Z0-9]/g, "").slice(0, 32);
+    const authorizeUrl = new URL(cfg.authorizeUrl);
+    authorizeUrl.searchParams.set(cfg.redirectParam ?? "redirect_uri", redirectUri);
+    authorizeUrl.searchParams.set("code_challenge", challenge);
+    authorizeUrl.searchParams.set("code_challenge_method", "S256");
+    if (cfg.clientId !== void 0) authorizeUrl.searchParams.set("client_id", cfg.clientId);
+    if (cfg.scopes.length > 0) authorizeUrl.searchParams.set("scope", cfg.scopes.join(" "));
+    for (const [key, value] of Object.entries(cfg.authorizeParams ?? {})) {
+      authorizeUrl.searchParams.set(key, value);
+    }
+    if (cfg.authorizeParams !== void 0) authorizeUrl.searchParams.set("state", state);
+    const openUrl = authorizeUrl.toString();
+    pushLine(`Sign in at: ${openUrl}`);
+    publish("running", `Complete the ${label} sign-in in your browser.`);
+    try {
+      await bounded(Promise.resolve(openBrowser(openUrl)));
+    } catch {
+      pushLine("Could not open a browser automatically; open the URL above.");
+      publish("running", `Complete the ${label} sign-in in your browser.`);
+    }
+    if (options.sleep) void bounded(sleep(PKCE_TIMEOUT_SECONDS * 1e3)).then(() => {
+      finish("failed", `${label} browser sign-in timed out. Start again.`);
+      controller.abort(new Error("Sign-in timed out"));
+      resolveOutcome({ type: "timeout" });
+    }, () => {
+    });
+    const outcome = await outcomePromise;
+    server.close();
+    if (outcome.type === "cancelled" || cancelled) {
+      finish("cancelled", `${label} browser sign-in cancelled.`);
+      return;
+    }
+    if (outcome.type === "timeout") {
+      finish("failed", `${label} browser sign-in timed out. Start again.`);
+      return;
+    }
+    const { code, error } = outcome.redirect;
+    if (error !== void 0) {
+      finish("failed", `${label} browser sign-in was denied: ${error}.`);
+      return;
+    }
+    if (code === void 0 || code.length === 0) {
+      finish("failed", `${label} browser sign-in did not return an authorization code.`);
+      return;
+    }
+    const result = await exchangeCode(cfg, code, verifier, redirectUri);
+    if (cancelled) {
+      finish("cancelled", `${label} browser sign-in cancelled.`);
+      return;
+    }
+    if (result.kind === "failed") {
+      finish("failed", result.message);
+      return;
+    }
+    let record;
+    try {
+      record = cfg.toAccountRecord(result.response);
+    } catch (error2) {
+      finish("failed", error2 instanceof Error ? error2.message : String(error2));
+      return;
+    }
+    persist(record, `${label} connected through browser sign-in.`);
+  };
+  let cancelWaiter;
+  armDeadline((config.kind === "pkce-loopback" ? PKCE_TIMEOUT_SECONDS : DEFAULT_EXPIRES_IN_SECONDS) * 1e3);
+  void (config.kind === "pkce-loopback" ? runPkceLoopback(config) : runDeviceCode(config)).catch((error) => {
+    finish(cancelled ? "cancelled" : "failed", cancelled ? `${label} sign-in cancelled.` : error instanceof Error ? error.message : "Sign-in failed.");
+  });
+  return {
+    cancel: () => {
+      if (settled || cancelled) return;
+      cancelled = true;
+      finish("cancelled", `${label} sign-in cancelled.`);
+      controller.abort(new Error("Sign-in cancelled"));
+      cancelWaiter?.();
+    }
+  };
+}
+var KIMI_DEVICE_ID_FILENAME = "kimi-device-id";
+function kimiDeviceId(homeDir) {
+  const idPath = join3(homeStateDir(homeDir), KIMI_DEVICE_ID_FILENAME);
+  try {
+    const existing = readFileSync3(idPath, "utf8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const deviceId = randomUUID2().replace(/-/g, "");
+  try {
+    mkdirSync3(homeStateDir(homeDir), { recursive: true });
+    writeFileSync3(idPath, `${deviceId}
+`, { mode: 384 });
+  } catch {
+  }
+  return deviceId;
+}
+function sanitizeHeaderValue(value, fallback = "unknown") {
+  const sanitized = value.replace(/[^\x20-\x7E]/g, "").trim();
+  return sanitized || fallback;
+}
+function kimiDeviceModel() {
+  const plat = platform2();
+  const label = plat === "darwin" ? "macOS" : plat === "win32" ? "Windows" : plat === "linux" ? "Linux" : plat;
+  return [label, release(), arch()].filter(Boolean).join(" ").trim();
+}
+function kimiFingerprintHeaders(homeDir) {
+  return {
+    "User-Agent": "0security",
+    "X-Msh-Platform": "0security",
+    "X-Msh-Version": "0",
+    "X-Msh-Device-Name": sanitizeHeaderValue(hostname()),
+    "X-Msh-Device-Model": sanitizeHeaderValue(kimiDeviceModel()),
+    "X-Msh-Os-Version": sanitizeHeaderValue(osVersion()),
+    "X-Msh-Device-Id": sanitizeHeaderValue(kimiDeviceId(homeDir))
+  };
+}
+function createProviderDeviceAuth(env = process.env) {
+  const clientId = (name) => env[name]?.trim() || void 0;
+  return {
+    // Endpoints use the provider protocol; client identity must be registered for 0.
+    ...clientId("ZERO_XAI_OAUTH_CLIENT_ID") ? { xai: {
+      kind: "device-code",
+      providerId: "xai",
+      deviceCodeUrl: "https://auth.x.ai/oauth2/device/code",
+      tokenUrl: "https://auth.x.ai/oauth2/token",
+      clientId: clientId("ZERO_XAI_OAUTH_CLIENT_ID"),
+      scopes: ["openid", "profile", "email", "offline_access", "grok-cli:access", "api:access"],
+      toAccountRecord: buildOAuthRecord
+    } } : {},
+    // Never borrow the official Kimi CLI client identity for a new 0 sign-in.
+    // Opt-in is only for an operator who has registered a client for 0.
+    ...clientId("ZERO_KIMI_OAUTH_CLIENT_ID") ? { kimi: {
+      kind: "device-code",
+      providerId: "kimi",
+      deviceCodeUrl: "https://auth.kimi.com/api/oauth/device_authorization",
+      tokenUrl: "https://auth.kimi.com/api/oauth/token",
+      clientId: clientId("ZERO_KIMI_OAUTH_CLIENT_ID"),
+      scopes: [],
+      buildHeaders: kimiFingerprintHeaders,
+      toAccountRecord: buildOAuthRecord
+    } } : {},
+    // Own GitHub app registration must also be entitled to the Copilot service.
+    ...clientId("ZERO_COPILOT_OAUTH_CLIENT_ID") ? { copilot: {
+      kind: "device-code",
+      providerId: "copilot",
+      deviceCodeUrl: "https://github.com/login/device/code",
+      tokenUrl: "https://github.com/login/oauth/access_token",
+      clientId: clientId("ZERO_COPILOT_OAUTH_CLIENT_ID"),
+      scopes: ["read:user"],
+      toAccountRecord: buildOAuthRecord
+    } } : {},
+    // Matches oh-my-pi rules/auth/openrouter.kdl (fetched 2026-09-14):
+    //   https://github.com/can1357/oh-my-pi/blob/main/packages/catalog/src/compat/rules/auth/openrouter.kdl
+    // login "oauth-code" pkce=#true, standard authorize params OFF: open
+    //   https://openrouter.ai/auth?callback_url=<loopback>&code_challenge=<c>&code_challenge_method=S256
+    // (CLIENT-ID-LESS — no client_id param), then POST JSON
+    //   { code, code_verifier, code_challenge_method: "S256" }
+    // to https://openrouter.ai/api/v1/auth/keys, which PROVISIONS a durable
+    // `sk-or-...` API key. The kdl's `credential { access "key" }` names the
+    // response field `key` (buildOpenRouterKeyRecord). Stored as an api_key record
+    // and written to OPENROUTER_API_KEY (envVars[0]) by accountEnvPatch, which
+    // llm-api already reads — so no llm-api change.
+    openrouter: {
+      kind: "pkce-loopback",
+      providerId: "openrouter",
+      authorizeUrl: "https://openrouter.ai/auth",
+      keysUrl: "https://openrouter.ai/api/v1/auth/keys",
+      redirectParam: "callback_url",
+      scopes: [],
+      toAccountRecord: buildOpenRouterKeyRecord
+    },
+    // Google browser sign-in requires a 0 registration entitled to Code Assist.
+    ...clientId("ZERO_GOOGLE_OAUTH_CLIENT_ID") ? { google: {
+      kind: "pkce-loopback",
+      providerId: "google",
+      authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+      keysUrl: "https://oauth2.googleapis.com/token",
+      clientId: clientId("ZERO_GOOGLE_OAUTH_CLIENT_ID"),
+      ...env.ZERO_GOOGLE_OAUTH_CLIENT_SECRET ? { clientSecret: env.ZERO_GOOGLE_OAUTH_CLIENT_SECRET } : {},
+      exchangeBodyMode: "form",
+      authorizeParams: { response_type: "code", access_type: "offline", prompt: "consent" },
+      scopes: [
+        "https://www.googleapis.com/auth/cloud-platform",
+        "https://www.googleapis.com/auth/userinfo.email",
+        "https://www.googleapis.com/auth/userinfo.profile"
+      ],
+      toAccountRecord: (tokenResponse) => ({
+        ...buildOAuthRecord(tokenResponse),
+        oauthClient: { clientId: clientId("ZERO_GOOGLE_OAUTH_CLIENT_ID"), ...env.ZERO_GOOGLE_OAUTH_CLIENT_SECRET ? { clientSecret: env.ZERO_GOOGLE_OAUTH_CLIENT_SECRET } : {} }
+      })
+    } } : {}
+  };
+}
+var PROVIDER_DEVICE_AUTH = createProviderDeviceAuth();
+function buildOAuthRecord(tokenResponse) {
+  const tokens = {};
+  if (typeof tokenResponse.access_token === "string") tokens.accessToken = tokenResponse.access_token;
+  if (typeof tokenResponse.refresh_token === "string") tokens.refreshToken = tokenResponse.refresh_token;
+  if (typeof tokenResponse.expires_in === "number" && Number.isFinite(tokenResponse.expires_in)) {
+    tokens.expiresAt = Date.now() + tokenResponse.expires_in * 1e3;
+  }
+  return { kind: "oauth", tokens };
+}
+function buildOpenRouterKeyRecord(exchange) {
+  const key = typeof exchange.key === "string" ? exchange.key : void 0;
+  if (key === void 0 || key.length === 0) {
+    throw new Error("OpenRouter sign-in did not return an API key.");
+  }
+  return { kind: "api_key", secret: key };
+}
+
+// packages/cli/src/tui/plugin-service.ts
+import { chmodSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+function coreLoader(injected) {
+  if (typeof injected === "function") return injected;
+  if (injected) return async () => injected;
+  let cached;
+  return () => {
+    if (!cached) cached = import("./dist-ONIRKDH6.js");
+    return cached;
+  };
+}
+function defaultApplyTheme(themeId) {
+  try {
+    return updateSetting("theme", themeId) === true;
+  } catch {
+    return false;
+  }
+}
+function createPluginService(deps = {}) {
+  const getCore = coreLoader(deps.core);
+  const homeDir = deps.homeDir;
+  const projectPath = deps.projectPath ?? process.cwd();
+  const now = deps.now ?? Date.now;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const isTurnActive2 = deps.isTurnActive ?? (() => false);
+  const applyTheme = deps.applyTheme ?? defaultApplyTheme;
+  const reservedToolNames2 = deps.reservedToolNames;
+  const registryUrl = (deps.registryUrl ?? "").trim();
+  const manager = deps.pluginHostManager;
+  let host;
+  const deferred = [];
+  async function core() {
+    return getCore();
+  }
+  function installedViews(c, root, ids) {
+    const views = [];
+    for (const id of ids) {
+      let disc;
+      try {
+        disc = c.readInstalledPlugin(root, id, reservedToolNames2 ? { reservedToolNames: reservedToolNames2 } : void 0);
+      } catch {
+        continue;
+      }
+      if (!disc.ok || !disc.plugin) continue;
+      const manifest = disc.plugin.manifest;
+      views.push({
+        id,
+        version: manifest.version,
+        capabilities: c.aggregateCapabilities(manifest)
+      });
+    }
+    return views;
+  }
+  async function fetchRegistry() {
+    try {
+      const c = await core();
+      const fetched = await c.fetchRegistryIndex(registryUrl, {
+        fetchImpl,
+        verifier: c.unconfiguredVerifier
+      });
+      if (!fetched.ok) return { ok: false, error: fetched.error };
+      return { ok: true, result: fetched.result };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  async function list(activeTheme) {
+    const themes = /* @__PURE__ */ new Set();
+    try {
+      for (const entry of installedThemeEntries(homeDir)) themes.add(entry.name);
+    } catch {
+    }
+    const plugins = /* @__PURE__ */ new Map();
+    try {
+      const c = await core();
+      const root = c.pluginsRootDir(homeDir);
+      const ids = c.listInstalledPluginIds(root);
+      const record = c.readEnablement(projectPath, homeDir);
+      const loadable = new Set(c.loadableIds(c.reconcile(record, installedViews(c, root, ids))));
+      for (const id of ids) {
+        plugins.set(id, loadable.has(id) ? "enabled" : "installed");
+      }
+    } catch {
+    }
+    return { themes, activeTheme, plugins };
+  }
+  function installTheme(item) {
+    if (!isSafeThemeId(item.id)) {
+      return { ok: false, message: `"${item.id}" is not a valid theme id; refused.` };
+    }
+    const theme = item.raw?.manifest?.theme;
+    const palette = theme?.palette;
+    if (!palette || typeof palette !== "object") {
+      return { ok: false, message: `Theme "${item.id}" is missing its palette.` };
+    }
+    if (validateTheme(palette).length > 0) {
+      return { ok: false, message: `Theme "${item.id}" has an invalid palette; refused.` };
+    }
+    const written = writeInstalledTheme(
+      {
+        id: item.id,
+        label: theme.label,
+        description: theme.description,
+        mode: theme.mode,
+        palette
+      },
+      homeDir
+    );
+    if (!written.ok) return { ok: false, message: `Could not install "${item.id}": ${written.error}` };
+    reloadInstalledThemes(homeDir);
+    return {
+      ok: true,
+      message: `Installed theme ${item.id}. Select it to apply.`,
+      state: "installed"
+    };
+  }
+  async function installPlugin(item) {
+    const entry = item.raw;
+    try {
+      const c = await core();
+      if (!c.isSafePluginId(item.id)) {
+        return { ok: false, message: `"${item.id}" is not a valid plugin id; refused.` };
+      }
+      const entryBody = entry.files?.[c.PLUGIN_ENTRY_FILE];
+      if (typeof entryBody !== "string") {
+        return { ok: false, message: `Registry entry is missing its ${c.PLUGIN_ENTRY_FILE}.` };
+      }
+      const root = c.pluginsRootDir(homeDir);
+      if (!c.ensurePluginsRoot(root)) {
+        return { ok: false, message: `Could not create the plugins root at ${root}.` };
+      }
+      const dir = join4(root, item.id);
+      mkdirSync4(dir, { recursive: true, mode: c.PLUGIN_DIR_MODE });
+      chmodSync(dir, c.PLUGIN_DIR_MODE);
+      const manifestPath = join4(dir, c.PLUGIN_MANIFEST_FILE);
+      writeFileSync4(manifestPath, `${JSON.stringify(entry.manifest, null, 2)}
+`, {
+        mode: c.PLUGIN_FILE_MODE
+      });
+      chmodSync(manifestPath, c.PLUGIN_FILE_MODE);
+      const entryPath = join4(dir, c.PLUGIN_ENTRY_FILE);
+      writeFileSync4(entryPath, entryBody, { mode: c.PLUGIN_FILE_MODE });
+      chmodSync(entryPath, c.PLUGIN_FILE_MODE);
+      return {
+        ok: true,
+        message: `Installed ${item.id}. NOT enabled \u2014 select it again to enable it.`,
+        state: "installed"
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        message: `Could not install "${item.id}": ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  async function install(item) {
+    return item.kind === "theme" ? installTheme(item) : installPlugin(item);
+  }
+  async function enable(item) {
+    if (item.kind !== "plugin") {
+      return { ok: false, message: "Only a plugin can be enabled.", capabilities: [] };
+    }
+    try {
+      const c = await core();
+      if (!c.isSafePluginId(item.id)) {
+        return { ok: false, message: `"${item.id}" is not a valid plugin id; refused.`, capabilities: [] };
+      }
+      const root = c.pluginsRootDir(homeDir);
+      const disc = c.readInstalledPlugin(
+        root,
+        item.id,
+        reservedToolNames2 ? { reservedToolNames: reservedToolNames2 } : void 0
+      );
+      if (!disc.ok || !disc.plugin) {
+        const why = disc.errors?.join("; ") ?? "not installed";
+        return { ok: false, message: `Cannot enable ${item.id}: ${why}. Install it first.`, capabilities: [] };
+      }
+      const manifest = disc.plugin.manifest;
+      const capabilities = c.aggregateCapabilities(manifest);
+      const record = c.readEnablement(projectPath, homeDir);
+      const result = c.enable(record, item.id, {
+        version: manifest.version,
+        capabilities,
+        now: now()
+      });
+      if (!result.ok) {
+        return { ok: false, message: `Cannot enable ${item.id}: ${result.error}`, capabilities: [] };
+      }
+      if (!c.writeEnablement(projectPath, result.record, homeDir)) {
+        return {
+          ok: false,
+          message: `Could not persist the enablement approval for ${item.id}.`,
+          capabilities: []
+        };
+      }
+      const capText = capabilities.length > 0 ? capabilities.join(", ") : "no capabilities";
+      return {
+        ok: true,
+        message: `Enabled ${item.id} for this project (approved: ${capText}). Select it again to run it.`,
+        capabilities,
+        state: "enabled"
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        message: `Could not enable "${item.id}": ${error instanceof Error ? error.message : String(error)}`,
+        capabilities: []
+      };
+    }
+  }
+  async function loadEnabled(c, pluginId) {
+    if (manager) {
+      const result2 = await manager.runPlugin(pluginId);
+      if (result2.ok) {
+        const tools = result2.tools ?? [];
+        const toolText = tools.length > 0 ? `tools: ${tools.join(", ")}` : "no tools";
+        return { ok: true, message: `Loaded ${pluginId} (${toolText}).`, state: "enabled" };
+      }
+      return {
+        ok: false,
+        message: `Could not load ${pluginId}: ${result2.errors?.join("; ") ?? "unknown error"}`
+      };
+    }
+    if (!host) {
+      const root = c.pluginsRootDir(homeDir);
+      const record = c.readEnablement(projectPath, homeDir);
+      const loadable = c.loadableIds(c.reconcile(record, installedViews(c, root, c.listInstalledPluginIds(root))));
+      host = deps.hostFactory ? deps.hostFactory({ homeDir, enabled: loadable, reservedToolNames: reservedToolNames2, coreVersion: deps.coreVersion }) : new c.PluginHost({ homeDir, enabled: loadable, reservedToolNames: reservedToolNames2, coreVersion: deps.coreVersion });
+    }
+    const result = await host.load(pluginId);
+    if (result.ok) {
+      const tools = result.tools ?? [];
+      const toolText = tools.length > 0 ? `tools: ${tools.join(", ")}` : "no tools";
+      return { ok: true, message: `Loaded ${pluginId} (${toolText}).`, state: "enabled" };
+    }
+    return { ok: false, message: `Could not load ${pluginId}: ${result.errors?.join("; ") ?? "unknown error"}` };
+  }
+  async function run(item) {
+    if (item.kind !== "plugin") {
+      return { ok: false, message: "Only a plugin can be run." };
+    }
+    try {
+      const c = await core();
+      const root = c.pluginsRootDir(homeDir);
+      const record = c.readEnablement(projectPath, homeDir);
+      const loadable = new Set(
+        c.loadableIds(c.reconcile(record, installedViews(c, root, c.listInstalledPluginIds(root))))
+      );
+      if (!loadable.has(item.id)) {
+        return {
+          ok: false,
+          message: `${item.id} is not enabled (or its capabilities changed since approval) \u2014 enable it first.`
+        };
+      }
+      if (isTurnActive2()) {
+        if (!deferred.includes(item.id)) deferred.push(item.id);
+        return {
+          ok: false,
+          deferred: true,
+          message: `A turn is in progress; loading ${item.id} is deferred to the next turn boundary.`
+        };
+      }
+      return await loadEnabled(c, item.id);
+    } catch (error) {
+      return { ok: false, message: `Could not run "${item.id}": ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
+  async function flushDeferred() {
+    if (deferred.length === 0) return [];
+    const ids = deferred.splice(0, deferred.length);
+    const results = [];
+    try {
+      const c = await core();
+      for (const id of ids) results.push(await loadEnabled(c, id));
+    } catch (error) {
+      for (const id of ids) {
+        results.push({
+          ok: false,
+          message: `Could not load ${id}: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    }
+    return results;
+  }
+  async function activateTheme(item) {
+    if (item.kind !== "theme") {
+      return { ok: false, message: "Only a theme can be applied." };
+    }
+    if (!isSafeThemeId(item.id)) {
+      return { ok: false, message: `"${item.id}" is not a valid theme id; refused.` };
+    }
+    try {
+      reloadInstalledThemes(homeDir);
+    } catch {
+    }
+    const applied = applyTheme(item.id);
+    if (!applied) {
+      return { ok: false, message: `Could not apply theme ${item.id}.` };
+    }
+    return { ok: true, message: `Applied theme ${item.id}.`, state: "active" };
+  }
+  return { fetchRegistry, list, install, enable, run, activateTheme, flushDeferred };
+}
+
+// packages/cli/src/tui/dialog-select-layout.ts
+var NO_MATCH = Number.POSITIVE_INFINITY;
+
+// packages/cli/src/tui/settings-layout.ts
+var DIALOG_HOST_FOOTER_ROWS = 1;
+var SETTINGS_DIALOG_HOST_ROWS = DIALOG_HOST_FOOTER_ROWS + 1;
+
+// packages/cli/src/tui/market-layout.ts
+function signatureOf(state) {
+  return state === "verified" ? "verified" : "unverified";
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function pluginDescription(entry) {
+  const tools = Array.isArray(entry.manifest?.tools) ? entry.manifest?.tools ?? [] : [];
+  const named = tools.map((tool) => nonEmpty(tool?.name) ? tool.name.trim() : "").filter(Boolean);
+  if (named.length === 0) return "Tool plugin.";
+  const count = named.length;
+  return `${count} tool${count === 1 ? "" : "s"}: ${named.join(", ")}`;
+}
+function buildMarketItems(view) {
+  const items = [];
+  if (!view || typeof view !== "object") return items;
+  for (const entry of view.entries ?? []) {
+    if (!entry || typeof entry.id !== "string" || entry.id.length === 0) continue;
+    const version = typeof entry.version === "string" ? entry.version : "";
+    items.push({
+      kind: "plugin",
+      id: entry.id,
+      name: nonEmpty(entry.manifest?.name) ? entry.manifest.name.trim() : entry.id,
+      version,
+      description: sanitizeTuiText(pluginDescription(entry)),
+      capabilities: Array.isArray(entry.capabilities) ? entry.capabilities.filter((cap) => nonEmpty(cap)) : [],
+      signature: signatureOf(entry.signatureState),
+      raw: entry
+    });
+  }
+  for (const artifact of view.artifacts ?? []) {
+    if (!artifact || artifact.kind !== "theme") continue;
+    if (typeof artifact.id !== "string" || artifact.id.length === 0) continue;
+    const theme = artifact.manifest?.theme;
+    const version = typeof artifact.version === "string" ? artifact.version : "";
+    const name = nonEmpty(theme?.label) ? theme.label.trim() : nonEmpty(artifact.manifest?.name) ? artifact.manifest.name.trim() : artifact.id;
+    items.push({
+      kind: "theme",
+      id: artifact.id,
+      name,
+      version,
+      description: sanitizeTuiText(nonEmpty(theme?.description) ? theme.description : "Colour theme."),
+      capabilities: [],
+      signature: signatureOf(artifact.signatureState),
+      raw: artifact
+    });
+  }
+  return items;
+}
+
+// packages/cli/src/tui/session-plugin-host.ts
+function coreLoader2(injected) {
+  if (typeof injected === "function") return injected;
+  if (injected) return async () => injected;
+  let cached;
+  return () => {
+    if (!cached) cached = import("./dist-ONIRKDH6.js");
+    return cached;
+  };
+}
+async function createSessionPluginHostManager(deps = {}) {
+  const getCore = coreLoader2(deps.core);
+  const homeDir = deps.homeDir;
+  const projectPath = deps.projectPath ?? process.cwd();
+  const reservedToolNames2 = deps.reservedToolNames;
+  const coreVersion = deps.coreVersion;
+  const listeners = /* @__PURE__ */ new Set();
+  let host;
+  let loaded = /* @__PURE__ */ new Map();
+  let enabledKey = "";
+  const leases = /* @__PURE__ */ new Map();
+  let disposed = false;
+  let refreshTail = Promise.resolve();
+  function computeLoadable(c) {
+    const root = c.pluginsRootDir(homeDir);
+    const ids = c.listInstalledPluginIds(root);
+    const views = [];
+    for (const id of ids) {
+      let disc;
+      try {
+        disc = c.readInstalledPlugin(
+          root,
+          id,
+          reservedToolNames2 ? { reservedToolNames: reservedToolNames2 } : void 0
+        );
+      } catch {
+        continue;
+      }
+      if (!disc.ok || !disc.plugin) continue;
+      views.push({
+        id,
+        version: disc.plugin.manifest.version,
+        capabilities: c.aggregateCapabilities(disc.plugin.manifest)
+      });
+    }
+    const record = c.readEnablement(projectPath, homeDir);
+    return c.loadableIds(c.reconcile(record, views)).slice().sort();
+  }
+  function buildHost(c, enabled) {
+    return deps.hostFactory ? deps.hostFactory({ homeDir, enabled, reservedToolNames: reservedToolNames2, coreVersion }) : new c.PluginHost({ homeDir, enabled, reservedToolNames: reservedToolNames2, coreVersion });
+  }
+  async function loadAll(into, enabled, into_loaded) {
+    for (const id of enabled) {
+      try {
+        const r = await into.load(id);
+        if (r.ok) into_loaded.set(id, r.tools ?? []);
+      } catch {
+      }
+    }
+  }
+  async function reconstruct(c, enabled, emit) {
+    const next = buildHost(c, enabled);
+    const nextLoaded = /* @__PURE__ */ new Map();
+    await loadAll(next, enabled, nextLoaded);
+    if (disposed) {
+      next.shutdown?.();
+      throw new Error("Marketplace host manager is closed");
+    }
+    const old = host;
+    host = next;
+    loaded = nextLoaded;
+    enabledKey = enabled.slice().sort().join("\n");
+    if (old && !leases.has(old)) {
+      try {
+        old.shutdown?.();
+      } catch {
+      }
+    }
+    if (emit) {
+      const swapped = host;
+      for (const listener of [...listeners]) {
+        try {
+          listener(swapped);
+        } catch {
+        }
+      }
+    }
+  }
+  async function refresh() {
+    if (disposed) throw new Error("Marketplace host manager is closed");
+    const operation = refreshTail.then(async () => {
+      if (disposed) throw new Error("Marketplace host manager is closed");
+      const c = await getCore();
+      if (disposed) throw new Error("Marketplace host manager is closed");
+      const enabled = computeLoadable(c);
+      const key = enabled.join("\n");
+      if (host && key === enabledKey && (!leases.has(host) || enabled.every((id) => loaded.has(id)))) {
+        for (const id of enabled) {
+          if (loaded.has(id)) continue;
+          try {
+            const r = await host.load(id);
+            if (r.ok) loaded.set(id, r.tools ?? []);
+          } catch {
+          }
+        }
+        return;
+      }
+      await reconstruct(
+        c,
+        enabled,
+        /* emit */
+        host !== void 0
+      );
+    });
+    refreshTail = operation.catch(() => {
+    });
+    return operation;
+  }
+  async function runPlugin(pluginId) {
+    await refresh();
+    const tools = loaded.get(pluginId);
+    if (tools) return { ok: true, pluginId, tools };
+    return {
+      ok: false,
+      pluginId,
+      errors: [
+        `plugin "${pluginId}" is not loaded; it may be uninstalled, not enabled, or its capabilities changed since approval`
+      ]
+    };
+  }
+  function onChanged(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  function current() {
+    if (disposed || !host) throw new Error("Marketplace host manager is closed");
+    return host;
+  }
+  function acquire() {
+    const owned = current();
+    const pinned = host;
+    leases.set(pinned, (leases.get(pinned) ?? 0) + 1);
+    let released = false;
+    return {
+      host: owned,
+      release() {
+        if (released) return;
+        released = true;
+        const count = (leases.get(pinned) ?? 1) - 1;
+        if (count > 0) {
+          leases.set(pinned, count);
+          return;
+        }
+        leases.delete(pinned);
+        if (pinned !== host || disposed) pinned.shutdown?.();
+      }
+    };
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    listeners.clear();
+    const old = host;
+    host = void 0;
+    loaded = /* @__PURE__ */ new Map();
+    enabledKey = "";
+    if (old && !leases.has(old)) {
+      try {
+        old.shutdown?.();
+      } catch {
+      }
+    }
+  }
+  {
+    const c = await getCore();
+    await reconstruct(
+      c,
+      computeLoadable(c),
+      /* emit */
+      false
+    );
+  }
+  return { current, acquire, refresh, runPlugin, onChanged, dispose };
+}
+
+// packages/cli/src/web/chatgpt-plan-controller.ts
+var ChatGptPlanAuthController = class {
+  #options;
+  #abort;
+  #epoch = 0;
+  #status = { phase: "idle", message: "Connect your ChatGPT account.", lines: [], verificationUrl: null, userCode: null, available: true };
+  constructor(options = {}) {
+    this.#options = options;
+  }
+  status() {
+    if (this.#status.phase !== "running" && this.#status.phase !== "failed" && this.#status.phase !== "cancelled") {
+      const active = (this.#options.list ?? listChatGptPlanProfiles)(this.#options.homeDir).find((p) => p.active && p.status === "connected");
+      if (active) return { ...this.#status, phase: "connected", message: active.sharing ? "ChatGPT plan sharing is connected." : "ChatGPT identity is connected. Grant plan usage to use models.", lines: [], verificationUrl: null };
+    }
+    return { ...this.#status, lines: [...this.#status.lines] };
+  }
+  start(profileId) {
+    if (this.#abort) return this.status();
+    const epoch2 = ++this.#epoch, abort = new AbortController();
+    this.#abort = abort;
+    this.#status = { ...this.#status, phase: "running", message: "Starting ChatGPT sign-in.", verificationUrl: null, lines: [] };
+    void Promise.resolve().then(() => {
+      abort.signal.throwIfAborted();
+      return (this.#options.signIn ?? signInChatGptPlan)({
+        homeDir: this.#options.homeDir,
+        profileId,
+        signal: abort.signal,
+        onAuthorize: (value) => {
+          if (epoch2 !== this.#epoch || abort.signal.aborted) return;
+          const url = new URL(value);
+          if (url.protocol !== "https:" || url.hostname !== "auth.openai.com" || url.port || url.username || url.password || url.hash || ["access_token", "refresh_token", "id_token", "id_token_hint", "api_key"].some((key) => url.searchParams.has(key))) throw new Error("Unsafe authorization destination.");
+          this.#status = { ...this.#status, message: "Continue in your browser to connect ChatGPT.", verificationUrl: url.href };
+        }
+      });
+    }).then(() => {
+      if (epoch2 !== this.#epoch || abort.signal.aborted) return;
+      this.#status = { ...this.#status, phase: "connected", verificationUrl: null, message: "ChatGPT sign-in completed." };
+    }, () => {
+      if (epoch2 !== this.#epoch || abort.signal.aborted) return;
+      this.#status = { ...this.#status, phase: "failed", verificationUrl: null, message: "ChatGPT sign-in failed. Retry the connection." };
+    }).finally(() => {
+      if (epoch2 === this.#epoch) this.#abort = void 0;
+    });
+    return this.status();
+  }
+  cancel() {
+    ++this.#epoch;
+    this.#abort?.abort();
+    this.#abort = void 0;
+    this.#status = { ...this.#status, phase: "cancelled", message: "ChatGPT sign-in cancelled.", verificationUrl: null, lines: [] };
+    return this.status();
+  }
+};
+
+// packages/cli/src/web/codex-auth-controller.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+
+// packages/cli/src/tui/codex-device-auth.ts
+import { spawn as spawn2, spawnSync } from "node:child_process";
+var MAX_VISIBLE_LINES2 = 8;
+var CODEX_UNAVAILABLE_MESSAGE = "Codex CLI is not available on this console's PATH. Install Codex, or add its directory to PATH and restart 0.";
+function defaultSpawnCodexDeviceAuth(command, args, options) {
+  const child = spawn2(command, args, {
+    env: options.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (!child.stdout || !child.stderr) {
+    child.kill("SIGTERM");
+    throw new Error("Codex device OAuth did not expose output streams.");
+  }
+  return child;
+}
+function defaultProbeCodexExecutable(env) {
+  const result = spawnSync("codex", ["--version"], { env, stdio: "ignore" });
+  return result.error?.code !== "ENOENT";
+}
+function isMissingCodexExecutable(error) {
+  return error?.code === "ENOENT";
+}
+function startCodexDeviceAuth(options) {
+  const env = options.env ?? process.env;
+  if (!(options.probe ?? defaultProbeCodexExecutable)(env)) {
+    options.onUpdate({
+      phase: "unavailable",
+      lines: [],
+      message: CODEX_UNAVAILABLE_MESSAGE
+    });
+    return { cancel: () => {
+    } };
+  }
+  const launch = options.spawn ?? defaultSpawnCodexDeviceAuth;
+  const openBrowser = options.openBrowser ?? defaultOpenBrowser;
+  const lines = [];
+  let pending = "";
+  let settled = false;
+  let cancelled = false;
+  let browserOpened = false;
+  const publish = (phase, message2) => {
+    options.onUpdate({ phase, lines: [...lines], message: message2 });
+  };
+  const tryOpenBrowser = (text2) => {
+    if (browserOpened) return;
+    const rawUrl = text2.match(/https:\/\/auth\.openai\.com\/codex\/device[^\s\x1b]*/)?.[0];
+    if (!rawUrl) return;
+    const url = rawUrl.replace(/[),.;]+$/, "");
+    browserOpened = true;
+    void Promise.resolve(openBrowser(url)).catch(() => {
+      if (settled) return;
+      lines.push("Could not open a browser automatically; open the URL above.");
+      if (lines.length > MAX_VISIBLE_LINES2) lines.shift();
+      publish("running", "Complete the ChatGPT Codex device sign-in in your browser.");
+    });
+  };
+  const pushOutput = (chunk) => {
+    if (settled) return;
+    const text2 = chunk.toString("utf8");
+    tryOpenBrowser(text2);
+    const raw = `${pending}${text2}`;
+    const parts = raw.split(/\r?\n/);
+    pending = parts.pop() ?? "";
+    for (const line of parts) {
+      const value = sanitizeTuiText(line);
+      if (value.length === 0) continue;
+      lines.push(value);
+      if (lines.length > MAX_VISIBLE_LINES2) lines.shift();
+      tryOpenBrowser(value);
+    }
+    publish("running", "Complete the ChatGPT Codex device sign-in in your browser.");
+  };
+  const finish = (phase, message2) => {
+    if (settled) return;
+    settled = true;
+    if (pending.trim().length > 0) {
+      lines.push(pending.trim());
+      if (lines.length > MAX_VISIBLE_LINES2) lines.shift();
+    }
+    publish(phase, message2);
+  };
+  let child;
+  try {
+    child = launch("codex", ["login", "--device-auth"], { env });
+  } catch (error) {
+    finish(
+      isMissingCodexExecutable(error) ? "unavailable" : "failed",
+      isMissingCodexExecutable(error) ? CODEX_UNAVAILABLE_MESSAGE : error instanceof Error ? error.message : String(error)
+    );
+    return { cancel: () => {
+    } };
+  }
+  child.stdout.on("data", pushOutput);
+  child.stderr.on("data", pushOutput);
+  child.on("error", (error) => {
+    finish(
+      isMissingCodexExecutable(error) ? "unavailable" : "failed",
+      isMissingCodexExecutable(error) ? CODEX_UNAVAILABLE_MESSAGE : error.message
+    );
+  });
+  child.on("close", (code) => {
+    if (settled) return;
+    if (cancelled) {
+      finish("cancelled", "Codex device sign-in cancelled.");
+      return;
+    }
+    if (code !== 0) {
+      finish("failed", `Codex device sign-in exited with code ${code ?? "unknown"}.`);
+      return;
+    }
+    maybeLoadCodexAuth({ env, home: options.homeDir, force: true });
+    if (!env["ZERO_CHATGPT_ACCESS_TOKEN"] && !env["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"]) {
+      finish("failed", "Codex completed without a readable ChatGPT subscription credential.");
+      return;
+    }
+    finish("connected", "ChatGPT Codex subscription connected.");
+    options.onConnected();
+  });
+  publish("running", "Starting ChatGPT Codex device sign-in\u2026");
+  return {
+    cancel: () => {
+      if (settled || cancelled) return;
+      cancelled = true;
+      child.kill("SIGTERM");
+    }
+  };
+}
+
+// packages/cli/src/web/codex-auth-controller.ts
+function webAuthStatus(status, available = true) {
+  const text2 = status.lines.join("\n");
+  const candidate = text2.match(/https:\/\/[^\s<>"\x1b]+/)?.[0]?.replace(/[),.;]+$/, "");
+  let verificationUrl = null;
+  if (candidate) {
+    try {
+      const url = new URL(candidate);
+      const allowedHost = [
+        "auth.openai.com",
+        "x.ai",
+        "kimi.com",
+        "github.com",
+        "openrouter.ai",
+        "accounts.google.com"
+      ].includes(url.hostname) || url.hostname.endsWith(".kimi.com") || url.hostname.endsWith(".x.ai");
+      const containsCredential = ["access_token", "refresh_token", "id_token", "api_key"].some((key) => url.searchParams.has(key));
+      if (!url.username && !url.password && allowedHost && !containsCredential) verificationUrl = url.href;
+    } catch {
+    }
+  }
+  const userCode = text2.match(/\b[A-Z0-9]{4,8}-[A-Z0-9]{4,8}\b/)?.[0] ?? text2.match(/(?:code[:\s]+)([A-Z0-9]{4,12})\b/i)?.[1] ?? null;
+  return { ...status, lines: [...status.lines], verificationUrl, userCode, available };
+}
+var CodexAuthController = class {
+  #start;
+  #env;
+  #homeDir;
+  #probe;
+  #status = { phase: "idle", message: "ChatGPT Codex is not connected.", lines: [] };
+  #session = null;
+  constructor(options = {}) {
+    this.#start = options.start ?? startCodexDeviceAuth;
+    this.#env = { ...options.env ?? process.env };
+    this.#homeDir = options.homeDir;
+    this.#probe = options.probe ?? ((env) => {
+      const result = spawnSync2("codex", ["--version"], { env, stdio: "ignore", timeout: 5e3 });
+      return !result.error && result.status === 0;
+    });
+  }
+  status() {
+    if (this.#status.phase === "running") return webAuthStatus(this.#status);
+    const env = { ...this.#env };
+    maybeLoadCodexAuth({ env, home: this.#homeDir, force: true });
+    const connected = Boolean(env.ZERO_CHATGPT_ACCESS_TOKEN?.trim() || env.ZERO_CHATGPT_OAUTH_REFRESH_TOKEN?.trim());
+    const available = this.#probe(env);
+    if (connected) return webAuthStatus({
+      phase: "connected",
+      message: "ChatGPT Codex subscription credentials are configured.",
+      lines: []
+    }, available);
+    if (!available) return webAuthStatus({
+      phase: "unavailable",
+      message: "Official Codex sign-in is unavailable because the Codex executable is not installed or cannot run. You can connect a supported API provider in this browser instead.",
+      lines: []
+    }, false);
+    return webAuthStatus(this.#status, true);
+  }
+  start() {
+    if (this.#status.phase === "running") return this.status();
+    this.#session = this.#start({
+      env: this.#env,
+      homeDir: this.#homeDir,
+      probe: this.#probe,
+      openBrowser: () => void 0,
+      onUpdate: (update) => this.#apply(update),
+      onConnected: () => void 0
+    });
+    return webAuthStatus(this.#status, this.#status.phase !== "unavailable");
+  }
+  cancel() {
+    this.#session?.cancel();
+    return this.status();
+  }
+  #apply(update) {
+    this.#status = {
+      phase: update.phase,
+      message: update.phase === "unavailable" ? "Official Codex browser sign-in is unavailable. Connect a supported API provider in this browser instead." : update.message,
+      lines: [...update.lines]
+    };
+    if (update.phase !== "running") this.#session = null;
+  }
+};
+
+// packages/cli/src/web/workspace-directories.ts
+import { opendir, realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join5, resolve } from "node:path";
+var MAX_FOLDERS = 200;
+var MAX_SCANNED_ENTRIES = 2e3;
+async function listWorkspaceDirectories(input) {
+  if (input !== void 0 && (typeof input !== "string" || input.length > 4096 || input.includes("\0"))) throw new Error("Enter a valid folder path.");
+  const homePath = await realpath(homedir()).catch(() => resolve(homedir()));
+  let path;
+  try {
+    path = await realpath(typeof input === "string" && input.trim() ? resolve(input.trim()) : homePath);
+  } catch {
+    throw new Error("That folder could not be found on this host.");
+  }
+  if (!(await stat(path)).isDirectory()) throw new Error("Choose a folder rather than a file.");
+  let directory;
+  try {
+    directory = await opendir(path);
+  } catch {
+    throw new Error("This host cannot open that folder. Check its permissions or enter another path.");
+  }
+  const entries = [];
+  let scanned = 0;
+  let truncated = false;
+  for await (const entry of directory) {
+    if (++scanned > MAX_SCANNED_ENTRIES) {
+      truncated = true;
+      break;
+    }
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    try {
+      const canonical = await realpath(join5(path, entry.name));
+      if (!(await stat(canonical)).isDirectory()) continue;
+      if (entries.length >= MAX_FOLDERS) {
+        truncated = true;
+        break;
+      }
+      entries.push({ name: entry.name, path: canonical });
+    } catch {
+    }
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name, void 0, { numeric: true, sensitivity: "base" }));
+  const parent = dirname2(path);
+  return { path, parentPath: parent === path ? null : parent, homePath, entries, truncated };
+}
+
+// packages/cli/src/web/workspace-folder-picker.ts
+import { execFile } from "node:child_process";
+import { realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+var PICKER_SCRIPT = `on run argv
+  activate
+  try
+    if (count of argv) > 0 then
+      set chosen to choose folder with prompt "Choose the folder where Zero works" default location (POSIX file (item 1 of argv))
+    else
+      set chosen to choose folder with prompt "Choose the folder where Zero works"
+    end if
+    return POSIX path of chosen
+  on error number -128
+    return ""
+  end try
+end run`;
+var pickerActive = false;
+async function chooseWorkspaceFolder(input, dependencies = {}) {
+  if (input !== void 0 && (typeof input !== "string" || input.length > 4096 || input.includes("\0"))) throw new Error("Enter a valid folder path.");
+  if ((dependencies.platform ?? process.platform) !== "darwin") return { supported: false, path: null };
+  if (pickerActive) throw new Error("A folder chooser is already open on this host.");
+  pickerActive = true;
+  try {
+    const args = ["-e", PICKER_SCRIPT];
+    if (typeof input === "string" && input.trim()) {
+      const initial = await realpath2(resolve2(input));
+      if (!(await stat2(initial)).isDirectory()) throw new Error("Choose a folder rather than a file.");
+      args.push(initial);
+    }
+    let stdout;
+    try {
+      ({ stdout } = await (dependencies.run ?? execute)("/usr/bin/osascript", args, { encoding: "utf8", timeout: 12e4, maxBuffer: 16384, windowsHide: true }));
+    } catch {
+      throw new Error("The folder chooser could not complete on this host. Try again or enter a folder path.");
+    }
+    const selected = stdout.replace(/\r?\n$/, "");
+    if (!selected) return { supported: true, path: null };
+    if (selected.length > 4096 || selected.includes("\0")) throw new Error("The folder chooser returned an invalid path.");
+    const path = await realpath2(selected);
+    if (!(await stat2(path)).isDirectory()) throw new Error("The folder chooser did not return an existing folder.");
+    return { supported: true, path };
+  } finally {
+    pickerActive = false;
+  }
+}
+
+// packages/cli/src/web/operator-services.ts
+var MODEL_ROLES = ["discovery", "attack", "verify", "report", "audit", "review"];
+var reservedToolNames = Object.values(TOOL_DEFINITIONS).map((tool) => tool.name);
+var runtimeEnvironments = /* @__PURE__ */ new WeakMap();
+function assertPlanAllowed(providerId, policy) {
+  if (providerId === "chatgpt-plan" && policy.allowChatGptPlan === false) throw new OperatorError(403, "local_only", "Native ChatGPT plan connections are available only in the local open-source application.");
+}
+var runtimeContextLimits = /* @__PURE__ */ new WeakMap();
+var pluginManager;
+var pluginManagerPromise;
+var isTurnActive = () => false;
+var deferredPlugins = /* @__PURE__ */ new Set();
+async function getWebConsolePluginHostManager() {
+  if (!pluginManagerPromise) {
+    pluginManagerPromise = createSessionPluginHostManager({ reservedToolNames, coreVersion: VERSION }).then((manager2) => {
+      pluginManager = manager2;
+      return manager2;
+    }).catch((error) => {
+      pluginManagerPromise = void 0;
+      throw error;
+    });
+  }
+  const manager = await pluginManagerPromise;
+  await manager.refresh();
+  return manager;
+}
+var pluginService = createPluginService({
+  registryUrl: (process.env.ZERO_REGISTRY_URL ?? DEFAULT_REGISTRY_URL).trim(),
+  reservedToolNames,
+  coreVersion: VERSION,
+  isTurnActive: () => isTurnActive(),
+  pluginHostManager: {
+    refresh: async () => {
+      await (await getWebConsolePluginHostManager()).refresh();
+    },
+    runPlugin: async (id) => (await getWebConsolePluginHostManager()).runPlugin(id)
+  }
+});
+async function flushWebConsolePlugins() {
+  if (consoleExecutionProfile() === "smolvm" || isTurnActive()) return [];
+  const results = await pluginService.flushDeferred();
+  deferredPlugins.clear();
+  return results;
+}
+function webRuntimeEnv() {
+  const env = { ...process.env };
+  Object.assign(env, connectionConfigEnvPatch(env), credentialEnvPatch(loadCredentials(), env), accountEnvPatch(loadAccountStore(), env));
+  maybeLoadCodexAuth({ env });
+  return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
+}
+function publicMessage(error) {
+  let message2 = error instanceof Error ? error.message : String(error);
+  const secrets = /* @__PURE__ */ new Set();
+  for (const provider2 of PROVIDERS) for (const variable of provider2.envVars) {
+    const value = process.env[variable];
+    if (value) secrets.add(value);
+  }
+  for (const accounts of Object.values(loadAccountStore().providers)) for (const record of Object.values(accounts.accounts)) {
+    if (record.kind === "api_key") secrets.add(record.secret);
+    else for (const token of [record.tokens.accessToken, record.tokens.refreshToken]) if (token) secrets.add(token);
+  }
+  const env = { ...process.env };
+  maybeLoadCodexAuth({ env });
+  for (const variable of PROVIDERS.find((provider2) => provider2.id === "chatgpt-codex").envVars) if (env[variable]) secrets.add(env[variable]);
+  for (const secret of secrets) if (secret) message2 = message2.split(secret).join("[redacted]");
+  return message2.replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/g, "$1[redacted]@").replace(/([?&](?:api[_-]?key|access_token|refresh_token|id_token|token|secret|password)=)[^&\s"'<>]+/gi, "$1[redacted]").slice(0, 4e3);
+}
+function runtimeDiagnostics(runtime) {
+  const diagnostics = runtime.getConfigurationDiagnostics();
+  return {
+    valid: diagnostics.valid,
+    reason: diagnostics.reason ?? null,
+    message: diagnostics.fatalError ? publicMessage(diagnostics.fatalError) : null
+  };
+}
+function connectionProbeRuntime(providerId, env) {
+  return new LlmApiRuntime({
+    type: "api",
+    timeout: 3e5,
+    provider: providerId,
+    env,
+    // OpenAI has no default model. Like accessibleProviders(), use an explicit
+    // sentinel solely for auth/transport inspection. Azure must still validate
+    // its real deployment configuration; the probe cannot supply that for it.
+    ...providerId !== "azure" ? { model: "probe" } : {}
+  });
+}
+function describeWebConsoleRuntime(runtime) {
+  const providerId = runtime.resolvedProvider?.() ?? "unknown";
+  const model = runtime.resolvedModel?.() ?? "unknown";
+  const api = runtime instanceof LlmApiRuntime ? runtime : void 0;
+  const diagnostics = api ? runtimeDiagnostics(api) : { valid: true, reason: null, message: null };
+  return {
+    providerId,
+    providerLabel: PROVIDERS.find((provider2) => provider2.id === providerId)?.label ?? providerId,
+    model,
+    configured: diagnostics.valid,
+    reasoning: api?.reasoningConfiguration() ?? null,
+    connectionIdentity: api?.connectionIdentity() ?? null,
+    diagnostics,
+    ...runtime.modelSelection?.() ?? { agentModels: {}, singleModel: false, autoRoute: false },
+    contextWindowTokens: (api ? runtimeContextLimits.get(api) : void 0) ?? resolveContextLimit({ modelId: model, providerId })?.tokens ?? null
+  };
+}
+function savedWebRuntimeSelection(selection, info) {
+  const { reasoningEffort: selectedEffort, ...stored } = selection;
+  const effort = info ? info.reasoning?.effort : selectedEffort;
+  const reasoning = effort && ["none", "low", "medium", "high", "xhigh", "max"].includes(effort) ? { reasoningEffort: effort } : {};
+  if (!info) return { ...stored, ...reasoning };
+  return {
+    ...stored,
+    providerId: info.providerId,
+    model: info.model,
+    agentModels: info.agentModels,
+    singleModel: info.singleModel,
+    autoRoute: info.autoRoute,
+    ...reasoning
+  };
+}
+function validateSelection(selection) {
+  if (selection.providerId !== void 0 && !PROVIDERS.some((provider2) => provider2.id === selection.providerId)) throw new OperatorError(400, "invalid_provider", "Unsupported provider.");
+  for (const value of [selection.model, ...Object.values(selection.agentModels ?? {})]) {
+    if (value !== void 0 && (typeof value !== "string" || !value || value.length > 256 || /[\s\x00-\x1f\x7f]/.test(value))) throw new OperatorError(400, "invalid_model", "Model identifiers must be non-empty and contain no whitespace.");
+  }
+  if (selection.reasoningEffort !== void 0 && !["none", "low", "medium", "high", "xhigh", "max"].includes(selection.reasoningEffort)) throw new OperatorError(400, "invalid_reasoning_effort", "Choose an available thinking effort.");
+  for (const key of Object.keys(selection.agentModels ?? {})) if (!/^[a-z][a-z0-9_-]{0,63}$/.test(key)) throw new OperatorError(400, "invalid_role", "Invalid model role.");
+}
+async function validateRuntimeModels(runtime) {
+  const diagnostics = runtime.getConfigurationDiagnostics();
+  if (!diagnostics.valid) throw new OperatorError(409, "provider_not_ready", publicMessage(diagnostics.fatalError ?? "Connect the selected provider first."));
+  if (diagnostics.provider === "chatgpt-codex") {
+    let models;
+    try {
+      models = await runtime.codexModelCatalog(AbortSignal.timeout(1e4));
+    } catch (error) {
+      if (error instanceof CodexCatalogRefreshError) models = [...error.cachedModels];
+      else if (/Codex model discovery failed \(HTTP 401\)/.test(error instanceof Error ? error.message : String(error))) throw new OperatorError(409, "connection_expired", "Your ChatGPT connection has expired or was rejected. Sign in again in Connections, then retry.");
+      else throw error;
+    }
+    const selected = models.find((model) => model.id === runtime.resolvedModel());
+    if (!selected) throw new OperatorError(409, "model_not_available", "The selected model is not available to this ChatGPT account.");
+    if (selected.contextTokens) runtimeContextLimits.set(runtime, selected.contextTokens);
+    for (const model of Object.values(runtime.modelSelection().agentModels)) {
+      if (model !== "auto" && !models.some((entry) => entry.id === model.replace(/^openai\//, ""))) throw new OperatorError(409, "model_not_available", "A role model is not available to this ChatGPT account.");
+    }
+  }
+  if (diagnostics.provider === "chatgpt-plan") {
+    const models = await runtime.availableModelCatalog(AbortSignal.timeout(1e4));
+    if (!models.some((model) => model.id === runtime.resolvedModel())) throw new OperatorError(409, "model_not_available", "This model is not available to the connected ChatGPT plan.");
+    for (const model of Object.values(runtime.modelSelection().agentModels)) {
+      if (model !== "auto" && !models.some((entry) => entry.id === model)) throw new OperatorError(409, "model_not_available", "A role model is not available to the connected ChatGPT plan.");
+    }
+  }
+  for (const role of Object.keys(runtime.modelSelection().agentModels)) {
+    if (runtime.modelSelection().agentModels[role] !== "auto") await runtime.forkForSubagent(12e4, { role });
+  }
+}
+async function createWebConsoleRuntime(selection = {}, policy = {}) {
+  validateSelection(selection);
+  assertPlanAllowed(selection.providerId, policy);
+  const env = webRuntimeEnv();
+  if (!selection.providerId) assertPlanAllowed(env.ZERO_SELECTED_PROVIDER || env.ZERO_PROVIDER || env.ZERO_FORCE_PROVIDER, policy);
+  const { runtime } = await createPreferredConsoleRuntime({
+    provider: selection.providerId,
+    model: selection.model,
+    agentModels: selection.agentModels,
+    singleModel: selection.singleModel,
+    autoRoute: selection.autoRoute,
+    env,
+    ...selection.providerId === "chatgpt-plan" ? { siwcConnection: getSiwcConnection(env.HOME) } : {}
+  }, policy);
+  await validateRuntimeModels(runtime);
+  if (selection.reasoningEffort !== void 0) {
+    try {
+      runtime.setReasoningEffort(selection.reasoningEffort);
+    } catch {
+      throw new OperatorError(400, "unsupported_reasoning_effort", "Choose an available thinking effort for this model.");
+    }
+  }
+  runtimeEnvironments.set(runtime, env);
+  if (selection.model !== void 0) saveAppliedModelPreference(runtime);
+  return { runtime, info: describeWebConsoleRuntime(runtime) };
+}
+async function reloadWebConsoleRuntimeConnection(runtime, policy = {}) {
+  const providerId = runtime.resolvedProvider();
+  const model = runtime.resolvedModel();
+  assertPlanAllowed(providerId, policy);
+  if (providerId === "chatgpt-plan") {
+    await validateRuntimeModels(runtime);
+    return describeWebConsoleRuntime(runtime);
+  }
+  const effort = runtime.reasoningConfiguration()?.effort;
+  const env = webRuntimeEnv();
+  const { runtime: candidate } = await createPreferredConsoleRuntime({
+    provider: providerId,
+    model,
+    ...runtime.modelSelection(),
+    env
+  }, policy);
+  if (candidate.resolvedProvider() !== providerId || candidate.resolvedModel() !== model) throw new OperatorError(409, "connection_changed", "Reconnect the conversation's selected provider and model first.");
+  await validateRuntimeModels(candidate);
+  if (effort !== void 0) candidate.setReasoningEffort(effort);
+  runtime.refreshConnection(env);
+  runtimeEnvironments.set(runtime, env);
+  const contextTokens2 = runtimeContextLimits.get(candidate);
+  if (contextTokens2) runtimeContextLimits.set(runtime, contextTokens2);
+  else runtimeContextLimits.delete(runtime);
+  return describeWebConsoleRuntime(runtime);
+}
+async function applyWebConsoleRuntimeSelection(runtime, selection, policy = {}) {
+  validateSelection(selection);
+  const currentProvider = runtime.resolvedProvider();
+  let providerId = selection.providerId;
+  if (providerId === void 0 && selection.model !== void 0) {
+    const inferred = modelProvider(selection.model);
+    if (inferred !== "unknown" && inferred !== currentProvider && !(["chatgpt-codex", "chatgpt-plan"].includes(currentProvider) && inferred === "openai")) providerId = inferred;
+  }
+  const targetProvider = providerId ?? currentProvider;
+  assertPlanAllowed(targetProvider, policy);
+  let candidate;
+  let planConnection;
+  if (targetProvider !== currentProvider) {
+    const env = webRuntimeEnv();
+    if (targetProvider === "chatgpt-plan") planConnection = getSiwcConnection(env.HOME);
+    const created = await createPreferredConsoleRuntime({
+      provider: targetProvider,
+      model: selection.model,
+      env,
+      ...runtime.modelSelection(),
+      ...selection,
+      ...planConnection ? { siwcConnection: planConnection } : {}
+    }, policy);
+    candidate = created.runtime;
+    await validateRuntimeModels(candidate);
+    runtimeEnvironments.set(candidate, env);
+  } else {
+    candidate = await runtime.forkForSubagent(12e4);
+    candidate.reconfigure({ ...runtime.modelSelection(), ...selection });
+    await validateRuntimeModels(candidate);
+  }
+  if (selection.reasoningEffort !== void 0) {
+    try {
+      candidate.setReasoningEffort(selection.reasoningEffort);
+    } catch {
+      throw new OperatorError(400, "unsupported_reasoning_effort", "Choose an available thinking effort for this model.");
+    }
+  }
+  runtime.reconfigure({
+    model: candidate.resolvedModel(),
+    provider: targetProvider,
+    ...planConnection ? { siwcConnection: planConnection } : {},
+    ...candidate.modelSelection(),
+    ...targetProvider !== currentProvider ? { env: runtimeEnvironments.get(candidate) } : {}
+  });
+  const reasoning = candidate.reasoningConfiguration();
+  if (reasoning) runtime.setReasoningEffort(reasoning.effort);
+  const contextTokens2 = runtimeContextLimits.get(candidate);
+  if (contextTokens2) runtimeContextLimits.set(runtime, contextTokens2);
+  else runtimeContextLimits.delete(runtime);
+  if (selection.model !== void 0) saveAppliedModelPreference(runtime);
+  return describeWebConsoleRuntime(runtime);
+}
+var OperatorError = class extends Error {
+  constructor(status, code, message2) {
+    super(message2);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function object2(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new OperatorError(400, "invalid_input", "Expected a JSON object.");
+  return input;
+}
+function text(input, name, max = 4096) {
+  if (typeof input !== "string" || !input.trim() || input.length > max || /[\x00]/.test(input)) throw new OperatorError(400, "invalid_input", `Invalid ${name}.`);
+  return input.trim();
+}
+function provider(input) {
+  const id = input === "codex" ? "chatgpt-codex" : text(input, "provider", 64);
+  const result = PROVIDERS.find((entry) => entry.id === id);
+  if (!result) throw new OperatorError(404, "unknown_provider", "Provider does not exist.");
+  return result;
+}
+function settingsView() {
+  syncThemeChoices();
+  return {
+    settings: getSettings(),
+    sources: getSettingSources(),
+    defaultWriteLayer: defaultWriteLayer(),
+    definitions: SETTING_DEFS.map((def) => ({ ...def, operatorOnly: isOperatorSetting(def.key) }))
+  };
+}
+var WebOperatorServices = class {
+  #servicePlugins = new ServicePluginServices();
+  #codex = new CodexAuthController();
+  #plan = new ChatGptPlanAuthController();
+  #allowChatGptPlan;
+  #auth = /* @__PURE__ */ new Map();
+  #catalogRefresh;
+  #registryItems = /* @__PURE__ */ new Map();
+  #registryError = null;
+  #feedback = null;
+  constructor(options = {}) {
+    isTurnActive = options.isTurnActive ?? (() => false);
+    this.#allowChatGptPlan = options.allowChatGptPlan !== false;
+  }
+  #publicAuth(status) {
+    return {
+      ...status,
+      message: publicMessage(status.message),
+      lines: status.lines.map((line) => publicMessage(line))
+    };
+  }
+  #authStatus(id, configured) {
+    if (id === "chatgpt-plan") return this.#plan.status();
+    if (id === "chatgpt-codex") return this.#publicAuth(this.#codex.status());
+    const flow = this.#auth.get(id);
+    if (flow?.status.phase === "running") return { ...flow.status, lines: [...flow.status.lines] };
+    if (configured) return webAuthStatus({ phase: "connected", message: "Credentials are configured. The first request verifies account access.", lines: [] }, Boolean(PROVIDER_DEVICE_AUTH[id]));
+    if (flow && flow.status.phase !== "connected") return { ...flow.status, lines: [...flow.status.lines] };
+    return webAuthStatus({ phase: "idle", message: PROVIDERS.find((p) => p.id === id)?.hint ?? "Not connected.", lines: [] }, Boolean(PROVIDER_DEVICE_AUTH[id]));
+  }
+  #providers() {
+    const env = webRuntimeEnv();
+    const store = loadAccountStore();
+    const configs = loadConnectionConfigs();
+    return PROVIDERS.filter((info) => this.#allowChatGptPlan || info.id !== "chatgpt-plan").map((info) => {
+      if (info.id === "chatgpt-plan") {
+        const profiles = listChatGptPlanProfiles();
+        const active = profiles.find((p) => p.active && p.status === "connected");
+        return {
+          id: info.id,
+          label: info.label,
+          methods: info.methods,
+          configured: Boolean(active),
+          source: active ? "account-store" : null,
+          diagnostics: { valid: Boolean(active?.sharing), reason: active?.sharing ? null : active ? "plan_sharing_required" : "missing_connection", message: active?.sharing ? null : active ? "ChatGPT identity is connected. Grant plan usage to use models." : "Connect your ChatGPT account." },
+          accounts: profiles.map((p) => ({ accountId: p.id, kind: "oauth", active: p.active, label: p.label, status: p.status, sharing: p.sharing })),
+          configuration: {},
+          auth: this.#plan.status()
+        };
+      }
+      let diagnostics = {
+        valid: false,
+        reason: "missing_key",
+        message: "Connect this provider in the browser to configure credentials."
+      };
+      const via = info.envVars.find((key) => Boolean(env[key]?.trim()));
+      const environment = info.envVars.some((key) => Boolean(process.env[key]?.trim()));
+      const accounts = listAccounts(store, info.id).map(({ accountId, record, active }) => ({
+        accountId,
+        kind: record.kind,
+        active,
+        label: record.kind === "oauth" ? record.identity?.email ?? record.identity?.label ?? accountId : accountId
+      }));
+      const configured = Boolean(via);
+      if (configured) {
+        try {
+          diagnostics = runtimeDiagnostics(connectionProbeRuntime(info.id, env));
+        } catch (error) {
+          diagnostics = { valid: false, reason: "invalid_config", message: publicMessage(error) };
+        }
+      }
+      return {
+        id: info.id,
+        label: info.id === "openai" ? "OpenAI / Custom AI Provider" : info.label,
+        methods: info.methods.includes("api-key") && !PROVIDER_DEVICE_AUTH[info.id] ? info.methods.filter((method) => method !== "oauth") : info.methods,
+        configured,
+        source: configured ? environment ? "environment" : store.providers[info.id] ? "account-store" : "codex-file" : null,
+        diagnostics,
+        accounts,
+        configuration: configs[info.id] ?? {},
+        auth: this.#authStatus(info.id, configured)
+      };
+    });
+  }
+  async #models(providerId) {
+    if (providerId !== void 0) providerId = provider(providerId).id;
+    assertPlanAllowed(providerId, { allowChatGptPlan: this.#allowChatGptPlan });
+    const env = webRuntimeEnv();
+    const ids = providerStates(env).filter((state) => state.configured && (!providerId || state.id === providerId)).map((state) => state.id);
+    if (this.#allowChatGptPlan && (!providerId || providerId === "chatgpt-plan") && listChatGptPlanProfiles().some((p) => p.active && p.status === "connected" && p.sharing)) ids.push("chatgpt-plan");
+    if (!this.#catalogRefresh) {
+      this.#catalogRefresh = Promise.resolve().then(() => syncModelCatalog()).catch(() => null).finally(() => {
+        this.#catalogRefresh = void 0;
+      });
+    }
+    const discovered = await discoverConnectionModels(env, ids);
+    const metadata = new Map(buildFullModelCatalog().map((model) => [`${model.provider}/${model.id}`, model]));
+    const rows = discovered.models.map((model) => ({
+      id: model.id,
+      provider: model.provider,
+      price: model.provider === "chatgpt-plan" ? "Shared ChatGPT allowance" : model.provider === "chatgpt-codex" ? "Included in subscription" : model.provider === "cline" && model.id.startsWith("cline-pass/") ? "ClinePass plan (access unverified)" : metadata.get(`${model.provider}/${model.id}`)?.price ?? "Unknown rate",
+      contextWindowTokens: model.contextTokens ?? resolveContextLimit({ modelId: model.id, providerId: model.provider })?.tokens ?? null,
+      source: model.provider !== "chatgpt-plan" && model.source === "catalog" ? "public-catalog" : "account"
+    }));
+    const configuredModel = env.OPENAI_MODEL;
+    if (configuredModel && ids.includes("openai") && !rows.some((row) => row.provider === "openai" && row.id === configuredModel)) {
+      rows.unshift({ id: configuredModel, provider: "openai", price: "Unknown rate", contextWindowTokens: null, source: "account" });
+    }
+    return {
+      models: rows,
+      providerId: providerId ?? null,
+      diagnostics: discovered.diagnostics.map((item) => ({ ...item, message: publicMessage(item.message) })),
+      roles: MODEL_ROLES
+    };
+  }
+  async #connections(input) {
+    const body = object2(input);
+    const info = provider(body.providerId);
+    const action = text(body.action, "connection action", 32);
+    assertPlanAllowed(info.id, { allowChatGptPlan: this.#allowChatGptPlan });
+    if (info.id === "chatgpt-plan") {
+      const id = text(body.accountId, "account ID", 128);
+      if (action === "activate") await selectChatGptPlanProfile(id);
+      else if (action === "disconnect") {
+        this.#plan.cancel();
+        const result = await signOutChatGptPlan(id);
+        return { providers: this.#providers(), revoked: result.revoked, message: result.revoked ? "Signed out locally and provider revocation completed." : "Signed out locally. Provider revocation could not be confirmed; review the connection in ChatGPT Settings." };
+      } else throw new OperatorError(400, "unsupported_auth", "Use native ChatGPT browser sign-in.");
+      return { providers: this.#providers() };
+    }
+    if (action === "configure") {
+      const config = validateConnectionConfig(info.id, {
+        ...body.baseUrl !== void 0 ? { baseUrl: text(body.baseUrl, "API endpoint") } : {},
+        ...body.model !== void 0 ? { model: text(body.model, "deployment model", 256) } : {},
+        ...body.projectId !== void 0 ? { projectId: text(body.projectId, "Google project", 256) } : {}
+      });
+      if (!Object.keys(config).length) throw new OperatorError(400, "empty_configuration", "Choose a supported connection configuration field to update.");
+      saveConnectionConfig(info.id, { ...loadConnectionConfigs()[info.id], ...config });
+      return { providers: this.#providers() };
+    }
+    let store = loadAccountStore();
+    if (action === "connect") {
+      if (!info.methods.includes("api-key")) throw new OperatorError(400, "unsupported_auth", "Use this provider's browser sign-in flow.");
+      const secret = text(body.apiKey, "API key", 16384);
+      if (/[\s\x00-\x1f\x7f]/.test(secret)) throw new OperatorError(400, "invalid_key", "API keys must not contain whitespace or control characters.");
+      const config = validateConnectionConfig(info.id, {
+        ...body.baseUrl !== void 0 ? { baseUrl: text(body.baseUrl, "API endpoint") } : {},
+        ...body.model !== void 0 ? { model: text(body.model, "deployment model", 256) } : {}
+      });
+      if (Object.keys(config).length) saveConnectionConfig(info.id, config);
+      const accountId = body.accountId === void 0 ? void 0 : text(body.accountId, "account ID", 128);
+      if (accountId && ["__proto__", "constructor", "prototype"].includes(accountId)) throw new OperatorError(400, "invalid_account", "Invalid account ID.");
+      store = addAccount(store, info.id, { kind: "api_key", secret }, { accountId, makeActive: true }).store;
+    } else if (action === "disconnect") {
+      if (info.envVars.some((key) => process.env[key]?.trim())) throw new OperatorError(409, "environment_owned", "This connection is supplied by the server environment and cannot be revoked by deleting a saved account.");
+      if (info.id === "chatgpt-codex" && !store.providers[info.id]) throw new OperatorError(409, "official_auth_owned", "The official Codex auth file belongs to Codex. Removing another account here does not revoke that login.");
+      this.#auth.get(info.id)?.session?.cancel();
+      this.#auth.delete(info.id);
+      store = body.accountId === void 0 ? logoutProvider(store, info.id) : removeAccount(store, info.id, text(body.accountId, "account ID", 128));
+    } else if (action === "activate") {
+      const accountId = text(body.accountId, "account ID", 128);
+      if (!store.providers[info.id]?.accounts[accountId]) throw new OperatorError(404, "unknown_account", "Saved account does not exist.");
+      if (info.envVars.some((key) => process.env[key]?.trim())) throw new OperatorError(409, "environment_owned", "The explicit server credential takes precedence over saved accounts.");
+      store = setActiveAccount(store, info.id, accountId);
+    } else throw new OperatorError(400, "invalid_action", "Unsupported connection action.");
+    if (!saveAccountStore(store)) throw new OperatorError(500, "persistence_failed", "Could not save the private credential account store.");
+    return { providers: this.#providers() };
+  }
+  #deviceAuth(id, method, input) {
+    const info = provider(id);
+    assertPlanAllowed(info.id, { allowChatGptPlan: this.#allowChatGptPlan });
+    if (info.id === "chatgpt-plan") {
+      const body = input === void 0 ? {} : object2(input);
+      const profileId = body.profileId === void 0 ? void 0 : text(body.profileId, "profile ID", 128);
+      return { status: method === "DELETE" ? this.#plan.cancel() : this.#plan.start(profileId) };
+    }
+    if (info.id === "chatgpt-codex") return { status: this.#publicAuth(method === "DELETE" ? this.#codex.cancel() : this.#codex.start()) };
+    const config = PROVIDER_DEVICE_AUTH[info.id];
+    if (!config) throw new OperatorError(409, "auth_unavailable", info.hint);
+    const previous = this.#auth.get(info.id);
+    if (method === "DELETE") {
+      previous?.session?.cancel();
+      return { status: previous?.status ?? this.#authStatus(info.id, false) };
+    }
+    if (previous?.status.phase === "running") return { status: previous.status };
+    const flow = { status: webAuthStatus({ phase: "running", message: "Starting browser sign-in.", lines: [] }), session: null, env: { ...process.env } };
+    this.#auth.set(info.id, flow);
+    flow.session = startDeviceAuth(config, {
+      env: flow.env,
+      openBrowser: (url) => {
+        const safe = webAuthStatus({ phase: "running", message: "", lines: [url] });
+        if (safe.verificationUrl) flow.status = { ...flow.status, verificationUrl: safe.verificationUrl };
+      },
+      onUpdate: (update) => {
+        const status = webAuthStatus({ phase: update.phase, message: publicMessage(update.message), lines: update.lines.map((line) => publicMessage(line)) });
+        flow.status = { ...status, verificationUrl: status.verificationUrl ?? flow.status.verificationUrl };
+        if (update.phase !== "running") flow.session = null;
+      },
+      onConnected: () => void 0
+    });
+    return { status: flow.status };
+  }
+  async #plugins() {
+    const registryUrl = (process.env.ZERO_REGISTRY_URL ?? DEFAULT_REGISTRY_URL).trim();
+    let publicRegistryUrl = "";
+    if (registryUrl) {
+      try {
+        const url = new URL(registryUrl);
+        url.username = "";
+        url.password = "";
+        url.search = "";
+        url.hash = "";
+        publicRegistryUrl = url.href;
+      } catch {
+        publicRegistryUrl = "Invalid configured registry URL";
+      }
+    }
+    const fetched = await pluginService.fetchRegistry();
+    this.#registryError = fetched.ok ? null : publicMessage(registryUrl ? fetched.error.split(registryUrl).join(publicRegistryUrl) : fetched.error);
+    this.#registryItems = fetched.ok ? new Map(buildMarketItems(fetched.result).map((item) => [`${item.kind}:${item.id}`, item])) : /* @__PURE__ */ new Map();
+    const installed = await pluginService.list(getSettings().theme);
+    const items = new Map(this.#registryItems);
+    const errors = /* @__PURE__ */ new Map();
+    for (const id of listInstalledPluginIds(pluginsRootDir())) {
+      const discovered = readInstalledPlugin(pluginsRootDir(), id, { reservedToolNames });
+      if (!discovered.ok) {
+        errors.set(id, discovered.errors.join("; "));
+        continue;
+      }
+      const manifest = discovered.plugin.manifest;
+      items.set(`plugin:${id}`, {
+        id,
+        kind: "plugin",
+        name: manifest.name ?? id,
+        version: manifest.version,
+        description: manifest.tools.map((tool) => tool.name).join(", "),
+        capabilities: aggregateCapabilities(manifest),
+        signature: "unverified",
+        raw: void 0
+      });
+    }
+    for (const theme of installedThemeEntries()) {
+      if (!items.has(`theme:${theme.name}`)) items.set(`theme:${theme.name}`, {
+        id: theme.name,
+        kind: "theme",
+        name: theme.label,
+        version: "",
+        description: theme.description,
+        capabilities: [],
+        signature: "unverified",
+        raw: void 0
+      });
+    }
+    const host = pluginManager?.current();
+    const hostStates = host?.status() ?? [];
+    const loadedPluginIds = hostStates.filter((entry) => entry.state === "ready").map((entry) => entry.pluginId);
+    const result = [...items.values()].map(({ raw: _raw, ...item }) => ({
+      ...item,
+      state: item.kind === "theme" ? item.id === installed.activeTheme ? "active" : installed.themes.has(item.id) ? "installed" : "available" : installed.plugins.get(item.id) ?? "available",
+      loaded: loadedPluginIds.includes(item.id),
+      error: errors.get(item.id) ?? (hostStates.some((state) => state.pluginId === item.id && state.state === "unavailable") ? "Plugin is unavailable in the current host." : null)
+    }));
+    for (const [id, error] of errors) if (!result.some((item) => item.id === id && item.kind === "plugin")) result.push({ id, kind: "plugin", name: id, version: "", description: "Installed manifest is invalid.", capabilities: [], signature: "unverified", state: "installed", loaded: false, error });
+    return {
+      registry: { url: publicRegistryUrl, available: fetched.ok, error: this.#registryError },
+      items: result,
+      deferred: [...deferredPlugins],
+      executionProfile: consoleExecutionProfile(),
+      host: { loadedPluginIds, tools: host?.toolDefinitions().map(({ name, description }) => ({ name, description })) ?? [] }
+    };
+  }
+  async #pluginAction(action, input) {
+    if (action === "run" && consoleExecutionProfile() === "smolvm") throw new OperatorError(409, "isolated_execution_required", "Plugins load automatically inside new SmolVM chats. Start a new chat to use an approved plugin.");
+    const body = object2(input);
+    const id = text(body.id, "plugin ID", 64);
+    if (action === "install") {
+      const kind = body.kind === "theme" ? "theme" : "plugin";
+      await this.#plugins();
+      if (this.#registryError) throw new OperatorError(503, "registry_unavailable", this.#registryError);
+      const item2 = this.#registryItems.get(`${kind}:${id}`);
+      if (!item2) throw new OperatorError(404, "unknown_artifact", "The configured registry has no installable artifact with that ID.");
+      const result2 = await pluginService.install(item2);
+      if (!result2.ok) throw new OperatorError(409, "install_failed", result2.message);
+      reloadInstalledThemes();
+      return result2;
+    }
+    if (!isSafePluginId(id)) throw new OperatorError(400, "invalid_plugin", "Invalid plugin ID.");
+    if (action === "disable") {
+      if (!writeEnablement(process.cwd(), disable(readEnablement(process.cwd()), id))) throw new OperatorError(500, "persistence_failed", "Could not save plugin approval removal.");
+      deferredPlugins.delete(id);
+      return { ok: true, message: "Disabled for future sessions. Already leased sessions keep their approved host until cleanup.", state: "installed" };
+    }
+    const discovered = readInstalledPlugin(pluginsRootDir(), id, { reservedToolNames });
+    if (!discovered.ok) throw new OperatorError(409, "invalid_plugin", discovered.errors.join("; "));
+    const manifest = discovered.plugin.manifest;
+    const capabilities = aggregateCapabilities(manifest);
+    const item = { id, kind: "plugin", name: manifest.name ?? id, version: manifest.version, description: "", capabilities, signature: "unverified", raw: void 0 };
+    if (action === "enable") {
+      if (body.approved !== true || body.version !== manifest.version || !Array.isArray(body.capabilities) || body.capabilities.some((entry) => typeof entry !== "string") || JSON.stringify([...new Set(body.capabilities)].sort()) !== JSON.stringify([...capabilities].sort())) throw new OperatorError(409, "approval_required", "Inspect and explicitly approve this installed version and its exact capabilities before enabling.");
+      const result2 = await pluginService.enable(item);
+      if (!result2.ok) throw new OperatorError(409, "enable_failed", result2.message);
+      return consoleExecutionProfile() === "smolvm" ? { ...result2, message: "Approved for new SmolVM chats. Plugin files are copied and loaded automatically inside each new VM." } : result2;
+    }
+    if (action !== "run") throw new OperatorError(404, "unknown_action", "Unsupported plugin action.");
+    const result = await pluginService.run(item);
+    if (result.deferred) deferredPlugins.add(id);
+    else if (!result.ok) throw new OperatorError(409, "run_failed", result.message);
+    return result;
+  }
+  async handle(pathname, method, input, query) {
+    if (!pathname.startsWith("/api/console/")) return null;
+    const path = pathname.slice("/api/console/".length);
+    const servicePluginResult = await this.#servicePlugins.handle(path, method, input);
+    if (servicePluginResult) return servicePluginResult;
+    if (!/^(providers(?:\/[^/]+(?:\/device-auth)?)?|models|connections|settings(?:\/reset)?|themes|plugins(?:\/(?:install|enable|disable|run))?|doctor|tools|project(?:\/(?:directories|choose-directory))?|checks|feedback)$/.test(path)) return null;
+    try {
+      let data;
+      let status = 200;
+      if (path === "providers" && method === "GET") data = { providers: this.#providers(), preference: getSettings().modelPreference };
+      else if (path === "models" && method === "GET") data = await this.#models(query.get("providerId") ?? void 0);
+      else if (path === "connections" && method === "POST") data = await this.#connections(input);
+      else if (/^providers\/[^/]+\/device-auth$/.test(path) && ["POST", "DELETE"].includes(method)) {
+        data = this.#deviceAuth(decodeURIComponent(path.split("/")[1]), method, input);
+        status = method === "POST" ? 202 : 200;
+      } else if (/^providers\/[^/]+$/.test(path) && method === "GET") {
+        const info = provider(decodeURIComponent(path.split("/")[1]));
+        assertPlanAllowed(info.id, { allowChatGptPlan: this.#allowChatGptPlan });
+        const state = this.#providers().find((entry) => entry.id === info.id);
+        data = { provider: state, status: state.auth };
+      } else if (path === "settings" && method === "GET") data = settingsView();
+      else if (path === "settings" && method === "PATCH") {
+        const body = object2(input);
+        const key = text(body.key, "setting", 128);
+        const def = SETTING_DEFS.find((entry) => entry.key === key);
+        const internalBoolean = key === "onboardingCompleted" || key === "diagnosticReportingPrompted";
+        if (!def && !internalBoolean) throw new OperatorError(400, "unknown_setting", "Only declared settings can be changed here. Model preferences are saved by successful runtime selection.");
+        if (body.scope !== void 0 && body.scope !== "global" && body.scope !== "project") throw new OperatorError(400, "invalid_scope", "Settings scope must be global or project.");
+        if (isOperatorSetting(key) && body.scope === "project") throw new OperatorError(400, "operator_global", "Operator consent and execution preferences can only be changed globally.");
+        if (internalBoolean ? typeof body.value !== "boolean" : def.kind === "boolean" ? typeof body.value !== "boolean" : key === "theme" ? !isKnownTheme(body.value) : typeof body.value !== "string" || !def.choices?.includes(body.value)) throw new OperatorError(400, "invalid_value", "The value is not supported by this setting.");
+        const persisted = updateSetting(key, body.value, { scope: body.scope });
+        data = { ...settingsView(), persisted, ...!persisted ? { error: "Settings changed in this process but could not be saved to disk.", code: "persistence_failed" } : {} };
+        if (!persisted) status = 507;
+      } else if (path === "settings/reset" && method === "POST") {
+        const body = object2(input);
+        const keys = body.keys ?? SETTING_DEFS.map((def) => def.key);
+        if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string" || !SETTING_DEFS.some((def) => def.key === key))) throw new OperatorError(400, "invalid_setting", "Reset keys must name declared settings.");
+        const persisted = resetSettings(DEFAULT_SETTINGS, keys);
+        data = { ...settingsView(), persisted, ...!persisted ? { error: "Settings reset in this process but could not be saved to disk.", code: "persistence_failed" } : {} };
+        if (!persisted) status = 507;
+      } else if (path === "themes" && method === "GET") data = { active: getSettings().theme, themes: allThemeNames().map((name) => ({ ...getThemeEntry(name) })) };
+      else if (path === "plugins" && method === "GET") data = await this.#plugins();
+      else if (path.startsWith("plugins/") && method === "POST") data = await this.#pluginAction(path.split("/")[1], input);
+      else if (path === "doctor" && method === "GET") {
+        const providers = this.#providers();
+        const availability = await getRuntimeAvailability();
+        const ready = providers.find((entry) => entry.diagnostics.valid);
+        const settings = getSettings();
+        data = {
+          version: VERSION,
+          runtime: { ...getRuntimeMetadata(), node: process.version, nodeSupported: Number(process.versions.node.split(".")[0]) >= 24 },
+          availability: { ...availability, hasApiKey: Boolean(ready), apiRuntime: ready ? { configured: true, valid: true, providerLabel: ready.label } : { ...availability.apiRuntime, error: availability.apiRuntime.error ? publicMessage(availability.apiRuntime.error) : void 0 } },
+          providers,
+          prerequisites: [{ id: "node", available: Number(process.versions.node.split(".")[0]) >= 24, required: true }, { id: "codex", available: providers.find((entry) => entry.id === "chatgpt-codex").auth.available, required: false }],
+          settings: { onboardingCompleted: settings.onboardingCompleted, analyticsLevel: settings.analyticsLevel, diagnosticReporting: settings.diagnosticReporting, executionProfile: settings.executionProfile }
+        };
+      } else if (path === "tools" && method === "GET") {
+        const roleTools = Object.fromEntries(MODEL_ROLES.map((role) => [role, new Set(getToolsForRole(role, { hasScope: true, webMode: true, hasBrowser: true, allowScanners: true }).map((tool) => tool.name))]));
+        data = { roles: MODEL_ROLES, tools: Object.values(TOOL_DEFINITIONS).map(({ name, description }) => ({ name, description, roles: MODEL_ROLES.filter((role) => roleTools[role].has(name)) })), plugins: pluginManager?.current().toolDefinitions().map(({ name, description }) => ({ name, description })) ?? [] };
+      } else if (path === "project/choose-directory" && method === "POST") {
+        data = await chooseWorkspaceFolder(object2(input).path);
+      } else if (path === "project/directories" && method === "POST") {
+        data = await listWorkspaceDirectories(object2(input).path);
+      } else if (path === "project" && method === "GET") {
+        const projectPath = realpathSync(resolve3(query.get("path") ?? process.cwd()));
+        if (!statSync(projectPath).isDirectory()) throw new OperatorError(400, "invalid_project", "Project path must name a local directory.");
+        const git = { root: null, branch: null, dirty: false, error: null };
+        try {
+          git.root = execFileSync("git", ["--no-optional-locks", "-c", "core.fsmonitor=false", "-C", projectPath, "rev-parse", "--show-toplevel"], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).trim();
+          git.branch = execFileSync("git", ["--no-optional-locks", "-c", "core.fsmonitor=false", "-C", projectPath, "branch", "--show-current"], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+          git.dirty = Boolean(execFileSync("git", ["--no-optional-locks", "-c", "core.fsmonitor=false", "-C", projectPath, "status", "--porcelain"], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"], maxBuffer: 1048576 }).trim());
+        } catch {
+          git.error = "Git metadata is unavailable for this directory.";
+        }
+        data = { path: projectPath, name: basename(projectPath), git };
+      } else if (path === "checks" && method === "GET") data = listProjectReviewChecks(query.get("path") ?? process.cwd());
+      else if (path === "checks" && method === "POST") {
+        const body = object2(input);
+        const mutation = object2(body.mutation);
+        const action = text(mutation.action, "review check action", 32);
+        if (!["propose", "add", "enable", "disable", "set", "remove"].includes(action)) throw new OperatorError(400, "invalid_action", "Unsupported review check action.");
+        if (mutation.approved !== void 0 && typeof mutation.approved !== "boolean") throw new OperatorError(400, "invalid_approval", "Approval must be an explicit boolean.");
+        if (mutation.expectedRevision !== void 0 && (!Number.isSafeInteger(mutation.expectedRevision) || Number(mutation.expectedRevision) < 1)) throw new OperatorError(400, "invalid_revision", "Expected revision must be a positive integer.");
+        data = updateProjectReviewChecks(body.path === void 0 ? process.cwd() : text(body.path, "project path"), mutation);
+      } else if (path === "feedback" && method === "POST") {
+        const body = object2(input);
+        if (body.action === "cancel") {
+          this.#feedback = null;
+          data = { cancelled: true, submitted: false };
+        } else if (body.action === "send") {
+          const staged = this.#feedback;
+          if (!staged || body.previewId !== staged.id) throw new OperatorError(409, "review_required", "Review and confirm the staged feedback before sending.");
+          const result = await submitFeedback(staged.payload, process.env, { expectedPreview: staged.preview });
+          if (!result.ok) throw new OperatorError(409, "submission_failed", result.error ?? "Feedback could not be submitted.");
+          this.#feedback = null;
+          data = { saved: true, submitted: true };
+        } else {
+          if (body.submit !== void 0 && typeof body.submit !== "boolean") throw new OperatorError(400, "invalid_submission", "Submission must be explicitly selected.");
+          const payload = { message: text(body.message, "feedback", 16e3), timestamp: (/* @__PURE__ */ new Date()).toISOString(), version: VERSION };
+          const saved = appendFeedback(payload);
+          if (!saved.ok) throw new OperatorError(500, "persistence_failed", saved.error ?? "Could not save local feedback.");
+          if (body.submit === true) {
+            const preview = buildSubmitPreview(payload);
+            if (!preview) throw new OperatorError(409, "submission_unavailable", "Local feedback was saved, but reporting is opted out or no supported HTTPS destination is available.");
+            const id = randomUUID3();
+            this.#feedback = { id, payload, preview };
+            data = { saved: true, path: saved.path, submitted: false, previewId: id, preview: { ...preview, url: publicMessage(preview.url) } };
+          } else data = { saved: true, path: saved.path, submitted: false };
+        }
+      } else throw new OperatorError(405, "method_not_allowed", "This operation does not support that HTTP method.");
+      return { status, data };
+    } catch (error) {
+      return { status: error instanceof OperatorError ? error.status : 400, data: { error: publicMessage(error), code: error instanceof OperatorError ? error.code : "operation_failed" } };
+    }
+  }
+  dispose() {
+    this.#plan.cancel();
+    this.#codex.cancel();
+    for (const flow of this.#auth.values()) flow.session?.cancel();
+    pluginManager?.dispose();
+  }
+};
+
+export {
+  sanitizeComposerText,
+  createSessionPluginHostManager,
+  jwtVerify,
+  createRemoteJWKSet,
+  getWebConsolePluginHostManager,
+  flushWebConsolePlugins,
+  describeWebConsoleRuntime,
+  savedWebRuntimeSelection,
+  createWebConsoleRuntime,
+  reloadWebConsoleRuntimeConnection,
+  applyWebConsoleRuntimeSelection,
+  WebOperatorServices
+};