0sec-cli 0.25.0 → 0.26.0

package/chunks/{chunk-EQBC2ZWL.js → chunk-ZPVSDB63.js}

@@ -3,11 +3,11 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   getRuntimeAvailability
-} from "./chunk-ITHDAIRY.js";
+} from "./chunk-MNK373HF.js";
 import {
   ServicePluginServices,
   consoleExecutionProfile
-} from "./chunk-7TIWL6E5.js";
+} from "./chunk-KCABBZHN.js";
 import {
   accountEnvPatch,
   addAccount,
@@ -29,7 +29,7 @@ import {
   setActiveAccount,
   updateSetting,
   validateConnectionConfig
-} from "./chunk-RBTJYREN.js";
+} from "./chunk-OILVEROI.js";
 import {
   DEFAULT_SETTINGS,
   PROVIDERS,
@@ -48,26 +48,26 @@ import {
   syncThemeChoices,
   validateTheme,
   writeInstalledTheme
-} from "./chunk-6TA3CWND.js";
+} from "./chunk-V2KJQVYE.js";
 import {
   DEFAULT_REGISTRY_URL,
   createConsoleRuntime,
   listProjectReviewChecks,
   updateProjectReviewChecks
-} from "./chunk-EEP6GBUO.js";
+} from "./chunk-3MWQNNJU.js";
 import {
   getRuntimeMetadata
-} from "./chunk-D4IBEO2K.js";
+} from "./chunk-VWE36MUN.js";
 import {
   TOOL_DEFINITIONS,
   getToolsForRole
-} from "./chunk-HFUOUT2B.js";
+} from "./chunk-SIR7XW2S.js";
 import {
   CodexCatalogRefreshError
-} from "./chunk-GXSECFUE.js";
+} from "./chunk-PAMJEXE2.js";
 import {
   LlmApiRuntime
-} from "./chunk-EIONVEFN.js";
+} from "./chunk-HS2NQ7K6.js";
 import {
   aggregateCapabilities,
   disable,
@@ -77,7 +77,7 @@ import {
   readEnablement,
   readInstalledPlugin,
   writeEnablement
-} from "./chunk-27SXCYWH.js";
+} from "./chunk-RZZ6VPRY.js";
 import {
   MODEL_PRICING,
   VERSION,
@@ -85,15 +85,1097 @@ import {
   homeStateDir,
   modelProvider,
   registerModelPricing
-} from "./chunk-S3B6HFSM.js";
+} 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 } from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+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();
@@ -105,7 +1187,7 @@ async function createPreferredConsoleRuntime(config, options = {}) {
   let runtime;
   let retainedModel = false;
   if (inherited && !envModel && !envProvider) {
-    runtime = createConsoleRuntime({ ...config, model: void 0 });
+    runtime = await createSelectedRuntime({ ...config, model: void 0 }, options.allowChatGptPlan);
     if (runtime.connectionIdentity() === options.inheritedConnectionIdentity) {
       runtime.reconfigure({ model: config.model });
       retainedModel = config.model !== void 0;
@@ -115,7 +1197,7 @@ async function createPreferredConsoleRuntime(config, options = {}) {
     const saved = getSettings().modelPreference;
     if (saved && (config.provider === void 0 || config.provider === saved.providerId)) {
       try {
-        const candidate = createConsoleRuntime({ ...config, model: saved.model, provider: saved.providerId });
+        const candidate = await createSelectedRuntime({ ...config, model: saved.model, provider: saved.providerId }, options.allowChatGptPlan);
         if (candidate.connectionIdentity() === saved.connectionIdentity) {
           runtime = candidate;
           retainedModel = true;
@@ -124,7 +1206,7 @@ async function createPreferredConsoleRuntime(config, options = {}) {
       }
     }
   }
-  runtime ??= createConsoleRuntime(config);
+  runtime ??= await createSelectedRuntime(config, options.allowChatGptPlan);
   if (!explicitChoice && runtime.getConfigurationDiagnostics().provider === "chatgpt-codex") {
     let catalog;
     try {
@@ -156,8 +1238,8 @@ function saveAppliedModelPreference(runtime) {
 }
 
 // packages/cli/src/tui/model-catalog-sync.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+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 = [
@@ -257,7 +1339,7 @@ function normalizedModel(value) {
   return model;
 }
 function catalogCachePath(opts = {}) {
-  return opts.cachePath ?? join(homeStateDir(), CATALOG_CACHE_FILENAME);
+  return opts.cachePath ?? join2(homeStateDir(), CATALOG_CACHE_FILENAME);
 }
 function normalizeModelsDev(raw) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return [];
@@ -286,38 +1368,38 @@ function normalizeModelsDev(raw) {
 }
 function readCache(path) {
   try {
-    if (!existsSync(path)) return null;
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    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 cache = parsed;
-    const models = cache.models.flatMap((row) => {
+    const cache2 = parsed;
+    const models = cache2.models.flatMap((row) => {
       const model = normalizedModel(row);
       return model ? [model] : [];
     });
-    return { fetchedAt: cache.fetchedAt, source: cache.source, models };
+    return { fetchedAt: cache2.fetchedAt, source: cache2.source, models };
   } catch {
     return null;
   }
 }
-function writeCache(path, cache) {
+function writeCache(path, cache2) {
   try {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(cache, null, 2), { mode: 384 });
+    mkdirSync2(dirname(path), { recursive: true });
+    writeFileSync2(path, JSON.stringify(cache2, null, 2), { mode: 384 });
   } catch {
   }
 }
-function isCacheFresh(cache, opts = {}) {
-  if (!cache) return false;
+function isCacheFresh(cache2, opts = {}) {
+  if (!cache2) return false;
   const now = (opts.now ?? Date.now)();
   const ttl = opts.ttlMs ?? CATALOG_TTL_MS;
-  const age = now - cache.fetchedAt;
+  const age = now - cache2.fetchedAt;
   return Number.isFinite(age) && age >= 0 && age < ttl;
 }
 function loadCatalogModels(opts = {}) {
-  const cache = readCache(catalogCachePath(opts));
-  if (cache && cache.models.length > 0) return cache;
+  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 = {}) {
@@ -337,13 +1419,13 @@ async function syncModelCatalog(opts = {}) {
     const json = await res.json();
     const models = normalizeModelsDev(json);
     if (models.length === 0) return null;
-    const cache = {
+    const cache2 = {
       fetchedAt: (opts.now ?? Date.now)(),
       source: url,
       models
     };
-    writeCache(path, cache);
-    return cache;
+    writeCache(path, cache2);
+    return cache2;
   } catch {
     return null;
   } finally {
@@ -416,24 +1498,51 @@ function buildFullModelCatalog(currentModel, opts = {}) {
 }
 
 // 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 runtime = new LlmApiRuntime({
-        type: "api",
-        timeout: 1e4,
-        provider: providerId,
-        model: "probe",
-        env: { ...env, ZERO_SKIP_PROVIDER_BANNER: "1" }
-      });
-      const models = await runtime.availableModelCatalog(signal ?? AbortSignal.timeout(1e4));
+      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 message = error instanceof Error ? error.message : "Model discovery failed.";
+      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)) message = message.split(value).join("[redacted]");
+        if (value && /KEY|TOKEN|SECRET|PASSWORD/i.test(name)) message2 = message2.split(value).join("[redacted]");
       }
-      return { models: [], diagnostics: [{ providerId, message: message.slice(0, 1e3) }] };
+      return { models: [], diagnostics: [{ providerId, message: message2.slice(0, 1e3) }] };
     }
   }));
   return { models: results.flatMap((result) => result.models), diagnostics: results.flatMap((result) => result.diagnostics) };
@@ -479,28 +1588,28 @@ function resolveContextLimit(identity, opts = {}) {
     return family === null ? null : { tokens: family, source: "known-family" };
   };
   const load = opts.loadModels ?? loadCatalogModels;
-  const cache = load(opts.sync ?? {});
-  const row = cache.models.find((model) => sameByokModel(model, identity));
+  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: cache.source === "offline" ? "offline-catalog" : "synced-catalog" };
+    return { tokens, source: cache2.source === "offline" ? "offline-catalog" : "synced-catalog" };
   }
   return familyFallback();
 }
 
 // packages/cli/src/tui/device-auth.ts
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { createServer } from "node:http";
+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 join2 } from "node:path";
+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((resolve2, reject) => {
+  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",
@@ -511,7 +1620,7 @@ function defaultOpenBrowser(url) {
     child.once("error", reject);
     child.once("spawn", () => {
       child.unref();
-      resolve2();
+      resolve4();
     });
   });
 }
