@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-browse/src/cookie-import-native-integrity.ts

@@ -1,95 +0,0 @@
-import { createHash } from 'node:crypto';
-import { createReadStream } from 'node:fs';
-import path from 'node:path';
-
-export const NATIVE_QUALIFICATION_DATA = 'browse/src/cookie-import-native-qualification.json';
-export const NATIVE_BROWSER_VERSION_COMMAND = '$ErrorActionPreference = "Stop"; [Diagnostics.FileVersionInfo]::GetVersionInfo($env:GSTACK_QUALIFY_BROWSER_EXE).ProductVersion';
-
-export const NATIVE_CODE_INPUTS = Object.freeze([
-  'browse/src/cookie-import-browser.ts',
-  'browse/src/cookie-database.ts',
-  'browse/src/cookie-import-native.ts',
-  'browse/src/cookie-import-native-integrity.ts',
-  'browse/src/cookie-import-native-job.ts',
-  'browse/src/cookie-import-native-worker.ts',
-  'browse/src/bun-child-config.ts',
-  'browse/src/bun-polyfill.cjs',
-  'browse/scripts/build-node-server.sh',
-  '.github/scripts/run-cookie-native-qualification.ps1',
-  'browse/dist/server-node.mjs',
-  'browse/dist/bun-polyfill.cjs',
-  'browse/test/cookie-import-native.test.ts',
-  'browse/test/cookie-import-native-job.test.ts',
-  'browse/test/cookie-import-native-qualification.ts',
-  'browse/test/fixtures/native-cookie-process.cjs',
-  'browse/test/fixtures/native-cookie-launch.cjs',
-  'browse/test/fixtures/native-cookie-process-observer.ts',
-  'browse/test/fixtures/native-cookie-file-owners.ts',
-  'browse/test/fixtures/native-cookie-remove-fixture.cjs',
-  'node_modules/playwright/package.json',
-  'node_modules/playwright/index.js',
-  'node_modules/playwright-core/package.json',
-  'node_modules/playwright-core/index.js',
-  'node_modules/playwright-core/lib/bootstrap.js',
-  'node_modules/playwright-core/lib/coreBundle.js',
-  'node_modules/playwright-core/lib/utilsBundle.js',
-]);
-
-export interface NativeQualifiedBuild {
-  browserName: 'Chrome' | 'Chromium' | 'Brave' | 'Edge';
-  architecture: 'x64' | 'arm64';
-  windowsRelease: string;
-  executableSha256: string;
-  nodeVersion: string;
-  bunVersion: string;
-  playwrightVersion: string;
-  sourceHashes: Record<string, string>;
-}
-
-async function readBoundedFile(file: string, deadline: number, maximumBytes: number): Promise<Buffer> {
-  if (!Number.isFinite(deadline) || Date.now() >= deadline) throw new Error('native_timeout');
-  const cancellation = new AbortController();
-  const timer = setTimeout(() => cancellation.abort(), Math.max(0, deadline - Date.now()));
-  const stream = createReadStream(file, { signal: cancellation.signal });
-  const chunks: Buffer[] = [];
-  let size = 0;
-  try {
-    for await (const chunk of stream) {
-      size += chunk.length;
-      if (size > maximumBytes) throw new Error('native_unqualified');
-      chunks.push(chunk);
-    }
-    if (Date.now() >= deadline) throw new Error('native_timeout');
-    return Buffer.concat(chunks);
-  } catch (error) {
-    if (cancellation.signal.aborted) throw new Error('native_timeout');
-    throw error;
-  } finally {
-    stream.destroy();
-    clearTimeout(timer);
-  }
-}
-
-export async function readNativeQualifications(root: string, deadline: number): Promise<NativeQualifiedBuild[]> {
-  const builds = JSON.parse((await readBoundedFile(path.join(root, NATIVE_QUALIFICATION_DATA), deadline, 1024 * 1024)).toString('utf8'));
-  if (!Array.isArray(builds) || builds.some(build => !build || typeof build !== 'object')) throw new Error('native_unqualified');
-  return builds;
-}
-
-export async function hashNativeFile(file: string, deadline: number): Promise<string> {
-  return createHash('sha256').update(await readBoundedFile(file, deadline, 64 * 1024 * 1024)).digest('hex');
-}
-
-export async function nativeCodeHashes(root: string, deadline: number): Promise<Record<string, string>> {
-  const hashes: Record<string, string> = {};
-  for (const file of NATIVE_CODE_INPUTS) hashes[file] = await hashNativeFile(path.join(root, file), deadline);
-  return hashes;
-}
-
-export function nativeCodeMatches(expected: unknown, actual: Record<string, string>): boolean {
-  if (!expected || typeof expected !== 'object' || Array.isArray(expected) || Object.keys(expected).length !== NATIVE_CODE_INPUTS.length) return false;
-  return NATIVE_CODE_INPUTS.every(file => {
-    const hash = (expected as Record<string, unknown>)[file];
-    return typeof hash === 'string' && /^[0-9a-f]{64}$/.test(hash) && hash === actual[file];
-  });
-}

