@lumy-pack/syncpoint 0.0.3 → 0.0.5

package/dist/commands/Migrate.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerMigrateCommand(program: Command): void;

package/dist/constants.d.ts

@@ -5,7 +5,6 @@ export declare const METADATA_FILENAME = "_metadata.json";
 export declare const LARGE_FILE_THRESHOLD: number;
 export declare const MAX_RETRY = 3;
 export declare const SENSITIVE_PATTERNS: string[];
-export declare const REMOTE_SCRIPT_PATTERN: RegExp;
 export declare const BACKUPS_DIR = "backups";
 export declare const TEMPLATES_DIR = "templates";
 export declare const SCRIPTS_DIR = "scripts";

package/dist/core/migrate.d.ts

@@ -0,0 +1,11 @@
+import type { MigrateResult } from '../utils/types.js';
+export interface DiffResult {
+    added: string[][];
+    removed: string[][];
+    existing: string[][];
+}
+export declare function diffConfigFields(userData: unknown): DiffResult;
+export declare function buildMigratedDocument(templateText: string, userData: unknown, diff: DiffResult): string;
+export declare function migrateConfig(options?: {
+    dryRun?: boolean;
+}): Promise<MigrateResult>;

package/dist/index.cjs

@@ -126,6 +126,76 @@ function getSubDir(sub) {
   return (0, import_node_path2.join)(getAppDir(), sub);
 }
 
+// assets/schemas/config.schema.json
+var config_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Syncpoint Config",
+  description: "Configuration for syncpoint backup tool",
+  type: "object",
+  required: [
+    "backup"
+  ],
+  properties: {
+    backup: {
+      type: "object",
+      description: "Backup configuration",
+      required: [
+        "targets",
+        "exclude",
+        "filename"
+      ],
+      properties: {
+        targets: {
+          type: "array",
+          description: "List of files/directories to backup. Supports literal paths (e.g. ~/.zshrc), glob patterns (e.g. ~/.config/*.conf), and regex patterns (e.g. /\\.conf$/).",
+          items: {
+            type: "string",
+            validPattern: true
+          }
+        },
+        exclude: {
+          type: "array",
+          description: "List of patterns to exclude from backup. Supports glob (e.g. **/*.swp) and regex (e.g. /\\.bak$/) patterns.",
+          items: {
+            type: "string",
+            validPattern: true
+          }
+        },
+        filename: {
+          type: "string",
+          description: "Backup archive filename pattern. Available variables: {hostname}, {datetime}.",
+          minLength: 1
+        },
+        destination: {
+          type: "string",
+          description: "Backup archive destination path. Default: ~/.syncpoint/backups/"
+        },
+        includeSensitiveFiles: {
+          type: "boolean",
+          description: "Include sensitive files (SSH keys, certificates, etc.) in backup. When false (default), files matching sensitive patterns (id_rsa, id_ed25519, *.pem, *.key) are automatically excluded."
+        }
+      },
+      additionalProperties: false
+    },
+    scripts: {
+      type: "object",
+      description: "Scripts configuration",
+      properties: {
+        includeInBackup: {
+          type: "boolean",
+          description: "Whether to include scripts/ directory in backup. Default: true."
+        }
+      },
+      additionalProperties: false
+    },
+    "yaml-language-server": {
+      type: "string",
+      description: "Editor directive for schema association; ignored at runtime."
+    }
+  },
+  additionalProperties: false
+};
+
 // src/schemas/ajv.ts
 var import_ajv = __toESM(require("ajv"), 1);
 var import_ajv_formats = __toESM(require("ajv-formats"), 1);
@@ -231,45 +301,7 @@ ajv.addKeyword({
 });
 
 // src/schemas/config.schema.ts
