@narumitw/pi-sync 0.49.9 → 0.49.11

package/dist/chunks/sync-operations-MPAFVVHA.ts

@@ -0,0 +1,1112 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  createSyncBackend,
+  formatRemoteSelectionStatus,
+  readSnapshotForHead,
+  requireCompatibleRemoteSelection
+} from "./chunk-FR6CVXAL.js";
+import {
+  applySnapshotTransaction,
+  recoverPendingSnapshotTransactions
+} from "./chunk-3NDD5QPM.js";
+import {
+  inspectLock,
+  isLockGuardHeld,
+  isStaleLock,
+  withLock
+} from "./chunk-LJDSHNS3.js";
+import {
+  SyncDecisionRequiredError,
+  countPreservedRemoteFiles,
+  errorMessage,
+  formatDiff,
+  formatPullSummary,
+  formatPushSummary,
+  formatRollbackSummary,
+  formatSnapshotOnlyDiff,
+  publicationCapabilityDescription,
+  safeTerminalText
+} from "./chunk-W64NEHXT.js";
+import {
+  canPullRemoteSessionsOnFirstSync,
+  canPullRemoteSettingsOnFirstSync,
+  fileHashMap,
+  hasLocalChanges,
+  hasRemoteChanges,
+  remoteChangedSinceState,
+  sameHashes,
+  shouldRefreshSyncedState,
+  snapshotHashesMatchState,
+  snapshotsMatch,
+  syncPolicyChanged
+} from "./chunk-RGJ6SOYR.js";
+import {
+  createSnapshot,
+  filterSnapshotForConfigPolicy,
+  isSessionFilePath,
+  isSessionPath,
+  mergeRemotePreservedFiles,
+  regenerateSnapshotIdentity,
+  scanSnapshot,
+  sessionSnapshotPathFromAbsolute,
+  sessionStorageRoot,
+  snapshotIncludesSessions,
+  snapshotTarget,
+  snapshotWithoutSessions
+} from "./chunk-EWX3TPLQ.js";
+import {
+  agentDir,
+  loadConfig,
+  readStateForConfig,
+  sessionDirForApply,
+  syncConfigReviewFingerprint,
+  syncConfigReviewIdentity,
+  syncSessionsWarnings,
+  writeStateForConfig
+} from "./chunk-APZVBSM6.js";
+import {
+  encodeSnapshot
+} from "./chunk-HGV24P4T.js";
+import {
+  stateDir
+} from "./chunk-F5QL2GPY.js";
+import {
+  expectedRemoteHead
+} from "./chunk-5MQ76BK5.js";
+import {
+  assertWithinRoot,
+  includeFromSelectionConfig,
+  inspectRemoteSelection,
+  isDeniedPath,
+  isPathInside,
+  parentPaths,
+  remoteSelectionMismatch,
+  safeJoin,
+  toPosix
+} from "./chunk-YQ6UW7IF.js";
+
+// src/sync-operations.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+
+// src/snapshot-apply.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function fileHashMap2(snapshot) {
+  return Object.fromEntries(snapshot.files.map((file) => [file.path, file.sha256]));
+}
+async function applySnapshot(snapshot, protectedRelativePaths = /* @__PURE__ */ new Set(), options = {}) {
+  const root = agentDir();
+  const { sessionDir } = options;
+  await recoverPendingSnapshotTransactions();
+  const current = await createSnapshot(snapshot.profile, {
+    ...options,
+    ...options.include === void 0 ? { syncSessions: snapshotIncludesSessions(snapshot) } : {},
+    sessionDir
+  });
+  const plan = await addTopLevelCaseVariantDeletes(
+    root,
+    protectSnapshotApplyPlan(
+      root,
+      preflightSnapshotApply(root, snapshot, current, { sessionDir }),
+      protectedRelativePaths,
+      sessionDir
+    ),
+    snapshot
+  );
+  await preflightSnapshotMutations(root, plan, sessionDir);
+  await applySnapshotTransaction(plan, { sessionDir });
+  return appliedFileHashMap(snapshot, current, protectedRelativePaths);
+}
+function preflightSnapshotApply(root, snapshot, current, options = {}) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  const remotePaths = /* @__PURE__ */ new Set();
+  const writes = [];
+  const deletes = [];
+  for (const file of snapshot.files) {
+    const normalized = toPosix(file.path);
+    if (!isSafeSnapshotPath(file.path)) {
+      throw new Error(`Unsafe path in snapshot: ${file.path}`);
+    }
+    if (isSessionPath(normalized) && !isSessionFilePath(normalized)) {
+      throw new Error(`Unsafe session path in snapshot: ${file.path}`);
+    }
+    if (seenPaths.has(normalized)) throw new Error(`Duplicate path in snapshot: ${normalized}`);
+    seenPaths.add(normalized);
+    remotePaths.add(normalized);
+    const target = snapshotTarget(root, normalized, options.sessionDir);
+    const content = decodeBase64Strict(file.contentBase64, normalized);
+    if (sha256(content) !== file.sha256)
+      throw new Error(`Checksum mismatch in snapshot file: ${normalized}`);
+    writes.push({ target, content });
+  }
+  const deletePaths = /* @__PURE__ */ new Set();
+  for (const file of current.files) {
+    const normalized = toPosix(file.path);
+    if (!remotePaths.has(normalized)) {
+      deletePaths.add(snapshotTarget(root, normalized, options.sessionDir));
+    }
+    for (const remotePath of parentPaths(normalized)) {
+      if (remotePaths.has(remotePath)) {
+        deletePaths.add(snapshotTarget(root, remotePath, options.sessionDir));
+      }
+    }
+  }
+  deletes.push(...deletePaths);
+  return { writes, deletes };
+}
+function protectSnapshotApplyPlan(root, plan, protectedRelativePaths, sessionDir) {
+  if (protectedRelativePaths.size === 0) return plan;
+  const protectedTargets = new Set(
+    [...protectedRelativePaths].map(
+      (relativePath) => snapshotTarget(root, relativePath, sessionDir)
+    )
+  );
+  return {
+    writes: plan.writes.filter((item) => !protectedTargets.has(item.target)),
+    deletes: plan.deletes.filter((target) => !protectedTargets.has(target))
+  };
+}
+async function addTopLevelCaseVariantDeletes(root, plan, snapshot) {
+  const topLevelPaths = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    const normalized = toPosix(file.path);
+    if (!normalized.includes("/") && isSafeSnapshotPath(file.path)) {
+      topLevelPaths.set(normalized.toLowerCase(), normalized);
+    }
+  }
+  if (topLevelPaths.size === 0) return plan;
+  let entries;
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return plan;
+    throw error;
+  }
+  const deletes = new Set(plan.deletes);
+  for (const entry of entries) {
+    const canonicalPath = topLevelPaths.get(entry.name.toLowerCase());
+    if (canonicalPath && entry.name !== canonicalPath && (entry.isFile() || entry.isSymbolicLink())) {
+      deletes.add(safeJoin(root, entry.name));
+    }
+  }
+  return { ...plan, deletes: [...deletes] };
+}
+function appliedFileHashMap(snapshot, current, protectedRelativePaths) {
+  const hashes = fileHashMap2(snapshot);
+  if (protectedRelativePaths.size === 0) return hashes;
+  const currentHashes = fileHashMap2(current);
+  for (const relativePath of protectedRelativePaths) {
+    const normalized = toPosix(relativePath);
+    if (currentHashes[normalized]) {
+      hashes[normalized] = currentHashes[normalized];
+    } else {
+      delete hashes[normalized];
+    }
+  }
+  return hashes;
+}
+function isSafeSnapshotPath(relativePath) {
+  if (relativePath.includes("\\")) return false;
+  const normalized = toPosix(relativePath);
+  return Boolean(normalized) && normalized !== "." && normalized !== ".." && !normalized.startsWith("../") && !path.posix.isAbsolute(normalized) && path.posix.normalize(normalized) === normalized && !isDeniedPath(normalized);
+}
+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");
+}
+async function preflightSnapshotMutations(root, plan, sessionDir) {
+  const deletePaths = new Set(plan.deletes);
+  for (const target of plan.deletes) {
+    await assertNoSymlinkParents(rootForTarget(root, target, sessionDir), target);
+  }
+  for (const item of plan.writes) {
+    await prepareSnapshotWrite(
+      rootForTarget(root, item.target, sessionDir),
+      item.target,
+      deletePaths
+    );
+  }
+}
+function rootForTarget(root, target, sessionDir) {
+  const sessionRoot = sessionDir ? sessionStorageRoot(root, sessionDir) : void 0;
+  if (sessionRoot && isPathInside(sessionRoot, target)) return sessionRoot;
+  return root;
+}
+async function prepareSnapshotWrite(root, target, deletePaths) {
+  const parentWillBeReplaced = await ensureSafeDirectory(root, path.dirname(target), deletePaths);
+  if (parentWillBeReplaced) return;
+  try {
+    const stat = await fs.lstat(target);
+    if (stat.isSymbolicLink())
+      throw new Error(`Refusing to overwrite symlink during snapshot apply: ${target}`);
+    if (stat.isDirectory() && !deletePaths.has(target)) {
+      throw new Error(`Refusing to overwrite directory during snapshot apply: ${target}`);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function ensureSafeDirectory(root, directory, deletePaths) {
+  assertWithinRoot(root, directory);
+  const rootPath = path.resolve(root);
+  const relative = path.relative(rootPath, path.resolve(directory));
+  let current = rootPath;
+  for (const part of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, part);
+    try {
+      const stat = await fs.lstat(current);
+      if (stat.isSymbolicLink())
+        throw new Error(`Refusing to follow symlink during snapshot apply: ${current}`);
+      if (!stat.isDirectory()) {
+        if (deletePaths.has(current)) return true;
+        throw new Error(`Snapshot path parent is not a directory: ${current}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      await fs.mkdir(current);
+    }
+  }
+  return false;
+}
+async function assertNoSymlinkParents(root, target) {
+  assertWithinRoot(root, target);
+  const rootPath = path.resolve(root);
+  const relative = path.relative(rootPath, path.resolve(target));
+  let current = rootPath;
+  const parts = relative.split(path.sep).filter(Boolean);
+  for (const part of parts.slice(0, -1)) {
+    current = path.join(current, part);
+    try {
+      const stat = await fs.lstat(current);
+      if (stat.isSymbolicLink())
+        throw new Error(`Refusing to follow symlink during snapshot apply: ${current}`);
+      if (!stat.isDirectory())
+        throw new Error(`Snapshot path parent is not a directory: ${current}`);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+  }
+}
+
+// src/sync-decision.ts
+function createSyncDecision(options) {
+  const { config, state, local, remote, kind } = options;
+  const policyChanged = Boolean(state.lastAppliedSnapshot) && syncPolicyChanged(state, config);
+  const previousInclude = includeFromSelectionConfig(state);
+  const currentInclude = [...config.include];
+  const causes = {
+    localChanged: options.localChanged,
+    remoteChanged: options.remoteChanged,
+    policyChanged
+  };
+  const causeLines = kind === "first-sync-settings-diverged" ? ["This machine and the remote have different Pi settings on first sync."] : kind === "first-sync-sessions-diverged" ? ["Pi settings match, but local and remote sessions differ on first sync."] : kind === "remote-empty" ? ["The remote storage location is empty."] : [
+    ...causes.localChanged ? ["Local content changed since the last sync."] : [],
+    ...causes.remoteChanged ? ["Remote content changed since the last sync."] : [],
+    ...causes.policyChanged ? ["Included content changed since the last sync."] : []
+  ];
+  const comparison = remote ? formatDiff(local, remote) : formatSnapshotOnlyDiff("Remote is empty. Local push would upload", local);
+  const review = [
+    `Sync setup: ${safeTerminalText(config.setupName)}`,
+    "",
+    "Why a decision is required:",
+    ...causeLines,
+    ...policyChanged ? [
+      "",
+      `Previously included: ${safeList(previousInclude)}`,
+      `Currently included: ${safeList(currentInclude)}`
+    ] : [],
+    "",
+    "Observed differences:",
+    ...comparison.split("\n").map(safeTerminalText)
+  ].join("\n");
+  return new SyncDecisionRequiredError({
+    kind,
+    setupName: config.setupName,
+    configIdentity: syncConfigReviewIdentity(config),
+    causes,
+    ...policyChanged ? { previousInclude: [...previousInclude] } : {},
+    currentInclude,
+    review,
+    directions: kind === "remote-empty" ? ["push"] : ["push", "pull"],
+    directMessage: options.directMessage
+  });
+}
+function safeList(values) {
+  return values.length > 0 ? values.map(safeTerminalText).join(", ") : "none";
+}
+
+// src/sync-operations.ts
+var STATUS_KEY = "sync";
+var VERSION = 1;
+var DEFAULT_PROFILE = "default";
+var POST_LOCAL_COMMIT_TIMEOUT_MS = 3e4;
+var PublicationStatePersistenceError = class extends Error {
+  head;
+  backupPath;
+  constructor(head, cause, backupPath) {
+    super(
+      `Remote publication ${head.snapshotId} is active, but local sync state could not be saved${backupPath ? `; local backup: ${backupPath}` : ""}: ${errorMessage(cause)}`,
+      { cause }
+    );
+    this.name = "PublicationStatePersistenceError";
+    this.head = head;
+    this.backupPath = backupPath;
+  }
+};
+var RollbackPublicationError = class extends Error {
+  backupPath;
+  constructor(backupPath, cause) {
+    super(
+      `Rollback applied locally with backup ${backupPath}, but remote publication failed: ${errorMessage(cause)}`,
+      { cause }
+    );
+    this.name = "RollbackPublicationError";
+    this.backupPath = backupPath;
+  }
+};
+function backendFor(config, factory) {
+  return factory(config);
+}
+async function status(ctx, options, factory = createSyncBackend) {
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  ctx.ui.setStatus(STATUS_KEY, `checking ${config.setupName}`);
+  const backend = await backendFor(config, factory);
+  const local = await createSnapshot(
+    config.snapshotIdentity,
+    snapshotOptionsForContext(ctx, config)
+  );
+  throwIfAborted(options.signal);
+  const state = await readStateForConfig(config);
+  throwIfAborted(options.signal);
+  const head = await backend.readHead(options.signal);
+  throwIfAborted(options.signal);
+  const selectionState = head ? inspectRemoteSelection(config.include, { selection: head.selection, files: [] }) : void 0;
+  const localChanged = hasLocalChanges(local, state, config);
+  const remoteText = head ? `remote: ${head.snapshotId} from ${head.machine} at ${head.createdAt}` : "remote: empty";
+  const remoteChanged = remoteChangedSinceState(
+    head,
+    state,
+    config,
+    (left, right) => backend.sameRevision(left, right)
+  );
+  const warnings = syncSessionsWarnings(config);
+  ctx.ui.setStatus(STATUS_KEY, void 0);
+  ctx.ui.notify(
+    [
+      `sync setup: ${config.setupName}`,
+      `storage connection: ${config.connectionName}`,
+      `storage location: ${safeTerminalText(backend.destination)}`,
+      `publication safety: ${publicationCapabilityDescription(backend.capability)}`,
+      `included content: ${config.include.join(", ") || "none"}`,
+      `sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
+      remoteText,
+      formatRemoteSelectionStatus(selectionState),
+      `local files: ${local.files.length}`,
+      `local changed since last sync: ${localChanged ? "yes" : "no"}`,
+      `remote changed since last sync: ${remoteChanged ? "yes" : "no"}`,
+      ...warnings
+    ].join("\n"),
+    localChanged || remoteChanged || selectionState?.kind === "different" || warnings.length > 0 ? "warning" : "info"
+  );
+}
+async function diff(ctx, options, factory = createSyncBackend) {
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  ctx.ui.setStatus(STATUS_KEY, `checking ${config.setupName}`);
+  const backend = await backendFor(config, factory);
+  const local = await createSnapshot(
+    config.snapshotIdentity,
+    snapshotOptionsForContext(ctx, config)
+  );
+  throwIfAborted(options.signal);
+  const { snapshot: remote, selectionState } = await readRemoteSnapshot(
+    backend,
+    config,
+    options.signal,
+    { allowSelectionDifference: true }
+  );
+  throwIfAborted(options.signal);
+  ctx.ui.setStatus(STATUS_KEY, void 0);
+  const warnings = syncSessionsWarnings(config);
+  const header = [
+    `sync setup: ${config.setupName}`,
+    `storage connection: ${config.connectionName}`,
+    `storage location: ${safeTerminalText(backend.destination)}`,
+    `included content: ${config.include.join(", ") || "none"}`,
+    `sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
+    formatRemoteSelectionStatus(selectionState),
+    ...warnings
+  ].join("\n");
+  const level = warnings.length > 0 || selectionState?.kind === "different" ? "warning" : "info";
+  if (!remote) {
+    ctx.ui.notify(
+      `${header}
+
+${formatSnapshotOnlyDiff("Remote is empty. Local push would upload", local)}`,
+      level
+    );
+    return;
+  }
+  ctx.ui.notify(`${header}
+
+${formatDiff(local, remote)}`, level);
+}
+async function doctor(ctx, options, factory = createSyncBackend) {
+  const messages = [];
+  let level = "info";
+  let snapshotOptions = {};
+  let profile = DEFAULT_PROFILE;
+  let backend;
+  let backendSummary = [];
+  try {
+    const config = await loadConfig(options.setup);
+    throwIfAborted(options.signal);
+    backend = await backendFor(config, factory);
+    profile = config.snapshotIdentity;
+    snapshotOptions = snapshotOptionsForContext(ctx, config);
+    messages.push(
+      `config: ok (sync setup ${config.setupName})`,
+      `included content: ${config.include.join(", ") || "none"}`,
+      `sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`
+    );
+    backendSummary = [
+      `storage location: ${safeTerminalText(backend.destination)}`,
+      `publication safety: ${publicationCapabilityDescription(backend.capability)}`
+    ];
+    const warnings = syncSessionsWarnings(config);
+    if (warnings.length > 0) {
+      level = "warning";
+      messages.push(...warnings);
+    }
+  } catch (error) {
+    throwIfAborted(options.signal);
+    level = "warning";
+    messages.push(`config: ${errorMessage(error)}`);
+  }
+  const local = await createSnapshot(profile, snapshotOptions);
+  throwIfAborted(options.signal);
+  const secrets = scanSnapshot(local);
+  if (secrets.length > 0) {
+    level = "warning";
+    messages.push("secret scan: possible secrets found:");
+    messages.push(...secrets.map((secret) => `- ${secret}`));
+  } else {
+    messages.push(`secret scan: ok (${local.files.length} files checked)`);
+  }
+  const lock = await inspectLock();
+  throwIfAborted(options.signal);
+  if (lock.status === "valid" && isStaleLock(lock.lock)) {
+    level = "warning";
+    messages.push(
+      `lock: stale (pid ${lock.lock.pid}); run /sync unlock after verifying no sync is running`
+    );
+  } else if (lock.status === "valid") {
+    messages.push(`lock: held by pid ${lock.lock.pid} since ${lock.lock.startedAt}`);
+  } else if (lock.status === "unreadable") {
+    level = "warning";
+    messages.push(
+      "lock: unreadable; use /sync unlock --stale only after verifying no sync is running"
+    );
+  } else if (await isLockGuardHeld()) {
+    throwIfAborted(options.signal);
+    level = "warning";
+    messages.push("lock: guard active while metadata is missing or still being initialized");
+  } else {
+    messages.push("lock: free");
+  }
+  if (backend) {
+    messages.push(...backendSummary);
+    const diagnostics = await backend.diagnose(options.signal);
+    throwIfAborted(options.signal);
+    for (const diagnostic of diagnostics) {
+      messages.push(diagnostic.message);
+      if (diagnostic.level !== "info") level = "warning";
+    }
+  }
+  ctx.ui.notify(messages.join("\n"), level);
+}
+async function push(ctx, options, input, factory = createSyncBackend) {
+  const config = input?.config ?? await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  ctx.ui.setStatus(STATUS_KEY, `pushing ${config.setupName}`);
+  const backend = input?.backend ?? await backendFor(config, factory);
+  const state = input?.state ?? await readStateForConfig(config);
+  throwIfAborted(options.signal);
+  const local = input?.local ?? await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+  throwIfAborted(options.signal);
+  let head = await backend.readHead(options.signal);
+  let remoteForUpload = await readRemoteSnapshotForUpload(
+    backend,
+    config,
+    head,
+    state,
+    options.signal
+  );
+  if (!options.force && !remoteForUpload && head?.selection && inspectRemoteSelection(config.include, { selection: head.selection, files: [] }).kind === "different") {
+    remoteForUpload = await readSnapshotForHead(backend, head, options.signal);
+  }
+  if (remoteForUpload && !options.force) {
+    requireCompatibleRemoteSelection(config, remoteForUpload);
+  }
+  if (remoteChangedSinceState(
+    head,
+    state,
+    config,
+    (left, right) => backend.sameRevision(left, right)
+  ) && !options.force) {
+    const remoteForConflict = remoteForUpload ? filterSnapshotForConfigPolicy(remoteForUpload, config) : void 0;
+    if (!remoteForConflict || !snapshotHashesMatchState(remoteForConflict, state, config)) {
+      throw createSyncDecision({
+        kind: head ? "remote-or-policy-changed" : "remote-empty",
+        config,
+        state,
+        local,
+        remote: remoteForConflict,
+        localChanged: hasLocalChanges(local, state, config),
+        remoteChanged: true,
+        directMessage: "Remote or sync policy changed since last sync. Run /sync pull first or /sync push --force."
+      });
+    }
+  }
+  let upload = await snapshotForUpload(
+    backend,
+    config,
+    local,
+    head,
+    remoteForUpload,
+    options.signal
+  );
+  const secrets = scanSnapshot(local);
+  if (secrets.length > 0) {
+    throw new Error(
+      `Refusing to push possible secrets:
+${secrets.map((s) => `- ${s}`).join("\n")}`
+    );
+  }
+  if (!await confirmPush(ctx, options, config, backend, local, upload, head, remoteForUpload)) {
+    return "cancelled";
+  }
+  if (options.force) {
+    const refreshedHead = await backend.readHead(options.signal);
+    if (!sameRemoteHead(backend, head, refreshedHead)) {
+      head = refreshedHead;
+      remoteForUpload = head ? await backend.readSnapshot(head.snapshotRef, options.signal) : void 0;
+      upload = await snapshotForUpload(
+        backend,
+        config,
+        local,
+        head,
+        remoteForUpload,
+        options.signal
+      );
+      if (!await confirmPush(
+        ctx,
+        options,
+        config,
+        backend,
+        local,
+        upload,
+        head,
+        remoteForUpload,
+        "Remote changed during review. Push the refreshed plan?"
+      )) {
+        return "cancelled";
+      }
+    }
+  }
+  const result = await backend.publishSnapshot(upload, expectedRemoteHead(head), {
+    signal: options.signal,
+    onCommit: options.onCommit
+  });
+  try {
+    await writeStateForConfig(config, {
+      version: VERSION,
+      profile: config.snapshotIdentity,
+      lastAppliedSnapshot: result.head.snapshotId,
+      lastRemoteRevision: result.head.revision,
+      lastFileHashes: fileHashMap(local),
+      include: [...config.include]
+    });
+  } catch (error) {
+    throw new PublicationStatePersistenceError(result.head, error);
+  }
+  if (options.signal?.aborted) return;
+  ctx.ui.setStatus(STATUS_KEY, void 0);
+  if (!options.silent) {
+    ctx.ui.notify(
+      [
+        `Pushed ${upload.files.length} files from sync setup \u201C${config.setupName}\u201D as ${result.head.snapshotId}.`,
+        ...result.warnings
+      ].filter(Boolean).join("\n"),
+      result.warnings.length > 0 ? "warning" : "info"
+    );
+  }
+  return "applied";
+}
+async function pull(ctx, options, factory = createSyncBackend) {
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  ctx.ui.setStatus(STATUS_KEY, `pulling ${config.setupName}`);
+  const backend = await backendFor(config, factory);
+  const state = await readStateForConfig(config);
+  throwIfAborted(options.signal);
+  const local = await createSnapshot(
+    config.snapshotIdentity,
+    snapshotOptionsForContext(ctx, config)
+  );
+  throwIfAborted(options.signal);
+  const { head, snapshot: remote } = await readRemoteSnapshot(backend, config, options.signal);
+  throwIfAborted(options.signal);
+  const localChanged = hasLocalChanges(local, state, config);
+  if (!remote) {
+    throw createSyncDecision({
+      kind: "remote-empty",
+      config,
+      state,
+      local,
+      localChanged,
+      remoteChanged: false,
+      directMessage: "Remote is empty. Run /sync push from a configured machine first."
+    });
+  }
+  const remoteChanged = hasRemoteChanges(remote, state, config, protectedSessionPaths(ctx));
+  if (localChanged && remoteChanged && state.lastAppliedSnapshot && !options.force) {
+    throw createSyncDecision({
+      kind: "both-changed",
+      config,
+      state,
+      local,
+      remote,
+      localChanged,
+      remoteChanged,
+      directMessage: "Both local and remote changed since last sync. Run /sync diff, then choose /sync pull --force or /sync push --force."
+    });
+  }
+  if (!options.yes && !await ctx.ui.confirm(
+    snapshotIncludesSessions(remote) ? "Pull pi settings and sessions?" : "Pull pi settings?",
+    formatPullSummary(
+      config,
+      backend.destination,
+      local,
+      remote,
+      protectedSessionPaths(ctx).size
+    )
+  )) {
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+    ctx.ui.notify("Pull cancelled.", "info");
+    return "cancelled";
+  }
+  throwIfAborted(options.signal);
+  const backup = await backupLocal(
+    config.snapshotIdentity,
+    snapshotOptionsForContext(ctx, config),
+    options.signal
+  );
+  const applySessionDir = await sessionDirForApply(ctx, remote);
+  throwIfAborted(options.signal);
+  options.onCommit?.();
+  const lastFileHashes = await applySnapshot(remote, protectedSessionPaths(ctx), {
+    include: config.include,
+    sessionDir: applySessionDir
+  });
+  await writeStateForConfig(config, {
+    version: VERSION,
+    profile: config.snapshotIdentity,
+    lastAppliedSnapshot: remote.id,
+    lastRemoteRevision: head?.revision,
+    lastFileHashes,
+    include: [...config.include]
+  });
+  if (options.signal?.aborted) return "applied";
+  ctx.ui.setStatus(STATUS_KEY, void 0);
+  if (!options.silent) {
+    ctx.ui.notify(
+      `Pulled ${remote.files.length} files from ${remote.id}. Backup: ${backup}`,
+      "info"
+    );
+  } else if (options.auto && config.include.includes("sessions") && snapshotIncludesSessions(remote)) {
+    ctx.ui.notify(
+      "Pulled Pi sessions after startup selected the current session. Restart Pi or resume a pulled session to use newly synced conversations.",
+      "warning"
+    );
+  }
+  if (options.reload) await maybeReload(ctx, options.signal);
+  return "applied";
+}
+async function syncBoth(ctx, options, factory = createSyncBackend) {
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  const backend = await backendFor(config, factory);
+  const state = await readStateForConfig(config);
+  throwIfAborted(options.signal);
+  const local = await createSnapshot(
+    config.snapshotIdentity,
+    snapshotOptionsForContext(ctx, config)
+  );
+  throwIfAborted(options.signal);
+  if (config.include.length === 0) {
+    if (!options.silent) {
+      ctx.ui.notify(
+        `Sync setup \u201C${config.setupName}\u201D includes no files. Choose included content in /sync Settings before syncing.`,
+        "warning"
+      );
+    }
+    return;
+  }
+  const { head, snapshot: remote } = await readRemoteSnapshot(backend, config, options.signal);
+  throwIfAborted(options.signal);
+  const localChanged = hasLocalChanges(local, state, config);
+  const remoteChanged = remote ? hasRemoteChanges(remote, state, config, protectedSessionPaths(ctx)) : false;
+  const firstSync = !state.lastAppliedSnapshot;
+  if (firstSync && remote && remote.files.length > 0 && local.files.length > 0) {
+    if (!canPullRemoteSettingsOnFirstSync(local, remote)) {
+      throw createSyncDecision({
+        kind: "first-sync-settings-diverged",
+        config,
+        state,
+        local,
+        remote,
+        localChanged: true,
+        remoteChanged: true,
+        directMessage: "Remote settings exist and this machine has different local Pi settings. Run /sync diff, then manually choose /sync pull or /sync push."
+      });
+    }
+    if (!sameHashes(fileHashMap(local), fileHashMap(remote))) {
+      if (!canPullRemoteSessionsOnFirstSync(local, remote)) {
+        throw createSyncDecision({
+          kind: "first-sync-sessions-diverged",
+          config,
+          state,
+          local,
+          remote,
+          localChanged: true,
+          remoteChanged: true,
+          directMessage: "Remote settings match, but local and remote Pi sessions differ. Run /sync diff, then manually choose /sync pull or /sync push."
+        });
+      }
+      await pull(ctx, options, factory);
+      return;
+    }
+    await writeStateForConfig(config, {
+      version: VERSION,
+      profile: config.snapshotIdentity,
+      lastAppliedSnapshot: remote.id,
+      lastRemoteRevision: head?.revision,
+      lastFileHashes: fileHashMap(remote),
+      include: [...config.include]
+    });
+    if (!options.silent)
+      ctx.ui.notify("pi-sync state initialized; local settings already match remote.", "info");
+    return;
+  }
+  if (localChanged && remoteChanged && remote && snapshotsMatch(local, remote)) {
+    await writeStateForConfig(config, {
+      version: VERSION,
+      profile: config.snapshotIdentity,
+      lastAppliedSnapshot: remote.id,
+      lastRemoteRevision: head?.revision,
+      lastFileHashes: fileHashMap(remote),
+      include: [...config.include]
+    });
+    if (!options.silent) ctx.ui.notify("pi-sync is already up to date.", "info");
+    return;
+  }
+  if (localChanged && remoteChanged && state.lastAppliedSnapshot) {
+    throw createSyncDecision({
+      kind: "both-changed",
+      config,
+      state,
+      local,
+      remote,
+      localChanged,
+      remoteChanged,
+      directMessage: "Both local and remote changed. Run /sync diff and resolve with push --force or pull --force."
+    });
+  }
+  if (remoteChanged) {
+    await pull(ctx, options, factory);
+    return;
+  }
+  if (localChanged || !remote) {
+    await push(ctx, options, void 0, factory);
+    return;
+  }
+  if (shouldRefreshSyncedState(
+    remote,
+    head,
+    state,
+    config,
+    (left, right) => backend.sameRevision(left, right)
+  )) {
+    await writeStateForConfig(config, {
+      version: VERSION,
+      profile: config.snapshotIdentity,
+      lastAppliedSnapshot: remote.id,
+      lastRemoteRevision: head?.revision,
+      lastFileHashes: fileHashMap(remote),
+      include: [...config.include]
+    });
+  }
+  if (!options.silent) ctx.ui.notify("pi-sync is already up to date.", "info");
+}
+async function history(ctx, options, factory = createSyncBackend) {
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  const backend = await backendFor(config, factory);
+  const snapshots = (await backend.listHistory(options.signal)).slice(-20).reverse();
+  throwIfAborted(options.signal);
+  if (snapshots.length === 0) {
+    ctx.ui.notify("No remote pi-sync history found.", "info");
+    return;
+  }
+  const currentSnapshot = snapshots[0]?.snapshotId;
+  if (ctx.mode === "tui") {
+    const labels = snapshots.map(
+      (item, index2) => `${index2 + 1}. ${item.createdAt} \xB7 ${safeTerminalText(item.machine)} \xB7 ${item.snapshotId}${item.snapshotId === currentSnapshot ? " (current)" : ""}${item.syncSessions ? " \xB7 sessions" : ""}`
+    );
+    const selected = await ctx.ui.select(
+      `History for sync setup \u201C${safeTerminalText(config.setupName)}\u201D
+
+Choose a snapshot to preview rollback.`,
+      [...labels, "Back"]
+    );
+    if (!selected || selected === "Back") return;
+    throwIfAborted(options.signal);
+    const index = labels.indexOf(selected);
+    const snapshot = snapshots[index];
+    if (!snapshot) return;
+    await withLock(
+      "rollback",
+      () => rollback(ctx, { ...options, args: [snapshot.snapshotRef], yes: false }, factory, {
+        backendIdentity: backend.identity,
+        setup: config.setupName
+      })
+    );
+    return;
+  }
+  ctx.ui.notify(
+    snapshots.map((item) => `${item.snapshotRef} ${item.createdAt} ${safeTerminalText(item.machine)}`).join("\n"),
+    "info"
+  );
+}
+async function rollback(ctx, options, factory = createSyncBackend, expectedSelection) {
+  const target = options.args[0];
+  if (!target) throw new Error("Usage: /sync rollback <snapshot-id> [--yes]");
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  const backend = await backendFor(config, factory);
+  if (expectedSelection && (backend.identity !== expectedSelection.backendIdentity || config.setupName !== expectedSelection.setup)) {
+    throw new Error(
+      "Sync setup or storage location changed while history was open; reopen history and retry."
+    );
+  }
+  const decoded = await backend.readSnapshot(target, options.signal);
+  const selected = filterSnapshotForConfigPolicy(
+    config.include.includes("sessions") ? decoded : snapshotWithoutSessions(decoded),
+    config
+  );
+  const remote = regenerateSnapshotIdentity(selected);
+  const local = await createSnapshot(
+    config.snapshotIdentity,
+    snapshotOptionsForContext(ctx, config)
+  );
+  const expectedHead = await backend.readHead(options.signal);
+  throwIfAborted(options.signal);
+  if (!options.yes && !await ctx.ui.confirm(
+    snapshotIncludesSessions(remote) ? "Rollback pi settings and sessions?" : "Rollback pi settings?",
+    formatRollbackSummary(
+      config,
+      backend.destination,
+      local,
+      remote,
+      target,
+      protectedSessionPaths(ctx).size
+    )
+  )) {
+    ctx.ui.notify("Rollback cancelled.", "info");
+    return;
+  }
+  throwIfAborted(options.signal);
+  const backup = await backupLocal(
+    config.snapshotIdentity,
+    snapshotOptionsForContext(ctx, config),
+    options.signal
+  );
+  const applySessionDir = await sessionDirForApply(ctx, remote);
+  throwIfAborted(options.signal);
+  options.onCommit?.();
+  const lastFileHashes = await applySnapshot(remote, protectedSessionPaths(ctx), {
+    include: config.include,
+    sessionDir: applySessionDir
+  });
+  let result;
+  try {
+    const completionSignal = AbortSignal.timeout(POST_LOCAL_COMMIT_TIMEOUT_MS);
+    const upload = await snapshotForUpload(
+      backend,
+      config,
+      remote,
+      expectedHead,
+      void 0,
+      completionSignal,
+      { ignoreUnreadableRemote: true }
+    );
+    result = await backend.publishSnapshot(upload, expectedRemoteHead(expectedHead), {
+      signal: completionSignal
+    });
+  } catch (error) {
+    throw new RollbackPublicationError(backup, error);
+  }
+  try {
+    await writeStateForConfig(config, {
+      version: VERSION,
+      profile: config.snapshotIdentity,
+      lastAppliedSnapshot: result.head.snapshotId,
+      lastRemoteRevision: result.head.revision,
+      lastFileHashes,
+      include: [...config.include]
+    });
+  } catch (error) {
+    throw new PublicationStatePersistenceError(result.head, error, backup);
+  }
+  if (options.signal?.aborted) return;
+  ctx.ui.notify(
+    [
+      `Rolled back sync setup \u201C${config.setupName}\u201D to ${target}; latest: ${result.head.snapshotId}. Backup: ${backup}`,
+      ...result.warnings
+    ].filter(Boolean).join("\n"),
+    result.warnings.length > 0 ? "warning" : "info"
+  );
+  await maybeReload(ctx, options.signal);
+}
+function protectedSessionPaths(ctx) {
+  const getSessionFile = ctx.sessionManager.getSessionFile;
+  if (typeof getSessionFile !== "function") return /* @__PURE__ */ new Set();
+  const sessionFile = getSessionFile.call(ctx.sessionManager);
+  const snapshotPath = sessionFile ? sessionSnapshotPathFromAbsolute(sessionFile, sessionDirFromContext(ctx)) : void 0;
+  return snapshotPath ? /* @__PURE__ */ new Set([snapshotPath]) : /* @__PURE__ */ new Set();
+}
+function snapshotOptionsForContext(ctx, config) {
+  return {
+    include: config.include,
+    sessionDir: sessionDirFromContext(ctx)
+  };
+}
+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 maybeReload(ctx, signal) {
+  if (signal?.aborted || !("reload" in ctx)) return;
+  if (ctx.hasUI && await ctx.ui.confirm(
+    "Reload Pi resources now?",
+    "This reloads extensions, skills, prompts, themes, and context files."
+  )) {
+    if (signal?.aborted) return;
+    await ctx.reload();
+  }
+}
+async function readRemoteSnapshotForUpload(backend, config, head, state, signal) {
+  if (!head || head.snapshotId === state.lastAppliedSnapshot && !syncPolicyChanged(state, config) && (!state.lastRemoteRevision || backend.sameRevision(head.revision, state.lastRemoteRevision))) {
+    return void 0;
+  }
+  return backend.readSnapshot(head.snapshotRef, signal);
+}
+async function snapshotForUpload(backend, config, local, head, remote, signal, options = {}) {
+  if (!head) return local;
+  let snapshot = remote;
+  if (!snapshot) {
+    try {
+      snapshot = await backend.readSnapshot(head.snapshotRef, signal);
+    } catch (error) {
+      if (options.ignoreUnreadableRemote) return local;
+      throw error;
+    }
+  }
+  return mergeRemotePreservedFiles(local, snapshot, config);
+}
+async function readRemoteSnapshot(backend, config, signal, options = {}) {
+  const head = await backend.readHead(signal);
+  if (!head) return { head: void 0, snapshot: void 0, selectionState: void 0 };
+  const snapshot = await readSnapshotForHead(backend, head, signal);
+  const selectionState = inspectRemoteSelection(config.include, snapshot);
+  if (!options.allowSelectionDifference && selectionState.kind === "different") {
+    const configIdentity = syncConfigReviewFingerprint(config);
+    throw remoteSelectionMismatch(config, selectionState.include, configIdentity);
+  }
+  return {
+    head,
+    snapshot: filterSnapshotForConfigPolicy(snapshot, config),
+    selectionState
+  };
+}
+async function confirmPush(ctx, options, config, backend, local, upload, head, remote, title = snapshotIncludesSessions(upload) ? "Push pi settings and sessions?" : "Push pi settings?") {
+  throwIfAborted(options.signal);
+  if (options.yes) return true;
+  const confirmed = await ctx.ui.confirm(
+    title,
+    formatPushSummary(
+      config,
+      backend.destination,
+      upload,
+      head,
+      countPreservedRemoteFiles(local, upload),
+      remote
+    )
+  );
+  throwIfAborted(options.signal);
+  if (confirmed) return true;
+  ctx.ui.setStatus(STATUS_KEY, void 0);
+  ctx.ui.notify("Push cancelled.", "info");
+  return false;
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+}
+function sameRemoteHead(backend, left, right) {
+  if (!left || !right) return left === right;
+  return backend.sameRevision(left.revision, right.revision);
+}
+async function backupLocal(profile, options = {}, signal) {
+  throwIfAborted(signal);
+  const snapshot = await createSnapshot(profile, options);
+  throwIfAborted(signal);
+  const backupDirectory = path2.join(stateDir(), "backups");
+  await fs2.mkdir(backupDirectory, { recursive: true });
+  throwIfAborted(signal);
+  const backupPath = path2.join(backupDirectory, `${snapshot.id}.json.gz`);
+  const encoded = await encodeSnapshot(snapshot);
+  throwIfAborted(signal);
+  await fs2.writeFile(backupPath, encoded, { signal });
+  return backupPath;
+}
+export {
+  PublicationStatePersistenceError,
+  RollbackPublicationError,
+  backupLocal,
+  diff,
+  doctor,
+  history,
+  pull,
+  push,
+  rollback,
+  status,
+  syncBoth
+};
+//# sourceMappingURL=sync-operations-MPAFVVHA.ts.map