codexunlimit 0.1.0-web.13 → 0.1.0-web.16

package/doctor.mjs

@@ -1,20 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import {execFileSync} from 'node:child_process';
-import {codexExecutable} from './codex-account-client.mjs';
-import {VERSION} from './product.mjs';
-
-export async function diagnoseRuntime(){
-  const version=process.versions.node.split('.').map(Number),checks=[{name:'Node.js',ok:version[0]===22&&version[1]>=15||version[0]>=24,version:process.versions.node},{name:'Codex Unlimit',ok:true,version:VERSION}];
-  try{await import('node:sqlite');checks.push({name:'SQLite',ok:true});}catch{checks.push({name:'SQLite',ok:false});}
-  const home=fs.mkdtempSync(path.join(os.tmpdir(),'cu-runtime-check-'));
-  try{
-    const env={...process.env,CODEX_HOME:home};for(const key of Object.keys(env))if(/^(OPENAI_|CHATGPT_|CODEX_API_KEY|NODE_OPTIONS|NODE_PATH|NODE_AUTH_TOKEN)/i.test(key))delete env[key];
-    const expected=JSON.parse(fs.readFileSync(new URL('./package.json',import.meta.url),'utf8')).dependencies['@openai/codex'];
-    const output=execFileSync(codexExecutable(),['--version'],{env,encoding:'utf8',windowsHide:true,timeout:20000,stdio:['ignore','pipe','pipe']});
-    const actual=output.match(/codex-cli (\d+\.\d+\.\d+)/)?.[1];checks.push({name:'Codex runtime',ok:actual===expected,...(actual?{version:actual}:{})});
-  }catch{checks.push({name:'Codex runtime',ok:false});}
-  finally{if(path.dirname(home)===os.tmpdir())fs.rmSync(home,{recursive:true,force:true,maxRetries:5,retryDelay:100});}
-  return {ok:checks.every(check=>check.ok),platform:process.platform,architecture:process.arch,checks,accountCredentialsRead:false};
-}

package/image-http.mjs

@@ -1,22 +0,0 @@
-import http from 'node:http';
-import https from 'node:https';
-import {Readable} from 'node:stream';
-
-export const isImageRoute=route=>/^\/(?:v1\/)?images\/(?:generations|edits)$/.test(route);
-export function imageRequest(value,options={}){
-  const url=new URL(value);
-  if(url.username||url.password||url.hash||url.search||!isImageRoute(url.pathname)||!(url.protocol==='https:'||url.protocol==='http:'&&url.hostname==='127.0.0.1'))throw Error('image_destination_denied');
-  const body=Buffer.from(options.body??''),headers=new Headers(options.headers);headers.set('content-length',String(body.length));headers.set('accept-encoding','identity');
-  for(const name of ['host','proxy-authorization','proxy-connection'])headers.delete(name);
-  return new Promise((resolve,reject)=>{
-    const request=(url.protocol==='https:'?https:http).request(url,{method:'POST',headers:Object.fromEntries(headers),signal:options.signal,agent:false,rejectUnauthorized:true},response=>{
-      clearTimeout(timer);const responseHeaders=new Headers();
-      for(const [name,value]of Object.entries(response.headers))if(value!==undefined)responseHeaders.set(name,Array.isArray(value)?value.join(', '):String(value));
-      if([204,205,304].includes(response.statusCode)){response.resume();resolve(new Response(null,{status:response.statusCode,headers:responseHeaders}));}
-      else resolve(new Response(Readable.toWeb(response),{status:response.statusCode,headers:responseHeaders}));
-    });
-    const timer=setTimeout(()=>request.destroy(Error('image_header_timeout')),600000);timer.unref();
-    request.once('error',error=>{clearTimeout(timer);reject(error);});request.end(body);
-  });
-}
-export const gatewayRequest=(url,options)=>isImageRoute(new URL(url).pathname)?imageRequest(url,options):fetch(url,options);

package/io.mjs

@@ -1,5 +0,0 @@
-export async function boundedJson(response,limit,code='invalid_remote_response'){
-  const chunks=[];let size=0;
-  for await(const chunk of response.body){size+=chunk.length;if(size>limit)throw Object.assign(Error(code),{status:502});chunks.push(chunk);}
-  try{return JSON.parse(Buffer.concat(chunks).toString('utf8'));}catch{throw Object.assign(Error(code),{status:502});}
-}

package/license-client.mjs

