@miruzero/zero-agent 0.3.6 → 0.3.7

package/src/chatgpt/session/index.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const paths = require('../config/paths');
+const localStorage = require('./local-storage');
+const exchange = require('./exchange');
+const direct = require('../transport/direct/http-client');
+const directTransport = require('./direct-transport');
+
+const nowIso = () => new Date().toISOString();
+const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+const writeJson = (file, value) => { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 }); };
+
+exports.validate = (result) => {
+  const body = result?.body ?? result;
+  const status = result?.status ?? 200;
+  const authenticated = Boolean(body && typeof body === 'object' && !Array.isArray(body) && (body.user || body.account || body.accessToken || body.sessionToken));
+  if (status === 200 && authenticated) return { status, body, source: exchange.SESSION_SOURCE };
+  throw Object.assign(new Error('ChatGPT final session response is not authenticated'), { code: status === 200 ? 'CHATGPT_SESSION_NOT_AUTHENTICATED' : 'CHATGPT_SESSION_FETCH_FAILED', status });
+};
+
+exports.resolveTransport = (env = process.env) => {
+  const modulePath = env.ZERO_CHATGPT_SESSION_TRANSPORT_MODULE;
+  if (!modulePath) return directTransport.transport;
+  const resolved = require.resolve(modulePath); delete require.cache[resolved];
+  const loaded = require(resolved);
+  const transport = typeof loaded === 'function' ? loaded : loaded.transport || loaded.exchangeSession;
+  if (typeof transport !== 'function') throw Object.assign(new Error('Configured ChatGPT session transport is invalid'), { code: 'CHATGPT_SESSION_TRANSPORT_INVALID' });
+  return transport;
+};
+
+exports.status = ({ env = process.env } = {}) => {
+  const file = paths.sessionFile(env);
+  if (!fs.existsSync(file)) return { present: false, status: 'missing', redacted: true, file };
+  const data = readJson(file);
+  if (!data) return { present: true, status: 'invalid', redacted: true, file };
+  const headerNames = data.headers && typeof data.headers === 'object' ? Object.keys(data.headers) : [];
+  return { present: true, status: 'present', redacted: true, source: data.source || null, expires: data.expires || null, updatedAt: data.updatedAt || null, headerNames, file };
+};
+
+exports.acquire = async ({
+  env = process.env,
+  transport,
+  acquireMarker = localStorage.acquireLocalSessionMarker,
+  requestJson = direct.requestJson,
+  fresh = false,
+  persist = true
+} = {}) => {
+  const file = paths.sessionFile(env);
+  const previous = readJson(file) || {};
+  let sessionHeaders = previous.headers && typeof previous.headers === 'object' && !Array.isArray(previous.headers)
+    ? { ...previous.headers }
+    : null;
+  let profile = previous.profile || null;
+  let result = null;
+
+  if (sessionHeaders && !fresh) {
+    const fetched = await requestJson('/api/auth/session', null, sessionHeaders, {
+      route: '/api/auth/session', env, sessionFile: file
+    });
+    if (fetched?.status === 200) {
+      try { result = exports.validate({ status: fetched.status, body: fetched.json }); }
+      catch (error) { if (error?.code !== 'CHATGPT_SESSION_NOT_AUTHENTICATED') throw error; }
+    } else if (![401, 403].includes(Number(fetched?.status))) {
+      exports.validate({ status: fetched?.status || 0, body: fetched?.json });
+    }
+  }
+
+  if (!result) {
+    const local = await acquireMarker({ env });
+    profile = local.profile || null;
+    const selectedTransport = transport || exports.resolveTransport(env);
+    const exchanged = await exchange.exchangeSession({ sessionMarker: local.sessionMarker, workspaceAccountId: local.workspaceAccountId || null, profile, env, transport: selectedTransport });
+    result = exports.validate(exchanged);
+    if (exchanged.sessionHeaders && typeof exchanged.sessionHeaders === 'object') sessionHeaders = { ...exchanged.sessionHeaders };
+  }
+
+  if (persist) {
+    const next = {
+      ...(sessionHeaders ? { headers: sessionHeaders } : {}),
+      source: 'api-auth-session',
+      updatedAt: nowIso(),
+      expires: result.body?.expires || previous.expires || null,
+      profile
+    };
+    writeJson(file, next);
+  }
+  return { ...result, profile };
+};exports.SESSION_STORAGE_KEY = localStorage.SESSION_STORAGE_KEY;
+exports.SESSION_SOURCE = exchange.SESSION_SOURCE;
+exports.resolveChromeDataRoot = (env = process.env) => localStorage.resolveChromeDataRoot(env);
+exports.detectProfile = (chromeRoot, env = process.env) => localStorage.detectProfile(chromeRoot, env);
+exports.copySnapshot = (source, destination) => localStorage.copySnapshot(source, destination);
+exports.decodeStorageKey = (value) => localStorage.decodeStorageKey(value);
+exports.decodeStorageValue = (value) => localStorage.decodeStorageValue(value);
+exports.readLocalStorage = (databasePath) => localStorage.readLocalStorage(databasePath);
+exports.extractSessionMarker = (storage) => localStorage.extractSessionMarker(storage);
+exports.extractSessionSelection = (storage) => localStorage.extractSessionSelection(storage);
+exports.acquireLocalSessionMarker = (input = {}) => localStorage.acquireLocalSessionMarker(input);
+exports.normalizeResult = (result) => exchange.normalizeResult(result);
+exports.exchangeSession = (input = {}) => exchange.exchangeSession(input);

