@wuyaos/pi-sync 1.1.0 → 1.2.0

package/extensions/sync/config.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { ensureDir as ensureSharedDir, readJsonSafe, writeJsonAtomic } from "../_shared/json-io";
+import { normalizeLanguage, type SyncLanguage } from "./i18n";
 
 export const AGENT_DIR = path.join(os.homedir(), ".pi", "agent");
 export const AGENT_SKILLS_DIR = path.join(os.homedir(), ".agents", "skills");
@@ -10,8 +11,11 @@ export const SESSIONS_DIR = path.join(AGENT_DIR, "sessions");
 export const SYNC_CONFIG_DIR = path.join(AGENT_DIR, "config");
 export const SYNC_CONFIG_PATH = path.join(SYNC_CONFIG_DIR, "sync.json");
 export const LEGACY_SYNC_CONFIG_PATH = path.join(AGENT_DIR, "sync_config.json");
-export const AGENT_ROOT_MARKDOWN_FILES = ["SYSTEM.md", "AGENTS.md", "APPEND_SYSTEM.md"] as const;
-export const MEMORY_MARKDOWN_FILES = ["USER.md", "MEMORY.md", "failures.md"] as const;
+export const DEFAULT_PI_EXCLUDE_PATHS = ["npm", "git", "sessions", "state", "tmp", "webui-rpc-supervisor", "vstack"] as const;
+const LEGACY_DEFAULT_PI_EXCLUDE_PATH_SETS = [
+  ["npm", "git", "sessions", "state", "vstack"],
+  ["npm", "git", "sessions", "state", "tmp", "vstack"],
+] as const;
 
 export type ManifestFile = { archive: string; source: string };
 
@@ -19,17 +23,13 @@ export interface SyncConfig {
   webdavUrl: string;
   webdavUser: string;
   webdavPass: string;
+  language: SyncLanguage;
   backupProviders: boolean;
-  backupSkills: boolean;
-  backupExtensions: boolean;
   backupSessions: boolean;
-  sessionProjects: string[];
-  liveSessionBackup: boolean;
-  liveBackupDebounceMs: number;
-  syncIntervalTurns: number;
-  syncSessionOnExit: boolean;
-  backupMemory: boolean;
   backupAgentSkills: boolean;
+  piExcludePaths: string[];
+  backupOnExit: boolean;
+  sessionProjects: string[];
   sessionProjectMode: "whitelist" | "blacklist";
   maxBackups: number;
 }
@@ -38,46 +38,76 @@ export function ensureDir(dir: string): void {
   ensureSharedDir(dir);
 }
 