@@ -1,153 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import {execFileSync} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-import {LICENSE_PUBLIC_KEY,LICENSE_ORIGIN} from './product.mjs';
-import {hash,publicText,signProof,verifyEnvelope} from './protocol.mjs';
-import {boundedJson} from './io.mjs';
-class RelayError extends Error{constructor(status,code){super(code);this.status=status;this.code=code;}}
-const TERMINAL_DENIALS=new Set(['license_invalid_or_expired','device_revoked','activation_invalid','device_already_bound_or_revoked']);
-const LOCAL_DENIALS=new Set(['activation_required','license_signature_invalid','clock_rollback_detected','license_clock_skew','license_invalid_or_expired','license_revoked']);
-function serviceError(code,status=503,retryAfter=1){const error=new RelayError(status,code);error.transient=true;error.authoritative=false;error.retryAfter=retryAfter;return error;}
-function normalizeFailure(error){
-  const code=typeof error?.code==='string'?error.code:error?.message;
-  if(code==='license_lease_expired'||code==='license_response_invalid')return serviceError(code,503,error?.retryAfter??1);
-  if(error?.transient||error?.status>=500||error?.status===429||['license_server_unavailable','license_response_invalid','license_service_busy','try_later','ingress_rate_limit','ingress_busy','ingress_capacity'].includes(code))return serviceError(code==='license_service_busy'||error?.status===429?'license_service_busy':'license_server_unavailable',error?.status===429?429:503,error?.retryAfter??1);
-  if(TERMINAL_DENIALS.has(code)||LOCAL_DENIALS.has(code)){const failure=new RelayError(403,code);failure.authoritative=error?.authoritative!==false;return failure;}
-  return serviceError('license_server_unavailable');
-}
-
-function windowsDevice(action,value){
-  const executable=path.join(process.env.SystemRoot??'C:/Windows','System32/WindowsPowerShell/v1.0/powershell.exe');
-  try{return execFileSync(executable,['-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-File',fileURLToPath(new URL('./device.ps1',import.meta.url))],
-    {input:JSON.stringify({action,value}),encoding:'utf8',windowsHide:true,timeout:15000,stdio:['pipe','pipe','pipe']}).trim();}
-  catch{throw Error('device_protection_failed');}
-}
-export function machineIdentity(){
-  let value;
-  if(process.platform==='win32')value=windowsDevice('identity');
-  else if(process.platform==='darwin'){
-    const text=execFileSync('/usr/sbin/ioreg',['-rd1','-c','IOPlatformExpertDevice'],{encoding:'utf8',timeout:10000});
-    value=text.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)?.[1];
-  }else{
-    const file=fs.existsSync('/run/tdh-machine-id')?'/run/tdh-machine-id':'/etc/machine-id';
-    value=fs.readFileSync(file,'utf8').trim();
-  }
-  if(!value||value.length<16)throw Error('stable_machine_identity_required');
-  return hash('cu-web-device-v1:'+process.platform+':'+value.trim().toLowerCase());
-}
-export function loadDevice(state){
-  const deviceId=machineIdentity();let saved=state.get('license.device');
-  if(!saved){
-    const pair=crypto.generateKeyPairSync('ed25519');
-    const raw=pair.privateKey.export({type:'pkcs8',format:'der'}).toString('base64');
-    saved={deviceId,publicKey:publicText(pair.privateKey),format:process.platform==='win32'?'dpapi':'owner-permissions',
-      privateKey:process.platform==='win32'?windowsDevice('protect',raw):raw};
-    state.set('license.device',saved);
-  }
-  if(saved.deviceId!==deviceId)throw Error('activation_belongs_to_another_device');
-  const raw=saved.format==='dpapi'?windowsDevice('unprotect',saved.privateKey):saved.privateKey;
-  const privateKey=crypto.createPrivateKey({key:Buffer.from(raw,'base64'),format:'der',type:'pkcs8'});
-  if(publicText(privateKey)!==saved.publicKey)throw Error('device_key_mismatch');
-  return {deviceId,publicKey:saved.publicKey,privateKey};
-}
-export async function requestLicense(route,body,{request=fetch}={}){
-  if(!['challenge','activate','renew'].includes(route))throw Error('invalid_license_route');
-  let response;
-  try{response=await request(LICENSE_ORIGIN+'/api/licenses/'+route,{method:'POST',redirect:'error',
-    headers:{'content-type':'application/json'},body:JSON.stringify(body),signal:AbortSignal.timeout(10000)});}
-  catch{throw serviceError('license_server_unavailable');}
-  if(response.status===429||response.status>=500||response.status===408){response.body?.cancel().catch(()=>{});const value=Number(response.headers.get('retry-after'));throw serviceError(response.status===429?'license_service_busy':'license_server_unavailable',response.status===429?429:503,Number.isFinite(value)&&value>0?Math.min(60,Math.ceil(value)):1);}
-  let data;try{data=await boundedJson(response,16384,'license_response_invalid');}catch{throw serviceError('license_response_invalid');}
-  if(!response.ok){const error=new RelayError(403,typeof data.error==='string'&&/^[a-z_]+$/.test(data.error)?data.error:'license_request_rejected');error.authoritative=true;throw error;}
-  return data;
-}
-export class LicenseClient {
-  constructor(state,{publicKey=LICENSE_PUBLIC_KEY,request=requestLicense,device,now=Date.now}={}){
-    this.state=state;this.publicKey=publicKey;this.request=request;this.device=device??loadDevice(state);this.now=now;this.pending=null;this.nextAttempt=0;this.lastFailure=null;this.failures=0;
-    this.wallStart=now();this.monotonicStart=performance.now();
-  }
-  check(envelope=this.state.get('license.lease'),feature='desktop',{allowExpired=false}={}){
-    let claims;try{claims=verifyEnvelope(envelope,this.publicKey);}catch{throw Error('license_signature_invalid');}
-    const now=this.now(),last=this.state.get('license.clock')??0;
-    // Local validation cannot establish that the issuer revoked or expired a key.
-    if(!claims||claims.kind!=='tdh-relay-lease-v1'||claims.product!=='tdh-relay'||claims.deviceId!==this.device.deviceId||
-      typeof claims.licenseId!=='string'||!claims.licenseId||typeof claims.activationId!=='string'||!claims.activationId||
-      claims.keyHash!==hash(this.device.publicKey)||!Array.isArray(claims.features)||!claims.features.includes(feature)||!Number.isSafeInteger(claims.licenseExpiresAt)||
-      !Number.isSafeInteger(claims.issuedAt)||!Number.isSafeInteger(claims.expiresAt)||
-      claims.expiresAt<=claims.issuedAt||claims.expiresAt>claims.issuedAt+600000||claims.expiresAt>claims.licenseExpiresAt)throw serviceError('license_response_invalid');
-    if(now<last-30000||now<this.wallStart+performance.now()-this.monotonicStart-30000)throw Error('clock_rollback_detected');
-    if(claims.issuedAt>now+60000)throw Error('license_clock_skew');
-    if(!allowExpired&&claims.expiresAt<=now)throw serviceError('license_lease_expired');
-    if(now>last+10000)this.state.set('license.clock',now);
-    return claims;
-  }
-  async proof(action){
-    const challenge=await this.request('challenge',{deviceId:this.device.deviceId,publicKey:this.device.publicKey});
-    if(typeof challenge.id!=='string'||typeof challenge.nonce!=='string'||challenge.nonce.length>100)throw Error('challenge_invalid');
-    return {challengeId:challenge.id,proof:signProof(action,challenge.nonce,this.device.deviceId,this.device.publicKey,this.device.privateKey)};
-  }
-  save(response){
-    let claims;try{claims=this.check(response?.lease??null);}catch(error){error.authoritative=false;throw error;}
-    this.state.transaction(()=>{this.state.set('license.lease',response.lease);this.state.set('license.activation',claims.activationId);this.state.set('license.denied',false);});
-    this.nextAttempt=0;this.lastFailure=null;this.failures=0;return claims;
-  }
-  async activate(key){
-    if(typeof key!=='string'||!/^TDH-[A-Za-z0-9_-]{32}$/.test(key.trim()))throw Error('invalid_activation_key');
-    key=key.trim();const proof=await this.proof('activate:'+hash(key));
-    return this.save(await this.request('activate',{...proof,key}));
-  }
-  async renew(){
-    if(this.pending)return this.pending;
-    const activationId=this.state.get('license.activation');if(!activationId)throw Error('activation_required');
-    this.pending=(async()=>{
-      try{
-        for(let attempt=0;;attempt++){
-          const proof=await this.proof('renew:'+activationId);
-          const response=await this.request('renew',{...proof,activationId});
-          try{return this.save(response);}
-          catch(error){error.authoritative=false;if(error.code!=='license_lease_expired'||attempt>=1)throw error;}
-        }
-      }catch(error){
-        const failure=normalizeFailure(error);this.lastFailure=failure;
-        if(TERMINAL_DENIALS.has(failure.code)&&failure.authoritative){
-          this.state.set('license.denied',true);this.state.set('license.lease',null);
-        }
-        this.failures=Math.min(this.failures+1,6);const delay=failure.transient?Math.max((failure.retryAfter??1)*1000,Math.min(30000,1000*2**(this.failures-1))):30000;
-        this.nextAttempt=this.now()+delay;failure.retryAfter=Math.ceil(delay/1000);throw failure;
-      }finally{this.pending=null;}
-    })();
-    return this.pending;
-  }
-  async ensure(feature='desktop',{online=false}={}){
-    let current;try{if(!this.state.get('license.denied'))current=this.check(undefined,feature);}catch{}
-    if(online||!current||current.expiresAt-this.now()<300000){
-      if(this.now()>=this.nextAttempt){
-        try{await this.renew();}
-        catch(error){if(!current||this.state.get('license.denied')||online)throw normalizeFailure(error);}
-      }else if((!current||online)&&this.lastFailure)throw this.lastFailure;
-    }
-    if(this.state.get('license.denied'))throw new RelayError(403,'license_revoked');
-    try{return this.check(undefined,feature);}catch(error){if(this.lastFailure?.transient)throw this.lastFailure;throw normalizeFailure(error);}
-  }
-  async forRequest(feature='desktop'){
-    try{if(!this.state.get('license.denied'))return this.check(undefined,feature,{allowExpired:true});}catch{}
-    return this.ensure(feature);
-  }
-  acceptLease(encoded){
-    if(typeof encoded!=='string'||encoded.length>4096||this.state.get('license.denied'))return false;
-    try{
-      const envelope=JSON.parse(Buffer.from(encoded,'base64url')),claims=this.check(envelope);
-      if(claims.activationId!==this.state.get('license.activation'))return false;
-      const current=this.check(undefined,'desktop',{allowExpired:true});
-      if(claims.licenseId!==current.licenseId||claims.issuedAt<current.issuedAt||claims.issuedAt===current.issuedAt&&claims.expiresAt<=current.expiresAt)return false;
-      this.save({lease:envelope});return true;
-    }catch{return false;}
-  }
-  status(){
-    try{const c=this.check();return {active:!this.state.get('license.denied'),licenseId:c.licenseId,activationId:c.activationId,
-      leaseUntil:new Date(c.expiresAt).toISOString(),expiresAt:new Date(c.licenseExpiresAt).toISOString()};}
-    catch{return {active:false,activationRequired:!this.state.get('license.activation')};}
-  }
-}