package/src/chatgpt/session/local-storage.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { ClassicLevel } = require('classic-level');
+
+const DOMAIN = 'chatgpt.com';
+const DEFAULT_PROFILE = 'Default';
+exports.SESSION_STORAGE_KEY = 'oai/apps/accountSwitchSessions';
+
+exports.resolveChromeDataRoot = (env = process.env) => {
+  const localAppData = env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+  return path.join(localAppData, 'Google', 'Chrome', 'User Data');
+};
+exports.detectProfile = (chromeRoot, env = process.env) => {
+  if (env.ZERO_CHATGPT_CHROME_PROFILE) return env.ZERO_CHATGPT_CHROME_PROFILE;
+  try { return JSON.parse(fs.readFileSync(path.join(chromeRoot, 'Local State'), 'utf8')).profile?.last_used || DEFAULT_PROFILE; }
+  catch { return DEFAULT_PROFILE; }
+};
+const isSnapshotFile = (name) => name.endsWith('.ldb') || name.endsWith('.log') || name === 'CURRENT' || name.startsWith('MANIFEST-');
+exports.copySnapshot = (source, destination) => {
+  if (!fs.existsSync(source)) throw Object.assign(new Error('ChatGPT local storage not found'), { code: 'CHATGPT_STORAGE_NOT_FOUND' });
+  fs.mkdirSync(destination, { recursive: true });
+  for (const name of fs.readdirSync(source)) {
+    if (!isSnapshotFile(name) || name.toLowerCase() === 'lock') continue;
+    try { fs.copyFileSync(path.join(source, name), path.join(destination, name)); } catch {}
+  }
+};
+exports.decodeStorageKey = (rawKey) => {
+  if (!rawKey?.length || rawKey[0] !== 0x5f) return null;
+  const full = rawKey.toString('utf8');
+  if (!full.toLowerCase().includes(DOMAIN)) return null;
+  const twoByte = rawKey.indexOf(Buffer.from([0x00, 0x01]));
+  if (twoByte !== -1) return rawKey.subarray(twoByte + 2).toString('utf8') || null;
+  const oneByte = rawKey.indexOf(0x00);
+  if (oneByte !== -1) return rawKey.subarray(oneByte + 1).toString('utf8') || null;
+  return full.replace(/^[^A-Za-z0-9_-]+/, '') || null;
+};
+exports.decodeStorageValue = (rawValue) => {
+  if (!rawValue?.length) return '';
+  const content = rawValue.subarray(1);
+  if (rawValue[0] === 0x00) return content.toString('utf16le');
+  return content.toString('utf8').replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+};
+exports.readLocalStorage = async (databasePath) => {
+  const storage = {};
+  const database = new ClassicLevel(databasePath, { keyEncoding: 'buffer', valueEncoding: 'buffer' });
+  await database.open();
+  try { for await (const [rawKey, rawValue] of database.iterator()) { const key = exports.decodeStorageKey(rawKey); if (key) storage[key] = exports.decodeStorageValue(rawValue); } }
+  finally { await database.close(); }
+  return storage;
+};
+exports.extractSessionSelection = (storage = {}) => {
+  const raw = storage[exports.SESSION_STORAGE_KEY];
+  if (!raw) return null;
+  let sessions;
+  try { sessions = JSON.parse(raw); } catch { return null; }
+  if (!Array.isArray(sessions)) return null;
+  const session = sessions.find((item) => typeof item?.sessionToken === 'string' && item.sessionToken.length > 0);
+  if (!session) return null;
+  const workspaces = Array.isArray(session.workspaces) ? session.workspaces : [];
+  const personal = workspaces.find((workspace) =>
+    workspace?.isPersonalWorkspace === true &&
+    workspace?.isDeactivated !== true &&
+    typeof workspace?.workspaceAccountId === 'string' &&
+    workspace.workspaceAccountId.length > 0
+  );
+  return { sessionMarker: session.sessionToken, workspaceAccountId: personal?.workspaceAccountId || null };
+};
+exports.extractSessionMarker = (storage = {}) => exports.extractSessionSelection(storage)?.sessionMarker || null;
+const readMarkerFromProfile = async (chromeRoot, profile) => {
+  const source = path.join(chromeRoot, profile, 'Local Storage', 'leveldb');
+  if (!fs.existsSync(source)) return null;
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'zero-chatgpt-'));
+  const snapshot = path.join(tempRoot, 'leveldb');
+  try {
+    exports.copySnapshot(source, snapshot);
+    const storage = await exports.readLocalStorage(snapshot);
+    const selection = exports.extractSessionSelection(storage);
+    return selection ? { ...selection, profile } : null;
+  } finally { fs.rmSync(tempRoot, { recursive: true, force: true }); }
+};
+exports.acquireLocalSessionMarker = async ({ env = process.env } = {}) => {
+  const chromeRoot = exports.resolveChromeDataRoot(env);
+  const preferred = exports.detectProfile(chromeRoot, env);
+  const preferredResult = await readMarkerFromProfile(chromeRoot, preferred);
+  if (preferredResult) return preferredResult;
+  if (env.ZERO_CHATGPT_CHROME_PROFILE) {
+    throw Object.assign(new Error(`No ChatGPT local session marker was found in profile ${preferred}`), { code: 'CHATGPT_LOCAL_SESSION_NOT_FOUND', profile: preferred });
+  }
+  const candidates = [];
+  for (const entry of fs.readdirSync(chromeRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name === preferred) continue;
+    const result = await readMarkerFromProfile(chromeRoot, entry.name);
+    if (result) candidates.push(result);
+  }
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length > 1) {
+    throw Object.assign(new Error('Multiple Chrome profiles contain ChatGPT local session markers'), {
+      code: 'CHATGPT_LOCAL_SESSION_AMBIGUOUS',
+      profiles: candidates.map((item) => item.profile)
+    });
+  }
+  throw Object.assign(new Error('No ChatGPT local session marker was found'), { code: 'CHATGPT_LOCAL_SESSION_NOT_FOUND' });
+};

