@narumitw/pi-sync 0.49.14 → 0.50.0

package/dist/index.ts

@@ -2,8 +2,28 @@
 // @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
 import {
   createSyncAttentionController,
+  observationMatchesConfig,
   syncAttentionMatchesConfig
-} from "./chunks/chunk-JNOOSPEW.ts";
+} from "./chunks/chunk-6UHKGALE.ts";
+import {
+  recoverSnapshotTransactionsOnStartup
+} from "./chunks/chunk-AXXS2BPA.ts";
+import {
+  unlock,
+  withLock
+} from "./chunks/chunk-GWMHAQG4.ts";
+import {
+  combineSignals,
+  throwIfAborted
+} from "./chunks/chunk-NJFUIVYL.ts";
+import {
+  ensureStateDir,
+  readStateForConfig,
+  syncStateFingerprint
+} from "./chunks/chunk-JSYMGJQQ.ts";
+import {
+  automaticSyncSummary
+} from "./chunks/chunk-Z4DQF6L3.ts";
 import {
   completeSyncArguments,
   parseOptions,
@@ -12,290 +32,51 @@ import {
   splitArgs,
   usage,
   validateCommandOptions
-} from "./chunks/chunk-4U6AFLJB.ts";
+} from "./chunks/chunk-CHH26D4F.ts";
 import {
-  recoverSnapshotTransactionsOnStartup
-} from "./chunks/chunk-3NDD5QPM.ts";
+  migrateLegacyStateDirectory,
+  stateDirectoryMigrationNotice,
+  withStateDirectoryAccess
+} from "./chunks/chunk-ZI5MXMEX.ts";
 import {
-  unlock,
-  withLock
-} from "./chunks/chunk-LJDSHNS3.ts";
+  syncErrorGuidance
+} from "./chunks/chunk-CPEHGXJV.ts";
 import {
-  SetupPullRequiresUiError,
-  errorMessage,
-  isSyncDecisionRequiredError
-} from "./chunks/chunk-W64NEHXT.ts";
-import "./chunks/chunk-RGJ6SOYR.ts";
-import "./chunks/chunk-EWX3TPLQ.ts";
+  safeTerminalText
+} from "./chunks/chunk-LTBWGSBV.ts";
 import {
   activeLocalConfigPath,
   configuredSyncSetupNames,
   consumeLocalConfigMigrationNotice,
   createLocalConfigDocument,
-  ensureStateDir,
-  isMissingConfigError,
   loadConfig,
+  loadConfigForCheck,
   loadPartialConfig,
   localConfigPath,
   localConfigTemplate,
   readLocalConfigObject,
-  readStateForConfig,
   sessionTokenWarnings,
+  syncCheckConfigFingerprint,
   syncSessionsWarnings
-} from "./chunks/chunk-APZVBSM6.ts";
+} from "./chunks/chunk-C7XY5NF5.ts";
+import "./chunks/chunk-6LP3MCR2.ts";
+import "./chunks/chunk-TEN2ZBJV.ts";
 import {
-  migrateLegacyStateDirectory,
-  stateDirectoryMigrationNotice,
-  withStateDirectoryAccess
-} from "./chunks/chunk-F5QL2GPY.ts";
+  SetupPullRequiresUiError,
+  errorMessage,
+  isSyncDecisionRequiredError
+} from "./chunks/chunk-2B2ELUF5.ts";
+import "./chunks/chunk-THMF4BVL.ts";
+import {
+  snapshotOptionsForContext
+} from "./chunks/chunk-T3HH3UEJ.ts";
 import {
   RemoteSelectionMismatchError,
   formatRemoteSelectionMismatch
-} from "./chunks/chunk-YQ6UW7IF.ts";
+} from "./chunks/chunk-JAAKLL6M.ts";
 
-// src/sync-extension.ts
+// src/commands/command-execution.ts
 var STATUS_KEY = "sync";
