@miruzero/zgpt 0.1.0

package/src/protocol/conduit.js

@@ -0,0 +1,26 @@
+'use strict';
+
+exports.SENTINEL_HEADER_NAMES = [
+  'openai-sentinel-chat-requirements-token',
+  'openai-sentinel-proof-token',
+  'openai-sentinel-turnstile-token'
+];
+
+exports.takeSentinelHeaders = (headers = {}) => Object.fromEntries(
+  exports.SENTINEL_HEADER_NAMES
+    .filter((name) => typeof headers[name] === 'string' && headers[name])
+    .map((name) => [name, headers[name]])
+);
+
+exports.observationFromUpdate = (value, phase = 'r') => {
+  const parts = String(value || '').split('.');
+  return parts[0] === 'ois1' && parts[2] ? `v1.${phase}.p.${parts[2]}` : null;
+};
+
+exports.applyIntegrityUpdate = (headers, responseHeaders, phase = 'r') => {
+  const observation = exports.observationFromUpdate(responseHeaders?.['x-oai-is-update'], phase);
+  if (observation) headers['x-oai-is-client-observation'] = observation;
+  return observation;
+};
+
+exports.streamObservation = (value) => String(value || '').replace(/^v1\.[rs]\.p\./, 'v1.s.p.');

package/src/protocol/conversation-payload.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const createUserMessage = (text, id = crypto.randomUUID(), metadata = {}) => ({
+  id,
+  author: { role: 'user' },
+  create_time: Date.now() / 1000,
+  content: { content_type: 'text', parts: [String(text)] },
+  metadata: {
+    selected_sources: [],
+    serialization_metadata: { custom_symbol_offsets: [] },
+    submission_mode: 'manual_send',
+    ...metadata
+  }
+});
+
+// targeted_reply (quote chip ของเว็บ): user message แปะ metadata + hidden system message ตามหลัง
+// spec จากซอร์สเว็บ (Hzi/_Pi) + capture จริง — label ตัดยาวสุด 80 ตัวอักษร
+const targetedReplyLabel = (text) => {
+  const trimmed = String(text).trim();
+  return trimmed.length <= 80 ? trimmed : `${trimmed.slice(0, 77).trimEnd()}...`;
+};
+
+const targetedReplyMetadata = (targetedReply) => {
+  if (!targetedReply || !targetedReply.text) return {};
+  return {
+    targeted_reply: String(targetedReply.text),
+    targeted_reply_label: targetedReply.label || targetedReplyLabel(targetedReply.text),
+    ...(targetedReply.sourceMessageId ? { targeted_reply_source_message_id: targetedReply.sourceMessageId } : {}),
+    ...(targetedReply.sourceRange ? { targeted_reply_source_range: targetedReply.sourceRange } : {})
+  };
+};
+
+const createHiddenSystemMessage = (text) => ({
+  id: crypto.randomUUID(),
+  author: { role: 'system' },
+  content: { content_type: 'text', parts: [String(text)] },
+  metadata: { exclude_after_next_user_message: true, is_visually_hidden_from_conversation: true }
+});
+
+const createHiddenTargetedReplyMessage = (text) =>
+  createHiddenSystemMessage(`The user is referring to this in particular:\n${String(text)}`);
+
+const systemHintMetadata = (systemHints = [], mentions = []) => ({
+  ...(systemHints.length ? { system_hints: systemHints } : {}),
+  ...(mentions.length ? { serialization_metadata: { custom_symbol_offsets: mentions.map(({ id, startIndex, endIndex }) => ({ id, symbol: 'ecosystemMention', startIndex, endIndex })) } } : {})
+});
+
+const applyAttachments = (message, attachments = []) => {
+  if (!Array.isArray(attachments) || attachments.length === 0) return message;
+  const kinds = new Set(attachments.map((item) => item?.kind));
+  if ([...kinds].some((kind) => kind !== 'image' && kind !== 'document')) {
+    throw new Error('unverified attachment projection');
+  }
+  if (kinds.size > 1) throw new Error('unverified mixed attachment projection');
+  if (attachments.some((item) => !item?.attachment || (item.kind === 'image' && !item.part))) {
+    throw new Error('unverified attachment projection');
+  }
+  message.metadata.attachments = attachments.map((item) => ({ ...item.attachment }));
+  if (kinds.has('image')) {
+    message.content = {
+      content_type: 'multimodal_text',
+      parts: [...attachments.map((item) => ({ ...item.part })), message.content.parts[0]]
+    };
+  }
+  return message;
+};
+
+const conversationMode = (projectId) => projectId
+  ? { kind: 'gizmo_interaction', gizmo_id: projectId }
+  : { kind: 'primary_assistant' };
+
+
+const DEFAULT_MODEL = 'gpt-5-6-thinking';
+const DEFAULT_THINKING_EFFORT = 'extended';
+const DEFAULT_MODEL_RESPONSE_CONTRACTS = Object.freeze([{
+  id: 'photo_upload_action.v1',
+  protocol_version: 1,
+  presets: ['cap:image', 'cap:file', 'placement:end']
+}]);
+
+const defaultClientContextualInfo = (temporaryChat = false) => temporaryChat
+  ? {
+      app_name: 'chatgpt.com',
+      app_surface: 'codex_browser',
+      has_web_push_capabilities: true,
+      web_push_notification_permission: 'granted'
+    }
+  : { app_name: 'chatgpt.com' };
+
+const resolveWebProtocolContext = ({ timezone = null, timezoneOffsetMin = null, modelResponseContracts = null, clientContextualInfo = null, temporaryChat = false } = {}) => ({
+  timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || null,
+  timezone_offset_min: Number.isFinite(timezoneOffsetMin) ? timezoneOffsetMin : new Date().getTimezoneOffset(),
+  model_response_contracts: Array.isArray(modelResponseContracts) ? modelResponseContracts : DEFAULT_MODEL_RESPONSE_CONTRACTS,
+  client_contextual_info: clientContextualInfo && typeof clientContextualInfo === 'object'
+    ? { ...defaultClientContextualInfo(temporaryChat), ...clientContextualInfo }
+    : defaultClientContextualInfo(temporaryChat)
+});
+
+const buildPrepareBody = ({
+  projectId = null,
+  model = DEFAULT_MODEL,
+  thinkingEffort = DEFAULT_THINKING_EFFORT,
+  systemHints = [],
+  localFunctionNames = null,
+  timezone = null,
+  timezoneOffsetMin = null,
+  modelResponseContracts = null,
+  clientContextualInfo = null,
+  temporaryChat = false,
+  attachments = [],
+  includeForkFromSharedPost = false
+}) => ({
+  action: 'next',
+  ...(includeForkFromSharedPost ? { fork_from_shared_post: false } : {}),
+  parent_message_id: 'client-created-root',
+  model,
+  thinking_effort: thinkingEffort,
+  client_prepare_state: 'none',
+  conversation_mode: conversationMode(projectId),
+  system_hints: systemHints,
+  supports_buffering: true,
+  supported_encodings: ['v1'],
+  ...(Array.isArray(attachments) && attachments.length ? { attachment_mime_types: attachments.map((item) => item.attachment.mime_type) } : {}),
+  ...resolveWebProtocolContext({ timezone, timezoneOffsetMin, modelResponseContracts, clientContextualInfo, temporaryChat }),
+  ...(Array.isArray(localFunctionNames) && localFunctionNames.length ? { local_function_names: [...localFunctionNames] } : {}),
+  client_prepare_dispatch: 'debounced',
+  client_prepare_source: 'window_focus'
+});
+
+const buildSendBody = ({
+  message,
+  projectId = null,
+  model = DEFAULT_MODEL,
+  thinkingEffort = DEFAULT_THINKING_EFFORT,
+  systemHints = [],
+  systemHintMentions = [],
+  targetedReply = null,
+  hiddenSystemMessages = [],
+  hideUserMessage = false,
+  timezone = null,
+  timezoneOffsetMin = null,
+  modelResponseContracts = null,
+  clientContextualInfo = null,
+  localFunctionNames = null,
+  enableMessageFollowups = true,
+  temporaryChat = false,
+  historyAndTrainingDisabled = null,
+  isDoNotRemember = null,
+  temporaryChatRequestsPersonalization = null,
+  browserContext = null,
+  attachments = [],
+  forceUseSse = null,
+  forceUseSearch = null,
+  forceParagen = false,
+  isOnboardingConversation = false,
+  stream = null,
+  serviceTier = null,
+  forceParallelSwitch = 'auto',
+  paragenCotSummaryDisplayOverride = 'allow',
+  includeForkFromSharedPost = false
+}) => ({
+  action: 'next',
+  ...(includeForkFromSharedPost ? { fork_from_shared_post: false } : {}),
+  ...(temporaryChat === true || historyAndTrainingDisabled === true ? { history_and_training_disabled: true } : {}),
+  ...(temporaryChat === true || typeof isDoNotRemember === 'boolean' ? { is_do_not_remember: typeof isDoNotRemember === 'boolean' ? isDoNotRemember : false } : {}),
+  ...(typeof temporaryChatRequestsPersonalization === 'boolean' ? { temporary_chat_requests_personalization: temporaryChatRequestsPersonalization } : {}),
+  parent_message_id: 'client-created-root',
+  model,
+  thinking_effort: thinkingEffort,
+  client_prepare_state: temporaryChat === true ? 'none' : 'success',
+  conversation_mode: conversationMode(projectId),
+  enable_message_followups: enableMessageFollowups,
+  ...(forceUseSse != null ? { force_use_sse: forceUseSse } : {}),
+  ...(forceUseSearch != null ? { force_use_search: forceUseSearch } : {}),
+  ...(forceParagen === true ? { force_paragen: true } : {}),
+  system_hints: systemHints,
+  ...(isOnboardingConversation === true ? { is_onboarding_conversation: true } : {}),
+  supports_buffering: true,
+  supported_encodings: ['v1'],
+  ...resolveWebProtocolContext({ timezone, timezoneOffsetMin, modelResponseContracts, clientContextualInfo, temporaryChat }),
+  ...(Array.isArray(localFunctionNames) && localFunctionNames.length ? { local_function_names: [...localFunctionNames] } : {}),
+  ...(browserContext && typeof browserContext === 'object' ? { browser_context: { ...browserContext } } : {}),
+  ...(serviceTier ? { service_tier: serviceTier } : {}),
+  ...(forceParallelSwitch ? { force_parallel_switch: forceParallelSwitch } : {}),
+  ...(paragenCotSummaryDisplayOverride ? { paragen_cot_summary_display_override: paragenCotSummaryDisplayOverride } : {}),
+  ...(stream != null ? { stream } : {}),
+  messages: [
+    applyAttachments(createUserMessage(message, undefined, {
+      ...(projectId ? { gizmo_id: projectId } : {}),
+      ...(serviceTier ? { service_tier: serviceTier } : {}),
+      ...systemHintMetadata(systemHints, systemHintMentions),
+      ...targetedReplyMetadata(targetedReply),
+      ...(hideUserMessage ? {
+        exclude_after_next_user_message: true,
+        is_visually_hidden_from_conversation: true
+      } : {})
+    }), attachments),
+    ...(Array.isArray(hiddenSystemMessages)
+      ? hiddenSystemMessages
+        .filter((text) => typeof text === 'string' && text.trim())
+        .map((text) => createHiddenSystemMessage(text))
+      : []),
+    ...(targetedReply?.text ? [createHiddenTargetedReplyMessage(targetedReply.text)] : [])
+  ]
+});
+
+
+exports.DEFAULT_MODEL = DEFAULT_MODEL;
+exports.DEFAULT_THINKING_EFFORT = DEFAULT_THINKING_EFFORT;
+exports.DEFAULT_MODEL_RESPONSE_CONTRACTS = DEFAULT_MODEL_RESPONSE_CONTRACTS;
+exports.buildPrepareBody = buildPrepareBody;
+exports.buildSendBody = buildSendBody;