package/product.mjs

@@ -1,5 +0,0 @@
-export const VERSION='0.1.0-web.13';
-export const PRODUCT='codexunlimit-connector';
-export const DEFAULT_PORT=18457;
-export const LICENSE_ORIGIN='https://codexunlimit.tudonghoa.me';
-export const LICENSE_PUBLIC_KEY='MCowBQYDK2VwAyEAnOW-TAyqv57sVI-ZOW3m0jurLc6hHzzeJ-KbiU_9hxk';

package/protocol.mjs

@@ -1,28 +0,0 @@
-import crypto from 'node:crypto';
-
-export const hash=value=>crypto.createHash('sha256').update(value).digest('hex');
-export const publicText=key=>crypto.createPublicKey(key).export({type:'spki',format:'der'}).toString('base64url');
-export function readPublic(text){
-  if(typeof text!=='string'||text.length>150)throw Error('invalid_device_key');
-  const key=crypto.createPublicKey({key:Buffer.from(text,'base64url'),type:'spki',format:'der'});
-  if(key.asymmetricKeyType!=='ed25519'&&!(key.asymmetricKeyType==='ec'&&key.asymmetricKeyDetails?.namedCurve==='prime256v1'))throw Error('invalid_device_key');
-  return key;
-}
-export function signEnvelope(value,privateKey){
-  const payload=Buffer.from(JSON.stringify(value)).toString('base64url');
-  return {payload,signature:crypto.sign(null,Buffer.from(payload),privateKey).toString('base64url')};
-}
-export function verifyEnvelope(envelope,publicKey){
-  if(!envelope||typeof envelope.payload!=='string'||envelope.payload.length>100000||
-    typeof envelope.signature!=='string'||!crypto.verify(null,Buffer.from(envelope.payload),readPublic(publicKey),Buffer.from(envelope.signature,'base64url')))throw Error('signature_invalid');
-  return JSON.parse(Buffer.from(envelope.payload,'base64url'));
-}
-export function proofText(action,nonce,deviceId,publicKey){
-  return Buffer.from(JSON.stringify(['tdh-relay-license-v1',action,nonce,deviceId,publicKey]));
-}
-export function signProof(action,nonce,deviceId,publicKey,privateKey){
-  return crypto.sign(privateKey.asymmetricKeyType==='ec'?'sha256':null,proofText(action,nonce,deviceId,publicKey),privateKey).toString('base64url');
-}
-export function verifyProof(action,nonce,deviceId,publicKey,signature){
-  try{const key=readPublic(publicKey);return crypto.verify(key.asymmetricKeyType==='ec'?'sha256':null,proofText(action,nonce,deviceId,publicKey),key,Buffer.from(signature,'base64url'));}catch{return false;}
-}

