@narumitw/pi-sync 0.51.0 → 0.52.0

package/dist/chunks/chunk-QOFMXPM5.ts

@@ -0,0 +1,735 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  isDeniedPath,
+  posixJoin,
+  readJsonIfExists,
+  safeJoin,
+  toPosix
+} from "./chunk-HUZ5CR4W.ts";
+
+// src/snapshot/snapshot.ts
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import os2 from "node:os";
+import path4 from "node:path";
+
+// src/snapshot/session-paths.ts
+import os from "node:os";
+import path2 from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+// src/snapshot/snapshot-paths.ts
+import path from "node:path";
+function expandHome(value) {
+  if (value === "~") return process.env.HOME ?? value;
+  if (value.startsWith("~/")) return path.join(process.env.HOME ?? "~", value.slice(2));
+  return value;
+}
+function sessionStorageRoot(root, configuredSessionDir2) {
+  return configuredSessionDir2 ? path.resolve(expandHome(configuredSessionDir2)) : path.resolve(root, "sessions");
+}
+
+// src/snapshot/session-paths.ts
+function sessionDirFromContext(ctx) {
+  const manager = ctx.sessionManager;
+  const usesDefaultSessionDir = manager.usesDefaultSessionDir;
+  if (typeof usesDefaultSessionDir === "function" && usesDefaultSessionDir.call(manager)) {
+    return void 0;
+  }
+  const getSessionDir = manager.getSessionDir;
+  return typeof getSessionDir === "function" ? getSessionDir.call(manager) : void 0;
+}
+async function configuredSessionDir() {
+  const settings = await readJsonIfExists(path2.join(agentDir(), "settings.json"));
+  return settings?.sessionDir ? expandSessionDir(settings.sessionDir) : void 0;
+}
+async function effectiveSessionRoot(ctx) {
+  return path2.resolve(sessionStorageRoot(agentDir(), sessionDirFromContext(ctx) ?? await configuredSessionDir()));
+}
+async function sessionDirForApply(ctx, snapshot) {
+  const contextSessionDir = sessionDirFromContext(ctx);
+  const localSessionDir = await configuredSessionDir();
+  if (contextSessionDir && path2.resolve(contextSessionDir) !== path2.resolve(localSessionDir ?? "")) {
+    return contextSessionDir;
+  }
+  return sessionDirFromSnapshot(snapshot) ?? contextSessionDir;
+}
+function requireStableMergeSessionRoot(before, after) {
+  const root = agentDir();
+  if (path2.resolve(sessionStorageRoot(root, sessionDirFromSnapshot(before))) !== path2.resolve(sessionStorageRoot(root, sessionDirFromSnapshot(after)))) {
+    throw new Error(
+      "Merged transfer changes the session root; no local apply or baseline acceptance is allowed. Review /sync diff and choose an explicit push or pull direction."
+    );
+  }
+}
+function sessionDirFromSnapshot(snapshot) {
+  const settingsFile = snapshot.files.find((file) => file.path === "settings.json");
+  if (!settingsFile) return void 0;
+  let settings;
+  try {
+    settings = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(
+        decodeBase64Strict(settingsFile.contentBase64, settingsFile.path)
+      )
+    );
+  } catch {
+    throw new Error("Merged settings cannot be parsed; review a directional recovery.");
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings))
+    throw new Error("Merged settings must be a JSON object; review a directional recovery.");
+  const sessionDir = settings.sessionDir;
+  if (sessionDir !== void 0 && typeof sessionDir !== "string")
+    throw new Error("Merged sessionDir must be a string; review a directional recovery.");
+  return sessionDir ? expandSessionDir(sessionDir) : void 0;
+}
+function decodeBase64Strict(value, filePath) {
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 !== 0) {
+    throw new Error(`Invalid base64 content in snapshot file: ${filePath}`);
+  }
+  return Buffer.from(value, "base64");
+}
+function agentDir() {
+  return getAgentDir();
+}
+function expandSessionDir(value) {
+  return value === "~" || value.startsWith("~/") ? path2.join(os.homedir(), value.slice(2)) : value;
+}
+function snapshotOptionsForContext(ctx, config) {
+  return {
+    include: config.include,
+    sessionDir: sessionDirFromContext(ctx)
+  };
+}
+
+// src/sync/sync-policy.ts
+import path3 from "node:path";
+var BUILT_IN_SYNC_ROOTS = [
+  "settings.json",
+  "keybindings.json",
+  "models.json",
+  "AGENTS.md",
+  "APPEND_SYSTEM.md",
+  "skills",
+  "prompts",
+  "themes",
+  "extensions"
+];
+var DEFAULT_SYNC_INCLUDE = [...BUILT_IN_SYNC_ROOTS];
+var SNAPSHOT_SELECTION_VERSION = 1;
+var MAX_SYNC_INCLUDE_ITEMS = 1024;
+var MAX_SYNC_INCLUDE_PATH_BYTES = 4096;
+var MAX_SYNC_INCLUDE_TOTAL_BYTES = 256 * 1024;
+var BUILT_IN_BY_LOWER = new Map(
+  BUILT_IN_SYNC_ROOTS.map((fileName) => [fileName.toLowerCase(), fileName])
+);
+var TOP_LEVEL_FILE_PATHS = new Map(
+  BUILT_IN_SYNC_ROOTS.filter((fileName) => fileName.includes(".")).map((fileName) => [
+    fileName.toLowerCase(),
+    fileName
+  ])
+);
+var TOP_LEVEL_DIRS = new Set(BUILT_IN_SYNC_ROOTS.filter((fileName) => !fileName.includes(".")));
+var RESERVED_TOP_LEVEL_NAMES = /* @__PURE__ */ new Set([...BUILT_IN_BY_LOWER.keys(), "sessions"]);
+function normalizeSyncInclude(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid pi-sync settings: sync.include must be an array.");
+  }
+  if (value.length > MAX_SYNC_INCLUDE_ITEMS) {
+    throw new Error(`Invalid pi-sync settings: sync.include has too many items; limit: ${MAX_SYNC_INCLUDE_ITEMS}.`);
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pathRoot = { children: /* @__PURE__ */ new Map() };
+  let totalBytes = 0;
+  for (const item of value) {
+    if (typeof item !== "string") {
+      throw new Error("Invalid pi-sync settings: sync.include items must be strings.");
+    }
+    const itemBytes = Buffer.byteLength(item, "utf8");
+    if (itemBytes > MAX_SYNC_INCLUDE_PATH_BYTES) {
+      throw new Error(
+        `Invalid pi-sync settings: sync.include item is too long; limit: ${MAX_SYNC_INCLUDE_PATH_BYTES} bytes.`
+      );
+    }
+    totalBytes += itemBytes;
+    if (totalBytes > MAX_SYNC_INCLUDE_TOTAL_BYTES) {
+      throw new Error(
+        `Invalid pi-sync settings: sync.include is too large; limit: ${MAX_SYNC_INCLUDE_TOTAL_BYTES} bytes.`
+      );
+    }
+    const trimmed = item.trim();
+    const builtIn = BUILT_IN_BY_LOWER.get(trimmed.toLowerCase());
+    const normalized = builtIn ?? (trimmed.toLowerCase() === "sessions" ? "sessions" : trimmed);
+    if (!builtIn && normalized !== "sessions") validateAgentRelativeInclude(normalized);
+    const identity = normalized.toLowerCase();
+    if (seen.has(identity)) {
+      throw new Error(`Invalid pi-sync settings: duplicate sync.include item: ${item}`);
+    }
+    addIncludePath(pathRoot, identity, item);
+    seen.add(identity);
+    result.push(normalized);
+  }
+  return result;
+}
+function addIncludePath(root, identity, source) {
+  let node = root;
+  for (const segment of identity.split("/")) {
+    if (node.selected !== void 0) throwOverlappingInclude(source);
+    let child = node.children.get(segment);
+    if (!child) {
+      child = { children: /* @__PURE__ */ new Map() };
+      node.children.set(segment, child);
+    }
+    node = child;
+  }
+  if (node.children.size > 0) throwOverlappingInclude(source);
+  node.selected = identity;
+}
+function throwOverlappingInclude(item) {
+  throw new Error(`Invalid pi-sync settings: overlapping sync.include items are ambiguous: ${item}`);
+}
+function validateAgentRelativeInclude(value) {
+  const normalized = toPosix(value);
+  const topLevel = normalized.split("/")[0]?.toLowerCase();
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || path3.posix.isAbsolute(normalized) || normalized.includes("\\") || path3.posix.normalize(normalized) !== normalized || // biome-ignore lint/suspicious/noControlCharactersInRegex: Include paths cannot contain controls.
+  /[\u0000-\u001f\u007f-\u009f]/u.test(normalized)) {
+    throw new Error(`Invalid pi-sync settings: sync.include item must be a safe agent-relative path: ${value}`);
+  }
+  if (isDeniedPath(normalized)) {
+    throw new Error(`Invalid pi-sync settings: ${value} cannot be synced.`);
+  }
+  if (topLevel && RESERVED_TOP_LEVEL_NAMES.has(topLevel)) {
+    throw new Error(
+      `Invalid pi-sync settings: use the canonical ${topLevel} root instead of a nested sync.include path.`
+    );
+  }
+}
+function portableSnapshotSelection(value) {
+  const selection = value;
+  if (!selection || typeof selection !== "object" || Array.isArray(selection) || selection.version !== SNAPSHOT_SELECTION_VERSION || !Object.hasOwn(selection, "include") || Object.keys(selection).some((key) => key !== "version" && key !== "include")) {
+    throw new Error("Invalid snapshot selection policy.");
+  }
+  return {
+    version: SNAPSHOT_SELECTION_VERSION,
+    include: normalizeSyncInclude(selection.include)
+  };
+}
+function snapshotSelectionInclude(snapshot) {
+  return snapshot.selection === void 0 ? void 0 : portableSnapshotSelection(snapshot.selection).include;
+}
+function selectionForSnapshot(include) {
+  return { version: SNAPSHOT_SELECTION_VERSION, include: normalizeSyncInclude(include) };
+}
+function sameSyncInclude(left, right) {
+  const normalizedLeft = normalizeSyncInclude(left);
+  const normalizedRight = normalizeSyncInclude(right);
+  return normalizedLeft.length === normalizedRight.length && normalizedLeft.every((item, index) => item === normalizedRight[index]);
+}
+function compareSyncInclude(local, remote) {
+  const localInclude = normalizeSyncInclude(local);
+  const remoteInclude = normalizeSyncInclude(remote);
+  const localSet = new Set(localInclude);
+  const remoteSet = new Set(remoteInclude);
+  return {
+    same: sameSyncInclude(localInclude, remoteInclude),
+    remoteOnly: remoteInclude.filter((item) => !localSet.has(item)),
+    localOnly: localInclude.filter((item) => !remoteSet.has(item))
+  };
+}
+function inspectRemoteSelection(localInclude, snapshot) {
+  const remoteInclude = snapshotSelectionInclude(snapshot);
+  if (!remoteInclude) {
+    return { kind: "legacy", discovered: discoverLegacySnapshotInclude(snapshot) };
+  }
+  const comparison = compareSyncInclude(localInclude, remoteInclude);
+  return comparison.same ? { kind: "same", include: remoteInclude } : { kind: "different", include: remoteInclude, ...comparison };
+}
+var RemoteSelectionMismatchError = class extends Error {
+  decision;
+  setupName;
+  localInclude;
+  remoteInclude;
+  constructor(setupName, localInclude, remoteInclude, configIdentity = JSON.stringify([setupName, normalizeSyncInclude(localInclude)])) {
+    const local = normalizeSyncInclude(localInclude);
+    const remote = normalizeSyncInclude(remoteInclude);
+    super(formatRemoteSelectionMismatch(setupName, local, remote));
+    this.name = "RemoteSelectionMismatchError";
+    this.setupName = setupName;
+    this.localInclude = local;
+    this.remoteInclude = remote;
+    this.decision = {
+      setupName,
+      configIdentity,
+      localInclude: [...local],
+      remoteInclude: [...remote]
+    };
+  }
+};
+function remoteSelectionMismatch(config, remoteInclude, configIdentity) {
+  return new RemoteSelectionMismatchError(config.setupName, config.include, remoteInclude, configIdentity);
+}
+function formatRemoteSelectionMismatch(setupName, localInclude, remoteInclude) {
+  const comparison = compareSyncInclude(localInclude, remoteInclude);
+  const lines = [
+    `Synced content differs for sync setup \u201C${stripTerminalControls(setupName)}\u201D.`,
+    `Remote-only: ${comparison.remoteOnly.join(", ") || "none"}`,
+    `This-device-only: ${comparison.localOnly.join(", ") || "none"}`
+  ];
+  if (comparison.remoteOnly.length === 0 && comparison.localOnly.length === 0) {
+    lines.push(
+      "Only ordering differs.",
+      `Remote order: ${remoteInclude.join(", ") || "none"}`,
+      `This device order: ${localInclude.join(", ") || "none"}`
+    );
+  }
+  lines.push("Run /sync in TUI to review both content lists and choose what happens next.");
+  return lines.join("\n");
+}
+function stripTerminalControls(value) {
+  return value.replace(/[\u0000-\u001f\u007f-\u009f]/gu, "?");
+}
+function discoverLegacySnapshotInclude(snapshot) {
+  const builtIns = /* @__PURE__ */ new Set();
+  const custom = /* @__PURE__ */ new Set();
+  let sessions = false;
+  for (const file of snapshot.files) {
+    const normalized = toPosix(file.path);
+    if (!normalized || file.path.includes("\\") || normalized.length > 4096 || normalized.startsWith("../") || path3.posix.isAbsolute(normalized) || path3.posix.normalize(normalized) !== normalized || // biome-ignore lint/suspicious/noControlCharactersInRegex: Ignore unsafe legacy paths.
+    /[\u0000-\u001f\u007f-\u009f]/u.test(normalized) || isDeniedPath(normalized)) {
+      continue;
+    }
+    const [topLevel, ...rest] = normalized.split("/");
+    if (!topLevel) continue;
+    if (topLevel === "sessions" && rest.length > 0) {
+      sessions = true;
+      continue;
+    }
+    const builtIn = BUILT_IN_BY_LOWER.get(topLevel.toLowerCase());
+    if (builtIn && (TOP_LEVEL_DIRS.has(builtIn) && rest.length > 0 || !TOP_LEVEL_DIRS.has(builtIn) && rest.length === 0)) {
+      builtIns.add(builtIn);
+      continue;
+    }
+    if (isSafeCustomIncludePath(topLevel)) custom.add(topLevel);
+  }
+  return [
+    ...BUILT_IN_SYNC_ROOTS.filter((item) => builtIns.has(item)),
+    ...[...custom].sort((left, right) => left.localeCompare(right)),
+    ...sessions ? ["sessions"] : []
+  ];
+}
+function syncIncludeSelection(value) {
+  const include = normalizeSyncInclude(value);
+  const builtIns = include.filter((item) => BUILT_IN_BY_LOWER.has(item.toLowerCase()));
+  const custom = include.filter((item) => item !== "sessions" && !BUILT_IN_BY_LOWER.has(item.toLowerCase()));
+  return { include, builtIns, custom, sessions: include.includes("sessions") };
+}
+function customIncludePathsByLower(value) {
+  return new Map(syncIncludeSelection(value).custom.map((relativePath) => [relativePath.toLowerCase(), relativePath]));
+}
+function includeFromSelectionConfig(config) {
+  if (config.include !== void 0) return normalizeSyncInclude(config.include);
+  return [
+    ...normalizeSyncFiles(config.syncFiles),
+    ...normalizeExtraFiles(config.extraFiles),
+    ...config.syncSessions ? ["sessions"] : []
+  ];
+}
+function isConfiguredSnapshotPath(relativePath, config, _legacyExtraFiles) {
+  const normalized = toPosix(relativePath);
+  const selection = syncIncludeSelection(includeFromSelectionConfig(config));
+  if (normalized.startsWith("sessions/")) return selection.sessions;
+  const lower = normalized.toLowerCase();
+  if (!normalized.includes("/")) {
+    const builtIn = BUILT_IN_BY_LOWER.get(lower);
+    if (builtIn) return selection.builtIns.includes(builtIn) && !TOP_LEVEL_DIRS.has(builtIn);
+  }
+  const topLevel = normalized.slice(0, normalized.indexOf("/"));
+  if (selection.builtIns.includes(topLevel) && TOP_LEVEL_DIRS.has(topLevel)) {
+    return true;
+  }
+  return selection.custom.some((candidate) => {
+    const candidateLower = candidate.toLowerCase();
+    return lower === candidateLower || lower.startsWith(`${candidateLower}/`);
+  });
+}
+function canonicalSnapshotPathForConfig(relativePath, includePaths) {
+  const normalized = toPosix(relativePath);
+  const lower = normalized.toLowerCase();
+  return TOP_LEVEL_FILE_PATHS.get(lower) ?? includePaths.get(lower) ?? normalized;
+}
+function isPreservableUnmanagedSnapshotPath(relativePath) {
+  const normalized = toPosix(relativePath);
+  if (!normalized || isDeniedPath(normalized)) return false;
+  if (normalized.startsWith("sessions/")) return normalized.endsWith(".jsonl");
+  if (!normalized.includes("/")) {
+    const lower = normalized.toLowerCase();
+    return TOP_LEVEL_FILE_PATHS.has(lower) || !RESERVED_TOP_LEVEL_NAMES.has(lower);
+  }
+  return true;
+}
+function isSafeCustomIncludePath(relativePath) {
+  try {
+    validateAgentRelativeInclude(relativePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeSyncFiles(value) {
+  if (value === void 0) return [...DEFAULT_SYNC_INCLUDE];
+  if (Array.isArray(value)) {
+    return normalizeSyncInclude(value).filter(
+      (item) => BUILT_IN_BY_LOWER.has(item.toLowerCase())
+    );
+  }
+  throw new Error("Invalid pi-sync settings: expected an include array.");
+}
+function normalizeExtraFiles(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && isSafeCustomIncludePath(item));
+}
+
+// src/snapshot/snapshot.ts
+var VERSION = 1;
+var TOP_LEVEL_FILES = DEFAULT_SYNC_INCLUDE.filter((name) => name.includes("."));
+var TOP_LEVEL_DIRS2 = new Set(DEFAULT_SYNC_INCLUDE.filter((name) => !name.includes(".")));
+var SECRET_PATTERNS = [
+  /AWS_SECRET_ACCESS_KEY\s*[=:]\s*['"]?[A-Za-z0-9/+]{35,}/i,
+  /(ANTHROPIC|OPENAI|GEMINI|GOOGLE|FIRECRAWL|GITHUB|CLOUDFLARE|R2|S3)_[A-Z0-9_]*(KEY|TOKEN|SECRET)\s*[=:]\s*['"]?[^\s'"]{12,}/i,
+  /sk-ant-[A-Za-z0-9_-]{20,}/,
+  /sk-[A-Za-z0-9]{20,}/,
+  /gh[pousr]_[A-Za-z0-9_]{20,}/
+];
+function selectTopLevelFileEntry(entries, fileName) {
+  const exact = entries.find((entry) => entry.isFile() && entry.name === fileName);
+  if (exact) return exact;
+  const lower = fileName.toLowerCase();
+  return entries.filter((entry) => entry.isFile() && entry.name.toLowerCase() === lower).sort((left, right) => left.name.localeCompare(right.name))[0];
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function isSafeSnapshotPath(relativePath) {
+  if (relativePath.includes("\\")) return false;
+  const normalized = toPosix(relativePath);
+  return Boolean(normalized) && normalized !== "." && normalized !== ".." && !normalized.startsWith("../") && !path4.posix.isAbsolute(normalized) && path4.posix.normalize(normalized) === normalized && !isDeniedPath(normalized);
+}
+function snapshotsMatch(left, right) {
+  const leftHashes = new Map(left.files.map((file) => [file.path, file.sha256]));
+  const rightHashes = new Map(right.files.map((file) => [file.path, file.sha256]));
+  return left.syncSessions === right.syncSessions && sameOptionalInclude(snapshotSelectionInclude(left), snapshotSelectionInclude(right)) && leftHashes.size === rightHashes.size && [...leftHashes].every(([filePath, hash]) => rightHashes.get(filePath) === hash);
+}
+function snapshotId() {
+  return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+}
+function regenerateSnapshotIdentity(snapshot) {
+  return {
+    ...snapshot,
+    id: snapshotId(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    machine: os2.hostname()
+  };
+}
+async function createSnapshot(profile, options = {}) {
+  options.signal?.throwIfAborted();
+  const include = effectiveInclude(options);
+  const syncSessions = include.includes("sessions");
+  const sessionDir = options.sessionDir ?? await configuredSessionDir();
+  options.signal?.throwIfAborted();
+  const files = await collectFiles(agentDir(), { include, sessionDir, signal: options.signal });
+  options.signal?.throwIfAborted();
+  return {
+    version: VERSION,
+    id: snapshotId(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    machine: os2.hostname(),
+    profile,
+    syncSessions,
+    selection: selectionForSnapshot(include),
+    files
+  };
+}
+function effectiveInclude(options) {
+  if (options.include) return options.include;
+  return [
+    ...normalizeSyncFiles(options.syncFiles),
+    ...normalizeExtraFiles(options.extraFiles),
+    ...options.syncSessions ? ["sessions"] : []
+  ];
+}
+async function collectFiles(root, options = {}) {
+  const signal = options.signal;
+  signal?.throwIfAborted();
+  const results = [];
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  signal?.throwIfAborted();
+  const selection = syncIncludeSelection(effectiveInclude(options));
+  const selectedFiles = new Set(selection.builtIns);
+  for (const entry of entries) {
+    if (entry.isDirectory() && TOP_LEVEL_DIRS2.has(entry.name) && selectedFiles.has(entry.name)) {
+      await collectDirectory(results, root, entry.name, { signal });
+    }
+  }
+  for (const fileName of TOP_LEVEL_FILES) {
+    if (!selectedFiles.has(fileName)) continue;
+    const entry = selectTopLevelFileEntry(entries, fileName);
+    if (entry) await addFile(results, root, entry.name, fileName, signal);
+  }
+  for (const relativePath of selection.custom) {
+    await collectIncludedPath(results, root, relativePath, signal);
+  }
+  if (selection.sessions) {
+    try {
+      await collectDirectory(results, sessionStorageRoot(root, options.sessionDir), "", {
+        sessionsOnly: true,
+        virtualPrefix: "sessions",
+        signal
+      });
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  signal?.throwIfAborted();
+  return results.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function collectIncludedPath(results, root, relativePath, signal) {
+  signal?.throwIfAborted();
+  const absolutePath = safeJoin(root, relativePath);
+  try {
+    const stat = await fs.lstat(absolutePath);
+    signal?.throwIfAborted();
+    if (stat.isFile()) await addFile(results, root, relativePath, relativePath, signal);
+    else if (stat.isDirectory()) await collectDirectory(results, root, relativePath, { signal });
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    if (!relativePath.includes("/")) {
+      const entries = await fs.readdir(root, { withFileTypes: true });
+      signal?.throwIfAborted();
+      const entry = selectTopLevelFileEntry(entries, relativePath);
+      if (entry) await addFile(results, root, entry.name, relativePath, signal);
+    }
+  }
+}
+async function collectDirectory(results, root, relativeDirectory, options = {}) {
+  options.signal?.throwIfAborted();
+  const absoluteDirectory = path4.join(root, relativeDirectory);
+  for (const entry of await fs.readdir(absoluteDirectory, { withFileTypes: true })) {
+    options.signal?.throwIfAborted();
+    const relativePath = relativeDirectory ? posixJoin(relativeDirectory, entry.name) : entry.name;
+    const snapshotPath = options.virtualPrefix ? posixJoin(options.virtualPrefix, relativePath) : relativePath;
+    if (isDeniedPath(snapshotPath)) continue;
+    if (entry.isDirectory()) {
+      await collectDirectory(results, root, relativePath, options);
+    } else if (entry.isFile() && (!options.sessionsOnly || isSessionFilePath(snapshotPath))) {
+      await addFile(results, root, relativePath, snapshotPath, options.signal);
+    }
+  }
+}
+async function addFile(results, root, relativePath, snapshotPath = relativePath, signal) {
+  signal?.throwIfAborted();
+  if (!isSafeSnapshotPath(snapshotPath)) return;
+  const absolutePath = safeJoin(root, relativePath);
+  const content = await fs.readFile(absolutePath, { signal });
+  signal?.throwIfAborted();
+  results.push({
+    path: snapshotPath,
+    contentBase64: content.toString("base64"),
+    sha256: sha256(content)
+  });
+}
+function isSessionPath(relativePath) {
+  return toPosix(relativePath).startsWith("sessions/");
+}
+function isSessionFilePath(relativePath) {
+  const normalized = toPosix(relativePath);
+  return isSessionPath(normalized) && normalized.endsWith(".jsonl");
+}
+function sessionSnapshotPathFromAbsolute(sessionFile, configuredSessionDir2) {
+  const relativePath = toPosix(path4.relative(sessionStorageRoot(agentDir(), configuredSessionDir2), sessionFile));
+  if (!relativePath || relativePath.startsWith("../") || path4.posix.isAbsolute(relativePath)) {
+    return void 0;
+  }
+  const snapshotPath = posixJoin("sessions", relativePath);
+  return isSessionFilePath(snapshotPath) ? snapshotPath : void 0;
+}
+function snapshotTarget(root, relativePath, configuredSessionDir2) {
+  if (isSessionPath(relativePath)) {
+    return safeJoin(sessionStorageRoot(root, configuredSessionDir2), relativePath.slice("sessions/".length));
+  }
+  return safeJoin(root, relativePath);
+}
+function snapshotIncludesSessions(snapshot) {
+  return snapshot.syncSessions === true || snapshotSelectionInclude(snapshot)?.includes("sessions") === true || snapshot.files.some((file) => isSessionPath(file.path));
+}
+function filterSnapshotForConfigPolicy(snapshot, config, options = {}) {
+  const include = includeFromSelectionConfig(config);
+  const includePaths = customIncludePathsByLower(include);
+  const filtered = {
+    ...snapshot,
+    syncSessions: include.includes("sessions") ? snapshot.syncSessions : false,
+    selection: selectionForSnapshot(include),
+    files: canonicalizeSnapshotFilesForConfig(snapshot.files, config, includePaths)
+  };
+  if (!options.regenerateId || snapshotsMatch(snapshot, filtered)) return filtered;
+  return {
+    ...filtered,
+    id: snapshotId(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    machine: os2.hostname()
+  };
+}
+function canonicalizeSnapshotFilesForConfig(files, config, includePaths) {
+  const configuredFiles = [];
+  const extraCandidates = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const normalized = toPosix(file.path);
+    if (!isSafeSnapshotPath(file.path) || !isConfiguredSnapshotPath(normalized, config)) {
+      continue;
+    }
+    if (normalized.includes("/")) {
+      configuredFiles.push(normalized === file.path ? file : { ...file, path: normalized });
+      continue;
+    }
+    const topLevelPath = canonicalSnapshotPathForConfig(normalized, includePaths);
+    const candidate = {
+      exact: normalized === topLevelPath,
+      file: { ...file, path: topLevelPath },
+      originalPath: normalized
+    };
+    const current = extraCandidates.get(topLevelPath.toLowerCase());
+    if (!current || isPreferredExtraCandidate(candidate, current)) {
+      extraCandidates.set(topLevelPath.toLowerCase(), candidate);
+    }
+  }
+  return [...configuredFiles, ...[...extraCandidates.values()].map((candidate) => candidate.file)].sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
+}
+function isPreferredExtraCandidate(left, right) {
+  if (left.exact !== right.exact) return left.exact;
+  return left.originalPath.localeCompare(right.originalPath) < 0;
+}
+function snapshotWithoutSessions(snapshot) {
+  const files = snapshot.files.filter((file) => !isSessionPath(file.path));
+  const include = snapshotSelectionInclude(snapshot)?.filter((item) => item !== "sessions");
+  if (files.length === snapshot.files.length && snapshot.syncSessions !== true && include?.length === snapshot.selection?.include.length) {
+    return snapshot;
+  }
+  return {
+    ...snapshot,
+    id: snapshotId(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    machine: os2.hostname(),
+    syncSessions: false,
+    ...include ? { selection: selectionForSnapshot(include) } : {},
+    files
+  };
+}
+function scanSnapshot(snapshot) {
+  const findings = [];
+  for (const file of snapshot.files) {
+    const content = Buffer.from(file.contentBase64, "base64");
+    if (content.includes(0)) continue;
+    const text = content.toString("utf8");
+    for (const pattern of SECRET_PATTERNS) {
+      if (pattern.test(text)) {
+        findings.push(file.path);
+        break;
+      }
+    }
+  }
+  return findings;
+}
+function mergeRemotePreservedFiles(local, remote, config) {
+  const localPathNames = new Set(local.files.map((file) => file.path.toLowerCase()));
+  const preservedPathNames = /* @__PURE__ */ new Set();
+  const preserved = remote.files.filter((file) => {
+    const normalized = toPosix(file.path);
+    const lower = normalized.toLowerCase();
+    if (localPathNames.has(lower) || preservedPathNames.has(lower) || !isSafeSnapshotPath(file.path) || isConfiguredSnapshotPath(normalized, config) || !isPreservableUnmanagedSnapshotPath(normalized)) {
+      return false;
+    }
+    preservedPathNames.add(lower);
+    return true;
+  });
+  if (preserved.length === 0) return local;
+  return {
+    ...local,
+    id: snapshotId(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    machine: os2.hostname(),
+    syncSessions: snapshotIncludesSessions(local) || snapshotIncludesSessions(remote),
+    files: [...local.files, ...preserved].sort((left, right) => left.path.localeCompare(right.path))
+  };
+}
+function mergeRemoteSessionFiles(local, remote) {
+  const remoteSessions = remote.files.filter((file) => {
+    const normalized = toPosix(file.path);
+    return isSessionFilePath(normalized) && isSafeSnapshotPath(file.path);
+  });
+  if (remoteSessions.length === 0 && !snapshotIncludesSessions(remote)) return local;
+  const localInclude = snapshotSelectionInclude(local);
+  return {
+    ...local,
+    id: snapshotId(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    machine: os2.hostname(),
+    syncSessions: true,
+    ...localInclude ? {
+      selection: selectionForSnapshot(
+        localInclude.includes("sessions") ? localInclude : [...localInclude, "sessions"]
+      )
+    } : {},
+    files: [...local.files.filter((file) => !isSessionPath(file.path)), ...remoteSessions].sort(
+      (left, right) => left.path.localeCompare(right.path)
+    )
+  };
+}
+function sameOptionalInclude(left, right) {
+  if (!left || !right) return left === right;
+  return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+
+export {
+  sessionStorageRoot,
+  sessionDirFromContext,
+  configuredSessionDir,
+  effectiveSessionRoot,
+  sessionDirForApply,
+  requireStableMergeSessionRoot,
+  agentDir,
+  expandSessionDir,
+  snapshotOptionsForContext,
+  BUILT_IN_SYNC_ROOTS,
+  DEFAULT_SYNC_INCLUDE,
+  normalizeSyncInclude,
+  portableSnapshotSelection,
+  snapshotSelectionInclude,
+  sameSyncInclude,
+  compareSyncInclude,
+  inspectRemoteSelection,
+  RemoteSelectionMismatchError,
+  remoteSelectionMismatch,
+  formatRemoteSelectionMismatch,
+  syncIncludeSelection,
+  customIncludePathsByLower,
+  includeFromSelectionConfig,
+  isConfiguredSnapshotPath,
+  canonicalSnapshotPathForConfig,
+  isSafeCustomIncludePath,
+  regenerateSnapshotIdentity,
+  createSnapshot,
+  collectFiles,
+  isSessionPath,
+  isSessionFilePath,
+  sessionSnapshotPathFromAbsolute,
+  snapshotTarget,
+  snapshotIncludesSessions,
+  filterSnapshotForConfigPolicy,
+  snapshotWithoutSessions,
+  scanSnapshot,
+  mergeRemotePreservedFiles,
+  mergeRemoteSessionFiles
+};
+//# sourceMappingURL=chunk-QOFMXPM5.ts.map