-var configSchema = {
-  type: "object",
-  required: ["backup"],
-  properties: {
-    backup: {
-      type: "object",
-      required: ["targets", "exclude", "filename"],
-      properties: {
-        targets: {
-          type: "array",
-          items: { type: "string", validPattern: true }
-        },
-        exclude: {
-          type: "array",
-          items: { type: "string", validPattern: true }
-        },
-        filename: {
-          type: "string",
-          minLength: 1
-        },
-        destination: {
-          type: "string"
-        }
-      },
-      additionalProperties: false
-    },
-    scripts: {
-      type: "object",
-      properties: {
-        includeInBackup: {
-          type: "boolean"
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  additionalProperties: false
-};
-var validate2 = ajv.compile(configSchema);
+var validate2 = ajv.compile(config_schema_default);
 function validateConfig(data) {
   const valid = validate2(data);
   if (valid) return { valid: true };
@@ -429,7 +461,7 @@ function generateFilename(pattern, options) {
 var import_promises3 = require("fs/promises");
 var import_node_path5 = require("path");
 var import_picocolors = __toESM(require("picocolors"), 1);
-var ANSI_RE = /\x1b\[[0-9;]*m/g;
+var ANSI_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 function stripAnsi(str) {
   return str.replace(ANSI_RE, "");
 }
@@ -485,8 +517,11 @@ var logger = {
 var import_node_crypto = require("crypto");
 var import_promises4 = require("fs/promises");
 
-// src/schemas/metadata.schema.ts
-var metadataSchema = {
+// assets/schemas/metadata.schema.json
+var metadata_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Syncpoint Backup Metadata",
+  description: "Metadata stored inside backup archives as _metadata.json",
   type: "object",
   required: [
     "version",
@@ -499,57 +534,114 @@ var metadataSchema = {
     "summary"
   ],
   properties: {
-    version: { type: "string" },
-    toolVersion: { type: "string" },
-    createdAt: { type: "string" },
-    hostname: { type: "string" },
+    version: {
+      type: "string",
+      description: "Metadata schema version."
+    },
+    toolVersion: {
+      type: "string",
+      description: "Syncpoint tool version used to create the backup."
+    },
+    createdAt: {
+      type: "string",
+      description: "ISO 8601 timestamp of backup creation."
+    },
+    hostname: {
+      type: "string",
+      description: "Hostname of the machine where the backup was created."
+    },
     system: {
       type: "object",
+      description: "System information at backup time.",
       required: ["platform", "release", "arch"],
       properties: {
-        platform: { type: "string" },
-        release: { type: "string" },
-        arch: { type: "string" }
+        platform: {
+          type: "string",
+          description: "Operating system platform (e.g. darwin, linux)."
+        },
+        release: {
+          type: "string",
+          description: "OS kernel release version."
+        },
+        arch: {
+          type: "string",
+          description: "CPU architecture (e.g. arm64, x64)."
+        }
       },
       additionalProperties: false
     },
     config: {
       type: "object",
+      description: "Backup configuration snapshot.",
       required: ["filename"],
       properties: {
-        filename: { type: "string" },
-        destination: { type: "string" }
+        filename: {
+          type: "string",
+          description: "Filename pattern used for the backup."
+        },
+        destination: {
+          type: "string",
+          description: "Custom destination path, if configured."
+        }
       },
       additionalProperties: false
     },
     files: {
       type: "array",
+      description: "List of files included in the backup.",
       items: {
         type: "object",
         required: ["path", "absolutePath", "size", "hash"],
         properties: {
-          path: { type: "string" },
-          absolutePath: { type: "string" },
-          size: { type: "number", minimum: 0 },
-          hash: { type: "string" },
-          type: { type: "string" }
+          path: {
+            type: "string",
+            description: "Display path (e.g. ~/.zshrc)."
+          },
+          absolutePath: {
+            type: "string",
+            description: "Full filesystem path."
+          },
+          size: {
+            type: "number",
+            description: "File size in bytes.",
+            minimum: 0
+          },
+          hash: {
+            type: "string",
+            description: "SHA-256 hash of file contents."
+          },
+          type: {
+            type: "string",
+            description: "File type (e.g. symlink, directory)."
+          }
         },
         additionalProperties: false
       }
     },
     summary: {
       type: "object",
+      description: "Backup summary statistics.",
       required: ["fileCount", "totalSize"],
       properties: {
-        fileCount: { type: "integer", minimum: 0 },
-        totalSize: { type: "number", minimum: 0 }
+        fileCount: {
+          type: "integer",
+          description: "Total number of files in the backup.",
+          minimum: 0
+        },
+        totalSize: {
+          type: "number",
+          description: "Total size of all files in bytes.",
+          minimum: 0
+        }
       },
       additionalProperties: false
     }
   },
   additionalProperties: false
 };
-var validate3 = ajv.compile(metadataSchema);
+
+// src/schemas/metadata.schema.ts
+var validate3 = ajv.compile(metadata_schema_default);
 function validateMetadata(data) {
   const valid = validate3(data);
   if (valid) return { valid: true };
@@ -560,7 +652,7 @@ function validateMetadata(data) {
 }
 
 // src/version.ts
-var VERSION = "0.0.3";
+var VERSION = "0.0.5";
 
 // src/core/metadata.ts
 var METADATA_VERSION = "1.0.0";
@@ -611,7 +703,8 @@ async function collectFileInfo(absolutePath, logicalPath) {
   }
   let hash;
   if (lstats.isSymbolicLink()) {
-    hash = `sha256:${(0, import_node_crypto.createHash)("sha256").update(absolutePath).digest("hex")}`;
+    const linkTarget = await (0, import_promises4.readlink)(absolutePath);
+    hash = `sha256:${(0, import_node_crypto.createHash)("sha256").update(linkTarget).digest("hex")}`;
   } else {
     hash = await computeFileHash(absolutePath);
   }
@@ -672,7 +765,8 @@ async function extractArchive(archivePath, destDir) {
       const normalizedPath = (0, import_node_path6.normalize)(path);
       if (normalizedPath.includes("..")) return false;
       if (normalizedPath.startsWith("/")) return false;
-      if (entry.type === "SymbolicLink" || entry.type === "Link") return false;
+      if ("type" in entry && (entry.type === "SymbolicLink" || entry.type === "Link"))
+        return false;
       return true;
     }
   });
@@ -743,6 +837,10 @@ async function scanTargets(config) {
         });
         for (const match of allFiles) {
           if (regex.test(match) && !isExcluded(match)) {
+            if (!config.backup.includeSensitiveFiles && isSensitiveFile(match)) {
+              logger.warn(`Sensitive file excluded: ${match}`);
+              continue;
+            }
             const entry = await collectFileInfo(match, match);
             found.push(entry);
           }
@@ -771,6 +869,10 @@ async function scanTargets(config) {
       });
       for (const match of matches) {
         if (!isExcluded(match)) {
+          if (!config.backup.includeSensitiveFiles && isSensitiveFile(match)) {
+            logger.warn(`Sensitive file excluded: ${match}`);
+            continue;
+          }
           const entry = await collectFileInfo(match, match);
           found.push(entry);
         }
@@ -804,6 +906,10 @@ async function scanTargets(config) {
         });
         for (const match of matches) {
           if (!isExcluded(match)) {
+            if (!config.backup.includeSensitiveFiles && isSensitiveFile(match)) {
+              logger.warn(`Sensitive file excluded: ${match}`);
+              continue;
+            }
             const entry = await collectFileInfo(match, match);
             found.push(entry);
           }
@@ -815,15 +921,16 @@ async function scanTargets(config) {
         if (isExcluded(absPath)) {
           continue;
         }
+        if (!config.backup.includeSensitiveFiles && isSensitiveFile(absPath)) {
+          logger.warn(`Sensitive file excluded: ${target}`);
+          continue;
+        }
         const entry = await collectFileInfo(absPath, absPath);
         if (entry.size > LARGE_FILE_THRESHOLD) {
           logger.warn(
             `Large file (>${Math.round(LARGE_FILE_THRESHOLD / 1024 / 1024)}MB): ${target}`
           );
         }
-        if (isSensitiveFile(absPath)) {
-          logger.warn(`Sensitive file detected: ${target}`);
-        }
         found.push(entry);
       }
     }
@@ -857,7 +964,7 @@ async function createBackup(config, options = {}) {
     }
   }
   let allFiles = [...found];
-  if (config.scripts.includeInBackup) {
+  if (config.scripts?.includeInBackup) {
     const scripts = await collectScripts();
     allFiles = [...allFiles, ...scripts];
   }
@@ -1055,27 +1162,61 @@ var import_promises8 = require("fs/promises");
 var import_node_path9 = require("path");
 var import_yaml2 = __toESM(require("yaml"), 1);
 
-// src/schemas/template.schema.ts
-var templateSchema = {
+// assets/schemas/template.schema.json
+var template_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Syncpoint Template",
+  description: "Provisioning template for syncpoint",
   type: "object",
   required: ["name", "steps"],
   properties: {
-    name: { type: "string", minLength: 1 },
-    description: { type: "string" },
-    backup: { type: "string" },
-    sudo: { type: "boolean" },
+    name: {
+      type: "string",
+      description: "Template name.",
+      minLength: 1
+    },
+    description: {
+      type: "string",
+      description: "Template description."
+    },
+    backup: {
+      type: "string",
+      description: "Backup name to restore automatically after provisioning."
+    },
+    sudo: {
+      type: "boolean",
+      description: "Whether sudo privilege is required. If true, requests sudo authentication before execution."
+    },
     steps: {
       type: "array",
+      description: "List of provisioning steps. At least 1 step required.",
       minItems: 1,
       items: {
         type: "object",
         required: ["name", "command"],
         properties: {
-          name: { type: "string", minLength: 1 },
-          description: { type: "string" },
-          command: { type: "string", minLength: 1 },
-          skip_if: { type: "string" },
-          continue_on_error: { type: "boolean" }
+          name: {
+            type: "string",
+            description: "Step name.",
+            minLength: 1
+          },
+          description: {
+            type: "string",
+            description: "Step description."
+          },
+          command: {
+            type: "string",
+            description: "Shell command to execute.",
+            minLength: 1
+          },
+          skip_if: {
+            type: "string",
+            description: "Skip this step if this command exits with code 0."
+          },
+          continue_on_error: {
+            type: "boolean",
+            description: "Continue to next step even if this fails. Default: false."
+          }
         },
         additionalProperties: false
       }
@@ -1083,7 +1224,9 @@ var templateSchema = {
   },
   additionalProperties: false
 };
-var validate4 = ajv.compile(templateSchema);
+
+// src/schemas/template.schema.ts
+var validate4 = ajv.compile(template_schema_default);
 function validateTemplate(data) {
   const valid = validate4(data);
   if (valid) return { valid: true };
@@ -1209,8 +1352,10 @@ async function executeStep(step) {
       output: output || void 0
     };
   } catch (err) {
-    const error = err;
-    const errorOutput = [error.stdout, error.stderr, error.message].filter(Boolean).join("\n").trim();
+    const error = err instanceof Error ? err : new Error(String(err));
+    const stdout = err?.stdout ?? "";
+    const stderr = err?.stderr ?? "";
+    const errorOutput = [stdout, stderr, error.message].filter(Boolean).join("\n").trim();
     return {
       name: step.name,
       status: "failed",