package/.agent/skills/gstack-browse/src/cookie-import-native-job.ts

@@ -1,161 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-const NATIVE_COOKIE_STAGES = [
-  'platform', 'ffi_import', 'ffi_open', 'job_create', 'job_limits', 'job_open',
-  'process_open', 'job_assign', 'job_assigned', 'job_joined', 'process_close', 'job_query', 'job_terminate', 'job_close',
-  'worker_boot', 'supervisor_input', 'runtime_check', 'member_start', 'member_input', 'member_decoded', 'member_exit',
-  'node_start', 'node_spawned', 'node_exit', 'node_input', 'node_load', 'browser_launch', 'cookie_read', 'browser_close',
-] as const;
-
-export interface NativeCookieDiagnostic {
-  stage: typeof NATIVE_COOKIE_STAGES[number];
-  win32Error?: number;
-  lastStage?: typeof NATIVE_COOKIE_STAGES[number];
-  exitCode?: number;
-  nodeExitCode?: number;
-  signal?: string;
-  memberMode?: boolean;
-  stderrBytes?: number;
-}
-
-export class NativeCookieJobError extends Error {
-  readonly diagnostic: NativeCookieDiagnostic;
-
-  constructor(stage: NativeCookieDiagnostic['stage'], win32Error?: number) {
-    super(stage === 'platform' ? 'native_supervision_unavailable' : 'native_supervision_failed');
-    this.name = 'NativeCookieJobError';
-    this.diagnostic = { stage, ...(Number.isInteger(win32Error) && win32Error! >= 0 && win32Error! <= 0xffffffff ? { win32Error } : {}) };
-  }
-}
-
-export function nativeCookieDiagnostic(error: unknown, fallback: NativeCookieDiagnostic['stage']): NativeCookieDiagnostic {
-  return error instanceof NativeCookieJobError ? error.diagnostic : { stage: fallback };
-}
-
-export function parseNativeCookieDiagnostic(value: unknown): NativeCookieDiagnostic | undefined {
-  if (!value || typeof value !== 'object') return undefined;
-  const candidate = value as NativeCookieDiagnostic;
-  if (!NATIVE_COOKIE_STAGES.includes(candidate.stage)) return undefined;
-  const diagnostic = new NativeCookieJobError(candidate.stage, candidate.win32Error).diagnostic;
-  if (NATIVE_COOKIE_STAGES.includes(candidate.lastStage!)) diagnostic.lastStage = candidate.lastStage;
-  for (const field of ['exitCode', 'nodeExitCode', 'stderrBytes'] as const) {
-    const value = candidate[field];
-    if (typeof value === 'number' && Number.isInteger(value) && value >= (field === 'stderrBytes' ? 0 : -0x80000000) && value <= 0xffffffff) diagnostic[field] = value;
-  }
-  if (['SIGTERM', 'SIGKILL', 'SIGINT', 'SIGSEGV', 'SIGABRT', 'SIGBREAK', 'SIGHUP'].includes(candidate.signal!)) diagnostic.signal = candidate.signal;
-  if (typeof candidate.memberMode === 'boolean') diagnostic.memberMode = candidate.memberMode;
-  return diagnostic;
-}
-
-export interface NativeCookieJob {
-  name: string;
-  terminate(): void;
-  activeProcesses(): number;
-  close(): void;
-}
-
-export async function createNativeCookieJob(): Promise<NativeCookieJob> {
-  if (process.platform !== 'win32' || !['x64', 'arm64'].includes(process.arch)) {
-    throw new NativeCookieJobError('platform');
-  }
-  const { api, ptr, closeLibrary } = await openKernel();
-  const name = `Local\\gstack-cookie-${randomUUID()}`;
-  const wideName = Buffer.from(`${name}\0`, 'utf16le');
-  let stage: NativeCookieDiagnostic['stage'] = 'job_create';
-  let handle: number | bigint = 0;
-  let closed = false;
-  const close = () => {
-    if (closed) return;
-    closed = true;
-    try {
-      if (handle && !api.CloseHandle(handle)) throw new NativeCookieJobError('job_close', api.GetLastError());
-    } finally {
-      closeLibrary();
-    }
-  };
-  try {
-    handle = api.CreateJobObjectW(null, ptr(wideName));
-    const createError = api.GetLastError();
-    if (!handle || createError === 183) throw new NativeCookieJobError('job_create', createError);
-    const limits = Buffer.alloc(144);
-    limits.writeUInt32LE(0x2000, 16);
-    stage = 'job_limits';
-    if (!api.SetInformationJobObject(handle, 9, ptr(limits), limits.byteLength)) {
-      throw new NativeCookieJobError(stage, api.GetLastError());
-    }
-    return {
-      name,
-      terminate() {
-        if (closed) throw new NativeCookieJobError('job_terminate');
-        if (!api.TerminateJobObject(handle, 1)) throw new NativeCookieJobError('job_terminate', api.GetLastError());
-      },
-      activeProcesses() {
-        const accounting = Buffer.alloc(48);
-        if (closed) throw new NativeCookieJobError('job_query');
-        if (!api.QueryInformationJobObject(handle, 1, ptr(accounting), accounting.byteLength, null)) throw new NativeCookieJobError('job_query', api.GetLastError());
-        return accounting.readUInt32LE(40);
-      },
-      close,
-    };
-  } catch (error) {
-    try { close(); } catch {}
-    throw error instanceof NativeCookieJobError ? error : new NativeCookieJobError(stage);
-  }
-}
-
-export async function joinNativeCookieJob(name: string, observe?: (stage: NativeCookieDiagnostic['stage']) => void): Promise<void> {
-  if (process.platform !== 'win32' || !/^Local\\gstack-cookie-[0-9a-f-]{36}$/.test(name)) {
-    throw new NativeCookieJobError('job_open');
-  }
-  observe?.('ffi_import');
-  const { api, ptr, closeLibrary } = await openKernel();
-  const wideName = Buffer.from(`${name}\0`, 'utf16le');
-  let stage: NativeCookieDiagnostic['stage'] = 'job_open';
-  let handle: number | bigint = 0;
-  let currentProcess: number | bigint = 0;
-  try {
-    observe?.(stage);
-    handle = api.OpenJobObjectW(1, 0, ptr(wideName));
-    if (!handle) throw new NativeCookieJobError(stage, api.GetLastError());
-    stage = 'process_open';
-    observe?.(stage);
-    currentProcess = api.OpenProcess(0x0101, 0, process.pid);
-    if (!currentProcess) throw new NativeCookieJobError(stage, api.GetLastError());
-    stage = 'job_assign';
-    observe?.(stage);
-    if (!api.AssignProcessToJobObject(handle, currentProcess)) throw new NativeCookieJobError(stage, api.GetLastError());
-    observe?.('job_assigned');
-  } catch (error) {
-    throw error instanceof NativeCookieJobError ? error : new NativeCookieJobError(stage);
-  } finally {
-    let closeError: NativeCookieJobError | undefined;
-    observe?.('process_close');
-    if (currentProcess && !api.CloseHandle(currentProcess)) closeError = new NativeCookieJobError('process_close', api.GetLastError());
-    observe?.('job_close');
-    if (handle && !api.CloseHandle(handle)) closeError ??= new NativeCookieJobError('job_close', api.GetLastError());
-    closeLibrary();
-    if (closeError) throw closeError;
-  }
-}
-
-async function openKernel() {
-  let stage: NativeCookieDiagnostic['stage'] = 'ffi_import';
-  try {
-    const { dlopen, FFIType, ptr } = await import('bun:ffi');
-    stage = 'ffi_open';
-    const library = dlopen('kernel32.dll', {
-      CreateJobObjectW: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u64 },
-      OpenJobObjectW: { args: [FFIType.u32, FFIType.i32, FFIType.ptr], returns: FFIType.u64 },
-      SetInformationJobObject: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
-      QueryInformationJobObject: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
-      AssignProcessToJobObject: { args: [FFIType.u64, FFIType.u64], returns: FFIType.i32 },
-      OpenProcess: { args: [FFIType.u32, FFIType.i32, FFIType.u32], returns: FFIType.u64 },
-      TerminateJobObject: { args: [FFIType.u64, FFIType.u32], returns: FFIType.i32 },
-      CloseHandle: { args: [FFIType.u64], returns: FFIType.i32 },
-      GetLastError: { args: [], returns: FFIType.u32 },
-    });
-    return { api: library.symbols, ptr, closeLibrary: () => library.close() };
-  } catch {
-    throw new NativeCookieJobError(stage);
-  }
-}