package/src/chatgpt/transport/direct/http-client.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const https = require('node:https');
+const fs = require('node:fs');
+const path = require('node:path');
+const paths = require('../../config/paths');
+
+const RETRY_AFTER_CAP_MS = 30000;
+const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 30000;
+const MAX_RATE_LIMIT_COOLDOWN_MS = 15 * 60 * 1000;
+
+const cleanHeaders = (input = {}) => Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null));
+const mergeSetCookies = (cookieString, setCookie) => {
+  const jar = new Map();
+  for (const pair of String(cookieString || '').split(';')) {
+    const index = pair.indexOf('=');
+    if (index > 0) jar.set(pair.slice(0, index).trim(), pair.slice(index + 1).trim());
+  }
+  for (const entry of Array.isArray(setCookie) ? setCookie : [setCookie]) {
+    const first = String(entry || '').split(';')[0];
+    const index = first.indexOf('=');
+    if (index > 0) jar.set(first.slice(0, index).trim(), first.slice(index + 1).trim());
+  }
+  return [...jar].map(([name, value]) => `${name}=${value}`).join('; ');
+};
+
+const rateLimitFileOf = (token, options = {}) => {
+  if (options.rateLimitFile === false) return null;
+  if (typeof options.rateLimitFile === 'string' && options.rateLimitFile.trim()) return path.resolve(options.rateLimitFile);
+  if (options.rateLimitFile === undefined && process.env.NODE_TEST_CONTEXT) return null;
+  return paths.rateLimitFile(options.env || process.env, token);
+};
+const readRateLimitState = (file) => {
+  if (!file || !fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+};
+const writeRateLimitState = (file, state) => {
+  if (!file) return;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temp, file);
+};
+const cleanupExpiredRateLimitStates = (options = {}) => {
+  if (options.rateLimitFile === false) return;
+  const env = options.env || process.env;
+  const files = [];
+  if (typeof options.rateLimitFile === 'string' && options.rateLimitFile.trim()) {
+    files.push(path.resolve(options.rateLimitFile));
+  } else {
+    const dir = paths.rateLimitDir(env);
+    try {
+      for (const name of fs.readdirSync(dir)) {
+        if (/^rate-limit-[a-f0-9]{16}\.json$/i.test(name)) files.push(path.join(dir, name));
+      }
+    } catch {}
+  }
+  const now = Date.now();
+  for (const file of files) {
+    const retryAt = Date.parse(readRateLimitState(file)?.retry_not_before || '');
+    if (!Number.isFinite(retryAt) || retryAt > now) continue;
+    try { fs.rmSync(file, { force: true }); } catch {}
+  }
+};
+
+const localRateLimitResponse = (token, options, parseBody) => {
+  const file = rateLimitFileOf(token, options);
+  const state = readRateLimitState(file);
+  const retryAt = Date.parse(state?.retry_not_before || '');
+  if (!Number.isFinite(retryAt) || retryAt <= Date.now()) return null;
+  const retryAfterMs = retryAt - Date.now();
+  return {
+    status: 429,
+    ...(parseBody ? { json: { detail: 'Too many requests' } } : { text: '{"detail":"Too many requests"}' }),
+    contentType: 'application/json',
+    headers: { 'retry-after': String(Math.max(1, Math.ceil(retryAfterMs / 1000))) },
+    localRateLimit: true
+  };
+};
+const recordRateLimitState = (response, token, options = {}) => {
+  const file = rateLimitFileOf(token, options);
+  if (!file || !response) return;
+  if (response.status === 429) {
+    const previous = readRateLimitState(file);
+    const consecutive = previous?.status === 429 ? Number(previous.consecutive_429 || 0) + 1 : 1;
+    const exponentialMs = Math.min(DEFAULT_RATE_LIMIT_COOLDOWN_MS * (2 ** Math.min(consecutive - 1, 8)), MAX_RATE_LIMIT_COOLDOWN_MS);
+    const serverMs = exports.parseRetryAfterMs(response.headers || {}) || 0;
+    const cooldownMs = Math.max(exponentialMs, serverMs);
+    writeRateLimitState(file, {
+      status: 429,
+      consecutive_429: consecutive,
+      observed_at: new Date().toISOString(),
+      retry_after_ms: cooldownMs,
+      retry_not_before: new Date(Date.now() + cooldownMs).toISOString()
+    });
+    return;
+  }
+  if (response.status >= 200 && response.status < 400) {
+    const state = readRateLimitState(file);
+    const retryAt = Date.parse(state?.retry_not_before || '');
+    if (Number.isFinite(retryAt) && retryAt <= Date.now()) {
+      try { fs.rmSync(file, { force: true }); } catch {}
+    }
+  }
+};
+
+exports.persistResponseHeaders = (sessionHeaders = {}, responseHeaders = {}, options = {}) => {
+  const setCookie = responseHeaders['set-cookie'];
+  if (!setCookie) return { changed: false, persisted: false };
+  const currentCookie = sessionHeaders.Cookie || sessionHeaders.cookie || '';
+  const cookie = mergeSetCookies(currentCookie, setCookie);
+  const changed = cookie !== currentCookie;
+  if (!changed) return { changed: false, persisted: false };
+  sessionHeaders.Cookie = cookie;
+  delete sessionHeaders.cookie;
+  if (options.persistSession === false) return { changed: true, persisted: false };
+  const sessionFile = options.sessionFile || paths.sessionFile(options.env || process.env);
+  if (!fs.existsSync(sessionFile)) return { changed: true, persisted: false };
+  const data = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+  if (data.headers && typeof data.headers === 'object') {
+    data.headers.Cookie = cookie;
+    delete data.headers.cookie;
+  } else data.cookie = cookie;
+  data.updatedAt = new Date().toISOString();
+  fs.writeFileSync(sessionFile, `${JSON.stringify(data, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  return { changed: true, persisted: true };
+};
+
+exports.buildHeaders = (token, sessionHeaders = {}, target, targetRoute) => {
+  const targetPath = target.split('?')[0];
+  return cleanHeaders({ ...sessionHeaders, ...(token ? { authorization: `Bearer ${token}` } : {}), 'x-openai-target-path': targetPath, 'x-openai-target-route': targetRoute || targetPath });
+};
+exports.parseRetryAfterMs = (headers = {}) => {
+  const raw = headers['retry-after'];
+  if (!raw) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.min(Math.max(seconds, 0) * 1000, RETRY_AFTER_CAP_MS);
+  const at = Date.parse(raw);
+  if (Number.isFinite(at)) return Math.min(Math.max(at - Date.now(), 0), RETRY_AFTER_CAP_MS);
+  return null;
+};
+const safeParse = (text) => { try { return JSON.parse(text); } catch { return null; } };
+const rawRequest = (target, token, sessionHeaders, options, parseBody) => new Promise((resolve, reject) => {
+  const payload = options.body === undefined ? null : Buffer.from(JSON.stringify(options.body));
+  let headers = exports.buildHeaders(token, sessionHeaders, target, options.route);
+  if (options.headers) headers = cleanHeaders({ ...headers, ...options.headers });
+  if (payload) { headers['content-type'] = 'application/json'; headers['content-length'] = String(payload.length); }
+  const req = https.request(`https://chatgpt.com${target}`, { method: options.method || 'GET', headers }, (res) => {
+    const chunks = [];
+    let ended = false;
+    const aborted = () => {
+      const error = new Error(`ChatGPT upstream stream aborted: ${target}`);
+      error.code = 'UPSTREAM_ABORTED';
+      reject(error);
+    };
+    res.on('data', (chunk) => { options.onChunk?.(chunk); chunks.push(chunk); });
+    res.on('end', () => {
+      ended = true;
+      const text = Buffer.concat(chunks).toString('utf8');
+      const response = { status: res.statusCode, ...(parseBody ? { json: safeParse(text) } : { text }), contentType: res.headers['content-type'] || null, headers: { ...res.headers } };
+      exports.persistResponseHeaders(sessionHeaders, response.headers, options);
+      resolve(response);
+    });
+    res.on('aborted', aborted);
+    res.on('error', reject);
+    res.on('close', () => { if (!ended) aborted(); });
+  });
+  req.on('error', reject);
+  if (Number.isFinite(options.idleTimeoutMs) && options.idleTimeoutMs > 0 && typeof req.setTimeout === 'function') {
+    req.setTimeout(options.idleTimeoutMs, () => {
+      const error = new Error(`ChatGPT upstream stream idle timeout: ${target}`);
+      error.code = 'UPSTREAM_IDLE_TIMEOUT';
+      req.destroy(error);
+    });
+  }
+  if (payload) req.write(payload);
+  req.end();
+});
+const guardedRequest = async (target, token, sessionHeaders, options, parseBody) => {
+  cleanupExpiredRateLimitStates(options);
+  const limited = localRateLimitResponse(token, options, parseBody);
+  if (limited) return limited;
+  const response = await rawRequest(target, token, sessionHeaders, options, parseBody);
+  recordRateLimitState(response, token, options);
+  return response;
+};
+exports.requestJson = (target, token, sessionHeaders = {}, options = {}) =>
+  guardedRequest(target, token, sessionHeaders, options, true);
+exports.requestText = (target, token, sessionHeaders = {}, options = {}) =>
+  guardedRequest(target, token, sessionHeaders, options, false);
+

