@lumy-pack/syncpoint 0.0.1 → 0.0.2

package/dist/commands/Backup.d.ts

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

package/dist/commands/CreateTemplate.d.ts

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

package/dist/commands/Help.d.ts

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

package/dist/commands/Wizard.d.ts

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

package/dist/constants.d.ts

@@ -11,6 +11,5 @@ export declare const TEMPLATES_DIR = "templates";
 export declare const SCRIPTS_DIR = "scripts";
 export declare const LOGS_DIR = "logs";
 export declare function getAppDir(): string;
-export declare const APP_VERSION = "0.0.1";
-export type SubDirName = "backups" | "templates" | "scripts" | "logs";
+export type SubDirName = 'backups' | 'templates' | 'scripts' | 'logs';
 export declare function getSubDir(sub: SubDirName): string;

package/dist/core/backup.d.ts

@@ -1,7 +1,14 @@
-import type { BackupOptions, BackupResult, FileEntry, SyncpointConfig } from "../utils/types.js";
+import type { BackupOptions, BackupResult, FileEntry, SyncpointConfig } from '../utils/types.js';
 /**
  * Scan config targets, resolve globs, filter excludes.
  * Returns found FileEntry[] and missing path strings.
+ *
+ * Supports three pattern types:
+ * - Regex: /pattern/ format (e.g., /\.conf$/)
+ * - Glob: *.ext, **\/pattern (e.g., ~/.config/*.yml)
+ * - Literal: Direct file paths (e.g., ~/.zshrc)
+ *
+ * Exclude patterns are applied consistently across all target types.
  */
 export declare function scanTargets(config: SyncpointConfig): Promise<{
     found: FileEntry[];

package/dist/core/config.d.ts

@@ -1,4 +1,4 @@
-import type { SyncpointConfig } from "../utils/types.js";
+import type { SyncpointConfig } from '../utils/types.js';
 /**
  * Get the path to the config.yml file.
  */

package/dist/core/metadata.d.ts

@@ -1,4 +1,4 @@
-import type { BackupMetadata, FileEntry, SyncpointConfig } from "../utils/types.js";
+import type { BackupMetadata, FileEntry, SyncpointConfig } from '../utils/types.js';
 /**
  * Create a full metadata object for a backup.
  */

package/dist/core/provision.d.ts

@@ -1,4 +1,4 @@
-import type { ProvisionOptions, StepResult, TemplateConfig, TemplateStep } from "../utils/types.js";
+import type { ProvisionOptions, StepResult, TemplateConfig, TemplateStep } from '../utils/types.js';
 /**
  * Load and validate a template from a YAML file.
  */

package/dist/core/restore.d.ts

@@ -1,4 +1,4 @@
-import type { BackupInfo, RestoreOptions, RestorePlan, RestoreResult, SyncpointConfig } from "../utils/types.js";
+import type { BackupInfo, RestoreOptions, RestorePlan, RestoreResult, SyncpointConfig } from '../utils/types.js';
 /**
  * List all backup archives in the backup directory, sorted by date desc.
  */

package/dist/index.cjs

@@ -99,6 +99,14 @@ async function fileExists(filePath) {
     return false;
   }
 }
