@wuyaos/pi-sync 1.1.0

package/extensions/sync/menus.ts

@@ -0,0 +1,258 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { enhancedSelect } from "../_shared/enhanced-select";
+import {
+  archiveTimestamp,
+  createAgentSkillsZip,
+  createConfigZip,
+  createLegacyZip,
+  createMemoryZip,
+  createSessionsArchiveZip,
+  listArchiveEntries,
+  platformTag,
+  validateArchiveEntries,
+  yieldToUI,
+} from "./archive";
+import { loadConfig, saveConfig, isProjectAllowed, type SyncConfig } from "./config";
+import {
+  extractAgentSkillsZip,
+  extractConfigZip,
+  extractLegacyZip,
+  extractMemoryZip,
+  extractSessionsArchiveZip,
+  getRestorePlan,
+} from "./restore";
+import {
+  describeSessionSelection,
+  listSessionProjects,
+  sessionDirToPath,
+  showSessionProjectSelect,
+  showSessionSyncMenu,
+} from "./session-sync";
+import {
+  downloadFromWebdavDir,
+  listWebdavDir,
+  pruneOldBackupsInDir,
+  sessionsWebdavBase,
+  uploadToWebdavDir,
+  WEBDAV_AGENT_SKILLS_DIR,
+  WEBDAV_CONFIG_DIR,
+  WEBDAV_MEMORY_DIR,
+  WEBDAV_SESSIONS_DIR,
+  webdavAuth,
+  webdavGetFile,
+  webdavList,
+} from "./webdav";
+
+export async function showSetupWizard(ctx: ExtensionCommandContext): Promise<boolean> {
+  const config = loadConfig();
+  ctx.ui.notify("WebDAV is not configured. Please set it up now.", "warning");
+  const url = await ctx.ui.input("WebDAV URL:", config.webdavUrl); if (!url) return false;
+  const user = await ctx.ui.input("WebDAV username:", config.webdavUser); if (!user) return false;
+  const pass = await ctx.ui.input("WebDAV token (or $ENV_VAR):", config.webdavPass); if (!pass) return false;
+  const merged = { ...config, webdavUrl: url.trim(), webdavUser: user.trim(), webdavPass: pass.trim() };
+  saveConfig(merged, ctx);
+  return true;
+}
+
+export async function showConfigureSettings(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig();
+  while (true) {
+    const choice = await enhancedSelect(ctx, "Configure Sync Settings", [
+      `WebDAV URL: ${config.webdavUrl || "(not set)"}`,
+      `WebDAV Username: ${config.webdavUser || "(not set)"}`,
+      `WebDAV Password/Token: ${config.webdavPass ? "(set)" : "(not set)"}`,
+      `Backup Providers & Config: ${config.backupProviders ? "ON" : "OFF"}`,
+      `Backup Skills: ${config.backupSkills ? "ON" : "OFF"}`,
+      `Backup Extensions: ${config.backupExtensions ? "ON" : "OFF"}`,
+      `Backup Memory Markdown: ${config.backupMemory ? "ON" : "OFF"}`,
+      `Backup Shared Agent Skills: ${config.backupAgentSkills ? "ON" : "OFF"}`,
+      `Backup Sessions: ${config.backupSessions ? "ON" : "OFF"}`,
+      `  ↳ Session Projects: ${describeSessionSelection(config)}`,
+      `Session Project Mode: ${config.sessionProjectMode}`,
+      `Sync Every N Turns: ${config.syncIntervalTurns || "OFF"}`,
+      `Sync Session On Exit: ${config.syncSessionOnExit ? "ON" : "OFF"}`,
+      `Max Cloud Backups: ${config.maxBackups === 0 ? "keep all" : config.maxBackups}`,
+      "s Save", "x Back",
+    ]);
+    if (!choice || choice === "x Back") return;
+    if (choice === "s Save") { saveConfig(config, ctx); ctx.ui.notify("Sync configuration updated.", "info"); return; }
+    if (choice.startsWith("WebDAV URL:")) { const value = await ctx.ui.input("WebDAV URL:", config.webdavUrl); if (value) config.webdavUrl = value.trim(); continue; }
+    if (choice.startsWith("WebDAV Username:")) { const value = await ctx.ui.input("WebDAV username:", config.webdavUser); if (value) config.webdavUser = value.trim(); continue; }
+    if (choice.startsWith("WebDAV Password")) { const value = await ctx.ui.input("WebDAV token (or $ENV_VAR):", config.webdavPass); if (value) config.webdavPass = value.trim(); continue; }
+    if (choice.startsWith("Backup Providers")) { config.backupProviders = !config.backupProviders; continue; }
+    if (choice.startsWith("Backup Skills:")) { config.backupSkills = !config.backupSkills; continue; }
+    if (choice.startsWith("Backup Extensions")) { config.backupExtensions = !config.backupExtensions; continue; }
+    if (choice.startsWith("Backup Memory")) { config.backupMemory = !config.backupMemory; continue; }
+    if (choice.startsWith("Backup Shared")) { config.backupAgentSkills = !config.backupAgentSkills; continue; }
+    if (choice.startsWith("Backup Sessions")) { config.backupSessions = !config.backupSessions; continue; }
+    if (choice.startsWith("  ↳")) { await showSessionProjectSelect(ctx, config); continue; }
+    if (choice.startsWith("Session Project Mode")) { config.sessionProjectMode = config.sessionProjectMode === "whitelist" ? "blacklist" : "whitelist"; continue; }
+    if (choice.startsWith("Sync Every")) { const value = await ctx.ui.input("Every N turns (0 = off):", String(config.syncIntervalTurns)); const n = value ? parseInt(value, 10) : NaN; if (n >= 0) config.syncIntervalTurns = n; continue; }
+    if (choice.startsWith("Sync Session On Exit")) { config.syncSessionOnExit = !config.syncSessionOnExit; continue; }
+    if (choice.startsWith("Max Cloud")) { const value = await ctx.ui.input("Maximum backups (0 = all):", String(config.maxBackups)); const n = value ? parseInt(value, 10) : NaN; if (n >= 0) config.maxBackups = n; continue; }
+  }
+}
+
+type BackupKind = "config" | "memory" | "agent-skills";
+
+async function showUploadPackage(ctx: ExtensionCommandContext, kind: BackupKind): Promise<void> {
+  const config = loadConfig();
+  if (kind === "memory" && !config.backupMemory) { ctx.ui.notify("Memory backup is disabled.", "warning"); return; }
+  if (kind === "agent-skills" && !config.backupAgentSkills) { ctx.ui.notify("Shared skills backup is disabled.", "warning"); return; }
+  const timestamp = archiveTimestamp();
+  const meta = kind === "config"
+    ? { filename: `pi_config_${platformTag()}_${timestamp}.tar.xz`, dir: WEBDAV_CONFIG_DIR, prefix: "pi_config_" }
+    : kind === "memory"
+      ? { filename: `memory_${timestamp}.tar.xz`, dir: WEBDAV_MEMORY_DIR, prefix: "memory_" }
+      : { filename: `agent_skills_${timestamp}.tar.xz`, dir: WEBDAV_AGENT_SKILLS_DIR, prefix: "agent_skills_" };
+  const archive = path.join(os.tmpdir(), meta.filename);
+  try {
+    const contents = kind === "config" ? await createConfigZip(config, archive) : kind === "memory" ? await createMemoryZip(archive) : await createAgentSkillsZip(archive);
+    await uploadToWebdavDir(archive, meta.dir, meta.filename, config, ctx);
+    const deleted = await pruneOldBackupsInDir(config, ctx, meta.dir, meta.prefix);
+    ctx.ui.notify(`🎉 Uploaded ${meta.filename}\n${contents.join("\n")}${deleted.length ? `\nPruned: ${deleted.length}` : ""}`, "info");
+  } catch (error) { ctx.ui.notify(`❌ ${kind} backup failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+  finally { fs.rmSync(archive, { force: true }); }
+}
+
+async function showUploadSessionsArchive(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig();
+  const projects = listSessionProjects().filter((project) => isProjectAllowed(project, config));
+  if (!projects.length) { ctx.ui.notify("No allowed local session projects found.", "warning"); return; }
+  const project = await enhancedSelect(ctx, "Archive session project", [...projects, "❌ Cancel"], { fuzzy: true });
+  if (!project || project.includes("Cancel")) return;
+  const filename = `sessions_${platformTag()}_${archiveTimestamp()}.tar.xz`;
+  const archive = path.join(os.tmpdir(), filename), remoteDir = `${WEBDAV_SESSIONS_DIR}${project}/archive/`;
+  try {
+    const contents = await createSessionsArchiveZip(project, archive);
+    await uploadToWebdavDir(archive, remoteDir, filename, config, ctx);
+    await pruneOldBackupsInDir(config, ctx, remoteDir, "sessions_");
+    ctx.ui.notify(`🎉 Uploaded ${filename}\n${contents.join("\n")}`, "info");
+  } catch (error) { ctx.ui.notify(`❌ Session archive failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+  finally { fs.rmSync(archive, { force: true }); }
+}
+
+async function showRestorePackage(ctx: ExtensionCommandContext, kind: BackupKind, autoLatest = false): Promise<boolean> {
+  const config = loadConfig();
+  const meta = kind === "config" ? { dir: WEBDAV_CONFIG_DIR, prefix: "pi_config_" } : kind === "memory" ? { dir: WEBDAV_MEMORY_DIR, prefix: "memory_" } : { dir: WEBDAV_AGENT_SKILLS_DIR, prefix: "agent_skills_" };
+  try {
+    const files = (await listWebdavDir(meta.dir, config, ctx)).filter((name) => name.startsWith(meta.prefix) && name.endsWith(".tar.xz")).sort().reverse();
+    if (!files.length) { ctx.ui.notify(`No ${kind} archives found.`, "warning"); return false; }
+    let selected: string | undefined;
+    if (autoLatest) selected = files[0];
+    else { selected = await enhancedSelect(ctx, `Restore ${kind} archive`, [...files, "❌ Cancel"], { fuzzy: true }); if (!selected || selected.includes("Cancel")) return false; }
+    if (kind === "agent-skills" && !await ctx.ui.confirm("Replace shared skills?", "The current ~/.agents/skills will be moved to a timestamped backup.")) return false;
+    const local = path.join(os.tmpdir(), path.basename(selected));
+    try {
+      await downloadFromWebdavDir(selected, meta.dir, local, config, ctx);
+      const restored = kind === "config" ? await extractConfigZip(local, config) : kind === "memory" ? await extractMemoryZip(local) : await extractAgentSkillsZip(local);
+      ctx.ui.notify(`🎉 Restored ${kind}:\n${restored.join("\n")}`, "info");
+      return true;
+    } finally { fs.rmSync(local, { force: true }); }
+  } catch (error) { ctx.ui.notify(`❌ ${kind} restore failed: ${error instanceof Error ? error.message : String(error)}`, "error"); return false; }
+}
+
+async function showUploadAll(ctx: ExtensionCommandContext): Promise<void> {
+  const results: string[] = [];
+  for (const kind of ["config", "memory", "agent-skills"] as BackupKind[]) {
+    const config = loadConfig();
+    if (kind === "config" && !config.backupProviders) { results.push(`⏭️  config (disabled)`); continue; }
+    if (kind === "memory" && !config.backupMemory) { results.push(`⏭️  memory (disabled)`); continue; }
+    if (kind === "agent-skills" && !config.backupAgentSkills) { results.push(`⏭️  agent-skills (disabled)`); continue; }
+    await showUploadPackage(ctx, kind);
+    results.push(`✅ ${kind}`);
+  }
+  ctx.ui.notify(`Upload All complete:\n${results.join("\n")}\n\n💡 Sessions: use 🗂️ Upload Sessions Archive or 🔄 Session Sync.`, "info");
+}
+
+async function showRestoreAll(ctx: ExtensionCommandContext): Promise<void> {
+  const results: string[] = [];
+  for (const kind of ["config", "memory", "agent-skills"] as BackupKind[]) {
+    const ok = await showRestorePackage(ctx, kind, true);
+    results.push(ok ? `✅ ${kind}` : `⏭️  ${kind} (skipped)`);
+  }
+  ctx.ui.notify(`Restore All complete:\n${results.join("\n")}`, "info");
+  if (results.some((r) => r.startsWith("✅")) && await ctx.ui.confirm("Reload Runtime?", "Reload Pi to apply the restored data?")) await ctx.reload();
+}
+
+async function showRestoreSessionsArchive(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig();
+  try {
+    const projects = await webdavList(sessionsWebdavBase(config), webdavAuth(config), ctx, (name) => name.startsWith("--") && name.endsWith("--"));
+    const project = await enhancedSelect(ctx, "Restore session archive: project", [...projects, "❌ Cancel"], { fuzzy: true }); if (!project || project.includes("Cancel")) return;
+    const remoteDir = `${WEBDAV_SESSIONS_DIR}${project}/archive/`;
+    const files = (await listWebdavDir(remoteDir, config, ctx)).filter((name) => name.startsWith("sessions_") && name.endsWith(".tar.xz")).sort().reverse();
+    const selected = await enhancedSelect(ctx, "Select session archive", [...files, "❌ Cancel"], { fuzzy: true }); if (!selected || selected.includes("Cancel")) return;
+    const local = path.join(os.tmpdir(), path.basename(selected));
+    try { await downloadFromWebdavDir(selected, remoteDir, local, config, ctx); ctx.ui.notify(`🎉 ${(await extractSessionsArchiveZip(local)).join("\n")}`, "info"); }
+    finally { fs.rmSync(local, { force: true }); }
+  } catch (error) { ctx.ui.notify(`❌ Session restore failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+}
+
+async function listLegacyBackups(config: SyncConfig, ctx: ExtensionCommandContext): Promise<string[]> {
+  return (await listWebdavDir("", config, ctx)).filter((name) => name.startsWith("pi_sync_backup_") && (name.endsWith(".tar.xz") || name.endsWith(".zip"))).sort().reverse();
+}
+
+async function showUploadLegacy(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig(), filename = `pi_sync_backup_${archiveTimestamp()}_${platformTag()}.tar.xz`, local = path.join(os.tmpdir(), filename);
+  try { const contents = await createLegacyZip(config, local); await uploadToWebdavDir(local, "", filename, config, ctx); await pruneOldBackupsInDir(config, ctx, "", "pi_sync_backup_"); ctx.ui.notify(`🎉 Legacy backup uploaded\n${contents.join("\n")}`, "info"); }
+  catch (error) { ctx.ui.notify(`❌ Legacy backup failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+  finally { fs.rmSync(local, { force: true }); }
+}
+
+async function showRestoreLegacy(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig();
+  try {
+    const files = await listLegacyBackups(config, ctx); if (!files.length) { ctx.ui.notify("No legacy backups found.", "warning"); return; }
+    const selected = await enhancedSelect(ctx, "Select legacy backup", [...files, "❌ Cancel"], { fuzzy: true }); if (!selected || selected.includes("Cancel")) return;
+    const local = path.join(os.tmpdir(), path.basename(selected));
+    try {
+      await downloadFromWebdavDir(selected, "", local, config, ctx);
+      const entries = await listArchiveEntries(local); validateArchiveEntries(entries);
+      if (!await ctx.ui.confirm("Confirm restore?", [`Entries: ${entries.length}`, ...getRestorePlan(entries, config)].join("\n"))) return;
+      await yieldToUI();
+      const restored = await extractLegacyZip(local, config); ctx.ui.notify(`🎉 Restored:\n${restored.join("\n")}`, "info");
+      if (await ctx.ui.confirm("Reload Runtime?", "Reload Pi now?")) await ctx.reload();
+    } finally { fs.rmSync(local, { force: true }); }
+  } catch (error) { ctx.ui.notify(`❌ Legacy restore failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+}
+
+export async function handleSyncCommand(ctx: ExtensionCommandContext): Promise<void> {
+  let config = loadConfig();
+  if (!config.webdavUrl || !config.webdavUser || !config.webdavPass) { if (!await showSetupWizard(ctx)) return; config = loadConfig(); }
+  const choice = await enhancedSelect(ctx, "Pi WebDAV Synchronization", [
+    "⬆️  Upload All (config + memory + skills)", "⬇️  Restore All (latest)",
+    "☁️  Upload Config Backup", "🧠 Upload Memory Backup", "📦 Upload Skills Snapshot", "🗂️  Upload Sessions Archive",
+    "📥 Restore Config Backup", "📥 Restore Memory Backup", "📥 Restore Skills Snapshot", "📥 Restore Sessions Archive",
+    "🔄 Session Sync", "🧰 Legacy Monolithic Backup/Restore", "⚙️  Configure Sync Settings", "❌  Cancel",
+  ]);
+  if (!choice || choice.includes("Cancel")) return;
+  if (choice.startsWith("⬆️  Upload All")) return showUploadAll(ctx);
+  if (choice.startsWith("⬇️  Restore All")) return showRestoreAll(ctx);
+  if (choice.includes("Configure")) return showConfigureSettings(ctx);
+  if (choice === "☁️  Upload Config Backup") return showUploadPackage(ctx, "config");
+  if (choice === "🧠 Upload Memory Backup") return showUploadPackage(ctx, "memory");
+  if (choice === "📦 Upload Skills Snapshot") return showUploadPackage(ctx, "agent-skills");
+  if (choice === "🗂️  Upload Sessions Archive") return showUploadSessionsArchive(ctx);
+  if (choice === "📥 Restore Config Backup") return showRestorePackage(ctx, "config");
+  if (choice === "📥 Restore Memory Backup") return showRestorePackage(ctx, "memory");
+  if (choice === "📥 Restore Skills Snapshot") return showRestorePackage(ctx, "agent-skills");
+  if (choice === "📥 Restore Sessions Archive") return showRestoreSessionsArchive(ctx);
+  if (choice.startsWith("🔄")) return showSessionSyncMenu(ctx);
+  if (choice.startsWith("🧰")) {
+    const action = await enhancedSelect(ctx, "Legacy backup", ["Upload legacy backup", "Restore legacy backup", "❌ Cancel"]);
+    if (action?.startsWith("Upload")) return showUploadLegacy(ctx);
+    if (action?.startsWith("Restore")) return showRestoreLegacy(ctx);
+  }
+}
+
+export function registerSyncCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("sync", {
+    description: "Sync configurations, skills, extensions, and sessions via WebDAV",
+    getArgumentCompletions: () => null,
+    handler: async (_args, ctx) => handleSyncCommand(ctx),
+  });
+}

package/extensions/sync/restore.ts

@@ -0,0 +1,140 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { timestampForBackup } from "../_shared/json-io";
+import { copyRecursiveSync, listArchiveEntries, runTar, validateArchiveEntries } from "./archive";
+import {
+  AGENT_DIR,
+  AGENT_ROOT_MARKDOWN_FILES,
+  AGENT_SKILLS_DIR,
+  MEMORY_MARKDOWN_FILES,
+  SESSIONS_DIR,
+  ensureDir,
+  type SyncConfig,
+} from "./config";
+
+async function extractToTemp(archivePath: string, prefix: string): Promise<string> {
+  const tempDir = path.join(os.tmpdir(), `${prefix}_${Date.now()}`);
+  ensureDir(tempDir);
+  validateArchiveEntries(await listArchiveEntries(archivePath));
+  await runTar(["-x", "-f", archivePath, "-C", tempDir]);
+  return tempDir;
+}
+
+function backupAndCopyFile(src: string, dest: string): void {
+  ensureDir(path.dirname(dest));
+  if (fs.existsSync(dest) && fs.statSync(dest).isFile()) fs.copyFileSync(dest, `${dest}.bak-${timestampForBackup()}`);
+  fs.copyFileSync(src, dest);
+}
+
+export function getRestorePlan(entries: string[], config: SyncConfig): string[] {
+  const has = (name: string) => entries.some((entry) => entry === name || entry.startsWith(`${name}/`));
+  const plan: string[] = [];
+  if (has("config")) plan.push(config.backupProviders ? "Config files will be overwritten after timestamped .bak copies are created." : "Config files are present but skipped by current settings.");
+  if (has("skills")) plan.push(config.backupSkills ? "Pi skills will be replaced after a timestamped directory backup." : "Pi skills are present but skipped by current settings.");
+  if (has("extensions")) plan.push(config.backupExtensions ? "Extensions will be merged after a timestamped directory backup." : "Extensions are present but skipped by current settings.");
+  if (has("sessions")) plan.push(config.backupSessions ? "Sessions will be merged into ~/.pi/agent/sessions/." : "Sessions are present but skipped by current settings.");
+  if (has("memory")) plan.push(config.backupMemory ? "Durable memory markdown files will be restored after .bak copies." : "Memory files are present but skipped by current settings.");
+  if (has("agent-skills")) plan.push(config.backupAgentSkills ? "~/.agents/skills will be replaced after moving the current directory to a backup." : "Shared skills are present but skipped by current settings.");
+  return plan.length ? plan : ["No restorable content was found in this archive."];
+}
+
+export async function extractConfigZip(archivePath: string, config: SyncConfig): Promise<string[]> {
+  const tempDir = await extractToTemp(archivePath, "pi_config_extract");
+  const restored: string[] = [];
+  try {
+    const root = path.join(tempDir, "config", "root");
+    if (config.backupProviders && fs.existsSync(root)) {
+      const allowedMd = new Set<string>(AGENT_ROOT_MARKDOWN_FILES);
+      for (const name of fs.readdirSync(root)) {
+        const src = path.join(root, name);
+        if (!fs.statSync(src).isFile() || (!name.endsWith(".json") && !allowedMd.has(name))) continue;
+        backupAndCopyFile(src, path.join(AGENT_DIR, name));
+        restored.push(`Config: ${name}`);
+      }
+    }
+    const sub = path.join(tempDir, "config", "sub");
+    if (config.backupProviders && fs.existsSync(sub)) {
+      const dest = path.join(AGENT_DIR, "config");
+      if (fs.existsSync(dest)) copyRecursiveSync(dest, path.join(AGENT_DIR, `config-backup-${timestampForBackup()}`));
+      copyRecursiveSync(sub, dest);
+      restored.push("Config directory");
+    }
+    const extensions = path.join(tempDir, "extensions");
+    if (config.backupExtensions && fs.existsSync(extensions)) {
+      const dest = path.join(AGENT_DIR, "extensions");
+      if (fs.existsSync(dest)) copyRecursiveSync(dest, path.join(AGENT_DIR, `extensions-backup-${timestampForBackup()}`));
+      copyRecursiveSync(extensions, dest);
+      restored.push("Extensions");
+    }
+    return restored;
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function extractMemoryZip(archivePath: string): Promise<string[]> {
+  const tempDir = await extractToTemp(archivePath, "pi_memory_extract");
+  const destDir = path.join(AGENT_DIR, "pi-hermes-memory");
+  const restored: string[] = [];
+  try {
+    for (const name of MEMORY_MARKDOWN_FILES) {
+      const src = path.join(tempDir, "memory", name);
+      if (!fs.existsSync(src)) continue;
+      backupAndCopyFile(src, path.join(destDir, name));
+      restored.push(name);
+    }
+    return restored;
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function extractAgentSkillsZip(archivePath: string): Promise<string[]> {
+  const tempDir = await extractToTemp(archivePath, "pi_agent_skills_extract");
+  try {
+    const source = path.join(tempDir, "agent-skills");
+    if (!fs.existsSync(source)) throw new Error("Archive does not contain agent-skills/.");
+    const backup = path.join(os.homedir(), ".agents", `skills-backup-${timestampForBackup()}`);
+    if (fs.existsSync(AGENT_SKILLS_DIR)) fs.renameSync(AGENT_SKILLS_DIR, backup);
+    copyRecursiveSync(source, AGENT_SKILLS_DIR);
+    return [`Shared skills; previous directory moved to ${backup}`];
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function extractSessionsArchiveZip(archivePath: string): Promise<string[]> {
+  const tempDir = await extractToTemp(archivePath, "pi_sessions_extract");
+  try {
+    const source = path.join(tempDir, "sessions");
+    if (!fs.existsSync(source)) throw new Error("Archive does not contain sessions/.");
+    copyRecursiveSync(source, SESSIONS_DIR);
+    return ["Session archive merged"];
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function extractLegacyZip(archivePath: string, config: SyncConfig): Promise<string[]> {
+  const tempDir = await extractToTemp(archivePath, "pi_sync_extract");
+  const restored: string[] = [];
+  try {
+    const configDir = path.join(tempDir, "config");
+    if (config.backupProviders && fs.existsSync(configDir)) {
+      for (const name of fs.readdirSync(configDir)) {
+        const src = path.join(configDir, name);
+        if (fs.statSync(src).isFile()) { backupAndCopyFile(src, path.join(AGENT_DIR, name)); restored.push(`Config: ${name}`); }
+      }
+    }
+    const skills = path.join(tempDir, "skills");
+    if (config.backupSkills && fs.existsSync(skills)) {
+      const dest = path.join(AGENT_DIR, "skills"), backup = path.join(AGENT_DIR, `skills-backup-${timestampForBackup()}`);
+      if (fs.existsSync(dest)) fs.renameSync(dest, backup);
+      copyRecursiveSync(skills, dest);
+      restored.push("Skills");
+    }
+    const extensions = path.join(tempDir, "extensions");
+    if (config.backupExtensions && fs.existsSync(extensions)) {
+      const dest = path.join(AGENT_DIR, "extensions");
+      if (fs.existsSync(dest)) copyRecursiveSync(dest, path.join(AGENT_DIR, `extensions-backup-${timestampForBackup()}`));
+      copyRecursiveSync(extensions, dest);
+      restored.push("Extensions");
+    }
+    const sessions = path.join(tempDir, "sessions");
+    if (config.backupSessions && fs.existsSync(sessions)) { copyRecursiveSync(sessions, SESSIONS_DIR); restored.push("Sessions"); }
+    return restored;
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}

package/extensions/sync/session-sync.ts

@@ -0,0 +1,231 @@
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { enhancedSelect } from "../_shared/enhanced-select";
+import { readJsonSafe } from "../_shared/json-io";
+import { extractSessionTs } from "./archive";
+import { SESSIONS_DIR, ensureDir, isProjectAllowed, loadConfig, saveConfig, type SyncConfig } from "./config";
+import { ensureWebdavDirectory, sessionsWebdavBase, WEBDAV_SESSIONS_DIR, webdavAuth, webdavGetFile, webdavList, webdavPutFile } from "./webdav";
+
+export interface SessionSyncState {
+  currentSessionFile?: string;
+  currentProjectDir?: string;
+  liveBackupTimer?: ReturnType<typeof setTimeout>;
+  turnCounter: number;
+}
+
+const state: SessionSyncState = { turnCounter: 0 };
+
+export function setSessionContext(file?: string, dir?: string): void {
+  state.currentSessionFile = file;
+  state.currentProjectDir = dir ? path.basename(dir) : undefined;
+  state.turnCounter = 0;
+}
+
+export function refreshSessionFile(file?: string): void {
+  state.currentSessionFile = file ?? state.currentSessionFile;
+}
+
+export function getCurrentSessionFile(): string | undefined {
+  return state.currentSessionFile;
+}
+
+export function incrementTurnAndShouldSync(interval: number): boolean {
+  if (interval <= 0) return false;
+  state.turnCounter++;
+  return state.turnCounter % interval === 0;
+}
+
+export function currentProjectIsAllowed(config: SyncConfig): boolean {
+  return isProjectAllowed(state.currentProjectDir, config);
+}
+
+export function listSessionProjects(): string[] {
+  if (!fs.existsSync(SESSIONS_DIR)) return [];
+  return fs.readdirSync(SESSIONS_DIR, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith("--") && entry.name.endsWith("--"))
+    .map((entry) => entry.name)
+    .sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" }));
+}
+
+export function sessionDirToPath(dirName: string): string {
+  let value = dirName;
+  if (value.startsWith("--")) value = value.slice(2);
+  if (value.endsWith("--")) value = value.slice(0, -2);
+  return value ? `/${value.replace(/-/g, "/")}` : dirName;
+}
+
+export function projectDirFromCwd(cwd: string): string {
+  return `--${cwd.replace(/\//g, "-")}--`;
+}
+
+export function describeSessionSelection(config: SyncConfig): string {
+  const count = config.sessionProjects.length;
+  if (count === 0) return config.sessionProjectMode === "whitelist" ? `whitelist: 0 projects (none)` : `blacklist: ALL projects (empty = all)`;
+  return `${config.sessionProjectMode}: ${count} project${count === 1 ? "" : "s"}`;
+}
+
+export async function updateLatestMarker(ctx: ExtensionContext, config: SyncConfig, projectDir: string, sessionFile: string): Promise<void> {
+  const filename = path.basename(sessionFile), sessionTs = extractSessionTs(filename);
+  if (!sessionTs) return;
+  const markerUrl = sessionsWebdavBase(config) + encodeURIComponent(projectDir) + "/_latest.json";
+  const temp = path.join(os.tmpdir(), `pi_latest_${process.pid}_${Date.now()}.json`);
+  let remoteTs: string | undefined;
+  try {
+    try { await webdavGetFile(markerUrl, temp, webdavAuth(config), ctx); remoteTs = readJsonSafe<{ sessionTs?: string }>(temp, {}).sessionTs; }
+    catch (error) { if (!(error instanceof Error) || !/HTTP 404/.test(error.message)) throw error; }
+    if (remoteTs && remoteTs >= sessionTs) return;
+    fs.writeFileSync(temp, JSON.stringify({ file: filename, sessionTs, machine: os.hostname(), uploadedAt: new Date().toISOString() }, null, 2));
+    await webdavPutFile(temp, markerUrl, webdavAuth(config), ctx);
+  } finally { fs.rmSync(temp, { force: true }); }
+}
+
+export async function uploadCurrentSession(ctx: ExtensionContext, silent = false): Promise<boolean> {
+  const config = loadConfig();
+  if (!state.currentSessionFile || !state.currentProjectDir) {
+    if (!silent) ctx.ui.notify("No active session file to upload.", "warning");
+    return false;
+  }
+  if (!isProjectAllowed(state.currentProjectDir, config)) return false;
+  if (!fs.existsSync(state.currentSessionFile)) {
+    if (!silent) ctx.ui.notify(`Session file missing: ${state.currentSessionFile}`, "warning");
+    return false;
+  }
+  try {
+    await ensureWebdavDirectory(`${WEBDAV_SESSIONS_DIR}${state.currentProjectDir}/`, config, ctx);
+    const remote = sessionsWebdavBase(config) + encodeURIComponent(state.currentProjectDir) + "/" + encodeURIComponent(path.basename(state.currentSessionFile));
+    await webdavPutFile(state.currentSessionFile, remote, webdavAuth(config), ctx);
+    await updateLatestMarker(ctx, config, state.currentProjectDir, state.currentSessionFile);
+    if (!silent) ctx.ui.notify(`☁️  Session uploaded: ${path.basename(state.currentSessionFile)}`, "info");
+    return true;
+  } catch (error) {
+    if (!silent) ctx.ui.notify(`❌ Session upload failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+    return false;
+  }
+}
+
+export function scheduleLiveBackup(ctx: ExtensionContext): void {
+  const config = loadConfig();
+  if (!config.liveSessionBackup || !currentProjectIsAllowed(config)) return;
+  clearLiveBackupTimer();
+  state.liveBackupTimer = setTimeout(() => {
+    state.liveBackupTimer = undefined;
+    uploadCurrentSession(ctx, true).catch(() => { /* silent */ });
+  }, config.liveBackupDebounceMs);
+}
+
+export function clearLiveBackupTimer(): void {
+  if (state.liveBackupTimer) clearTimeout(state.liveBackupTimer);
+  state.liveBackupTimer = undefined;
+}
+
+async function listRemoteProjects(config: SyncConfig, ctx: ExtensionContext): Promise<string[]> {
+  try { return await webdavList(sessionsWebdavBase(config), webdavAuth(config), ctx, (name) => name.startsWith("--") && name.endsWith("--")); }
+  catch (error) { if (error instanceof Error && /HTTP 404/.test(error.message)) return []; throw error; }
+}
+
+export async function showRestoreLatest(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig();
+  try {
+    const projects = await listRemoteProjects(config, ctx);
+    if (!projects.length) { ctx.ui.notify("No remote session projects found.", "warning"); return; }
+    const project = await enhancedSelect(ctx, "Restore latest: select project", [...projects, "❌ Cancel"], { fuzzy: true });
+    if (!project || project.includes("Cancel")) return;
+    const markerPath = path.join(os.tmpdir(), `pi_latest_${Date.now()}.json`);
+    try {
+      const base = sessionsWebdavBase(config) + encodeURIComponent(project) + "/";
+      await webdavGetFile(base + "_latest.json", markerPath, webdavAuth(config), ctx);
+      const marker = readJsonSafe<{ file?: string }>(markerPath, {});
+      if (!marker.file || !marker.file.endsWith(".jsonl") || path.basename(marker.file) !== marker.file) throw new Error("Remote _latest.json has no safe session filename.");
+      const localDir = path.join(SESSIONS_DIR, project); ensureDir(localDir);
+      const localPath = path.join(localDir, marker.file);
+      await webdavGetFile(base + encodeURIComponent(marker.file), localPath, webdavAuth(config), ctx);
+      ctx.ui.notify(`🎉 Restored latest session into ${localPath}\nUse /resume to continue.`, "info");
+    } finally { fs.rmSync(markerPath, { force: true }); }
+  } catch (error) { ctx.ui.notify(`❌ Restore latest failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+}
+
+export async function showRestoreSessions(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig();
+  try {
+    const projects = await listRemoteProjects(config, ctx);
+    if (!projects.length) { ctx.ui.notify("No remote session projects found.", "warning"); return; }
+    const project = await enhancedSelect(ctx, "Select remote project to restore", [...projects, "❌ Cancel"], { fuzzy: true });
+    if (!project || project.includes("Cancel")) return;
+    const base = sessionsWebdavBase(config) + encodeURIComponent(project) + "/";
+    const files = await webdavList(base, webdavAuth(config), ctx, (name) => name.endsWith(".jsonl"));
+    if (!files.length) { ctx.ui.notify(`No .jsonl files in ${project}.`, "warning"); return; }
+    const choice = await enhancedSelect(ctx, `Restore from ${project}`, [...files, "a Restore ALL", "❌ Cancel"], { fuzzy: true });
+    if (!choice || choice.includes("Cancel")) return;
+    const targets = choice === "a Restore ALL" ? files : [choice];
+    const localDir = path.join(SESSIONS_DIR, project); ensureDir(localDir);
+    for (const file of targets) await webdavGetFile(base + encodeURIComponent(file), path.join(localDir, file), webdavAuth(config), ctx);
+    ctx.ui.notify(`🎉 Restored ${targets.length} session(s) into ${localDir}`, "info");
+  } catch (error) { ctx.ui.notify(`❌ Restore failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+}
+
+export async function showForkSession(ctx: ExtensionCommandContext): Promise<void> {
+  const config = loadConfig();
+  try {
+    const projects = await listRemoteProjects(config, ctx);
+    if (!projects.length) { ctx.ui.notify("No remote session projects found.", "warning"); return; }
+    const project = await enhancedSelect(ctx, "Fork: select source project", [...projects, "❌ Cancel"], { fuzzy: true });
+    if (!project || project.includes("Cancel")) return;
+    const base = sessionsWebdavBase(config) + encodeURIComponent(project) + "/";
+    const files = await webdavList(base, webdavAuth(config), ctx, (name) => name.endsWith(".jsonl"));
+    const file = await enhancedSelect(ctx, "Fork: select session", [...files, "❌ Cancel"], { fuzzy: true });
+    if (!file || file.includes("Cancel")) return;
+    const temp = path.join(os.tmpdir(), `pi_fork_${Date.now()}.jsonl`);
+    try {
+      await webdavGetFile(base + encodeURIComponent(file), temp, webdavAuth(config), ctx);
+      const manager = SessionManager.forkFrom(temp, process.cwd());
+      ctx.ui.notify(`🎉 Forked into: ${manager.getSessionFile() ?? "(unknown)"}`, "info");
+    } finally { fs.rmSync(temp, { force: true }); }
+  } catch (error) { ctx.ui.notify(`❌ Fork failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }
+}
+
+export async function showSessionProjectSelect(ctx: ExtensionCommandContext, config: SyncConfig): Promise<void> {
+  while (true) {
+    const projects = listSessionProjects();
+    if (!projects.length) { ctx.ui.notify("No local session projects found.", "warning"); return; }
+    const selected = new Set(config.sessionProjects);
+    const items = projects.map((dir) => `${selected.has(dir) ? "[x]" : "[ ]"} ${sessionDirToPath(dir)}`);
+    items.push("───────────────", `m Switch to ${config.sessionProjectMode === "whitelist" ? "blacklist" : "whitelist"} mode`, "a Select All", "r Reset list", "x Back");
+    const label = config.sessionProjectMode === "whitelist" ? "白名单模式" : "黑名单模式";
+    const choice = await enhancedSelect(ctx, `Select Session Projects [${label}]`, items, { fuzzy: true });
+    if (!choice || choice === "x Back") { saveConfig(config, ctx); return; }
+    if (choice.startsWith("m Switch")) { config.sessionProjectMode = config.sessionProjectMode === "whitelist" ? "blacklist" : "whitelist"; saveConfig(config, ctx); continue; }
+    if (choice === "a Select All") { config.sessionProjects = [...projects]; saveConfig(config, ctx); continue; }
+    if (choice.startsWith("r Reset")) { config.sessionProjects = []; saveConfig(config, ctx); continue; }
+    const match = choice.match(/^\[[ x]\]\s+(.*)$/); if (!match) continue;
+    const dir = projects.find((candidate) => sessionDirToPath(candidate) === match[1]); if (!dir) continue;
+    config.sessionProjects = selected.has(dir) ? config.sessionProjects.filter((item) => item !== dir) : [...config.sessionProjects, dir];
+    saveConfig(config, ctx);
+  }
+}
+
+export async function showSessionSyncMenu(ctx: ExtensionCommandContext): Promise<void> {
+  while (true) {
+    const config = loadConfig();
+    const current = state.currentSessionFile ? path.basename(state.currentSessionFile) : "(none)";
+    const choice = await enhancedSelect(ctx, "Session Sync", [
+      `⚡ Live Backup: ${config.liveSessionBackup ? "ON" : "OFF"}`,
+      `  ↳ Debounce: ${config.liveBackupDebounceMs}ms`,
+      `🔄 Sync Interval: ${config.syncIntervalTurns === 0 ? "OFF" : `every ${config.syncIntervalTurns} turns`}`,
+      `📤 Sync On Exit: ${config.syncSessionOnExit ? "ON" : "OFF"}`,
+      `☁️  Upload Current Session Now  (cur: ${current})`,
+      "📥 Restore Latest Session", "📥 Restore Sessions", "🌿 Fork Remote Session", "x Back",
+    ]);
+    if (!choice || choice === "x Back") return;
+    if (choice.startsWith("⚡")) { config.liveSessionBackup = !config.liveSessionBackup; saveConfig(config, ctx); continue; }
+    if (choice.startsWith("  ↳")) { const value = await ctx.ui.input("Debounce ms:", String(config.liveBackupDebounceMs)); const n = value ? parseInt(value, 10) : NaN; if (n > 0) { config.liveBackupDebounceMs = n; saveConfig(config, ctx); } continue; }
+    if (choice.startsWith("🔄")) { const value = await ctx.ui.input("Upload every N turns (0 = off):", String(config.syncIntervalTurns)); const n = value ? parseInt(value, 10) : NaN; if (n >= 0) { config.syncIntervalTurns = n; saveConfig(config, ctx); } continue; }
+    if (choice.startsWith("📤")) { config.syncSessionOnExit = !config.syncSessionOnExit; saveConfig(config, ctx); continue; }
+    if (choice.startsWith("☁️")) { await uploadCurrentSession(ctx); continue; }
+    if (choice.startsWith("📥 Restore Latest")) { await showRestoreLatest(ctx); continue; }
+    if (choice.startsWith("📥 Restore Sessions")) { await showRestoreSessions(ctx); continue; }
+    if (choice.startsWith("🌿")) { await showForkSession(ctx); continue; }
+  }
+}