package/src/protocol/sentinel-client.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const requirements = require('./sentinel-requirements');
+const proof = require('./sentinel-proof');
+
+const PREPARE = '/backend-api/sentinel/chat-requirements/prepare';
+const FINALIZE = '/backend-api/sentinel/chat-requirements/finalize';
+
+const requireStep = (response, step) => {
+  if (!response || response.status !== 200 || !response.json) {
+    const error = new Error(`sentinel ${step} failed (${response?.status || 'no-status'})`);
+    error.code = 'SENTINEL_FAILED';
+    error.status = response?.status || null;
+    throw error;
+  }
+  return response.json;
+};
+
+exports.fetchChatRequirements = async ({ token, sessionHeaders = {}, userAgent, requestJson }) => {
+  if (typeof requestJson !== 'function') throw new TypeError('requestJson is required');
+  const ua = userAgent || sessionHeaders['user-agent'] || sessionHeaders['User-Agent'] || '';
+  const p = requirements.buildToken(ua);
+  const prepare = requireStep(await requestJson(PREPARE, token, sessionHeaders, {
+    method: 'POST', body: { p }, route: PREPARE
+  }), 'prepare');
+  if (!prepare.prepare_token) throw Object.assign(new Error('sentinel prepare missing prepare_token'), { code: 'SENTINEL_PREPARE_INVALID' });
+  const finalize = requireStep(await requestJson(FINALIZE, token, sessionHeaders, {
+    method: 'POST', body: { prepare_token: prepare.prepare_token }, route: FINALIZE
+  }), 'finalize');
+  if (!finalize.token) throw Object.assign(new Error('sentinel finalize missing token'), { code: 'SENTINEL_FINALIZE_INVALID' });
+  const proofToken = prepare.proofofwork?.required
+    ? proof.solve(prepare.proofofwork.seed, prepare.proofofwork.difficulty, ua)
+    : null;
+  return { token: finalize.token, persona: finalize.persona || null, proofToken };
+};

