@askexenow/exe-os 0.9.21 → 0.9.23

package/dist/bin/update.js

@@ -16,8 +16,8 @@ var __export = (target, all) => {
 };
 
 // src/lib/secure-files.ts
-import { chmodSync, existsSync, mkdirSync } from "fs";
-import { chmod, mkdir } from "fs/promises";
+import { chmodSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { chmod, mkdir as mkdir2 } from "fs/promises";
 var init_secure_files = __esm({
   "src/lib/secure-files.ts"() {
     "use strict";
@@ -25,16 +25,16 @@ var init_secure_files = __esm({
 });
 
 // src/lib/config.ts
-import { readFile, writeFile } from "fs/promises";
-import { readFileSync as readFileSync2, existsSync as existsSync2, renameSync } from "fs";
-import path2 from "path";
-import os from "os";
-function resolveDataDir() {
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFileSync as readFileSync2, existsSync as existsSync3, renameSync } from "fs";
+import path3 from "path";
+import os2 from "os";
+function resolveDataDir2() {
   if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path2.join(os.homedir(), ".exe-os");
-  const legacyDir = path2.join(os.homedir(), ".exe-mem");
-  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
+  const newDir = path3.join(os2.homedir(), ".exe-os");
+  const legacyDir = path3.join(os2.homedir(), ".exe-mem");
+  if (!existsSync3(newDir) && existsSync3(legacyDir)) {
     try {
       renameSync(legacyDir, newDir);
       process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
@@ -50,11 +50,11 @@ var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     init_secure_files();
-    EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
+    EXE_AI_DIR = resolveDataDir2();
+    DB_PATH = path3.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path3.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path3.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path3.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
       config_version: CURRENT_CONFIG_VERSION,
@@ -133,12 +133,12 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
 import { randomUUID } from "crypto";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
-import os2 from "os";
-import path3 from "path";
+import os3 from "os";
+import path4 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -149,16 +149,16 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path3.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path4.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync3(deviceJsonPath)) {
+    if (existsSync4(deviceJsonPath)) {
       const data = JSON.parse(readFileSync3(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync3(DEVICE_ID_PATH)) {
+    if (existsSync4(DEVICE_ID_PATH)) {
       const id2 = readFileSync3(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
@@ -171,7 +171,7 @@ function loadDeviceId() {
 }
 function loadLicense() {
   try {
-    if (!existsSync3(LICENSE_PATH)) return null;
+    if (!existsSync4(LICENSE_PATH)) return null;
     return readFileSync3(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
@@ -205,7 +205,7 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync3(CACHE_PATH)) return null;
+    if (!existsSync4(CACHE_PATH)) return null;
     const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
@@ -215,7 +215,7 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync3(CACHE_PATH)) return null;
+    if (!existsSync4(CACHE_PATH)) return null;
     const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
@@ -258,8 +258,8 @@ function loadPrismaForLicense() {
   if (_prismaFailed) return null;
   const dbUrl = process.env.DATABASE_URL;
   if (!dbUrl) {
-    const exeDbRoot = process.env.EXE_DB_ROOT ?? path3.join(os2.homedir(), "exe-db");
-    if (!existsSync3(path3.join(exeDbRoot, "package.json"))) {
+    const exeDbRoot = process.env.EXE_DB_ROOT ?? path4.join(os3.homedir(), "exe-db");
+    if (!existsSync4(path4.join(exeDbRoot, "package.json"))) {
       _prismaFailed = true;
       return null;
     }
@@ -273,8 +273,8 @@ function loadPrismaForLicense() {
         if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
         return new Ctor2();
       }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path3.join(os2.homedir(), "exe-db");
-      const req = createRequire(path3.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path4.join(os3.homedir(), "exe-db");
+      const req = createRequire(path4.join(exeDbRoot, "package.json"));
       const entry = req.resolve("@prisma/client");
       const mod = await import(pathToFileURL(entry).href);
       const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
@@ -363,7 +363,7 @@ async function validateLicense(apiKey, deviceId) {
   const cached = await getCachedLicense();
   if (cached) return cached;
   try {
-    if (existsSync3(CACHE_PATH)) {
+    if (existsSync4(CACHE_PATH)) {
       const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
       if (raw.pgLicense && raw.ts && Date.now() - raw.ts < 7 * 24 * 60 * 60 * 1e3) {
         return raw.pgLicense;
@@ -388,8 +388,8 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path3.join(EXE_AI_DIR, "config.json");
-      if (existsSync3(configPath)) {
+      const configPath = path4.join(EXE_AI_DIR, "config.json");
+      if (existsSync4(configPath)) {
         const raw = JSON.parse(readFileSync3(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
@@ -549,9 +549,9 @@ var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path3.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path3.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path3.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path4.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path4.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path4.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -601,12 +601,102 @@ function isMainModule(importMetaUrl) {
   }
 }
 
+// src/lib/update-backup.ts
+import { copyFile, readFile, readdir, writeFile, rm, mkdir, cp } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import os from "os";
+var BACKUP_DIR_NAME = ".update-backup";
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
+  return path.join(os.homedir(), ".exe-os");
+}
+var BACKUP_TARGETS = [
+  { name: "config.json", type: "file" },
+  { name: "exe-employees.json", type: "file" },
+  { name: "master.key", type: "file" },
+  { name: "identity", type: "dir" }
+  // All .db files (SQLCipher databases) — matched dynamically
+];
+async function createUpdateBackup(currentVersion, dataDir) {
+  const dir = dataDir ?? resolveDataDir();
+  const backupDir = path.join(dir, BACKUP_DIR_NAME);
+  if (existsSync(backupDir)) {
+    await rm(backupDir, { recursive: true, force: true });
+  }
+  await mkdir(backupDir, { recursive: true });
+  const backedUpFiles = [];
+  for (const target of BACKUP_TARGETS) {
+    const src = path.join(dir, target.name);
+    if (!existsSync(src)) continue;
+    const dest = path.join(backupDir, target.name);
+    if (target.type === "file") {
+      await copyFile(src, dest);
+    } else {
+      await cp(src, dest, { recursive: true });
+    }
+    backedUpFiles.push(target.name);
+  }
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".db") && entry.name !== BACKUP_DIR_NAME) {
+      const src = path.join(dir, entry.name);
+      const dest = path.join(backupDir, entry.name);
+      await copyFile(src, dest);
+      backedUpFiles.push(entry.name);
+    }
+  }
+  const manifest = {
+    version: currentVersion,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    files: backedUpFiles
+  };
+  await writeFile(
+    path.join(backupDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n"
+  );
+  return manifest;
+}
+async function restoreFromBackup(dataDir) {
+  const dir = dataDir ?? resolveDataDir();
+  const backupDir = path.join(dir, BACKUP_DIR_NAME);
+  const manifestPath = path.join(backupDir, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    throw new Error(
+      `No backup found at ${backupDir}. Nothing to restore.`
+    );
+  }
+  const manifest = JSON.parse(
+    await readFile(manifestPath, "utf-8")
+  );
+  for (const fileName of manifest.files) {
+    const src = path.join(backupDir, fileName);
+    const dest = path.join(dir, fileName);
+    if (!existsSync(src)) continue;
+    const stat = await import("fs/promises").then((m) => m.stat(src));
+    if (stat.isDirectory()) {
+      await cp(src, dest, { recursive: true, force: true });
+    } else {
+      await copyFile(src, dest);
+    }
+  }
+  return manifest;
+}
+async function deleteBackup(dataDir) {
+  const dir = dataDir ?? resolveDataDir();
+  const backupDir = path.join(dir, BACKUP_DIR_NAME);
+  if (existsSync(backupDir)) {
+    await rm(backupDir, { recursive: true, force: true });
+  }
+}
+
 // src/lib/update-check.ts
 import { execSync } from "child_process";
 import { readFileSync } from "fs";
-import path from "path";
+import path2 from "path";
 function getLocalVersion(packageRoot) {
-  const pkgPath = path.join(packageRoot, "package.json");
+  const pkgPath = path2.join(packageRoot, "package.json");
   const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
@@ -639,10 +729,47 @@ function checkForUpdate(packageRoot) {
 }
 
 // src/bin/update.ts
+async function runRestore() {
+  console.log("\n\u{1F504} Restoring from update backup...");
+  try {
+    const manifest = await restoreFromBackup();
+    console.log(`   Restored ${manifest.files.length} file(s) from v${manifest.version} backup.`);
+    console.log(`   Backup was created at ${manifest.timestamp}`);
+    console.log(`
+\u{1F4E5} Reinstalling @askexenow/exe-os@${manifest.version}...`);
+    try {
+      execSync2(`npm install -g @askexenow/exe-os@${manifest.version}`, {
+        stdio: ["pipe", "pipe", "inherit"],
+        timeout: 3e5
+      });
+      console.log(`
+\u2705 Restored to v${manifest.version}`);
+    } catch {
+      console.error(`
+\u26A0\uFE0F  Could not reinstall v${manifest.version} via npm.`);
+      console.error(`   Your data files have been restored. Try manually:`);
+      console.error(`   npm install -g @askexenow/exe-os@${manifest.version}`);
+    }
+    try {
+      await deleteBackup();
+    } catch {
+    }
+    console.log("\n\u{1F680} Restore complete. Restart your sessions.\n");
+  } catch (err) {
+    console.error("\u274C Restore failed.");
+    if (err instanceof Error) console.error(`   ${err.message}`);
+    process.exit(1);
+  }
+}
 async function runUpdate(cliArgs) {
   const args = cliArgs ?? process.argv.slice(2);
   const autoMode = args.includes("--auto") || args.includes("-y");
   const checkOnly = args.includes("--check");
+  const restoreMode = args.includes("--restore");
+  if (restoreMode) {
+    await runRestore();
+    return;
+  }
   const packageRoot = new URL("../..", import.meta.url).pathname;
   const result = checkForUpdate(packageRoot);
   if (result.error) {
@@ -677,7 +804,16 @@ async function runUpdate(cliArgs) {
     console.log("Update skipped.");
     process.exit(0);
   }
-  console.log("\n\u{1F9F9} Clearing npm cache...");
+  console.log("\n\u{1F4BE} Backing up customer data...");
+  try {
+    const backupResult = await createUpdateBackup(result.localVersion);
+    console.log(`   Backed up ${backupResult.files.length} file(s) to ${BACKUP_DIR_NAME}/`);
+  } catch (err) {
+    console.error("\u274C Backup failed \u2014 aborting update to protect your data.");
+    if (err instanceof Error) console.error(`   ${err.message}`);
+    process.exit(1);
+  }
+  console.log("\u{1F9F9} Clearing npm cache...");
   try {
     execSync2("npm cache clean --force", { stdio: "pipe" });
     console.log("   Done");
@@ -692,8 +828,9 @@ async function runUpdate(cliArgs) {
       timeout: 3e5
     });
   } catch (err) {
-    console.error("\n\u274C Update failed.");
-    console.error("   Try manually: npm install -g @askexenow/exe-os@latest");
+    console.error("\n\u274C Update failed. Your backup is preserved.");
+    console.error(`   Restore with: exe-os update --restore`);
+    console.error("   Or try manually: npm install -g @askexenow/exe-os@latest");
     if (err instanceof Error && err.message) {
       console.error(`   Error: ${err.message.split("\n")[0]}`);
     }
@@ -712,30 +849,38 @@ async function runUpdate(cliArgs) {
     }
   }
   const remoteVersion = result.remoteVersion;
+  const updateSucceeded = newVersion !== result.localVersion;
   if (newVersion === remoteVersion) {
     console.log(`
 \u2705 Updated to v${newVersion}`);
-  } else if (newVersion !== result.localVersion) {
+  } else if (updateSucceeded) {
     console.log(`
 \u2705 Updated to v${newVersion} (latest: v${remoteVersion})`);
   } else {
     console.log(`
 \u26A0\uFE0F  Version unchanged (v${newVersion}). npm cache may be stale.`);
+    console.log("   Backup preserved. Restore with: exe-os update --restore");
     console.log("   Try: npm cache clean --force && npm install -g @askexenow/exe-os@latest");
   }
+  if (updateSucceeded) {
+    try {
+      await deleteBackup();
+    } catch {
+    }
+  }
   console.log("   Hooks re-wired, daemon restarted automatically.");
   console.log("");
   console.log("   \x1B[33m\u26A1 Run /mcp in each active Claude Code session to pick up new tools.\x1B[0m");
   console.log("   \x1B[2m(MCP servers can't hot-reload \u2014 Claude Code needs to reconnect them.)\x1B[0m");
   try {
-    const { existsSync: exists, readFileSync: readFile2 } = await import("fs");
+    const { existsSync: exists, readFileSync: readFile3 } = await import("fs");
     const p = await import("path");
     const { homedir: home } = await import("os");
     const exeDir = p.default.join(home(), ".exe-os");
     const licKeyPath = p.default.join(exeDir, "license.key");
     const configPath = p.default.join(exeDir, "config.json");
     if (!exists(licKeyPath) && exists(configPath)) {
-      const cfg = JSON.parse(readFile2(configPath, "utf8"));
+      const cfg = JSON.parse(readFile3(configPath, "utf8"));
       const cloud = cfg.cloud;
       if (cloud?.apiKey) {
         const { mirrorLicenseKey: mirrorLicenseKey2 } = await Promise.resolve().then(() => (init_license(), license_exports));

package/dist/gateway/index.js

@@ -3580,8 +3580,8 @@ function getShardClient(projectName) {
     throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
   const cached = _shards.get(safeName);
   if (cached) {
@@ -4450,19 +4450,32 @@ async function flushBatch() {
       const { isShardingEnabled: isShardingEnabled2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
       if (isShardingEnabled2()) {
         const byProject = /* @__PURE__ */ new Map();
+        let skippedUnknown = 0;
         for (const row of batch) {
-          const proj = row.project_name || "unknown";
+          const proj = row.project_name?.trim();
+          if (!proj) {
+            skippedUnknown++;
+            continue;
+          }
           if (!byProject.has(proj)) byProject.set(proj, []);
           byProject.get(proj).push(row);
         }
+        if (skippedUnknown > 0) {
+          process.stderr.write(
+            `[store] Shard skip: ${skippedUnknown} record(s) with empty project_name (kept in main DB only)
+`
+          );
+        }
         for (const [project, rows] of byProject) {
           try {
             const shardClient = await getReadyShardClient2(project);
             const shardStmts = rows.map(buildStmt);
             await shardClient.batch(shardStmts, "write");
           } catch (err) {
+            const fullError = err instanceof Error ? `${err.name}: ${err.message}${err.stack ? `
+${err.stack.split("\n").slice(1, 3).join("\n")}` : ""}` : String(err);
             process.stderr.write(
-              `[store] Shard write failed for ${project}: ${err instanceof Error ? err.message : String(err)}
+              `[store] Shard write failed for ${project} (${rows.length} records): ${fullError}
 `
             );
           }