-var AUTO_SYNC_OPTIONS = {
-  yes: true,
-  force: false,
-  stale: false,
-  silent: true,
-  reload: false,
-  auto: true,
-  args: []
-};
-function sync(pi, dependencies = {}) {
-  const loaders = {
-    setupSwitch: cachedModuleLoader(
-      dependencies.loadSetupSwitch ?? (() => import("./chunks/setup-switch-X3W3FALZ.ts"))
-    ),
-    snapshot: cachedModuleLoader(dependencies.loadSnapshot ?? (() => import("./chunks/snapshot-WBSV4MQG.ts"))),
-    syncState: cachedModuleLoader(dependencies.loadSyncState ?? (() => import("./chunks/sync-state-36H7ULG2.ts"))),
-    operations: cachedModuleLoader(
-      dependencies.loadSyncOperations ?? (() => import("./chunks/sync-operations-MPAFVVHA.ts"))
-    )
-  };
-  const attention = createSyncAttentionController();
-  let sessionAbort = new AbortController();
-  let shutdownAbort;
-  pi.registerCommand("sync", {
-    description: "Sync Pi settings through Git, WebDAV, R2, or S3-compatible storage",
-    getArgumentCompletions: completeSyncArguments,
-    handler: async (args, ctx) => {
-      if (!ctx.hasUI) {
-        throw new Error(
-          "/sync requires TUI or RPC mode so results and safety prompts are observable."
-        );
-      }
-      const run = () => handleCommand(args, ctx, sessionAbort.signal, loaders, attention);
-      if (splitArgs(args)[0] === "migrate-state") await run();
-      else await withStateDirectoryAccess(run);
-    }
-  });
-  pi.on("session_start", async (_event, ctx) => {
-    shutdownAbort?.abort(new DOMException("Session replaced", "AbortError"));
-    shutdownAbort = void 0;
-    sessionAbort.abort(new DOMException("Session replaced", "AbortError"));
-    sessionAbort = new AbortController();
-    const signal = sessionAbort.signal;
-    attention.reset(ctx);
-    let decision;
-    try {
-      decision = await withStateDirectoryAccess(() => startSession(ctx, signal, loaders));
-    } catch (error) {
-      if (signal.aborted) return;
-      ctx.ui.notify(`pi-sync state access failed: ${errorMessage(error)}`, "error");
-      return;
-    }
-    if (!decision || signal.aborted) return;
-    attention.set(decision, "sync");
-    if (ctx.mode !== "tui") {
-      ctx.ui.notify(
-        `pi-sync auto sync skipped: ${formatRemoteSelectionMismatch(
-          decision.setupName,
-          decision.localInclude,
-          decision.remoteInclude
-        )}
-RPC review is read-only.`,
-        "warning"
-      );
-    } else if (attention.markOffered()) {
-      await resolveSelectionAttention(ctx, attention, signal, loaders, {
-        cancelLabel: "Later",
-        withStateAccess: withStateDirectoryAccess
-      });
-    }
-    if (!signal.aborted) attention.publish(ctx);
-  });
-  pi.on("session_shutdown", async (event, ctx) => {
-    sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
-    attention.reset(ctx);
-    shutdownAbort?.abort(new DOMException("Session shut down again", "AbortError"));
-    const controller = new AbortController();
-    shutdownAbort = controller;
-    const signal = combineSignals(controller.signal, AbortSignal.timeout(3e4));
-    const reason = typeof event === "object" && event ? event.reason : void 0;
-    try {
-      if (reason !== "reload") {
-        await withStateDirectoryAccess(async () => {
-          if (signal.aborted) return;
-          await autoPushSessions(ctx, signal, loaders);
-        });
-      }
-    } catch (error) {
-      if (!signal.aborted) {
-        ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
-      }
-    } finally {
-      if (shutdownAbort === controller) shutdownAbort = void 0;
-    }
-    if (signal.aborted) return;
-    ctx.ui.setStatus(STATUS_KEY, void 0);
-  });
-}
-async function startSession(ctx, signal, loaders) {
-  if (signal.aborted) return;
-  try {
-    const migrationNotice2 = stateDirectoryMigrationNotice();
-    if (migrationNotice2) ctx.ui.notify(migrationNotice2, "warning");
-  } catch (error) {
-    ctx.ui.notify(`pi-sync state directory requires attention: ${errorMessage(error)}`, "error");
-    return;
-  }
-  try {
-    await recoverSnapshotTransactionsOnStartup();
-    if (signal.aborted) return;
-  } catch (error) {
-    if (signal.aborted) return;
-    ctx.ui.notify(`pi-sync recovery required: ${errorMessage(error)}`, "error");
-    return;
-  }
-  try {
-    setSyncSetupCompletions(await configuredSyncSetupNames());
-    if (signal.aborted) return;
-  } catch {
-    if (signal.aborted) return;
-    setSyncSetupCompletions([]);
-  }
-  const migrationNotice = consumeLocalConfigMigrationNotice();
-  if (migrationNotice) ctx.ui.notify(migrationNotice, "warning");
-  if (signal.aborted) return;
-  return autoSync(ctx, signal, loaders);
-}
-async function handleCommand(rawArgs, ctx, sessionSignal, loaders, attention) {
-  if (!rawArgs.trim()) {
-    try {
-      const { showSyncManager } = await import("./chunks/manager-ui-QO2P4V3Z.ts");
-      if (sessionSignal.aborted) return;
-      await showSyncManager(
-        ctx,
-        (route, signal, onCommit, target) => executeCommand(
-          route,
-          ctx,
-          combineSignals(sessionSignal, signal),
-          loaders,
-          onCommit,
-          target
-        ),
-        sessionSignal,
-        {
-          getAttention: () => attention.current(),
-          onSelectionResolved: (expected) => {
-            if (attention.current() === expected) attention.clear(ctx);
-          }
-        }
-      );
-    } catch (error) {
-      if (sessionSignal.aborted) return;
-      ctx.ui.setStatus(STATUS_KEY, void 0);
-      ctx.ui.notify(errorMessage(error), "error");
-    }
-    if (!sessionSignal.aborted) attention.publish(ctx);
-    return;
-  }
-  const result = await executeCommand(rawArgs, ctx, sessionSignal, loaders);
-  if (result.kind === "decision-required") {
-    ctx.ui.notify(result.decision.directMessage, "error");
-  } else if (result.kind === "remote-selection-required") {
-    const origin = directSelectionOrigin(rawArgs);
-    if (origin) attention.set(result.decision, origin);
-    const deterministic = splitArgs(rawArgs).some((arg) => arg === "--yes" || arg === "-y");
-    if (origin && ctx.mode === "tui" && !deterministic) {
-      await resolveSelectionAttention(ctx, attention, sessionSignal, loaders);
-    } else {
-      ctx.ui.notify(
-        formatRemoteSelectionMismatch(
-          result.decision.setupName,
-          result.decision.localInclude,
-          result.decision.remoteInclude
-        ),
-        "error"
-      );
-    }
-  }
-  await clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, sessionSignal);
-  await reconcileSelectionAttention(ctx, attention, sessionSignal);
-  if (!sessionSignal.aborted) attention.publish(ctx);
-}
-async function clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, signal) {
-  if (result.kind !== "completed" || result.outcome === "cancelled" || signal.aborted) return;
-  const [command, ...rest] = splitArgs(rawArgs);
-  if (command !== "sync" && command !== "pull" && command !== "push") return;
-  const current = attention.current();
-  if (!current) return;
-  try {
-    const options = parseOptions(rest);
-    const setupName = options.setup ?? (await loadConfig()).setupName;
-    if (signal.aborted || attention.current() !== current) return;
-    if (current.decision.setupName === setupName) attention.clear(ctx);
-  } catch {
-  }
-}
-async function reconcileSelectionAttention(ctx, attention, signal) {
-  const current = attention.current();
-  if (!current || signal.aborted) return;
-  try {
-    const config = await loadConfig(current.decision.setupName);
-    if (signal.aborted || attention.current() !== current) return;
-    if (!syncAttentionMatchesConfig(current, config)) attention.clear(ctx);
-  } catch {
-    if (!signal.aborted && attention.current() === current) attention.clear(ctx);
-  }
-}
-function directSelectionOrigin(rawArgs) {
-  const command = splitArgs(rawArgs)[0];
-  return command === "sync" || command === "pull" || command === "push" ? command : void 0;
-}
-async function resolveSelectionAttention(ctx, attention, signal, loaders, options = {}) {
-  const current = attention.current();
-  if (!current || signal.aborted) return;
-  const { dispatchManagerResult } = await import("./chunks/manager-result-dispatcher-RNRQA3PW.ts");
-  if (signal.aborted || attention.current() !== current) return;
-  await dispatchManagerResult(
-    ctx,
-    { kind: "remote-selection-required", decision: current.decision },
-    current.origin,
-    (route, actionSignal, onCommit, target) => {
-      const execute = () => executeRecoveryCommand(
-        route,
-        ctx,
-        combineSignals(signal, actionSignal),
-        loaders,
-        onCommit,
-        target
-      );
-      return options.withStateAccess ? options.withStateAccess(execute) : execute();
-    },
-    signal,
-    {
-      cancelLabel: options.cancelLabel,
-      withStateAccess: options.withStateAccess,
-      onSelectionResolved: () => {
-        if (attention.current() === current) attention.clear(ctx);
-      }
-    }
-  );
-}
 async function executeRecoveryCommand(rawArgs, ctx, signal, loaders, onCommit, setup) {
   try {
     const [subcommand, ...rest] = splitArgs(rawArgs);
@@ -330,7 +111,7 @@ async function executeRecoveryCommand(rawArgs, ctx, signal, loaders, onCommit, s
     if (isSyncDecisionRequiredError(error)) {
       return { kind: "decision-required", decision: error.decision };
     }
-    ctx.ui.notify(errorMessage(error), "error");
+    ctx.ui.notify(syncErrorGuidance(error), "error");
     return { kind: "failed" };
   }
 }
@@ -374,7 +155,7 @@ async function executeCommand(rawArgs, ctx, signal, loaders, onCommit, setup) {
         await showConfig(ctx, options);
         return { kind: "completed" };
       case "files": {
-        const { showFileSelection } = await import("./chunks/file-selection-4UABOP44.ts");
+        const { showFileSelection } = await import("./chunks/file-selection-FTTKAOYX.ts");
         throwIfAborted(options.signal);
         await showFileSelection(ctx, options.setup, options.signal);
         return { kind: "completed" };
@@ -449,7 +230,7 @@ ${usage()}`, "warning");
     if (isSyncDecisionRequiredError(error)) {
       return { kind: "decision-required", decision: error.decision };
     }
-    ctx.ui.notify(errorMessage(error), "error");
+    ctx.ui.notify(syncErrorGuidance(error), "error");
     return { kind: "failed" };
   }
 }
@@ -476,63 +257,6 @@ async function migrateStateDirectory(ctx, options) {
   }
   ctx.ui.notify(result.message, result.status === "migrated" ? "info" : "warning");
 }
-async function autoSync(ctx, signal, loaders) {
-  try {
-    const partial = await loadPartialConfig();
-    throwIfAborted(signal);
-    if (!partial.automatic) return;
-    await ensureStateDir();
-    throwIfAborted(signal);
-    await loadConfig();
-    throwIfAborted(signal);
-    const operations = await loaders.operations();
-    throwIfAborted(signal);
-    await withLock("auto-sync", () => {
-      throwIfAborted(signal);
-      return operations.syncBoth(ctx, { ...AUTO_SYNC_OPTIONS, signal });
-    });
-  } catch (error) {
-    if (signal.aborted || isMissingConfigError(error)) return;
-    ctx.ui.setStatus(STATUS_KEY, void 0);
-    if (error instanceof RemoteSelectionMismatchError) return error.decision;
-    ctx.ui.notify(`pi-sync auto sync skipped: ${errorMessage(error)}`, "warning");
-  }
-}
-async function autoPushSessions(ctx, signal, loaders) {
-  try {
-    const partial = await loadPartialConfig();
-    throwIfAborted(signal);
-    if (!partial.automatic) return;
-    if (!partial.include.includes("sessions")) return;
-    await ensureStateDir();
-    throwIfAborted(signal);
-    const config = await loadConfig();
-    throwIfAborted(signal);
-    if (!config.include.includes("sessions")) return;
-    const [operations, snapshotModule, syncStateModule] = await Promise.all([
-      loaders.operations(),
-      loaders.snapshot(),
-      loaders.syncState()
-    ]);
-    throwIfAborted(signal);
-    await withLock("auto-session-push", async () => {
-      throwIfAborted(signal);
-      const state = await readStateForConfig(config);
-      throwIfAborted(signal);
-      const local = await snapshotModule.createSnapshot(
-        config.snapshotIdentity,
-        snapshotOptionsForContext(ctx, config)
-      );
-      throwIfAborted(signal);
-      if (!syncStateModule.hasLocalChanges(local, state, config)) return;
-      await operations.push(ctx, { ...AUTO_SYNC_OPTIONS, signal }, { config, state, local });
-    });
-  } catch (error) {
-    if (signal.aborted || isMissingConfigError(error)) return;
-    ctx.ui.setStatus(STATUS_KEY, void 0);
-    ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
-  }
-}
 async function initConfig(ctx, signal) {
   const configPath = localConfigPath();
   if (await readLocalConfigObject()) {
@@ -540,7 +264,7 @@ async function initConfig(ctx, signal) {
     return;
   }
   if (ctx.mode === "tui") {
-    const { showSetupWizard } = await import("./chunks/manager-ui-QO2P4V3Z.ts");
+    const { showSetupWizard } = await import("./chunks/setup-wizard-VB3VDOV5.ts");
     throwIfAborted(signal);
     await showSetupWizard(ctx, signal);
     return;
@@ -565,7 +289,7 @@ async function showConfig(ctx, options) {
       `storage connection: ${config.connectionName}`,
       ...storageLines,
       `storage path: ${config.storagePath}`,
-      `automatic sync: ${config.automatic ? "enabled" : "disabled"}`,
+      `automatic sync: ${automaticSyncSummary(config.automatic)}`,
       `included content: ${config.include.join(", ") || "none"}`,
       `sessions: ${config.include.includes("sessions") ? "included" : "not included"}`,
       `settings file: ${localConfigPath()}`,
@@ -628,27 +352,342 @@ function displayWebDavUrl(value, username) {
     return "invalid (value hidden)";
   }
 }
-function throwIfAborted(signal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+
+// src/commands/command-handler.ts
+var STATUS_KEY2 = "sync";
+async function handleCommand(rawArgs, ctx, sessionSignal, loaders, attention) {
+  await reconcileObservation(attention, sessionSignal);
+  if (sessionSignal.aborted) return;
+  const run = (route, signal, onCommit, target) => executeCommand(
+    route,
+    ctx,
+    combineSignals(sessionSignal, signal),
+    loaders,
+    observationCommitCallback(attention, sessionSignal, onCommit),
+    target
+  );
+  if (!rawArgs.trim()) {
+    try {
+      const { showSyncManager } = await import("./chunks/manager-ui-ABATHC36.ts");
+      if (sessionSignal.aborted) return;
+      await showSyncManager(ctx, run, sessionSignal, {
+        getAttention: () => attention.current(),
+        getObservation: () => attention.observation(),
+        onObservationInvalidated: () => attention.clearObservation(),
+        onSelectionResolved: (expected) => {
+          if (attention.current() === expected) attention.clear(ctx);
+        }
+      });
+    } catch (error) {
+      if (sessionSignal.aborted) return;
+      ctx.ui.setStatus(STATUS_KEY2, void 0);
+      ctx.ui.notify(errorMessage(error), "error");
+    }
+    await reconcileObservation(attention, sessionSignal);
+    if (!sessionSignal.aborted) attention.publish(ctx);
+    return;
+  }
+  const result = await run(rawArgs);
+  if (result.kind === "decision-required") {
+    ctx.ui.notify(result.decision.directMessage, "error");
+  } else if (result.kind === "remote-selection-required") {
+    const origin = directSelectionOrigin(rawArgs);
+    if (origin) attention.set(result.decision, origin);
+    const deterministic = splitArgs(rawArgs).some((arg) => arg === "--yes" || arg === "-y");
+    if (origin && ctx.mode === "tui" && !deterministic) {
+      await resolveSelectionAttention(ctx, attention, sessionSignal, loaders);
+    } else {
+      ctx.ui.notify(
+        formatRemoteSelectionMismatch(
+          result.decision.setupName,
+          result.decision.localInclude,
+          result.decision.remoteInclude
+        ),
+        "error"
+      );
+    }
+  }
+  await clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, sessionSignal);
+  await reconcileSelectionAttention(ctx, attention, sessionSignal);
+  await reconcileObservation(attention, sessionSignal);
+  if (!sessionSignal.aborted) attention.publish(ctx);
+}
+function observationCommitCallback(attention, sessionSignal, onCommit) {
+  const observed = attention.observation();
+  return () => {
+    if (!sessionSignal.aborted && attention.observation() === observed)
+      attention.clearObservation();
+    onCommit?.();
+  };
 }
-function combineSignals(primary, secondary) {
-  return secondary ? AbortSignal.any([primary, secondary]) : primary;
+async function reconcileObservation(attention, signal) {
+  const observed = attention.observation();
+  if (!observed || signal.aborted) return;
+  try {
+    const config = await loadConfig();
+    if (signal.aborted || attention.observation() !== observed) return;
+    if (!observationMatchesConfig(observed, config)) {
+      attention.clearObservation();
+      return;
+    }
+    const state = await readStateForConfig(config);
+    if (signal.aborted || attention.observation() !== observed) return;
+    if (syncStateFingerprint(state) !== observed.inspection.stateIdentity)
+      attention.clearObservation();
+  } catch {
+    if (!signal.aborted && attention.observation() === observed) attention.clearObservation();
+  }
 }
-function snapshotOptionsForContext(ctx, config) {
+async function clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, signal) {
+  if (result.kind !== "completed" || result.outcome === "cancelled" || signal.aborted) return;
+  const [command, ...rest] = splitArgs(rawArgs);
+  if (command !== "sync" && command !== "pull" && command !== "push") return;
+  const current = attention.current();
+  if (!current) return;
+  try {
+    const options = parseOptions(rest);
+    const setupName = options.setup ?? (await loadConfig()).setupName;
+    if (signal.aborted || attention.current() !== current) return;
+    if (current.decision.setupName === setupName) attention.clear(ctx);
+  } catch {
+  }
+}
+async function reconcileSelectionAttention(ctx, attention, signal) {
+  const current = attention.current();
+  if (!current || signal.aborted) return;
+  try {
+    const config = await loadConfig(current.decision.setupName);
+    if (signal.aborted || attention.current() !== current) return;
+    if (!syncAttentionMatchesConfig(current, config)) attention.clear(ctx);
+  } catch {
+    if (!signal.aborted && attention.current() === current) attention.clear(ctx);
+  }
+}
+function directSelectionOrigin(rawArgs) {
+  const command = splitArgs(rawArgs)[0];
+  return command === "sync" || command === "pull" || command === "push" ? command : void 0;
+}
+async function resolveSelectionAttention(ctx, attention, signal, loaders, options = {}) {
+  const current = attention.current();
+  if (!current || signal.aborted) return;
+  const { dispatchManagerResult } = await import("./chunks/manager-result-dispatcher-U23ODD32.ts");
+  if (signal.aborted || attention.current() !== current) return;
+  await dispatchManagerResult(
+    ctx,
+    { kind: "remote-selection-required", decision: current.decision },
+    current.origin,
+    (route, actionSignal, onCommit, target) => {
+      const execute = () => executeRecoveryCommand(
+        route,
+        ctx,
+        combineSignals(signal, actionSignal),
+        loaders,
+        observationCommitCallback(attention, signal, onCommit),
+        target
+      );
+      return options.withStateAccess ? options.withStateAccess(execute) : execute();
+    },
+    signal,
+    {
+      cancelLabel: options.cancelLabel,
+      withStateAccess: options.withStateAccess,
+      onSelectionResolved: () => {
+        if (attention.current() === current) attention.clear(ctx);
+      }
+    }
+  );
+}
+
+// src/settings/config-errors.ts
+function isMissingConfigError(error) {
+  return error instanceof Error && (error.message.startsWith("Missing pi-sync settings.") || error.message === "No sync setups are configured.");
+}
+
+// src/sync/automatic-sync.ts
+var AUTO_SYNC_OPTIONS = {
+  yes: true,
+  force: false,
+  stale: false,
+  silent: true,
+  reload: false,
+  auto: true,
+  args: []
+};
+var STATUS_KEY3 = "sync";
+async function startSession(ctx, signal) {
+  throwIfAborted(signal);
+  const stateNotice = stateDirectoryMigrationNotice();
+  if (stateNotice && ctx.hasUI) ctx.ui.notify(stateNotice, "warning");
+  await recoverSnapshotTransactionsOnStartup();
+  throwIfAborted(signal);
+  try {
+    const names = await configuredSyncSetupNames();
+    throwIfAborted(signal);
+    setSyncSetupCompletions(names);
+  } catch {
+    if (signal.aborted) return;
+    setSyncSetupCompletions([]);
+  }
+  const migrationNotice = consumeLocalConfigMigrationNotice();
+  if (migrationNotice && ctx.hasUI) ctx.ui.notify(migrationNotice, "warning");
+  throwIfAborted(signal);
+  if (!ctx.hasUI) return;
+  try {
+    const config = await loadConfig();
+    throwIfAborted(signal);
+    return config.automatic ? config : void 0;
+  } catch (error) {
+    throwIfAborted(signal);
+    if (!isMissingConfigError(error)) {
+      ctx.ui.notify(
+        `pi-sync startup check skipped: ${safeTerminalText(errorMessage(error))}`,
+        "warning"
+      );
+    }
+  }
+}
+async function autoPushSessions(ctx, signal, loaders) {
+  try {
+    const partial = await loadPartialConfig();
+    throwIfAborted(signal);
+    if (!partial.automatic) return;
+    if (!partial.include.includes("sessions")) return;
+    await ensureStateDir();
+    throwIfAborted(signal);
+    const config = await loadConfig();
+    throwIfAborted(signal);
+    if (!config.include.includes("sessions")) return;
+    const [operations, snapshotModule, syncStateModule] = await Promise.all([
+      loaders.operations(),
+      loaders.snapshot(),
+      loaders.syncState()
+    ]);
+    throwIfAborted(signal);
+    await withLock("auto-session-push", async () => {
+      throwIfAborted(signal);
+      const state = await readStateForConfig(config);
+      throwIfAborted(signal);
+      const local = await snapshotModule.createSnapshot(config.snapshotIdentity, {
+        ...snapshotOptionsForContext(ctx, config),
+        signal
+      });
+      throwIfAborted(signal);
+      if (!syncStateModule.hasLocalChanges(local, state, config)) return;
+      await operations.push(ctx, { ...AUTO_SYNC_OPTIONS, signal }, { config, state, local });
+    });
+  } catch (error) {
+    if (signal.aborted || isMissingConfigError(error)) return;
+    ctx.ui.setStatus(STATUS_KEY3, void 0);
+    ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
+  }
+}
+
+// src/sync/startup-check.ts
+var STATUS_KEY4 = "sync";
+function createStartupCheck(loaders, attention, timeoutMs = 3e4) {
+  let active;
   return {
-    include: config.include,
-    sessionDir: sessionDirFromContext(ctx)
+    start(ctx, sessionSignal, initialConfig) {
+      if (!ctx.hasUI || sessionSignal.aborted) return;
+      if (active) throw new Error("Previous startup check has not been drained.");
+      const controller = new AbortController();
+      const signal = combineSignals(sessionSignal, controller.signal);
+      const task = { controller, owner: ctx.sessionManager, promise: Promise.resolve() };
+      active = task;
+      const isCurrent = () => !sessionSignal.aborted && active === task && task.owner === ctx.sessionManager;
+      const timer = setTimeout(
+        () => controller.abort(new DOMException("Startup check timed out", "TimeoutError")),
+        timeoutMs
+      );
+      let config;
+      let checking = false;
+      task.promise = Promise.resolve().then(async () => {
+        try {
+          throwIfAborted(signal);
+          config = initialConfig ?? await loadConfigForCheck();
+          throwIfAborted(signal);
+          if (!config.automatic) return;
+          const captured = config;
+          const identity = syncCheckConfigFingerprint(captured);
+          checking = true;
+          ctx.ui.setStatus(STATUS_KEY4, "checking in background");
+          const { inspectSync } = await loaders.inspection();
+          throwIfAborted(signal);
+          const currentConfig = await loadConfigForCheck();
+          throwIfAborted(signal);
+          if (syncCheckConfigFingerprint(currentConfig) !== identity) return;
+          const inspection = await withStateDirectoryAccess(() => {
+            throwIfAborted(signal);
+            return withLock("startup-check", () => {
+              throwIfAborted(signal);
+              return inspectSync(captured, snapshotOptionsForContext(ctx, captured), signal);
+            });
+          });
+          throwIfAborted(signal);
+          const latest = await loadConfigForCheck();
+          throwIfAborted(signal);
+          if (syncCheckConfigFingerprint(latest) !== identity) return;
+          const state = await withStateDirectoryAccess(() => readStateForConfig(latest));
+          throwIfAborted(signal);
+          if (syncStateFingerprint(state) !== inspection.stateIdentity || !isCurrent()) return;
+          attention.observe({
+            setupName: captured.setupName,
+            configIdentity: identity,
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            inspection
+          });
+          if (ctx.mode === "rpc") attention.notifyObservation(ctx);
+        } catch (error) {
+          if (!isCurrent() || sessionSignal.aborted || isMissingConfigError(error)) return;
+          if (signal.aborted && controller.signal.reason?.name !== "TimeoutError") return;
+          if (config) {
+            const latest = await loadConfigForCheck().catch(() => void 0);
+            if (!isCurrent() || signal.aborted && controller.signal.reason?.name !== "TimeoutError")
+              return;
+            if (!latest || syncCheckConfigFingerprint(latest) !== syncCheckConfigFingerprint(config))
+              return;
+          }
+          ctx.ui.notify(
+            `pi-sync startup check skipped: ${safeTerminalText(errorMessage(error))}. Run /sync status to retry. No startup transfer was performed.`,
+            "warning"
+          );
+        } finally {
+          clearTimeout(timer);
+          if (isCurrent() && checking) attention.publish(ctx);
+          if (active === task) active = void 0;
+        }
+      }).catch(() => {
+        clearTimeout(timer);
+        if (active === task) active = void 0;
+      });
+    },
+    async stop() {
+      const task = active;
+      if (!task) return;
+      task.controller.abort(new DOMException("Startup check cancelled", "AbortError"));
+      await task.promise;
+    }
   };
 }
-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;
+
+// src/sync/sync-loaders.ts
+function createSyncLoaders(dependencies) {
+  const loaders = {
+    inspection: cachedModuleLoader(
+      dependencies.loadSyncInspection ?? (() => import("./chunks/sync-inspection-FEP4L5TR.ts"))
+    ),
+    setupSwitch: cachedModuleLoader(
+      dependencies.loadSetupSwitch ?? (() => import("./chunks/setup-switch-IS2PEZ3J.ts"))
+    ),
+    snapshot: cachedModuleLoader(
+      dependencies.loadSnapshot ?? (() => import("./chunks/snapshot-HKEWCVK6.ts"))
+    ),
+    syncState: cachedModuleLoader(dependencies.loadSyncState ?? (() => import("./chunks/sync-state-Q2FTXTW6.ts"))),
+    operations: cachedModuleLoader(
+      dependencies.loadSyncOperations ?? (() => import("./chunks/sync-operations-ONJ27QRL.ts"))
+    )
+  };
+  return loaders;
 }
 function cachedModuleLoader(load) {
   let pending;
@@ -662,6 +701,102 @@ function cachedModuleLoader(load) {
     return pending;
   };
 }
+
+// src/sync-extension.ts
+var STATUS_KEY5 = "sync";
+function sync(pi, dependencies = {}) {
+  const loaders = createSyncLoaders(dependencies);
+  const attention = createSyncAttentionController();
+  const check = createStartupCheck(loaders, attention);
+  let sessionAbort = new AbortController();
+  let shutdownAbort;
+  let initialization = Promise.resolve(void 0);
+  pi.registerCommand("sync", {
+    description: "Sync Pi settings through Git, WebDAV, R2, or S3-compatible storage",
+    getArgumentCompletions: completeSyncArguments,
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) {
+        throw new Error(
+          "/sync requires TUI or RPC mode so results and safety prompts are observable."
+        );
+      }
+      const signal = sessionAbort.signal;
+      const ready = await initialization;
+      if (signal.aborted) return;
+      await check.stop();
+      if (signal.aborted) return;
+      const command = splitArgs(args)[0];
+      if (ready === false && command !== "help" && command !== "unlock" && command !== "migrate-state") {
+        ctx.ui.notify(
+          "pi-sync recovery required. Repair the startup error, then /reload before syncing. Use /sync help for recovery guidance.",
+          "error"
+        );
+        return;
+      }
+      const run = () => handleCommand(args, ctx, signal, loaders, attention);
+      if (command === "migrate-state" || command === "help") await run();
+      else await withStateDirectoryAccess(run);
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    shutdownAbort?.abort(new DOMException("Session replaced", "AbortError"));
+    shutdownAbort = void 0;
+    sessionAbort.abort(new DOMException("Session replaced", "AbortError"));
+    sessionAbort = new AbortController();
+    const signal = sessionAbort.signal;
+    attention.reset(ctx);
+    const previous = initialization;
+    initialization = (async () => {
+      await previous;
+      if (signal.aborted) return false;
+      await check.stop();
+      if (signal.aborted) return false;
+      try {
+        const config = await withStateDirectoryAccess(() => startSession(ctx, signal));
+        return signal.aborted ? false : config;
+      } catch (error) {
+        if (!signal.aborted && ctx.hasUI) {
+          ctx.ui.notify(
+            `pi-sync recovery required: ${safeTerminalText(errorMessage(error))}`,
+            "error"
+          );
+        }
+        return false;
+      }
+    })();
+    const ready = await initialization;
+    if (ready && !signal.aborted) check.start(ctx, signal, ready);
+  });
+  pi.on("session_shutdown", async (event, ctx) => {
+    sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
+    attention.reset(ctx);
+    shutdownAbort?.abort(new DOMException("Session shut down again", "AbortError"));
+    const controller = new AbortController();
+    shutdownAbort = controller;
+    const signal = combineSignals(controller.signal, AbortSignal.timeout(3e4));
+    const reason = typeof event === "object" && event ? event.reason : void 0;
+    try {
+      const ready = await initialization;
+      if (signal.aborted) return;
+      await check.stop();
+      if (signal.aborted) return;
+      if (ready !== false && reason !== "reload") {
+        await withStateDirectoryAccess(async () => {
+          if (signal.aborted) return;
+          await autoPushSessions(ctx, signal, loaders);
+        });
+      }
+    } catch (error) {
+      if (!signal.aborted) {
+        ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
+      }
+    } finally {
+      if (shutdownAbort === controller) shutdownAbort = void 0;
+    }
+    if (signal.aborted) return;
+    ctx.ui.setStatus(STATUS_KEY5, void 0);
+  });
+}
 export {
   sync as default
 };