package/src/protocol/sentinel-proof.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const requirements = require('./sentinel-requirements');
+
+exports.solve = (seed, difficulty, ua, scripts, build) => {
+  const target = Buffer.from(String(difficulty || '0'), 'hex');
+  const value = requirements.browserConfig(ua, scripts, build);
+  for (let i = 0; i < 500000; i += 1) {
+    value[3] = i;
+    value[9] = i >> 1;
+    const encoded = requirements.encode(value);
+    const digest = crypto.createHash('sha3-512').update(String(seed)).update(encoded).digest();
+    if (Buffer.compare(digest.subarray(0, target.length), target) <= 0) return `gAAAAAB${encoded}`;
+  }
+  const error = new Error('failed to solve sentinel proof');
+  error.code = 'SENTINEL_PROOF_FAILED';
+  throw error;
+};

package/src/protocol/sentinel-requirements.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { performance } = require('node:perf_hooks');
+
+const DEFAULT_SCRIPT = 'https://chatgpt.com/backend-api/sentinel/sdk.js';
+const pick = (items) => items[Math.floor(Math.random() * items.length)];
+const b64 = (value) => Buffer.from(JSON.stringify(value)).toString('base64');
+
+exports.browserConfig = (ua, scripts = [DEFAULT_SCRIPT], build = '') => {
+  const perf = performance.now();
+  return [
+    pick([3000, 4000, 5000]), new Date().toString(), 4294705152, 1, ua,
+    pick(scripts.length ? scripts : [DEFAULT_SCRIPT]), build,
+    'en-US', 'en-US,es-US,en,es', Math.random(),
+    pick(['webdriver-false', 'vendor-Google Inc.', 'hardwareConcurrency-32', 'pdfViewerEnabled-true']),
+    pick(['location', 'documentURI', 'compatMode']),
+    pick(['window', 'self', 'document', 'location', 'navigator', 'performance', 'crypto', 'fetch']),
+    perf, crypto.randomUUID(), '', pick([8, 16, 24, 32]), Date.now() - perf,
+    0, 0, 0, 0, 0, 0, 0
+  ];
+};
+
+exports.encode = b64;
+exports.buildToken = (ua, scripts, build) => `gAAAAAC${b64(exports.browserConfig(ua, scripts, build))}`;

