@amg555/frameforge-mcp 2.7.6 → 2.7.8

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

@@ -1,166 +0,0 @@
-import { spawn } from 'node:child_process';
-import { realpathSync, statSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { release } from 'node:os';
-import path from 'node:path';
-import { CookieImportError, normalizeCookieDomain, type PlaywrightCookie } from './cookie-import-browser';
-import { emptyBunConfig } from './bun-child-config';
-import { hashNativeFile, nativeCodeHashes, nativeCodeMatches, readNativeQualifications, type NativeQualifiedBuild } from './cookie-import-native-integrity';
-
-type BrowserName = 'Chrome' | 'Chromium' | 'Brave' | 'Edge';
-
-export function nativeBrowserPaths(browserName: string, env: NodeJS.ProcessEnv): {
-  name: BrowserName;
-  userDataDir: string;
-  executables: string[];
-} {
-  const get = (key: string) => Object.entries(env).find(([name]) => name.toLowerCase() === key.toLowerCase())?.[1];
-  const local = get('LOCALAPPDATA');
-  if (!local || !path.win32.isAbsolute(local)) {
-    throw new CookieImportError('The Windows browser data location is unavailable. Sign in manually in the gstack browser.', 'native_profile_unsupported');
-  }
-  const pf = get('PROGRAMFILES') || 'C:\\Program Files';
-  const pf86 = get('PROGRAMFILES(X86)') || 'C:\\Program Files (x86)';
-  const mappings = {
-    chrome: { name: 'Chrome', root: ['Google', 'Chrome'], exe: 'chrome.exe', installs: [pf, pf86, local] },
-    chromium: { name: 'Chromium', root: ['Chromium'], exe: 'chrome.exe', installs: [local] },
-    brave: { name: 'Brave', root: ['BraveSoftware', 'Brave-Browser'], exe: 'brave.exe', installs: [pf, pf86, local] },
-    edge: { name: 'Edge', root: ['Microsoft', 'Edge'], exe: 'msedge.exe', installs: [pf86, pf, local] },
-  } as const;
-  const key = browserName.toLowerCase();
-  if (!Object.hasOwn(mappings, key)) {
-    throw new CookieImportError('This browser has no supported Windows native-cookie mapping. Sign in manually in the gstack browser.', 'not_supported');
-  }
-  const browser = mappings[key as keyof typeof mappings];
-  return {
-    name: browser.name,
-    userDataDir: path.win32.join(local, ...browser.root, 'User Data'),
-    executables: [...new Set(browser.installs.map(root => path.win32.join(root, ...browser.root, 'Application', browser.exe)))],
-  };
-}
-
-export async function importNativeCookies(options: {
-  browserName: string;
-  userDataDir: string;
-  profile: string;
-  domains: string[];
-}): Promise<PlaywrightCookie[]> {
-  let domains: string[];
-  try {
-    if (!Array.isArray(options.domains)) throw new Error();
-    domains = [...new Set(options.domains.map(normalizeCookieDomain))];
-  } catch {
-    throw new CookieImportError('Native cookie import needs explicit valid domain selections.', 'invalid_domain');
-  }
-  if (!domains.length) return [];
-  if (process.platform !== 'win32' || process.versions.bun) {
-    throw new CookieImportError('Native cookie import requires the Windows Node server. Sign in manually in the gstack browser.', 'not_supported');
-  }
-  if (!/^(Default|Profile [0-9]+)$/.test(options.profile)) {
-    throw new CookieImportError('Select an existing browser profile before importing cookies.', 'invalid_profile');
-  }
-  const browser = nativeBrowserPaths(options.browserName, process.env);
-  if (path.win32.resolve(options.userDataDir).toLowerCase() !== path.win32.resolve(browser.userDataDir).toLowerCase()) {
-    throw new CookieImportError('Native cookie import cannot substitute or copy the selected browser profile. Sign in manually in the gstack browser.', 'native_profile_unsupported');
-  }
-  if (browser.name === 'Chrome') {
-    throw new CookieImportError('Chrome 136 and later block remote debugging of the default user-data directory, including every profile inside it, over both pipe and TCP. Default-directory extraction is unavailable; sign in manually in the gstack browser.', 'native_profile_unsupported');
-  }
-  const deadline = Date.now() + 25_000;
-  let qualified: NativeQualifiedBuild[];
-  try {
-    const root = path.resolve(import.meta.dir, '../..');
-    const builds = await readNativeQualifications(root, deadline);
-    qualified = builds.filter(build => build.browserName === browser.name && build.nodeVersion === process.version && build.architecture === process.arch && build.windowsRelease === release());
-    if (qualified.length) {
-      const hashes = await nativeCodeHashes(root, deadline);
-      qualified = qualified.filter(build => nativeCodeMatches(build.sourceHashes, hashes));
-    }
-  } catch (error) {
-    throw new CookieImportError('The native-cookie qualification inputs could not be verified. Sign in manually in the gstack browser.', error instanceof Error && error.message === 'native_timeout' ? 'native_timeout' : 'native_unqualified');
-  }
-  if (!qualified.length) {
-    throw new CookieImportError('Windows native cookie extraction is disabled until this browser and runtime pass native process-ownership and forced-cleanup qualification. Sign in manually in the gstack browser.', 'native_unqualified');
-  }
-  const executablePath = browser.executables.find(candidate => {
-    try { return statSync(candidate).isFile(); } catch { return false; }
-  });
-  if (!executablePath) throw new CookieImportError('The selected browser executable is not installed.', 'not_installed');
-  try {
-    const profilePath = path.join(options.userDataDir, options.profile);
-    if (realpathSync(options.userDataDir).toLowerCase() !== path.win32.resolve(options.userDataDir).toLowerCase()
-      || realpathSync(profilePath).toLowerCase() !== path.win32.resolve(profilePath).toLowerCase()
-      || !statSync(profilePath).isDirectory()) {
-      throw new Error('invalid_profile');
-    }
-  } catch {
-    throw new CookieImportError('The selected source profile is unavailable or redirects to another location.', 'native_profile_unsupported');
-  }
-  const require = createRequire(import.meta.url);
-  let playwrightVersion: string;
-  let playwrightEntry: string;
-  let executableSha256: string;
-  try {
-    playwrightVersion = require('playwright/package.json').version;
-    playwrightEntry = require.resolve('playwright');
-    executableSha256 = await hashNativeFile(executablePath, deadline);
-  } catch (error) {
-    throw new CookieImportError('The native browser build could not be checked safely. Sign in manually in the gstack browser.', error instanceof Error && error.message === 'native_timeout' ? 'native_timeout' : 'native_unqualified');
-  }
-  const bunCandidates = [
-    ...(process.env.BUN_INSTALL ? [path.join(process.env.BUN_INSTALL, 'bin', 'bun.exe')] : []),
-    ...(process.env.PATH || process.env.Path || '').split(path.delimiter).filter(directory => path.isAbsolute(directory)).map(directory => path.join(directory, 'bun.exe')),
-    ...(process.env.USERPROFILE ? [path.join(process.env.USERPROFILE, '.bun', 'bin', 'bun.exe')] : []),
-  ];
-  const bunExecutable = bunCandidates.find(candidate => {
-    try { return statSync(candidate).isFile(); } catch { return false; }
-  });
-  if (!bunExecutable || !qualified.some(build => build.executableSha256 === executableSha256 && build.playwrightVersion === playwrightVersion)) {
-    throw new CookieImportError('This browser build or supervisor runtime has not passed native qualification. Sign in manually in the gstack browser.', 'native_unqualified');
-  }
-  if (Date.now() >= deadline) throw new CookieImportError('Native cookie import exceeded its operation deadline.', 'native_timeout');
-  const env = Object.fromEntries(Object.entries(process.env).filter(([key, value]) => /^(systemroot|windir|temp|tmp|userprofile|localappdata|appdata|programfiles|programfiles\(x86\)|programdata|path|pathext)$/i.test(key) && typeof value === 'string'));
-  const worker = spawn(bunExecutable, ['--no-env-file', '--no-install', '--no-macros', `--config=${emptyBunConfig()}`, path.join(import.meta.dir, 'cookie-import-native-worker.ts')], {
-    env,
-    stdio: ['pipe', 'pipe', 'ignore'],
-    windowsHide: true,
-  });
-  return new Promise((resolve, reject) => {
-    let output = '';
-    const timer = setTimeout(() => {
-      worker.kill();
-      reject(new CookieImportError('Native cookie cleanup could not be confirmed within its deadline.', 'native_cleanup_failed'));
-    }, Math.max(0, deadline + 5_000 - Date.now()));
-    worker.stdout.setEncoding('utf8');
-    worker.stdout.on('data', chunk => {
-      output += chunk;
-      if (Buffer.byteLength(output) > 8 * 1024 * 1024) worker.kill();
-    });
-    worker.once('error', () => {
-      clearTimeout(timer);
-      reject(new CookieImportError('Native cookie supervision could not start.', 'native_supervision_failed'));
-    });
-    worker.once('close', () => {
-      clearTimeout(timer);
-      try {
-        const result = JSON.parse(output);
-        if (Array.isArray(result.cookies)) resolve(result.cookies);
-        else reject(new CookieImportError('Native cookie import did not complete. Sign in manually in the gstack browser.', ['native_timeout', 'native_failed', 'native_cleanup_failed', 'native_supervision_failed', 'browser_running', 'native_profile_unsupported'].includes(result.error) ? result.error : 'native_failed'));
-      } catch {
-        reject(new CookieImportError('Native cookie supervision did not return a complete result.', 'native_failed'));
-      }
-    });
-    worker.stdin.on('error', () => {});
-    worker.stdin.write(JSON.stringify({
-      nodeExecutable: process.execPath,
-      nodeArchitecture: process.arch,
-      playwrightEntry,
-      executablePath,
-      userDataDir: options.userDataDir,
-      profile: options.profile,
-      domains,
-      deadline,
-      qualifiedBunVersions: qualified.filter(build => build.executableSha256 === executableSha256 && build.playwrightVersion === playwrightVersion).map(build => build.bunVersion),
-    }) + '\n');
-  });
-}

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

@@ -1,232 +0,0 @@
-import type { Page } from 'playwright';
-import {
-  CookieImportError, assertCookieDatabase, cookieDomainMatches, importCookies, importCookiesViaCdp,
-  listDomains, listProfiles, normalizeCookieDomain, resolveBrowserInfo, withCookieReadRetry,
-  type ProfileEntry,
-} from './cookie-import-browser';
-import { clearCookieTargetStorage, validateCookieAuthOptions, validateCookieStorageSupport, verifyCookieAuthentication, type CookieAuthVerificationOptions } from './cookie-auth-verification';
-
-export interface CookieImportTarget {
-  page: Page;
-  url: string;
-}
-
-export interface CookieImportOptions {
-  browser: string;
-  domains?: string[];
-  profile?: string;
-  all?: boolean;
-  clearStorage?: boolean;
-  verifyAuth?: boolean;
-}
-
-const activeImports = new WeakSet<object>();
-
-export function parseCookieImportArgs(args: string[]): CookieImportOptions {
-  const options: CookieImportOptions = { browser: 'comet' };
-  let browserSet = false;
-  const seen = new Set<string>();
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (!arg.startsWith('--')) {
-      if (browserSet) throw new CookieImportError('Specify only one source browser.', 'bad_request');
-      options.browser = arg;
-      browserSet = true;
-      continue;
-    }
-    if (seen.has(arg)) throw new CookieImportError('Duplicate cookie-import option.', 'bad_request');
-    seen.add(arg);
-    if (arg === '--domain' || arg === '--profile') {
-      const value = args[++i];
-      if (!value || value.startsWith('--')) throw new CookieImportError('Cookie-import option requires a value.', 'bad_request');
-      if (arg === '--domain') options.domains = [normalizeCookieDomain(value)];
-      else options.profile = value;
-    } else if (arg === '--all') options.all = true;
-    else if (arg === '--clear-storage') options.clearStorage = true;
-    else if (arg === '--verify-auth') options.verifyAuth = true;
-    else throw new CookieImportError('Unknown cookie-import option.', 'bad_request');
-  }
-  if (options.all && options.domains) throw new CookieImportError('Choose --domain or --all, not both.', 'bad_request');
-  if (options.all && options.clearStorage) throw new CookieImportError('Storage reset requires a single target origin; --all is not supported.', 'bad_request');
-  return options;
-}
-
-export async function getCookieProfiles(browser: string, domains: string[] = [], hostname?: string) {
-  const profiles: Array<ProfileEntry & { matches?: boolean; unavailable?: boolean }> = listProfiles(browser);
-  if (domains.length || hostname) {
-    const selected = domains.map(normalizeCookieDomain);
-    let index = 0;
-    const check = async () => {
-      while (index < profiles.length) {
-        const profile = profiles[index++];
-        try {
-          const result = await withCookieReadRetry(() => listDomains(browser, profile.name));
-          profile.matches = result.domains.some(entry => selected.length
-            ? selected.includes(normalizeCookieDomain(entry.domain))
-            : cookieDomainMatches(hostname!, entry.domain));
-        } catch (err) {
-          if (err instanceof CookieImportError && err.code === 'sqlite_unavailable') throw err;
-          profile.unavailable = true;
-        }
-      }
-    };
-    await Promise.all([check(), check()]);
-  }
-  const matching = profiles.filter(profile => profile.matches === true);
-  const recommendedProfile = !profiles.some(profile => profile.unavailable) && matching.length === 1
-    ? matching[0].name : profiles.length === 1 && profiles[0].matches !== false && !profiles[0].unavailable ? profiles[0].name : undefined;
-  return { profiles, recommendedProfile };
-}
-
-type ProfileSuggestion = Array<ProfileEntry & { matches?: boolean; unavailable?: boolean }>;
-
-function profileSelectionError(browser: string, profiles: ProfileSuggestion, domains: string[]): CookieImportError {
-  const { name, aliases } = resolveBrowserInfo(browser);
-  if (!profiles.length) {
-    assertCookieDatabase(browser, 'Default');
-    return new CookieImportError(`${name} profiles changed while selecting. Retry with --profile "<dir>", or run \`$B cookie-import-browser ${aliases[0]}\` to choose in the picker.`, 'profile_required');
-  }
-  const retry = `Retry with --profile "<dir>", or run \`$B cookie-import-browser ${aliases[0]}\` to choose in the picker.`;
-  const list = (entries: ProfileSuggestion) => entries.map(entry => entry.name).join(', ');
-  const unreadable = profiles.filter(entry => entry.unavailable);
-  const matching = profiles.filter(entry => entry.matches === true);
-  const scope = domains.join(', ');
-  if (unreadable.length) {
-    const found = matching.length ? ` Profiles with cookies for ${scope}: ${list(matching)}.` : '';
-    return new CookieImportError(`${name} profiles ${list(unreadable)} could not be read (the browser may be locking them). Close ${name} and retry, or pass --profile.${found}`, 'profile_required');
-  }
-  if (!domains.length) return new CookieImportError(`${name} has several profiles: ${list(profiles)}. ${retry}`, 'profile_required');
-  if (matching.length > 1) return new CookieImportError(`${name} has several profiles with cookies for ${scope}: ${list(matching)}. ${retry}`, 'profile_required');
-  return new CookieImportError(`No ${name} profile has cookies for ${scope}. Check the domain and that you are signed in to it in ${name}.`, 'profile_required');
-}
-
-function appBoundMessage(browser: string, result: { count: number; failureReasons?: Record<string, number> }): string {
-  const { name } = resolveBrowserInfo(browser);
-  const recovery = 'Sign in manually: run `$B handoff`, sign in to the intended account in the window that opens, then run `$B resume` (needs a display). See BROWSER.md, Platform limits.';
-  if (result.count) return `Some ${name} cookies use App-Bound Encryption and were skipped, so the session may not be restored. Check with \`$B reload\` (or --verify-auth); if you are signed out, run \`$B handoff\`, sign in, then \`$B resume\`.`;
-  if (result.failureReasons?.decryption_failed) return `${name} cookies could not be imported: some use App-Bound Encryption and others could not be decrypted. ${recovery}`;
-  return `Some selected ${name} cookies use App-Bound Encryption, which gstack cannot decrypt for this browser. ${recovery}`;
-}
-
-export function validateCookieTarget(target: CookieImportTarget): URL {
-  try {
-    const url = new URL(target.url);
-    if (!['http:', 'https:'].includes(url.protocol)) throw new Error();
-    if (target.page.isClosed() || target.page.url() !== target.url) throw new Error();
-    return url;
-  } catch {
-    throw new CookieImportError('The captured HTTP(S) target has changed or is unavailable. Reopen the picker on the intended page.', 'target_changed');
-  }
-}
-
-export async function runCookieImport(
-  options: CookieImportOptions,
-  target: CookieImportTarget,
-  trackDomains: (domains: string[]) => void,
-  authOptions: CookieAuthVerificationOptions = {},
-) {
-  for (const value of [options.all, options.clearStorage, options.verifyAuth]) {
-    if (value !== undefined && typeof value !== 'boolean') throw new CookieImportError('Cookie import options must be booleans.', 'bad_request');
-  }
-  if (typeof options.browser !== 'string' || !options.browser.trim()) throw new CookieImportError('Select a source browser.', 'bad_request');
-  if (options.profile !== undefined && (typeof options.profile !== 'string' || !options.profile)) throw new CookieImportError('Invalid source profile.', 'bad_request');
-  if (options.all && options.domains || options.all && options.clearStorage) throw new CookieImportError('All-domain import cannot be combined with a scoped domain or storage reset.', 'bad_request');
-  if (!options.all && (!Array.isArray(options.domains) || !options.domains.length)) throw new CookieImportError('Select at least one cookie domain.', 'bad_request');
-  const selected = options.domains?.map(normalizeCookieDomain) ?? [];
-  const needsTarget = options.clearStorage || options.verifyAuth;
-  const targetUrl = needsTarget ? validateCookieTarget(target) : undefined;
-  if (options.clearStorage) validateCookieStorageSupport(target.page);
-  if (options.verifyAuth) validateCookieAuthOptions(authOptions);
-  if (targetUrl && selected.length && !selected.some(domain => cookieDomainMatches(targetUrl.hostname, '.' + domain))) {
-    throw new CookieImportError('The selected cookies do not match the captured target origin.', 'target_mismatch');
-  }
-  const context = target.page.context();
-  if (target.page.isClosed()) throw new CookieImportError('The captured target is closed.', 'target_closed');
-  if (activeImports.has(context)) throw new CookieImportError('Another cookie import is still running. Wait before retrying.', 'import_busy', 'retry');
-  activeImports.add(context);
-  try {
-    let profile = options.profile;
-    if (!profile) {
-      const suggestion = await getCookieProfiles(options.browser, selected);
-      profile = suggestion.recommendedProfile;
-      if (!profile) throw profileSelectionError(options.browser, suggestion.profiles, selected);
-    }
-    const domains = options.all
-      ? (await withCookieReadRetry(() => listDomains(options.browser, profile!))).domains.map(entry => entry.domain)
-      : selected;
-    let result = await withCookieReadRetry(() => importCookies(options.browser, domains, profile));
-    const appBound = process.platform === 'win32' && result.failureReasons?.unsupported_encryption && !resolveBrowserInfo(options.browser).windowsNative
-      ? appBoundMessage(options.browser, result) : undefined;
-    if (!appBound && result.count === 0 && result.failureReasons?.unsupported_encryption && process.platform === 'win32') {
-      const failed = result.failed;
-      result = await importCookiesViaCdp(options.browser, domains, profile);
-      result.failed = Math.max(result.failed, failed - result.count);
-      if (result.failed) result.failureReasons = { native_unrecovered: result.failed };
-    }
-    const receipt = {
-      browser: options.browser,
-      profile,
-      imported: 0,
-      failed: result.failed,
-      domainCounts: {} as Record<string, number>,
-      failureReasons: result.failureReasons ?? {},
-      outcome: (result.failed ? 'failed' : 'empty') as 'empty' | 'imported' | 'partial' | 'failed',
-      reset: 'not_requested' as 'not_requested' | 'cleared' | 'failed',
-      verification: { verified: false, reason: 'not_requested' } as { verified: boolean; reason: string; status?: number },
-      message: appBound ?? (result.failed ? 'No cookies imported; cookies could not be decrypted.' : 'No matching cookies found.'),
-    };
-    if (!result.count) {
-      if (options.verifyAuth) receipt.verification.reason = 'no_cookies_imported';
-      return receipt;
-    }
-    if (targetUrl && !result.cookies.some(cookie => cookieDomainMatches(targetUrl.hostname, cookie.domain))) {
-      throw new CookieImportError('No imported cookies apply to the captured target origin.', 'target_mismatch');
-    }
-    if (target.page.isClosed()) throw new CookieImportError('The captured target is closed.', 'target_closed');
-    if (needsTarget) validateCookieTarget(target);
-    if (options.clearStorage) {
-      try {
-        await clearCookieTargetStorage(target.page, targetUrl!.origin);
-        receipt.reset = 'cleared';
-      } catch {
-        receipt.outcome = 'failed';
-        receipt.reset = 'failed';
-        receipt.message = 'Storage reset did not complete; storage may be partially cleared. No new cookies were applied.';
-        receipt.verification.reason = 'reset_failed';
-        return receipt;
-      }
-    }
-    const appliedDomains = [...new Set(result.cookies.map(cookie => cookie.domain))];
-    try {
-      await context.addCookies(result.cookies);
-    } catch {
-      trackDomains(appliedDomains);
-      receipt.outcome = 'failed';
-      receipt.message = 'Cookie application failed; the browser may contain a partial import. Authentication was not verified.';
-      receipt.verification.reason = 'application_failed';
-      return receipt;
-    }
-    trackDomains(appliedDomains);
-    receipt.imported = result.count;
-    receipt.domainCounts = result.domainCounts;
-    receipt.outcome = result.failed ? 'partial' : 'imported';
-    receipt.message = appBound ?? (result.failed ? 'Some cookies could not be decrypted.' : 'Cookie copy complete.');
-    if (options.verifyAuth) {
-      try {
-        validateCookieTarget(target);
-        receipt.verification = await verifyCookieAuthentication(target.page, authOptions, targetUrl!.origin);
-      } catch {
-        receipt.verification = { verified: false, reason: 'target_changed' };
-      }
-    }
-    return receipt;
-  } finally {
-    activeImports.delete(context);
-  }
-}
-
-export function formatCookieImportResult(result: Awaited<ReturnType<typeof runCookieImport>>): string {
-  const reasons = Object.entries(result.failureReasons).sort(([a], [b]) => a.localeCompare(b)).map(([key, count]) => `${key}=${count}`);
-  const reasonText = reasons.length ? ` Failure reasons: ${reasons.join(', ')}.` : '';
-  return `Imported ${result.imported} cookies from ${result.browser} (profile: ${result.profile}); ${result.failed} failed to decrypt. ${result.message}${reasonText} Storage reset: ${result.reset}. Authentication: ${result.verification.reason}.`;
-}