@miruzero/zgpt 0.1.0 → 0.1.1

package/src/session/direct-transport.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const fs = require('node:fs');
+const paths = require('../config/paths');
+const direct = require('../transport/direct/http-client');
+
+const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+const mergeSetCookies = (cookieString, setCookie) => {
+  const jar = new Map();
+  const add = (entry) => {
+    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());
+  };
+  for (const pair of String(cookieString || '').split(';')) add(pair);
+  for (const entry of Array.isArray(setCookie) ? setCookie : [setCookie]) add(entry);
+  return [...jar].map(([name, value]) => `${name}=${value}`).join('; ');
+};
+const bootstrapHeaders = (env) => {
+  const state = readJson(paths.sessionFile(env)) || {};
+  const saved = state.headers && typeof state.headers === 'object' && !Array.isArray(state.headers) ? state.headers : {};
+  const { Cookie: _cookie, cookie: _cookieLower, authorization: _authorization, ...safe } = saved;
+  return {
+    ...safe,
+    origin: safe.origin || 'https://chatgpt.com',
+    referer: safe.referer || 'https://chatgpt.com/',
+    accept: safe.accept || 'application/json'
+  };
+};
+
+exports.createTransport = ({ requestJson = direct.requestJson } = {}) => async ({ sessionMarker, workspaceAccountId = null, env = process.env } = {}) => {
+  if (!sessionMarker || typeof sessionMarker !== 'string') {
+    throw Object.assign(new Error('Missing local ChatGPT session marker'), { code: 'CHATGPT_SESSION_MARKER_MISSING' });
+  }
+  const sessionFile = paths.sessionFile(env);
+  const sessionHeaders = bootstrapHeaders(env);
+  const first = await requestJson('/api/auth/session', sessionMarker, sessionHeaders, {
+    route: '/api/auth/session', env, sessionFile, persistSession: false
+  });
+  if (![200, 403].includes(Number(first?.status))) {
+    throw Object.assign(new Error('ChatGPT session bootstrap round one failed'), { code: 'CHATGPT_SESSION_BOOTSTRAP_FAILED', status: first?.status || 0 });
+  }
+  const cookie = mergeSetCookies('', first?.headers?.['set-cookie']);
+  if (!cookie) {
+    throw Object.assign(new Error('ChatGPT session bootstrap did not return a cookie'), { code: 'CHATGPT_SESSION_BOOTSTRAP_COOKIE_MISSING', status: first?.status || 0 });
+  }
+  sessionHeaders.Cookie = cookie;
+  const switched = await requestJson('/account-switch/switch', null, sessionHeaders, {
+    method: 'POST',
+    body: workspaceAccountId ? { workspaceAccountId } : {},
+    route: '/account-switch/switch',
+    headers: { 'OAI-Account-Switch-Session-Token': sessionMarker },
+    env,
+    sessionFile,
+    persistSession: false
+  });
+  if (!switched || switched.status < 200 || switched.status >= 300) {
+    throw Object.assign(new Error('ChatGPT direct session exchange failed'), { code: 'CHATGPT_SESSION_EXCHANGE_FAILED', status: switched?.status || 0 });
+  }
+  const switchedCookie = mergeSetCookies(sessionHeaders.Cookie, switched?.headers?.['set-cookie']);
+  if (switchedCookie) sessionHeaders.Cookie = switchedCookie;
+  const second = await requestJson('/api/auth/session', null, sessionHeaders, {
+    route: '/api/auth/session', env, sessionFile, persistSession: false
+  });
+  return { status: Number(second?.status || 0), body: second?.json ?? null, sessionHeaders };
+};
+
+exports.transport = exports.createTransport();

package/src/session/exchange.js

@@ -1,12 +1,17 @@
-'use strict';
+'use strict';
 
 exports.SESSION_SOURCE = 'https://chatgpt.com/api/auth/session';
 exports.normalizeResult = (result) => {
   if (!result || typeof result !== 'object') throw Object.assign(new Error('ChatGPT session exchange returned an invalid result'), { code: 'CHATGPT_SESSION_EXCHANGE_INVALID_RESULT' });
-  return { status: Number(result.status || 0), body: result.body ?? result.data ?? null, source: exports.SESSION_SOURCE };
+  return {
+    status: Number(result.status || 0),
+    body: result.body ?? result.data ?? null,
+    source: exports.SESSION_SOURCE,
+    sessionHeaders: result.sessionHeaders && typeof result.sessionHeaders === 'object' ? { ...result.sessionHeaders } : null
+  };
 };