package/src/protocol/sse.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const stateOf = (events, completed, conversationId, currentNode, resumeToken, malformed) => ({
+  events: [...events], completed, conversationId, currentNode, resumeToken, malformed
+});
+
+exports.createParser = () => {
+  let pending = '';
+  const events = [];
+  let completed = false;
+  let conversationId = null;
+  let currentNode = null;
+  let resumeToken = null;
+  let malformed = 0;
+
+  const acceptLine = (line) => {
+    if (!line.startsWith('data:')) return;
+    const data = line.slice(5).trim();
+    if (!data) return;
+    if (data === '[DONE]') { completed = true; return; }
+    let event;
+    try { event = JSON.parse(data); }
+    catch { malformed += 1; return; }
+    events.push(event);
+    const id = event?.conversation_id || event?.v?.conversation_id || event?.conversation?.id;
+    if (typeof id === 'string' && id) conversationId = id;
+    if (event?.type === 'message_marker' && typeof event.message_id === 'string' && event.message_id) {
+      currentNode = event.message_id;
+    }
+    if (event?.type === 'resume_conversation_token' && typeof event.token === 'string' && event.token) {
+      resumeToken = event.token;
+    }
+  };
+
+  return {
+    push(chunk) {
+      pending += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk ?? '');
+      const lines = pending.split(/\r?\n/);
+      pending = lines.pop() || '';
+      for (const line of lines) acceptLine(line);
+      return this.snapshot();
+    },
+    finish() {
+      if (pending) acceptLine(pending);
+      pending = '';
+      return this.snapshot();
+    },
+    snapshot() { return stateOf(events, completed, conversationId, currentNode, resumeToken, malformed); }
+  };
+};
+
+exports.parse = (input) => {
+  const parser = exports.createParser();
+  parser.push(input);
+  return parser.finish();
+};

package/src/session/exchange.js

@@ -0,0 +1,12 @@
+'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 };
+};
+exports.exchangeSession = async ({ sessionMarker, 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 }));
+};

package/src/session/index.js

@@ -0,0 +1,70 @@
+'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);
+exports.extractSessionMarker = (storage) => localStorage.extractSessionMarker(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

@@ -0,0 +1,75 @@
+'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 = {}) => {
+  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;
+};
+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 }); }
+};