package/quota.mjs

@@ -1,34 +0,0 @@
-import crypto from 'node:crypto';
-
-export function accountIdentity(credentials){
-  let claims={};try{claims=JSON.parse(Buffer.from(credentials.token.split('.')[1],'base64url'));}catch{}
-  const auth=claims['https://api.openai.com/auth']??{},profile=claims['https://api.openai.com/profile']??{};
-  const accountId=credentials.accountId??auth.chatgpt_account_id,subject=typeof claims.sub==='string'?claims.sub:'';
-  const email=typeof (claims.email??profile.email)==='string'?(claims.email??profile.email).slice(0,254):null;
-  return {ref:crypto.createHash('sha256').update(subject||accountId?JSON.stringify([subject,accountId??'']):credentials.token).digest('hex'),email,plan:typeof auth.chatgpt_plan_type==='string'?auth.chatgpt_plan_type.slice(0,40):null,accountId};
-}
-function windowValue(minutes,used,resetAt){
-  if(![300,10080].includes(minutes)||typeof used!=='number'||!Number.isFinite(used)||used<0||used>100)return null;
-  return {minutes,used,resetAt:Number.isSafeInteger(resetAt)&&resetAt>0&&resetAt<8640000000000000?resetAt:null};
-}
-export function headerWindows(headers,now=Date.now()){
-  const number=value=>typeof value==='string'&&/^\d+(?:\.\d+)?$/.test(value)&&Number.isFinite(Number(value))?Number(value):null;
-  return ['primary','secondary'].map(prefix=>{
-    const get=name=>number(headers.get('x-codex-'+prefix+'-'+name));
-    const reset=get('reset-at'),after=get('reset-after-seconds');return windowValue(get('window-minutes'),get('used-percent'),reset!==null?reset*1000:after!==null?now+after*1000:null);
-  }).filter(Boolean);
-}
-export function rateLimitWindows(result){
-  const bucket=result?.rateLimitsByLimitId?.codex??result?.rateLimits;
-  if(!bucket||bucket.limitId&&bucket.limitId!=='codex')return [];
-  return [bucket.primary,bucket.secondary].filter(Boolean).map(window=>windowValue(window.windowDurationMins,window.usedPercent,typeof window.resetsAt==='number'?window.resetsAt*1000:null)).filter(Boolean);
-}
-export class LocalQuota{
-  constructor(state,{now=Date.now}={}){this.db=state.db;this.now=now;this.db.exec('CREATE TABLE IF NOT EXISTS local_account_quota(account_ref TEXT NOT NULL,minutes INTEGER NOT NULL,used REAL NOT NULL,reset_at INTEGER,observed_at INTEGER NOT NULL,source TEXT NOT NULL,PRIMARY KEY(account_ref,minutes))');}
-  save(ref,windows,source){
-    const now=this.now();for(const window of windows)this.db.prepare('INSERT INTO local_account_quota VALUES(?,?,?,?,?,?) ON CONFLICT(account_ref,minutes) DO UPDATE SET used=excluded.used,reset_at=excluded.reset_at,observed_at=excluded.observed_at,source=excluded.source WHERE excluded.observed_at>=observed_at').run(ref,window.minutes,window.used,window.resetAt,now,source);
-    this.db.prepare('DELETE FROM local_account_quota WHERE observed_at<?').run(now-30*86400000);
-  }
-  observe(credentials,response){if(response.ok||response.status===429)this.save(accountIdentity(credentials).ref,headerWindows(response.headers,this.now()),'response_headers');}
-  read(ref){return this.db.prepare('SELECT minutes,used,reset_at,observed_at,source FROM local_account_quota WHERE account_ref=? ORDER BY minutes').all(ref).map(window=>({...window,stale:this.now()-window.observed_at>15*60000||window.reset_at!==null&&window.reset_at<=this.now()}));}
-}

package/relay.mjs