package/.agent/skills/gstack-browse/src/cookie-import-native-qualification.json

@@ -1 +0,0 @@
-[]

package/.agent/skills/gstack-browse/src/cookie-import-native-worker.ts

@@ -1,268 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import { writeSync } from 'node:fs';
-import { createNativeCookieJob, joinNativeCookieJob, nativeCookieDiagnostic, parseNativeCookieDiagnostic, type NativeCookieDiagnostic, type NativeCookieJob } from './cookie-import-native-job';
-import type { PlaywrightCookie } from './cookie-import-browser';
-import { emptyBunConfig } from './bun-child-config';
-
-export interface NativeCookieRequest {
-  nodeExecutable: string;
-  nodeArchitecture: string;
-  playwrightEntry: string;
-  executablePath: string;
-  userDataDir: string;
-  profile: string;
-  domains: string[];
-  deadline: number;
-  qualifiedBunVersions: string[];
-}
-
-export type NativeCookieReply =
-  | { cookies: PlaywrightCookie[] }
-  | { error: 'native_timeout' | 'native_failed' | 'native_cleanup_failed' | 'native_supervision_failed' | 'browser_running' | 'native_profile_unsupported'; diagnostic?: NativeCookieDiagnostic };
-
-export interface NativeCookieMember {
-  result: Promise<NativeCookieReply>;
-  closed: Promise<void>;
-  stop(): void;
-}
-
-const MAX_REPLY_BYTES = 8 * 1024 * 1024;
-export const NATIVE_PROGRESS_PREFIX = 'GSTACK_NATIVE_PROGRESS ';
-
-function nativeProgress(diagnostic: NativeCookieDiagnostic): void {
-  try { writeSync(2, NATIVE_PROGRESS_PREFIX + JSON.stringify(diagnostic) + '\n'); } catch {}
-}
-
-export function nativeCookieEnvironment(env: NodeJS.ProcessEnv): Record<string, string> {
-  const allowed = new Set(['systemroot', 'windir', 'temp', 'tmp', 'userprofile', 'localappdata', 'appdata', 'programfiles', 'programfiles(x86)', 'programdata', 'path', 'pathext']);
-  return Object.fromEntries(Object.entries(env).filter(([key, value]) => allowed.has(key.toLowerCase()) && typeof value === 'string')) as Record<string, string>;
-}
-
-export const NATIVE_COOKIE_NODE_SCRIPT = String.raw`
-const fs = require('node:fs');
-let stage = 'node_input';
-const progress = () => { try { fs.writeSync(2, 'GSTACK_NATIVE_PROGRESS ' + JSON.stringify({ stage }) + '\n'); } catch {} };
-progress();
-(async () => {
-  const request = JSON.parse(fs.readFileSync(0, 'utf8'));
-  stage = 'node_load';
-  progress();
-  const { chromium } = require(request.playwrightEntry);
-  let context;
-  try {
-    const remaining = request.deadline - Date.now();
-    if (remaining <= 0) throw new Error('native_timeout');
-    stage = 'browser_launch';
-    progress();
-    context = await chromium.launchPersistentContext(request.userDataDir, {
-      executablePath: request.executablePath,
-      args: ['--profile-directory=' + request.profile],
-      headless: true,
-      chromiumSandbox: true,
-      timeout: remaining,
-      handleSIGINT: false,
-      handleSIGTERM: false,
-      handleSIGHUP: false,
-      env: process.env,
-    });
-    stage = 'cookie_read';
-    progress();
-    const selected = new Set(request.domains.map(domain => domain.toLowerCase().replace(/^\./, '').replace(/\.$/, '')));
-    const cookies = (await context.cookies()).filter(cookie => selected.has(cookie.domain.toLowerCase().replace(/^\./, '').replace(/\.$/, '')));
-    await new Promise(resolve => process.stdout.write(JSON.stringify({ cookies }) + '\n', resolve));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : '';
-    const exited = message.match(/<process did exit: exitCode=(-?\d+), signal=(?:null|SIG[A-Z]+)>/);
-    const exitCode = exited ? Number(exited[1]) : undefined;
-    const code = (stage === 'browser_launch' && exitCode === 21) || /ProcessSingleton|profile.*in use|user data directory is already in use|opening in existing browser session/i.test(message)
-      ? 'browser_running'
-      : /remote debugging requires a non-default data directory/i.test(message)
-        ? 'native_profile_unsupported'
-        : /Timeout|native_timeout/.test(message) ? 'native_timeout' : 'native_failed';
-    await new Promise(resolve => process.stdout.write(JSON.stringify({ error: code, diagnostic: { stage, ...(Number.isInteger(exitCode) ? { exitCode } : {}) } }) + '\n', resolve));
-  } finally {
-    stage = 'browser_close';
-    progress();
-    await context?.close().catch(() => {});
-  }
-})().catch(() => { process.stdout.write(JSON.stringify({ error: 'native_failed', diagnostic: { stage } }) + '\n'); process.exitCode = 1; });
-`;
-
-export async function superviseNativeCookieImport(
-  request: NativeCookieRequest,
-  dependencies: {
-    createJob?: () => Promise<NativeCookieJob>;
-    startMember?: (request: NativeCookieRequest, jobName: string) => NativeCookieMember;
-    now?: () => number;
-    sleep?: (milliseconds: number) => Promise<void>;
-    signal?: AbortSignal;
-  } = {},
-): Promise<NativeCookieReply> {
-  const now = dependencies.now ?? Date.now;
-  const sleep = dependencies.sleep ?? (milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds)));
-  const deadline = Math.min(request.deadline, now() + 25_000);
-  let job: NativeCookieJob | undefined;
-  let member: NativeCookieMember | undefined;
-  let reply: NativeCookieReply | undefined;
-  let closed = false;
-  try {
-    job = await (dependencies.createJob ?? createNativeCookieJob)();
-    if (now() >= deadline || dependencies.signal?.aborted) return { error: 'native_timeout' };
-    member = (dependencies.startMember ?? startMember)({ ...request, deadline }, job.name);
-    void member.result.then(value => { reply ??= value; }, () => { reply ??= { error: 'native_failed' }; });
-    void member.closed.then(() => { closed = true; }, () => { closed = true; });
-    while (!reply && !closed && now() < deadline && !dependencies.signal?.aborted) await sleep(Math.min(20, deadline - now()));
-    reply ??= { error: now() >= deadline ? 'native_timeout' : 'native_failed' };
-    const cleanupDeadline = now() + 5_000;
-    const graceDeadline = now() + ('cookies' in reply ? 2_000 : 0);
-    while ((!closed || job.activeProcesses() !== 0) && now() < graceDeadline) await sleep(20);
-    if (job.activeProcesses() !== 0) job.terminate();
-    while ((!closed || job.activeProcesses() !== 0) && now() < cleanupDeadline) await sleep(20);
-    if (!closed || job.activeProcesses() !== 0) return { error: 'native_cleanup_failed' };
-    return reply;
-  } catch (error) {
-    return { error: job ? 'native_cleanup_failed' : 'native_supervision_failed', diagnostic: nativeCookieDiagnostic(error, job ? 'job_query' : 'job_create') };
-  } finally {
-    let diagnostic: NativeCookieDiagnostic | undefined;
-    try { job?.close(); } catch (error) { diagnostic = nativeCookieDiagnostic(error, 'job_close'); }
-    try { member?.stop(); } catch (error) { diagnostic ??= nativeCookieDiagnostic(error, 'member_exit'); }
-    if (diagnostic) return { error: 'native_cleanup_failed', diagnostic };
-  }
-}
-
-function startMember(request: NativeCookieRequest, jobName: string, mode = '--member'): NativeCookieMember {
-  const child = spawn(process.execPath, ['--no-env-file', '--no-install', '--no-macros', `--config=${emptyBunConfig()}`, import.meta.path, mode], {
-    env: nativeCookieEnvironment(process.env),
-    stdio: ['pipe', 'pipe', 'pipe'],
-    windowsHide: true,
-  });
-  const closed = new Promise<void>(resolve => child.once('close', () => resolve()));
-  let progressInput = '';
-  let lastStage: NativeCookieDiagnostic['stage'] | undefined;
-  let memberMode: boolean | undefined;
-  let nodeExitCode: number | undefined;
-  let stderrBytes = 0;
-  child.stderr.on('data', chunk => {
-    stderrBytes = Math.min(0xffffffff, stderrBytes + chunk.length);
-    progressInput += chunk.toString('utf8');
-    for (let end = progressInput.indexOf('\n'); end >= 0; end = progressInput.indexOf('\n')) {
-      const line = progressInput.slice(0, end);
-      progressInput = progressInput.slice(end + 1);
-      if (!line.startsWith(NATIVE_PROGRESS_PREFIX)) continue;
-      try {
-        const diagnostic = parseNativeCookieDiagnostic(JSON.parse(line.slice(NATIVE_PROGRESS_PREFIX.length)));
-        if (!diagnostic) continue;
-        lastStage = diagnostic.stage;
-        memberMode ??= diagnostic.memberMode;
-        if (diagnostic.stage === 'node_exit') nodeExitCode = diagnostic.exitCode;
-      } catch {}
-    }
-    if (progressInput.length > 4096) progressInput = '';
-  });
-  const result = new Promise<NativeCookieReply>(resolve => {
-    let output = '';
-    child.stdout.setEncoding('utf8');
-    child.stdout.on('data', chunk => {
-      output += chunk;
-      if (Buffer.byteLength(output) > MAX_REPLY_BYTES) {
-        resolve({ error: 'native_failed' });
-        child.stdout.destroy();
-      } else if (output.includes('\n')) {
-        try {
-          const parsed = JSON.parse(output.slice(0, output.indexOf('\n')));
-          const errors = ['native_timeout', 'native_failed', 'native_cleanup_failed', 'native_supervision_failed', 'browser_running', 'native_profile_unsupported'];
-          const diagnostic = parseNativeCookieDiagnostic(parsed.diagnostic);
-          resolve(Array.isArray(parsed.cookies) ? { cookies: parsed.cookies } : { error: errors.includes(parsed.error) ? parsed.error : 'native_failed', ...(diagnostic ? { diagnostic } : {}) });
-        } catch {
-          resolve({ error: 'native_failed' });
-        }
-      }
-    });
-    child.once('error', () => resolve({ error: 'native_failed', diagnostic: { stage: 'member_start' } }));
-    child.once('close', (code, signal) => resolve({ error: 'native_failed', diagnostic: parseNativeCookieDiagnostic({ stage: 'member_exit', exitCode: code, signal, lastStage, memberMode, nodeExitCode, stderrBytes }) }));
-    child.stdin.on('error', () => resolve({ error: 'native_failed', diagnostic: { stage: 'member_input' } }));
-    child.stdin.end(JSON.stringify({ request, jobName }));
-  });
-  return { result, closed, stop: () => { if (child.exitCode === null && child.signalCode === null) child.kill(); } };
-}
-
-export async function probeNativeCookieMember(): Promise<NativeCookieReply> {
-  return superviseNativeCookieImport({
-    nodeExecutable: '', nodeArchitecture: process.arch, playwrightEntry: '', executablePath: '',
-    userDataDir: '', profile: '', domains: [], deadline: Date.now() + 5_000, qualifiedBunVersions: [Bun.version],
-  }, { startMember: (request, jobName) => startMember(request, jobName, '--member-smoke') });
-}
-
-let mainStage: NativeCookieDiagnostic['stage'] = 'supervisor_input';
-
-async function main(): Promise<void> {
-  if (process.argv[2] === '--member' || process.argv[2] === '--member-smoke') {
-    mainStage = 'member_input';
-    nativeProgress({ stage: mainStage });
-    const serialized = await new Promise<string>((resolve, reject) => {
-      let payload = '';
-      let bytes = 0;
-      process.stdin.setEncoding('utf8');
-      process.stdin.on('data', chunk => {
-        bytes += Buffer.byteLength(chunk);
-        if (bytes > 1024 * 1024) {
-          reject(new Error('native_supervision_failed'));
-          process.stdin.destroy();
-          return;
-        }
-        payload += chunk;
-      });
-      process.stdin.once('end', () => resolve(payload));
-      process.stdin.once('error', () => reject(new Error('native_supervision_failed')));
-      process.stdin.once('close', () => reject(new Error('native_supervision_failed')));
-      process.stdin.resume();
-    });
-    const input = JSON.parse(serialized);
-    nativeProgress({ stage: 'member_decoded' });
-    await joinNativeCookieJob(input.jobName, stage => nativeProgress({ stage }));
-    nativeProgress({ stage: 'job_joined' });
-    if (process.argv[2] === '--member-smoke') {
-      process.stdout.write(JSON.stringify({ cookies: [] }) + '\n', () => process.exit(0));
-      return;
-    }
-    mainStage = 'node_start';
-    nativeProgress({ stage: mainStage });
-    const child = spawn(input.request.nodeExecutable, ['--input-type=commonjs', '-e', NATIVE_COOKIE_NODE_SCRIPT], {
-      env: nativeCookieEnvironment(process.env),
-      stdio: ['pipe', 'inherit', 'inherit'],
-      windowsHide: true,
-    });
-    nativeProgress({ stage: 'node_spawned' });
-    child.stdin.on('error', () => {});
-    child.stdin.end(JSON.stringify(input.request));
-    child.once('error', () => process.stdout.write(JSON.stringify({ error: 'native_failed', diagnostic: { stage: 'node_start' } }) + '\n', () => process.exit(1)));
-    child.once('close', (code, signal) => {
-      nativeProgress(parseNativeCookieDiagnostic({ stage: 'node_exit', exitCode: code, signal })!);
-      process.exit(code ?? 1);
-    });
-    return;
-  }
-  const cancellation = new AbortController();
-  const lines = createInterface({ input: process.stdin });
-  lines.once('close', () => cancellation.abort());
-  const input = await new Promise<NativeCookieRequest>((resolve, reject) => {
-    lines.once('line', line => {
-      try { resolve(JSON.parse(line)); } catch { reject(new Error('native_supervision_failed')); }
-    });
-    lines.once('close', () => reject(new Error('native_supervision_failed')));
-  });
-  mainStage = 'runtime_check';
-  if (input.nodeArchitecture !== process.arch || !Array.isArray(input.qualifiedBunVersions) || !input.qualifiedBunVersions.includes(Bun.version)) {
-    throw new Error('native_supervision_failed');
-  }
-  const result = await superviseNativeCookieImport(input, { signal: cancellation.signal });
-  process.stdout.write(JSON.stringify(result) + '\n', () => process.exit(0));
-}
-
-if (import.meta.main) {
-  nativeProgress({ stage: 'worker_boot', memberMode: process.argv[2] === '--member' || process.argv[2] === '--member-smoke' });
-  void main().catch(error => {
-    process.stdout.write(JSON.stringify({ error: 'native_supervision_failed', diagnostic: nativeCookieDiagnostic(error, mainStage) }) + '\n', () => process.exit(1));
-  });
-}