@wuyaos/pi-sync 1.1.0

package/extensions/_shared/spawn.ts

@@ -0,0 +1,91 @@
+/**
+ * Shared spawn wrapper for Pi extensions.
+ *
+ * Single unified async spawn with timeout, Windows process-tree kill,
+ * and consistent { ok, stdout, stderr, status } result.
+ *
+ * Usage:
+ *   import { runCommand, type SpawnResult } from "../_shared/spawn";
+ *   const r = await runCommand("git", ["status"], { cwd: repoDir, timeoutMs: 30000 });
+ *   if (!r.ok) throw new Error(r.stderr);
+ */
+
+import { spawn } from "node:child_process";
+
+export interface SpawnResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  status: number | null;
+}
+
+export interface SpawnOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  shell?: boolean;
+  timeoutMs?: number;
+  windowsHide?: boolean;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+export function runCommand(
+  cmd: string,
+  args: string[],
+  opts: SpawnOptions = {},
+): Promise<SpawnResult> {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      shell: opts.shell ?? false,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: opts.windowsHide ?? true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+
+    child.stdout?.on("data", (d: Buffer) => (stdout += d.toString()));
+    child.stderr?.on("data", (d: Buffer) => (stderr += d.toString()));
+
+    const ms = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      try {
+        if (process.platform === "win32" && child.pid) {
+          spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+          });
+        } else {
+          child.kill();
+        }
+      } catch (_error) {
+        // Ignore process cleanup failure.
+      }
+      resolve({
+        ok: false,
+        stdout,
+        stderr: `${stderr}\nTimeout ${ms}ms`,
+        status: null,
+      });
+    }, ms);
+
+    child.on("error", (err) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ ok: false, stdout, stderr: stderr || err.message, status: null });
+    });
+
+    child.on("close", (code) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ ok: code === 0, stdout, stderr, status: code });
+    });
+  });
+}

package/extensions/sync/archive.ts