@@ -1,156 +0,0 @@
-import http from 'node:http';
-import crypto from 'node:crypto';
-import {Readable} from 'node:stream';
-import {pipeline} from 'node:stream/promises';
-import {PRODUCT,VERSION,LICENSE_ORIGIN} from './product.mjs';
-import {hash} from './protocol.mjs';
-import {isImageRoute,gatewayRequest} from './image-http.mjs';
-import {boundedJson} from './io.mjs';
-
-const CONTEXT_HEADERS=['content-type','content-encoding','chatgpt-account-id','session_id','session-id','conversation_id','originator','version','openai-beta','x-codex-beta-features','x-codex-parent-thread-id','x-codex-turn-metadata','x-codex-turn-state'];
-export function signedHeaders(license,state,method,route,authorization,body=Buffer.alloc(0),headers=new Headers(),timestamp=Date.now()){
-  const envelope=state.get('license.lease');license.check(envelope,'desktop',{allowExpired:true});
-  const nonce=crypto.randomBytes(24).toString('base64url'),key=license.device.privateKey;
-  const bodyHash=hash(body??Buffer.alloc(0));
-  const contextHeaders=isImageRoute(route)?[...CONTEXT_HEADERS,'x-codex-image-turn-id']:CONTEXT_HEADERS;
-  const text=Buffer.from(JSON.stringify(['cu-request-v2',envelope.payload,method,route,timestamp,nonce,hash(authorization),bodyHash,contextHeaders.map(name=>[name,headers.get(name)??''])]));
-  return {'x-cu-lease':Buffer.from(JSON.stringify(envelope)).toString('base64url'),'x-cu-time':String(timestamp),'x-cu-nonce':nonce,
-    'x-cu-proof-version':'2','x-cu-body-sha256':bodyHash,
-    'x-cu-proof':crypto.sign(key.asymmetricKeyType==='ec'?'sha256':null,text,key).toString('base64url')};
-}
-const connectionError=(status,code)=>Object.assign(Error(code),{status,code});
-const requestId=value=>typeof value==='string'&&/^[a-f0-9-]{36}$/i.test(value)?value:null;
-function waitForRetry(ms,signal){
-  return new Promise((resolve,reject)=>{
-    if(signal.aborted)return reject(signal.reason);
-    const finish=error=>{clearTimeout(timer);signal.removeEventListener('abort',abort);error?reject(error):resolve();};
-    const abort=()=>finish(signal.reason??connectionError(499,'client_cancelled'));
-    const timer=setTimeout(()=>finish(),ms);signal.addEventListener('abort',abort,{once:true});
-  });
-}
-function connectionQueue(limit,{maxQueued,queueTimeoutMs}){
-  const active={inference:0,models:0},pending=[];let capacity=Math.min(2,limit);
-  const drain=()=>{for(let i=0;i<pending.length;){const item=pending[i];if(active[item.lane]<(item.lane==='models'?1:capacity)){pending.splice(i,1);item.grant();}else i++;}};
-  return {
-    observe(response){const value=response.headers.get('x-cu-max-concurrent');if(value&&/^[1-9][0-9]{0,2}$/.test(value)){capacity=Math.min(limit,Number(value));drain();}},
-    acquire(lane,signal){return new Promise((resolve,reject)=>{
-      if(signal.aborted)return reject(signal.reason);
-      if(pending.length>=maxQueued)return reject(connectionError(429,'local_queue_full'));
-      let timer,settled=false;
-      const clean=()=>{clearTimeout(timer);signal.removeEventListener('abort',abort);};
-      const fail=error=>{if(settled)return;settled=true;clean();const i=pending.indexOf(item);if(i>=0)pending.splice(i,1);reject(error);};
-      const abort=()=>fail(signal.reason??connectionError(499,'client_cancelled'));
-      const item={lane,grant(){if(settled)return;settled=true;clean();active[lane]++;let released=false;resolve(()=>{if(released)return;released=true;active[lane]--;drain();});}};
-      signal.addEventListener('abort',abort,{once:true});timer=setTimeout(()=>fail(connectionError(429,'local_queue_timeout')),queueTimeoutMs);
-      pending.push(item);drain();
-    })}
-  };
-}
-export function createConnector(state,{license,localApp,pool,onStop=()=>{},prepareStop=()=>{},origin=LICENSE_ORIGIN,request=gatewayRequest,maxBufferedBytes=128*1024*1024,bodyTimeoutMs=60000,maxQueued=32,queueTimeoutMs=15000,retryBudgetMs=15000,retryDelayMs=1000}={}){
-  if(new URL(origin).protocol!=='https:')throw Error('https_required');
-  let buffered=0,clockOffsetMs=0;
-  const queue=connectionQueue(state.settings.get('relay.max_concurrency')??4,{maxQueued,queueTimeoutMs});
-  const server=http.createServer(async(req,res)=>{
-    const controller=new AbortController(),started=Date.now(),localRequestId=crypto.randomUUID();
-    let status=503,reserved=0,bodyTimer,release,tracked=false,stage='routing',errorCode=null,serverRequestId=null,attempts=0,queueMs=0,uploadMs=0,proofAgeMs=null;
-    req.on('aborted',()=>controller.abort());res.on('close',()=>{if(!res.writableFinished)controller.abort();});
-    const json=(code,data)=>{status=code;errorCode=data?.error?.code??errorCode;res.writeHead(code,{'content-type':'application/json','cache-control':'no-store'});res.end(JSON.stringify(data));};
-    try{
-      if(!['127.0.0.1:'+server.address().port,'localhost:'+server.address().port].includes(req.headers.host))return json(403,{error:{code:'local_request_denied'}});
-      if(localApp&&await localApp(req,res,server))return;
-      if(req.headers.origin)return json(403,{error:{code:'local_request_denied'}});
-      if(req.method==='GET'&&req.url==='/healthz')return json(200,{ok:true,service:PRODUCT,version:VERSION,mode:'desktop'});
-      if(req.method==='GET'&&req.url==='/control/identity'){
-        const nonce=String(req.headers['x-cu-nonce']??'');if(!/^[a-f0-9]{48}$/.test(nonce))return json(400,{error:{code:'invalid_nonce'}});
-        return json(200,{proof:crypto.createHmac('sha256',state.get('control_token')).update('cu-instance:'+nonce).digest('hex')});
-      }
-      if(req.method==='POST'&&req.url==='/control/stop'){
-        const a=Buffer.from(state.get('control_token')??''),b=Buffer.from(String(req.headers['x-cu-control']??''));
-        if(!a.length||a.length!==b.length||!crypto.timingSafeEqual(a,b))return json(403,{error:{code:'control_denied'}});
-        const mode=req.headers['x-cu-stop-mode']??'exit';if(!['exit','update'].includes(mode))return json(400,{error:{code:'invalid_stop_mode'}});
-        await prepareStop(mode);json(200,{stopped:true});setImmediate(onStop);return;
-      }
-      tracked=/^\/v1\/(?:responses(?:\/compact)?|models(?:\?.*)?|images\/(?:generations|edits))$/.test(req.url)||isImageRoute(req.url);
-      if(tracked)res.setHeader('x-cu-local-request-id',localRequestId);
-      if(!(req.method==='GET'&&/^\/v1\/models(?:\?client_version=[a-zA-Z0-9._%-]{1,100})?$/.test(req.url))&&!(req.method==='POST'&&(['/v1/responses','/v1/responses/compact'].includes(req.url)||isImageRoute(req.url))))return json(404,{error:{code:'route_not_found'}});
-      let authorization=req.headers.authorization??'';
-      const selectedAccount=pool?.active();
-      if(!/^Bearer [^\s]{16,32768}$/.test(authorization)||authorization.startsWith('Bearer sk-'))return json(401,{error:{code:'chatgpt_sign_in_required'}});
-      stage='queue';const queuedAt=Date.now();
-      release=await queue.acquire(req.method==='GET'?'models':'inference',controller.signal);queueMs=Date.now()-queuedAt;
-      controller.signal.throwIfAborted();
-      const limit=state.settings.get('relay.max_body_bytes');if(Number(req.headers['content-length']??0)>limit){req.resume();return json(413,{error:{code:'request_too_large'}});}
-      const length=Number(req.headers['content-length']??limit);
-      if(!Number.isSafeInteger(length)||length<0)return json(400,{error:{code:'invalid_body_length'}});
-      // Account for input chunks and their contiguous copy together.
-      reserved=req.method==='POST'?2*length:0;
-      if(buffered+reserved>maxBufferedBytes){reserved=0;req.resume();return json(503,{error:{code:'client_memory_busy'}});}
-      buffered+=reserved;stage='upload';const uploadStarted=Date.now();
-      bodyTimer=setTimeout(()=>{controller.abort(connectionError(408,'local_upload_timeout'));req.destroy();},bodyTimeoutMs);bodyTimer.unref();
-      const headers=new Headers();
-      for(const name of ['authorization','content-type','content-encoding','chatgpt-account-id','session_id','session-id','conversation_id','originator','user-agent','version','openai-beta','x-codex-beta-features','x-codex-parent-thread-id','x-codex-turn-metadata','x-codex-turn-state','x-codex-image-turn-id'])if(typeof req.headers[name]==='string')headers.set(name,req.headers[name]);
-      const localToken=Buffer.from(String(req.headers['x-cu-control']??'')),expectedToken=Buffer.from(state.get('control_token')??'');
-      const fromLocalApp=expectedToken.length>0&&localToken.length===expectedToken.length&&crypto.timingSafeEqual(localToken,expectedToken);
-      if(pool&&selectedAccount!=='codex'&&!fromLocalApp){
-        if(!state.get('web.privacyAcceptedAt'))throw Object.assign(Error('privacy_required'),{status:403});
-        const credentials=await pool.credentials(selectedAccount);authorization='Bearer '+credentials.token;headers.set('authorization',authorization);headers.delete('chatgpt-account-id');if(credentials.accountId)headers.set('chatgpt-account-id',credentials.accountId);
-      }
-      // Bound input in the connector too, before forwarding. No request content is persisted.
-      const chunks=[];let size=0;for await(const chunk of req){size+=chunk.length;if(size>limit)throw Object.assign(Error('request_too_large'),{status:413});chunks.push(chunk);}
-      clearTimeout(bodyTimer);uploadMs=Date.now()-uploadStarted;const payload=req.method==='POST'?Buffer.concat(chunks):undefined;chunks.length=0;
-      // Queueing and upload finish before the timestamp/nonce are minted. A retry
-      // is allowed only after an authenticated gateway's explicit pre-upstream denial.
-      stage='license';controller.signal.throwIfAborted();await license.forRequest('desktop');controller.signal.throwIfAborted();
-      const retryDeadline=Date.now()+retryBudgetMs;let response,proofRetries=0;
-      for(;;){
-        stage='gateway';const sentAt=Date.now();
-        for(const [key,value]of Object.entries(signedHeaders(license,state,req.method,req.url,authorization,payload,headers,Math.round(sentAt+clockOffsetMs))))headers.set(key,value);
-        attempts++;
-        response=await request(origin+req.url,{method:req.method,headers,body:payload,redirect:'error',signal:AbortSignal.any([controller.signal,AbortSignal.timeout(isImageRoute(req.url)?630000:1800000)])});
-        queue.observe(response);serverRequestId=requestId(response.headers.get('x-cu-request-id'));
-        const receivedAt=Date.now(),serverDate=Date.parse(response.headers.get('date')??'');
-        if(Number.isFinite(serverDate)){
-          proofAgeMs=serverDate-Number(headers.get('x-cu-time'));
-          const offset=serverDate+500-(sentAt+receivedAt)/2;
-          if(serverRequestId&&receivedAt-sentAt<5000&&Math.abs(offset)<=300000)clockOffsetMs=Math.round(offset);
-        }
-        let gatewayCode=null;
-        if(serverRequestId&&response.status>=400&&(response.headers.get('content-type')??'').toLowerCase().startsWith('application/json')){
-          const data=await boundedJson(response,32768,'gateway_response_invalid').catch(()=>{throw connectionError(502,'gateway_response_invalid');});
-          gatewayCode=typeof data?.error?.code==='string'&&/^[a-z_]{1,80}$/.test(data.error.code)?data.error.code:null;
-          response=new Response(JSON.stringify(data),{status:response.status,headers:response.headers});
-        }
-        const stale=response.status===408&&gatewayCode==='request_proof_expired'&&proofRetries<1;
-        const busy=response.status===429&&gatewayCode==='license_concurrency_limit';
-        const requestedDelay=Number(response.headers.get('retry-after'))*1000;
-        const delay=stale?0:Math.max(retryDelayMs,Number.isFinite(requestedDelay)&&requestedDelay>0?requestedDelay:0);
-        if((stale||busy)&&attempts<8&&Date.now()+delay<retryDeadline){
-          await response.body?.cancel();if(stale)proofRetries++;
-          stage='retry_wait';await waitForRetry(delay,controller.signal);continue;
-        }
-        errorCode=gatewayCode;break;
-      }
-      license.acceptLease(response.headers.get('x-cu-lease'));
-      pool?.observe({token:authorization.slice(7),accountId:headers.get('chatgpt-account-id')??undefined},response);
-      if(response.status>=400&&!(response.headers.get('content-type')??'').toLowerCase().startsWith('application/json')){
-        response.body?.cancel().catch(()=>{});status=response.status===429?429:503;const wait=Number(response.headers.get('retry-after'));res.setHeader('retry-after',String(Number.isFinite(wait)&&wait>0?Math.min(60,Math.ceil(wait)):3));
-        return json(status,{error:{code:'service_unavailable',message:'Máy chủ tạm thời chưa phản hồi hợp lệ. Không tự gửi lại tác vụ đang chạy; kiểm tra kết nối rồi thử lại.'}});
-      }
-      stage='stream';status=response.status;const outgoing={'cache-control':'no-store'};
-      for(const [key,value]of response.headers)if(['content-type','retry-after','x-cu-request-id'].includes(key)||key.startsWith('x-codex-')||isImageRoute(req.url)&&key==='x-relay-policy-mode')outgoing[key]=value;
-      res.writeHead(status,outgoing);if(response.body)await pipeline(Readable.fromWeb(response.body),res,{signal:controller.signal});else res.end();stage='complete';
-    }catch(error){
-      const reason=controller.signal.reason?.status?controller.signal.reason:error;
-      status=reason?.status??(controller.signal.aborted?499:502);
-      errorCode=(typeof reason?.code==='string'?reason.code.toLowerCase():typeof reason?.cause?.code==='string'?reason.cause.code.toLowerCase():null)??(controller.signal.aborted?'client_cancelled':stage==='stream'?'stream_interrupted':'connection_failed');
-      if(res.headersSent||status===499||res.destroyed)res.destroy();
-      else{if([429,503].includes(status))res.setHeader('retry-after',String(reason?.retryAfter??3));json(status,{error:{code:errorCode}});}
-    }finally{
-      if(stage==='queue')queueMs=Date.now()-started;
-      if(stage==='upload')uploadMs=Math.max(0,Date.now()-started-queueMs);
-      clearTimeout(bodyTimer);controller.abort();buffered-=reserved;release?.();
-      if(tracked){try{state.record({status,duration:Date.now()-started,requestId:localRequestId,serverRequestId,route:req.url.split('?')[0],method:req.method,errorCode,stage,queueMs,uploadMs,attempts,proofAgeMs});}catch{}}
-    }
-  });
-  server.headersTimeout=15000;server.requestTimeout=bodyTimeoutMs+queueTimeoutMs;return server;
-}

