@amg555/frameforge-mcp 2.7.6 → 2.7.8

package/.agent/skills/gstack-browse/src/content-security.ts

@@ -1,373 +0,0 @@
-/**
- * Content security layer for pair-agent browser sharing.
- *
- * Four defense layers:
- *   1. Datamarking — watermark text output to detect exfiltration
- *   2. Hidden element stripping — remove invisible/deceptive elements from output
- *   3. Content filter hooks — extensible URL/content filter pipeline
- *   4. Instruction block hardening — SECURITY section in agent instructions
- *
- * This module handles layers 1-3. Layer 4 is in cli.ts.
- */
-
-import { randomBytes } from 'crypto';
-import type { Page, Frame } from 'playwright';
-import { stripLoneSurrogates } from './sanitize';
-
-// ─── Datamarking (Layer 1) ──────────────────────────────────────
-
-/** Session-scoped random marker for text watermarking */
-let sessionMarker: string | null = null;
-
-function ensureMarker(): string {
-  if (!sessionMarker) {
-    sessionMarker = randomBytes(3).toString('base64').slice(0, 4);
-  }
-  return sessionMarker;
-}
-
-/** Exported for tests only */
-export function getSessionMarker(): string {
-  return ensureMarker();
-}
-
-/** Reset marker (for testing) */
-export function resetSessionMarker(): void {
-  sessionMarker = null;
-}
-
-/**
- * Insert invisible watermark into text content.
- * Places the marker as zero-width characters between words.
- * Only applied to `text` command output (not html, forms, or structured data).
- */
-export function datamarkContent(content: string): string {
-  const marker = ensureMarker();
-  // Insert marker as a Unicode tag sequence between sentences (after periods followed by space)
-  // This is subtle enough to not corrupt output but detectable if exfiltrated
-  const zwsp = '\u200B'; // zero-width space
-  const taggedMarker = marker.split('').map(c => zwsp + c).join('');
-  // Insert after every 3rd sentence-ending period
-  let count = 0;
-  return content.replace(/(\. )/g, (match) => {
-    count++;
-    if (count % 3 === 0) {
-      return match + taggedMarker;
-    }
-    return match;
-  });
-}
-
-// ─── Hidden Element Stripping (Layer 2) ─────────────────────────
-
-/** Injection-like patterns in ARIA labels */
-const ARIA_INJECTION_PATTERNS = [
-  /ignore\s+(previous|above|all)\s+instructions?/i,
-  /you\s+are\s+(now|a)\s+/i,
-  /system\s*:\s*/i,
-  /\bdo\s+not\s+(follow|obey|listen)/i,
-  /\bexecute\s+(the\s+)?following/i,
-  /\bforget\s+(everything|all|your)/i,
-  /\bnew\s+instructions?\s*:/i,
-];
-
-/**
- * Detect hidden elements and ARIA injection on a page.
- * Marks hidden elements with data-gstack-hidden attribute.
- * Returns descriptions of what was found for logging.
- *
- * Detection criteria:
- *   - opacity < 0.1
- *   - font-size < 1px
- *   - off-screen (positioned far outside viewport)
- *   - visibility:hidden or display:none with text content
- *   - same foreground/background color
- *   - clip/clip-path hiding
- *   - ARIA labels with injection patterns
- */
-export async function markHiddenElements(page: Page | Frame): Promise<string[]> {
-  return page.evaluate((ariaPatterns: string[]) => {
-    const found: string[] = [];
-    const elements = document.querySelectorAll('body *');
-
-    for (const el of elements) {
-      if (el instanceof HTMLElement) {
-        const style = window.getComputedStyle(el);
-        const text = el.textContent?.trim() || '';
-        if (!text) continue; // skip empty elements
-
-        let isHidden = false;
-        let reason = '';
-
-        // Check opacity
-        if (parseFloat(style.opacity) < 0.1) {
-          isHidden = true;
-          reason = 'opacity < 0.1';
-        }
-        // Check font-size
-        else if (parseFloat(style.fontSize) < 1) {
-          isHidden = true;
-          reason = 'font-size < 1px';
-        }
-        // Check off-screen positioning
-        else if (style.position === 'absolute' || style.position === 'fixed') {
-          const rect = el.getBoundingClientRect();
-          if (rect.right < -100 || rect.bottom < -100 || rect.left > window.innerWidth + 100 || rect.top > window.innerHeight + 100) {
-            isHidden = true;
-            reason = 'off-screen';
-          }
-        }
-        // Check same fg/bg color (text hiding)
-        else if (style.color === style.backgroundColor && text.length > 10) {
-          isHidden = true;
-          reason = 'same fg/bg color';
-        }
-        // Check clip-path hiding
-        else if (style.clipPath === 'inset(100%)' || style.clip === 'rect(0px, 0px, 0px, 0px)') {
-          isHidden = true;
-          reason = 'clip hiding';
-        }
-        // Check visibility: hidden
-        else if (style.visibility === 'hidden') {
-          isHidden = true;
-          reason = 'visibility hidden';
-        }
-
-        if (isHidden) {
-          el.setAttribute('data-gstack-hidden', 'true');
-          found.push(`[${el.tagName.toLowerCase()}] ${reason}: "${text.slice(0, 60)}..."`);
-        }
-
-        // Check ARIA labels for injection patterns
-        const ariaLabel = el.getAttribute('aria-label') || '';
-        const ariaLabelledBy = el.getAttribute('aria-labelledby');
-        let labelText = ariaLabel;
-        if (ariaLabelledBy) {
-          const labelEl = document.getElementById(ariaLabelledBy);
-          if (labelEl) labelText += ' ' + (labelEl.textContent || '');
-        }
-
-        if (labelText) {
-          for (const pattern of ariaPatterns) {
-            if (new RegExp(pattern, 'i').test(labelText)) {
-              el.setAttribute('data-gstack-hidden', 'true');
-              found.push(`[${el.tagName.toLowerCase()}] ARIA injection: "${labelText.slice(0, 60)}..."`);
-              break;
-            }
-          }
-        }
-      }
-    }
-
-    return found;
-  }, ARIA_INJECTION_PATTERNS.map(p => p.source));
-}
-
-/**
- * Get clean text with hidden elements stripped (for `text` command).
- * Uses clone + remove approach: clones body, removes marked elements, returns innerText.
- */
-export async function getCleanTextWithStripping(page: Page | Frame): Promise<string> {
-  const raw = await page.evaluate(() => {
-    const body = document.body;
-    if (!body) return '';
-    const clone = body.cloneNode(true) as HTMLElement;
-    // Remove standard noise elements
-    clone.querySelectorAll('script, style, noscript, svg').forEach(el => el.remove());
-    // Remove hidden-marked elements
-    clone.querySelectorAll('[data-gstack-hidden]').forEach(el => el.remove());
-    return clone.innerText
-      .split('\n')
-      .map(line => line.trim())
-      .filter(line => line.length > 0)
-      .join('\n');
-  });
-  return stripLoneSurrogates(raw);
-}
-
-/**
- * Clean up data-gstack-hidden attributes from the page.
- * Should be called after extraction is complete.
- */
-export async function cleanupHiddenMarkers(page: Page | Frame): Promise<void> {
-  await page.evaluate(() => {
-    document.querySelectorAll('[data-gstack-hidden]').forEach(el => {
-      el.removeAttribute('data-gstack-hidden');
-    });
-  });
-}
-
-// ─── Content Envelope (wrapping) ────────────────────────────────
-
-const ENVELOPE_BEGIN = '═══ BEGIN UNTRUSTED WEB CONTENT ═══';
-const ENVELOPE_END = '═══ END UNTRUSTED WEB CONTENT ═══';
-
-/**
- * Defuse envelope sentinels that appear inside attacker-controlled page
- * content. Any raw BEGIN/END marker inside `content` gets a zero-width
- * space spliced through CONTENT so the marker still renders visibly but
- * no longer matches the envelope grep the LLM anchors on.
- *
- * Both the wrap path (full-page content) and the split path (scoped
- * snapshots) must funnel untrusted text through this helper before
- * emitting the outer envelope, otherwise a page whose accessibility
- * tree contains the literal sentinel can close the envelope early and
- * forge a fake "trusted" section in the LLM's view.
- */
-export function escapeEnvelopeSentinels(content: string): string {
-  const zwsp = '\u200B';
-  return content
-    .replace(/═══ BEGIN UNTRUSTED WEB CONTENT ═══/g, `═══ BEGIN UNTRUSTED WEB C${zwsp}ONTENT ═══`)
-    .replace(/═══ END UNTRUSTED WEB CONTENT ═══/g, `═══ END UNTRUSTED WEB C${zwsp}ONTENT ═══`);
-}
-
-/**
- * Wrap page content in a trust boundary envelope for scoped tokens.
- * Escapes envelope markers in content to prevent boundary escape attacks.
- */
-export function wrapUntrustedPageContent(
-  content: string,
-  command: string,
-  filterWarnings?: string[],
-): string {
-  const safeContent = escapeEnvelopeSentinels(content);
-
-  const parts: string[] = [];
-
-  if (filterWarnings && filterWarnings.length > 0) {
-    parts.push(`⚠ CONTENT WARNINGS: ${filterWarnings.join('; ')}`);
-  }
-
-  parts.push(ENVELOPE_BEGIN);
-  parts.push(safeContent);
-  parts.push(ENVELOPE_END);
-
-  return parts.join('\n');
-}
-
-// ─── Content Filter Hooks (Layer 3) ─────────────────────────────
-
-export interface ContentFilterResult {
-  safe: boolean;
-  warnings: string[];
-  blocked?: boolean;
-  message?: string;
-}
-
-export type ContentFilter = (
-  content: string,
-  url: string,
-  command: string,
-) => ContentFilterResult;
-
-const registeredFilters: ContentFilter[] = [];
-
-export function registerContentFilter(filter: ContentFilter): void {
-  registeredFilters.push(filter);
-}
-
-export function clearContentFilters(): void {
-  registeredFilters.length = 0;
-}
-
-/** Get current filter mode from env */
-export function getFilterMode(): 'off' | 'warn' | 'block' {
-  const mode = process.env.BROWSE_CONTENT_FILTER?.toLowerCase();
-  if (mode === 'off' || mode === 'block') return mode;
-  return 'warn'; // default
-}
-
-/**
- * Run all registered content filters against content.
- * Returns aggregated result with all warnings.
- */
-export function runContentFilters(
-  content: string,
-  url: string,
-  command: string,
-): ContentFilterResult {
-  const mode = getFilterMode();
-  if (mode === 'off') {
-    return { safe: true, warnings: [] };
-  }
-
-  const allWarnings: string[] = [];
-  let blocked = false;
-
-  for (const filter of registeredFilters) {
-    const result = filter(content, url, command);
-    if (!result.safe) {
-      allWarnings.push(...result.warnings);
-      if (mode === 'block') {
-        blocked = true;
-      }
-    }
-  }
-
-  if (blocked && allWarnings.length > 0) {
-    return {
-      safe: false,
-      warnings: allWarnings,
-      blocked: true,
-      message: `Content blocked: ${allWarnings.join('; ')}`,
-    };
-  }
-
-  return {
-    safe: allWarnings.length === 0,
-    warnings: allWarnings,
-  };
-}
-
-// ─── Built-in URL Blocklist Filter ──────────────────────────────
-
-const BLOCKLIST_DOMAINS = [
-  'requestbin.com',
-  'pipedream.com',
-  'webhook.site',
-  'hookbin.com',
-  'requestcatcher.com',
-  'burpcollaborator.net',
-  'interact.sh',
-  'canarytokens.com',
-  'ngrok.io',
-  'ngrok-free.app',
-];
-
-/** Check if URL matches any blocklisted exfiltration domain */
-export function urlBlocklistFilter(content: string, url: string, _command: string): ContentFilterResult {
-  const warnings: string[] = [];
-
-  // Matching is case-insensitive. Hostnames and URL schemes are
-  // case-insensitive (RFC 3986), so an uppercased sink like
-  // https://WEBHOOK.SITE/x must not slip past the blocklist. Normalize the
-  // haystack to lowercase; BLOCKLIST_DOMAINS entries are lowercase by
-  // construction, so a direct compare then holds.
-
-  // Check page URL
-  const normalizedUrl = url.toLowerCase();
-  for (const domain of BLOCKLIST_DOMAINS) {
-    if (normalizedUrl.includes(domain)) {
-      warnings.push(`Page URL matches blocklisted domain: ${domain}`);
-    }
-  }
-
-  // Check for blocklisted URLs in content (links, form actions). The `i` flag
-  // keeps an uppercased scheme (HTTPS://) from evading URL extraction.
-  const urlPattern = /https?:\/\/[^\s"'<>]+/gi;
-  const contentUrls = content.match(urlPattern) || [];
-  for (const contentUrl of contentUrls) {
-    const normalizedContentUrl = contentUrl.toLowerCase();
-    for (const domain of BLOCKLIST_DOMAINS) {
-      if (normalizedContentUrl.includes(domain)) {
-        warnings.push(`Content contains blocklisted URL: ${contentUrl.slice(0, 100)}`);
-        break;
-      }
-    }
-  }
-
-  return { safe: warnings.length === 0, warnings };
-}
-
-// Register the built-in filter on module load
-registerContentFilter(urlBlocklistFilter);

package/.agent/skills/gstack-browse/src/cookie-auth-verification.ts

@@ -1,225 +0,0 @@
-import { errors, type Page } from 'playwright';
-import { CookieImportError } from './cookie-import-browser';
-import { withCdpSession } from './cdp-bridge';
-
-export interface CookieAuthVerificationOptions {
-  identitySelector?: string;
-  expectedIdentity?: string;
-  timeoutMs?: number;
-}
-
-type VerificationReason = 'verified' | 'not_configured' | 'invalid_configuration'
-  | 'invalid_target' | 'target_closed' | 'target_changed' | 'login_redirect'
-  | 'http_error' | 'no_response' | 'identity_missing' | 'identity_ambiguous'
-  | 'identity_mismatch' | 'timeout' | 'verification_failed';
-
-type VerificationResult = { verified: boolean; reason: VerificationReason; status?: number };
-
-const MAX_TIMEOUT_MS = 15_000;
-const LOGIN_PATH = /(?:^|\/)(?:log[-_]?in|sign[-_]?in|logon)(?:[\/.;]|$)|(?:^|\/)sessions?\/new(?:[\/.;]|$)/i;
-
-function validateOrigin(expectedOrigin: string): void {
-  try {
-    const target = new URL(expectedOrigin);
-    if ((target.protocol === 'http:' || target.protocol === 'https:') && target.origin === expectedOrigin) return;
-  } catch {}
-  throw new CookieImportError('A captured HTTP(S) target origin is required.', 'invalid_target');
-}
-
-export function validateCookieAuthOptions(options: CookieAuthVerificationOptions): void {
-  if (!options || typeof options.identitySelector !== 'string' || !options.identitySelector.trim()
-    || typeof options.expectedIdentity !== 'string' || !options.expectedIdentity.replace(/\s+/g, ' ').trim()) {
-    throw new CookieImportError('Authentication verification requires an identity selector and expected identity.', 'verification_not_configured');
-  }
-  if (options.timeoutMs !== undefined && (typeof options.timeoutMs !== 'number'
-    || !Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
-    throw new CookieImportError('Authentication verification requires a positive finite timeout.', 'invalid_verification_config');
-  }
-}
-
-export async function verifyCookieAuthentication(
-  page: Page,
-  options: CookieAuthVerificationOptions,
-  expectedOrigin: string,
-): Promise<VerificationResult> {
-  try {
-    validateCookieAuthOptions(options);
-    validateOrigin(expectedOrigin);
-  } catch (error) {
-    const reason = error instanceof CookieImportError && error.code === 'verification_not_configured'
-      ? 'not_configured' : error instanceof CookieImportError && error.code === 'invalid_target'
-        ? 'invalid_target' : 'invalid_configuration';
-    return { verified: false, reason };
-  }
-
-  const timeoutMs = Math.min(options.timeoutMs ?? MAX_TIMEOUT_MS, MAX_TIMEOUT_MS);
-  const deadline = performance.now() + timeoutMs;
-  const expectedIdentity = options.expectedIdentity!.replace(/\s+/g, ' ').trim();
-  let finished = false;
-  let status: number | undefined;
-  let lastFailure: VerificationReason = 'timeout';
-  let timer: ReturnType<typeof setTimeout>;
-  const timeout = new Promise<VerificationResult>(resolve => {
-    timer = setTimeout(() => {
-      finished = true;
-      resolve({ verified: false, reason: lastFailure, ...(status === undefined ? {} : { status }) });
-    }, timeoutMs);
-  });
-
-  try {
-    return await Promise.race([timeout, (async (): Promise<VerificationResult> => {
-      if (page.isClosed()) return { verified: false, reason: 'target_closed' };
-      if (new URL(page.url()).origin !== expectedOrigin) return { verified: false, reason: 'target_changed' };
-      const response = await page.reload({ waitUntil: 'domcontentloaded', timeout: Math.max(1, deadline - performance.now()) });
-      if (finished || performance.now() >= deadline) return { verified: false, reason: 'timeout' };
-      if (page.isClosed()) return { verified: false, reason: 'target_closed' };
-      const loadedUrl = page.url();
-      if (new URL(loadedUrl).origin !== expectedOrigin) return { verified: false, reason: 'target_changed' };
-      if (LOGIN_PATH.test(decodeURIComponent(new URL(loadedUrl).pathname))) return { verified: false, reason: 'login_redirect' };
-      if (!response) return { verified: false, reason: 'no_response' };
-      status = response.status();
-      if (status < 200 || status >= 300) return { verified: false, reason: 'http_error', status };
-      for (let request = response.request(); request; request = request.redirectedFrom()!) {
-        const url = new URL(request.url());
-        if (url.origin !== expectedOrigin) return { verified: false, reason: 'target_changed', status };
-        if (LOGIN_PATH.test(decodeURIComponent(url.pathname))) return { verified: false, reason: 'login_redirect', status };
-      }
-      if (new URL(response.url()).origin !== expectedOrigin
-        || new URL(response.url()).href !== new URL(loadedUrl.split('#')[0]).href) {
-        return { verified: false, reason: 'target_changed', status };
-      }
-
-      while (!finished && performance.now() < deadline) {
-        if (page.isClosed()) return { verified: false, reason: 'target_closed', status };
-        if (page.url() !== loadedUrl) return { verified: false, reason: 'target_changed', status };
-        const reason = await page.locator(options.identitySelector!).filter({ visible: true }).evaluateAll((elements, expected) => {
-          if (location.origin !== expected.origin || location.href !== expected.url) return 'target_changed';
-          if (elements.length === 0) return 'identity_missing';
-          if (elements.length !== 1) return 'identity_ambiguous';
-          const element = elements[0];
-          const text = element instanceof HTMLElement ? element.innerText : element.textContent ?? '';
-          return text.replace(/\s+/g, ' ').trim() === expected.identity ? 'verified' : 'identity_mismatch';
-        }, { origin: expectedOrigin, url: loadedUrl, identity: expectedIdentity });
-        if (finished || performance.now() >= deadline) return { verified: false, reason: lastFailure, status };
-        if (page.isClosed()) return { verified: false, reason: 'target_closed', status };
-        if (page.url() !== loadedUrl) return { verified: false, reason: 'target_changed', status };
-        if (reason === 'target_changed' || reason === 'verified') return { verified: reason === 'verified', reason, status };
-        lastFailure = reason;
-        const remaining = deadline - performance.now();
-        if (remaining <= 0) return { verified: false, reason, status };
-        await new Promise(resolve => setTimeout(resolve, Math.min(50, remaining)));
-      }
-      return { verified: false, reason: lastFailure, ...(status === undefined ? {} : { status }) };
-    })()]);
-  } catch (error) {
-    const reason = error instanceof errors.TimeoutError || finished || performance.now() >= deadline ? 'timeout'
-      : page.isClosed() ? 'target_closed' : 'verification_failed';
-    return { verified: false, reason, ...(status === undefined ? {} : { status }) };
-  } finally {
-    finished = true;
-    clearTimeout(timer!);
-  }
-}
-
-export function validateCookieStorageSupport(page: Page): void {
-  try {
-    if (page.context().browser()?.browserType().name() === 'chromium') return;
-  } catch {}
-  throw new CookieImportError('Storage reset requires a Chromium target. Import cookies without storage reset on other browsers.', 'storage_reset_unsupported');
-}
-
-export async function clearCookieTargetStorage(page: Page, expectedOrigin: string, timeoutMs = MAX_TIMEOUT_MS): Promise<void> {
-  validateOrigin(expectedOrigin);
-  validateCookieStorageSupport(page);
-  if (page.isClosed()) throw new CookieImportError('The captured target is closed.', 'target_closed');
-  let targetUrl: string;
-  try {
-    targetUrl = page.url();
-    if (new URL(targetUrl).origin !== expectedOrigin) {
-      throw new CookieImportError('The captured target has changed.', 'target_changed');
-    }
-  } catch {
-    throw new CookieImportError('The captured target has changed.', 'target_changed');
-  }
-
-  const deadline = performance.now() + timeoutMs;
-  let expired = false;
-  let navigated = false;
-  const frame = page.mainFrame();
-  const navigation = Promise.withResolvers<string>();
-  const onNavigation = (changed: typeof frame) => {
-    if (changed === frame) { navigated = true; navigation.resolve('target_changed'); }
-  };
-  const onClose = () => { navigated = true; navigation.resolve('target_changed'); };
-  page.on('framenavigated', onNavigation);
-  page.on('close', onClose);
-  const cancelled = () => expired || performance.now() >= deadline ? 'storage_reset_timeout'
-    : navigated || page.isClosed() || page.url() !== targetUrl ? 'target_changed' : undefined;
-  let timer: ReturnType<typeof setTimeout>;
-  const timeout = new Promise<string>(resolve => {
-    timer = setTimeout(() => {
-      expired = true;
-      resolve('storage_reset_timeout');
-    }, Math.max(0, deadline - performance.now()));
-  });
-  const cancellation = Promise.race([timeout, navigation.promise]);
-  let result: string;
-  try {
-    result = await Promise.race([cancellation, withCdpSession(page, async session => {
-      let isolated: { id: number; uniqueId: string } | undefined;
-      let frameId: string | undefined;
-      const worldName = 'gstack-cookie-storage-reset';
-      const onContext = ({ context }: any) => {
-        if (context.name === worldName && context.auxData?.frameId === frameId && context.auxData?.isDefault === false) isolated = context;
-      };
-      session.on('Runtime.executionContextCreated', onContext);
-      try {
-        return await Promise.race([cancellation, (async () => {
-          if (cancelled()) return cancelled()!;
-          const tree = await session.send('Page.getFrameTree');
-          if (cancelled()) return cancelled()!;
-          frameId = tree.frameTree.frame.id;
-          await session.send('Runtime.enable');
-          if (cancelled()) return cancelled()!;
-          const world = await session.send('Page.createIsolatedWorld', { frameId, worldName, grantUniveralAccess: false });
-          if (cancelled()) return cancelled()!;
-          if (!isolated?.uniqueId || isolated.id !== world.executionContextId) return 'storage_reset_failed';
-          const uniqueContextId = isolated.uniqueId;
-          const clock = await session.send('Runtime.evaluate', { expression: 'performance.now()', uniqueContextId, returnByValue: true, silent: true });
-          const remaining = deadline - performance.now();
-          if (cancelled() || remaining <= 0) return cancelled() ?? 'storage_reset_timeout';
-          if (clock.exceptionDetails || !Number.isFinite(clock.result?.value)) return 'storage_reset_failed';
-          const cleared = await session.send('Runtime.callFunctionOn', {
-            uniqueContextId,
-            functionDeclaration: String(({ origin, url, deadline }: { origin: string; url: string; deadline: number }) => {
-              if (performance.now() >= deadline) return 'storage_reset_timeout';
-              if (location.origin !== origin || location.href !== url) return 'target_changed';
-              localStorage.clear();
-              if (performance.now() >= deadline) return 'storage_reset_timeout';
-              sessionStorage.clear();
-              return 'cleared';
-            }),
-            arguments: [{ value: { origin: expectedOrigin, url: targetUrl, deadline: clock.result.value + remaining } }],
-            returnByValue: true,
-            silent: true,
-          });
-          if (cancelled()) return cancelled()!;
-          if (cleared.exceptionDetails || !['cleared', 'target_changed', 'storage_reset_timeout'].includes(cleared.result?.value)) return 'storage_reset_failed';
-          return cleared.result.value;
-        })()]);
-      } finally {
-        session.off('Runtime.executionContextCreated', onContext);
-      }
-    })]);
-  } catch {
-    result = cancelled() ?? 'storage_reset_failed';
-  } finally {
-    expired = true;
-    clearTimeout(timer!);
-    page.off('framenavigated', onNavigation);
-    page.off('close', onClose);
-  }
-  if (result === 'storage_reset_timeout') throw new CookieImportError('Target storage reset timed out; storage may be partially cleared.', 'storage_reset_timeout');
-  if (result === 'target_changed') throw new CookieImportError('The captured target has changed.', 'target_changed');
-  if (result !== 'cleared') throw new CookieImportError('Target storage reset failed; storage may be partially cleared.', 'storage_reset_failed');
-}

package/.agent/skills/gstack-browse/src/cookie-database.ts

@@ -1,73 +0,0 @@
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-
-function databaseError(error: unknown): Error & { code: string } {
-  const detail = error as { errcode?: number; errno?: number; code?: string } | null;
-  const codes: Record<number, string> = {
-    5: 'SQLITE_BUSY', 6: 'SQLITE_LOCKED', 8: 'SQLITE_READONLY', 10: 'SQLITE_IOERR',
-    11: 'SQLITE_CORRUPT', 14: 'SQLITE_CANTOPEN', 26: 'SQLITE_CORRUPT',
-  };
-  const number = detail?.errcode ?? detail?.errno;
-  const code = typeof number === 'number' ? codes[number & 255] ?? 'SQLITE_ERROR'
-    : Object.values(codes).includes(detail?.code ?? '') ? detail!.code! : 'SQLITE_ERROR';
-  const message = code === 'SQLITE_BUSY' || code === 'SQLITE_LOCKED'
-    ? 'Cookie database is locked. Close the source browser and retry.'
-    : 'Cookie database operation failed (' + code + ').';
-  return Object.assign(new Error(message), { code });
-}
-
-export function openCookieDatabase(dbPath: string): {
-  query(sql: string): { all(...bindings: any[]): unknown[] };
-  close(): void;
-} {
-  const isBun = typeof process.versions.bun === 'string';
-  let Database;
-  try {
-    const sqlite = require(isBun ? 'bun:sqlite' : 'node:sqlite');
-    Database = isBun ? sqlite.Database : sqlite.DatabaseSync;
-    if (typeof Database !== 'function') throw new Error();
-  } catch {
-    throw Object.assign(new Error(isBun
-      ? 'Cookie import requires a Bun runtime with SQLite support. Upgrade Bun and retry.'
-      : 'Cookie import requires Node.js 22.13 or newer with built-in SQLite enabled. Upgrade Node.js or enable SQLite and retry.'), { code: 'sqlite_unavailable' });
-  }
-
-  let database;
-  try {
-    database = new Database(dbPath, isBun ? { readonly: true, safeIntegers: true } : { readOnly: true });
-  } catch (error) {
-    throw databaseError(error);
-  }
-
-  return {
-    query(sql) {
-      let statement;
-      try {
-        statement = isBun ? database.query(sql) : database.prepare(sql);
-        if (!isBun) statement.setReadBigInts(true);
-      } catch (error) {
-        throw databaseError(error);
-      }
-      return {
-        all(...bindings) {
-          try {
-            return statement.all(...bindings).map((row: Record<string, unknown>) => Object.fromEntries(
-              Object.entries(row).map(([key, value]) => [key,
-                typeof value === 'bigint' && Number.isSafeInteger(Number(value)) ? Number(value) : value]),
-            ));
-          } catch (error) {
-            throw databaseError(error);
-          }
-        },
-      };
-    },
-    close() {
-      try {
-        database.close();
-      } catch (error) {
-        throw databaseError(error);
-      }
-    },
-  };
-}