packbat 0.1.0

package/dist/init-wizard-PEBPT3M3.js

@@ -0,0 +1,680 @@
+import {
+  PackbatError,
+  commandOnPath,
+  createArchiveRemote,
+  createInitScheduleOptions,
+  decryptWithIdentity,
+  detectInitStores,
+  discoverRclone,
+  generateIdentity,
+  identityToRecipient,
+  installInitSchedule,
+  loadConfig,
+  previewSchedule,
+  resolveHome,
+  runDoctor,
+  runSync,
+  skippedOffboxConfig,
+  userHome,
+  writeInitConfig
+} from "./chunk-O43RENSG.js";
+
+// src/commands/init-wizard.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { isAbsolute, join as join3 } from "path";
+import { cancel, confirm, intro, isCancel, log, note, outro, password, select, spinner, text } from "@clack/prompts";
+
+// src/core/private-file.ts
+import { randomUUID } from "crypto";
+import { chmod, link, mkdir, rename, rm, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+async function writePrivateFile(path, contents, options = { overwrite: true }) {
+  const directory = dirname(path);
+  const temporary = join(directory, `.packbat-private.tmp-${process.pid}-${randomUUID()}`);
+  await mkdir(directory, { recursive: true });
+  try {
+    await writeFile(temporary, contents, { mode: 384 });
+    await chmod(temporary, 384);
+    if (options.overwrite) {
+      await rename(temporary, path);
+    } else {
+      await link(temporary, path);
+      await rm(temporary);
+    }
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
+  }
+}
+
+// src/offbox/rclone-conf.ts
+function renderRemote(lines) {
+  return `${lines.join("\n")}
+`;
+}
+function managedRcloneRemoteName(index) {
+  if (!Number.isInteger(index) || index < 0) {
+    throw new Error("managed remote index must be a non-negative integer");
+  }
+  return index === 0 ? "packbat" : `packbat-${index + 1}`;
+}
+function renderS3Remote(input, remoteName = managedRcloneRemoteName(0)) {
+  return renderRemote([
+    `[${remoteName}]`,
+    "type = s3",
+    "provider = Other",
+    `access_key_id = ${input.accessKeyId}`,
+    `secret_access_key = ${input.secretAccessKey}`,
+    `endpoint = ${input.endpoint}`,
+    ...input.region === void 0 ? [] : [`region = ${input.region}`]
+  ]);
+}
+function renderSftpRemote(input, remoteName = managedRcloneRemoteName(0)) {
+  return renderRemote([
+    `[${remoteName}]`,
+    "type = sftp",
+    `host = ${input.host}`,
+    `user = ${input.user}`,
+    ...input.port === void 0 ? [] : [`port = ${input.port}`],
+    ...input.keyFile === void 0 ? [] : [`key_file = ${input.keyFile}`]
+  ]);
+}
+async function writeManagedRcloneConfig(path, contents) {
+  await writePrivateFile(path, contents);
+}
+
+// src/offbox/rclone-install.ts
+var MANUAL_INSTALL = {
+  linux: "sudo apt install rclone",
+  other: "https://rclone.org/install/"
+};
+function pickRcloneInstall(platform, hasCommand) {
+  if (hasCommand("brew")) {
+    return { kind: "brew", command: ["brew", "install", "rclone"] };
+  }
+  return {
+    kind: "manual",
+    command: platform === "linux" ? MANUAL_INSTALL.linux : MANUAL_INSTALL.other
+  };
+}
+
+// package.json
+var package_default = {
+  name: "packbat",
+  version: "0.1.0",
+  description: "Every agent session, kept. Preserves AI-agent sessions as raw, append-only archives in a store you own.",
+  license: "MIT",
+  author: "Liam Vinberg",
+  homepage: "https://packbat.dev",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/liamvinberg/packbat.git"
+  },
+  bugs: {
+    url: "https://github.com/liamvinberg/packbat/issues"
+  },
+  keywords: [
+    "ai-agents",
+    "archive",
+    "backup",
+    "cli"
+  ],
+  type: "module",
+  engines: {
+    node: ">=22.16"
+  },
+  bin: {
+    packbat: "bin/packbat.js"
+  },
+  files: [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsx src/main.ts",
+    typecheck: "tsc",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: {
+    "@clack/prompts": "^1.7.0",
+    "age-encryption": "^0.3.0",
+    picocolors: "^1.1.1",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@types/node": "^26.1.1",
+    tsup: "^8.5.1",
+    tsx: "^4.23.0",
+    typescript: "^7.0.2",
+    vitest: "^4.1.10"
+  }
+};
+
+// src/offbox/recovery-kit.ts
+var RECOVERY_KIT_FORMAT = 2;
+function renderRemote2(remote) {
+  switch (remote.type) {
+    case "s3-compatible":
+      return [
+        "type: s3-compatible",
+        `endpoint: ${remote.endpoint}`,
+        `bucket: ${remote.bucket}`,
+        ...remote.prefix === void 0 ? [] : [`prefix: ${remote.prefix}`],
+        `destination: ${remote.destination}`
+      ].join("\n");
+    case "sftp":
+      return [
+        "type: sftp",
+        `host: ${remote.host}`,
+        ...remote.port === void 0 ? [] : [`port: ${remote.port}`],
+        `path: ${remote.path}`,
+        `destination: ${remote.destination}`
+      ].join("\n");
+    case "rclone":
+      return `type: rclone
+destination: ${remote.destination}`;
+  }
+}
+function renderRecoveryKit(input) {
+  const remoteSections = input.remotes.map((remote, index) => `${input.remotes.length === 1 ? "Remote" : `Remote ${index + 1}`}
+${renderRemote2(remote)}`).join("\n\n");
+  const firstRemote = input.remotes[0];
+  const additionalSetup = input.remotes.length === 1 ? "" : "\nAdd the other remote destinations to config.json.\n";
+  const restoreCommands = input.remotes.map(
+    (remote, index) => `packbat restore --from-remote --identity <kit-file>${index === 0 ? "" : ` --remote ${remote.destination}`} <unit> --machine <source-machine>`
+  ).join("\n");
+  return `Packbat recovery kit
+Packbat version: ${package_default.version}
+format: ${RECOVERY_KIT_FORMAT}
+created: ${input.createdAt}
+
+Age identity
+${input.identity}
+
+Age recipient
+${input.recipient}
+
+${remoteSections}
+
+Fresh-machine setup
+Configure rclone access to ${input.remotes.map((remote) => remote.destination).join(", ")}, then run:
+packbat init --yes --offbox remote --offbox-remote ${firstRemote.destination} --age-recipient ${input.recipient} --rclone-config default
+${additionalSetup}
+Fresh-machine restore
+${restoreCommands}
+
+Raw age fallback
+age -d -i <kit-file> -o <archive-file> <archive-file>.age
+
+If every copy of this identity is lost, nobody can recover this archive.
+`;
+}
+function recipientChallenge(recipient) {
+  return recipient.slice(-8);
+}
+async function writeRecoveryKit(path, contents) {
+  await writePrivateFile(path, contents, { overwrite: false });
+}
+
+// src/offbox/smoke.ts
+import { mkdtemp, readFile, rm as rm2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+async function smokeTestRemoteIndex(config, remoteConfig, identity) {
+  const remote = createArchiveRemote(remoteConfig);
+  if (!await remote.indexExists(config.machine)) {
+    throw new PackbatError("remote index does not exist");
+  }
+  const stagePath = await mkdtemp(join2(tmpdir(), "packbat-offbox-smoke-"));
+  try {
+    const encryptedIndexPath = join2(stagePath, "index.jsonl.age");
+    await remote.getIndex(config.machine, encryptedIndexPath);
+    const [localIndex, ciphertext] = await Promise.all([
+      readFile(join2(config.archiveRoot, config.machine, "index.jsonl")),
+      readFile(encryptedIndexPath)
+    ]);
+    const remoteIndexContents = await decryptWithIdentity(identity, ciphertext);
+    if (!remoteIndexContents.equals(localIndex)) {
+      throw new PackbatError("downloaded remote index does not match the local index");
+    }
+  } finally {
+    await rm2(stagePath, { recursive: true, force: true });
+  }
+}
+
+// src/commands/init-wizard.ts
+var WIZARD_CANCELLED = /* @__PURE__ */ Symbol("wizard-cancelled");
+var RCLONE_INSTALL_COPY = {
+  brewConfirm: "Install rclone with Homebrew? (runs: brew install rclone)",
+  manualNoteTitle: "Install rclone",
+  manualConfirm: "rclone is installed now",
+  skipped: "Off-box is skipped because rclone is not installed."
+};
+function cancelWizard() {
+  cancel("Setup cancelled.");
+  return WIZARD_CANCELLED;
+}
+function promptResult(value) {
+  return isCancel(value) ? cancelWizard() : value;
+}
+function required(value) {
+  return value?.trim() ? void 0 : "Enter a value.";
+}
+function singleLine(value) {
+  return value?.includes("\n") || value?.includes("\r") ? "Use one line." : void 0;
+}
+async function askRequiredText(message) {
+  const answer = promptResult(await text({ message, validate: required }));
+  return answer === WIZARD_CANCELLED ? answer : answer.trim();
+}
+async function askOptionalText(message) {
+  const answer = promptResult(await text({ message, defaultValue: "", validate: singleLine }));
+  return answer === WIZARD_CANCELLED ? answer : answer.trim();
+}
+async function askSecret(message) {
+  const answer = promptResult(await password({ message, validate: required }));
+  return answer === WIZARD_CANCELLED ? answer : answer.trim();
+}
+function s3Destination(bucket, prefix) {
+  const cleanBucket = bucket.replace(/^\/+|\/+$/gu, "");
+  const cleanPrefix = prefix.replace(/^\/+|\/+$/gu, "");
+  return `packbat:${cleanPrefix === "" ? cleanBucket : `${cleanBucket}/${cleanPrefix}`}`;
+}
+async function runStreaming(command) {
+  const executable = command[0];
+  if (executable === void 0) return;
+  await new Promise((resolve) => {
+    const child = spawn(executable, command.slice(1), { env: process.env, stdio: "inherit" });
+    child.on("error", () => resolve());
+    child.on("close", () => resolve());
+  });
+}
+async function ensureRclone() {
+  try {
+    await discoverRclone();
+    return true;
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.startsWith("rclone was not found")) {
+      throw error;
+    }
+  }
+  const hasBrew = commandOnPath("brew") !== null;
+  const install = pickRcloneInstall(process.platform, (command) => command === "brew" && hasBrew);
+  if (install.kind === "brew") {
+    const accepted = promptResult(await confirm({ message: RCLONE_INSTALL_COPY.brewConfirm, initialValue: true }));
+    if (accepted === WIZARD_CANCELLED) return accepted;
+    if (!accepted) {
+      log.info(RCLONE_INSTALL_COPY.skipped);
+      return false;
+    }
+    await runStreaming(install.command);
+  } else {
+    note(install.command, RCLONE_INSTALL_COPY.manualNoteTitle);
+    const ready = promptResult(await confirm({ message: RCLONE_INSTALL_COPY.manualConfirm, initialValue: true }));
+    if (ready === WIZARD_CANCELLED) return ready;
+    if (!ready) {
+      log.info(RCLONE_INSTALL_COPY.skipped);
+      return false;
+    }
+  }
+  try {
+    await discoverRclone();
+    return true;
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.startsWith("rclone was not found")) {
+      throw error;
+    }
+    log.info(RCLONE_INSTALL_COPY.skipped);
+    return false;
+  }
+}
+async function askS3Remote() {
+  const endpoint = await askRequiredText("S3 endpoint");
+  if (endpoint === WIZARD_CANCELLED) return endpoint;
+  const accessKeyId = await askRequiredText("Access key ID");
+  if (accessKeyId === WIZARD_CANCELLED) return accessKeyId;
+  const secretAccessKey = await askSecret("Secret access key");
+  if (secretAccessKey === WIZARD_CANCELLED) return secretAccessKey;
+  const region = await askOptionalText("Region (optional)");
+  if (region === WIZARD_CANCELLED) return region;
+  const bucket = await askRequiredText("Bucket");
+  if (bucket === WIZARD_CANCELLED) return bucket;
+  const prefix = await askOptionalText("Prefix (optional)");
+  if (prefix === WIZARD_CANCELLED) return prefix;
+  const destination = s3Destination(bucket, prefix);
+  return {
+    remote: { type: "rclone", destination, rcloneConfig: "managed" },
+    recovery: {
+      type: "s3-compatible",
+      destination,
+      endpoint,
+      bucket,
+      ...prefix === "" ? {} : { prefix }
+    },
+    managedConfig: renderS3Remote({
+      endpoint,
+      accessKeyId,
+      secretAccessKey,
+      ...region === "" ? {} : { region }
+    })
+  };
+}
+async function askSftpRemote() {
+  const host = await askRequiredText("SFTP host");
+  if (host === WIZARD_CANCELLED) return host;
+  const user = await askRequiredText("SFTP user");
+  if (user === WIZARD_CANCELLED) return user;
+  const portAnswer = promptResult(
+    await text({
+      message: "Port (optional)",
+      defaultValue: "",
+      validate(value) {
+        const answer = value?.trim() ?? "";
+        if (answer === "") return void 0;
+        if (!/^\d+$/u.test(answer)) return "Enter a port from 1 to 65535.";
+        const port2 = Number.parseInt(answer, 10);
+        return port2 >= 1 && port2 <= 65535 ? void 0 : "Enter a port from 1 to 65535.";
+      }
+    })
+  );
+  if (portAnswer === WIZARD_CANCELLED) return portAnswer;
+  const keyFile = await askOptionalText("SSH key file (optional)");
+  if (keyFile === WIZARD_CANCELLED) return keyFile;
+  const remotePath = await askRequiredText("Remote path");
+  if (remotePath === WIZARD_CANCELLED) return remotePath;
+  const port = portAnswer.trim() === "" ? void 0 : Number.parseInt(portAnswer.trim(), 10);
+  const destination = `packbat:${remotePath}`;
+  return {
+    remote: { type: "rclone", destination, rcloneConfig: "managed" },
+    recovery: {
+      type: "sftp",
+      destination,
+      host,
+      ...port === void 0 ? {} : { port },
+      path: remotePath
+    },
+    managedConfig: renderSftpRemote({
+      host,
+      user,
+      ...port === void 0 ? {} : { port },
+      ...keyFile === "" ? {} : { keyFile }
+    })
+  };
+}
+async function askCustomRemote() {
+  const destination = await askRequiredText("Rclone destination");
+  if (destination === WIZARD_CANCELLED) return destination;
+  const configMode = promptResult(
+    await select({
+      message: "Rclone config",
+      options: [
+        { value: "default", label: "Default rclone config" },
+        { value: "managed", label: "Managed by Packbat" }
+      ],
+      initialValue: "default"
+    })
+  );
+  if (configMode === WIZARD_CANCELLED) return configMode;
+  return {
+    remote: { type: "rclone", destination, rcloneConfig: configMode },
+    recovery: { type: "rclone", destination }
+  };
+}
+async function askRemote() {
+  const kind = promptResult(
+    await select({
+      message: "Remote kind",
+      options: [
+        { value: "s3", label: "S3-compatible" },
+        { value: "sftp", label: "SFTP" },
+        { value: "custom", label: "Any rclone destination" }
+      ],
+      initialValue: "s3"
+    })
+  );
+  if (kind === WIZARD_CANCELLED) return kind;
+  switch (kind) {
+    case "s3":
+      return await askS3Remote();
+    case "sftp":
+      return await askSftpRemote();
+    case "custom":
+      return await askCustomRemote();
+  }
+  throw new Error("Unknown remote kind");
+}
+async function saveRecoveryKit(kit, homePath) {
+  const destination = promptResult(
+    await select({
+      message: "Recovery kit destination",
+      options: [
+        { value: "save", label: "Save to a file" },
+        { value: "print", label: "Print to terminal" }
+      ],
+      initialValue: "save"
+    })
+  );
+  if (destination === WIZARD_CANCELLED) return destination;
+  if (destination === "print") {
+    note(kit, "Recovery kit");
+    return true;
+  }
+  const defaultPath = join3(homePath, "packbat-recovery-kit.txt");
+  const path = promptResult(
+    await text({
+      message: "Recovery kit path",
+      initialValue: defaultPath,
+      validate(value) {
+        const path2 = value?.trim();
+        if (!path2) return "Enter a path.";
+        return existsSync(path2) ? "Path already exists. Choose another path." : void 0;
+      }
+    })
+  );
+  if (path === WIZARD_CANCELLED) return path;
+  await writeRecoveryKit(path.trim(), kit);
+  log.success(`Saved recovery kit: ${path.trim()}`);
+  return true;
+}
+async function verifyCustody(challenge) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const answer = promptResult(
+      await text({
+        message: "Enter the last 8 recipient characters from the recovery kit",
+        validate: required
+      })
+    );
+    if (answer === WIZARD_CANCELLED) return answer;
+    if (answer.trim() === challenge) {
+      return true;
+    }
+    if (attempt === 0) {
+      log.warn("That did not match. One try left.");
+    }
+  }
+  return false;
+}
+async function configureOffbox(config, homePath) {
+  const home = resolveHome();
+  const choice = promptResult(
+    await select({
+      message: "Off-box copies",
+      options: [
+        { value: "skip", label: "Skip for now" },
+        { value: "remote", label: "Remote I own" }
+      ],
+      initialValue: "skip"
+    })
+  );
+  if (choice === WIZARD_CANCELLED) return choice;
+  if (choice === "skip") {
+    return { kind: "skipped", config: await writeInitConfig(home, config.archiveRoot, skippedOffboxConfig()) };
+  }
+  const rclone = await ensureRclone();
+  if (rclone === WIZARD_CANCELLED) return rclone;
+  if (!rclone) {
+    return { kind: "skipped", config: await writeInitConfig(home, config.archiveRoot, skippedOffboxConfig()) };
+  }
+  const remote = await askRemote();
+  if (remote === WIZARD_CANCELLED) return remote;
+  const identity = await generateIdentity();
+  const recipient = await identityToRecipient(identity);
+  const kit = renderRecoveryKit({
+    identity,
+    recipient,
+    remotes: [remote.recovery],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const saved = await saveRecoveryKit(kit, homePath);
+  if (saved === WIZARD_CANCELLED) return saved;
+  const custody = await verifyCustody(recipientChallenge(recipient));
+  if (custody === WIZARD_CANCELLED) return custody;
+  if (!custody) {
+    log.warn("Custody was not verified. Off-box is skipped.");
+    return { kind: "skipped", config: await writeInitConfig(home, config.archiveRoot, skippedOffboxConfig()) };
+  }
+  log.success("Recovery kit verified. Future backups need no key prompt.");
+  if (remote.managedConfig !== void 0) {
+    await writeManagedRcloneConfig(home.rcloneConfPath, remote.managedConfig);
+  }
+  const offbox = { mode: "configured", recipient, remotes: [remote.remote] };
+  return { kind: "configured", config: await writeInitConfig(home, config.archiveRoot, offbox), offbox, identity };
+}
+async function runInitWizard() {
+  intro("packbat init");
+  const home = resolveHome();
+  const homePath = userHome();
+  const detection = detectInitStores(homePath);
+  if (detection.detected.length === 0) {
+    log.info("Detected harnesses: none");
+  } else {
+    log.info(
+      ["Detected harnesses:", ...detection.detected.map((item) => `${item.displayName}: ${item.path}`)].join("\n")
+    );
+  }
+  if (detection.unsupported.length === 0) {
+    log.info("Found, not yet supported: none");
+  } else {
+    log.info(
+      ["Found, not yet supported:", ...detection.unsupported.map((item) => `${item.displayName}: ${item.path}`)].join(
+        "\n"
+      )
+    );
+  }
+  const existing = existsSync(home.configPath) ? loadConfig(home) : void 0;
+  const defaultArchiveRoot = existing?.archiveRoot ?? home.defaultArchiveRoot;
+  const archiveAnswer = promptResult(
+    await text({
+      message: "Archive root",
+      initialValue: defaultArchiveRoot,
+      validate(value) {
+        const answer = value?.trim() ?? "";
+        if (!isAbsolute(answer)) return "Use an absolute path.";
+        if (existing !== void 0 && answer !== existing.archiveRoot) {
+          return `Archive root is already ${existing.archiveRoot}. Edit config.json to move it.`;
+        }
+        return void 0;
+      }
+    })
+  );
+  if (archiveAnswer === WIZARD_CANCELLED) return 1;
+  let config = await writeInitConfig(home, archiveAnswer.trim());
+  const scheduleOptions = await createInitScheduleOptions(home, homePath);
+  const schedule = previewSchedule(scheduleOptions);
+  log.info(
+    [
+      "Schedule:",
+      ...schedule.artifactPaths.map((path) => `artifact: ${path}`),
+      `node: ${scheduleOptions.nodePath}`,
+      `entry: ${scheduleOptions.entryPath}`,
+      "hourly at :03, plus at login/wake"
+    ].join("\n")
+  );
+  const install = promptResult(await confirm({ message: "Install and activate this schedule?", initialValue: true }));
+  if (install === WIZARD_CANCELLED) return 1;
+  if (!install) {
+    cancel("Setup stopped before schedule install.");
+    return 1;
+  }
+  const installed = await installInitSchedule(scheduleOptions, true);
+  for (const message of [...installed.schedule.notes, ...installed.activationNotes]) {
+    log.info(message);
+  }
+  const configured = await configureOffbox(config, homePath);
+  if (configured === WIZARD_CANCELLED) return 1;
+  config = configured.config;
+  let sweepCancelled = false;
+  const sweep = spinner({
+    onCancel() {
+      sweepCancelled = true;
+    }
+  });
+  let summary = "First sweep finished.";
+  sweep.start("Running first sweep");
+  let syncCode;
+  while (true) {
+    if (sweepCancelled) return 1;
+    let busy = false;
+    syncCode = await runSync([], {
+      writeSummary: false,
+      onSummary(value) {
+        summary = value;
+      },
+      onBusy() {
+        busy = true;
+      }
+    });
+    if (!busy) break;
+    if (sweepCancelled) return 1;
+    sweep.message("Waiting for running sync");
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  if (syncCode === 1) {
+    sweep.error(summary);
+  } else {
+    sweep.stop(summary);
+  }
+  if (sweepCancelled) return 1;
+  let remoteCode = 0;
+  if (configured.kind === "configured") {
+    let remoteCancelled = false;
+    const remoteCheck = spinner({
+      onCancel() {
+        remoteCancelled = true;
+      }
+    });
+    remoteCheck.start("Checking remote index");
+    const remoteErrors = [];
+    for (const remote of configured.offbox.remotes) {
+      try {
+        await smokeTestRemoteIndex(config, remote, configured.identity);
+      } catch (error) {
+        remoteErrors.push(`${remote.destination}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (remoteErrors.length === 0) {
+      if (!remoteCancelled) remoteCheck.stop("Remote index checked.");
+    } else {
+      if (!remoteCancelled) {
+        remoteCheck.error(`Remote index check failed: ${remoteErrors.join("; ")}`);
+      }
+      remoteCode = 1;
+    }
+    if (remoteCancelled) return 1;
+  }
+  const doctorCode = await runDoctor([]);
+  const operationalFailure = syncCode === 1 || remoteCode === 1 || doctorCode === 1;
+  outro(operationalFailure ? "Setup failed. Run `packbat status`." : "Done. Run `packbat status`.");
+  return operationalFailure ? 1 : 0;
+}
+export {
+  runInitWizard
+};