package/state.mjs

@@ -1,33 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import {DatabaseSync} from 'node:sqlite';
-import {DEFAULT_PORT,VERSION} from './product.mjs';
-export class ClientState{
-  constructor(home){
-    this.home=path.resolve(home);fs.mkdirSync(path.join(this.home,'data'),{recursive:true,mode:0o700});
-    this.db=new DatabaseSync(path.join(this.home,'data','connector.sqlite'));
-    this.db.exec('PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000; CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY,value TEXT NOT NULL); CREATE TABLE IF NOT EXISTS desktop_usage(id INTEGER PRIMARY KEY,ts INTEGER NOT NULL,status INTEGER NOT NULL,duration_ms INTEGER NOT NULL);');
-    this.db.exec('CREATE TABLE IF NOT EXISTS connection_diagnostics(id INTEGER PRIMARY KEY,at INTEGER NOT NULL,request_id TEXT,server_request_id TEXT,route TEXT,method TEXT,status INTEGER,error_code TEXT,stage TEXT,duration_ms INTEGER,queue_ms INTEGER,upload_ms INTEGER,attempts INTEGER,proof_age_ms INTEGER);');
-    this.settings={get:key=>this.get(key),set:(key,value)=>this.set(key,value)};
-  }
-  get(key){const row=this.db.prepare('SELECT value FROM settings WHERE key=?').get(key);return row?JSON.parse(row.value):null;}
-  set(key,value){this.db.prepare('INSERT INTO settings VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value').run(key,JSON.stringify(value));}
-  transaction(action){this.db.exec('BEGIN IMMEDIATE');try{const value=action();this.db.exec('COMMIT');return value;}catch(error){this.db.exec('ROLLBACK');throw error;}}
-  initialize({port=DEFAULT_PORT,codexHome}={}){
-    if(!this.get('initialized')){this.set('relay.port',port);this.set('control_token',crypto.randomBytes(32).toString('base64url'));this.set('initialized',true);}
-    this.set('relay.max_body_bytes',64*1024*1024);this.set('relay.max_concurrency',4);this.set('version',VERSION);
-    if(codexHome)this.set('codex_home',path.resolve(codexHome));
-  }
-  record(row){
-    const now=Date.now();this.db.prepare('INSERT INTO desktop_usage(ts,status,duration_ms) VALUES(?,?,?)').run(now,row.status,row.duration);this.db.prepare('DELETE FROM desktop_usage WHERE id<(SELECT MAX(id)-2000 FROM desktop_usage)').run();
-    if(!/^\/(?:v1\/)?(?:responses(?:\/compact)?|models|images\/(?:generations|edits))$/.test(row.route??''))return;
-    const code=value=>typeof value==='string'&&/^[a-z_]{1,80}$/.test(value)?value:null;
-    const id=value=>typeof value==='string'&&/^[a-f0-9-]{36}$/i.test(value)?value:null;
-    const number=value=>Number.isSafeInteger(value)?value:null;
-    this.db.prepare('INSERT INTO connection_diagnostics(at,request_id,server_request_id,route,method,status,error_code,stage,duration_ms,queue_ms,upload_ms,attempts,proof_age_ms) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)').run(now,id(row.requestId),id(row.serverRequestId),row.route,['GET','POST'].includes(row.method)?row.method:null,number(row.status),code(row.errorCode),code(row.stage),number(row.duration),number(row.queueMs),number(row.uploadMs),number(row.attempts),number(row.proofAgeMs));
-    this.db.prepare('DELETE FROM connection_diagnostics WHERE id<=(SELECT MAX(id)-2000 FROM connection_diagnostics) OR at<?').run(now-7*86400000);
-  }
-  diagnostics(){return this.db.prepare('SELECT * FROM connection_diagnostics ORDER BY id DESC LIMIT 100').all();}
-  close(){this.db.close();}
-}

