abtars 0.2.1-alpha.8 → 0.2.1-alpha.9

package/README.md

@@ -29,31 +29,28 @@ abTARS (agent brain)
 ## Quick Start
 
 ```bash
-npm install -g abtars
-abtars init
+npm install -g abtars@alpha abmind@alpha
+abmind install
+abtars install
+abtars update
+abtars onboard
+sudo $(which abtars) daemon install
 ```
 
-The init wizard walks you through:
-1. Telegram bot token (from [@BotFather](https://t.me/BotFather))
-2. Model provider (kiro-cli, gemini-cli, ollama, or OpenRouter)
-3. Your user ID
-
-Then start:
-
-```bash
-abtars start
-```
+Full installation guide: **[docs/wiki/install.md](docs/wiki/install.md)**
 
 ## Documentation
 
-Full docs, configuration reference, and guides: **[Wiki](https://github.com/aksika/abtars/wiki)**
+Docs live in the repo at **[docs/wiki/](docs/wiki/)** — always up to date with the code.
 
-- [Installation](https://github.com/aksika/abtars/wiki/Installation)
-- [Configuration](https://github.com/aksika/abtars/wiki/Configuration)
-- [Commands](https://github.com/aksika/abtars/wiki/Commands)
+- [Installation](docs/wiki/install.md)
+- [Configuration](docs/wiki/commands.md)
+- [Commands](docs/wiki/cli.md)
 - [Memory System (abmind)](https://github.com/aksika/abmind)
-- [Skills & Extensions](https://github.com/aksika/abtars/wiki/Skills)
-- [Deployment & Watchdog](https://github.com/aksika/abtars/wiki/Deployment)
+- [Skills & Extensions](docs/wiki/skills.md)
+- [Deployment & Supervision](docs/wiki/supervision.md)
+
+> **Note:** The [aksika.github.io](https://aksika.github.io/abtars/) site may be outdated. Always refer to the docs in this repo.
 
 ## Supported Transports
 

package/bundle/abtars-cli.js

@@ -301,112 +301,198 @@ async function uninstall(opts) {
 
 // src/cli/commands/backup.ts
 init_paths();
-import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, statSync, renameSync, unlinkSync as unlinkSync3, copyFileSync } from "node:fs";
-import { join as join4, dirname } from "node:path";
+import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, statSync, unlinkSync as unlinkSync3, renameSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join4, dirname, basename } from "node:path";
 import { spawnSync } from "node:child_process";
-var AB_SAVE = ["config", "secret", "tasks", "logo", "workspace", "skills/custom", "skills/self"];
+import { createCipheriv, hkdfSync, randomBytes } from "node:crypto";
 var DEFAULT_PRUNE_DAYS = 7;
-async function backup(outputDir, pruneDays) {
+var ABTARS_EXCLUDE = [
+  "releases",
+  "current",
+  "bin",
+  "app",
+  "logs",
+  "node_modules",
+  "overflow",
+  "browser-socket",
+  "bridge.lock",
+  "watchdog.lock",
+  "browse-spawn.sock",
+  "*.sock"
+];
+var ABMIND_EXCLUDE = [
+  "memory/memory.db",
+  "lib",
+  "node_modules",
+  "backups",
+  "*.sock",
+  "*.db-wal",
+  "*.db-shm"
+];
+var CONFIG_DIRS = ["config", "secret", "tasks", "skills", "core", "agents"];
+async function backup(opts = {}) {
   const abHome = abtarsHome();
+  const abmindHome = process.env["ABMIND_HOME"] ?? join4(dirname(abHome), ".abmind");
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const destDir = outputDir ?? join4(dirname(abHome), ".backup-abtars");
+  const destDir = opts.outputDir ?? join4(dirname(abHome), ".backup-abtars");
   mkdirSync(destDir, { recursive: true });
-  const abmindPaths = [
-    join4(dirname(abHome), ".abmind", "lib", "node_modules", "abmind", "dist", "cli", "abmind-backup.js"),
-    join4(dirname(abHome), "workspace", "ab", "abmind", "dist", "cli", "abmind-backup.js")
-  ];
-  const abmindBin = abmindPaths.find((p) => existsSync3(p));
-  let abmResult;
-  if (abmindBin) {
-    abmResult = spawnSync("node", [abmindBin], { encoding: "utf-8", env: { ...process.env } });
-  } else {
-    abmResult = spawnSync("abmind", ["backup"], { encoding: "utf-8", env: { ...process.env } });
-  }
-  if (abmResult.status !== 0) {
-    process.stderr.write(`\u26A0\uFE0F abmind backup failed: ${abmResult.stderr || abmResult.stdout}
-`);
-    return 1;
-  }
-  const abmindBackupsDir = join4(dirname(abHome), ".abmind", "backups");
-  let abmFile;
-  if (existsSync3(abmindBackupsDir)) {
-    const abmFiles = readdirSync2(abmindBackupsDir).filter((f) => f.endsWith(".abm")).sort().reverse();
-    if (abmFiles.length > 0) abmFile = abmFiles[0];
-  }
-  if (abmFile) {
-    const src = join4(abmindBackupsDir, abmFile);
-    const dest = join4(destDir, `abmind-${date}.abm`);
-    renameSync(src, dest);
-    const size = (statSync(dest).size / 1024).toFixed(0);
-    process.stdout.write(`\u2713 abmind-${date}.abm (${size}KB, encrypted)
-`);
+  const isConfig = opts.config === true;
+  const prefix = isConfig ? `abtars-config-${date}` : `abtars-${date}`;
+  const zipExcludes = [];
+  if (isConfig) {
   } else {
-    process.stderr.write(`\u26A0\uFE0F abmind backup produced no .abm file
-`);
-  }
-  const files = [];
-  for (const dir of AB_SAVE) {
-    const abs = join4(abHome, dir);
-    if (existsSync3(abs)) collectDir(abs, dir, files);
-  }
-  if (files.length === 0) {
-    process.stderr.write("Nothing to zip from abtars.\n");
-    return 1;
-  }
-  const tmpDir = join4(process.env["TMPDIR"] ?? "/tmp", `abtars-backup-${Date.now()}`);
-  mkdirSync(tmpDir, { recursive: true });
-  for (const f of files) {
-    const dest = join4(tmpDir, f.zipPath);
-    mkdirSync(dirname(dest), { recursive: true });
-    copyFileSync(f.absPath, dest);
+    for (const ex of ABTARS_EXCLUDE) {
+      zipExcludes.push(`${ex}/*`, ex);
+    }
+    zipExcludes.push("*.db-wal", "*.db-shm", "*.sock");
   }
-  const zipPath = join4(destDir, `abtars-${date}.zip`);
   const has7z = spawnSync("which", ["7z"], { encoding: "utf-8" }).status === 0;
+  const zipExt = has7z ? ".7z" : ".zip";
+  let zipPath = join4(destDir, prefix + zipExt);
   let zipOk;
-  if (has7z) {
-    const r = spawnSync("7z", ["a", zipPath.replace(/\.zip$/, ".7z"), "."], { cwd: tmpDir, encoding: "utf-8" });
-    zipOk = r.status === 0;
+  if (isConfig) {
+    const existingDirs = CONFIG_DIRS.filter((d) => existsSync3(join4(abHome, d)));
+    if (existingDirs.length === 0) {
+      process.stderr.write("Nothing to backup \u2014 no config dirs found\n");
+      return 1;
+    }
+    if (has7z) {
+      const r = spawnSync("7z", ["a", zipPath, ...existingDirs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    } else {
+      const r = spawnSync("zip", ["-qr", zipPath, ...existingDirs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    }
   } else {
-    const r = spawnSync("zip", ["-r", zipPath, "."], { cwd: tmpDir, encoding: "utf-8" });
-    zipOk = r.status === 0;
+    if (has7z) {
+      const excludeArgs = ABTARS_EXCLUDE.flatMap((ex) => ["-xr!" + ex]);
+      excludeArgs.push("-xr!*.db-wal", "-xr!*.db-shm", "-xr!*.sock");
+      const r = spawnSync("7z", ["a", zipPath, ".", ...excludeArgs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    } else {
+      const excludeArgs = ABTARS_EXCLUDE.flatMap((ex) => ["-x", `${ex}/*`, "-x", ex]);
+      excludeArgs.push("-x", "*.db-wal", "-x", "*.db-shm", "-x", "*.sock");
+      const r = spawnSync("zip", ["-qr", zipPath, ".", ...excludeArgs], { cwd: abHome, encoding: "utf-8" });
+      zipOk = r.status === 0;
+    }
+    if (zipOk && existsSync3(abmindHome)) {
+      if (has7z) {
+        const excludeArgs = ABMIND_EXCLUDE.flatMap((ex) => ["-xr!" + ex]);
+        const r = spawnSync("7z", ["a", zipPath, ".", ...excludeArgs], { cwd: abmindHome, encoding: "utf-8" });
+        zipOk = r.status === 0;
+      } else {
+        const excludeArgs = ABMIND_EXCLUDE.flatMap((ex) => ["-x", `${ex}/*`, "-x", ex]);
+        const r = spawnSync("zip", ["-qr", zipPath, "-g", ".", ...excludeArgs], { cwd: abmindHome, encoding: "utf-8" });
+        zipOk = r.status === 0;
+      }
+    }
+    const dbPath = join4(abmindHome, "memory", "memory.db");
+    if (zipOk && existsSync3(dbPath)) {
+      const tmpDb = join4(process.env["TMPDIR"] ?? "/tmp", `abtars-backup-memory-${Date.now()}.db`);
+      const sqliteResult = spawnSync("sqlite3", [dbPath, `.backup '${tmpDb}'`], { encoding: "utf-8" });
+      if (sqliteResult.status === 0 && existsSync3(tmpDb)) {
+        if (has7z) {
+          spawnSync("7z", ["a", zipPath, tmpDb], { encoding: "utf-8" });
+        } else {
+          spawnSync("zip", ["-qj", zipPath, tmpDb], { encoding: "utf-8" });
+        }
+        try {
+          unlinkSync3(tmpDb);
+        } catch {
+        }
+      }
+    }
   }
-  spawnSync("rm", ["-rf", tmpDir]);
   if (!zipOk) {
-    process.stderr.write(`\u26A0\uFE0F zip/7z failed
-`);
+    process.stderr.write("Backup zip failed\n");
     return 1;
   }
-  const actualZip = has7z ? zipPath.replace(/\.zip$/, ".7z") : zipPath;
-  const sizeMb = (statSync(actualZip).size / 1024 / 1024).toFixed(1);
-  process.stdout.write(`\u2713 ${actualZip.split("/").pop()} (${sizeMb}MB, ${files.length} files)
+  if (!isConfig) {
+    const actual = statSync(zipPath).size;
+    if (actual < 1e5) {
+      process.stderr.write(`\u26A0\uFE0F Backup suspiciously small (${actual} bytes)
 `);
-  const maxAge = (pruneDays ?? DEFAULT_PRUNE_DAYS) * 864e5;
-  const now = Date.now();
-  for (const f of readdirSync2(destDir)) {
-    if (!(f.startsWith("abtars-") || f.startsWith("abmind-"))) continue;
-    if (!(f.endsWith(".zip") || f.endsWith(".7z") || f.endsWith(".abm"))) continue;
-    const fPath = join4(destDir, f);
-    try {
-      if (now - statSync(fPath).mtimeMs > maxAge) {
-        unlinkSync3(fPath);
-        process.stdout.write(`  \u{1F5D1} pruned ${f}
+    }
+  }
+  const zipSize = (statSync(zipPath).size / 1024 / 1024).toFixed(1);
+  process.stdout.write(`\u2713 ${basename(zipPath)} (${zipSize}MB)
 `);
+  if (opts.encrypt) {
+    const encPath = zipPath + ".enc";
+    const ok = encryptFile(zipPath, encPath, abmindHome);
+    if (!ok) return 1;
+    unlinkSync3(zipPath);
+    zipPath = encPath;
+    process.stdout.write(`\u2713 encrypted \u2192 ${basename(encPath)}
+`);
+  }
+  if (!isConfig) {
+    const abmResult = runAbmindBackup(abHome, abmindHome);
+    if (abmResult) {
+      const dest = join4(destDir, `abmind-${date}.abm`);
+      renameSync(abmResult, dest);
+      const size = (statSync(dest).size / 1024).toFixed(0);
+      process.stdout.write(`\u2713 abmind-${date}.abm (${size}KB, encrypted)
+`);
+    } else {
+      process.stderr.write("\u26A0\uFE0F abmind backup failed or produced no .abm\n");
+    }
+  }
+  const pruneDays = opts.pruneDays ?? DEFAULT_PRUNE_DAYS;
+  if (pruneDays > 0) {
+    const maxAge = pruneDays * 864e5;
+    const now = Date.now();
+    for (const f of readdirSync2(destDir)) {
+      if (!(f.startsWith("abtars-") || f.startsWith("abmind-"))) continue;
+      if (!(f.endsWith(".zip") || f.endsWith(".7z") || f.endsWith(".abm") || f.endsWith(".enc"))) continue;
+      const fPath = join4(destDir, f);
+      try {
+        if (now - statSync(fPath).mtimeMs > maxAge) {
+          unlinkSync3(fPath);
+          process.stdout.write(`  \u{1F5D1} pruned ${f}
+`);
+        }
+      } catch {
       }
-    } catch {
     }
   }
   return 0;
 }
-function collectDir(dir, prefix, out) {
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const abs = join4(dir, entry.name);
-    const rel = `${prefix}/${entry.name}`;
-    if (entry.isDirectory()) {
-      collectDir(abs, rel, out);
-    } else if (entry.isFile()) {
-      out.push({ absPath: abs, zipPath: rel });
-    }
+function runAbmindBackup(abHome, abmindHome) {
+  const abmindPaths = [
+    join4(dirname(abHome), "workspace", "ab", "abmind", "dist", "cli", "abmind-backup.js"),
+    join4(abmindHome, "lib", "node_modules", "abmind", "dist", "cli", "abmind-backup.js")
+  ];
+  const abmindBin = abmindPaths.find((p) => existsSync3(p));
+  let result;
+  if (abmindBin) {
+    result = spawnSync("node", [abmindBin], { encoding: "utf-8", env: { ...process.env } });
+  } else {
+    result = spawnSync("abmind", ["backup"], { encoding: "utf-8", env: { ...process.env } });
   }
+  if (result.status !== 0) return null;
+  const backupsDir = join4(abmindHome, "backups");
+  if (!existsSync3(backupsDir)) return null;
+  const abmFiles = readdirSync2(backupsDir).filter((f) => f.endsWith(".abm")).sort().reverse();
+  return abmFiles[0] ? join4(backupsDir, abmFiles[0]) : null;
+}
+function encryptFile(inputPath, outputPath, abmindHome) {
+  const keyPath = join4(abmindHome, "secret", "abmind.key");
+  if (!existsSync3(keyPath)) {
+    process.stderr.write(`\u26A0\uFE0F --encrypt requires ${keyPath}
+`);
+    return false;
+  }
+  const master = Buffer.from(readFileSync2(keyPath, "utf-8").trim(), "hex");
+  const key = Buffer.from(hkdfSync("sha256", master, "", "abtars-backup-v1", 32));
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const input = readFileSync2(inputPath);
+  const encrypted = Buffer.concat([cipher.update(input), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const out = Buffer.concat([iv, encrypted, tag]);
+  writeFileSync(outputPath, out);
+  return true;
 }
 
 // src/cli/commands/onboard.ts
@@ -417,7 +503,7 @@ import { homedir as homedir2 } from "node:os";
 import { fileURLToPath } from "node:url";
 
 // src/components/hints.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync, renameSync as renameSync2 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync as renameSync2 } from "node:fs";
 import { join as join5 } from "node:path";
 function manifestPath() {
   const home = process.env["ABTARS_HOME"] ?? join5(process.env["HOME"] ?? "", ".abtars");
@@ -427,7 +513,7 @@ function readManifest2() {
   const path = manifestPath();
   if (!existsSync4(path)) return {};
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return {};
   }
@@ -435,7 +521,7 @@ function readManifest2() {
 function writeManifestAtomic(data) {
   const path = manifestPath();
   const tmp = path + ".tmp";
-  writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  writeFileSync2(tmp, JSON.stringify(data, null, 2) + "\n");
   renameSync2(tmp, path);
 }
 function showHintOnce(id, text) {
@@ -1209,7 +1295,7 @@ Rollback complete.
 
 // src/cli/commands/status.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import { join as join8 } from "node:path";
 async function status() {
   const paths = packagePaths("abtars");
@@ -1239,7 +1325,7 @@ Run 'abtars install' to set up.
     `  host:          ${manifest.host}`
   ];
   try {
-    const bridgeLock = JSON.parse(readFileSync3(join8(paths.home, "bridge.lock"), "utf-8"));
+    const bridgeLock = JSON.parse(readFileSync4(join8(paths.home, "bridge.lock"), "utf-8"));
     if (bridgeLock.pid) {
       const alive = (() => {
         try {
@@ -1280,7 +1366,7 @@ Run 'abtars install' to set up.
 // src/cli/commands/update.ts
 import { hostname } from "node:os";
 import { join as join11 } from "node:path";
-import { readFileSync as readFileSync5, existsSync as existsSync9 } from "node:fs";
+import { readFileSync as readFileSync6, existsSync as existsSync9 } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir4, chmod, readdir } from "node:fs/promises";
 import { rmSync as rmSync3, cpSync, readdirSync as readdirSync3, mkdirSync as mkdirSync2 } from "node:fs";
 
@@ -1411,7 +1497,7 @@ function makeLocalBuildSource(opts = {}) {
 
 // src/cli/update-sources/npm.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync4, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5, unlinkSync as unlinkSync4 } from "node:fs";
 import { mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
 import { join as join10 } from "node:path";
 var TIMEOUT_MS = 6e4;
@@ -1423,7 +1509,7 @@ function run(cmd, args, cwd) {
 }
 function readLocalVersion(home) {
   try {
-    const pkg = JSON.parse(readFileSync4(join10(home, "app", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync5(join10(home, "app", "package.json"), "utf-8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -1455,7 +1541,7 @@ function makeNpmSource(packageName) {
 // src/cli/commands/update.ts
 function readJsonField2(file, field) {
   try {
-    return JSON.parse(readFileSync5(file, "utf-8"))[field];
+    return JSON.parse(readFileSync6(file, "utf-8"))[field];
   } catch {
     return void 0;
   }
@@ -1522,12 +1608,12 @@ Use --source local (default) or --source npm.
     {
       const pkgPath = join11(staged.stagedPath, "package.json");
       try {
-        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
         const externals = { patchright: "^1.59.4", "rettiwt-api": "^4.1.3" };
         pkg.dependencies = { ...pkg.dependencies, ...externals };
         if (pkg.dependencies?.abmind?.startsWith("file:")) delete pkg.dependencies.abmind;
-        const { writeFileSync: writeFileSync2 } = await import("node:fs");
-        writeFileSync2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+        const { writeFileSync: writeFileSync3 } = await import("node:fs");
+        writeFileSync3(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
         const { execSync } = await import("node:child_process");
         execSync("npm install --omit=dev --ignore-scripts 2>/dev/null", { cwd: staged.stagedPath, timeout: 6e4 });
         process.stdout.write(`\u2713 external deps installed
@@ -1700,7 +1786,7 @@ async function postSwapHousekeeping(paths, repoRoot, _staged) {
   const transportJson = join11(paths.home, "config", "transport.json");
   if (existsSync9(transportJson)) {
     try {
-      const tc = JSON.parse(readFileSync5(transportJson, "utf-8"));
+      const tc = JSON.parse(readFileSync6(transportJson, "utf-8"));
       let cleared = false;
       for (const agent of Object.values(tc.agents ?? {})) {
         if (agent.demoted) {
@@ -1719,8 +1805,8 @@ async function postSwapHousekeeping(paths, repoRoot, _staged) {
         }
       }
       if (cleared) {
-        const { writeFileSync: writeFileSync2 } = await import("node:fs");
-        writeFileSync2(transportJson, JSON.stringify(tc, null, 2) + "\n");
+        const { writeFileSync: writeFileSync3 } = await import("node:fs");
+        writeFileSync3(transportJson, JSON.stringify(tc, null, 2) + "\n");
       }
     } catch {
     }
@@ -1858,8 +1944,8 @@ Usage:
   abtars uninstall [--yes]
   abtars update  [--source local|npm|github] [--from-local]
   abtars rollback [--to <version>]
-  abtars backup
-  abtars restore <file.zip|.7z>
+  abtars backup [--config] [--encrypt] [--output <dir>] [--prune-days N]
+  abtars restore <file.zip|.7z|.abm|.enc> [--config] [--passphrase <p>]
   abtars doctor [<args passed to doctor.sh>...]
   abtars onboard [--non-interactive --accept-risk --telegram-token ... --telegram-chat-id ...]
   abtars restart [--cold]
@@ -1893,10 +1979,18 @@ async function main(argv) {
       case "rollback":
         return await rollback();
       case "backup":
-        return await backup(typeof flags.get("output") === "string" ? flags.get("output") : void 0);
+        return await backup({
+          config: flags.get("config") === true,
+          encrypt: flags.get("encrypt") === true,
+          outputDir: typeof flags.get("output") === "string" ? flags.get("output") : void 0,
+          pruneDays: typeof flags.get("prune-days") === "string" ? Number(flags.get("prune-days")) : void 0
+        });
       case "restore": {
-        const { restore } = await import("./restore-ROJF22R2.js");
-        return await restore(argv[1] ?? "");
+        const { restore } = await import("./restore-MFSW3EBL.js");
+        return await restore(argv[1] ?? "", {
+          config: flags.get("config") === true,
+          passphrase: typeof flags.get("passphrase") === "string" ? flags.get("passphrase") : void 0
+        });
       }
       case "doctor":
         return await doctor(argv.slice(1).filter((a) => a !== ""));