@shellus/way 0.6.11 → 0.6.12

package/README.md

@@ -39,6 +39,8 @@
 
 定期清理旧快照，防止存储膨胀。
 
+正式 `way gc` 在删除快照前执行普通 `restic unlock`，仅回收 restic 判定失效的锁，不使用 `--remove-all`。解锁失败时停止清理；`--dry-run` 不解锁。活跃锁仍由 restic 保护。
+
 ### 7. 同步不等于备份
 
 同步工具（如 Syncthing）会将误操作实时传播到所有节点。真正的备份必须具备版本历史和回滚能力。
@@ -52,6 +54,7 @@
 - 支持项目级 schedule 配置（不同项目不同频率）
 - 使用 node-cron 实现精确到分钟的调度
 - systemd service 管理常驻进程（自动重启）
+- 支持把本地仓库中各项目的最新快照定期复制到远程仓库
 
 ### 9. 多层冗余原则
 
@@ -168,6 +171,8 @@ way restore data --host old-host --target /tmp/restore --dry-run  # 从指定 ho
 way restore data --target /tmp/restore --delete     # 删除目标中快照不存在的文件
 way gc                  # 按 retention 策略清理旧快照
 way gc --dry-run        # 模拟清理（不实际删除）
+way replicate           # 执行全部仓库复制任务
+way replicate local-to-s3 --init  # 首次初始化目标仓库并执行复制
 
 # daemon 模式（推荐）
 way daemon              # 启动常驻进程，按配置定时执行
@@ -205,6 +210,8 @@ graph LR
     C --> D[node-cron 定时触发]
     D --> E[执行 restic backup]
     E --> F[推送 Uptime Kuma]
+    D --> K[选择各项目最新快照]
+    K --> L[restic copy 到远程仓库]
 
     G[systemd service] --> H[启动 daemon]
     H --> I[进程崩溃自动重启]
@@ -237,7 +244,9 @@ WAY_DIR=/path/to/config way restic snapshots
 - **projects.*.hooks**: 项目级备份钩子，支持 `before_backup` 和 `after_backup`
 - **uptime_kuma.push_url**: 全局 Uptime Kuma Push 地址，作为项目未配置通知地址时的回退
 - **projects.*.uptime_kuma.push_url**: 项目级 Uptime Kuma Push 地址，优先于全局地址
+- **replications**: 仓库复制任务，包含源仓库、目标仓库、调度和目标仓库独立保留策略
 - **maintenance**: 维护任务配置（prune、check）
+- **maintenance.prune.uptime_kuma.push_url**: daemon 定时 prune 的 Uptime Kuma Push 地址，未配置时回退到全局地址；prune 成功推送 UP，失败推送带原因的 DOWN
 - **global_excludes**: 全局排除规则
 
 `defaults.retention` 支持两种互斥模式：
@@ -372,6 +381,27 @@ daemon 的调度心跳最多容忍 5 秒延迟；事件循环短暂阻塞后仍
 | `"*/30 * * * *"` | 分钟间隔 | 每 30 分钟 |
 | `false` | 禁用自动调度 | 只手动备份 |
 
+**仓库复制示例**：
+
+```yaml
+replications:
+  local-to-s3:
+    from: local
+    to: s3
+    snapshot_policy: latest-per-project
+    schedule: "30 5 * * *"
+    prune_schedule: "30 6 * * 0"
+    retention:
+      keep_daily: 30
+      keep_weekly: 12
+      keep_monthly: 12
+      keep_yearly: 3
+```
+
+复制任务读取源仓库中所有带 `way:<project>` 标签的快照，每个项目只选择时间最新的一份传给 `restic copy`。因此本地可以高频备份，而远程只接收每日复制时刻的项目最新状态；重复运行会跳过已经复制的源快照。目标仓库的 `prune_schedule` 和 `retention` 独立于默认仓库。
+
+目标仓库第一次使用时执行 `way replicate <name> --init`。该命令通过 `--copy-chunker-params` 继承源仓库的分块参数，再执行首次复制；初始化后日常任务只运行 `way replicate <name>`。复制源当前必须是本地仓库，源与目标可以使用不同的 restic 密码。
+
 #### 排除规则通配符语法
 
 restic 使用 Go 的 filepath.Match 语法：
@@ -396,6 +426,18 @@ repositories:
     path: /backup/repo
     credentials:
       password: your-password  # 直接明文