+export function normalizePiExcludePaths(value: unknown): string[] {
+  const source = Array.isArray(value) ? value : DEFAULT_PI_EXCLUDE_PATHS;
+  const normalized = new Set<string>();
+  for (const raw of source) {
+    const candidate = String(raw).trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+    if (!candidate || candidate.startsWith("/") || /^[a-zA-Z]:\//.test(candidate)) continue;
+    if (candidate.split("/").includes("..")) continue;
+    normalized.add(candidate);
+  }
+  return [...normalized];
+}
+
+function isLegacyDefaultPiExcludePaths(value: unknown): boolean {
+  if (!Array.isArray(value)) return false;
+  const normalized = normalizePiExcludePaths(value);
+  return LEGACY_DEFAULT_PI_EXCLUDE_PATH_SETS.some((legacy) => (
+    normalized.length === legacy.length && legacy.every((entry) => normalized.includes(entry))
+  ));
+}
+
+function defaultLanguage(): SyncLanguage {
+  const settings = readJsonSafe<{ piSwitch?: { language?: unknown } }>(path.join(AGENT_DIR, "settings.json"), {});
+  return normalizeLanguage(settings.piSwitch?.language);
+}
+
+/** In-memory config cache, invalidated on saveConfig. Avoids per-hook disk reads. */
+let configCache: SyncConfig | null = null;
+
 export function loadConfig(): SyncConfig {
+  if (configCache) return configCache;
   if (!fs.existsSync(SYNC_CONFIG_PATH) && fs.existsSync(LEGACY_SYNC_CONFIG_PATH)) {
     ensureDir(SYNC_CONFIG_DIR);
-    try { fs.copyFileSync(LEGACY_SYNC_CONFIG_PATH, SYNC_CONFIG_PATH); } catch { /* best effort migration */ }
+    try {
+      fs.copyFileSync(LEGACY_SYNC_CONFIG_PATH, SYNC_CONFIG_PATH);
+    } catch (error) {
+      console.warn(`[pi-sync] Failed to migrate legacy sync config: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
   const data = readJsonSafe<Partial<SyncConfig>>(SYNC_CONFIG_PATH, {});
   const normalizeList = (value: unknown): string[] => Array.isArray(value) ? value.map(String).filter(Boolean) : [];
-  return {
+  const result: SyncConfig = {
     webdavUrl: data.webdavUrl || "",
     webdavUser: data.webdavUser || "",
     webdavPass: data.webdavPass || "",
+    language: data.language ? normalizeLanguage(data.language) : defaultLanguage(),
     backupProviders: data.backupProviders !== false,
-    backupSkills: data.backupSkills !== false,
-    backupExtensions: data.backupExtensions !== false,
-    backupSessions: data.backupSessions === true,
+    backupSessions: data.backupSessions !== false,
+    backupAgentSkills: data.backupAgentSkills === true,
+    piExcludePaths: isLegacyDefaultPiExcludePaths(data.piExcludePaths)
+      ? [...DEFAULT_PI_EXCLUDE_PATHS]
+      : normalizePiExcludePaths(data.piExcludePaths),
+    backupOnExit: data.backupOnExit !== false,
     sessionProjects: normalizeList(data.sessionProjects),
-    liveSessionBackup: data.liveSessionBackup === true,
-    liveBackupDebounceMs: typeof data.liveBackupDebounceMs === "number" && data.liveBackupDebounceMs > 0 ? data.liveBackupDebounceMs : 3000,
-    syncIntervalTurns: typeof data.syncIntervalTurns === "number" && data.syncIntervalTurns >= 0 ? Math.floor(data.syncIntervalTurns) : 0,
-    syncSessionOnExit: data.syncSessionOnExit !== false,
-    backupMemory: data.backupMemory !== false,
-    backupAgentSkills: data.backupAgentSkills !== false,
-    sessionProjectMode: data.sessionProjectMode === "blacklist" ? "blacklist" : "whitelist",
+    sessionProjectMode: data.sessionProjectMode === "whitelist" ? "whitelist" : "blacklist",
     maxBackups: typeof data.maxBackups === "number" && data.maxBackups >= 0 ? Math.floor(data.maxBackups) : 10,
   };
+  configCache = result;
+  return result;
 }
 
 export function saveConfig(config: SyncConfig, ctx?: Pick<ExtensionContext, "ui">): void {
   ensureDir(path.dirname(SYNC_CONFIG_PATH));
   writeJsonAtomic(SYNC_CONFIG_PATH, config, { backup: true });
+  configCache = config;
   if (ctx) refreshFooterStatusFromConfig(ctx, config);
 }
 
 /** Refresh footer status from an already-loaded config (avoids re-reading the file). */
 export function refreshFooterStatusFromConfig(ctx: Pick<ExtensionContext, "ui">, config: SyncConfig): void {
-  const parts: string[] = [];
-  if (config.liveSessionBackup) parts.push("⚡");
-  if (config.syncIntervalTurns > 0) parts.push(`🔄${config.syncIntervalTurns}`);
-  if (config.syncSessionOnExit) parts.push("📤");
-  ctx.ui.setStatus("pi-sync", parts.length ? `sync:${parts.join("")}` : undefined);
+  ctx.ui.setStatus("pi-sync", config.backupOnExit ? "backup:exit" : undefined);
 }
 
 export function isProjectAllowed(projectDir: string | undefined, config: SyncConfig): boolean {

package/extensions/sync/i18n.ts

@@ -0,0 +1,203 @@
+export type SyncLanguage = "en" | "zh";
+
+const EN = {
+  on: "ON",
+  off: "OFF",
+  enabled: "enabled",
+  disabled: "disabled",
+  keepAll: "keep all",
+  cancel: "❌ Cancel",
+  back: "x Back",
+  save: "s Save",
+
+  menuTitle: "Pi WebDAV Backup",
+  uploadAllBackups: "⬆️  Back Up All",
+  restoreAllBackups: "⬇️  Restore All (latest)",
+  uploadPiBackup: "☁️  Upload Pi Backup",
+  uploadSkillsBackup: "📦 Upload Skills Backup",
+  uploadSessionsArchive: "🗂️  Upload Sessions Archive",
+  restorePiBackup: "📥 Restore Pi Backup",
+  restoreSkillsBackup: "📥 Restore Skills Backup",
+  restoreSessionsArchive: "📥 Restore Sessions Archive",
+  configureSettings: "⚙️  Configure Backup Settings",
+  switchLanguage: "🌐 Language: English → 中文",
+
+  configureTitle: "Configure Backup Settings",
+  webdavUrl: "WebDAV URL: {value}",
+  webdavUsername: "WebDAV Username: {value}",
+  webdavPassword: "WebDAV Password/Token: {value}",
+  piBackup: "Pi Backup: {value}",
+  skillsBackup: "Shared Skills Backup: {value}",
+  sessionsBackup: "Sessions Backup: {value}",
+  backupOnExit: "Archive Current Project On Exit: {value}",
+  piExcludePaths: "Pi Backup Exclusions: {value}",
+  sessionProjects: "Session Projects: {value}",
+  sessionProjectMode: "Session Project Mode: {value}",
+  maxCloudBackups: "Max Cloud Backups: {value}",
+  language: "Language: English",
+  notSet: "(not set)",
+  passwordSet: "(set)",
+  none: "(none)",
+  piKind: "Pi",
+  skillsKind: "Skills",
+  sessionsKind: "Sessions",
+
+  setupRequired: "WebDAV is not configured. Please set it up now.",
+  promptWebdavUrl: "WebDAV URL:",
+  promptWebdavUsername: "WebDAV username:",
+  promptWebdavPassword: "WebDAV token (or $ENV_VAR):",
+  promptExcludePaths: "Excluded paths (comma separated, relative to ~/.pi/agent):",
+  promptMaxBackups: "Maximum backups (0 = keep all):",
+  configSaved: "Backup configuration updated.",
+
+  backupDisabled: "{kind} backup is disabled.",
+  backupUploaded: "Uploaded {filename}\n{contents}{pruned}",
+  backupFailed: "{kind} backup failed: {error}",
+  prunedCount: "\nPruned: {count}",
+  noAllowedSessionProjects: "No allowed local session projects found.",
+  archiveSessionProject: "Archive session project",
+  sessionArchiveUploaded: "Uploaded {filename}\n{contents}",
+  sessionArchiveFailed: "Session archive failed: {error}",
+
+  noArchivesFound: "No {kind} archives found.",
+  restoreArchive: "Restore {kind} archive",
+  replaceSharedSkillsTitle: "Replace shared skills?",
+  replaceSharedSkillsBody: "The current ~/.agents/skills will be moved to a timestamped backup.",
+  restoreCompleted: "Restored {kind}:\n{contents}",
+  restoreFailed: "{kind} restore failed: {error}",
+  restoreSessionProject: "Restore session archive: project",
+  selectSessionArchive: "Select session archive",
+  sessionRestoreCompleted: "Session archive restored:\n{contents}",
+  sessionRestoreFailed: "Session restore failed: {error}",
+  noRemoteSessionProjects: "No remote session archives found.",
+  confirmPiRestoreTitle: "Restore Pi backup?",
+  confirmPiRestoreBody: "Entries: {count}\n{plan}",
+  confirmRestoreAllTitle: "Restore all latest backups?",
+  confirmRestoreAllBody: "This restores Pi, enabled Skills, and the latest archive for every allowed session project.",
+  allBackupCompleted: "All backups completed:\n{results}",
+  allRestoreCompleted: "Restore all completed:\n{results}",
+  reloadRuntimeTitle: "Reload Runtime?",
+  reloadRuntimeBody: "Reload Pi to apply the restored data?",
+
+  projectModeWhitelist: "whitelist",
+  projectModeBlacklist: "blacklist",
+  projectSelectionWhitelist: "only selected projects",
+  projectSelectionBlacklist: "all except selected projects",
+  projectSelectionAll: "all projects",
+  selectSessionProjects: "Select Session Projects [{mode}]",
+  switchProjectMode: "m Switch Mode: {mode}",
+  selectAllProjects: "a Select All",
+  resetProjects: "r Reset",
+
+  exitBackupFailed: "Exit session backup failed: {error}",
+} as const;
+
+export type TranslationKey = keyof typeof EN;
+type TranslationParams = Record<string, string | number | boolean>;
+
+const ZH: Record<TranslationKey, string> = {
+  on: "开启",
+  off: "关闭",
+  enabled: "已启用",
+  disabled: "已禁用",
+  keepAll: "全部保留",
+  cancel: "❌ 取消",
+  back: "x 返回",
+  save: "s 保存",
+
+  menuTitle: "Pi WebDAV 备份",
+  uploadAllBackups: "⬆️  全部备份",
+  restoreAllBackups: "⬇️  全部恢复（最新）",
+  uploadPiBackup: "☁️  上传 Pi 备份",
+  uploadSkillsBackup: "📦 上传 Skills 备份",
+  uploadSessionsArchive: "🗂️  上传会话归档",
+  restorePiBackup: "📥 恢复 Pi 备份",
+  restoreSkillsBackup: "📥 恢复 Skills 备份",
+  restoreSessionsArchive: "📥 恢复会话归档",
+  configureSettings: "⚙️  配置备份设置",
+  switchLanguage: "🌐 语言：中文 → English",
+
+  configureTitle: "配置备份设置",
+  webdavUrl: "WebDAV 地址：{value}",
+  webdavUsername: "WebDAV 用户名：{value}",
+  webdavPassword: "WebDAV 密码/令牌：{value}",
+  piBackup: "Pi 备份：{value}",
+  skillsBackup: "共享 Skills 备份：{value}",
+  sessionsBackup: "会话备份：{value}",
+  backupOnExit: "退出时归档当前项目：{value}",
+  piExcludePaths: "Pi 备份排除项：{value}",
+  sessionProjects: "会话项目：{value}",
+  sessionProjectMode: "会话项目模式：{value}",
+  maxCloudBackups: "云端最大备份数：{value}",
+  language: "语言：中文",
+  notSet: "（未设置）",
+  passwordSet: "（已设置）",
+  none: "（无）",
+  piKind: "Pi",
+  skillsKind: "Skills",
+  sessionsKind: "会话",
+
+  setupRequired: "尚未配置 WebDAV，请先完成设置。",
+  promptWebdavUrl: "WebDAV 地址：",
+  promptWebdavUsername: "WebDAV 用户名：",
+  promptWebdavPassword: "WebDAV 令牌（或 $ENV_VAR）：",
+  promptExcludePaths: "排除路径（以逗号分隔，相对于 ~/.pi/agent）：",
+  promptMaxBackups: "最大备份数（0 = 全部保留）：",
+  configSaved: "备份配置已更新。",
+
+  backupDisabled: "{kind} 备份已禁用。",
+  backupUploaded: "已上传 {filename}\n{contents}{pruned}",
+  backupFailed: "{kind} 备份失败：{error}",
+  prunedCount: "\n已清理旧备份：{count} 个",
+  noAllowedSessionProjects: "没有允许备份的本地会话项目。",
+  archiveSessionProject: "选择要归档的会话项目",
+  sessionArchiveUploaded: "已上传 {filename}\n{contents}",
+  sessionArchiveFailed: "会话归档失败：{error}",
+
+  noArchivesFound: "未找到 {kind} 归档。",
+  restoreArchive: "恢复 {kind} 归档",
+  replaceSharedSkillsTitle: "替换共享 Skills？",
+  replaceSharedSkillsBody: "当前 ~/.agents/skills 将移动到带时间戳的备份目录。",
+  restoreCompleted: "已恢复 {kind}：\n{contents}",
+  restoreFailed: "{kind} 恢复失败：{error}",
+  restoreSessionProject: "选择要恢复的会话项目",
+  selectSessionArchive: "选择会话归档",
+  sessionRestoreCompleted: "会话归档已恢复：\n{contents}",
+  sessionRestoreFailed: "会话恢复失败：{error}",
+  noRemoteSessionProjects: "未找到远端会话归档。",
+  confirmPiRestoreTitle: "恢复 Pi 备份？",
+  confirmPiRestoreBody: "归档条目：{count}\n{plan}",
+  confirmRestoreAllTitle: "恢复全部最新备份？",
+  confirmRestoreAllBody: "将恢复 Pi、已启用的 Skills，以及每个允许会话项目的最新归档。",
+  allBackupCompleted: "全部备份完成：\n{results}",
+  allRestoreCompleted: "全部恢复完成：\n{results}",
+  reloadRuntimeTitle: "重新加载运行时？",
+  reloadRuntimeBody: "现在重新加载 Pi 以应用恢复的数据？",
+
+  projectModeWhitelist: "白名单",
+  projectModeBlacklist: "黑名单",
+  projectSelectionWhitelist: "仅所选项目",
+  projectSelectionBlacklist: "除所选项目外全部",
+  projectSelectionAll: "全部项目",
+  selectSessionProjects: "选择会话项目［{mode}］",
+  switchProjectMode: "m 切换模式：{mode}",
+  selectAllProjects: "a 全选",
+  resetProjects: "r 重置",
+
+  exitBackupFailed: "退出时会话备份失败：{error}",
+};
+
+const STRINGS: Record<SyncLanguage, Record<TranslationKey, string>> = { en: EN, zh: ZH };
+
+export function normalizeLanguage(value: unknown): SyncLanguage {
+  return typeof value === "string" && value.toLowerCase().startsWith("zh") ? "zh" : "en";
+}
+
+export function t(language: SyncLanguage, key: TranslationKey, params?: TranslationParams): string {
+  let message = STRINGS[language][key];
+  if (!params) return message;
+  for (const [name, value] of Object.entries(params)) {
+    message = message.split(`{${name}}`).join(String(value));
+  }
+  return message;
+}

package/extensions/sync/index.ts

@@ -1,58 +1,35 @@
 import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as path from "node:path";
 
-import { loadConfig, refreshFooterStatusFromConfig } from "./config";
-import { registerSyncCommand } from "./menus";
-import {
-  clearLiveBackupTimer,
-  currentProjectIsAllowed,
-  incrementTurnAndShouldSync,
-  refreshSessionFile,
-  scheduleLiveBackup,
-  setSessionContext,
-  uploadCurrentSession,
-} from "./session-sync";
+import { isProjectAllowed, loadConfig, refreshFooterStatusFromConfig } from "./config";
+import { registerSyncCommand, uploadSessionProjectArchive } from "./menus";
+
+export function projectDirFromSessionDir(sessionDir: string | undefined): string | undefined {
+  if (!sessionDir) return undefined;
+  const projectDir = path.basename(sessionDir);
+  return projectDir.startsWith("--") && projectDir.endsWith("--") ? projectDir : undefined;
+}
 
 /**
- * pi-sync extension entrypoint.
+ * Archive-only pi-sync entrypoint.
  *
- * Wires session lifecycle hooks to the session-sync state module and registers
- * the `/sync` interactive command. All implementation lives in the responsibility
- * modules: config, webdav, archive, restore, session-sync, menus.
+ * Runtime work is intentionally limited to one cached config read at startup
+ * and one current-project archive on shutdown. There are no per-turn hooks,
+ * timers, live uploads, or interval counters.
  */
-export default function (pi: ExtensionAPI): void {
-  // Capture the active session file/project dir for live backup and interval sync.
+export default function registerSyncExtension(pi: ExtensionAPI): void {
   pi.on("session_start", async (_event, ctx) => {
-    setSessionContext(ctx.sessionManager.getSessionFile() ?? undefined, ctx.sessionManager.getSessionDir());
-    refreshFooterStatusFromConfig(ctx, loadConfig());
-  });
-
-  // Refresh the session path (compaction/fork may change it) and schedule a debounced live backup.
-  pi.on("agent_settled", async (_event, ctx) => {
-    refreshSessionFile(ctx.sessionManager.getSessionFile() ?? undefined);
-    const config = loadConfig();
-    if (config.liveSessionBackup && currentProjectIsAllowed(config)) {
-      scheduleLiveBackup(ctx);
-    }
-  });
-
-  // Every-N-turns interval sync (0 = off). Only counts turns for allowed projects.
-  pi.on("turn_end", async (_event, ctx) => {
     const config = loadConfig();
-    if (!config.syncIntervalTurns || config.syncIntervalTurns <= 0) return;
-    if (!currentProjectIsAllowed(config)) return;
-    refreshSessionFile(ctx.sessionManager.getSessionFile() ?? undefined);
-    if (incrementTurnAndShouldSync(config.syncIntervalTurns)) {
-      await uploadCurrentSession(ctx, true).catch(() => { /* silent */ });
-    }
+    refreshFooterStatusFromConfig(ctx, config);
   });
 
-  // Flush on exit: upload if sync-on-exit or live backup is enabled.
   pi.on("session_shutdown", async (_event, ctx) => {
-    clearLiveBackupTimer();
     const config = loadConfig();
-    if (config.syncSessionOnExit || config.liveSessionBackup) {
-      await uploadCurrentSession(ctx, true).catch(() => { /* silent */ });
-    }
+    if (!config.backupOnExit || !config.backupSessions) return;
+    if (!config.webdavUrl || !config.webdavUser || !config.webdavPass) return;
+    const projectDir = projectDirFromSessionDir(ctx.sessionManager.getSessionDir());
+    if (!projectDir || !isProjectAllowed(projectDir, config)) return;
+    await uploadSessionProjectArchive(ctx, config, projectDir, true);
   });
 
   registerSyncCommand(pi);