+async function isDirectory(filePath) {
+  try {
+    const stats = await (0, import_promises.stat)(filePath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
 
 // src/constants.ts
 var APP_NAME = "syncpoint";
@@ -114,7 +122,6 @@ var LOGS_DIR = "logs";
 function getAppDir() {
   return (0, import_node_path2.join)(getHomeDir(), APP_DIR);
 }
-var APP_VERSION = "0.0.1";
 function getSubDir(sub) {
   return (0, import_node_path2.join)(getAppDir(), sub);
 }
@@ -122,8 +129,106 @@ function getSubDir(sub) {
 // src/schemas/ajv.ts
 var import_ajv = __toESM(require("ajv"), 1);
 var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+
+// src/utils/pattern.ts
+var import_micromatch = __toESM(require("micromatch"), 1);
+function detectPatternType(pattern) {
+  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
+    const inner = pattern.slice(1, -1);
+    const hasUnescapedSlash = /(?<!\\)\//.test(inner);
+    if (!hasUnescapedSlash) {
+      return "regex";
+    }
+  }
+  if (pattern.includes("*") || pattern.includes("?") || pattern.includes("{")) {
+    return "glob";
+  }
+  return "literal";
+}
+function parseRegexPattern(pattern) {
+  if (!pattern.startsWith("/") || !pattern.endsWith("/")) {
+    throw new Error(
+      `Invalid regex pattern format: ${pattern}. Must be enclosed in slashes like /pattern/`
+    );
+  }
+  const regexBody = pattern.slice(1, -1);
+  try {
+    return new RegExp(regexBody);
+  } catch (error) {
+    throw new Error(
+      `Invalid regex pattern: ${pattern}. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function createExcludeMatcher(excludePatterns) {
+  if (excludePatterns.length === 0) {
+    return () => false;
+  }
+  const regexPatterns = [];
+  const globPatterns = [];
+  const literalPatterns = /* @__PURE__ */ new Set();
+  for (const pattern of excludePatterns) {
+    const type = detectPatternType(pattern);
+    if (type === "regex") {
+      try {
+        regexPatterns.push(parseRegexPattern(pattern));
+      } catch {
+        console.warn(`Skipping invalid regex pattern: ${pattern}`);
+      }
+    } else if (type === "glob") {
+      globPatterns.push(pattern);
+    } else {
+      literalPatterns.add(pattern);
+    }
+  }
+  return (filePath) => {
+    if (literalPatterns.has(filePath)) {
+      return true;
+    }
+    if (globPatterns.length > 0 && import_micromatch.default.isMatch(filePath, globPatterns, {
+      dot: true,
+      // Match dotfiles
+      matchBase: false
+      // Don't use basename matching, match full path
+    })) {
+      return true;
+    }
+    for (const regex of regexPatterns) {
+      if (regex.test(filePath)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function isValidPattern(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return false;
+  }
+  const type = detectPatternType(pattern);
+  if (type === "regex") {
+    try {
+      parseRegexPattern(pattern);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/schemas/ajv.ts
 var ajv = new import_ajv.default({ allErrors: true });
 (0, import_ajv_formats.default)(ajv);
+ajv.addKeyword({
+  keyword: "validPattern",
+  type: "string",
+  validate: function validate(schema, data) {
+    if (!schema) return true;
+    return isValidPattern(data);
+  },
+  errors: true
+});
 
 // src/schemas/config.schema.ts
 var configSchema = {
@@ -136,11 +241,11 @@ var configSchema = {
       properties: {
         targets: {
           type: "array",
-          items: { type: "string" }
+          items: { type: "string", validPattern: true }
         },
         exclude: {
           type: "array",
-          items: { type: "string" }
+          items: { type: "string", validPattern: true }
         },
         filename: {
           type: "string",
@@ -164,11 +269,11 @@ var configSchema = {
   },
   additionalProperties: false
 };
-var validate = ajv.compile(configSchema);
+var validate2 = ajv.compile(configSchema);
 function validateConfig(data) {
-  const valid = validate(data);
+  const valid = validate2(data);
   if (valid) return { valid: true };
-  const errors = validate.errors?.map(
+  const errors = validate2.errors?.map(
     (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
   );
   return { valid: false, errors };
@@ -220,20 +325,16 @@ Run "syncpoint init" first.`
   const data = stripDangerousKeys(import_yaml.default.parse(raw));
   const result = validateConfig(data);
   if (!result.valid) {
-    throw new Error(
-      `Invalid config:
-${(result.errors ?? []).join("\n")}`
-    );
+    throw new Error(`Invalid config:
+${(result.errors ?? []).join("\n")}`);
   }
   return data;
 }
 async function saveConfig(config) {
   const result = validateConfig(config);
   if (!result.valid) {
-    throw new Error(
-      `Invalid config:
-${(result.errors ?? []).join("\n")}`
-    );
+    throw new Error(`Invalid config:
+${(result.errors ?? []).join("\n")}`);
   }
   const configPath = getConfigPath();
   await ensureDir(getAppDir());
@@ -290,7 +391,7 @@ function getSystemInfo() {
 }
 function formatHostname(name) {
   const raw = name ?? getHostname();
-  return raw.replace(/\s+/g, "-").replace(/\./g, "-").replace(/[^a-zA-Z0-9\-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return raw.replace(/\s+/g, "-").replace(/\./g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 
 // src/utils/format.ts
@@ -448,23 +549,26 @@ var metadataSchema = {
   },
   additionalProperties: false
 };
-var validate2 = ajv.compile(metadataSchema);
+var validate3 = ajv.compile(metadataSchema);
 function validateMetadata(data) {
-  const valid = validate2(data);
+  const valid = validate3(data);
   if (valid) return { valid: true };
-  const errors = validate2.errors?.map(
+  const errors = validate3.errors?.map(
     (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
   );
   return { valid: false, errors };
 }
 
+// src/version.ts
+var VERSION = "0.0.2";
+
 // src/core/metadata.ts
 var METADATA_VERSION = "1.0.0";
 function createMetadata(files, config) {
   const totalSize = files.reduce((sum, f) => sum + f.size, 0);
   return {
     version: METADATA_VERSION,
-    toolVersion: APP_VERSION,
+    toolVersion: VERSION,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     hostname: getHostname(),
     system: getSystemInfo(),
@@ -484,10 +588,8 @@ function parseMetadata(data) {
   const parsed = JSON.parse(str);
   const result = validateMetadata(parsed);
   if (!result.valid) {
-    throw new Error(
-      `Invalid metadata:
-${(result.errors ?? []).join("\n")}`
-    );
+    throw new Error(`Invalid metadata:
+${(result.errors ?? []).join("\n")}`);
   }
   return parsed;
 }
@@ -503,6 +605,9 @@ async function collectFileInfo(absolutePath, logicalPath) {
     type = "symlink";
   } else if (lstats.isDirectory()) {
     type = "directory";
+    throw new Error(
+      `Cannot collect file info for directory: ${logicalPath}. Directories should be converted to glob patterns before calling collectFileInfo().`
+    );
   }
   let hash;
   if (lstats.isSymbolicLink()) {
@@ -530,7 +635,10 @@ async function createArchive(files, outputPath) {
     const fileNames = [];
     for (const file of files) {
       const targetPath = (0, import_node_path6.join)(tmpDir, file.name);
-      const parentDir = (0, import_node_path6.join)(tmpDir, file.name.split("/").slice(0, -1).join("/"));
+      const parentDir = (0, import_node_path6.join)(
+        tmpDir,
+        file.name.split("/").slice(0, -1).join("/")
+      );
       if (parentDir !== tmpDir) {
         await (0, import_promises5.mkdir)(parentDir, { recursive: true });
       }
@@ -607,18 +715,48 @@ function isSensitiveFile(filePath) {
 async function scanTargets(config) {
   const found = [];
   const missing = [];
+  const isExcluded = createExcludeMatcher(config.backup.exclude);
   for (const target of config.backup.targets) {
     const expanded = expandTilde(target);
-    if (expanded.includes("*") || expanded.includes("?") || expanded.includes("{")) {
+    const patternType = detectPatternType(expanded);
+    if (patternType === "regex") {
+      try {
+        const regex = parseRegexPattern(expanded);
+        const homeDir = expandTilde("~/");
+        const homeDirNormalized = homeDir.endsWith("/") ? homeDir : `${homeDir}/`;
+        const allFiles = await (0, import_fast_glob.default)(`${homeDirNormalized}**`, {
+          dot: true,
+          absolute: true,
+          onlyFiles: true,
+          deep: 5
+          // Limit depth for performance
+        });
+        for (const match of allFiles) {
+          if (regex.test(match) && !isExcluded(match)) {
+            const entry = await collectFileInfo(match, match);
+            found.push(entry);
+          }
+        }
+      } catch (error) {
+        logger.warn(
+          `Invalid regex pattern "${target}": ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } else if (patternType === "glob") {
+      const globExcludes = config.backup.exclude.filter(
+        (p) => detectPatternType(p) === "glob"
+      );
       const matches = await (0, import_fast_glob.default)(expanded, {
         dot: true,
         absolute: true,
-        ignore: config.backup.exclude,
+        ignore: globExcludes,
         onlyFiles: true
       });
       for (const match of matches) {
-        const entry = await collectFileInfo(match, match);
-        found.push(entry);
+        if (!isExcluded(match)) {
+          const entry = await collectFileInfo(match, match);
+          found.push(entry);
+        }
       }
     } else {
       const absPath = resolveTargetPath(target);
@@ -627,16 +765,43 @@ async function scanTargets(config) {
         missing.push(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}`
+      const isDir = await isDirectory(absPath);
+      if (isDir) {
+        const dirGlob = `${expanded}/**/*`;
+        const globExcludes = config.backup.exclude.filter(
+          (p) => detectPatternType(p) === "glob"
         );
+        const matches = await (0, import_fast_glob.default)(dirGlob, {
+          dot: true,
+          absolute: true,
+          ignore: globExcludes,
+          onlyFiles: true
+          // Only include files, not subdirectories
+        });
+        for (const match of matches) {
+          if (!isExcluded(match)) {
+            const entry = await collectFileInfo(match, match);
+            found.push(entry);
+          }
+        }
+        if (matches.length === 0) {
+          logger.warn(`Directory is empty or fully excluded: ${target}`);
+        }
+      } else {
+        if (isExcluded(absPath)) {
+          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);
       }
-      if (isSensitiveFile(absPath)) {
-        logger.warn(`Sensitive file detected: ${target}`);
-      }
-      found.push(entry);
     }
   }
   return { found, missing };
@@ -662,8 +827,10 @@ async function collectScripts() {
 }
 async function createBackup(config, options = {}) {
   const { found, missing } = await scanTargets(config);
-  for (const m of missing) {
-    logger.warn(`File not found, skipping: ${m}`);
+  if (options.verbose && missing.length > 0) {
+    for (const m of missing) {
+      logger.warn(`File not found, skipping: ${m}`);
+    }
   }
   let allFiles = [...found];
   if (config.scripts.includeInBackup) {
@@ -892,11 +1059,11 @@ var templateSchema = {
   },
   additionalProperties: false
 };
-var validate3 = ajv.compile(templateSchema);
+var validate4 = ajv.compile(templateSchema);
 function validateTemplate(data) {
-  const valid = validate3(data);
+  const valid = validate4(data);
   if (valid) return { valid: true };
-  const errors = validate3.errors?.map(
+  const errors = validate4.errors?.map(
     (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
   );
   return { valid: false, errors };
@@ -980,7 +1147,9 @@ function execAsync(command) {
 }
 async function evaluateSkipIf(command, stepName) {
   if (containsRemoteScriptPattern(command)) {
-    throw new Error(`Blocked dangerous remote script pattern in skip_if: ${stepName}`);
+    throw new Error(
+      `Blocked dangerous remote script pattern in skip_if: ${stepName}`
+    );
   }
   try {
     await execAsync(command);
@@ -992,7 +1161,9 @@ async function evaluateSkipIf(command, stepName) {
 async function executeStep(step) {
   const startTime = Date.now();
   if (containsRemoteScriptPattern(step.command)) {
-    throw new Error(`Blocked dangerous remote script pattern in command: ${step.name}`);
+    throw new Error(
+      `Blocked dangerous remote script pattern in command: ${step.name}`
+    );
   }
   if (step.skip_if) {
     const shouldSkip = await evaluateSkipIf(step.skip_if, step.name);
@@ -1046,9 +1217,7 @@ async function* runProvision(templatePath, options = {}) {
     const result = await executeStep(step);
     yield result;
     if (result.status === "failed" && !step.continue_on_error) {
-      logger.error(
-        `Step "${step.name}" failed. Stopping provisioning.`
-      );
+      logger.error(`Step "${step.name}" failed. Stopping provisioning.`);
       return;
     }
   }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { SyncpointConfig, BackupMetadata, FileEntry, TemplateConfig, TemplateStep, BackupResult, RestoreResult, RestorePlan, RestoreAction, StepResult, BackupOptions, RestoreOptions, ProvisionOptions, BackupInfo, StatusInfo, } from "./utils/types.js";
-export { loadConfig, saveConfig, initDefaultConfig } from "./core/config.js";
-export { createBackup, scanTargets } from "./core/backup.js";
-export { restoreBackup, getBackupList, getRestorePlan } from "./core/restore.js";
-export { runProvision, loadTemplate, listTemplates } from "./core/provision.js";
+export type { SyncpointConfig, BackupMetadata, FileEntry, TemplateConfig, TemplateStep, BackupResult, RestoreResult, RestorePlan, RestoreAction, StepResult, BackupOptions, RestoreOptions, ProvisionOptions, BackupInfo, StatusInfo, } from './utils/types.js';
+export { loadConfig, saveConfig, initDefaultConfig } from './core/config.js';
+export { createBackup, scanTargets } from './core/backup.js';
+export { restoreBackup, getBackupList, getRestorePlan, } from './core/restore.js';
+export { runProvision, loadTemplate, listTemplates } from './core/provision.js';