+
+  s3:
+    type: s3
+    endpoint: s3.example.com
+    bucket: my-backup-bucket
+    region: region-1
+    options:
+      bucket_lookup: dns
+    credentials:
+      password: your-restic-password
+      access_key_id: your-access-key
+      secret_access_key: your-secret-key
 ```
 
 建议设置文件权限：`chmod 600 ~/.way/repositories.yaml`

package/dist/cli.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { Command } from "commander";
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 
 // src/core/config.ts
 import fs from "fs";
@@ -93,19 +93,20 @@ function resolveResticBin(options = {}) {
 }
 
 // src/core/restic.ts
-function buildResticEnv(repo) {
-  const env = {};
+function buildRepositoryLocation(repo) {
   switch (repo.type) {
     case "s3":
-      env.RESTIC_REPOSITORY = `s3:https://${repo.endpoint}/${repo.bucket}`;
-      break;
+      return `s3:https://${repo.endpoint}/${repo.bucket}`;
     case "local":
-      env.RESTIC_REPOSITORY = repo.path;
-      break;
+      return repo.path;
     case "sftp":
-      env.RESTIC_REPOSITORY = `sftp:${repo.host}:${repo.path}`;
-      break;
+      return `sftp:${repo.host}:${repo.path}`;
   }
+}
+function buildResticEnv(repo) {
+  const env = {
+    RESTIC_REPOSITORY: buildRepositoryLocation(repo)
+  };
   if (repo.credentials.password) env.RESTIC_PASSWORD = repo.credentials.password;
   if (repo.credentials.access_key_id) env.AWS_ACCESS_KEY_ID = repo.credentials.access_key_id;
   if (repo.credentials.secret_access_key) env.AWS_SECRET_ACCESS_KEY = repo.credentials.secret_access_key;
@@ -194,7 +195,7 @@ function buildRestoreArgs(name, project, options) {
   ];
   if (options.host) args.push(`--host=${options.host}`);
   args.push(`--target=${options.target}`);
-  for (const path9 of options.includePaths || project.paths) args.push(`--include=${normalizeResticPath(path9, options.platform)}`);
+  for (const path10 of options.includePaths || project.paths) args.push(`--include=${normalizeResticPath(path10, options.platform)}`);
   if (options.dryRun) args.push("--dry-run");
   if (options.delete) args.push("--delete");
   if (options.verbose) args.push("--verbose=2");
@@ -205,6 +206,9 @@ function buildS3Options(repo) {
   if (repo.options?.bucket_lookup) {
     options.push("-o", `s3.bucket-lookup=${repo.options.bucket_lookup}`);
   }
+  if (repo.region) {
+    options.push("-o", `s3.region=${repo.region}`);
+  }
   return options;
 }
 async function execRestic(args, env, s3Options = []) {
@@ -230,6 +234,23 @@ async function runRestic(args, env, s3Options, capture) {
   }
 }
 
+// src/core/uptime-kuma.ts
+var MAX_MESSAGE_LENGTH = 200;
+async function notifyUptimeKuma(push, pushUrl) {
+  const msg = push.msg.length > MAX_MESSAGE_LENGTH ? `${push.msg.slice(0, MAX_MESSAGE_LENGTH - 3)}...` : push.msg;
+  const url = `${pushUrl}?status=${push.status}&msg=${encodeURIComponent(msg)}&ping=${push.ping}`;
+  try {
+    const response = await fetch(url);
+    if (response.ok) {
+      console.log(`Uptime Kuma notified: status=${push.status}, ping=${push.ping}ms`);
+    } else {
+      console.error("Uptime Kuma notification failed");
+    }
+  } catch (error) {
+    console.error("Uptime Kuma notification failed:", error);
+  }
+}
+
 // src/commands/backup.ts
 import fs4 from "fs";
 import os from "os";
@@ -318,7 +339,11 @@ async function backup(options) {
   if (failed.length > 0) console.log("Failed:", failed.join(", "));
   if (!dryRun) {
     for (const [pushUrl, result] of groupUptimeKumaResults(projectResults)) {
-      await notifyUptimeKuma(result, pushUrl);
+      await notifyUptimeKuma({
+        status: result.failed.length > 0 ? "down" : "up",
+        msg: `Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}`,
+        ping: result.duration
+      }, pushUrl);
     }
   }
   return { succeeded, failed, duration };
@@ -422,21 +447,6 @@ async function runProjectHooks(hooks, context) {
     }
   }
 }