-exports.exchangeSession = async ({ sessionMarker, profile, env = process.env, transport } = {}) => {
+exports.exchangeSession = async ({ sessionMarker, workspaceAccountId = null, profile, env = process.env, transport } = {}) => {
   if (!sessionMarker || typeof sessionMarker !== 'string') throw Object.assign(new Error('Missing local ChatGPT session marker'), { code: 'CHATGPT_SESSION_MARKER_MISSING' });
   if (typeof transport !== 'function') throw Object.assign(new Error('ChatGPT session exchange transport is required'), { code: 'CHATGPT_SESSION_EXCHANGE_TRANSPORT_REQUIRED' });
-  return exports.normalizeResult(await transport({ sessionMarker, profile: profile || null, env, sessionSource: exports.SESSION_SOURCE }));
+  return exports.normalizeResult(await transport({ sessionMarker, workspaceAccountId, profile: profile || null, env, sessionSource: exports.SESSION_SOURCE }));
 };

package/src/session/index.js

@@ -1,70 +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 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) throw Object.assign(new Error('ChatGPT session transport is required'), { code: 'CHATGPT_SESSION_TRANSPORT_REQUIRED' });
-  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, persist = true } = {}) => {
-  const local = await acquireMarker({ env });
-  const selectedTransport = transport || exports.resolveTransport(env);
-  const exchanged = await exchange.exchangeSession({ sessionMarker: local.sessionMarker, profile: local.profile, env, transport: selectedTransport });
-  const result = exports.validate(exchanged);
-  if (persist) {
-    const file = paths.sessionFile(env);
-    const previous = readJson(file) || {};
-    const next = {
-      ...(previous.headers && typeof previous.headers === 'object' ? { headers: previous.headers } : {}),
-      source: 'api-auth-session',
-      updatedAt: nowIso(),
-      expires: result.body?.expires || previous.expires || null,
-      profile: local.profile || null
-    };
-    writeJson(file, next);
-  }
-  return { ...result, profile: local.profile || null };
-};
-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);
+'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.acquireLocalSessionMarker = (input = {}) => localStorage.acquireLocalSessionMarker(input);
-exports.normalizeResult = (result) => exchange.normalizeResult(result);
+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/session/local-storage.js

@@ -1,75 +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.extractSessionMarker = (storage = {}) => {
+'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;
-  return sessions.find((item) => typeof item?.sessionToken === 'string' && item.sessionToken.length > 0)?.sessionToken || 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.acquireLocalSessionMarker = async ({ env = process.env } = {}) => {
-  const chromeRoot = exports.resolveChromeDataRoot(env);
-  const profile = exports.detectProfile(chromeRoot, env);
-  const source = path.join(chromeRoot, profile, 'Local Storage', 'leveldb');
-  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 sessionMarker = exports.extractSessionMarker(storage);
-    if (!sessionMarker) throw Object.assign(new Error('No ChatGPT local session marker was found'), { code: 'CHATGPT_LOCAL_SESSION_NOT_FOUND' });
-    return { sessionMarker, profile };
-  } finally { fs.rmSync(tempRoot, { recursive: true, force: true }); }
+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/settings/index.js

@@ -0,0 +1,18 @@
+'use strict';
+const direct = require('../transport/direct/http-client');
+const context = require('../runtime-context');
+const requireOk = (response, target) => {
+  if (!response || response.status < 200 || response.status >= 300) throw Object.assign(new Error(`ChatGPT request failed (${response?.status || 'no-status'}): ${target}`), { status: response?.status || null, target });
+  return response.json || { success: true };
+};
+exports.getUser = async (options = {}) => {
+  options = await context.bind(options);
+  const target = '/backend-api/settings/user';
+  return requireOk(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { route: target }), target);
+};
+exports.updateAccountUserSetting = async (options = {}) => {
+  options = await context.bind(options);
+  if (!options.body || typeof options.body !== 'object' || Array.isArray(options.body)) throw Object.assign(new Error('body is required'), { code: 'BAD_ARGS' });
+  const target = '/backend-api/settings/account_user_setting';
+  return requireOk(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'PATCH', retry: false, route: target, body: options.body }), target);
+};

package/src/share/index.js

@@ -0,0 +1,25 @@
+'use strict';
+const direct = require('../transport/direct/http-client');
+const context = require('../runtime-context');
+const requireOk = (response, target) => {
+  if (!response || response.status < 200 || response.status >= 300) throw Object.assign(new Error(`ChatGPT request failed (${response?.status || 'no-status'}): ${target}`), { status: response?.status || null, target });
+  return response.json || { success: true };
+};
+const id = (value) => { if (typeof value !== 'string' || !value) throw Object.assign(new Error('shareId is required'), { code: 'BAD_ARGS' }); return encodeURIComponent(value); };
+exports.create = async (options = {}) => {
+  options = await context.bind(options);
+  if (!options.body || typeof options.body !== 'object' || Array.isArray(options.body)) throw Object.assign(new Error('body is required'), { code: 'BAD_ARGS' });
+  const target = '/backend-api/share/create';
+  return requireOk(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'POST', retry: false, route: target, body: options.body }), target);
+};
+exports.get = async (options = {}) => {
+  options = await context.bind(options);
+  const target = `/backend-api/share/${id(options.shareId)}`;
+  return requireOk(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { route: '/backend-api/share/{id}' }), target);
+};
+exports.update = async (options = {}) => {
+  options = await context.bind(options);
+  if (!options.body || typeof options.body !== 'object' || Array.isArray(options.body)) throw Object.assign(new Error('body is required'), { code: 'BAD_ARGS' });
+  const target = `/backend-api/share/${id(options.shareId)}`;
+  return requireOk(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'PATCH', retry: false, route: '/backend-api/share/{id}', body: options.body }), target);
+};