@@ -0,0 +1,264 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { runCommand } from "../_shared/spawn";
+import {
+  AGENT_DIR,
+  AGENT_ROOT_MARKDOWN_FILES,
+  AGENT_SKILLS_DIR,
+  MEMORY_MARKDOWN_FILES,
+  SESSIONS_DIR,
+  ensureDir,
+  isProjectAllowed,
+  type ManifestFile,
+  type SyncConfig,
+} from "./config";
+
+const TAR_TIMEOUT_MS = 300_000;
+
+export function platformTag(): string {
+  const platform = os.platform();
+  if (platform === "win32") {
+    const build = parseInt(os.release().split(".")[2] ?? "0", 10);
+    return build >= 22000 ? "windows11" : "windows10";
+  }
+  if (platform === "darwin") return "macos";
+  if (platform === "linux") return "linux";
+  return platform;
+}
+
+export function archiveTimestamp(): string {
+  return new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+
+export function yieldToUI(): Promise<void> {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+export async function runTar(args: string[], options: { capture?: boolean; timeoutMs?: number } = {}): Promise<string> {
+  const result = await runCommand("tar", args, { timeoutMs: options.timeoutMs ?? TAR_TIMEOUT_MS });
+  if (!result.ok) throw new Error(result.stderr || `tar ${args[0]} failed with status ${result.status}`);
+  return options.capture ? result.stdout : "";
+}
+
+export function copyRecursiveSync(src: string, dest: string): void {
+  if (!fs.existsSync(src)) return;
+  const stats = fs.statSync(src);
+  if (stats.isDirectory()) {
+    ensureDir(dest);
+    for (const child of fs.readdirSync(src)) copyRecursiveSync(path.join(src, child), path.join(dest, child));
+  } else {
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(src, dest);
+  }
+}
+
+export function copyRecursiveSyncFiltered(src: string, dest: string, include: (name: string, isDirectory: boolean) => boolean): void {
+  if (!fs.existsSync(src)) return;
+  const stats = fs.statSync(src);
+  if (!include(path.basename(src), stats.isDirectory())) return;
+  if (stats.isDirectory()) {
+    ensureDir(dest);
+    for (const child of fs.readdirSync(src)) copyRecursiveSyncFiltered(path.join(src, child), path.join(dest, child), include);
+  } else {
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(src, dest);
+  }
+}
+
+export function collectManifest(dir: string, archivePrefix: string, sourcePrefix: string, files: ManifestFile[]): void {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const archivePath = `${archivePrefix}/${entry.name}`;
+    const sourcePath = sourcePrefix ? `${sourcePrefix}/${entry.name}` : entry.name;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) collectManifest(full, archivePath, sourcePath, files);
+    else files.push({ archive: archivePath, source: sourcePath });
+  }
+}
+
+export function writeManifest(tempDir: string, agentDir: string, files: ManifestFile[]): void {
+  fs.writeFileSync(path.join(tempDir, "manifest.json"), JSON.stringify({
+    version: 1,
+    createdAt: new Date().toISOString(),
+    agentDir,
+    fileCount: files.length,
+    files,
+  }, null, 2), "utf8");
+}
+
+export function extractSessionTs(filename: string): string | null {
+  return filename.match(/^(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)_/)?.[1] ?? null;
+}
+
+export async function listArchiveEntries(archivePath: string): Promise<string[]> {
+  return (await runTar(["-t", "-f", archivePath], { capture: true }))
+    .split(/\r?\n/)
+    .map((entry) => entry.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, ""))
+    .filter((entry) => entry && entry !== ".");
+}
+
+export function validateArchiveEntries(entries: string[]): void {
+  const allowed = new Set(["config", "skills", "extensions", "sessions", "memory", "agent-skills", "manifest.json"]);
+  const legacyConfigFiles = new Set(["models.json", "settings.json", "auth.json"]);
+  const rootMarkdownFiles = new Set<string>(AGENT_ROOT_MARKDOWN_FILES);
+  if (entries.length === 0) throw new Error("Backup archive is empty or unreadable");
+  for (const entry of entries) {
+    const parts = entry.split("/");
+    if (entry.startsWith("/") || /^[a-zA-Z]:\//.test(entry) || parts.includes("..") || !allowed.has(parts[0]!)) {
+      throw new Error(`Unsafe archive path rejected: ${entry}`);
+    }
+    if (parts[0] !== "config" || !parts[1]) continue;
+    if (parts[1] === "root") {
+      if (!parts[2]) continue;
+      if (parts.length !== 3 || (!parts[2].endsWith(".json") && !rootMarkdownFiles.has(parts[2]))) {
+        throw new Error(`Unexpected root config file rejected: ${entry}`);
+      }
+    } else if (parts[1] === "sub") {
+      continue;
+    } else if (parts.length !== 2 || !legacyConfigFiles.has(parts[1])) {
+      throw new Error(`Unexpected config file rejected: ${entry}`);
+    }
+  }
+}
+
+export async function packTemporaryArchive(tempDir: string, archivePath: string): Promise<void> {
+  await yieldToUI();
+  await runTar(["-J", "-c", "-f", archivePath, "-C", tempDir, "."]);
+}
+
+export async function createConfigZip(config: SyncConfig, archivePath: string): Promise<string[]> {
+  const tempDir = path.join(os.tmpdir(), `pi_config_temp_${Date.now()}`);
+  const rootDir = path.join(tempDir, "config", "root");
+  const subDir = path.join(tempDir, "config", "sub");
+  const manifest: ManifestFile[] = [];
+  const contents: string[] = [];
+  ensureDir(rootDir);
+  ensureDir(subDir);
+  try {
+    if (config.backupProviders) {
+      const rootNames = fs.readdirSync(AGENT_DIR).filter((name) => name.endsWith(".json"));
+      for (const name of AGENT_ROOT_MARKDOWN_FILES) if (!rootNames.includes(name)) rootNames.push(name);
+      for (const name of rootNames) {
+        const src = path.join(AGENT_DIR, name);
+        if (!fs.existsSync(src) || !fs.statSync(src).isFile()) continue;
+        fs.copyFileSync(src, path.join(rootDir, name));
+        manifest.push({ archive: `config/root/${name}`, source: name });
+        contents.push(`Config: ${name}`);
+      }
+      const configDir = path.join(AGENT_DIR, "config");
+      if (fs.existsSync(configDir)) {
+        copyRecursiveSync(configDir, subDir);
+        collectManifest(subDir, "config/sub", "config", manifest);
+        contents.push("Config directory");
+      }
+    }
+    if (config.backupExtensions) {
+      const source = path.join(AGENT_DIR, "extensions");
+      const dest = path.join(tempDir, "extensions");
+      if (fs.existsSync(source)) {
+        copyRecursiveSync(source, dest);
+        fs.rmSync(path.join(dest, "sync"), { recursive: true, force: true });
+        collectManifest(dest, "extensions", "extensions", manifest);
+        contents.push("Extensions directory");
+      }
+    }
+    if (manifest.length === 0) throw new Error("No config or extension files found to back up.");
+    writeManifest(tempDir, AGENT_DIR, manifest);
+    await packTemporaryArchive(tempDir, archivePath);
+    return contents;
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function createMemoryZip(archivePath: string): Promise<string[]> {
+  const sourceDir = path.join(AGENT_DIR, "pi-hermes-memory");
+  const tempDir = path.join(os.tmpdir(), `pi_memory_temp_${Date.now()}`);
+  const destDir = path.join(tempDir, "memory");
+  const manifest: ManifestFile[] = [];
+  ensureDir(destDir);
+  try {
+    for (const name of MEMORY_MARKDOWN_FILES) {
+      const src = path.join(sourceDir, name);
+      if (!fs.existsSync(src)) continue;
+      fs.copyFileSync(src, path.join(destDir, name));
+      manifest.push({ archive: `memory/${name}`, source: `pi-hermes-memory/${name}` });
+    }
+    if (manifest.length === 0) throw new Error("No durable pi-hermes-memory markdown files found.");
+    writeManifest(tempDir, AGENT_DIR, manifest);
+    await packTemporaryArchive(tempDir, archivePath);
+    return manifest.map((item) => `Memory: ${path.basename(item.source)}`);
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function createAgentSkillsZip(archivePath: string): Promise<string[]> {
+  if (!fs.existsSync(AGENT_SKILLS_DIR)) throw new Error("~/.agents/skills does not exist.");
+  const tempDir = path.join(os.tmpdir(), `pi_agent_skills_temp_${Date.now()}`);
+  const destDir = path.join(tempDir, "agent-skills");
+  const manifest: ManifestFile[] = [];
+  try {
+    copyRecursiveSyncFiltered(AGENT_SKILLS_DIR, destDir, (name, isDirectory) => isDirectory ? name !== "__pycache__" : !name.endsWith(".pyc"));
+    collectManifest(destDir, "agent-skills", ".agents/skills", manifest);
+    if (manifest.length === 0) throw new Error("No shared agent skill files found.");
+    writeManifest(tempDir, os.homedir(), manifest);
+    await packTemporaryArchive(tempDir, archivePath);
+    return [`Shared agent skills: ${manifest.length} file(s)`];
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function createSessionsArchiveZip(projectDir: string, archivePath: string): Promise<string[]> {
+  const sourceDir = path.join(SESSIONS_DIR, projectDir);
+  if (!fs.existsSync(sourceDir)) throw new Error(`Session project not found: ${projectDir}`);
+  const tempDir = path.join(os.tmpdir(), `pi_sessions_temp_${Date.now()}`);
+  const destDir = path.join(tempDir, "sessions", projectDir);
+  const manifest: ManifestFile[] = [];
+  try {
+    copyRecursiveSync(sourceDir, destDir);
+    collectManifest(destDir, `sessions/${projectDir}`, `sessions/${projectDir}`, manifest);
+    if (manifest.length === 0) throw new Error(`No session files found for ${projectDir}.`);
+    writeManifest(tempDir, AGENT_DIR, manifest);
+    await packTemporaryArchive(tempDir, archivePath);
+    return [`Sessions: ${projectDir} (${manifest.length} file(s))`];
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+export async function createLegacyZip(config: SyncConfig, archivePath: string): Promise<string[]> {
+  const tempDir = path.join(os.tmpdir(), `pi_sync_temp_${Date.now()}`);
+  const manifest: ManifestFile[] = [];
+  const contents: string[] = [];
+  ensureDir(tempDir);
+  try {
+    if (config.backupProviders) {
+      const configDir = path.join(tempDir, "config");
+      ensureDir(configDir);
+      for (const name of ["models.json", "settings.json", "auth.json"]) {
+        const src = path.join(AGENT_DIR, name);
+        if (!fs.existsSync(src)) continue;
+        fs.copyFileSync(src, path.join(configDir, name));
+        manifest.push({ archive: `config/${name}`, source: name });
+        contents.push(`Config: ${name}`);
+      }
+    }
+    if (config.backupSkills) {
+      const src = path.join(AGENT_DIR, "skills"), dest = path.join(tempDir, "skills");
+      if (fs.existsSync(src)) { copyRecursiveSync(src, dest); collectManifest(dest, "skills", "skills", manifest); contents.push("Skills Directory"); }
+    }
+    if (config.backupExtensions) {
+      const src = path.join(AGENT_DIR, "extensions"), dest = path.join(tempDir, "extensions");
+      if (fs.existsSync(src)) { copyRecursiveSync(src, dest); fs.rmSync(path.join(dest, "sync"), { recursive: true, force: true }); collectManifest(dest, "extensions", "extensions", manifest); contents.push("Extensions Directory"); }
+    }
+    if (config.backupSessions) {
+      for (const entry of fs.existsSync(SESSIONS_DIR) ? fs.readdirSync(SESSIONS_DIR, { withFileTypes: true }) : []) {
+        if (!entry.isDirectory()) continue;
+        if (!isProjectAllowed(entry.name, config)) continue;
+        const dest = path.join(tempDir, "sessions", entry.name);
+        copyRecursiveSync(path.join(SESSIONS_DIR, entry.name), dest);
+      }
+      const sessionsDest = path.join(tempDir, "sessions");
+      if (fs.existsSync(sessionsDest)) { collectManifest(sessionsDest, "sessions", "sessions", manifest); contents.push("Sessions"); }
+    }
+    if (manifest.length === 0) throw new Error("No components selected or found to backup.");
+    writeManifest(tempDir, AGENT_DIR, manifest);
+    await packTemporaryArchive(tempDir, archivePath);
+    return contents;
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}

package/extensions/sync/config.ts

@@ -0,0 +1,93 @@
+import type { ExtensionContext } 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 { ensureDir as ensureSharedDir, readJsonSafe, writeJsonAtomic } from "../_shared/json-io";
+
+export const AGENT_DIR = path.join(os.homedir(), ".pi", "agent");
+export const AGENT_SKILLS_DIR = path.join(os.homedir(), ".agents", "skills");
+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 type ManifestFile = { archive: string; source: string };
+
+export interface SyncConfig {
+  webdavUrl: string;
+  webdavUser: string;
+  webdavPass: string;
+  backupProviders: boolean;
+  backupSkills: boolean;
+  backupExtensions: boolean;
+  backupSessions: boolean;
+  sessionProjects: string[];
+  liveSessionBackup: boolean;
+  liveBackupDebounceMs: number;
+  syncIntervalTurns: number;
+  syncSessionOnExit: boolean;
+  backupMemory: boolean;
+  backupAgentSkills: boolean;
+  sessionProjectMode: "whitelist" | "blacklist";
+  maxBackups: number;
+}
+
+export function ensureDir(dir: string): void {
+  ensureSharedDir(dir);
+}
+
+export function loadConfig(): SyncConfig {
+  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 */ }
+  }
+  const data = readJsonSafe<Partial<SyncConfig>>(SYNC_CONFIG_PATH, {});
+  const normalizeList = (value: unknown): string[] => Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+  return {
+    webdavUrl: data.webdavUrl || "",
+    webdavUser: data.webdavUser || "",
+    webdavPass: data.webdavPass || "",
+    backupProviders: data.backupProviders !== false,
+    backupSkills: data.backupSkills !== false,
+    backupExtensions: data.backupExtensions !== false,
+    backupSessions: data.backupSessions === true,
+    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",
+    maxBackups: typeof data.maxBackups === "number" && data.maxBackups >= 0 ? Math.floor(data.maxBackups) : 10,
+  };
+}
+
+export function saveConfig(config: SyncConfig, ctx?: Pick<ExtensionContext, "ui">): void {
+  ensureDir(path.dirname(SYNC_CONFIG_PATH));
+  writeJsonAtomic(SYNC_CONFIG_PATH, config, { backup: true });
+  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);
+}
+
+export function isProjectAllowed(projectDir: string | undefined, config: SyncConfig): boolean {
+  if (!projectDir) return false;
+  const listed = config.sessionProjects.includes(projectDir);
+  // whitelist: only listed projects are backed up (empty = none)
+  // blacklist: listed projects are skipped (empty = all)
+  return config.sessionProjectMode === "blacklist" ? !listed : listed;
+}
+
+export function resolvePassword(pass: string): string {
+  return pass.startsWith("$") ? process.env[pass.slice(1)] ?? pass : pass;
+}

package/extensions/sync/index.ts

@@ -0,0 +1,59 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { loadConfig, refreshFooterStatusFromConfig } from "./config";
+import { registerSyncCommand } from "./menus";
+import {
+  clearLiveBackupTimer,
+  currentProjectIsAllowed,
+  incrementTurnAndShouldSync,
+  refreshSessionFile,
+  scheduleLiveBackup,
+  setSessionContext,
+  uploadCurrentSession,
+} from "./session-sync";
+
+/**
+ * pi-sync extension 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.
+ */
+export default function (pi: ExtensionAPI): void {
+  // Capture the active session file/project dir for live backup and interval sync.
+  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 */ });
+    }
+  });
+
+  // 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 */ });
+    }
+  });
+
+  registerSyncCommand(pi);
+}