pi-oracle 0.7.3 → 0.7.5

package/extensions/oracle/lib/runtime.ts

@@ -6,8 +6,9 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { constants as fsConstants, existsSync, realpathSync, readFileSync } from "node:fs";
-import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { access, cp as copyDirectory, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { delimiter, dirname, join } from "node:path";
+import { assertNotKnownBrowserUserDataPath, sweetCookieSafeStoragePasswordScrubbedEnv } from "../shared/browser-profile-helpers.mjs";
 import { jobBlocksAdmission } from "../shared/job-coordination-helpers.mjs";
 import { isTrackedProcessAlive } from "../shared/process-helpers.mjs";
 import type { OracleConfig } from "./config.js";
@@ -21,16 +22,44 @@ const AGENT_BROWSER_BIN = [process.env.AGENT_BROWSER_PATH, "/opt/homebrew/bin/ag
 ) || "agent-browser";
 const PROFILE_CLONE_TIMEOUT_MS = 120_000;
 const ORACLE_SUBPROCESS_KILL_GRACE_MS = 2_000;
+
+function killProcessTree(child: ReturnType<typeof spawn>): void {
+  if (process.platform === "win32" && child.pid) {
+    spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore", windowsHide: true })
+      .on("error", () => undefined);
+    return;
+  }
+  child.kill("SIGTERM");
+}
+
+function killProcess(child: ReturnType<typeof spawn>): void {
+  if (process.platform === "win32" && child.pid) {
+    spawn("taskkill", ["/pid", String(child.pid), "/f"], { stdio: "ignore", windowsHide: true })
+      .on("error", () => undefined);
+    return;
+  }
+  child.kill("SIGKILL");
+}
 const WORKSPACE_ROOT_MARKERS = [
   ".pi/extensions/oracle.json",
   ".pi",
   "AGENTS.md",
 ] as const;
-const REQUIRED_ORACLE_DEPENDENCIES = [
-  { name: "agent-browser", command: AGENT_BROWSER_BIN },
-  { name: "tar", command: "tar" },
-  { name: "zstd", command: "zstd" },
-] as const;
+function cpCommand(): string {
+  return process.env.PI_ORACLE_CP_PATH?.trim() || "cp";
+}
+
+function requiredOracleDependencies(config: OracleConfig): Array<{ name: string; command: string }> {
+  const dependencies = [
+    { name: "agent-browser", command: AGENT_BROWSER_BIN },
+    { name: "tar", command: "tar" },
+    { name: "zstd", command: "zstd" },
+  ];
+  if (config.browser.cloneStrategy === "apfs-clone" && process.platform === "darwin") {
+    dependencies.push({ name: "cp", command: cpCommand() });
+  }
+  return dependencies;
+}
 
 export interface OracleRuntimeLeaseMetadata {
   jobId: string;
@@ -152,30 +181,61 @@ function missingLocalDependencyMessage(name: string): string {
   return `Oracle prerequisite not found on PATH: ${name}. Install ${name} and retry.`;
 }
 
+function unsafeOracleProfilePathMessage(label: string, path: string, error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return `Oracle ${label} path is unsafe: ${path}. ${message}`;
+}
+
+function assertSafeOracleProfilePath(
+  path: string,
+  label: "auth seed profile" | "runtime profile" | "runtime profiles",
+  config?: OracleConfig,
+): void {
+  try {
+    assertNotKnownBrowserUserDataPath(path, `Oracle ${label}`, {
+      cookieSources: config ? { chromeProfile: config.auth.chromeProfile, chromeCookiePath: config.auth.chromeCookiePath } : undefined,
+    });
+  } catch (error) {
+    throw new Error(unsafeOracleProfilePathMessage(label, path, error));
+  }
+}
+
 function unwritableOracleDirectoryMessage(label: "runtime profiles" | "jobs", path: string): string {
   return `Oracle ${label} directory is not writable: ${path}. Fix its permissions or configure a writable path, then retry.`;
 }
 
+async function isExecutableFile(path: string): Promise<boolean> {
+  try {
+    const stats = await stat(path);
+    if (!stats.isFile()) return false;
+    await access(path, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function executableNameCandidates(command: string): string[] {
+  if (process.platform !== "win32" || /\.[^\\/]+$/.test(command)) return [command];
+  const extensions = (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD;.PS1").split(";").filter(Boolean);
+  return [command, ...extensions.map((extension) => `${command}${extension.toLowerCase()}`), ...extensions.map((extension) => `${command}${extension.toUpperCase()}`)];
+}
+
 async function resolveExecutableOnPath(command: string): Promise<string | undefined> {
   if (!command) return undefined;
-  if (command.includes("/")) {
-    try {
-      await access(command, fsConstants.X_OK);
-      return command;
-    } catch {
-      return undefined;
+  if (command.includes("/") || command.includes("\\")) {
+    for (const candidate of executableNameCandidates(command)) {
+      if (await isExecutableFile(candidate)) return candidate;
     }
+    return undefined;
   }
 
   const pathValue = process.env.PATH ?? "";
   for (const segment of pathValue.split(delimiter)) {
     if (!segment) continue;
-    const candidate = join(segment, command);
-    try {
-      await access(candidate, fsConstants.X_OK);
-      return candidate;
-    } catch {
-      continue;
+    for (const name of executableNameCandidates(command)) {
+      const candidate = join(segment, name);
+      if (await isExecutableFile(candidate)) return candidate;
     }
   }
   return undefined;
@@ -235,6 +295,7 @@ async function assertWritableDirectory(path: string, label: "runtime profiles" |
 
 export async function assertOracleAuthSeedProfileReady(config: OracleConfig): Promise<void> {
   const seedDir = config.browser.authSeedProfileDir;
+  assertSafeOracleProfilePath(seedDir, "auth seed profile", config);
   let seedStats;
   try {
     seedStats = await stat(seedDir);
@@ -257,9 +318,10 @@ export async function assertOracleAuthSeedProfileReady(config: OracleConfig): Pr
 }
 
 export async function assertOracleSubmitPrerequisites(config: OracleConfig): Promise<void> {
+  assertSafeOracleProfilePath(config.browser.runtimeProfilesDir, "runtime profiles", config);
   await assertOracleAuthSeedProfileReady(config);
   await assertConfiguredBrowserExecutableReady(config.browser.executablePath);
-  for (const dependency of REQUIRED_ORACLE_DEPENDENCIES) {
+  for (const dependency of requiredOracleDependencies(config)) {
     await assertRequiredLocalDependencyReady(dependency.name, dependency.command);
   }
   await assertWritableDirectory(config.browser.runtimeProfilesDir, "runtime profiles");
@@ -379,7 +441,7 @@ export async function releaseConversationLease(conversationId: string | undefine
 }
 
 function profileCloneArgs(config: OracleConfig, sourceDir: string, destinationDir: string): string[] {
-  if (config.browser.cloneStrategy === "apfs-clone") {
+  if (config.browser.cloneStrategy === "apfs-clone" && process.platform === "darwin") {
     return ["-cR", sourceDir, destinationDir];
   }
   return ["-R", sourceDir, destinationDir];
@@ -387,7 +449,7 @@ function profileCloneArgs(config: OracleConfig, sourceDir: string, destinationDi
 
 async function spawnCp(args: string[], options?: { timeoutMs?: number }): Promise<void> {
   await new Promise<void>((resolve, reject) => {
-    const child = spawn("cp", args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn(cpCommand(), args, { env: sweetCookieSafeStoragePasswordScrubbedEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     let stderr = "";
     let timedOut = false;
     let killTimer: NodeJS.Timeout | undefined;
@@ -401,9 +463,9 @@ async function spawnCp(args: string[], options?: { timeoutMs?: number }): Promis
     if ((options?.timeoutMs ?? 0) > 0) {
       killTimer = setTimeout(() => {
         timedOut = true;
-        child.kill("SIGTERM");
+        killProcessTree(child);
         killGraceTimer = setTimeout(() => {
-          child.kill("SIGKILL");
+          killProcess(child);
         }, ORACLE_SUBPROCESS_KILL_GRACE_MS);
         killGraceTimer.unref?.();
       }, options?.timeoutMs);
@@ -445,11 +507,16 @@ export async function cloneSeedProfileToRuntime(
 ): Promise<string | undefined> {
   const seedDir = config.browser.authSeedProfileDir;
   await assertOracleAuthSeedProfileReady(config);
+  assertSafeOracleProfilePath(runtimeProfileDir, "runtime profile", config);
 
   await withAuthLock({ runtimeProfileDir, seedDir }, async () => {
     await rm(runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);
     await mkdir(dirname(runtimeProfileDir), { recursive: true, mode: 0o700 }).catch(() => undefined);
-    await spawnCp(profileCloneArgs(config, seedDir, runtimeProfileDir), { timeoutMs: options?.cpTimeoutMs ?? PROFILE_CLONE_TIMEOUT_MS });
+    if (config.browser.cloneStrategy === "apfs-clone" && process.platform === "darwin") {
+      await spawnCp(profileCloneArgs(config, seedDir, runtimeProfileDir), { timeoutMs: options?.cpTimeoutMs ?? PROFILE_CLONE_TIMEOUT_MS });
+    } else {
+      await copyDirectory(seedDir, runtimeProfileDir, { recursive: true, force: true, verbatimSymlinks: true });
+    }
     await removeChromiumProcessSingletonArtifacts(runtimeProfileDir);
   });
 
@@ -465,7 +532,7 @@ export interface OracleCleanupReport {
 
 async function closeRuntimeBrowserSession(runtimeSessionName: string): Promise<string | undefined> {
   return new Promise<string | undefined>((resolve) => {
-    const child = spawn(AGENT_BROWSER_BIN, ["--session", runtimeSessionName, "close"], { stdio: "ignore" });
+    const child = spawn(AGENT_BROWSER_BIN, ["--session", runtimeSessionName, "close"], { env: sweetCookieSafeStoragePasswordScrubbedEnv(), stdio: "ignore", shell: process.platform === "win32" });
     let settled = false;
     let timeout: NodeJS.Timeout | undefined;
     let timedOut = false;
@@ -479,15 +546,21 @@ async function closeRuntimeBrowserSession(runtimeSessionName: string): Promise<s
 
     timeout = setTimeout(() => {
       timedOut = true;
-      child.kill("SIGTERM");
+      killProcessTree(child);
       setTimeout(() => {
-        child.kill("SIGKILL");
+        killProcess(child);
         finish(`Timed out closing agent-browser session ${runtimeSessionName} after ${AGENT_BROWSER_CLOSE_TIMEOUT_MS}ms`);
       }, 2_000).unref?.();
     }, AGENT_BROWSER_CLOSE_TIMEOUT_MS);
     timeout.unref?.();
 
-    child.on("error", (error) => finish(`Failed to close agent-browser session ${runtimeSessionName}: ${error.message}`));
+    child.on("error", (error: NodeJS.ErrnoException) => {
+      if (error.code === "ENOENT") {
+        finish();
+        return;
+      }
+      finish(`Failed to close agent-browser session ${runtimeSessionName}: ${error.message}`);
+    });
     child.on("close", (code) => {
       if (timedOut || code === 0) finish();
       else finish(`agent-browser close exited with code ${code} for session ${runtimeSessionName}`);
@@ -510,9 +583,12 @@ export async function cleanupRuntimeArtifacts(runtime: {
   }
   if (runtime.runtimeProfileDir) {
     report.attempted.push("runtimeProfileDir");
-    await rm(runtime.runtimeProfileDir, { recursive: true, force: true }).catch((error: Error) => {
-      report.warnings.push(`Failed to remove runtime profile ${runtime.runtimeProfileDir}: ${error.message}`);
-    });
+    try {
+      assertSafeOracleProfilePath(runtime.runtimeProfileDir, "runtime profile");
+      await rm(runtime.runtimeProfileDir, { recursive: true, force: true });
+    } catch (error) {
+      report.warnings.push(`Failed to remove runtime profile ${runtime.runtimeProfileDir}: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
   if (runtime.conversationId) {
     report.attempted.push("conversationLease");
@@ -529,4 +605,3 @@ export async function cleanupRuntimeArtifacts(runtime: {
 
   return report;
 }
-

package/extensions/oracle/lib/tools.ts

@@ -4,9 +4,13 @@
 // Usage: Imported by the oracle extension entrypoint and sanity tests to register tools against the pi API.
 // Invariants/Assumptions: The pi runtime validates TypeBox schemas before execute, while execute owns semantic normalization.
 import { randomUUID } from "node:crypto";
-import { lstat, mkdtemp, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createReadStream } from "node:fs";
+import { lstat, mkdtemp, readdir, readlink, rename, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, join, posix } from "node:path";
+import { basename, dirname, join, posix } from "node:path";
+import { sweetCookieSafeStoragePasswordScrubbedEnv } from "../shared/browser-profile-helpers.mjs";
 import { runOracleAuthBootstrap } from "./auth.js";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -125,6 +129,8 @@ const DEFAULT_ARCHIVE_EXCLUDED_DIR_NAMES_ANYWHERE = new Set([
   ".pi",
   ".oracle-context",
   ".cursor",
+  ".artifacts",
+  ".crabbox",
   "node_modules",
   "target",
   ".venv",
@@ -386,6 +392,99 @@ function formatArchiveOversizeError(args: {
     .join("\n");
 }
 
+function writeOctal(value: number, width: number): Buffer {
+  const text = Math.max(0, Math.floor(value)).toString(8).slice(-(width - 1)).padStart(width - 1, "0") + "\0";
+  return Buffer.from(text, "ascii");
+}
+
+function writeTarName(header: Buffer, name: string): void {
+  const normalized = name.replaceAll("\\", "/");
+  const nameBytes = Buffer.byteLength(normalized);
+  if (nameBytes <= 100) {
+    header.write(normalized, 0, 100, "utf8");
+    return;
+  }
+  const parts = normalized.split("/");
+  const fileName = parts.pop() || "";
+  const prefix = parts.join("/");
+  if (Buffer.byteLength(fileName) > 100 || Buffer.byteLength(prefix) > 155) {
+    throw new Error(`archive path is too long for portable tar header: ${normalized}`);
+  }
+  header.write(fileName, 0, 100, "utf8");
+  header.write(prefix, 345, 155, "utf8");
+}
+
+function buildTarHeader(name: string, options: { mode: number; size: number; mtimeMs: number; type: "file" | "directory" | "symlink"; linkName?: string }): Buffer {
+  const header = Buffer.alloc(512);
+  writeTarName(header, options.type === "directory" && !name.endsWith("/") ? `${name}/` : name);
+  writeOctal(options.mode & 0o7777, 8).copy(header, 100);
+  writeOctal(0, 8).copy(header, 108);
+  writeOctal(0, 8).copy(header, 116);
+  writeOctal(options.size, 12).copy(header, 124);
+  writeOctal(Math.floor(options.mtimeMs / 1000), 12).copy(header, 136);
+  Buffer.from("        ", "ascii").copy(header, 148);
+  header[156] = options.type === "directory" ? 53 : options.type === "symlink" ? 50 : 48;
+  if (options.linkName) header.write(options.linkName.replaceAll("\\", "/"), 157, 100, "utf8");
+  header.write("ustar", 257, 6, "ascii");
+  header.write("00", 263, 2, "ascii");
+  let checksum = 0;
+  for (const byte of header) checksum += byte;
+  const checksumText = checksum.toString(8).padStart(6, "0");
+  header.write(`${checksumText}\0 `, 148, 8, "ascii");
+  return header;
+}
+
+async function writeChunk(stream: NodeJS.WritableStream, chunk: Buffer): Promise<void> {
+  if (!stream.write(chunk)) await once(stream, "drain");
+}
+
+async function writeWindowsTarArchiveToZstd(cwd: string, entries: string[], archivePath: string, timeout: AbortSignal): Promise<void> {
+  const scrubbedEnv = sweetCookieSafeStoragePasswordScrubbedEnv(process.env);
+  const zstd = spawn("zstd", ["-19", "-T0", "-f", "-o", archivePath], {
+    cwd,
+    env: scrubbedEnv,
+    stdio: ["pipe", "ignore", "pipe"],
+    signal: timeout,
+  });
+  let stderr = "";
+  zstd.stderr?.on("data", (chunk) => {
+    stderr += String(chunk);
+  });
+  try {
+    for (const entry of entries) {
+      const normalizedEntry = entry.replaceAll("\\", "/");
+      const absolutePath = join(cwd, normalizedEntry);
+      const info = await lstat(absolutePath);
+      if (info.isSymbolicLink()) {
+        await writeChunk(zstd.stdin, buildTarHeader(normalizedEntry, { mode: info.mode, size: 0, mtimeMs: info.mtimeMs, type: "symlink", linkName: await readlink(absolutePath) }));
+        continue;
+      }
+      if (info.isDirectory()) {
+        await writeChunk(zstd.stdin, buildTarHeader(normalizedEntry, { mode: info.mode, size: 0, mtimeMs: info.mtimeMs, type: "directory" }));
+        continue;
+      }
+      if (!info.isFile()) continue;
+      await writeChunk(zstd.stdin, buildTarHeader(normalizedEntry, { mode: info.mode, size: info.size, mtimeMs: info.mtimeMs, type: "file" }));
+      for await (const chunk of createReadStream(absolutePath)) {
+        await writeChunk(zstd.stdin, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      const padding = info.size % 512 === 0 ? 0 : 512 - (info.size % 512);
+      if (padding > 0) await writeChunk(zstd.stdin, Buffer.alloc(padding));
+    }
+    await writeChunk(zstd.stdin, Buffer.alloc(1024));
+    zstd.stdin.end();
+  } catch (error) {
+    zstd.stdin.destroy();
+    zstd.kill();
+    throw error;
+  }
+  const code = await new Promise<number | null>((resolve, reject) => {
+    zstd.once("error", reject);
+    zstd.once("close", resolve);
+  });
+  if (code !== 0) throw new Error(`zstd archive compression failed with status ${code}: ${stderr.trim()}`);
+}
+
 async function writeArchiveFile(
   cwd: string,
   entries: string[],
@@ -396,13 +495,32 @@ async function writeArchiveFile(
   await writeFile(listPath, Buffer.from(`${entries.join("\0")}\0`), { mode: 0o600 });
   await rm(archivePath, { force: true }).catch(() => undefined);
 
-  const { spawn } = await import("node:child_process");
+  if (process.platform === "win32") {
+    const timeoutController = new AbortController();
+    const timeout = setTimeout(() => timeoutController.abort(), options?.commandTimeoutMs ?? ARCHIVE_COMMAND_TIMEOUT_MS);
+    try {
+      await writeWindowsTarArchiveToZstd(cwd, entries, archivePath, timeoutController.signal);
+      return (await stat(archivePath)).size;
+    } catch (error) {
+      if (timeoutController.signal.aborted) {
+        throw new Error(`Oracle archive subprocess timed out after ${options?.commandTimeoutMs ?? ARCHIVE_COMMAND_TIMEOUT_MS}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
   await new Promise<void>((resolvePromise, rejectPromise) => {
-    const tar = spawn("tar", ["--null", "-cf", "-", "-T", listPath], {
-      cwd,
+    const scrubbedEnv = sweetCookieSafeStoragePasswordScrubbedEnv();
+    const tarArgs = ["--null", "-cf", "-", "-C", cwd, "-T", basename(listPath)];
+    const tar = spawn(process.env.PI_ORACLE_TEST_TAR_BIN ?? "tar", tarArgs, {
+      cwd: dirname(listPath),
+      env: scrubbedEnv,
       stdio: ["ignore", "pipe", "pipe"],
     });
-    const zstd = spawn("zstd", ["-19", "-T0", "-f", "-o", archivePath], {
+    const zstd = spawn(process.env.PI_ORACLE_TEST_ZSTD_BIN ?? "zstd", ["-19", "-T0", "-f", "-o", archivePath], {
+      env: scrubbedEnv,
       stdio: ["pipe", "ignore", "pipe"],
     });
 
@@ -832,6 +950,14 @@ function buildOracleToolErrorDetails(toolName: OracleToolErrorSource, error: unk
     };
   }
 
+  if (/^Oracle (auth seed profile|runtime profile|runtime profiles) path is unsafe: /.test(message)) {
+    return {
+      code: "oracle_profile_path_unsafe",
+      message,
+      suggestedNextStep: "Move browser.authSeedProfileDir/browser.runtimeProfilesDir outside real browser profile directories and retry.",
+    };
+  }
+
   if (message.startsWith("Oracle runtime profiles directory is not writable: ")) {
     return {
       code: "runtime_profiles_dir_unwritable",
@@ -964,10 +1090,10 @@ function buildOracleToolErrorDetails(toolName: OracleToolErrorSource, error: unk
 function buildOracleToolErrorResult(
   toolName: OracleToolName,
   error: unknown,
-  params: Record<string, unknown>,
+  params: unknown,
   options?: { job?: NonNullable<ReturnType<typeof readJob>>; jobDetails?: OracleToolJobDetailsOptions },
 ) {
-  const errorDetails = buildOracleToolErrorDetails(toolName, error, params);
+  const errorDetails = buildOracleToolErrorDetails(toolName, error, asRecord(params) ?? {});
   return {
     content: [{
       type: "text" as const,
@@ -1430,7 +1556,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
             await appendCleanupWarnings(job.id, cleanupReport.warnings).catch(() => undefined);
           }
           if (ctx.hasUI) refreshOracleStatus(ctx);
-          return buildOracleToolErrorResult("oracle_submit", error, params as unknown as Record<string, unknown>, {
+          return buildOracleToolErrorResult("oracle_submit", error, params, {
             job: latest ?? job,
             jobDetails: {
               queue: latest ? buildOracleQueueSnapshot(latest, latest.status === "queued" ? getQueuePosition(latest.id) : undefined) : undefined,
@@ -1443,7 +1569,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
           await rm(tempArchivePath, { force: true }).catch(() => undefined);
         }
       } catch (error) {
-        return buildOracleToolErrorResult("oracle_submit", error, params as unknown as Record<string, unknown>);
+        return buildOracleToolErrorResult("oracle_submit", error, params);
       }
     },
   });
@@ -1503,7 +1629,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
           },
         };
       } catch (error) {
-        return buildOracleToolErrorResult("oracle_read", error, params as unknown as Record<string, unknown>);
+        return buildOracleToolErrorResult("oracle_read", error, params);
       }
     },
   });
@@ -1538,7 +1664,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
           details: { job: redactJobDetails(cancelled, { queue: buildOracleQueueSnapshot(cancelled, cancelled.status === "queued" ? getQueuePosition(cancelled.id) : undefined) }) },
         };
       } catch (error) {
-        return buildOracleToolErrorResult("oracle_cancel", error, params as unknown as Record<string, unknown>);
+        return buildOracleToolErrorResult("oracle_cancel", error, params);
       }
     },
   });

package/extensions/oracle/shared/browser-profile-helpers.d.mts

@@ -0,0 +1,59 @@
+export type OraclePlatform = NodeJS.Platform;
+
+export interface BrowserPathOptions {
+  env?: NodeJS.ProcessEnv;
+  homeDir?: string;
+}
+
+export interface ExecutableSearchOptions {
+  pathValue?: string;
+  pathDelimiter?: string;
+}
+
+export const SWEET_COOKIE_SAFE_STORAGE_PASSWORD_ENV_NAMES: readonly [
+  "SWEET_COOKIE_CHROME_SAFE_STORAGE_PASSWORD",
+  "SWEET_COOKIE_BRAVE_SAFE_STORAGE_PASSWORD",
+  "SWEET_COOKIE_EDGE_SAFE_STORAGE_PASSWORD",
+];
+
+export function expandHomePath(value: string, homeDir?: string): string;
+export function normalizedAbsolutePath(value: string, options?: BrowserPathOptions): string;
+export function linuxConfigHome(options?: BrowserPathOptions): string;
+export function linuxChromiumCookieImportUserDataDirs(options?: BrowserPathOptions): string[];
+export function linuxBrowserSafetyUserDataDirs(options?: BrowserPathOptions): string[];
+export function browserUserDataDirsForPlatform(
+  platform?: OraclePlatform,
+  options?: BrowserPathOptions & { includeUnsupported?: boolean },
+): string[];
+export function defaultCloneStrategyForPlatform(platform?: OraclePlatform): "apfs-clone" | "copy";
+export function chromiumKeychainSupportedOnPlatform(platform?: OraclePlatform): boolean;
+export function chromeUserAgentPlatformToken(platform?: OraclePlatform): string | undefined;
+export function pathInsideOrEqual(childPath: string, parentPath: string): boolean;
+export function resolvePathThroughExistingAncestorsSync(pathValue: string): string | undefined;
+export function protectedCookieSourcePaths(cookieSources?: { chromeProfile?: string; chromeCookiePath?: string }): string[];
+export function knownBrowserUserDataPathMatch(
+  pathValue: string,
+  options?: BrowserPathOptions & {
+    platform?: OraclePlatform;
+    includeUnsupported?: boolean;
+    extraProtectedPaths?: string[];
+    cookieSources?: { chromeProfile?: string; chromeCookiePath?: string };
+  },
+): string | undefined;
+export function assertNotKnownBrowserUserDataPath(
+  pathValue: string,
+  label: string,
+  options?: BrowserPathOptions & {
+    platform?: OraclePlatform;
+    includeUnsupported?: boolean;
+    extraProtectedPaths?: string[];
+    cookieSources?: { chromeProfile?: string; chromeCookiePath?: string };
+  },
+): void;
+export function isExecutableFileSync(pathValue: string): boolean;
+export function findExecutableOnPathSync(names: readonly string[], options?: ExecutableSearchOptions): string | undefined;
+export function detectDefaultLinuxChromeExecutablePath(options?: ExecutableSearchOptions): string | undefined;
+export function detectDefaultLinuxCookieProfileSource(options?: BrowserPathOptions): string | undefined;
+export function detectDefaultBrowserProfileSource(platform?: OraclePlatform, options?: BrowserPathOptions): string;
+export function scrubSweetCookieSafeStoragePasswordEnv(env?: NodeJS.ProcessEnv): void;
+export function sweetCookieSafeStoragePasswordScrubbedEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;