package/src/chatgpt-auth.js

@@ -1,121 +1,27 @@
 'use strict';
 
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const crypto = require('node:crypto');
+const runtime = require('./chatgpt-runtime');
 
 const provider = 'chatgpt';
 
-const defaultMcpHome = (env = process.env) => env.ZERO_MCP_HOME || path.join(os.homedir(), '.zero_mcp');
-const defaultAuthFile = (env = process.env) => path.join(defaultMcpHome(env), 'chatgpt', 'auth.json');
-const resolveAuthFile = (env = process.env) => env.ZERO_CHATGPT_AUTH_FILE || defaultAuthFile(env);
+exports.resolveAuthFile = (env = process.env) => runtime.load(env).auth.file(env);
+exports.defaultAuthFile = exports.resolveAuthFile;
+exports.defaultMcpHome = (env = process.env) => runtime.load(env).paths.stateDir(env);
 
-const sha256 = (value) => crypto.createHash('sha256').update(String(value)).digest('hex');
-const nowIso = () => new Date().toISOString();
-
-const parseMaybeJson = (text) => {
-  try {
-    return { ok: true, value: JSON.parse(text) };
-  } catch (error) {
-    return { ok: false, error: error.message || String(error) };
-  }
+exports.status = ({ env = process.env } = {}) => {
+  const auth = runtime.load(env).auth.status({ env });
+  return { ok: true, provider, auth, file: auth.file || exports.resolveAuthFile(env) };
 };
 
-const ensureInput = (input) => {
+exports.ensure = async ({ env = process.env } = {}) => runtime.load(env).auth.ensure({ env });
+exports.login = async ({ env = process.env } = {}) => runtime.load(env).auth.login({ env });
+
+exports.importAuth = ({ input, env = process.env, source = 'zero-agent' } = {}) => {
   const text = String(input || '').trim();
-  if (!text) {
-    const error = new Error('input is required');
-    error.code = 'BAD_AUTH_INPUT';
-    throw error;
-  }
-  return text;
+  if (!text) throw Object.assign(new Error('input is required'), { code: 'BAD_AUTH_INPUT' });
+  let body;
+  try { body = JSON.parse(text); }
+  catch { throw Object.assign(new Error('ChatGPT auth input must be JSON session data'), { code: 'BAD_AUTH_INPUT' }); }
+  const auth = runtime.load(env).auth.importSession({ body, env, source });
+  return { ok: true, provider, file: auth.file, auth };
 };
-const status = ({ env = process.env } = {}) => {
-  const file = resolveAuthFile(env);
-  if (!fs.existsSync(file)) {
-    return {
-      ok: true,
-      provider,
-      auth: { present: false, status: 'missing', redacted: true },
-      file
-    };
-  }
-  const stat = fs.statSync(file);
-  let storedStatus = 'imported-test-fixture';
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    storedStatus = parsed.status || storedStatus;
-  } catch {}
-  return {
-    ok: true,
-    provider,
-    auth: {
-      present: true,
-      status: storedStatus,
-      redacted: true,
-      updated_at: stat.mtime.toISOString(),
-      size: stat.size
-    },
-    file
-  };
-};
-
-const importAuth = ({ input, env = process.env, source = 'zero-agent' } = {}) => {
-  const text = ensureInput(input);
-  const parsed = parseMaybeJson(text);
-  const timestamp = nowIso();
-  const payload = {
-    provider,
-    mode: 'dev-fixture',
-    status: 'imported-test-fixture',
-    source,
-    created_at: timestamp,
-    updated_at: timestamp,
-    validation: {
-      session: 'not-run',
-      sentinel: 'not-run',
-      capability_probe: 'not-run'
-    },
-    security: {
-      raw_secret_return_allowed: false,
-      logs_allowed: false,
-      rotation_required: false
-    },
-    imported: {
-      format: parsed.ok ? 'json' : 'text',
-      parse_error: parsed.ok ? null : parsed.error,
-      sha256: sha256(text),
-      byte_length: Buffer.byteLength(text, 'utf8')
-    },
-    session: parsed.ok ? parsed.value : { raw_text: text }
-  };
-  const file = resolveAuthFile(env);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, JSON.stringify(payload, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
-  return {
-    ok: true,
-    provider,
-    file,
-    auth: {
-      present: true,
-      status: payload.status,
-      mode: payload.mode,
-      redacted: true,
-      updated_at: payload.updated_at,
-      input_format: payload.imported.format,
-      input_sha256: payload.imported.sha256,
-      byte_length: payload.imported.byte_length
-    }
-  };
-};
-
-const chatgptAuth = {
-  defaultMcpHome,
-  defaultAuthFile,
-  resolveAuthFile,
-  status,
-  importAuth
-};
-
-Object.assign(exports, chatgptAuth);

package/src/chatgpt-runtime.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const path = require('node:path');
+
+const root = path.resolve(__dirname, 'chatgpt');
+
+exports.root = () => root;
+exports.load = () => require(root);

package/src/chatgpt-session-exchange.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const runtime = require('./chatgpt-runtime');
+const session = (env = process.env) => runtime.load(env).session;
+
+exports.SESSION_SOURCE = session().SESSION_SOURCE;
+exports.normalizeResult = (result, env = process.env) => session(env).normalizeResult(result);
+exports.exchangeSession = (input = {}) => session(input.env || process.env).exchangeSession(input);

package/src/chatgpt-session.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const runtime = require('./chatgpt-runtime');
+
+const session = (env = process.env) => runtime.load(env).session;
+
+exports.SESSION_STORAGE_KEY = session().SESSION_STORAGE_KEY;
+exports.SESSION_SOURCE = session().SESSION_SOURCE;
+
+exports.resolveChromeDataRoot = (env = process.env) => session(env).resolveChromeDataRoot(env);
+exports.detectProfile = (chromeRoot, env = process.env) => session(env).detectProfile(chromeRoot, env);
+exports.copySnapshot = (source, destination, env = process.env) => session(env).copySnapshot(source, destination);
+exports.decodeStorageKey = (value, env = process.env) => session(env).decodeStorageKey(value);
+exports.decodeStorageValue = (value, env = process.env) => session(env).decodeStorageValue(value);
+exports.readLocalStorage = (databasePath, env = process.env) => session(env).readLocalStorage(databasePath);
+exports.extractSessionMarker = (storage, env = process.env) => session(env).extractSessionMarker(storage);
+exports.acquireLocalSessionMarker = ({ env = process.env } = {}) => session(env).acquireLocalSessionMarker({ env });
+
+exports.isAuthenticatedSession = (body, env = process.env) => {
+  try { session(env).validate({ status: 200, body }); return true; }
+  catch { return false; }
+};
+exports.validateFinalSession = (result, env = process.env) => session(env).validate(result);
+exports.resolveTransport = (env = process.env) => session(env).resolveTransport(env);
+exports.fetchSession = ({ env = process.env, transport } = {}) =>
+  session(env).acquire({ env, ...(transport ? { transport } : {}) });