@miruzero/zero-agent 0.3.6 → 0.3.8

package/src/autostart.js

@@ -1,85 +1,74 @@
 'use strict';
 
-const childProcess = require('node:child_process');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const config = require('./config');
-const pkg = require('../package.json');
+const zero = require('./zero');
 
-const DEFAULT_INTERVAL = 5000;
+
+exports.DEFAULT_INTERVAL = 5000;
 
 const q = (value) => '"' + String(value).replace(/"/g, '""') + '"';
 const winPath = (value) => String(value).replace(/\//g, '\\');
 
-const defaultRoots = (env = process.env) => {
-  if (env.ZERO_AGENT_ROOTS) return env.ZERO_AGENT_ROOTS;
-  const home = env.USERPROFILE || os.homedir();
-  return [
-    path.join(home, 'Desktop', 'zero'),
-    path.join(home, 'Downloads')
-  ].join(path.delimiter);
-};
+exports.defaultRoots = () => null;
 
 const startupDir = (env = process.env) => {
-  const appData = env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
-  return path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
+  const appData = env.APPDATA || zero.path.join(zero.os.homedir(), 'AppData', 'Roaming');
+  return zero.path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
 };
-const paths = (env = process.env) => {
-  const home = config.agentHome(env);
+exports.paths = (env = process.env) => {
+  const home = zero.config.agentHome(env);
   return {
     home,
-    launcherFile: path.join(home, 'start-zero-agent.cmd'),
-    startupFile: path.join(startupDir(env), 'MiruZeroAgent.vbs'),
-    logFile: path.join(config.logDir(env), 'zero-agent.log')
+    launcherFile: zero.path.join(home, 'start-zero-agent.cmd'),
+    startupFile: zero.path.join(startupDir(env), 'MiruZeroAgent.vbs'),
+    logFile: zero.path.join(zero.config.logDir(env), 'zero-agent.log')
   };
 };
 
-const packageSpec = () => pkg.name + '@' + pkg.version;
-const localPackageBin = () => path.join(__dirname, '..', 'bin', 'zero-agent.js');
+const packageSpec = () => zero.pkg.name + '@' + zero.pkg.version;
+const localPackageBin = () => zero.path.join(__dirname, '..', 'bin', 'zero-agent.js');
 
 const globalRoot = (env = process.env) => {
-  if (env.ZERO_AGENT_GLOBAL_ROOT) return path.resolve(env.ZERO_AGENT_GLOBAL_ROOT);
+  if (env.ZERO_AGENT_GLOBAL_ROOT) return zero.path.resolve(env.ZERO_AGENT_GLOBAL_ROOT);
   const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const result = childProcess.spawnSync(npmCmd, ['root', '-g'], {
+  const result = zero.childProcess.spawnSync(npmCmd, ['root', '-g'], {
     env,
     encoding: 'utf8',
     windowsHide: true
   });
   if (result.status !== 0) return null;
   const value = String(result.stdout || '').trim();
-  return value ? path.resolve(value) : null;
+  return value ? zero.path.resolve(value) : null;
 };
 
-const packageBin = (env = process.env) => {
-  if (env.ZERO_AGENT_BIN) return path.resolve(env.ZERO_AGENT_BIN);
+exports.packageBin = (env = process.env) => {
+  if (env.ZERO_AGENT_BIN) return zero.path.resolve(env.ZERO_AGENT_BIN);
   if (env.ZERO_AGENT_SKIP_GLOBAL_INSTALL !== '1') {
     const root = globalRoot(env);
     const candidate = root
-      ? path.join(root, '@miruzero', 'zero-agent', 'bin', 'zero-agent.js')
+      ? zero.path.join(root, '@miruzero', 'zero-agent', 'bin', 'zero-agent.js')
       : null;
-    if (candidate && fs.existsSync(candidate)) return candidate;
+    if (candidate && zero.fs.existsSync(candidate)) return candidate;
   }
   return localPackageBin();
 };
 
-const nodeBin = (env = process.env) => path.resolve(env.ZERO_AGENT_NODE || process.execPath);
+exports.nodeBin = (env = process.env) => zero.path.resolve(env.ZERO_AGENT_NODE || process.execPath);
 
-const launcherContent = ({ interval = DEFAULT_INTERVAL, roots, logFile, binFile, nodeFile }, env = process.env) => {
-  const home = config.agentHome(env);
+exports.launcherContent = ({ interval = exports.DEFAULT_INTERVAL, roots, logFile, binFile, nodeFile }, env = process.env) => {
+  const home = zero.config.agentHome(env);
   const spec = packageSpec();
-  const bin = binFile || packageBin(env);
-  const node = nodeFile || nodeBin(env);
+  const bin = binFile || exports.packageBin(env);
+  const node = nodeFile || exports.nodeBin(env);
   return [
     '@echo off',
     'setlocal',
     'set "ZERO_TRACE=1"',
     'set "ZERO_AGENT_HOME=' + winPath(home) + '"',
-    'set "ZERO_AGENT_ROOTS=' + winPath(roots) + '"',
+    ...(roots ? ['set "ZERO_AGENT_ROOTS=' + winPath(roots) + '"'] : []),
     ...(env.ZERO_MCP_ROOT ? ['set "ZERO_MCP_ROOT=' + winPath(env.ZERO_MCP_ROOT) + '"'] : []),
-    'set "ZERO_AGENT_INTERVAL=' + Number(interval || DEFAULT_INTERVAL) + '"',
-    'rem interval=' + Number(interval || DEFAULT_INTERVAL) + 'ms',
-    'if not exist ' + q(winPath(path.dirname(logFile))) + ' mkdir ' + q(winPath(path.dirname(logFile))),
+    'set "ZERO_AGENT_INTERVAL=' + Number(interval || exports.DEFAULT_INTERVAL) + '"',
+    'rem interval=' + Number(interval || exports.DEFAULT_INTERVAL) + 'ms',
+    'if not exist ' + q(winPath(zero.path.dirname(logFile))) + ' mkdir ' + q(winPath(zero.path.dirname(logFile))),
     'echo [%date% %time%] starting ' + spec + ' >> ' + q(winPath(logFile)),
     q(winPath(node)) + ' ' + q(winPath(bin)) + ' start --interval %ZERO_AGENT_INTERVAL% >> ' + q(winPath(logFile)) + ' 2>&1',
     ''
@@ -92,41 +81,28 @@ const vbsContent = (launcherFile) => [
   ''
 ].join('\r\n');
 
-const prepare = (options = {}, env = process.env) => {
-  config.ensureDirs(env);
-  const p = paths(env);
-  const interval = Number(options.interval || env.ZERO_AGENT_INTERVAL || DEFAULT_INTERVAL);
-  const roots = options.roots || defaultRoots(env);
-  const binFile = packageBin(env);
-  const nodeFile = nodeBin(env);
-  fs.mkdirSync(path.dirname(p.launcherFile), { recursive: true });
-  fs.mkdirSync(path.dirname(p.startupFile), { recursive: true });
-  fs.mkdirSync(path.dirname(p.logFile), { recursive: true });
-  fs.writeFileSync(p.launcherFile, launcherContent({
+exports.prepare = (options = {}, env = process.env) => {
+  zero.config.ensureDirs(env);
+  const p = exports.paths(env);
+  const interval = Number(options.interval || env.ZERO_AGENT_INTERVAL || exports.DEFAULT_INTERVAL);
+  const roots = options.roots || exports.defaultRoots(env);
+  const binFile = exports.packageBin(env);
+  const nodeFile = exports.nodeBin(env);
+  zero.fs.mkdirSync(zero.path.dirname(p.launcherFile), { recursive: true });
+  zero.fs.mkdirSync(zero.path.dirname(p.startupFile), { recursive: true });
+  zero.fs.mkdirSync(zero.path.dirname(p.logFile), { recursive: true });
+  zero.fs.writeFileSync(p.launcherFile, exports.launcherContent({
     interval,
     roots,
     logFile: p.logFile,
     binFile,
     nodeFile
   }, env), 'utf8');
-  fs.writeFileSync(p.startupFile, vbsContent(p.launcherFile), 'utf8');
+  zero.fs.writeFileSync(p.startupFile, vbsContent(p.launcherFile), 'utf8');
   return { ok: true, interval, roots, binFile, nodeFile, ...p };
 };
 
-const isPrepared = (env = process.env) => {
-  const p = paths(env);
-  return fs.existsSync(p.launcherFile) && fs.existsSync(p.startupFile);
+exports.isPrepared = (env = process.env) => {
+  const p = exports.paths(env);
+  return zero.fs.existsSync(p.launcherFile) && zero.fs.existsSync(p.startupFile);
 };
-
-const autostart = {
-  DEFAULT_INTERVAL,
-  defaultRoots,
-  paths,
-  prepare,
-  isPrepared,
-  packageBin,
-  nodeBin,
-  launcherContent
-};
-
-Object.assign(exports, autostart);

package/src/capabilities.js

@@ -1,63 +1,58 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-const localTools = require('./local-tools');
-const command = require('./command');
-const zero = require('./zero-runtime');
-
-const defaultMcpRoot = () => path.resolve(__dirname, '../..');
-const mcpRoot = (env = process.env) => path.resolve(env.ZERO_MCP_ROOT || defaultMcpRoot());
-const providersDir = (env = process.env) => path.join(mcpRoot(env), 'providers');
-
-const readManifest = (file) => {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch (error) {
-    return { error: error.message };
-  }
-};
-
-const manifestProviders = (env = process.env) => {
-  const dir = providersDir(env);
-  if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir, { withFileTypes: true })
-    .filter((item) => item.isDirectory())
-    .map((item) => {
-      const root = path.join(dir, item.name);
-      const manifestFile = path.join(root, 'provider.json');
-      const manifest = fs.existsSync(manifestFile) ? readManifest(manifestFile) : {};
-      return {
-        name: item.name,
-        type: manifest.type || 'unknown',
-        description: manifest.description || '',
-        providerRoot: root,
-        manifestFile,
-        manifestError: manifest.error || null,
-        module: manifest.module || null,
-        command: manifest.command || null,
-        args: manifest.args || []
-      };
-    });
-};
-
-const safeInternalTools = (provider) => {
-  if (!provider.module) return [];
-  const modulePath = provider.module.replaceAll('{providerRoot}', provider.providerRoot.replace(/\\/g, '/'));
-  const resolved = path.resolve(modulePath);
-  try {
-    const runtime = require(resolved);
-    if (typeof runtime.listTools !== 'function') return [];
-    return runtime.listTools({}).map((tool) => ({
-      name: tool.name,
-      description: tool.description || '',
-      inputSchema: tool.inputSchema || null
-    }));
-  } catch (error) {
-    return [{ name: '__scan_error__', description: error.message, inputSchema: null }];
-  }
-};
+'use strict';
+
+const zero = require('./zero');
+
+const defaultMcpRoot = () => zero.path.resolve(__dirname, '..');
+exports.mcpRoot = (env = process.env) => zero.path.resolve(env.ZERO_MCP_ROOT || defaultMcpRoot());
+exports.providersDir = (env = process.env) => zero.path.join(exports.mcpRoot(env), 'providers');
+
+const readManifest = (file) => {
+  try {
+    return JSON.parse(zero.fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    return { error: error.message };
+  }
+};
+
+exports.manifestProviders = (env = process.env) => {
+  const dir = exports.providersDir(env);
+  if (!zero.fs.existsSync(dir)) return [];
+  return zero.fs.readdirSync(dir, { withFileTypes: true })
+    .filter((item) => item.isDirectory())
+    .map((item) => {
+      const root = zero.path.join(dir, item.name);
+      const manifestFile = zero.path.join(root, 'provider.json');
+      const manifest = zero.fs.existsSync(manifestFile) ? readManifest(manifestFile) : {};
+      return {
+        name: item.name,
+        type: manifest.type || 'unknown',
+        description: manifest.description || '',
+        providerRoot: root,
+        manifestFile,
+        manifestError: manifest.error || null,
+        module: manifest.module || null,
+        command: manifest.command || null,
+        args: manifest.args || []
+      };
+    });
+};
+
+const safeInternalTools = (provider) => {
+  if (!provider.module) return [];
+  const modulePath = provider.module.replaceAll('{providerRoot}', provider.providerRoot.replace(/\\/g, '/'));
+  const resolved = zero.path.resolve(modulePath);
+  try {
+    const runtime = require(resolved);
+    if (typeof runtime.listTools !== 'function') return [];
+    return runtime.listTools({}).map((tool) => ({
+      name: tool.name,
+      description: tool.description || '',
+      inputSchema: tool.inputSchema || null
+    }));
+  } catch (error) {
+    return [{ name: '__scan_error__', description: error.message, inputSchema: null }];
+  }
+};
 const publicCommandTool = (tool) => ({
   name: tool.name,
   description: tool.description || '',
@@ -69,7 +64,7 @@ const publicCommandTool = (tool) => ({
 });
 
 const builtInLocalProvider = () => {
-  const tools = command.listTools().map(publicCommandTool);
+  const tools = zero.command.listTools().map(publicCommandTool);
   return {
     name: 'zero-agent-command',
     type: 'internal',
@@ -80,81 +75,43 @@ const builtInLocalProvider = () => {
   };
 };
 
-const builtInChatGptAuthProvider = () => {
-  const tools = [
-    {
-      name: 'status',
-      description: 'Return redacted ChatGPT auth fixture status from the local zero-agent host.',
-      canonicalName: 'zero.chatgpt.auth.status',
-      category: 'auth',
-      function: 'status',
-      aliases: ['chatgpt.auth.status'],
-      inputSchema: { type: 'object', properties: {}, additionalProperties: false }
-    },
-    {
-      name: 'import',
-      description: 'Write ChatGPT auth fixture input to the local zero-agent host. Returns redacted metadata only.',
-      canonicalName: 'zero.chatgpt.auth.import',
-      category: 'auth',
-      function: 'import',
-      aliases: ['chatgpt.auth.import'],
-      inputSchema: {
-        type: 'object',
-        properties: { input: { type: 'string' } },
-        required: ['input'],
-        additionalProperties: false
-      }
-    }
-  ];
-  return {
-    name: 'chatgpt',
-    type: 'internal',
-    description: 'Built-in ChatGPT auth setup support exposed by zero-agent.',
-    status: 'present',
-    tools,
-    tool_count: tools.length
+exports.buildCapabilities = (env = process.env) => {
+  const providers = [builtInLocalProvider(), ...exports.manifestProviders(env).map((provider) => {
+    const tools = provider.type === 'internal' ? safeInternalTools(provider) : [];
+    return {
+      name: provider.name,
+      type: provider.type,
+      description: provider.description,
+      status: provider.manifestError ? 'invalid' : 'present',
+      tools,
+      tool_count: tools.length,
+      mcp_stdio_live_scan: provider.type === 'mcp-stdio' ? false : undefined
+    };
+  })];
+  const agentVersion = zero.pkg.version;
+  const categories = Array.from(new Set(zero.command.listTools().map((tool) => `${tool.provider}.${tool.category}`))).sort();
+  const adapters = ['native'];
+  const payload = {
+    agentVersion,
+    agent_version: agentVersion,
+    contractVersion: zero.contract.version,
+    platform: process.platform,
+    architecture: process.arch,
+    categories,
+    adapters,
+    mcp_root: exports.mcpRoot(env),
+    filesystem: zero.devicePaths.snapshot(env),
+    providers
+  };
+  const fingerprint = {
+    contractVersion: payload.contractVersion,
+    platform: payload.platform,
+    architecture: payload.architecture,
+    categories: payload.categories,
+    adapters: payload.adapters,
+    providers: payload.providers
   };
-};
-
-const buildCapabilities = (env = process.env) => {
-  const providers = [builtInLocalProvider(), builtInChatGptAuthProvider(), ...manifestProviders(env).map((provider) => {
-    const tools = provider.type === 'internal' ? safeInternalTools(provider) : [];
-    return {
-      name: provider.name,
-      type: provider.type,
-      description: provider.description,
-      status: provider.manifestError ? 'invalid' : 'present',
-      tools,
-      tool_count: tools.length,
-      mcp_stdio_live_scan: provider.type === 'mcp-stdio' ? false : undefined
-    };
-  })];
-  const agentVersion = require('../package.json').version;
-  const categories = Array.from(new Set(command.listTools().map((tool) => `${tool.provider}.${tool.category}`))).sort();
-  const adapters = ['native'];
-  const payload = {
-    agentVersion,
-    agent_version: agentVersion,
-    contractVersion: zero.contract.version,
-    platform: process.platform,
-    architecture: process.arch,
-    categories,
-    adapters,
-    mcp_root: mcpRoot(env),
-    providers
-  };
-  const fingerprint = {
-    contractVersion: payload.contractVersion,
-    platform: payload.platform,
-    architecture: payload.architecture,
-    categories: payload.categories,
-    adapters: payload.adapters,
-    providers: payload.providers
-  };
-  payload.capability_hash = crypto.createHash('sha256').update(JSON.stringify(fingerprint)).digest('hex');
-  return payload;
-};
-
-const capabilities = { mcpRoot, providersDir, manifestProviders, buildCapabilities };
-Object.assign(exports, capabilities);
-
+  payload.capability_hash = zero.crypto.createHash('sha256').update(JSON.stringify(fingerprint)).digest('hex');
+  return payload;
+};
+

package/src/chatgpt/auth/index.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const paths = require('../config/paths');
+
+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 }); };
+const tokenExpiry = (token) => {
+  try {
+    const payload = JSON.parse(Buffer.from(String(token).split('.')[1], 'base64url').toString('utf8'));
+    return Number.isFinite(payload.exp) ? new Date(payload.exp * 1000).toISOString() : null;
+  } catch { return null; }
+};
+const isExpired = (expires) => { const at = Date.parse(expires || ''); return Number.isFinite(at) && at <= Date.now(); };
+const rawFromEnv = (env) => {
+  const token = typeof env.ZERO_CHATGPT_ACCESS_TOKEN === 'string' ? env.ZERO_CHATGPT_ACCESS_TOKEN.trim() : '';
+  if (!token) return null;
+  return { tokenName: 'env', accessToken: token, expires: tokenExpiry(token), source: 'env' };
+};
+exports.file = (env = process.env) => paths.authFile(env);
+
+const rawFromFile = (env) => {
+  const file = paths.authFile(env);
+  const data = readJson(file);
+  if (!data || typeof data.accessToken !== 'string' || !data.accessToken) return null;
+  return { tokenName: data.tokenName || 'ACCESS', accessToken: data.accessToken, expires: data.expires || tokenExpiry(data.accessToken), updatedAt: data.updatedAt || null, source: 'file', file };
+};
+
+exports.status = ({ env = process.env } = {}) => {
+  const raw = rawFromEnv(env) || rawFromFile(env);
+  const file = paths.authFile(env);
+  if (!raw) return { present: false, status: fs.existsSync(file) ? 'invalid' : 'missing', redacted: true, source: 'none', file };
+  return { present: true, status: isExpired(raw.expires) ? 'expired' : 'valid', redacted: true, source: raw.source, tokenName: raw.tokenName, expires: raw.expires || null, updatedAt: raw.updatedAt || null, file: raw.file || null };
+};
+
+exports.importSession = ({ body, env = process.env, source = 'session' } = {}) => {
+  const accessToken = body?.accessToken || body?.access_token;
+  if (!accessToken || typeof accessToken !== 'string') {
+    throw Object.assign(new Error('ChatGPT session did not provide an access token'), { code: 'AUTH_REQUIRED' });
+  }
+  const expires = body?.expires || body?.expires_at || tokenExpiry(accessToken);
+  const value = {
+    tokenName: 'ACCESS',
+    accessToken,
+    expires: expires || null,
+    updatedAt: new Date().toISOString(),
+    source
+  };
+  writeJson(paths.authFile(env), value);
+  return {
+    present: true,
+    status: isExpired(value.expires) ? 'expired' : 'valid',
+    redacted: true,
+    source,
+    tokenName: value.tokenName,
+    expires: value.expires,
+    updatedAt: value.updatedAt,
+    file: paths.authFile(env)
+  };
+};
+
+exports.refresh = async ({ env = process.env, acquireSession, fresh = false } = {}) => {
+  const flow = typeof acquireSession === 'function' ? acquireSession : require('../session').acquire;
+  const result = await flow({ env, fresh });
+  const body = result?.body ?? result;
+  const accessToken = body?.accessToken || body?.access_token;
+  if (!accessToken || typeof accessToken !== 'string') throw Object.assign(new Error('ChatGPT session did not provide an access token'), { code: 'AUTH_REQUIRED' });
+  const value = {
+    tokenName: 'ACCESS',
+    accessToken,
+    expires: body?.expires || body?.expires_at || tokenExpiry(accessToken),
+    updatedAt: new Date().toISOString()
+  };
+  writeJson(paths.authFile(env), value);
+  return { ...value, source: 'session' };
+};
+
+exports.login = async ({ env = process.env, acquireSession } = {}) => {
+  await exports.refresh({ env, fresh: true, ...(typeof acquireSession === 'function' ? { acquireSession } : {}) });
+  return exports.status({ env });
+};
+
+exports.logout = ({ env = process.env } = {}) => {
+  const authFile = paths.authFile(env);
+  const sessionFile = paths.sessionFile(env);
+  const remove = (file) => {
+    const existed = fs.existsSync(file);
+    if (existed) fs.rmSync(file, { force: true });
+    return existed;
+  };
+  const authRemoved = remove(authFile);
+  const sessionRemoved = remove(sessionFile);
+  const envOverridePresent = typeof env.ZERO_CHATGPT_ACCESS_TOKEN === 'string' && Boolean(env.ZERO_CHATGPT_ACCESS_TOKEN.trim());
+  return {
+    status: envOverridePresent ? 'env-active' : 'logged-out',
+    redacted: true,
+    authRemoved,
+    sessionRemoved,
+    envOverridePresent
+  };
+};
+exports.ensure = async ({ env = process.env, acquireSession } = {}) => {
+  const envAuth = rawFromEnv(env);
+  if (envAuth && !isExpired(envAuth.expires)) return envAuth;
+  const fileAuth = rawFromFile(env);
+  if (fileAuth && !isExpired(fileAuth.expires)) return fileAuth;
+  if (fileAuth && isExpired(fileAuth.expires)) {
+    try { fs.rmSync(paths.authFile(env), { force: true }); } catch {}
+  }
+  if (acquireSession === false) throw Object.assign(new Error('ChatGPT authentication required'), { code: 'AUTH_REQUIRED' });
+  try { return await exports.refresh({ env, ...(typeof acquireSession === 'function' ? { acquireSession } : {}) }); }
+  catch (error) { if (error?.code) throw error; throw Object.assign(new Error('ChatGPT authentication required'), { code: 'AUTH_REQUIRED', cause: error }); }
+};

package/src/chatgpt/config/paths.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+const agentHome = (env = process.env) =>
+  path.resolve(env.ZERO_AGENT_HOME || path.join(os.homedir(), '.zero-agent'));
+
+exports.stateDir = (env = process.env) =>
+  path.resolve(env.ZERO_CHATGPT_STATE_DIR || path.join(agentHome(env), 'chatgpt'));
+exports.authFile = (env = process.env) =>
+  path.resolve(env.ZERO_CHATGPT_AUTH_FILE || path.join(exports.stateDir(env), 'auth-context.json'));
+exports.sessionFile = (env = process.env) =>
+  path.resolve(env.ZERO_CHATGPT_SESSION_FILE || path.join(exports.stateDir(env), 'session-context.json'));
+exports.tempConversationFile = (env = process.env) =>
+  path.resolve(env.ZERO_CHATGPT_TEMP_STATE_FILE || path.join(exports.stateDir(env), 'temp-conversations.json'));
+exports.rateLimitDir = (env = process.env) => env.ZERO_CHATGPT_RATE_LIMIT_FILE
+  ? path.dirname(path.resolve(env.ZERO_CHATGPT_RATE_LIMIT_FILE))
+  : exports.stateDir(env);
+exports.rateLimitFile = (env = process.env, token = 'anonymous') => {
+  if (env.ZERO_CHATGPT_RATE_LIMIT_FILE) return path.resolve(env.ZERO_CHATGPT_RATE_LIMIT_FILE);
+  const key = crypto.createHash('sha256').update(String(token || 'anonymous')).digest('hex').slice(0, 16);
+  return path.join(exports.rateLimitDir(env), `rate-limit-${key}.json`);
+};

package/src/chatgpt/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.paths = require('./config/paths');
+exports.auth = require('./auth');
+exports.session = require('./session');

package/src/chatgpt/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/chatgpt/session/exchange.js

@@ -0,0 +1,17 @@
+'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,
+    sessionHeaders: result.sessionHeaders && typeof result.sessionHeaders === 'object' ? { ...result.sessionHeaders } : null
+  };
+};
+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, workspaceAccountId, profile: profile || null, env, sessionSource: exports.SESSION_SOURCE }));
+};