-async function notifyUptimeKuma(result, pushUrl) {
-  const status = result.failed.length > 0 ? "down" : "up";
-  const msg = `Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}`;
-  const url = `${pushUrl}?status=${status}&msg=${encodeURIComponent(msg)}&ping=${result.duration}`;
-  try {
-    const response = await fetch(url);
-    if (response.ok) {
-      console.log(`Uptime Kuma notified: status=${status}, ping=${result.duration}ms`);
-    } else {
-      console.error("Uptime Kuma notification failed");
-    }
-  } catch (error) {
-    console.error("Uptime Kuma notification failed:", error);
-  }
-}
 
 // src/commands/restore.ts
 import path5 from "path";
@@ -580,6 +590,13 @@ function buildResticOptions(s3Options, retryLock) {
   if (retryLock) options.push(`--retry-lock=${retryLock}`);
   return options;
 }
+async function executeGc(args, dryRun, env, resticOptions) {
+  if (!dryRun) {
+    console.log("Removing stale repository locks before cleanup...");
+    await execRestic(["unlock"], env, resticOptions);
+  }
+  await execRestic(args, env, resticOptions);
+}
 async function runStrictGc(retention, dryRun, env, resticOptions) {
   const snapshotsJson = await execResticCapture(["snapshots", "--json", "--no-lock"], env, resticOptions);
   const snapshots = JSON.parse(snapshotsJson);
@@ -596,12 +613,12 @@ async function runStrictGc(retention, dryRun, env, resticOptions) {
     console.log("No snapshots matched cleanup; prune was skipped.");
     return;
   }
-  await execRestic(["forget", "--prune", ...plan.remove.map((snapshot) => snapshot.id)], env, resticOptions);
+  await executeGc(["forget", "--prune", ...plan.remove.map((snapshot) => snapshot.id)], false, env, resticOptions);
 }
 async function gc(options) {
   const wayDir = process.env.WAY_DIR || `${process.env.HOME}/.way`;
   const config = loadConfig(wayDir, options.remote);
-  const retention = config.rules.defaults?.retention || {};
+  const retention = options.retention ?? config.rules.defaults?.retention ?? {};
   const dryRun = options.dryRun || false;
   console.log("=== Cleaning snapshots ===");
   const env = buildResticEnv(config.repository);
@@ -613,11 +630,11 @@ async function gc(options) {
     await runStrictGc(retention, dryRun, env, resticOptions);
     return;
   }
-  const keepDaily = retention.keep_daily || 7;
-  const keepWeekly = retention.keep_weekly || 4;
-  const keepMonthly = retention.keep_monthly || 6;
+  const keepDaily = retention.keep_daily ?? 7;
+  const keepWeekly = retention.keep_weekly ?? 4;
+  const keepMonthly = retention.keep_monthly ?? 6;
   const keepYearly = retention.keep_yearly;
-  console.log(`Policy: daily=${keepDaily}, weekly=${keepWeekly}, monthly=${keepMonthly}${keepYearly ? `, yearly=${keepYearly}` : ""}`);
+  console.log(`Policy: daily=${keepDaily}, weekly=${keepWeekly}, monthly=${keepMonthly}${keepYearly !== void 0 ? `, yearly=${keepYearly}` : ""}`);
   const args = [
     "forget",
     "--prune",
@@ -625,9 +642,9 @@ async function gc(options) {
     `--keep-weekly=${keepWeekly}`,
     `--keep-monthly=${keepMonthly}`
   ];
-  if (keepYearly) args.push(`--keep-yearly=${keepYearly}`);
+  if (keepYearly !== void 0) args.push(`--keep-yearly=${keepYearly}`);
   if (dryRun) args.push("--dry-run");
-  await execRestic(args, env, resticOptions);
+  await executeGc(args, dryRun, env, resticOptions);
 }
 
 // src/commands/systemd.ts
@@ -823,6 +840,113 @@ async function windowsService(options, dependencies = {}) {
 
 // src/commands/daemon.ts
 import cron from "node-cron";
+
+// src/commands/replicate.ts
+import fs7 from "fs";
+import os3 from "os";
+import path8 from "path";
+function selectLatestProjectSnapshots(snapshots, projectNames) {
+  const selected = /* @__PURE__ */ new Map();
+  for (const snapshot of snapshots) {
+    const snapshotTime = Date.parse(snapshot.time);
+    if (Number.isNaN(snapshotTime)) {
+      throw new Error(`Snapshot ${snapshot.id} has an invalid timestamp: ${snapshot.time}`);
+    }
+    for (const tag of snapshot.tags || []) {
+      if (!tag.startsWith("way:")) continue;
+      const projectName = tag.slice("way:".length);
+      if (!projectNames.includes(projectName)) continue;
+      const current = selected.get(projectName);
+      if (!current || snapshotTime > Date.parse(current.time)) {
+        selected.set(projectName, snapshot);
+      }
+    }
+  }
+  return projectNames.flatMap((projectName) => {
+    const snapshot = selected.get(projectName);
+    return snapshot ? [snapshot.id] : [];
+  });
+}
+function validateReplication(name, replication, sourceType) {
+  if (replication.from === replication.to) {
+    throw new Error(`Replication ${name} must use different source and destination repositories`);
+  }
+  if (sourceType !== "local") {
+    throw new Error(`Replication ${name} source repository must be local`);
+  }
+  if (replication.snapshot_policy && replication.snapshot_policy !== "latest-per-project") {
+    throw new Error(`Replication ${name} has unsupported snapshot_policy: ${replication.snapshot_policy}`);
+  }
+}
+async function withSourcePasswordFile(password, run) {
+  if (!password) throw new Error("Source repository password is required for replication");
+  const tempDir = fs7.mkdtempSync(path8.join(os3.tmpdir(), "way-replication-"));
+  const passwordFile = path8.join(tempDir, "source-password");
+  fs7.writeFileSync(passwordFile, `${password}
+`, { encoding: "utf8", mode: 384 });
+  try {
+    return await run(passwordFile);
+  } finally {
+    fs7.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+async function replicateOne(wayDir, name, replication, initialize) {
+  const sourceConfig = loadConfig(wayDir, replication.from);
+  const destinationConfig = loadConfig(wayDir, replication.to);
+  validateReplication(name, replication, sourceConfig.repository.type);
+  const sourceEnv = buildResticEnv(sourceConfig.repository);
+  const destinationEnv = buildResticEnv(destinationConfig.repository);
+  const sourceOptions = buildS3Options(sourceConfig.repository);
+  const destinationOptions = buildS3Options(destinationConfig.repository);
+  const snapshots = JSON.parse(
+    await execResticCapture(["snapshots", "--json"], sourceEnv, sourceOptions)
+  );
+  if (!Array.isArray(snapshots)) throw new Error("restic snapshots --json did not return an array");
+  const snapshotIds = selectLatestProjectSnapshots(snapshots, Object.keys(sourceConfig.rules.projects));
+  await withSourcePasswordFile(sourceConfig.repository.credentials.password, async (passwordFile) => {
+    const sourceArguments = [
+      `--from-repo=${buildRepositoryLocation(sourceConfig.repository)}`,
+      `--from-password-file=${passwordFile}`
+    ];
+    if (initialize) {
+      console.log(`Initializing replication destination ${replication.to} from ${replication.from}`);
+      await execRestic(["init", ...sourceArguments, "--copy-chunker-params"], destinationEnv, destinationOptions);
+    }
+    if (snapshotIds.length === 0) {
+      console.log(`No project snapshots available for replication ${name}`);
+      return;
+    }
+    console.log(`Replicating ${snapshotIds.length} latest project snapshots: ${replication.from} -> ${replication.to}`);
+    await execRestic(["copy", ...sourceArguments, ...snapshotIds], destinationEnv, destinationOptions);
+  });
+}
+async function replicate(options = {}) {
+  const wayDir = process.env.WAY_DIR || `${process.env.HOME}/.way`;
+  const defaultConfig = loadConfig(wayDir, "default");
+  const replications = defaultConfig.rules.replications || {};
+  const names = options.names?.length ? options.names : Object.keys(replications);
+  const succeeded = [];
+  const failed = [];
+  const startTime = Date.now();
+  for (const name of names) {
+    const replication = replications[name];
+    if (!replication) {
+      console.error(`Replication not found: ${name}`);
+      failed.push(name);
+      continue;
+    }
+    try {
+      await replicateOne(wayDir, name, replication, options.initialize || false);
+      succeeded.push(name);
+    } catch (error) {
+      console.error(`Failed replication ${name}:`, error);
+      failed.push(name);
+    }
+  }
+  return { succeeded, failed, duration: Date.now() - startTime };
+}
+
+// src/commands/daemon.ts
 var isRunning = false;
 var taskQueue = [];
 var CRON_OPTIONS = {
@@ -840,6 +964,24 @@ function assertValidSchedule(schedule, label) {
     throw new Error(`${label} must be a cron expression or false. Use false to disable scheduling.`);
   }
 }
+function resolvePrunePushUrl(rules) {
+  return rules.maintenance?.prune?.uptime_kuma?.push_url || rules.uptime_kuma?.push_url;
+}
+async function runPruneWithNotification(remote, pushUrl) {
+  const startTime = Date.now();
+  try {
+    await gc({ remote, dryRun: false });
+  } catch (error) {
+    if (pushUrl) {
+      const reason = error instanceof Error ? error.message : String(error);
+      await notifyUptimeKuma({ status: "down", msg: `Prune failed: ${reason}`, ping: Date.now() - startTime }, pushUrl);
+    }
+    throw error;
+  }
+  if (pushUrl) {
+    await notifyUptimeKuma({ status: "up", msg: "Prune succeeded", ping: Date.now() - startTime }, pushUrl);
+  }
+}
 function addScheduledBackup(scheduledBackups, schedule, projectName) {
   const projects = scheduledBackups.get(schedule) || [];
   projects.push(projectName);
@@ -882,13 +1024,37 @@ async function daemon(options) {
     }, CRON_OPTIONS);
     console.log(`Scheduled backup for ${projects.join(", ")}: ${schedule}`);
   }
+  for (const [name, replication] of Object.entries(config.rules.replications || {})) {
+    assertValidSchedule(replication.schedule, `replications.${name}.schedule`);
+    if (isEnabledSchedule(replication.schedule)) {
+      cron.schedule(replication.schedule, () => {
+        executeTask(async () => {
+          console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Running replication: ${name}`);
+          const result = await replicate({ names: [name] });
+          if (result.failed.length > 0) throw new Error(`Replication failed: ${result.failed.join(", ")}`);
+        });
+      }, CRON_OPTIONS);
+      console.log(`Scheduled replication ${name}: ${replication.schedule}`);
+    }
+    assertValidSchedule(replication.prune_schedule, `replications.${name}.prune_schedule`);
+    if (isEnabledSchedule(replication.prune_schedule)) {
+      cron.schedule(replication.prune_schedule, () => {
+        executeTask(async () => {
+          console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Running replication prune: ${name}`);
+          await gc({ remote: replication.to, dryRun: false, retention: replication.retention });
+        });
+      }, CRON_OPTIONS);
+      console.log(`Scheduled replication prune ${name}: ${replication.prune_schedule}`);
+    }
+  }
   const pruneSchedule = config.rules.maintenance?.prune?.schedule;
   assertValidSchedule(pruneSchedule, "maintenance.prune.schedule");
   if (isEnabledSchedule(pruneSchedule)) {
+    const prunePushUrl = resolvePrunePushUrl(config.rules);
     cron.schedule(pruneSchedule, () => {
       executeTask(async () => {
         console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Running prune`);
-        await gc({ remote: options.remote, dryRun: false });
+        await runPruneWithNotification(options.remote, prunePushUrl);
       });
     }, CRON_OPTIONS);
     console.log(`Scheduled prune: ${pruneSchedule}`);
@@ -915,7 +1081,7 @@ async function daemon(options) {
 
 // src/cli.ts
 var program = new Command();
-program.name("way").version("0.6.11").description("\u7B56\u7565\u5907\u4EFD\u5DE5\u5177 - \u57FA\u4E8E restic \u7684\u7B56\u7565\u5C01\u88C5").option("--remote <name>", "\u6307\u5B9A\u4ED3\u5E93", "default").addHelpText("after", `
+program.name("way").version("0.6.12").description("\u7B56\u7565\u5907\u4EFD\u5DE5\u5177 - \u57FA\u4E8E restic \u7684\u7B56\u7565\u5C01\u88C5").option("--remote <name>", "\u6307\u5B9A\u4ED3\u5E93", "default").addHelpText("after", `
 \u793A\u4F8B:
   $ way backup                 \u6267\u884C\u6240\u6709\u9879\u76EE\u5907\u4EFD
   $ way backup data            \u53EA\u5907\u4EFD data \u9879\u76EE
@@ -924,6 +1090,7 @@ program.name("way").version("0.6.11").description("\u7B56\u7565\u5907\u4EFD\u5DE
   $ way --remote=oss backup    \u4F7F\u7528 oss \u4ED3\u5E93\u6267\u884C\u5907\u4EFD\uFF08\u5168\u5C40\u9009\u9879\u9700\u653E\u5728\u5B50\u547D\u4EE4\u524D\uFF09
   $ way init                   \u521D\u59CB\u5316 way \u914D\u7F6E\u6587\u4EF6
   $ way gc                     \u6E05\u7406\u65E7\u5FEB\u7167
+  $ way replicate              \u590D\u5236\u5404\u9879\u76EE\u6700\u65B0\u5FEB\u7167\u5230\u8FDC\u7A0B\u4ED3\u5E93
   $ way systemd install        \u5B89\u88C5\u5B9A\u65F6\u4EFB\u52A1
   $ way restic snapshots       \u67E5\u770B\u5FEB\u7167\u5217\u8868
   $ way restic restore abc123 --target /tmp/restore
@@ -952,17 +1119,17 @@ var commonHelpText = `
 program.command("init").description("\u521D\u59CB\u5316 way \u914D\u7F6E\u6587\u4EF6").addHelpText("after", commonHelpText).action(() => {
   const wayDir = process.env.WAY_DIR || `${process.env.HOME}/.way`;
   const files = ["repositories.yaml", "rules.yaml"];
-  fs7.mkdirSync(wayDir, { recursive: true });
+  fs8.mkdirSync(wayDir, { recursive: true });
   for (const file of files) {
-    const target = path8.join(wayDir, file);
-    if (fs7.existsSync(target)) {
+    const target = path9.join(wayDir, file);
+    if (fs8.existsSync(target)) {
       throw new Error(`${target} already exists, aborting to avoid overwriting existing config.`);
     }
   }
   for (const file of files) {
     const source = resolveExampleConfigPath(file);
-    const target = path8.join(wayDir, file);
-    fs7.copyFileSync(source, target);
+    const target = path9.join(wayDir, file);
+    fs8.copyFileSync(source, target);
     console.log(`Created ${target}`);
   }
 });
@@ -995,6 +1162,10 @@ program.command("gc").description("\u6E05\u7406\u65E7\u5FEB\u7167").option("--dr
   const remote = resolveRemote(this);
   await gc({ remote, dryRun: cmdOptions.dryRun });
 });
+program.command("replicate [names...]").description("\u6309 rules.yaml \u590D\u5236\u5404\u9879\u76EE\u6700\u65B0\u5FEB\u7167\u5230\u76EE\u6807\u4ED3\u5E93").option("--init", "\u521D\u59CB\u5316\u76EE\u6807\u4ED3\u5E93\u5E76\u7EE7\u627F\u6E90\u4ED3\u5E93 chunker \u53C2\u6570").addHelpText("after", commonHelpText).action(async function(names, cmdOptions) {
+  const result = await replicate({ names, initialize: cmdOptions.init });
+  if (result.failed.length > 0) process.exitCode = 1;
+});
 program.command("systemd <action>").description("\u7BA1\u7406 systemd \u5B9A\u65F6\u4EFB\u52A1 (show|install|uninstall|status)").addHelpText("after", commonHelpText).action(async (action, options, command) => {
   const remote = resolveRemote(command);
   await systemd({ remote, action });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shellus/way",
-  "version": "0.6.11",
+  "version": "0.6.12",
   "description": "将备份作为持续运营的项目，而非一次性任务。基于 restic 的策略封装。",
   "type": "module",
   "bin": {

package/repositories.yaml.example

@@ -15,6 +15,7 @@ repositories:
     type: s3
     endpoint: s3.example.com
     bucket: my-backup-bucket
+    region: region-1
     options:
       bucket_lookup: dns
     credentials:

package/rules.yaml.example

@@ -98,10 +98,26 @@ global_excludes:
   - "*.tmp"
   - "*.swp"
 
+# 仓库复制：每天只复制各项目的最新快照，远程仓库使用独立保留策略
+replications:
+  local-to-s3:
+    from: local
+    to: s3
+    snapshot_policy: latest-per-project
+    schedule: "30 5 * * *"
+    prune_schedule: "30 6 * * 0"
+    retention:
+      keep_daily: 30
+      keep_weekly: 12
+      keep_monthly: 12
+      keep_yearly: 3
+
 # 维护任务（可选）
 maintenance:
   prune:
     schedule: "0 4 * * 0"  # 每周日凌晨 4 点清理
     # retry_lock: "30m"      # 备份仍持有仓库锁时等待，避免立即失败
+    # uptime_kuma:           # 定时 prune 成功推送 UP、失败推送 DOWN；未配置时回退到全局 uptime_kuma
+    #   push_url: "https://uptime.example.com/api/push/prune-placeholder"
   check:
     schedule: false        # 不执行