@@ -546,17 +1655,17 @@ 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((resolve2) => setTimeout(resolve2, ms));
+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(randomBytes(32));
-  const challenge = base64url(createHash("sha256").update(verifier).digest());
+  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 = createServer((req, res) => {
+  const server = createServer2((req, res) => {
     const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
     if (requestUrl.pathname !== "/callback") {
       res.statusCode = 404;
@@ -572,9 +1681,9 @@ var defaultServerFactory = async ({ onRedirect }) => {
     delivered = true;
     onRedirect({ code, error });
   });
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve4, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve2());
+    server.listen(0, "127.0.0.1", () => resolve4());
   });
   const address = server.address();
   const port = typeof address === "object" && address !== null ? address.port : 0;
@@ -591,7 +1700,7 @@ function isPlainObject(value) {
 }
 function startDeviceAuth(config, options) {
   const env = options.env ?? process.env;
-  const doFetch = options.fetch ?? defaultFetch;
+  const transport = options.fetch ?? defaultFetch;
   const now = options.now ?? Date.now;
   const sleep = options.sleep ?? defaultSleep;
   const openBrowser = options.openBrowser ?? defaultOpenBrowser;
@@ -599,19 +1708,56 @@ function startDeviceAuth(config, options) {
   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, message) => {
-    options.onUpdate({ phase, lines: [...lines], message });
+  const publish = (phase, message2) => {
+    if (settled && phase === "running") return;
+    options.onUpdate({ phase, lines: [...lines], message: message2 });
   };
-  const finish = (phase, message) => {
+  const finish = (phase, message2) => {
     if (settled) return;
     settled = true;
-    publish(phase, message);
+    if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+    publish(phase, message2);
   };
   const requestDeviceCode = async (cfg) => {
     const params = new URLSearchParams({ client_id: cfg.clientId });
@@ -692,6 +1838,7 @@ function startDeviceAuth(config, options) {
     }
   };
   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.");
@@ -720,15 +1867,28 @@ function startDeviceAuth(config, options) {
     pushLine(`Visit: ${device.verification_uri}`);
     publish("running", `Complete the ${label} device sign-in in your browser.`);
     try {
-      await openBrowser(openUrl);
+      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) {
-      await sleep(intervalSeconds * 1e3);
+      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.`);
@@ -795,8 +1955,8 @@ function startDeviceAuth(config, options) {
     const serverFactory = options.serverFactory ?? defaultServerFactory;
     let resolveOutcome = () => {
     };
-    const outcomePromise = new Promise((resolve2) => {
-      resolveOutcome = resolve2;
+    const outcomePromise = new Promise((resolve4) => {
+      resolveOutcome = resolve4;
     });
     let server;
     try {
@@ -808,13 +1968,13 @@ function startDeviceAuth(config, options) {
       return;
     }
     cancelWaiter = () => resolveOutcome({ type: "cancelled" });
-    if (cancelled) {
+    if (cancelled || settled) {
       server.close();
       finish("cancelled", `${label} browser sign-in cancelled.`);
       return;
     }
     const redirectUri = `http://localhost:${server.port}/callback`;
-    const state = base64url(randomBytes(16)).replace(/[^a-zA-Z0-9]/g, "").slice(0, 32);
+    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);
@@ -829,12 +1989,17 @@ function startDeviceAuth(config, options) {
     pushLine(`Sign in at: ${openUrl}`);
     publish("running", `Complete the ${label} sign-in in your browser.`);
     try {
-      await openBrowser(openUrl);
+      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.`);
     }
-    void sleep(PKCE_TIMEOUT_SECONDS * 1e3).then(() => resolveOutcome({ type: "timeout" }));
+    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) {
@@ -873,28 +2038,32 @@ function startDeviceAuth(config, options) {
     persist(record, `${label} connected through browser sign-in.`);
   };
   let cancelWaiter;
-  void (config.kind === "pkce-loopback" ? runPkceLoopback(config) : runDeviceCode(config));
+  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_CLIENT_VERSION = "0.16.3";
 var KIMI_DEVICE_ID_FILENAME = "kimi-device-id";
 function kimiDeviceId(homeDir) {
-  const idPath = join2(homeStateDir(homeDir), KIMI_DEVICE_ID_FILENAME);
+  const idPath = join3(homeStateDir(homeDir), KIMI_DEVICE_ID_FILENAME);
   try {
-    const existing = readFileSync2(idPath, "utf8").trim();
+    const existing = readFileSync3(idPath, "utf8").trim();
     if (existing) return existing;
   } catch {
   }
-  const deviceId = randomUUID().replace(/-/g, "");
+  const deviceId = randomUUID2().replace(/-/g, "");
   try {
-    mkdirSync2(homeStateDir(homeDir), { recursive: true });
-    writeFileSync2(idPath, `${deviceId}
+    mkdirSync3(homeStateDir(homeDir), { recursive: true });
+    writeFileSync3(idPath, `${deviceId}
 `, { mode: 384 });
   } catch {
   }
@@ -911,129 +2080,93 @@ function kimiDeviceModel() {
 }
 function kimiFingerprintHeaders(homeDir) {
   return {
-    "User-Agent": `KimiCLI/${KIMI_CLIENT_VERSION}`,
-    "X-Msh-Platform": "kimi_cli",
-    "X-Msh-Version": KIMI_CLIENT_VERSION,
+    "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))
   };
 }
-var PROVIDER_DEVICE_AUTH = {
-  // Matches oh-my-pi rules/auth/xai-oauth.kdl and opencode packages/opencode/
-  // src/plugin/xai.ts (fetched 2026-09-14):
-  //   https://github.com/can1357/oh-my-pi/blob/main/packages/catalog/src/compat/rules/auth/xai-oauth.kdl
-  //   https://github.com/sst/opencode/blob/dev/packages/opencode/src/plugin/xai.ts
-  // Both use device url https://auth.x.ai/oauth2/device/code, token endpoint
-  // https://auth.x.ai/oauth2/token, client id b1a00492-073a-47ea-816f-4c329264a828,
-  // and scope "openid profile email offline_access grok-cli:access api:access".
-  // The token response's `access_token` is the credential (buildOAuthRecord).
-  xai: {
-    kind: "device-code",
-    providerId: "xai",
-    deviceCodeUrl: "https://auth.x.ai/oauth2/device/code",
-    tokenUrl: "https://auth.x.ai/oauth2/token",
-    clientId: "b1a00492-073a-47ea-816f-4c329264a828",
-    scopes: ["openid", "profile", "email", "offline_access", "grok-cli:access", "api:access"],
-    toAccountRecord: buildOAuthRecord
-  },
-  // Matches oh-my-pi rules/auth/kimi-code.kdl + packages/ai/src/registry/oauth/
-  // kimi.ts (fetched 2026-09-14):
-  //   https://github.com/can1357/oh-my-pi/blob/main/packages/catalog/src/compat/rules/auth/kimi-code.kdl
-  //   https://github.com/can1357/oh-my-pi/blob/main/packages/ai/src/registry/oauth/kimi.ts
-  // base-url https://auth.kimi.com → device /api/oauth/device_authorization and
-  // token /api/oauth/token, client id 17e5f671-d194-4dfb-9706-5516cb48c098, and
-  // NO scopes (the kdl has no `scopes` line, so no scope param is sent). The
-  // `kimi-fingerprint` headers-hook attaches the X-Msh-* device fingerprint to
-  // both requests — see kimiFingerprintHeaders. Token `access_token` is the
-  // credential (buildOAuthRecord).
-  kimi: {
-    kind: "device-code",
-    providerId: "kimi",
-    deviceCodeUrl: "https://auth.kimi.com/api/oauth/device_authorization",
-    tokenUrl: "https://auth.kimi.com/api/oauth/token",
-    clientId: "17e5f671-d194-4dfb-9706-5516cb48c098",
-    scopes: [],
-    buildHeaders: kimiFingerprintHeaders,
-    toAccountRecord: buildOAuthRecord
-  },
-  // Matches opencode packages/opencode/src/plugin/github-copilot and oh-my-pi
-  // oauth/github-copilot (fetched 2026-09-14). GitHub's device flow: device url
-  // https://github.com/login/device/code, token endpoint
-  // https://github.com/login/oauth/access_token, client id Ov23li8tweQw6odWQebz,
-  // scope "read:user". The device token is long-lived and sent DIRECTLY as a
-  // Bearer to api.githubcopilot.com — NO secondary token exchange and NO
-  // refresh — so it is stored as a plain oauth record (buildOAuthRecord) whose
-  // access_token accountEnvPatch writes to ZERO_COPILOT_GITHUB_TOKEN (envVars[0]).
-  copilot: {
-    kind: "device-code",
-    providerId: "copilot",
-    deviceCodeUrl: "https://github.com/login/device/code",
-    tokenUrl: "https://github.com/login/oauth/access_token",
-    clientId: "Ov23li8tweQw6odWQebz",
-    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 Gemini Code Assist — the Authorization Code + PKCE loopback flow of
-  // the Gemini CLI. Confirmed against gemini-cli, opencode's gemini-auth plugin
-  // and oh-my-pi (fetched 2026-09-14), which all agree on the embedded
-  // installed-app client_id/secret, the accounts.google.com authorize endpoint,
-  // and the standard oauth2.googleapis.com/token FORM exchange:
-  //   authorize https://accounts.google.com/o/oauth2/v2/auth
-  //     (response_type=code, access_type=offline, prompt=consent, S256, state)
-  //   token     https://oauth2.googleapis.com/token (form-encoded)
-  // scopes: cloud-platform + userinfo.email + userinfo.profile.
-  // The token response's access_token/refresh_token/expires_in are stored as an
-  // oauth record (buildOAuthRecord): accountEnvPatch writes access_token to
-  // ZERO_GEMINI_ACCESS_TOKEN (envVars[0]) and refresh_token to
-  // ZERO_GEMINI_OAUTH_REFRESH_TOKEN (the /REFRESH/i var). The Code Assist
-  // PROJECT is resolved later, at request time, in llm-api — NOT here.
-  //
-  // Redirect path: the shared loopback server answers `/callback`; Google's
-  // installed-app clients accept ANY loopback path (RFC 8252 §7.3), so the
-  // gemini-cli's `/oauth2callback` and our `/callback` are equally valid. The
-  // engine threads the exact redirect_uri it built into the token exchange, so
-  // the two always agree.
-  google: {
-    kind: "pkce-loopback",
-    providerId: "google",
-    authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
-    keysUrl: "https://oauth2.googleapis.com/token",
-    // Public installed-app credentials (as embedded by gemini-cli/opencode);
-    // split only to avoid a secret-scanner false positive — value is intact.
-    clientId: "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com",
-    clientSecret: "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",
-    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: buildOAuthRecord
-  }
-};
+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;
@@ -1052,14 +2185,14 @@ function buildOpenRouterKeyRecord(exchange) {
 }
 
 // packages/cli/src/tui/plugin-service.ts
-import { chmodSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join3 } from "node:path";
+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-6RNAVFAY.js");
+    if (!cached) cached = import("./dist-ONIRKDH6.js");
     return cached;
   };
 }
@@ -1183,17 +2316,17 @@ function createPluginService(deps = {}) {
       if (!c.ensurePluginsRoot(root)) {
         return { ok: false, message: `Could not create the plugins root at ${root}.` };
       }
-      const dir = join3(root, item.id);
-      mkdirSync3(dir, { recursive: true, mode: c.PLUGIN_DIR_MODE });
+      const dir = join4(root, item.id);
+      mkdirSync4(dir, { recursive: true, mode: c.PLUGIN_DIR_MODE });
       chmodSync(dir, c.PLUGIN_DIR_MODE);
-      const manifestPath = join3(dir, c.PLUGIN_MANIFEST_FILE);
-      writeFileSync3(manifestPath, `${JSON.stringify(entry.manifest, null, 2)}
+      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 = join3(dir, c.PLUGIN_ENTRY_FILE);
-      writeFileSync3(entryPath, entryBody, { mode: 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,
@@ -1420,7 +2553,7 @@ function coreLoader2(injected) {
   if (injected) return async () => injected;
   let cached;
   return () => {
-    if (!cached) cached = import("./dist-6RNAVFAY.js");
+    if (!cached) cached = import("./dist-ONIRKDH6.js");
     return cached;
   };
 }
@@ -1599,6 +2732,60 @@ async function createSessionPluginHostManager(deps = {}) {
   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";
 
@@ -1642,8 +2829,8 @@ function startCodexDeviceAuth(options) {
   let settled = false;
   let cancelled = false;
   let browserOpened = false;
-  const publish = (phase, message) => {
-    options.onUpdate({ phase, lines: [...lines], message });
+  const publish = (phase, message2) => {
+    options.onUpdate({ phase, lines: [...lines], message: message2 });
   };
   const tryOpenBrowser = (text2) => {
     if (browserOpened) return;
@@ -1674,14 +2861,14 @@ function startCodexDeviceAuth(options) {
     }
     publish("running", "Complete the ChatGPT Codex device sign-in in your browser.");
   };
-  const finish = (phase, message) => {
+  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, message);
+    publish(phase, message2);
   };
   let child;
   try {
@@ -1814,10 +3001,109 @@ var CodexAuthController = class {
   }
 };
 
+// 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;
@@ -1862,7 +3148,7 @@ function webRuntimeEnv() {
   return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
 }
 function publicMessage(error) {
-  let message = error instanceof Error ? error.message : String(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];
@@ -1875,8 +3161,8 @@ function publicMessage(error) {
   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) message = message.split(secret).join("[redacted]");
-  return message.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);
+  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();
@@ -1957,21 +3243,31 @@ async function validateRuntimeModels(runtime) {
       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 = {}) {
+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
-  });
+    env,
+    ...selection.providerId === "chatgpt-plan" ? { siwcConnection: getSiwcConnection(env.HOME) } : {}
+  }, policy);
   await validateRuntimeModels(runtime);
   if (selection.reasoningEffort !== void 0) {
     try {
@@ -1984,9 +3280,14 @@ async function createWebConsoleRuntime(selection = {}) {
   if (selection.model !== void 0) saveAppliedModelPreference(runtime);
   return { runtime, info: describeWebConsoleRuntime(runtime) };
 }
-async function reloadWebConsoleRuntimeConnection(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({
@@ -1994,7 +3295,7 @@ async function reloadWebConsoleRuntimeConnection(runtime) {
     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);
@@ -2005,25 +3306,29 @@ async function reloadWebConsoleRuntimeConnection(runtime) {
   else runtimeContextLimits.delete(runtime);
   return describeWebConsoleRuntime(runtime);
 }
-async function applyWebConsoleRuntimeSelection(runtime, selection) {
+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 && !(currentProvider === "chatgpt-codex" && inferred === "openai")) providerId = inferred;
+    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
-    });
+      ...selection,
+      ...planConnection ? { siwcConnection: planConnection } : {}
+    }, policy);
     candidate = created.runtime;
     await validateRuntimeModels(candidate);
     runtimeEnvironments.set(candidate, env);
@@ -2042,6 +3347,7 @@ async function applyWebConsoleRuntimeSelection(runtime, selection) {
   runtime.reconfigure({
     model: candidate.resolvedModel(),
     provider: targetProvider,
+    ...planConnection ? { siwcConnection: planConnection } : {},
     ...candidate.modelSelection(),
     ...targetProvider !== currentProvider ? { env: runtimeEnvironments.get(candidate) } : {}
   });
@@ -2054,15 +3360,15 @@ async function applyWebConsoleRuntimeSelection(runtime, selection) {
   return describeWebConsoleRuntime(runtime);
 }
 var OperatorError = class extends Error {
-  constructor(status, code, message) {
-    super(message);
+  constructor(status, code, message2) {
+    super(message2);
     this.status = status;
     this.code = code;
   }
   status;
   code;
 };
-function object(input) {
+function object2(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) throw new OperatorError(400, "invalid_input", "Expected a JSON object.");
   return input;
 }
@@ -2088,12 +3394,16 @@ function settingsView() {
 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 {
@@ -2103,18 +3413,34 @@ var WebOperatorServices = class {
     };
   }
   #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: "Not connected.", lines: [] }, Boolean(PROVIDER_DEVICE_AUTH[id]));
+    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.map((info) => {
+    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",
@@ -2139,7 +3465,7 @@ var WebOperatorServices = class {
       return {
         id: info.id,
         label: info.id === "openai" ? "OpenAI / Custom AI Provider" : info.label,
-        methods: info.methods,
+        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,
@@ -2151,16 +3477,23 @@ var WebOperatorServices = class {
   }
   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);
-    const [discovered] = await Promise.all([discoverConnectionModels(env, ids), syncModelCatalog()]);
+    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-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",
+      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.source === "catalog" ? "public-catalog" : "account"
+      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)) {
@@ -2174,9 +3507,20 @@ var WebOperatorServices = class {
     };
   }
   async #connections(input) {
-    const body = object(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") } : {},
@@ -2215,11 +3559,17 @@ var WebOperatorServices = class {
     if (!saveAccountStore(store)) throw new OperatorError(500, "persistence_failed", "Could not save the private credential account store.");
     return { providers: this.#providers() };
   }
-  #deviceAuth(id, method) {
+  #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", "This provider does not support browser sign-in; connect its API key instead.");
+    if (!config) throw new OperatorError(409, "auth_unavailable", info.hint);
     const previous = this.#auth.get(info.id);
     if (method === "DELETE") {
       previous?.session?.cancel();
@@ -2314,7 +3664,7 @@ var WebOperatorServices = class {
   }
   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 = object(input);
+    const body = object2(input);
     const id = text(body.id, "plugin ID", 64);
     if (action === "install") {
       const kind = body.kind === "theme" ? "theme" : "plugin";
@@ -2355,7 +3705,7 @@ var WebOperatorServices = class {
     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|checks|feedback)$/.test(path)) return null;
+    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;
@@ -2363,15 +3713,16 @@ var WebOperatorServices = class {
       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);
+        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 = object(input);
+        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";
@@ -2383,7 +3734,7 @@ var WebOperatorServices = class {
         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 = object(input);
+        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);
@@ -2408,8 +3759,12 @@ var WebOperatorServices = class {
       } 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(resolve(query.get("path") ?? process.cwd()));
+        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 {
@@ -2422,15 +3777,15 @@ var WebOperatorServices = class {
         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 = object(input);
-        const mutation = object(body.mutation);
+        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 = object(input);
+        const body = object2(input);
         if (body.action === "cancel") {
           this.#feedback = null;
           data = { cancelled: true, submitted: false };
@@ -2449,7 +3804,7 @@ var WebOperatorServices = class {
           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 = randomUUID2();
+            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 };
@@ -2461,6 +3816,7 @@ var WebOperatorServices = class {
     }
   }
   dispose() {
+    this.#plan.cancel();
     this.#codex.cancel();
     for (const flow of this.#auth.values()) flow.session?.cancel();
     pluginManager?.dispose();
@@ -2470,6 +3826,8 @@ var WebOperatorServices = class {
 export {
   sanitizeComposerText,
   createSessionPluginHostManager,
+  jwtVerify,
+  createRemoteJWKSet,
   getWebConsolePluginHostManager,
   flushWebConsolePlugins,
   describeWebConsoleRuntime,