package/updates.mjs

@@ -1,47 +0,0 @@
-import {VERSION} from './product.mjs';
-import {boundedJson} from './io.mjs';
-
-function parseVersion(value){
-  if(typeof value!=='string'||value.length>120)return null;
-  const match=/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(value);
-  if(!match)return null;
-  const pre=match[4]?.split('.')??[];
-  if(pre.some(id=>/^0\d+$/.test(id)))return null;
-  return {core:match.slice(1,4).map(BigInt),pre};
-}
-export function compareVersions(left,right){
-  const a=parseVersion(left),b=parseVersion(right);if(!a||!b)throw Error('invalid_version');
-  const compare=(x,y)=>x<y?-1:x>y?1:0;
-  for(let i=0;i<3;i++){const result=compare(a.core[i],b.core[i]);if(result)return result;}
-  if(!a.pre.length||!b.pre.length)return compare(Number(!a.pre.length),Number(!b.pre.length));
-  for(let i=0;i<Math.max(a.pre.length,b.pre.length);i++){
-    if(a.pre[i]===undefined)return -1;if(b.pre[i]===undefined)return 1;
-    const x=a.pre[i],y=b.pre[i],xn=/^\d+$/.test(x),yn=/^\d+$/.test(y);
-    const result=xn&&yn?compare(BigInt(x),BigInt(y)):xn!==yn?(xn?-1:1):compare(x,y);
-    if(result)return result;
-  }
-  return 0;
-}
-export function createUpdateChecker({request=fetch,now=Date.now,version=VERSION,platform=process.platform}={}){
-  let cached=null,pending=null,nextCheck=0;
-  const commands={installCommand:(platform==='win32'?'npm.cmd':'npm')+' i -g codexunlimit@latest',restartCommand:platform==='win32'?'codexunlimit.cmd restart':'codexunlimit restart'};
-  return function check(){
-    if(pending)return pending;
-    if(cached&&now()<nextCheck)return Promise.resolve(cached);
-    pending=(async()=>{
-      try{
-        const response=await request('https://registry.npmjs.org/codexunlimit/latest',{headers:{accept:'application/json'},redirect:'error',signal:AbortSignal.timeout(5000)});
-        if(!response.ok)throw Error('update_check_failed');
-        const release=await boundedJson(response,65536);
-        if(release.name!=='codexunlimit'||!parseVersion(release.version))throw Error('invalid_release');
-        cached={currentVersion:version,latestVersion:release.version,available:compareVersions(release.version,version)>0,status:'checked',checkedAt:now(),...commands};
-        nextCheck=now()+3600000;
-      }catch{
-        cached={currentVersion:version,latestVersion:null,available:false,status:'unavailable',checkedAt:null,...commands};
-        nextCheck=now()+60000;
-      }
-      return cached;
-    })().finally(()=>{pending=null;});
-    return pending;
-  };
-}

