opendevbrowser 0.0.28 → 0.0.29

package/dist/chunk-MX3NFLCE.js

@@ -0,0 +1,940 @@
+import {
+  generateSecureToken
+} from "./chunk-ASMHEEKY.js";
+import {
+  writeFileAtomic
+} from "./chunk-TBUCZX4A.js";
+
+// src/config.ts
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { parse as parseJsonc, modify, applyEdits } from "jsonc-parser";
+
+// src/canvas/code-sync/types.ts
+var LEGACY_CODE_SYNC_ADAPTERS = ["tsx-react-v1"];
+var BUILT_IN_FRAMEWORK_ADAPTER_IDS = [
+  "builtin:react-tsx-v2",
+  "builtin:html-static-v1",
+  "builtin:custom-elements-v1",
+  "builtin:vue-sfc-v1",
+  "builtin:svelte-sfc-v1"
+];
+var CODE_SYNC_ADAPTERS = [
+  ...LEGACY_CODE_SYNC_ADAPTERS,
+  ...BUILT_IN_FRAMEWORK_ADAPTER_IDS
+];
+var CODE_SYNC_SYNC_MODES = ["manual", "watch"];
+var CODE_SYNC_PROJECTIONS = ["canvas_html", "bound_app_runtime"];
+var CODE_SYNC_OWNERSHIP_DIMENSIONS = [
+  "structure",
+  "text",
+  "style",
+  "tokens",
+  "behavior",
+  "data"
+];
+var CODE_SYNC_OWNERSHIP_STATES = ["shared", "canvas", "code"];
+var CODE_SYNC_CAPABILITIES = [
+  "preview",
+  "inventory_extract",
+  "code_pull",
+  "code_push",
+  "token_roundtrip",
+  "figma_materialize"
+];
+var CODE_SYNC_STATUS_REASONS = [
+  "none",
+  "framework_migrated",
+  "manifest_migrated",
+  "requires_rebind",
+  "framework_mismatch",
+  "adapter_mismatch",
+  "capability_denied",
+  "plugin_not_found",
+  "plugin_load_failed",
+  "plugin_execution_failed",
+  "import_graph_changed"
+];
+var DEFAULT_CODE_SYNC_OWNERSHIP = {
+  structure: "shared",
+  text: "shared",
+  style: "shared",
+  tokens: "shared",
+  behavior: "code",
+  data: "code"
+};
+var BUILT_IN_FRAMEWORK_DETAILS = {
+  "builtin:react-tsx-v2": {
+    frameworkId: "react",
+    sourceFamily: "react-tsx",
+    adapterKind: "tsx-react",
+    adapterVersion: 2,
+    declaredCapabilities: ["preview", "inventory_extract", "code_pull", "code_push", "token_roundtrip"]
+  },
+  "builtin:html-static-v1": {
+    frameworkId: "html",
+    sourceFamily: "html-static",
+    adapterKind: "html-static",
+    adapterVersion: 1,
+    declaredCapabilities: ["preview", "inventory_extract", "code_pull"]
+  },
+  "builtin:custom-elements-v1": {
+    frameworkId: "custom-elements",
+    sourceFamily: "custom-elements",
+    adapterKind: "custom-elements",
+    adapterVersion: 1,
+    declaredCapabilities: ["preview", "inventory_extract", "code_pull"]
+  },
+  "builtin:vue-sfc-v1": {
+    frameworkId: "vue",
+    sourceFamily: "vue-sfc",
+    adapterKind: "vue-sfc",
+    adapterVersion: 1,
+    declaredCapabilities: ["preview", "inventory_extract", "code_pull"]
+  },
+  "builtin:svelte-sfc-v1": {
+    frameworkId: "svelte",
+    sourceFamily: "svelte-sfc",
+    adapterKind: "svelte-sfc",
+    adapterVersion: 1,
+    declaredCapabilities: ["preview", "inventory_extract", "code_pull"]
+  }
+};
+var LEGACY_ADAPTER_MAP = {
+  "tsx-react-v1": {
+    frameworkAdapterId: "builtin:react-tsx-v2",
+    reasonCode: "framework_migrated"
+  }
+};
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return [...new Set(value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()))];
+}
+function isCodeSyncProjectionMode(value) {
+  return typeof value === "string" && CODE_SYNC_PROJECTIONS.includes(value);
+}
+function isCodeSyncCapability(value) {
+  return typeof value === "string" && CODE_SYNC_CAPABILITIES.includes(value);
+}
+function isCodeSyncStatusReason(value) {
+  return typeof value === "string" && CODE_SYNC_STATUS_REASONS.includes(value);
+}
+function normalizeCodeSyncOwnership(value) {
+  if (!isRecord(value)) {
+    return { ...DEFAULT_CODE_SYNC_OWNERSHIP };
+  }
+  const normalized = {};
+  for (const dimension of CODE_SYNC_OWNERSHIP_DIMENSIONS) {
+    const entry = value[dimension];
+    normalized[dimension] = typeof entry === "string" && CODE_SYNC_OWNERSHIP_STATES.includes(entry) ? entry : DEFAULT_CODE_SYNC_OWNERSHIP[dimension];
+  }
+  return normalized;
+}
+function defaultDeclaredCapabilities(frameworkAdapterId) {
+  const details = BUILT_IN_FRAMEWORK_DETAILS[frameworkAdapterId];
+  return details ? [...details.declaredCapabilities] : ["preview"];
+}
+function defaultGrantedCapabilities(frameworkAdapterId) {
+  return defaultDeclaredCapabilities(frameworkAdapterId).map((capability) => ({
+    capability,
+    granted: true
+  }));
+}
+function mergeDeclaredCapabilities(frameworkAdapterId, explicitCapabilities) {
+  const merged = new Set(defaultDeclaredCapabilities(frameworkAdapterId));
+  for (const capability of explicitCapabilities) {
+    merged.add(capability);
+  }
+  return [...merged];
+}
+function mergeGrantedCapabilities(frameworkAdapterId, explicitGrants) {
+  const grants = /* @__PURE__ */ new Map();
+  for (const grant of defaultGrantedCapabilities(frameworkAdapterId)) {
+    grants.set(grant.capability, grant);
+  }
+  for (const grant of explicitGrants) {
+    grants.set(grant.capability, grant);
+  }
+  return [...grants.values()];
+}
+function inferBuiltInFrameworkAdapterIdFromPath(repoPath) {
+  const normalized = repoPath.toLowerCase();
+  if (normalized.endsWith(".vue")) {
+    return "builtin:vue-sfc-v1";
+  }
+  if (normalized.endsWith(".svelte")) {
+    return "builtin:svelte-sfc-v1";
+  }
+  if (normalized.endsWith(".html") || normalized.endsWith(".htm")) {
+    return "builtin:html-static-v1";
+  }
+  return "builtin:react-tsx-v2";
+}
+function inferCodeSyncSourceFamilyFromPath(repoPath) {
+  return BUILT_IN_FRAMEWORK_DETAILS[inferBuiltInFrameworkAdapterIdFromPath(repoPath)].sourceFamily;
+}
+function normalizeCodeSyncRootLocator(value, options) {
+  const record = isRecord(value) ? value : {};
+  const kind = readString(record.kind);
+  const exportName = readString(record.exportName) ?? options.exportName;
+  const selector = readString(record.selector) ?? options.selector;
+  if (options.sourceFamily === "react-tsx") {
+    if (kind === "dom-selector" && selector) {
+      return { kind, selector };
+    }
+    if (exportName) {
+      return {
+        kind: "react-export",
+        exportName,
+        ...selector ? { selector } : {}
+      };
+    }
+    if (selector) {
+      return {
+        kind: "dom-selector",
+        selector
+      };
+    }
+    throw new Error("codeSync.exportName or codeSync.selector is required.");
+  }
+  if (options.sourceFamily === "vue-sfc") {
+    return {
+      kind: "vue-template",
+      ...selector ? { selector } : {}
+    };
+  }
+  if (options.sourceFamily === "svelte-sfc") {
+    return {
+      kind: "svelte-markup",
+      ...selector ? { selector } : {}
+    };
+  }
+  if (selector) {
+    return {
+      kind: "dom-selector",
+      selector
+    };
+  }
+  return {
+    kind: "document-root"
+  };
+}
+function normalizeCodeSyncCapabilityGrant(value) {
+  if (!isRecord(value) || !isCodeSyncCapability(value.capability)) {
+    return null;
+  }
+  return {
+    capability: value.capability,
+    granted: value.granted !== false,
+    ...isCodeSyncStatusReason(value.reasonCode) ? { reasonCode: value.reasonCode } : {},
+    ...isRecord(value.details) ? { details: value.details } : {}
+  };
+}
+function normalizeFrameworkAdapterIdentity(input) {
+  const adapter = input.adapter ?? "";
+  const explicitFrameworkAdapterId = readString(input.frameworkAdapterId);
+  const inferredFrameworkAdapterId = explicitFrameworkAdapterId ?? (adapter in LEGACY_ADAPTER_MAP ? LEGACY_ADAPTER_MAP[adapter].frameworkAdapterId : adapter.startsWith("builtin:") ? adapter : adapter.includes("/") ? adapter : inferBuiltInFrameworkAdapterIdFromPath(input.repoPath));
+  const migratedReason = adapter in LEGACY_ADAPTER_MAP ? LEGACY_ADAPTER_MAP[adapter].reasonCode : "none";
+  if (inferredFrameworkAdapterId in BUILT_IN_FRAMEWORK_DETAILS) {
+    const details = BUILT_IN_FRAMEWORK_DETAILS[inferredFrameworkAdapterId];
+    return {
+      adapter: adapter || inferredFrameworkAdapterId,
+      frameworkAdapterId: inferredFrameworkAdapterId,
+      frameworkId: details.frameworkId,
+      sourceFamily: details.sourceFamily,
+      adapterKind: details.adapterKind,
+      adapterVersion: details.adapterVersion,
+      reasonCode: migratedReason
+    };
+  }
+  const pluginId = inferredFrameworkAdapterId.includes("/") ? inferredFrameworkAdapterId.split("/", 1)[0] : void 0;
+  const sourceFamily = inferCodeSyncSourceFamilyFromPath(input.repoPath);
+  return {
+    adapter: adapter || inferredFrameworkAdapterId,
+    frameworkAdapterId: inferredFrameworkAdapterId,
+    frameworkId: sourceFamily === "react-tsx" ? "react" : sourceFamily === "vue-sfc" ? "vue" : sourceFamily === "svelte-sfc" ? "svelte" : "html",
+    sourceFamily,
+    adapterKind: pluginId ? "plugin" : "unknown",
+    adapterVersion: 1,
+    reasonCode: migratedReason,
+    ...pluginId ? { pluginId } : {}
+  };
+}
+function normalizeCodeSyncBindingMetadata(value) {
+  if (!isRecord(value)) {
+    throw new Error("Invalid code sync binding metadata.");
+  }
+  const repoPath = readString(value.repoPath);
+  const syncMode = readString(value.syncMode);
+  if (!repoPath) {
+    throw new Error("codeSync.repoPath is required.");
+  }
+  if (!syncMode || !CODE_SYNC_SYNC_MODES.includes(syncMode)) {
+    throw new Error(`Unsupported code sync mode: ${syncMode || "unknown"}`);
+  }
+  const exportName = readString(value.exportName) ?? void 0;
+  const selector = readString(value.selector) ?? void 0;
+  const identity = normalizeFrameworkAdapterIdentity({
+    adapter: readString(value.adapter),
+    frameworkAdapterId: readString(value.frameworkAdapterId),
+    repoPath
+  });
+  const rootLocator = normalizeCodeSyncRootLocator(value.rootLocator, {
+    sourceFamily: identity.sourceFamily,
+    exportName,
+    selector
+  });
+  const declaredCapabilities = readStringArray(value.declaredCapabilities).filter((entry) => isCodeSyncCapability(entry));
+  const grantedCapabilities = Array.isArray(value.grantedCapabilities) ? value.grantedCapabilities.map((entry) => normalizeCodeSyncCapabilityGrant(entry)).filter((entry) => Boolean(entry)) : [];
+  const manifestVersion = readNumber(value.manifestVersion) ?? 2;
+  const reasonCode = isCodeSyncStatusReason(value.reasonCode) ? value.reasonCode : identity.reasonCode;
+  return {
+    adapter: identity.adapter,
+    frameworkAdapterId: identity.frameworkAdapterId,
+    frameworkId: readString(value.frameworkId) ?? identity.frameworkId,
+    sourceFamily: readString(value.sourceFamily) ?? identity.sourceFamily,
+    adapterKind: readString(value.adapterKind) ?? identity.adapterKind,
+    adapterVersion: readNumber(value.adapterVersion) ?? identity.adapterVersion,
+    repoPath,
+    rootLocator,
+    exportName,
+    selector,
+    syncMode,
+    ownership: normalizeCodeSyncOwnership(value.ownership),
+    route: readString(value.route) ?? void 0,
+    verificationTarget: readString(value.verificationTarget) ?? void 0,
+    runtimeRootSelector: readString(value.runtimeRootSelector) ?? void 0,
+    projection: isCodeSyncProjectionMode(value.projection) ? value.projection : "canvas_html",
+    manifestVersion,
+    libraryAdapterIds: readStringArray(value.libraryAdapterIds ?? value.libraryAdapters),
+    pluginId: readString(value.pluginId) ?? identity.pluginId,
+    declaredCapabilities: declaredCapabilities.length > 0 ? mergeDeclaredCapabilities(identity.frameworkAdapterId, declaredCapabilities) : defaultDeclaredCapabilities(identity.frameworkAdapterId),
+    grantedCapabilities: grantedCapabilities.length > 0 ? mergeGrantedCapabilities(identity.frameworkAdapterId, grantedCapabilities) : defaultGrantedCapabilities(identity.frameworkAdapterId),
+    reasonCode
+  };
+}
+
+// src/config.ts
+function isExecutable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_RELAY_PORT = 8787;
+var DEFAULT_DAEMON_PORT = 8788;
+function buildDefaultConfigJsonc(relayToken, daemonToken) {
+  return `{
+  // Set relayToken to false to disable extension pairing.
+  "relayPort": ${DEFAULT_RELAY_PORT},
+  "relayToken": "${relayToken}",
+  // Optional: extension ID for native host auto-install.
+  // "nativeExtensionId": "abcdefghijklmnopabcdefghijklmnop",
+  "daemonPort": ${DEFAULT_DAEMON_PORT},
+  "daemonToken": "${daemonToken}"
+}
+`;
+}
+var snapshotSchema = z.object({
+  maxChars: z.number().int().min(500).max(2e5).default(16e3),
+  maxNodes: z.number().int().min(50).max(5e3).default(1e3)
+});
+var securitySchema = z.object({
+  allowRawCDP: z.boolean().default(false),
+  allowNonLocalCdp: z.boolean().default(false),
+  allowUnsafeExport: z.boolean().default(false),
+  promptInjectionGuard: z.object({
+    enabled: z.boolean().default(true)
+  }).default({})
+});
+var DEFAULT_PROVIDER_COOKIE_FILE = "~/.config/opencode/opendevbrowser.provider-cookies.json";
+var DEFAULT_PROVIDER_COOKIE_ENV = "OPENDEVBROWSER_PROVIDER_COOKIES";
+var providerCookieRecordSchema = z.object({
+  name: z.string().min(1),
+  value: z.string(),
+  url: z.string().min(1).optional(),
+  domain: z.string().min(1).optional(),
+  path: z.string().optional(),
+  expires: z.number().optional(),
+  httpOnly: z.boolean().optional(),
+  secure: z.boolean().optional(),
+  sameSite: z.enum(["Strict", "Lax", "None"]).optional()
+}).superRefine((cookie, ctx) => {
+  if (!cookie.url && !cookie.domain) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Provider cookie entries must set url or domain."
+    });
+  }
+});
+var providersSchema = z.object({
+  tiers: z.object({
+    default: z.enum(["A", "B", "C"]).default("A"),
+    enableHybrid: z.boolean().default(false),
+    enableRestrictedSafe: z.boolean().default(false),
+    hybridRiskThreshold: z.number().min(0).max(1).default(0.6),
+    restrictedSafeRecoveryIntervalMs: z.number().int().min(0).max(864e5).default(6e4)
+  }).default({}),
+  adaptiveConcurrency: z.object({
+    enabled: z.boolean().default(false),
+    maxGlobal: z.number().int().min(1).max(512).default(8),
+    maxPerDomain: z.number().int().min(1).max(256).default(4)
+  }).default({}),
+  crawler: z.object({
+    workerThreads: z.number().int().min(1).max(64).default(4),
+    queueMax: z.number().int().min(1).max(1e5).default(2e3)
+  }).default({}),
+  antiBotPolicy: z.object({
+    enabled: z.boolean().default(true),
+    cooldownMs: z.number().int().min(0).max(3e5).default(3e4),
+    maxChallengeRetries: z.number().int().min(0).max(10).default(1),
+    proxyHint: z.string().min(1).optional(),
+    sessionHint: z.string().min(1).optional(),
+    allowBrowserEscalation: z.boolean().default(true)
+  }).default({}),
+  challengeOrchestration: z.object({
+    mode: z.enum(["off", "browser", "browser_with_helper"]).default("browser_with_helper"),
+    attemptBudget: z.number().int().min(1).max(20).default(6),
+    noProgressLimit: z.number().int().min(1).max(10).default(3),
+    stepTimeoutMs: z.number().int().min(250).max(12e4).default(5e3),
+    minAttemptGapMs: z.number().int().min(0).max(3e5).default(1e4),
+    allowAuthNavigation: z.boolean().default(true),
+    allowSessionReuse: z.boolean().default(true),
+    allowCookieReuse: z.boolean().default(true),
+    allowNonSecretFormFill: z.boolean().default(true),
+    allowInteractionExploration: z.boolean().default(true),
+    governed: z.object({
+      allowOwnedEnvironmentFixtures: z.boolean().default(true),
+      allowSanctionedIdentity: z.boolean().default(false),
+      allowServiceAdapters: z.boolean().default(false),
+      requireAuditMetadata: z.boolean().default(true)
+    }).default({}),
+    optionalComputerUseBridge: z.object({
+      enabled: z.boolean().default(true),
+      maxSuggestions: z.number().int().min(1).max(20).default(3)
+    }).default({})
+  }).default({}),
+  transcript: z.object({
+    modeDefault: z.union([
+      z.enum(["auto", "web", "no-auto", "yt-dlp", "apify"]),
+      z.literal("ytdlp")
+    ]).default("auto").transform((mode) => mode === "ytdlp" ? "yt-dlp" : mode),
+    strategyOrder: z.array(z.enum([
+      "youtubei",
+      "native_caption_parse",
+      "ytdlp_audio_asr",
+      "apify",
+      "ytdlp_subtitle",
+      "optional_asr"
+    ])).default(["youtubei", "native_caption_parse", "ytdlp_audio_asr", "apify"]),
+    enableYtdlp: z.boolean().default(false),
+    enableAsr: z.boolean().default(false),
+    enableYtdlpAudioAsr: z.boolean().default(true),
+    enableApify: z.boolean().default(true),
+    apifyActorId: z.string().min(1).default("streamers/youtube-scraper"),
+    enableBrowserFallback: z.boolean().default(false),
+    ytdlpTimeoutMs: z.number().int().min(1e3).max(12e4).default(1e4)
+  }).default({}),
+  cookiePolicy: z.enum(["off", "auto", "required"]).default("auto"),
+  cookieSource: z.object({
+    type: z.enum(["file", "env", "inline"]).default("file"),
+    value: z.union([
+      z.string(),
+      z.array(providerCookieRecordSchema)
+    ]).optional()
+  }).transform((raw) => {
+    if (raw.type === "inline") {
+      return {
+        type: "inline",
+        value: Array.isArray(raw.value) ? raw.value : []
+      };
+    }
+    return {
+      type: raw.type,
+      value: typeof raw.value === "string" ? raw.value : raw.type === "file" ? DEFAULT_PROVIDER_COOKIE_FILE : DEFAULT_PROVIDER_COOKIE_ENV
+    };
+  }).default({
+    type: "file",
+    value: DEFAULT_PROVIDER_COOKIE_FILE
+  })
+}).default({});
+var canarySchema = z.object({
+  targets: z.object({
+    enabled: z.boolean().default(false)
+  }).default({})
+});
+var devtoolsSchema = z.object({
+  showFullUrls: z.boolean().default(false),
+  showFullConsole: z.boolean().default(false)
+});
+var exportSchema = z.object({
+  maxNodes: z.number().int().min(1).max(5e3).default(1e3),
+  inlineStyles: z.boolean().default(true)
+});
+var desktopSchema = z.object({
+  permissionLevel: z.enum(["off", "observe"]).default("observe"),
+  commandTimeoutMs: z.number().int().min(250).max(3e5).default(1e4),
+  auditArtifactsDir: z.string().min(1).default(".opendevbrowser/desktop-runtime"),
+  accessibilityMaxDepth: z.number().int().min(1).max(8).default(2),
+  accessibilityMaxChildren: z.number().int().min(1).max(500).default(25)
+}).default({});
+var parallelismSchema = z.object({
+  floor: z.number().int().min(1).max(32).default(1),
+  backpressureTimeoutMs: z.number().int().min(100).max(12e4).default(5e3),
+  sampleIntervalMs: z.number().int().min(250).max(6e4).default(2e3),
+  recoveryStableWindows: z.number().int().min(1).max(20).default(3),
+  hostFreeMemMediumPct: z.number().int().min(1).max(99).default(25),
+  hostFreeMemHighPct: z.number().int().min(1).max(99).default(18),
+  hostFreeMemCriticalPct: z.number().int().min(1).max(99).default(10),
+  rssBudgetMb: z.number().int().min(64).max(65536).default(2048),
+  rssSoftPct: z.number().int().min(1).max(99).default(65),
+  rssHighPct: z.number().int().min(1).max(99).default(75),
+  rssCriticalPct: z.number().int().min(1).max(99).default(85),
+  queueAgeHighMs: z.number().int().min(100).max(12e4).default(2e3),
+  queueAgeCriticalMs: z.number().int().min(100).max(12e4).default(5e3),
+  modeCaps: z.object({
+    managedHeaded: z.number().int().min(1).max(64).default(6),
+    managedHeadless: z.number().int().min(1).max(64).default(8),
+    cdpConnectHeaded: z.number().int().min(1).max(64).default(6),
+    cdpConnectHeadless: z.number().int().min(1).max(64).default(8),
+    extensionOpsHeaded: z.number().int().min(1).max(64).default(6),
+    extensionLegacyCdpHeaded: z.number().int().min(1).max(64).default(1)
+  }).default({})
+}).default({});
+var blockerArtifactCapsSchema = z.object({
+  maxNetworkEvents: z.number().int().min(1).max(500).default(20),
+  maxConsoleEvents: z.number().int().min(1).max(500).default(20),
+  maxExceptionEvents: z.number().int().min(1).max(200).default(10),
+  maxHosts: z.number().int().min(1).max(200).default(10),
+  maxTextLength: z.number().int().min(32).max(4096).default(512)
+}).default({});
+var skillsNudgeSchema = z.object({
+  enabled: z.boolean().default(true),
+  keywords: z.array(z.string()).default([
+    "quick start",
+    "getting started",
+    "launch",
+    "connect",
+    "setup"
+  ]),
+  maxAgeMs: z.number().int().min(1e3).max(6e5).default(6e4)
+});
+var skillsSchema = z.object({
+  nudge: skillsNudgeSchema.default({})
+}).default({});
+var continuityNudgeSchema = z.object({
+  enabled: z.boolean().default(true),
+  keywords: z.array(z.string()).default([
+    "plan",
+    "multi-step",
+    "multi step",
+    "long-running",
+    "long running",
+    "refactor",
+    "migration",
+    "rollout",
+    "release",
+    "upgrade",
+    "investigate",
+    "follow-up",
+    "continue"
+  ]),
+  maxAgeMs: z.number().int().min(1e3).max(6e5).default(6e4)
+});
+var continuitySchema = z.object({
+  enabled: z.boolean().default(true),
+  filePath: z.string().min(1).default("opendevbrowser_continuity.md"),
+  nudge: continuityNudgeSchema.default({})
+}).default({});
+var tier1GeolocationSchema = z.object({
+  latitude: z.number().min(-90).max(90),
+  longitude: z.number().min(-180).max(180),
+  accuracy: z.number().min(1).max(1e4).default(50)
+});
+var fingerprintTier1Schema = z.object({
+  enabled: z.boolean().default(true),
+  warnOnly: z.boolean().default(true),
+  locale: z.string().min(2).optional(),
+  timezone: z.string().min(2).optional(),
+  languages: z.array(z.string().min(2)).default([]),
+  requireProxy: z.boolean().default(false),
+  geolocation: tier1GeolocationSchema.optional(),
+  geolocationRequired: z.boolean().default(false)
+}).default({});
+var fingerprintTier2Schema = z.object({
+  enabled: z.boolean().default(true),
+  mode: z.union([z.enum(["deterministic", "adaptive"]), z.literal("off")]).default("adaptive").transform((mode) => {
+    return mode === "off" ? "deterministic" : mode;
+  }),
+  continuousSignals: z.boolean().default(true),
+  rotationIntervalMs: z.number().int().min(0).max(864e5).default(9e5),
+  challengePatterns: z.array(z.string().min(1)).default([
+    "captcha",
+    "challenge",
+    "interstitial",
+    "cf_chl",
+    "bot"
+  ]),
+  maxChallengeEvents: z.number().int().min(1).max(100).default(20),
+  scorePenalty: z.number().int().min(1).max(100).default(20),
+  scoreRecovery: z.number().int().min(0).max(100).default(5),
+  rotationHealthThreshold: z.number().int().min(0).max(100).default(55)
+}).default({});
+var fingerprintTier3CanarySchema = z.object({
+  windowSize: z.number().int().min(1).max(100).default(10),
+  minSamples: z.number().int().min(1).max(100).default(3),
+  promoteThreshold: z.number().int().min(0).max(100).default(80),
+  rollbackThreshold: z.number().int().min(0).max(100).default(35)
+});
+var fingerprintTier3Schema = z.object({
+  enabled: z.boolean().default(true),
+  continuousSignals: z.boolean().default(true),
+  fallbackTier: z.enum(["tier1", "tier2"]).default("tier2"),
+  canary: fingerprintTier3CanarySchema.default({})
+}).default({});
+var fingerprintSchema = z.object({
+  tier1: fingerprintTier1Schema.default({}),
+  tier2: fingerprintTier2Schema.default({}),
+  tier3: fingerprintTier3Schema.default({})
+}).default({});
+var figmaIntegrationSchema = z.object({
+  accessToken: z.string().min(1).optional()
+}).default({});
+var integrationsSchema = z.object({
+  figma: figmaIntegrationSchema.default({})
+}).default({});
+var canvasAdapterPluginDeclarationSchema = z.union([
+  z.string().min(1),
+  z.object({
+    ref: z.string().min(1),
+    enabled: z.boolean().optional(),
+    trustedWorkspaceRoots: z.array(z.string().min(1)).optional(),
+    capabilityOverrides: z.array(z.enum(CODE_SYNC_CAPABILITIES)).optional()
+  })
+]);
+var canvasSchema = z.object({
+  adapterPlugins: z.array(canvasAdapterPluginDeclarationSchema).default([])
+}).default({});
+var configSchema = z.object({
+  headless: z.boolean().default(false),
+  profile: z.string().min(1).default("default"),
+  snapshot: snapshotSchema.default({}),
+  security: securitySchema.default({}),
+  blockerDetectionThreshold: z.number().min(0).max(1).default(0.7),
+  blockerResolutionTimeoutMs: z.number().int().min(1e3).max(864e5).default(6e5),
+  blockerArtifactCaps: blockerArtifactCapsSchema,
+  providers: providersSchema.default({}),
+  integrations: integrationsSchema.default({}),
+  canvas: canvasSchema.default({}),
+  devtools: devtoolsSchema.default({}),
+  fingerprint: fingerprintSchema.default({}),
+  canary: canarySchema.default({}),
+  export: exportSchema.default({}),
+  desktop: desktopSchema,
+  parallelism: parallelismSchema.default({}),
+  skills: skillsSchema.default({}),
+  continuity: continuitySchema.default({}),
+  relayPort: z.number().int().min(0).max(65535).default(DEFAULT_RELAY_PORT),
+  relayToken: z.union([z.string(), z.literal(false)]).optional(),
+  nativeExtensionId: z.string().optional(),
+  daemonPort: z.number().int().min(0).max(65535).default(DEFAULT_DAEMON_PORT),
+  daemonToken: z.string().min(1).optional(),
+  chromePath: z.string().min(1).optional().refine(
+    (val) => val === void 0 || isExecutable(val),
+    { message: "chromePath must point to an executable file" }
+  ),
+  flags: z.array(z.string()).default([]),
+  checkForUpdates: z.boolean().default(false),
+  persistProfile: z.boolean().default(true),
+  skillPaths: z.array(z.string()).default([])
+});
+var CONFIG_FILE_NAME = "opendevbrowser.jsonc";
+function getGlobalConfigPath() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path.join(os.homedir(), ".config", "opencode");
+  return path.join(configDir, CONFIG_FILE_NAME);
+}
+function ensureConfigFile(filePath) {
+  const relayToken = generateSecureToken();
+  const daemonToken = generateSecureToken();
+  if (fs.existsSync(filePath)) {
+    return { relayToken, daemonToken };
+  }
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
+    fs.writeFileSync(filePath, buildDefaultConfigJsonc(relayToken, daemonToken), { encoding: "utf-8", mode: 384 });
+  } catch (error) {
+    console.warn(`[opendevbrowser] Warning: Could not create config file at ${filePath}:`, error);
+  }
+  return { relayToken, daemonToken };
+}
+function loadConfigFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    const tokens = ensureConfigFile(filePath);
+    const content2 = buildDefaultConfigJsonc(tokens.relayToken, tokens.daemonToken);
+    return {
+      raw: {},
+      content: content2,
+      generatedRelayToken: tokens.relayToken,
+      generatedDaemonToken: tokens.daemonToken,
+      created: true
+    };
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const errors = [];
+  const parsed = parseJsonc(content, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    const firstError = errors[0];
+    if (!firstError) {
+      throw new Error(`Invalid JSONC in opendevbrowser config at ${filePath}: parse error`);
+    }
+    throw new Error(`Invalid JSONC in opendevbrowser config at ${filePath}: parse error at offset ${firstError.offset}`);
+  }
+  return {
+    raw: parsed ?? {},
+    content,
+    generatedRelayToken: null,
+    generatedDaemonToken: null,
+    created: false
+  };
+}
+function loadGlobalConfig() {
+  const configPath = getGlobalConfigPath();
+  const { raw, content, generatedRelayToken, generatedDaemonToken, created } = loadConfigFile(configPath);
+  const parsed = configSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
+    throw new Error(`Invalid opendevbrowser config at ${configPath}: ${issues}`);
+  }
+  const data = parsed.data;
+  const relayToken = data.relayToken ?? generatedRelayToken ?? generateSecureToken();
+  const daemonToken = data.daemonToken ?? generatedDaemonToken ?? generateSecureToken();
+  if (!created) {
+    persistDaemonConfigDefaults({
+      configPath,
+      content,
+      raw,
+      daemonPort: data.daemonPort,
+      daemonToken
+    });
+  }
+  return { ...data, relayToken, daemonToken };
+}
+function resolveConfig(config) {
+  if (typeof config === "undefined") {
+    return loadGlobalConfig();
+  }
+  const parsed = configSchema.safeParse(config);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
+    throw new Error(`Invalid opendevbrowser config override: ${issues}`);
+  }
+  const data = parsed.data;
+  const relayToken = data.relayToken ?? generateSecureToken();
+  const daemonToken = data.daemonToken ?? generateSecureToken();
+  return { ...data, relayToken, daemonToken };
+}
+function requireChallengeOrchestrationConfig(config) {
+  const challengeOrchestration = config.providers?.challengeOrchestration;
+  if (!challengeOrchestration) {
+    throw new Error("Challenge orchestration config is unavailable.");
+  }
+  return challengeOrchestration;
+}
+function persistDaemonConfigDefaults(params) {
+  if (!isRecord2(params.raw)) {
+    return;
+  }
+  const hasDaemonPort = Object.prototype.hasOwnProperty.call(params.raw, "daemonPort");
+  const hasDaemonToken = Object.prototype.hasOwnProperty.call(params.raw, "daemonToken");
+  if (hasDaemonPort && hasDaemonToken) {
+    return;
+  }
+  const formattingOptions = { insertSpaces: true, tabSize: 2 };
+  let updatedContent = params.content;
+  if (!hasDaemonPort) {
+    const edits = modify(updatedContent, ["daemonPort"], params.daemonPort, { formattingOptions });
+    if (edits.length) {
+      updatedContent = applyEdits(updatedContent, edits);
+    }
+  }
+  if (!hasDaemonToken) {
+    const edits = modify(updatedContent, ["daemonToken"], params.daemonToken, { formattingOptions });
+    if (edits.length) {
+      updatedContent = applyEdits(updatedContent, edits);
+    }
+  }
+  if (updatedContent !== params.content) {
+    writeFileAtomic(params.configPath, updatedContent, { mode: 384 });
+  }
+}
+var isRecord2 = (value) => {
+  return typeof value === "object" && value !== null;
+};
+var ConfigStore = class {
+  current;
+  constructor(initial) {
+    this.current = initial;
+  }
+  get() {
+    return this.current;
+  }
+  set(next) {
+    this.current = next;
+  }
+};
+
+// src/cache/chrome-user-data.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { homedir as homedir2 } from "os";
+var PROFILE_PREFERENCES_FILES = ["Preferences", "Secure Preferences"];
+var getChromeUserDataRootCandidates = () => {
+  if (process.platform === "darwin") {
+    return [
+      {
+        browserName: "chrome",
+        userDataDir: path2.join(homedir2(), "Library", "Application Support", "Google", "Chrome")
+      },
+      {
+        browserName: "chromium",
+        userDataDir: path2.join(homedir2(), "Library", "Application Support", "Chromium")
+      },
+      {
+        browserName: "brave",
+        userDataDir: path2.join(homedir2(), "Library", "Application Support", "BraveSoftware", "Brave-Browser")
+      }
+    ];
+  }
+  if (process.platform === "linux") {
+    return [
+      {
+        browserName: "chrome",
+        userDataDir: path2.join(homedir2(), ".config", "google-chrome")
+      },
+      {
+        browserName: "chromium",
+        userDataDir: path2.join(homedir2(), ".config", "chromium")
+      },
+      {
+        browserName: "brave",
+        userDataDir: path2.join(homedir2(), ".config", "BraveSoftware", "Brave-Browser")
+      }
+    ];
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || (process.env.USERPROFILE ? path2.join(process.env.USERPROFILE, "AppData", "Local") : "");
+    if (!localAppData) {
+      return [];
+    }
+    return [
+      {
+        browserName: "chrome",
+        userDataDir: path2.join(localAppData, "Google", "Chrome", "User Data")
+      },
+      {
+        browserName: "chromium",
+        userDataDir: path2.join(localAppData, "Chromium", "User Data")
+      },
+      {
+        browserName: "brave",
+        userDataDir: path2.join(localAppData, "BraveSoftware", "Brave-Browser", "User Data")
+      }
+    ];
+  }
+  return [];
+};
+var getChromeUserDataRoots = () => {
+  return getChromeUserDataRootCandidates().map((candidate) => candidate.userDataDir);
+};
+var getProfileDirs = (root) => {
+  try {
+    const entries = fs2.readdirSync(root, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory() && (entry.name === "Default" || entry.name.startsWith("Profile "))).map((entry) => path2.join(root, entry.name)).filter((dir) => PROFILE_PREFERENCES_FILES.some((filename) => fs2.existsSync(path2.join(dir, filename))));
+  } catch {
+    return [];
+  }
+};
+var readProfilePreferences = (profileDir) => {
+  const records = [];
+  for (const filename of PROFILE_PREFERENCES_FILES) {
+    try {
+      const raw = fs2.readFileSync(path2.join(profileDir, filename), "utf8");
+      records.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return records;
+};
+var readLocalState = (root) => {
+  try {
+    const raw = fs2.readFileSync(path2.join(root, "Local State"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var pickPreferredProfileDirectory = (root, profileDirs) => {
+  if (profileDirs.length === 0) {
+    return null;
+  }
+  const available = new Set(profileDirs.map((profileDir) => path2.basename(profileDir)));
+  const localState = readLocalState(root);
+  const profileState = localState?.profile;
+  const lastUsed = typeof profileState === "object" && profileState !== null ? typeof profileState.last_used === "string" ? profileState.last_used : null : null;
+  if (lastUsed && available.has(lastUsed)) {
+    return lastUsed;
+  }
+  if (available.has("Default")) {
+    return "Default";
+  }
+  const firstProfile = profileDirs[0];
+  return path2.basename(firstProfile);
+};
+var discoverSystemChromeProfileSource = () => {
+  for (const candidate of getChromeUserDataRootCandidates()) {
+    const profileDirs = getProfileDirs(candidate.userDataDir);
+    const profileDirectory = pickPreferredProfileDirectory(candidate.userDataDir, profileDirs);
+    if (!profileDirectory) {
+      continue;
+    }
+    return {
+      browserName: candidate.browserName,
+      userDataDir: candidate.userDataDir,
+      profileDirectory,
+      profilePath: path2.join(candidate.userDataDir, profileDirectory)
+    };
+  }
+  return null;
+};
+
+export {
+  CODE_SYNC_CAPABILITIES,
+  isCodeSyncCapability,
+  inferBuiltInFrameworkAdapterIdFromPath,
+  normalizeCodeSyncRootLocator,
+  normalizeCodeSyncCapabilityGrant,
+  normalizeFrameworkAdapterIdentity,
+  normalizeCodeSyncBindingMetadata,
+  loadGlobalConfig,
+  resolveConfig,
+  requireChallengeOrchestrationConfig,
+  ConfigStore,
+  getChromeUserDataRoots,
+  getProfileDirs,
+  readProfilePreferences,
+  discoverSystemChromeProfileSource
+};
+//# sourceMappingURL=chunk-MX3NFLCE.js.map