@lumy-pack/syncpoint 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,2651 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/Init.tsx
+import { useState, useEffect } from "react";
+import { Text, Box, useApp } from "ink";
+import { render } from "ink";
+import { join as join5 } from "path";
+
+// src/constants.ts
+import { join as join2 } from "path";
+
+// src/utils/paths.ts
+import { mkdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join, normalize, resolve } from "path";
+function getHomeDir() {
+  const envHome = process.env.SYNCPOINT_HOME;
+  if (envHome) {
+    const normalized = normalize(envHome);
+    if (normalized.includes("..")) {
+      throw new Error(`SYNCPOINT_HOME contains path traversal: ${envHome}`);
+    }
+    if (!resolve(normalized).startsWith("/")) {
+      throw new Error(`SYNCPOINT_HOME must be an absolute path: ${envHome}`);
+    }
+    return normalized;
+  }
+  return homedir();
+}
+function expandTilde(p) {
+  if (p === "~") return getHomeDir();
+  if (p.startsWith("~/")) return join(getHomeDir(), p.slice(2));
+  return p;
+}
+function contractTilde(p) {
+  const home = getHomeDir();
+  if (p === home) return "~";
+  if (p.startsWith(home + "/")) return "~" + p.slice(home.length);
+  return p;
+}
+function resolveTargetPath(p) {
+  return resolve(expandTilde(p));
+}
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInsideDir(filePath, dir) {
+  const resolvedFile = resolve(filePath);
+  const resolvedDir = resolve(dir);
+  return resolvedFile.startsWith(resolvedDir + "/") || resolvedFile === resolvedDir;
+}
+
+// src/constants.ts
+var APP_NAME = "syncpoint";
+var APP_DIR = `.${APP_NAME}`;
+var CONFIG_FILENAME = "config.yml";
+var METADATA_FILENAME = "_metadata.json";
+var LARGE_FILE_THRESHOLD = 10 * 1024 * 1024;
+var SENSITIVE_PATTERNS = ["id_rsa", "id_ed25519", "*.pem", "*.key"];
+var BACKUPS_DIR = "backups";
+var TEMPLATES_DIR = "templates";
+var SCRIPTS_DIR = "scripts";
+var LOGS_DIR = "logs";
+function getAppDir() {
+  return join2(getHomeDir(), APP_DIR);
+}
+var APP_VERSION = "0.0.1";
+function getSubDir(sub) {
+  return join2(getAppDir(), sub);
+}
+
+// src/utils/assets.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+function getPackageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  while (dir !== dirname(dir)) {
+    if (existsSync(join3(dir, "package.json"))) return dir;
+    dir = dirname(dir);
+  }
+  throw new Error("Could not find package root");
+}
+function getAssetPath(filename) {
+  return join3(getPackageRoot(), "assets", filename);
+}
+function readAsset(filename) {
+  return readFileSync(getAssetPath(filename), "utf-8");
+}
+
+// src/core/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { join as join4 } from "path";
+import YAML from "yaml";
+
+// src/schemas/ajv.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+var ajv = new Ajv({ allErrors: true });
+addFormats(ajv);
+
+// 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" }
+        },
+        exclude: {
+          type: "array",
+          items: { type: "string" }
+        },
+        filename: {
+          type: "string",
+          minLength: 1
+        },
+        destination: {
+          type: "string"
+        }
+      },
+      additionalProperties: false
+    },
+    scripts: {
+      type: "object",
+      properties: {
+        includeInBackup: {
+          type: "boolean"
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  additionalProperties: false
+};
+var validate = ajv.compile(configSchema);
+function validateConfig(data) {
+  const valid = validate(data);
+  if (valid) return { valid: true };
+  const errors = validate.errors?.map(
+    (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
+  );
+  return { valid: false, errors };
+}
+
+// src/core/config.ts
+function stripDangerousKeys(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(stripDangerousKeys);
+  const cleaned = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (["__proto__", "constructor", "prototype"].includes(key)) continue;
+    cleaned[key] = stripDangerousKeys(value);
+  }
+  return cleaned;
+}
+function getConfigPath() {
+  return join4(getAppDir(), CONFIG_FILENAME);
+}
+async function loadConfig() {
+  const configPath = getConfigPath();
+  const exists = await fileExists(configPath);
+  if (!exists) {
+    throw new Error(
+      `Config file not found: ${configPath}
+Run "syncpoint init" first.`
+    );
+  }
+  const raw = await readFile(configPath, "utf-8");
+  const data = stripDangerousKeys(YAML.parse(raw));
+  const result = validateConfig(data);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid config:
+${(result.errors ?? []).join("\n")}`
+    );
+  }
+  return data;
+}
+async function initDefaultConfig() {
+  const created = [];
+  const skipped = [];
+  const dirs = [
+    getAppDir(),
+    getSubDir(BACKUPS_DIR),
+    getSubDir(TEMPLATES_DIR),
+    getSubDir(SCRIPTS_DIR),
+    getSubDir(LOGS_DIR)
+  ];
+  for (const dir of dirs) {
+    const exists = await fileExists(dir);
+    if (!exists) {
+      await ensureDir(dir);
+      created.push(dir);
+    } else {
+      skipped.push(dir);
+    }
+  }
+  const configPath = getConfigPath();
+  const configExists = await fileExists(configPath);
+  if (!configExists) {
+    const yamlContent = readAsset("config.default.yml");
+    await writeFile(configPath, yamlContent, "utf-8");
+    created.push(configPath);
+  } else {
+    skipped.push(configPath);
+  }
+  return { created, skipped };
+}
+
+// src/commands/Init.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var InitView = () => {
+  const { exit } = useApp();
+  const [steps, setSteps] = useState([]);
+  const [error, setError] = useState(null);
+  const [complete, setComplete] = useState(false);
+  useEffect(() => {
+    (async () => {
+      try {
+        const appDir = getAppDir();
+        if (await fileExists(join5(appDir, CONFIG_FILENAME))) {
+          setError(`Already initialized: ${appDir}`);
+          exit();
+          return;
+        }
+        const dirs = [
+          { name: appDir, label: `~/.${APP_NAME}/` },
+          {
+            name: getSubDir(BACKUPS_DIR),
+            label: `~/.${APP_NAME}/${BACKUPS_DIR}/`
+          },
+          {
+            name: getSubDir(TEMPLATES_DIR),
+            label: `~/.${APP_NAME}/${TEMPLATES_DIR}/`
+          },
+          {
+            name: getSubDir(SCRIPTS_DIR),
+            label: `~/.${APP_NAME}/${SCRIPTS_DIR}/`
+          },
+          {
+            name: getSubDir(LOGS_DIR),
+            label: `~/.${APP_NAME}/${LOGS_DIR}/`
+          }
+        ];
+        const completed = [];
+        for (const dir of dirs) {
+          await ensureDir(dir.name);
+          completed.push({ name: `Created ${dir.label}`, done: true });
+          setSteps([...completed]);
+        }
+        await initDefaultConfig();
+        completed.push({ name: `Created ${CONFIG_FILENAME} (defaults)`, done: true });
+        setSteps([...completed]);
+        const exampleTemplatePath = join5(getSubDir(TEMPLATES_DIR), "example.yml");
+        if (!await fileExists(exampleTemplatePath)) {
+          const { writeFile: writeFile3 } = await import("fs/promises");
+          const exampleYaml = readAsset("template.example.yml");
+          await writeFile3(exampleTemplatePath, exampleYaml, "utf-8");
+          completed.push({ name: `Created templates/example.yml`, done: true });
+          setSteps([...completed]);
+        }
+        setComplete(true);
+        setTimeout(() => exit(), 100);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        exit();
+      }
+    })();
+  }, []);
+  if (error) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    steps.map((step, idx) => /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2713" }),
+      " ",
+      step.name
+    ] }, idx)),
+    complete && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Initialization complete! Next steps:" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        "1. Edit config.yml to specify backup targets"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "     ",
+        "\u2192 ~/.",
+        APP_NAME,
+        "/",
+        CONFIG_FILENAME
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        "2. Run ",
+        APP_NAME,
+        " backup to create your first snapshot"
+      ] })
+    ] })
+  ] });
+};
+function registerInitCommand(program2) {
+  program2.command("init").description(`Initialize ~/.${APP_NAME}/ directory structure and default config`).action(async () => {
+    const { waitUntilExit } = render(/* @__PURE__ */ jsx(InitView, {}));
+    await waitUntilExit();
+  });
+}
+
+// src/commands/Backup.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Text as Text3, Box as Box2, useApp as useApp2 } from "ink";
+import { render as render2 } from "ink";
+
+// src/core/backup.ts
+import { readdir } from "fs/promises";
+import { join as join8, basename } from "path";
+import fg from "fast-glob";
+
+// src/utils/system.ts
+import { hostname as osHostname, platform, release, arch } from "os";
+function getHostname() {
+  return osHostname();
+}
+function getSystemInfo() {
+  return {
+    platform: platform(),
+    release: release(),
+    arch: arch()
+  };
+}
+function formatHostname(name) {
+  const raw = name ?? getHostname();
+  return raw.replace(/\s+/g, "-").replace(/\./g, "-").replace(/[^a-zA-Z0-9\-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/utils/format.ts
+function formatBytes(bytes) {
+  if (bytes <= 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const value = bytes / Math.pow(k, i);
+  if (i === 0) return `${bytes} B`;
+  return `${value.toFixed(1)} ${units[i]}`;
+}
+function formatDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const min = String(date.getMinutes()).padStart(2, "0");
+  return `${y}-${m}-${d} ${h}:${min}`;
+}
+function formatDatetime(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const min = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${y}-${m}-${d}_${h}${min}${s}`;
+}
+function formatRelativeTime(date) {
+  const now = Date.now();
+  const diffMs = now - date.getTime();
+  const diffSec = Math.floor(diffMs / 1e3);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+  if (diffSec < 60) return `${diffSec}s ago`;
+  if (diffMin < 60) return `${diffMin}m ago`;
+  if (diffHour < 24) return `${diffHour}h ago`;
+  return `${diffDay}d ago`;
+}
+function generateFilename(pattern, options) {
+  const now = options?.date ?? /* @__PURE__ */ new Date();
+  const host = formatHostname(options?.hostname);
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const min = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  let result = pattern.replace(/\{hostname\}/g, host).replace(/\{date\}/g, `${y}-${m}-${d}`).replace(/\{time\}/g, `${h}${min}${s}`).replace(/\{datetime\}/g, `${y}-${m}-${d}_${h}${min}${s}`);
+  if (options?.tag) {
+    result = result.replace(/\{tag\}/g, options.tag);
+    if (!pattern.includes("{tag}")) {
+      result += `_${options.tag}`;
+    }
+  } else {
+    result = result.replace(/\{tag\}/g, "").replace(/_+/g, "_").replace(/_$/, "");
+  }
+  return result;
+}
+
+// src/utils/logger.ts
+import { appendFile, mkdir as mkdir2 } from "fs/promises";
+import { join as join6 } from "path";
+import pc from "picocolors";
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(str) {
+  return str.replace(ANSI_RE, "");
+}
+function timestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const h = String(now.getHours()).padStart(2, "0");
+  const m = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+function dateStamp() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+var logDirCreated = false;
+async function writeToFile(level, message) {
+  try {
+    const logsDir = join6(getAppDir(), LOGS_DIR);
+    if (!logDirCreated) {
+      await mkdir2(logsDir, { recursive: true });
+      logDirCreated = true;
+    }
+    const logFile = join6(logsDir, `${dateStamp()}.log`);
+    const line = `[${timestamp()}] [${level.toUpperCase()}] ${stripAnsi(message)}
+`;
+    await appendFile(logFile, line, "utf-8");
+  } catch {
+  }
+}
+var logger = {
+  info(message) {
+    console.log(`${pc.blue("info")} ${message}`);
+    void writeToFile("info", message);
+  },
+  success(message) {
+    console.log(`${pc.green("success")} ${message}`);
+    void writeToFile("success", message);
+  },
+  warn(message) {
+    console.warn(`${pc.yellow("warn")} ${message}`);
+    void writeToFile("warn", message);
+  },
+  error(message) {
+    console.error(`${pc.red("error")} ${message}`);
+    void writeToFile("error", message);
+  }
+};
+
+// src/core/metadata.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, lstat } from "fs/promises";
+
+// src/schemas/metadata.schema.ts
+var metadataSchema = {
+  type: "object",
+  required: [
+    "version",
+    "toolVersion",
+    "createdAt",
+    "hostname",
+    "system",
+    "config",
+    "files",
+    "summary"
+  ],
+  properties: {
+    version: { type: "string" },
+    toolVersion: { type: "string" },
+    createdAt: { type: "string" },
+    hostname: { type: "string" },
+    system: {
+      type: "object",
+      required: ["platform", "release", "arch"],
+      properties: {
+        platform: { type: "string" },
+        release: { type: "string" },
+        arch: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    config: {
+      type: "object",
+      required: ["filename"],
+      properties: {
+        filename: { type: "string" },
+        destination: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    files: {
+      type: "array",
+      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" }
+        },
+        additionalProperties: false
+      }
+    },
+    summary: {
+      type: "object",
+      required: ["fileCount", "totalSize"],
+      properties: {
+        fileCount: { type: "integer", minimum: 0 },
+        totalSize: { type: "number", minimum: 0 }
+      },
+      additionalProperties: false
+    }
+  },
+  additionalProperties: false
+};
+var validate2 = ajv.compile(metadataSchema);
+function validateMetadata(data) {
+  const valid = validate2(data);
+  if (valid) return { valid: true };
+  const errors = validate2.errors?.map(
+    (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
+  );
+  return { valid: false, errors };
+}
+
+// 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,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    hostname: getHostname(),
+    system: getSystemInfo(),
+    config: {
+      filename: config.backup.filename,
+      destination: config.backup.destination
+    },
+    files,
+    summary: {
+      fileCount: files.length,
+      totalSize
+    }
+  };
+}
+function parseMetadata(data) {
+  const str = typeof data === "string" ? data : data.toString("utf-8");
+  const parsed = JSON.parse(str);
+  const result = validateMetadata(parsed);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid metadata:
+${(result.errors ?? []).join("\n")}`
+    );
+  }
+  return parsed;
+}
+async function computeFileHash(filePath) {
+  const content = await readFile2(filePath);
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `sha256:${hash}`;
+}
+async function collectFileInfo(absolutePath, logicalPath) {
+  const lstats = await lstat(absolutePath);
+  let type;
+  if (lstats.isSymbolicLink()) {
+    type = "symlink";
+  } else if (lstats.isDirectory()) {
+    type = "directory";
+  }
+  let hash;
+  if (lstats.isSymbolicLink()) {
+    hash = `sha256:${createHash("sha256").update(absolutePath).digest("hex")}`;
+  } else {
+    hash = await computeFileHash(absolutePath);
+  }
+  return {
+    path: contractTilde(logicalPath),
+    absolutePath,
+    size: lstats.size,
+    hash,
+    type
+  };
+}
+
+// src/core/storage.ts
+import { mkdir as mkdir3, mkdtemp, readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join7, normalize as normalize2 } from "path";
+import * as tar from "tar";
+async function createArchive(files, outputPath) {
+  const tmpDir = await mkdtemp(join7(tmpdir(), "syncpoint-"));
+  try {
+    const fileNames = [];
+    for (const file of files) {
+      const targetPath = join7(tmpDir, file.name);
+      const parentDir = join7(tmpDir, file.name.split("/").slice(0, -1).join("/"));
+      if (parentDir !== tmpDir) {
+        await mkdir3(parentDir, { recursive: true });
+      }
+      if (file.content !== void 0) {
+        await writeFile2(targetPath, file.content);
+      } else if (file.sourcePath) {
+        const data = await readFile3(file.sourcePath);
+        await writeFile2(targetPath, data);
+      }
+      fileNames.push(file.name);
+    }
+    await tar.create(
+      {
+        gzip: true,
+        file: outputPath,
+        cwd: tmpDir
+      },
+      fileNames
+    );
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}
+async function extractArchive(archivePath, destDir) {
+  await mkdir3(destDir, { recursive: true });
+  await tar.extract({
+    file: archivePath,
+    cwd: destDir,
+    preservePaths: false,
+    filter: (path, entry) => {
+      const normalizedPath = normalize2(path);
+      if (normalizedPath.includes("..")) return false;
+      if (normalizedPath.startsWith("/")) return false;
+      if (entry.type === "SymbolicLink" || entry.type === "Link") return false;
+      return true;
+    }
+  });
+}
+async function readFileFromArchive(archivePath, filename) {
+  if (filename.includes("..") || filename.startsWith("/")) {
+    throw new Error(`Invalid filename: ${filename}`);
+  }
+  const tmpDir = await mkdtemp(join7(tmpdir(), "syncpoint-read-"));
+  try {
+    await tar.extract({
+      file: archivePath,
+      cwd: tmpDir,
+      filter: (path) => {
+        const normalized = path.replace(/^\.\//, "");
+        return normalized === filename;
+      }
+    });
+    const extractedPath = join7(tmpDir, filename);
+    try {
+      return await readFile3(extractedPath);
+    } catch {
+      return null;
+    }
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// src/core/backup.ts
+function isSensitiveFile(filePath) {
+  const name = basename(filePath);
+  return SENSITIVE_PATTERNS.some((pattern) => {
+    if (pattern.startsWith("*")) {
+      return name.endsWith(pattern.slice(1));
+    }
+    return name === pattern || filePath.includes(pattern);
+  });
+}
+async function scanTargets(config) {
+  const found = [];
+  const missing = [];
+  for (const target of config.backup.targets) {
+    const expanded = expandTilde(target);
+    if (expanded.includes("*") || expanded.includes("?") || expanded.includes("{")) {
+      const matches = await fg(expanded, {
+        dot: true,
+        absolute: true,
+        ignore: config.backup.exclude,
+        onlyFiles: true
+      });
+      for (const match of matches) {
+        const entry = await collectFileInfo(match, match);
+        found.push(entry);
+      }
+    } else {
+      const absPath = resolveTargetPath(target);
+      const exists = await fileExists(absPath);
+      if (!exists) {
+        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}`
+        );
+      }
+      if (isSensitiveFile(absPath)) {
+        logger.warn(`Sensitive file detected: ${target}`);
+      }
+      found.push(entry);
+    }
+  }
+  return { found, missing };
+}
+async function collectScripts() {
+  const scriptsDir = getSubDir(SCRIPTS_DIR);
+  const exists = await fileExists(scriptsDir);
+  if (!exists) return [];
+  const entries = [];
+  try {
+    const files = await readdir(scriptsDir, { withFileTypes: true });
+    for (const file of files) {
+      if (file.isFile() && file.name.endsWith(".sh")) {
+        const absPath = join8(scriptsDir, file.name);
+        const entry = await collectFileInfo(absPath, absPath);
+        entries.push(entry);
+      }
+    }
+  } catch {
+    logger.info("Skipping unreadable scripts directory");
+  }
+  return entries;
+}
+async function createBackup(config, options = {}) {
+  const { found, missing } = await scanTargets(config);
+  for (const m of missing) {
+    logger.warn(`File not found, skipping: ${m}`);
+  }
+  let allFiles = [...found];
+  if (config.scripts.includeInBackup) {
+    const scripts = await collectScripts();
+    allFiles = [...allFiles, ...scripts];
+  }
+  if (allFiles.length === 0) {
+    throw new Error("No files found to backup.");
+  }
+  const metadata = createMetadata(allFiles, config);
+  const filename = generateFilename(config.backup.filename, {
+    tag: options.tag
+  });
+  const archiveFilename = `${filename}.tar.gz`;
+  const destDir = config.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir(BACKUPS_DIR);
+  await ensureDir(destDir);
+  const archivePath = join8(destDir, archiveFilename);
+  if (options.dryRun) {
+    return { archivePath, metadata };
+  }
+  const archiveFiles = [];
+  archiveFiles.push({
+    name: METADATA_FILENAME,
+    content: JSON.stringify(metadata, null, 2)
+  });
+  for (const file of allFiles) {
+    archiveFiles.push({
+      name: file.path.startsWith("~/") ? file.path.slice(2) : file.path,
+      sourcePath: file.absolutePath
+    });
+  }
+  await createArchive(archiveFiles, archivePath);
+  logger.success(`Backup created: ${archivePath}`);
+  return { archivePath, metadata };
+}
+
+// src/components/ProgressBar.tsx
+import { Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var ProgressBar = ({
+  percent,
+  width = 30
+}) => {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(width * (clamped / 100));
+  const empty = width - filled;
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "\u2591".repeat(empty) }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      " ",
+      clamped,
+      "%"
+    ] })
+  ] });
+};
+
+// src/commands/Backup.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var BackupView = ({ options }) => {
+  const { exit } = useApp2();
+  const [phase, setPhase] = useState2("scanning");
+  const [, setConfig] = useState2(null);
+  const [foundFiles, setFoundFiles] = useState2([]);
+  const [missingFiles, setMissingFiles] = useState2([]);
+  const [progress, setProgress] = useState2(0);
+  const [result, setResult] = useState2(null);
+  const [error, setError] = useState2(null);
+  useEffect2(() => {
+    (async () => {
+      try {
+        const cfg = await loadConfig();
+        setConfig(cfg);
+        const { found, missing } = await scanTargets(cfg);
+        setFoundFiles(found);
+        setMissingFiles(missing);
+        if (options.dryRun) {
+          setPhase("done");
+          setTimeout(() => exit(), 100);
+          return;
+        }
+        setPhase("compressing");
+        const progressInterval = setInterval(() => {
+          setProgress((prev) => {
+            if (prev >= 90) return prev;
+            return prev + 10;
+          });
+        }, 100);
+        const backupResult = await createBackup(cfg, options);
+        clearInterval(progressInterval);
+        setProgress(100);
+        setResult(backupResult);
+        setPhase("done");
+        setTimeout(() => exit(), 100);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        exit();
+      }
+    })();
+  }, []);
+  if (phase === "error" || error) {
+    return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      "\u2717 Backup failed: ",
+      error
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "\u25B8 Scanning backup targets..." }),
+    foundFiles.map((file, idx) => /* @__PURE__ */ jsxs3(Text3, { children: [
+      "  ",
+      /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713" }),
+      " ",
+      contractTilde(file.absolutePath),
+      /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+        "    ",
+        formatBytes(file.size).padStart(10)
+      ] })
+    ] }, idx)),
+    missingFiles.map((file, idx) => /* @__PURE__ */ jsxs3(Text3, { children: [
+      "  ",
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "\u26A0" }),
+      " ",
+      file,
+      /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+        "    ",
+        "File not found, skipped"
+      ] })
+    ] }, idx)),
+    options.dryRun && phase === "done" && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "(dry-run) No actual backup was created" }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "Target files: ",
+        foundFiles.length,
+        " (",
+        formatBytes(foundFiles.reduce((sum, f) => sum + f.size, 0)),
+        ")"
+      ] })
+    ] }),
+    phase === "compressing" && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { children: "\u25B8 Compressing..." }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "  ",
+        /* @__PURE__ */ jsx3(ProgressBar, { percent: progress })
+      ] })
+    ] }),
+    phase === "done" && result && !options.dryRun && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "\u2713 Backup complete" }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "  ",
+        "File: ",
+        result.metadata.config.filename
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "  ",
+        "Size: ",
+        formatBytes(result.metadata.summary.totalSize),
+        " (",
+        result.metadata.summary.fileCount,
+        " files + metadata)"
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "  ",
+        "Path: ",
+        contractTilde(result.archivePath)
+      ] })
+    ] })
+  ] });
+};
+function registerBackupCommand(program2) {
+  program2.command("backup").description("Create a config file backup").option("--dry-run", "Show target file list without actual compression", false).option("--tag <name>", "Add a tag to the backup filename").action(async (opts) => {
+    const { waitUntilExit } = render2(
+      /* @__PURE__ */ jsx3(BackupView, { options: { dryRun: opts.dryRun, tag: opts.tag } })
+    );
+    await waitUntilExit();
+  });
+}
+
+// src/commands/Restore.tsx
+import { useState as useState4, useEffect as useEffect3 } from "react";
+import { Text as Text5, Box as Box3, useApp as useApp3 } from "ink";
+import SelectInput from "ink-select-input";
+import { render as render3 } from "ink";
+
+// src/core/restore.ts
+import { copyFile, lstat as lstat2, readdir as readdir2, stat as stat2 } from "fs/promises";
+import { join as join9, dirname as dirname2 } from "path";
+async function getBackupList(config) {
+  const backupDir = config?.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir(BACKUPS_DIR);
+  const exists = await fileExists(backupDir);
+  if (!exists) return [];
+  const entries = await readdir2(backupDir, { withFileTypes: true });
+  const backups = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".tar.gz")) continue;
+    const fullPath = join9(backupDir, entry.name);
+    const fileStat = await stat2(fullPath);
+    let hostname;
+    let fileCount;
+    try {
+      const metaBuf = await readFileFromArchive(fullPath, METADATA_FILENAME);
+      if (metaBuf) {
+        const meta = parseMetadata(metaBuf);
+        hostname = meta.hostname;
+        fileCount = meta.summary.fileCount;
+      }
+    } catch {
+      logger.info(`Could not read metadata from: ${entry.name}`);
+    }
+    backups.push({
+      filename: entry.name,
+      path: fullPath,
+      size: fileStat.size,
+      createdAt: fileStat.mtime,
+      hostname,
+      fileCount
+    });
+  }
+  backups.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  return backups;
+}
+async function getRestorePlan(archivePath) {
+  const metaBuf = await readFileFromArchive(archivePath, METADATA_FILENAME);
+  if (!metaBuf) {
+    throw new Error(
+      `No metadata found in archive: ${archivePath}
+This may not be a valid syncpoint backup.`
+    );
+  }
+  const metadata = parseMetadata(metaBuf);
+  const actions = [];
+  for (const file of metadata.files) {
+    const absPath = resolveTargetPath(file.path);
+    const exists = await fileExists(absPath);
+    if (!exists) {
+      actions.push({
+        path: file.path,
+        action: "create",
+        backupSize: file.size,
+        reason: "File does not exist on this machine"
+      });
+      continue;
+    }
+    const currentHash = await computeFileHash(absPath);
+    const currentStat = await stat2(absPath);
+    if (currentHash === file.hash) {
+      actions.push({
+        path: file.path,
+        action: "skip",
+        currentSize: currentStat.size,
+        backupSize: file.size,
+        reason: "File is identical (same hash)"
+      });
+    } else {
+      actions.push({
+        path: file.path,
+        action: "overwrite",
+        currentSize: currentStat.size,
+        backupSize: file.size,
+        reason: "File has been modified"
+      });
+    }
+  }
+  return { metadata, actions };
+}
+async function createSafetyBackup(filePaths) {
+  const now = /* @__PURE__ */ new Date();
+  const filename = `_pre-restore_${formatDatetime(now)}.tar.gz`;
+  const backupDir = getSubDir(BACKUPS_DIR);
+  await ensureDir(backupDir);
+  const archivePath = join9(backupDir, filename);
+  const files = [];
+  for (const fp of filePaths) {
+    const absPath = resolveTargetPath(fp);
+    const exists = await fileExists(absPath);
+    if (!exists) continue;
+    const archiveName = fp.startsWith("~/") ? fp.slice(2) : fp;
+    files.push({ name: archiveName, sourcePath: absPath });
+  }
+  if (files.length === 0) {
+    logger.info("No existing files to safety-backup.");
+    return archivePath;
+  }
+  await createArchive(files, archivePath);
+  logger.info(`Safety backup created: ${archivePath}`);
+  return archivePath;
+}
+async function restoreBackup(archivePath, options = {}) {
+  const plan = await getRestorePlan(archivePath);
+  const restoredFiles = [];
+  const skippedFiles = [];
+  const overwritePaths = plan.actions.filter((a) => a.action === "overwrite").map((a) => a.path);
+  let safetyBackupPath;
+  if (overwritePaths.length > 0 && !options.dryRun) {
+    safetyBackupPath = await createSafetyBackup(overwritePaths);
+  }
+  if (options.dryRun) {
+    return {
+      restoredFiles: plan.actions.filter((a) => a.action !== "skip").map((a) => a.path),
+      skippedFiles: plan.actions.filter((a) => a.action === "skip").map((a) => a.path),
+      safetyBackupPath
+    };
+  }
+  const { mkdtemp: mkdtemp2, rm: rm2 } = await import("fs/promises");
+  const { tmpdir: tmpdir2 } = await import("os");
+  const tmpDir = await mkdtemp2(join9(tmpdir2(), "syncpoint-restore-"));
+  try {
+    await extractArchive(archivePath, tmpDir);
+    for (const action of plan.actions) {
+      if (action.action === "skip") {
+        skippedFiles.push(action.path);
+        continue;
+      }
+      const archiveName = action.path.startsWith("~/") ? action.path.slice(2) : action.path;
+      const extractedPath = join9(tmpDir, archiveName);
+      const destPath = resolveTargetPath(action.path);
+      const extractedExists = await fileExists(extractedPath);
+      if (!extractedExists) {
+        logger.warn(`File not found in archive: ${archiveName}`);
+        skippedFiles.push(action.path);
+        continue;
+      }
+      await ensureDir(dirname2(destPath));
+      try {
+        const destStat = await lstat2(destPath);
+        if (destStat.isSymbolicLink()) {
+          logger.warn(`Skipping symlink target: ${action.path}`);
+          skippedFiles.push(action.path);
+          continue;
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+      await copyFile(extractedPath, destPath);
+      restoredFiles.push(action.path);
+    }
+  } finally {
+    await rm2(tmpDir, { recursive: true, force: true });
+  }
+  return { restoredFiles, skippedFiles, safetyBackupPath };
+}
+
+// src/components/Confirm.tsx
+import { Text as Text4, useInput } from "ink";
+import { useState as useState3 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var Confirm = ({
+  message,
+  onConfirm,
+  defaultYes = true
+}) => {
+  const [answered, setAnswered] = useState3(false);
+  useInput((input, key) => {
+    if (answered) return;
+    if (input === "y" || input === "Y") {
+      setAnswered(true);
+      onConfirm(true);
+    } else if (input === "n" || input === "N") {
+      setAnswered(true);
+      onConfirm(false);
+    } else if (key.return) {
+      setAnswered(true);
+      onConfirm(defaultYes);
+    }
+  });
+  const yText = defaultYes ? /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Y" }) : /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "y" });
+  const nText = defaultYes ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "n" }) : /* @__PURE__ */ jsx4(Text4, { bold: true, children: "N" });
+  return /* @__PURE__ */ jsxs4(Text4, { children: [
+    /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "? " }),
+    message,
+    " ",
+    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "[" }),
+    yText,
+    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "/" }),
+    nText,
+    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "]" })
+  ] });
+};
+
+// src/commands/Restore.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var RestoreView = ({ filename, options }) => {
+  const { exit } = useApp3();
+  const [phase, setPhase] = useState4("loading");
+  const [backups, setBackups] = useState4([]);
+  const [selectedPath, setSelectedPath] = useState4(null);
+  const [plan, setPlan] = useState4(null);
+  const [result, setResult] = useState4(null);
+  const [safetyDone, setSafetyDone] = useState4(false);
+  const [error, setError] = useState4(null);
+  useEffect3(() => {
+    (async () => {
+      try {
+        const list2 = await getBackupList();
+        setBackups(list2);
+        if (list2.length === 0) {
+          setError("No backups available.");
+          setPhase("error");
+          exit();
+          return;
+        }
+        if (filename) {
+          const match = list2.find(
+            (b) => b.filename === filename || b.filename.startsWith(filename)
+          );
+          if (!match) {
+            setError(`Backup not found: ${filename}`);
+            setPhase("error");
+            exit();
+            return;
+          }
+          setSelectedPath(match.path);
+          setPhase("planning");
+        } else {
+          setPhase("selecting");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        exit();
+      }
+    })();
+  }, []);
+  useEffect3(() => {
+    if (phase !== "planning" || !selectedPath) return;
+    (async () => {
+      try {
+        const restorePlan = await getRestorePlan(selectedPath);
+        setPlan(restorePlan);
+        if (options.dryRun) {
+          setPhase("done");
+          setTimeout(() => exit(), 100);
+        } else {
+          setPhase("confirming");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        exit();
+      }
+    })();
+  }, [phase, selectedPath]);
+  const handleSelect = (item) => {
+    setSelectedPath(item.value);
+    setPhase("planning");
+  };
+  const handleConfirm = async (yes) => {
+    if (!yes || !selectedPath) {
+      setPhase("done");
+      setTimeout(() => exit(), 100);
+      return;
+    }
+    try {
+      setPhase("restoring");
+      try {
+        const config = await loadConfig();
+        await createBackup(config, { tag: "pre-restore" });
+        setSafetyDone(true);
+      } catch {
+      }
+      const restoreResult = await restoreBackup(selectedPath, options);
+      setResult(restoreResult);
+      setPhase("done");
+      setTimeout(() => exit(), 100);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setPhase("error");
+      exit();
+    }
+  };
+  if (phase === "error" || error) {
+    return /* @__PURE__ */ jsx5(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsxs5(Text5, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  const selectItems = backups.map((b, idx) => ({
+    label: `${String(idx + 1).padStart(2)}  ${b.filename.replace(".tar.gz", "").padEnd(40)}  ${formatBytes(b.size).padStart(8)}   ${formatDate(b.createdAt)}`,
+    value: b.path
+  }));
+  const currentHostname = getHostname();
+  const isRemoteBackup = plan?.metadata.hostname && plan.metadata.hostname !== currentHostname;
+  return /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
+    phase === "loading" && /* @__PURE__ */ jsx5(Text5, { children: "\u25B8 Loading backup list..." }),
+    phase === "selecting" && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "\u25B8 Select backup" }),
+      /* @__PURE__ */ jsx5(SelectInput, { items: selectItems, onSelect: handleSelect })
+    ] }),
+    (phase === "planning" || phase === "confirming" || phase === "restoring" || phase === "done" && plan) && plan && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
+          "\u25B8 Metadata (",
+          plan.metadata.config.filename ?? "",
+          ")"
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "  ",
+          "Host: ",
+          plan.metadata.hostname
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "  ",
+          "Created: ",
+          plan.metadata.createdAt
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "  ",
+          "Files: ",
+          plan.metadata.summary.fileCount,
+          " (",
+          formatBytes(plan.metadata.summary.totalSize),
+          ")"
+        ] }),
+        isRemoteBackup && /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+          "  ",
+          "\u26A0 This backup was created on a different machine (",
+          plan.metadata.hostname,
+          ")"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "\u25B8 Restore plan:" }),
+        plan.actions.map((action, idx) => {
+          let icon;
+          let color;
+          let label;
+          switch (action.action) {
+            case "overwrite":
+              icon = "Overwrite";
+              color = "yellow";
+              label = `(${formatBytes(action.currentSize ?? 0)} \u2192 ${formatBytes(action.backupSize ?? 0)}, ${action.reason})`;
+              break;
+            case "skip":
+              icon = "Skip";
+              color = "gray";
+              label = `(${action.reason})`;
+              break;
+            case "create":
+              icon = "Create";
+              color = "green";
+              label = "(not present)";
+              break;
+          }
+          return /* @__PURE__ */ jsxs5(Text5, { children: [
+            "  ",
+            /* @__PURE__ */ jsx5(Text5, { color, children: icon.padEnd(8) }),
+            "  ",
+            contractTilde(action.path),
+            "  ",
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: label })
+          ] }, idx);
+        })
+      ] }),
+      options.dryRun && phase === "done" && /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "(dry-run) No actual restore was performed" })
+    ] }),
+    phase === "confirming" && /* @__PURE__ */ jsx5(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsx5(Confirm, { message: "Proceed with restore?", onConfirm: handleConfirm }) }),
+    phase === "restoring" && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
+      safetyDone && /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2713" }),
+        " Safety backup of current files complete"
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { children: "\u25B8 Restoring..." })
+    ] }),
+    phase === "done" && result && !options.dryRun && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", marginTop: 1, children: [
+      safetyDone && /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2713" }),
+        " Safety backup of current files complete"
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { color: "green", bold: true, children: "\u2713 Restore complete" }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        "  ",
+        "Restored: ",
+        result.restoredFiles.length,
+        " files"
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        "  ",
+        "Skipped: ",
+        result.skippedFiles.length,
+        " files"
+      ] }),
+      result.safetyBackupPath && /* @__PURE__ */ jsxs5(Text5, { children: [
+        "  ",
+        "Safety backup: ",
+        contractTilde(result.safetyBackupPath)
+      ] })
+    ] })
+  ] });
+};
+function registerRestoreCommand(program2) {
+  program2.command("restore [filename]").description("Restore config files from a backup").option("--dry-run", "Show planned changes without actual restore", false).action(async (filename, opts) => {
+    const { waitUntilExit } = render3(
+      /* @__PURE__ */ jsx5(
+        RestoreView,
+        {
+          filename,
+          options: { dryRun: opts.dryRun }
+        }
+      )
+    );
+    await waitUntilExit();
+  });
+}
+
+// src/commands/Provision.tsx
+import { useState as useState5, useEffect as useEffect4 } from "react";
+import { Text as Text7, Box as Box5, useApp as useApp4 } from "ink";
+import { render as render4 } from "ink";
+
+// src/core/provision.ts
+import { exec } from "child_process";
+import { readFile as readFile4, readdir as readdir3 } from "fs/promises";
+import { join as join10 } from "path";
+import YAML2 from "yaml";
+
+// src/schemas/template.schema.ts
+var templateSchema = {
+  type: "object",
+  required: ["name", "steps"],
+  properties: {
+    name: { type: "string", minLength: 1 },
+    description: { type: "string" },
+    backup: { type: "string" },
+    sudo: { type: "boolean" },
+    steps: {
+      type: "array",
+      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" }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  additionalProperties: false
+};
+var validate3 = ajv.compile(templateSchema);
+function validateTemplate(data) {
+  const valid = validate3(data);
+  if (valid) return { valid: true };
+  const errors = validate3.errors?.map(
+    (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
+  );
+  return { valid: false, errors };
+}
+
+// src/core/provision.ts
+var REMOTE_SCRIPT_PATTERNS = [
+  /curl\s.*\|\s*(ba)?sh/,
+  /wget\s.*\|\s*(ba)?sh/,
+  /curl\s.*\|\s*python/,
+  /wget\s.*\|\s*python/
+];
+function containsRemoteScriptPattern(command) {
+  return REMOTE_SCRIPT_PATTERNS.some((p) => p.test(command));
+}
+function sanitizeErrorOutput(output) {
+  return output.replace(/\/Users\/[^\s/]+/g, "/Users/***").replace(/\/home\/[^\s/]+/g, "/home/***").replace(/(password|token|key|secret)[=:]\s*\S+/gi, "$1=***").slice(0, 500);
+}
+async function loadTemplate(templatePath) {
+  const exists = await fileExists(templatePath);
+  if (!exists) {
+    throw new Error(`Template not found: ${templatePath}`);
+  }
+  const raw = await readFile4(templatePath, "utf-8");
+  const data = YAML2.parse(raw);
+  const result = validateTemplate(data);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid template ${templatePath}:
+${(result.errors ?? []).join("\n")}`
+    );
+  }
+  return data;
+}
+async function listTemplates() {
+  const templatesDir = getSubDir(TEMPLATES_DIR);
+  const exists = await fileExists(templatesDir);
+  if (!exists) return [];
+  const entries = await readdir3(templatesDir, { withFileTypes: true });
+  const templates = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".yml") && !entry.name.endsWith(".yaml")) {
+      continue;
+    }
+    const fullPath = join10(templatesDir, entry.name);
+    try {
+      const config = await loadTemplate(fullPath);
+      templates.push({
+        name: entry.name.replace(/\.ya?ml$/, ""),
+        path: fullPath,
+        config
+      });
+    } catch {
+      logger.warn(`Skipping invalid template: ${entry.name}`);
+    }
+  }
+  return templates;
+}
+function execAsync(command) {
+  return new Promise((resolve2, reject) => {
+    exec(
+      command,
+      { shell: "/bin/bash", timeout: 3e5 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(
+            Object.assign(error, {
+              stdout: stdout?.toString() ?? "",
+              stderr: stderr?.toString() ?? ""
+            })
+          );
+        } else {
+          resolve2({
+            stdout: stdout?.toString() ?? "",
+            stderr: stderr?.toString() ?? ""
+          });
+        }
+      }
+    );
+  });
+}
+async function evaluateSkipIf(command, stepName) {
+  if (containsRemoteScriptPattern(command)) {
+    throw new Error(`Blocked dangerous remote script pattern in skip_if: ${stepName}`);
+  }
+  try {
+    await execAsync(command);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function executeStep(step) {
+  const startTime = Date.now();
+  if (containsRemoteScriptPattern(step.command)) {
+    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);
+    if (shouldSkip) {
+      return {
+        name: step.name,
+        status: "skipped",
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  try {
+    const { stdout, stderr } = await execAsync(step.command);
+    const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+    return {
+      name: step.name,
+      status: "success",
+      duration: Date.now() - startTime,
+      output: output || void 0
+    };
+  } catch (err) {
+    const error = err;
+    const errorOutput = [error.stdout, error.stderr, error.message].filter(Boolean).join("\n").trim();
+    return {
+      name: step.name,
+      status: "failed",
+      duration: Date.now() - startTime,
+      error: sanitizeErrorOutput(errorOutput)
+    };
+  }
+}
+async function* runProvision(templatePath, options = {}) {
+  const template = await loadTemplate(templatePath);
+  for (const step of template.steps) {
+    if (options.dryRun) {
+      let status = "pending";
+      if (step.skip_if) {
+        const shouldSkip = await evaluateSkipIf(step.skip_if, step.name);
+        if (shouldSkip) status = "skipped";
+      }
+      yield {
+        name: step.name,
+        status
+      };
+      continue;
+    }
+    yield {
+      name: step.name,
+      status: "running"
+    };
+    const result = await executeStep(step);
+    yield result;
+    if (result.status === "failed" && !step.continue_on_error) {
+      logger.error(
+        `Step "${step.name}" failed. Stopping provisioning.`
+      );
+      return;
+    }
+  }
+}
+
+// src/utils/sudo.ts
+import { execSync } from "child_process";
+import pc2 from "picocolors";
+function isSudoCached() {
+  try {
+    execSync("sudo -n true", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureSudo(templateName) {
+  if (isSudoCached()) return;
+  console.log(
+    `
+${pc2.yellow("\u26A0")} Template ${pc2.bold(templateName)} requires ${pc2.bold("sudo")} privileges.`
+  );
+  console.log(
+    pc2.gray("  Some provisioning steps need elevated permissions to execute.")
+  );
+  console.log(pc2.gray("  You will be prompted for your password.\n"));
+  try {
+    execSync("sudo -v", { stdio: "inherit", timeout: 6e4 });
+  } catch {
+    console.error(
+      `
+${pc2.red("\u2717")} Sudo authentication failed or was cancelled. Aborting.`
+    );
+    process.exit(1);
+  }
+}
+
+// src/components/StepRunner.tsx
+import { Text as Text6, Box as Box4 } from "ink";
+import Spinner from "ink-spinner";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var StepIcon = ({ status }) => {
+  switch (status) {
+    case "success":
+      return /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713" });
+    case "running":
+      return /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: /* @__PURE__ */ jsx6(Spinner, { type: "dots" }) });
+    case "skipped":
+      return /* @__PURE__ */ jsx6(Text6, { color: "blue", children: "\u23ED" });
+    case "failed":
+      return /* @__PURE__ */ jsx6(Text6, { color: "red", children: "\u2717" });
+    case "pending":
+    default:
+      return /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "\u25CB" });
+  }
+};
+var StepStatusText = ({ step }) => {
+  switch (step.status) {
+    case "success":
+      return /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
+        "Done",
+        step.duration != null ? ` (${Math.round(step.duration / 1e3)}s)` : ""
+      ] });
+    case "running":
+      return /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "Running..." });
+    case "skipped":
+      return /* @__PURE__ */ jsx6(Text6, { color: "blue", children: "Skipped (already installed)" });
+    case "failed":
+      return /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
+        "Failed",
+        step.error ? `: ${step.error}` : ""
+      ] });
+    case "pending":
+    default:
+      return null;
+  }
+};
+var StepRunner = ({
+  steps,
+  total
+}) => {
+  return /* @__PURE__ */ jsx6(Box4, { flexDirection: "column", children: steps.map((step, idx) => /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", marginBottom: idx < steps.length - 1 ? 1 : 0, children: [
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      "  ",
+      /* @__PURE__ */ jsx6(StepIcon, { status: step.status }),
+      /* @__PURE__ */ jsxs6(Text6, { children: [
+        " ",
+        /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
+          "Step ",
+          idx + 1,
+          "/",
+          total
+        ] }),
+        "  ",
+        step.name
+      ] })
+    ] }),
+    step.output && step.status !== "pending" && /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+      "            ",
+      step.output
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      "            ",
+      /* @__PURE__ */ jsx6(StepStatusText, { step })
+    ] })
+  ] }, idx)) });
+};
+
+// src/commands/Provision.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var ProvisionView = ({
+  template,
+  templatePath,
+  options
+}) => {
+  const { exit } = useApp4();
+  const [phase, setPhase] = useState5(options.dryRun ? "done" : "running");
+  const [steps, setSteps] = useState5(
+    template.steps.map((s) => ({
+      name: s.name,
+      status: "pending",
+      output: s.description
+    }))
+  );
+  const [currentStep, setCurrentStep] = useState5(0);
+  const [error, setError] = useState5(null);
+  useEffect4(() => {
+    if (options.dryRun) {
+      setTimeout(() => exit(), 100);
+      return;
+    }
+    (async () => {
+      try {
+        const generator = runProvision(templatePath, options);
+        let stepIdx = 0;
+        for await (const result of generator) {
+          setCurrentStep(stepIdx);
+          setSteps((prev) => {
+            const updated = [...prev];
+            updated[stepIdx] = result;
+            return updated;
+          });
+          if (result.status === "success" || result.status === "skipped" || result.status === "failed") {
+            stepIdx++;
+          }
+        }
+        setPhase("done");
+        setTimeout(() => exit(), 100);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        exit();
+      }
+    })();
+  }, []);
+  if (phase === "error" || error) {
+    return /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  const successCount = steps.filter((s) => s.status === "success").length;
+  const skippedCount = steps.filter((s) => s.status === "skipped").length;
+  const failedCount = steps.filter((s) => s.status === "failed").length;
+  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+        "\u25B8 ",
+        template.name
+      ] }),
+      template.description && /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+        "  ",
+        template.description
+      ] })
+    ] }),
+    options.dryRun && phase === "done" && /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: "(dry-run) Showing execution plan only" }),
+      template.sudo && /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
+        "  ",
+        "\u26A0 This template requires sudo privileges (will prompt on actual run)"
+      ] }),
+      /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", marginTop: 1, children: template.steps.map((step, idx) => /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs7(Text7, { children: [
+          "  ",
+          /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+            "Step ",
+            idx + 1,
+            "/",
+            template.steps.length
+          ] }),
+          "  ",
+          step.name
+        ] }),
+        step.description && /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+          "            ",
+          step.description
+        ] }),
+        step.skip_if && /* @__PURE__ */ jsxs7(Text7, { color: "blue", children: [
+          "            ",
+          "Skip condition: ",
+          step.skip_if
+        ] })
+      ] }, idx)) })
+    ] }),
+    (phase === "running" || phase === "done" && !options.dryRun) && /* @__PURE__ */ jsx7(
+      StepRunner,
+      {
+        steps,
+        currentStep,
+        total: template.steps.length
+      }
+    ),
+    phase === "done" && !options.dryRun && /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+        "  ",
+        "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+      ] }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        "  ",
+        "Result: ",
+        /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+          successCount,
+          " succeeded"
+        ] }),
+        " \xB7",
+        " ",
+        /* @__PURE__ */ jsxs7(Text7, { color: "blue", children: [
+          skippedCount,
+          " skipped"
+        ] }),
+        " \xB7",
+        " ",
+        /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+          failedCount,
+          " failed"
+        ] })
+      ] }),
+      template.backup && !options.skipRestore && /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "\u25B8 Proceeding with config file restore..." }),
+        /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+          "  ",
+          "Backup link: ",
+          template.backup
+        ] })
+      ] })
+    ] })
+  ] });
+};
+function registerProvisionCommand(program2) {
+  program2.command("provision <template>").description("Run template-based machine provisioning").option("--dry-run", "Show plan without execution", false).option("--skip-restore", "Skip automatic restore after template completion", false).action(
+    async (templateName, opts) => {
+      const templates = await listTemplates();
+      const match = templates.find(
+        (t) => t.name === templateName || t.name === `${templateName}.yml` || t.config.name === templateName
+      );
+      if (!match) {
+        console.error(`Template not found: ${templateName}`);
+        process.exit(1);
+      }
+      const tmpl = await loadTemplate(match.path);
+      if (tmpl.sudo && !opts.dryRun) {
+        ensureSudo(tmpl.name);
+      }
+      const { waitUntilExit } = render4(
+        /* @__PURE__ */ jsx7(
+          ProvisionView,
+          {
+            template: tmpl,
+            templatePath: match.path,
+            options: {
+              dryRun: opts.dryRun,
+              skipRestore: opts.skipRestore
+            }
+          }
+        )
+      );
+      await waitUntilExit();
+    }
+  );
+}
+
+// src/commands/List.tsx
+import { unlinkSync } from "fs";
+import { Box as Box7, Text as Text9, useApp as useApp5, useInput as useInput2 } from "ink";
+import { render as render5 } from "ink";
+import SelectInput2 from "ink-select-input";
+import { useEffect as useEffect5, useState as useState6 } from "react";
+
+// src/components/Table.tsx
+import { Text as Text8, Box as Box6 } from "ink";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var Table = ({
+  headers,
+  rows,
+  columnWidths
+}) => {
+  const widths = columnWidths ?? headers.map((header, colIdx) => {
+    const dataMax = rows.reduce(
+      (max, row) => Math.max(max, (row[colIdx] ?? "").length),
+      0
+    );
+    return Math.max(header.length, dataMax) + 2;
+  });
+  const padCell = (text, width) => {
+    return text.padEnd(width);
+  };
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("  ");
+  return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Text8, { children: headers.map((h, i) => /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+      padCell(h, widths[i]),
+      i < headers.length - 1 ? "  " : ""
+    ] }, i)) }),
+    /* @__PURE__ */ jsx8(Text8, { color: "gray", children: separator }),
+    rows.map((row, rowIdx) => /* @__PURE__ */ jsx8(Text8, { children: row.map((cell, colIdx) => /* @__PURE__ */ jsxs8(Text8, { children: [
+      padCell(cell, widths[colIdx]),
+      colIdx < row.length - 1 ? "  " : ""
+    ] }, colIdx)) }, rowIdx))
+  ] });
+};
+
+// src/commands/List.tsx
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var MenuItem = ({ isSelected = false, label }) => {
+  if (label === "Delete") {
+    return /* @__PURE__ */ jsx9(Text9, { bold: isSelected, color: "red", children: label });
+  }
+  const match = label.match(/^(.+?)\s+\((\d+)\)$/);
+  if (match) {
+    const [, name, count] = match;
+    return /* @__PURE__ */ jsxs9(Text9, { children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: isSelected, children: name }),
+      " ",
+      /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "(",
+        count,
+        ")"
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsx9(Text9, { bold: isSelected, children: label });
+};
+var ListView = ({ type, deleteIndex }) => {
+  const { exit } = useApp5();
+  const [phase, setPhase] = useState6("loading");
+  const [backups, setBackups] = useState6([]);
+  const [templates, setTemplates] = useState6([]);
+  const [selectedTemplate, setSelectedTemplate] = useState6(
+    null
+  );
+  const [selectedBackup, setSelectedBackup] = useState6(null);
+  const [deleteTarget, setDeleteTarget] = useState6(null);
+  const [error, setError] = useState6(null);
+  useInput2((_input, key) => {
+    if (!key.escape) return;
+    switch (phase) {
+      case "main-menu":
+        exit();
+        break;
+      case "backup-list":
+      case "template-list":
+        setSelectedBackup(null);
+        setSelectedTemplate(null);
+        setPhase("main-menu");
+        break;
+      case "backup-detail":
+        setSelectedBackup(null);
+        setPhase("backup-list");
+        break;
+      case "template-detail":
+        setSelectedTemplate(null);
+        setPhase("template-list");
+        break;
+    }
+  });
+  useEffect5(() => {
+    (async () => {
+      try {
+        const showBackups = !type || type === "backups";
+        const showTemplates = !type || type === "templates";
+        if (showBackups) {
+          const list2 = await getBackupList();
+          setBackups(list2);
+        }
+        if (showTemplates) {
+          const tmpls = await listTemplates();
+          setTemplates(tmpls);
+        }
+        if (deleteIndex != null && type === "backups") {
+          const list2 = await getBackupList();
+          const idx = deleteIndex - 1;
+          if (idx < 0 || idx >= list2.length) {
+            setError(`Invalid index: ${deleteIndex}`);
+            setPhase("error");
+            setTimeout(() => exit(), 100);
+            return;
+          }
+          setDeleteTarget({
+            name: list2[idx].filename,
+            path: list2[idx].path
+          });
+          setPhase("deleting");
+          return;
+        }
+        setPhase("main-menu");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        setTimeout(() => exit(), 100);
+      }
+    })();
+  }, []);
+  const goBackToMainMenu = () => {
+    setSelectedBackup(null);
+    setSelectedTemplate(null);
+    setPhase("main-menu");
+  };
+  const goBackToBackupList = () => {
+    setSelectedBackup(null);
+    setPhase("backup-list");
+  };
+  const goBackToTemplateList = () => {
+    setSelectedTemplate(null);
+    setPhase("template-list");
+  };
+  const handleDeleteConfirm = (yes) => {
+    if (yes && deleteTarget) {
+      try {
+        if (!isInsideDir(deleteTarget.path, getSubDir("backups"))) {
+          throw new Error(`Refusing to delete file outside backups directory: ${deleteTarget.path}`);
+        }
+        unlinkSync(deleteTarget.path);
+        setPhase("done");
+        setTimeout(() => exit(), 100);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        setTimeout(() => exit(), 100);
+      }
+    } else {
+      setDeleteTarget(null);
+      if (selectedBackup) {
+        setPhase("backup-detail");
+      } else {
+        goBackToMainMenu();
+      }
+    }
+  };
+  if (phase === "error" || error) {
+    return /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsxs9(Text9, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  if (phase === "loading") {
+    return /* @__PURE__ */ jsx9(Text9, { color: "cyan", children: "Loading..." });
+  }
+  if (phase === "deleting" && deleteTarget) {
+    return /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsx9(
+      Confirm,
+      {
+        message: `Delete ${deleteTarget.name}?`,
+        onConfirm: handleDeleteConfirm,
+        defaultYes: false
+      }
+    ) });
+  }
+  if (phase === "done" && deleteTarget) {
+    return /* @__PURE__ */ jsxs9(Text9, { color: "green", children: [
+      "\u2713 ",
+      deleteTarget.name,
+      " deleted"
+    ] });
+  }
+  if (phase === "main-menu") {
+    const showBackups = !type || type === "backups";
+    const showTemplates = !type || type === "templates";
+    const menuItems = [];
+    if (showBackups) {
+      menuItems.push({
+        label: `Backups (${backups.length})`,
+        value: "backups"
+      });
+    }
+    if (showTemplates) {
+      menuItems.push({
+        label: `Templates (${templates.length})`,
+        value: "templates"
+      });
+    }
+    menuItems.push({ label: "Exit", value: "exit" });
+    const handleMainMenu = (item) => {
+      if (item.value === "exit") {
+        exit();
+      } else if (item.value === "backups") {
+        setPhase("backup-list");
+      } else if (item.value === "templates") {
+        setPhase("template-list");
+      }
+    };
+    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(
+        SelectInput2,
+        {
+          items: menuItems,
+          onSelect: handleMainMenu,
+          itemComponent: MenuItem
+        }
+      ),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
+        " to exit"
+      ] }) })
+    ] });
+  }
+  if (phase === "backup-list") {
+    const items = backups.map((b) => ({
+      label: `${b.filename.replace(".tar.gz", "")}  \u2022  ${formatBytes(b.size)}  \u2022  ${formatDate(b.createdAt)}`,
+      value: b.path
+    }));
+    const handleBackupSelect = (item) => {
+      const backup = backups.find((b) => b.path === item.value);
+      if (backup) {
+        setSelectedBackup(backup);
+        setPhase("backup-detail");
+      }
+    };
+    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: true, children: "\u25B8 Backups" }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: backups.length === 0 ? /* @__PURE__ */ jsx9(Text9, { color: "gray", children: " No backups found." }) : /* @__PURE__ */ jsx9(
+        SelectInput2,
+        {
+          items,
+          onSelect: handleBackupSelect,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
+  }
+  if (phase === "template-list") {
+    const items = templates.map((t) => ({
+      label: t.config.description ? `${t.config.name}  \u2014  ${t.config.description}` : t.config.name,
+      value: t.path
+    }));
+    const handleTemplateSelect = (item) => {
+      const tmpl = templates.find((t) => t.path === item.value);
+      if (tmpl) {
+        setSelectedTemplate(tmpl);
+        setPhase("template-detail");
+      }
+    };
+    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: true, children: "\u25B8 Templates" }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: templates.length === 0 ? /* @__PURE__ */ jsx9(Text9, { color: "gray", children: " No templates found." }) : /* @__PURE__ */ jsx9(
+        SelectInput2,
+        {
+          items,
+          onSelect: handleTemplateSelect,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
+  }
+  if (phase === "backup-detail" && selectedBackup) {
+    const sections = [
+      { label: "Filename", value: selectedBackup.filename },
+      { label: "Date", value: formatDate(selectedBackup.createdAt) },
+      { label: "Size", value: formatBytes(selectedBackup.size) },
+      ...selectedBackup.hostname ? [{ label: "Hostname", value: selectedBackup.hostname }] : [],
+      ...selectedBackup.fileCount != null ? [{ label: "Files", value: String(selectedBackup.fileCount) }] : []
+    ];
+    const actionItems = [
+      { label: "Delete", value: "delete" },
+      { label: "Cancel", value: "cancel" }
+    ];
+    const handleDetailAction = (item) => {
+      if (item.value === "delete") {
+        setDeleteTarget({
+          name: selectedBackup.filename,
+          path: selectedBackup.path
+        });
+        setPhase("deleting");
+      } else if (item.value === "cancel") {
+        goBackToBackupList();
+      }
+    };
+    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs9(Text9, { bold: true, children: [
+        "\u25B8 ",
+        selectedBackup.filename.replace(".tar.gz", "")
+      ] }),
+      /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: sections.map((section, idx) => {
+        const labelWidth = Math.max(...sections.map((s) => s.label.length)) + 1;
+        return /* @__PURE__ */ jsxs9(Box7, { children: [
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: section.label.padEnd(labelWidth) }),
+          /* @__PURE__ */ jsx9(Text9, { children: " " }),
+          /* @__PURE__ */ jsx9(Text9, { children: section.value })
+        ] }, idx);
+      }) }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx9(
+        SelectInput2,
+        {
+          items: actionItems,
+          onSelect: handleDetailAction,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
+  }
+  if (phase === "template-detail" && selectedTemplate) {
+    const t = selectedTemplate.config;
+    const sections = [
+      { label: "Name", value: t.name },
+      ...t.description ? [{ label: "Description", value: t.description }] : [],
+      ...t.backup ? [{ label: "Backup link", value: t.backup }] : [],
+      { label: "Steps", value: String(t.steps.length) }
+    ];
+    const actionItems = [{ label: "Cancel", value: "cancel" }];
+    const handleDetailAction = (item) => {
+      if (item.value === "cancel") {
+        goBackToTemplateList();
+      }
+    };
+    const labelWidth = Math.max(...sections.map((s) => s.label.length)) + 1;
+    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs9(Text9, { bold: true, children: [
+        "\u25B8 ",
+        selectedTemplate.name
+      ] }),
+      /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: sections.map((section, idx) => /* @__PURE__ */ jsxs9(Box7, { children: [
+        /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: section.label.padEnd(labelWidth) }),
+        /* @__PURE__ */ jsx9(Text9, { children: " " }),
+        /* @__PURE__ */ jsx9(Text9, { children: section.value })
+      ] }, idx)) }),
+      t.steps.length > 0 && /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: " Provisioning Steps" }),
+        /* @__PURE__ */ jsx9(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx9(
+          Table,
+          {
+            headers: ["#", "Step", "Description"],
+            rows: t.steps.map((s, idx) => [
+              String(idx + 1),
+              s.name,
+              s.description ?? "\u2014"
+            ])
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx9(
+        SelectInput2,
+        {
+          items: actionItems,
+          onSelect: handleDetailAction,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
+  }
+  return null;
+};
+function registerListCommand(program2) {
+  program2.command("list [type]").description("List backups and templates").option("--delete <n>", "Delete item #n").action(async (type, opts) => {
+    const deleteIndex = opts.delete ? parseInt(opts.delete, 10) : void 0;
+    const { waitUntilExit } = render5(
+      /* @__PURE__ */ jsx9(ListView, { type, deleteIndex })
+    );
+    await waitUntilExit();
+  });
+}
+
+// src/commands/Status.tsx
+import { readdirSync, statSync, unlinkSync as unlinkSync2 } from "fs";
+import { join as join11 } from "path";
+import { Box as Box8, Text as Text10, useApp as useApp6, useInput as useInput3 } from "ink";
+import { render as render6 } from "ink";
+import SelectInput3 from "ink-select-input";
+import { useEffect as useEffect6, useState as useState7 } from "react";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function getDirStats(dirPath) {
+  try {
+    const entries = readdirSync(dirPath);
+    let totalSize = 0;
+    let count = 0;
+    for (const entry of entries) {
+      try {
+        const stat3 = statSync(join11(dirPath, entry));
+        if (stat3.isFile()) {
+          totalSize += stat3.size;
+          count++;
+        }
+      } catch {
+      }
+    }
+    return { count, totalSize };
+  } catch {
+    return { count: 0, totalSize: 0 };
+  }
+}
+var DisplayActionItem = ({ isSelected = false, label }) => {
+  return /* @__PURE__ */ jsx10(Text10, { bold: isSelected, children: label });
+};
+var CleanupActionItem = ({ isSelected = false, label }) => {
+  if (label === "Cancel" || label === "Select specific backups to delete") {
+    return /* @__PURE__ */ jsx10(Text10, { bold: isSelected, children: label });
+  }
+  const parts = label.split(/\s{2,}/);
+  if (parts.length === 2) {
+    return /* @__PURE__ */ jsxs10(Text10, { bold: isSelected, children: [
+      parts[0],
+      "  ",
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: parts[1] })
+    ] });
+  }
+  return /* @__PURE__ */ jsx10(Text10, { bold: isSelected, children: label });
+};
+var StatusView = ({ cleanup }) => {
+  const { exit } = useApp6();
+  const [phase, setPhase] = useState7("loading");
+  const [status, setStatus] = useState7(null);
+  const [backups, setBackups] = useState7([]);
+  const [cleanupAction, setCleanupAction] = useState7(null);
+  const [cleanupMessage, setCleanupMessage] = useState7("");
+  const [error, setError] = useState7(null);
+  const [selectedForDeletion, setSelectedForDeletion] = useState7(
+    []
+  );
+  useInput3((_input, key) => {
+    if (!key.escape) return;
+    if (phase === "display") {
+      exit();
+    } else if (phase === "cleanup") {
+      setPhase("display");
+    } else if (phase === "select-delete") {
+      setSelectedForDeletion([]);
+      setPhase("cleanup");
+    }
+  });
+  useEffect6(() => {
+    (async () => {
+      try {
+        const backupStats = getDirStats(getSubDir("backups"));
+        const templateStats = getDirStats(getSubDir("templates"));
+        const scriptStats = getDirStats(getSubDir("scripts"));
+        const logStats = getDirStats(getSubDir("logs"));
+        const backupList = await getBackupList();
+        setBackups(backupList);
+        const lastBackup = backupList.length > 0 ? backupList[0].createdAt : void 0;
+        const oldestBackup = backupList.length > 0 ? backupList[backupList.length - 1].createdAt : void 0;
+        setStatus({
+          backups: backupStats,
+          templates: templateStats,
+          scripts: scriptStats,
+          logs: logStats,
+          lastBackup,
+          oldestBackup
+        });
+        setPhase(cleanup ? "cleanup" : "display");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        setTimeout(() => exit(), 100);
+      }
+    })();
+  }, []);
+  const handleDisplayAction = (item) => {
+    if (item.value === "cleanup") {
+      setPhase("cleanup");
+    } else if (item.value === "exit") {
+      exit();
+    }
+  };
+  const handleCleanupSelect = (item) => {
+    const action = item.value;
+    if (action === "cancel") {
+      setPhase("display");
+      return;
+    }
+    if (action === "select-specific") {
+      setSelectedForDeletion([]);
+      setPhase("select-delete");
+      return;
+    }
+    setCleanupAction(action);
+    if (action === "keep-recent-5") {
+      const toDelete = backups.slice(5);
+      setCleanupMessage(
+        `Keep only the 5 most recent backups. ${toDelete.length} to delete, ${formatBytes(toDelete.reduce((s, b) => s + b.size, 0))} freed`
+      );
+    } else if (action === "older-than-30") {
+      const cutoff = /* @__PURE__ */ new Date();
+      cutoff.setDate(cutoff.getDate() - 30);
+      const toDelete = backups.filter((b) => b.createdAt < cutoff);
+      setCleanupMessage(
+        `Remove backups older than 30 days. ${toDelete.length} to delete, ${formatBytes(toDelete.reduce((s, b) => s + b.size, 0))} freed`
+      );
+    } else if (action === "delete-logs") {
+      setCleanupMessage(
+        `Delete all logs. ${formatBytes(status?.logs.totalSize ?? 0)} freed`
+      );
+    }
+    setPhase("confirming");
+  };
+  const handleConfirm = (yes) => {
+    if (!yes) {
+      setPhase("cleanup");
+      return;
+    }
+    try {
+      const backupsDir = getSubDir("backups");
+      if (cleanupAction === "keep-recent-5") {
+        const toDelete = backups.slice(5);
+        for (const b of toDelete) {
+          if (!isInsideDir(b.path, backupsDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
+          unlinkSync2(b.path);
+        }
+      } else if (cleanupAction === "older-than-30") {
+        const cutoff = /* @__PURE__ */ new Date();
+        cutoff.setDate(cutoff.getDate() - 30);
+        const toDelete = backups.filter((b) => b.createdAt < cutoff);
+        for (const b of toDelete) {
+          if (!isInsideDir(b.path, backupsDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
+          unlinkSync2(b.path);
+        }
+      } else if (cleanupAction === "delete-logs") {
+        const logsDir = getSubDir(LOGS_DIR);
+        try {
+          const entries = readdirSync(logsDir);
+          for (const entry of entries) {
+            const logPath = join11(logsDir, entry);
+            if (!isInsideDir(logPath, logsDir)) throw new Error(`Refusing to delete file outside logs directory: ${logPath}`);
+            unlinkSync2(logPath);
+          }
+        } catch {
+        }
+      } else if (cleanupAction === "select-specific") {
+        for (const b of selectedForDeletion) {
+          if (!isInsideDir(b.path, backupsDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
+          unlinkSync2(b.path);
+        }
+      }
+      setPhase("done");
+      setTimeout(() => exit(), 100);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setPhase("error");
+      setTimeout(() => exit(), 100);
+    }
+  };
+  const handleSelectBackup = (item) => {
+    if (item.value === "done") {
+      if (selectedForDeletion.length === 0) {
+        setPhase("cleanup");
+        return;
+      }
+      setCleanupAction("select-specific");
+      setCleanupMessage(
+        `Delete ${selectedForDeletion.length} selected backup(s). ${formatBytes(selectedForDeletion.reduce((s, b) => s + b.size, 0))} freed`
+      );
+      setPhase("confirming");
+      return;
+    }
+    const backup = backups.find((b) => b.path === item.value);
+    if (backup) {
+      setSelectedForDeletion((prev) => [...prev, backup]);
+    }
+  };
+  if (phase === "error" || error) {
+    return /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsxs10(Text10, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  if (phase === "loading") {
+    return /* @__PURE__ */ jsx10(Text10, { color: "cyan", children: "Loading..." });
+  }
+  if (!status) return null;
+  const totalCount = status.backups.count + status.templates.count + status.scripts.count + status.logs.count;
+  const totalSize = status.backups.totalSize + status.templates.totalSize + status.scripts.totalSize + status.logs.totalSize;
+  const statusDisplay = /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs10(Text10, { bold: true, children: [
+      "\u25B8 ",
+      APP_NAME,
+      " status \u2014 ~/.",
+      APP_NAME,
+      "/"
+    ] }),
+    /* @__PURE__ */ jsx10(Box8, { marginLeft: 2, marginTop: 1, children: /* @__PURE__ */ jsx10(
+      Table,
+      {
+        headers: ["Directory", "Count", "Size"],
+        rows: [
+          [
+            "backups/",
+            `${status.backups.count}`,
+            formatBytes(status.backups.totalSize)
+          ],
+          [
+            "templates/",
+            `${status.templates.count}`,
+            formatBytes(status.templates.totalSize)
+          ],
+          [
+            "scripts/",
+            `${status.scripts.count}`,
+            formatBytes(status.scripts.totalSize)
+          ],
+          [
+            "logs/",
+            `${status.logs.count}`,
+            formatBytes(status.logs.totalSize)
+          ],
+          ["Total", `${totalCount}`, formatBytes(totalSize)]
+        ]
+      }
+    ) }),
+    status.lastBackup && /* @__PURE__ */ jsxs10(Box8, { marginTop: 1, marginLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs10(Text10, { children: [
+        "Latest backup: ",
+        formatDate(status.lastBackup),
+        " (",
+        formatRelativeTime(status.lastBackup),
+        ")"
+      ] }),
+      status.oldestBackup && /* @__PURE__ */ jsxs10(Text10, { children: [
+        "Oldest backup: ",
+        formatDate(status.oldestBackup),
+        " (",
+        formatRelativeTime(status.oldestBackup),
+        ")"
+      ] })
+    ] })
+  ] });
+  const escHint = (action) => /* @__PURE__ */ jsx10(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+    "Press ",
+    /* @__PURE__ */ jsx10(Text10, { bold: true, children: "ESC" }),
+    " to ",
+    action
+  ] }) });
+  if (phase === "display") {
+    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+      statusDisplay,
+      /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx10(Text10, { bold: true, children: "\u25B8 Actions" }),
+        /* @__PURE__ */ jsx10(
+          SelectInput3,
+          {
+            items: [
+              { label: "Cleanup", value: "cleanup" },
+              { label: "Exit", value: "exit" }
+            ],
+            onSelect: handleDisplayAction,
+            itemComponent: DisplayActionItem
+          }
+        )
+      ] }),
+      escHint("exit")
+    ] });
+  }
+  if (phase === "cleanup") {
+    const keepRecent5 = backups.slice(5);
+    const cutoff30 = /* @__PURE__ */ new Date();
+    cutoff30.setDate(cutoff30.getDate() - 30);
+    const olderThan30 = backups.filter((b) => b.createdAt < cutoff30);
+    const labels = [
+      "Keep only 5 recent backups",
+      "Remove backups older than 30d",
+      "Delete all logs"
+    ];
+    const maxWidth = Math.max(...labels.map((l) => l.length));
+    const cleanupItems = [
+      {
+        label: `${"Keep only 5 recent backups".padEnd(maxWidth)}  ${keepRecent5.length} to delete, ${formatBytes(keepRecent5.reduce((s, b) => s + b.size, 0))} freed`,
+        value: "keep-recent-5"
+      },
+      {
+        label: `${"Remove backups older than 30d".padEnd(maxWidth)}  ${olderThan30.length} to delete, ${formatBytes(olderThan30.reduce((s, b) => s + b.size, 0))} freed`,
+        value: "older-than-30"
+      },
+      {
+        label: "Select specific backups to delete",
+        value: "select-specific"
+      },
+      {
+        label: `${"Delete all logs".padEnd(maxWidth)}  ${formatBytes(status.logs.totalSize)} freed`,
+        value: "delete-logs"
+      },
+      {
+        label: "Cancel",
+        value: "cancel"
+      }
+    ];
+    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+      statusDisplay,
+      /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx10(Text10, { bold: true, children: "\u25B8 Cleanup options" }),
+        /* @__PURE__ */ jsx10(
+          SelectInput3,
+          {
+            items: cleanupItems,
+            onSelect: handleCleanupSelect,
+            itemComponent: CleanupActionItem
+          }
+        )
+      ] }),
+      escHint("go back")
+    ] });
+  }
+  if (phase === "select-delete") {
+    const remaining = backups.filter(
+      (b) => !selectedForDeletion.some((s) => s.path === b.path)
+    );
+    const selectItems = [
+      ...remaining.map((b) => ({
+        label: `${b.filename.replace(".tar.gz", "")}  ${formatBytes(b.size)}  ${formatDate(b.createdAt)}`,
+        value: b.path
+      })),
+      {
+        label: `Done (${selectedForDeletion.length} selected)`,
+        value: "done"
+      }
+    ];
+    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+      statusDisplay,
+      /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx10(Text10, { bold: true, children: "\u25B8 Select backups to delete" }),
+        selectedForDeletion.length > 0 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+          "  ",
+          selectedForDeletion.length,
+          " backup(s) selected (",
+          formatBytes(selectedForDeletion.reduce((s, b) => s + b.size, 0)),
+          ")"
+        ] }),
+        /* @__PURE__ */ jsx10(SelectInput3, { items: selectItems, onSelect: handleSelectBackup })
+      ] }),
+      escHint("go back")
+    ] });
+  }
+  if (phase === "confirming") {
+    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text10, { children: cleanupMessage }),
+      /* @__PURE__ */ jsx10(
+        Confirm,
+        {
+          message: "Proceed?",
+          onConfirm: handleConfirm,
+          defaultYes: false
+        }
+      )
+    ] });
+  }
+  if (phase === "done") {
+    return /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsx10(Text10, { color: "green", children: "\u2713 Cleanup complete" }) });
+  }
+  return null;
+};
+function registerStatusCommand(program2) {
+  program2.command("status").description(`Show ~/.${APP_NAME}/ status summary`).option("--cleanup", "Interactive cleanup mode", false).action(async (opts) => {
+    const { waitUntilExit } = render6(/* @__PURE__ */ jsx10(StatusView, { cleanup: opts.cleanup }));
+    await waitUntilExit();
+  });
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("syncpoint").description(
+  "Personal Environment Manager \u2014 Config backup/restore and machine provisioning CLI"
+).version(APP_VERSION);
+registerInitCommand(program);
+registerBackupCommand(program);
+registerRestoreCommand(program);
+registerProvisionCommand(program);
+registerListCommand(program);
+registerStatusCommand(program);
+program.parseAsync(process.argv).catch((error) => {
+  console.error("Fatal error:", error.message);
+  process.exit(1);
+});