package/web/markdown.js

@@ -1,15 +0,0 @@
-import markdownit from '/app/vendor/markdown-it.js';
-
-const markdown=markdownit({html:false,linkify:false,breaks:false});
-const escape=markdown.utils.escapeHtml;
-markdown.validateLink=value=>/^(?:https?:\/\/|mailto:|#)/i.test(value);
-markdown.renderer.rules.image=(tokens,index)=>'<span class="markdown-image">[Ảnh: '+escape(tokens[index].content||'không có mô tả')+']</span>';
-markdown.renderer.rules.link_open=(tokens,index,options,environment,renderer)=>{
-  tokens[index].attrSet('target','_blank');tokens[index].attrSet('rel','noopener noreferrer');return renderer.renderToken(tokens,index,options);
-};
-const fence=markdown.renderer.rules.fence;
-markdown.renderer.rules.fence=(tokens,index,options,environment,renderer)=>{
-  const name=tokens[index].info.trim().split(/\s+/)[0],language=/^[a-z0-9_+-]{1,24}$/i.test(name)?name:'Code';
-  return '<div class="markdown-code"><div class="markdown-code-head"><span>'+escape(language)+'</span><button type="button" data-copy-code>Sao chép</button></div>'+fence(tokens,index,options,environment,renderer)+'</div>';
-};
-export function renderMarkdown(text){return markdown.render(String(text??''));}