@askexenow/exe-os 0.8.55 → 0.8.56

package/dist/bin/cli.js

@@ -6335,6 +6335,24 @@ async function runUpdate(cliArgs) {
     console.log("   Try: npm cache clean --force && npm install -g @askexenow/exe-os@latest");
   }
   console.log("   Hooks re-wired, daemon restarted automatically.");
+  try {
+    const { existsSync: exists, readFileSync: readFile6 } = 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(readFile6(configPath, "utf8"));
+      const cloud = cfg.cloud;
+      if (cloud?.apiKey) {
+        const { mirrorLicenseKey: mirrorLicenseKey2 } = await Promise.resolve().then(() => (init_license(), license_exports));
+        mirrorLicenseKey2(cloud.apiKey);
+        console.log("   \u{1F511} License key restored from cloud config.");
+      }
+    }
+  } catch {
+  }
   console.log("\n\u{1F680} Ready. Start your COO session to use the new version.\n");
 }
 var init_update = __esm({
@@ -23118,10 +23136,40 @@ if (args.includes("--global")) {
 } else if (args[0] === "update") {
   const { runUpdate: runUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
   await runUpdate2(args.slice(1));
-} else {
+} else if (args.includes("--tui") || args.includes("--demo") || args[0] === "tui") {
   checkForUpdateOnBoot().catch(() => {
   });
   await init_App2().then(() => App_exports);
+} else {
+  const claudeDir = path33.join(os11.homedir(), ".claude");
+  const settingsPath = path33.join(claudeDir, "settings.json");
+  const hasClaudeCode = existsSync21(settingsPath) && (() => {
+    try {
+      const raw = readFileSync17(settingsPath, "utf8");
+      return raw.includes("exe-os") || raw.includes("exe-mem");
+    } catch {
+      return false;
+    }
+  })();
+  if (hasClaudeCode) {
+    console.log(`
+\x1B[1mexe-os\x1B[0m \u2014 AI Employee Operating System
+
+\x1B[33mMode 1 detected:\x1B[0m Claude Code integration is installed.
+Open Claude Code and run \x1B[1m/exe\x1B[0m to boot your COO.
+
+\x1B[2mCommands:\x1B[0m
+  exe-os update          Check for and install updates
+  exe-os setup           Re-run setup wizard
+  exe-os claude check    Verify Claude Code integration
+  exe-os tui             Launch TUI dashboard (Mode 2)
+  exe-os --help          Show all commands
+`);
+  } else {
+    checkForUpdateOnBoot().catch(() => {
+    });
+    await init_App2().then(() => App_exports);
+  }
 }
 async function runClaudeInstall() {
   const { runInstaller: runInstaller2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));

package/dist/bin/install.js

@@ -672,8 +672,8 @@ function summarizeSymlinkResults(results) {
 }
 
 // src/bin/install.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync, openSync, closeSync } from "fs";
-import { spawn } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync, readdirSync, openSync, closeSync } from "fs";
+import { spawn, execSync as execSync2 } from "child_process";
 import path5 from "path";
 import { homedir } from "os";
 var EXE_DIR = path5.join(homedir(), ".exe-os");
@@ -685,7 +685,7 @@ function restartDaemon() {
       const pid = parseInt(readFileSync4(pidPath, "utf8").trim(), 10);
       if (!isNaN(pid) && pid > 0) {
         try {
-          process.kill(pid, "SIGTERM");
+          process.kill(pid, "SIGKILL");
         } catch {
         }
       }
@@ -694,10 +694,54 @@ function restartDaemon() {
       } catch {
       }
     }
+    try {
+      const pids = execSync2("pgrep -f 'exe-daemon.js' 2>/dev/null || true", { encoding: "utf8" }).trim().split("\n").filter(Boolean).map(Number).filter((n) => !isNaN(n) && n !== process.pid);
+      for (const pid of pids) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+      if (pids.length > 0) {
+        process.stderr.write(`exe-os: killed ${pids.length} orphaned daemon(s)
+`);
+      }
+    } catch {
+    }
+    try {
+      const pids = execSync2("pgrep -f 'backfill-vectors.js' 2>/dev/null || true", { encoding: "utf8" }).trim().split("\n").filter(Boolean).map(Number).filter((n) => !isNaN(n) && n !== process.pid);
+      for (const pid of pids) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+      if (pids.length > 0) {
+        process.stderr.write(`exe-os: killed ${pids.length} orphaned backfill worker(s)
+`);
+      }
+    } catch {
+    }
+    try {
+      const wpDir = path5.join(EXE_DIR, "worker-pids");
+      if (existsSync5(wpDir)) {
+        for (const f of readdirSync(wpDir)) {
+          try {
+            unlinkSync(path5.join(wpDir, f));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
     try {
       unlinkSync(sockPath);
     } catch {
     }
+    try {
+      execSync2("sleep 0.5");
+    } catch {
+    }
   } catch {
   }
   try {

package/dist/bin/update.js

@@ -1,4 +1,471 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { readFileSync as readFileSync2, existsSync, renameSync } from "fs";
+import path2 from "path";
+import os from "os";
+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;
+  const newDir = path2.join(os.homedir(), ".exe-os");
+  const legacyDir = path2.join(os.homedir(), ".exe-mem");
+  if (!existsSync(newDir) && existsSync(legacyDir)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    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");
+    CURRENT_CONFIG_VERSION = 1;
+    DEFAULT_CONFIG = {
+      config_version: CURRENT_CONFIG_VERSION,
+      dbPath: DB_PATH,
+      modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+      embeddingDim: 1024,
+      batchSize: 20,
+      flushIntervalMs: 1e4,
+      autoIngestion: true,
+      autoRetrieval: true,
+      searchMode: "hybrid",
+      hookSearchMode: "hybrid",
+      fileGrepEnabled: true,
+      splashEffect: true,
+      consolidationEnabled: true,
+      consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+      consolidationModel: "claude-haiku-4-5-20251001",
+      consolidationMaxCallsPerRun: 20,
+      selfQueryRouter: true,
+      selfQueryModel: "claude-haiku-4-5-20251001",
+      rerankerEnabled: true,
+      scalingRoadmap: {
+        rerankerAutoTrigger: {
+          enabled: true,
+          broadQueryMinCardinality: 5e4,
+          fetchTopK: 150,
+          returnTopK: 5
+        }
+      },
+      graphRagEnabled: true,
+      wikiEnabled: false,
+      wikiUrl: "",
+      wikiApiKey: "",
+      wikiSyncIntervalMs: 30 * 60 * 1e3,
+      wikiWorkspaceMapping: {
+        exe: "Executive",
+        yoshi: "Engineering",
+        mari: "Marketing",
+        tom: "Engineering",
+        sasha: "Production"
+      },
+      wikiAutoUpdate: true,
+      wikiAutoUpdateThreshold: 0.5,
+      wikiAutoUpdateCreateNew: true,
+      skillLearning: true,
+      skillThreshold: 3,
+      skillModel: "claude-haiku-4-5-20251001",
+      exeHeartbeat: {
+        enabled: true,
+        intervalSeconds: 60,
+        staleInProgressThresholdHours: 2
+      },
+      sessionLifecycle: {
+        idleKillEnabled: true,
+        idleKillTicksRequired: 3,
+        idleKillIntercomAckWindowMs: 1e4,
+        maxAutoInstances: 10
+      },
+      autoUpdate: {
+        checkOnBoot: true,
+        autoInstall: false,
+        checkIntervalMs: 24 * 60 * 60 * 1e3
+      }
+    };
+  }
+});
+
+// src/lib/license.ts
+var license_exports = {};
+__export(license_exports, {
+  LICENSE_PUBLIC_KEY_PEM: () => LICENSE_PUBLIC_KEY_PEM,
+  PLAN_LIMITS: () => PLAN_LIMITS,
+  assertVpsLicense: () => assertVpsLicense,
+  checkLicense: () => checkLicense,
+  getCachedLicense: () => getCachedLicense,
+  isFeatureAllowed: () => isFeatureAllowed,
+  loadDeviceId: () => loadDeviceId,
+  loadLicense: () => loadLicense,
+  mirrorLicenseKey: () => mirrorLicenseKey,
+  saveLicense: () => saveLicense,
+  startLicenseRevalidation: () => startLicenseRevalidation,
+  stopLicenseRevalidation: () => stopLicenseRevalidation,
+  validateLicense: () => validateLicense
+});
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
+import path3 from "path";
+import { jwtVerify, importSPKI } from "jose";
+async function fetchRetry(url, init) {
+  try {
+    return await fetch(url, init);
+  } catch {
+    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+    return fetch(url, { ...init, signal: AbortSignal.timeout(1e4) });
+  }
+}
+function loadDeviceId() {
+  const deviceJsonPath = path3.join(EXE_AI_DIR, "device.json");
+  try {
+    if (existsSync2(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync3(deviceJsonPath, "utf8"));
+      if (data.deviceId) return data.deviceId;
+    }
+  } catch {
+  }
+  try {
+    if (existsSync2(DEVICE_ID_PATH)) {
+      const id2 = readFileSync3(DEVICE_ID_PATH, "utf8").trim();
+      if (id2) return id2;
+    }
+  } catch {
+  }
+  const id = randomUUID();
+  mkdirSync(EXE_AI_DIR, { recursive: true });
+  writeFileSync(DEVICE_ID_PATH, id, "utf8");
+  return id;
+}
+function loadLicense() {
+  try {
+    if (!existsSync2(LICENSE_PATH)) return null;
+    return readFileSync3(LICENSE_PATH, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+function saveLicense(apiKey) {
+  mkdirSync(EXE_AI_DIR, { recursive: true });
+  writeFileSync(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+}
+async function verifyLicenseJwt(token) {
+  try {
+    const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
+    const { payload } = await jwtVerify(token, key, {
+      algorithms: [LICENSE_JWT_ALG]
+    });
+    const plan = payload.plan ?? "free";
+    const email = payload.sub ?? "";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email,
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return null;
+  }
+}
+async function getCachedLicense() {
+  try {
+    if (!existsSync2(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);
+  } catch {
+    return null;
+  }
+}
+function readCachedToken() {
+  try {
+    if (!existsSync2(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
+    return typeof raw.token === "string" ? raw.token : null;
+  } catch {
+    return null;
+  }
+}
+function cacheResponse(token) {
+  try {
+    writeFileSync(CACHE_PATH, JSON.stringify({ token }), "utf8");
+  } catch {
+  }
+}
+async function validateLicense(apiKey, deviceId) {
+  const did = deviceId ?? loadDeviceId();
+  try {
+    const res = await fetchRetry(`${API_BASE}/auth/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey, deviceId: did }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      if (data.error === "device_limit_exceeded") {
+        const cached2 = await getCachedLicense();
+        if (cached2) return cached2;
+        return { ...FREE_LICENSE, valid: false, plan: "free" };
+      }
+      if (data.token) {
+        cacheResponse(data.token);
+        const verified = await verifyLicenseJwt(data.token);
+        if (verified) return verified;
+      }
+      const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
+      return {
+        valid: data.valid,
+        plan: data.plan,
+        email: data.email,
+        expiresAt: data.expiresAt,
+        deviceLimit: limits.devices,
+        employeeLimit: limits.employees,
+        memoryLimit: limits.memories
+      };
+    }
+    const cached = await getCachedLicense();
+    if (cached) return cached;
+    return { ...FREE_LICENSE, valid: false, plan: "free" };
+  } catch {
+    const cached = await getCachedLicense();
+    if (cached) return cached;
+    return { ...FREE_LICENSE, valid: false, error: "offline" };
+  }
+}
+function getCacheAgeMs() {
+  try {
+    const { statSync } = __require("fs");
+    const s = statSync(CACHE_PATH);
+    return Date.now() - s.mtimeMs;
+  } catch {
+    return Infinity;
+  }
+}
+async function checkLicense() {
+  let key = loadLicense();
+  if (!key) {
+    try {
+      const configPath = path3.join(EXE_AI_DIR, "config.json");
+      if (existsSync2(configPath)) {
+        const raw = JSON.parse(readFileSync3(configPath, "utf8"));
+        const cloud = raw.cloud;
+        if (cloud?.apiKey) {
+          key = cloud.apiKey;
+          saveLicense(key);
+        }
+      }
+    } catch {
+    }
+  }
+  if (!key) return FREE_LICENSE;
+  const cached = await getCachedLicense();
+  if (cached && getCacheAgeMs() < CACHE_MAX_AGE_MS) return cached;
+  const deviceId = loadDeviceId();
+  return validateLicense(key, deviceId);
+}
+function isFeatureAllowed(license, feature) {
+  switch (feature) {
+    case "cloud_sync":
+    case "external_agents":
+    case "wiki":
+      return license.plan !== "free";
+    case "unlimited_employees":
+      return license.plan === "team" || license.plan === "agency" || license.plan === "enterprise";
+  }
+}
+function mirrorLicenseKey(apiKey) {
+  const trimmed = apiKey.trim();
+  if (!trimmed) return;
+  saveLicense(trimmed);
+}
+async function assertVpsLicense(opts) {
+  const env = opts?.env ?? process.env;
+  const inProduction = env.NODE_ENV === "production";
+  if (!opts?.force && !inProduction) {
+    return { ...FREE_LICENSE, plan: "free" };
+  }
+  const envKey = env.EXE_LICENSE_KEY?.trim();
+  if (envKey) {
+    saveLicense(envKey);
+  }
+  const apiKey = envKey ?? loadLicense();
+  if (!apiKey) {
+    throw new Error(
+      "License required: set EXE_LICENSE_KEY env var with your exe_sk_* key. Purchase at https://askexe.com. This VPS image refuses to boot without a valid license."
+    );
+  }
+  const deviceId = loadDeviceId();
+  let backendResponse = null;
+  let explicitRejection = false;
+  let transientFailure = false;
+  try {
+    const res = await fetchRetry(`${API_BASE}/auth/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey, deviceId }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.ok) {
+      backendResponse = await res.json();
+      if (!backendResponse.valid) explicitRejection = true;
+    } else if (res.status === 401 || res.status === 403) {
+      explicitRejection = true;
+    } else {
+      transientFailure = true;
+    }
+  } catch {
+    transientFailure = true;
+  }
+  if (backendResponse?.valid) {
+    if (backendResponse.token) {
+      cacheResponse(backendResponse.token);
+      const verified = await verifyLicenseJwt(backendResponse.token);
+      if (verified) return verified;
+    }
+    const limits = PLAN_LIMITS[backendResponse.plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan: backendResponse.plan,
+      email: backendResponse.email,
+      expiresAt: backendResponse.expiresAt,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  }
+  if (explicitRejection) {
+    throw new Error(
+      `License invalid or expired. Renew at https://askexe.com, then restart. Backend rejected key ending in ...${apiKey.slice(-4)}.`
+    );
+  }
+  if (!transientFailure) {
+    throw new Error(
+      "License validation failed: unknown backend state. Restore network connectivity to https://askexe.com/cloud and retry."
+    );
+  }
+  const fresh = await getCachedLicense();
+  if (fresh && fresh.valid) return fresh;
+  const graceDays = opts?.offlineGraceDays ?? 7;
+  const graceMs = graceDays * 24 * 60 * 60 * 1e3;
+  try {
+    const token = readCachedToken();
+    if (token) {
+      const payloadB64 = token.split(".")[1];
+      if (payloadB64) {
+        const payload = JSON.parse(Buffer.from(payloadB64, "base64url").toString());
+        const expMs = (payload.exp ?? 0) * 1e3;
+        if (Date.now() < expMs + graceMs) {
+          const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
+          const { payload: verified } = await jwtVerify(token, key, {
+            algorithms: [LICENSE_JWT_ALG],
+            clockTolerance: graceDays * 24 * 60 * 60
+          });
+          const plan = verified.plan ?? "free";
+          const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+          return {
+            valid: true,
+            plan,
+            email: verified.sub ?? "",
+            expiresAt: verified.exp ? new Date(verified.exp * 1e3).toISOString() : null,
+            deviceLimit: limits.devices,
+            employeeLimit: limits.employees,
+            memoryLimit: limits.memories
+          };
+        }
+      }
+    }
+  } catch {
+  }
+  throw new Error(
+    `License validation unreachable for more than ${graceDays} days. Restore network connectivity to https://askexe.com/cloud and retry. This VPS image refuses to boot after the offline grace window.`
+  );
+}
+function startLicenseRevalidation(intervalMs = 36e5) {
+  if (_revalTimer) return;
+  _revalTimer = setInterval(async () => {
+    try {
+      const license = await checkLicense();
+      if (!license.valid) {
+        process.stderr.write("[exe-os] License expired or invalid \u2014 features may be restricted\n");
+      }
+    } catch {
+    }
+  }, intervalMs);
+  if (_revalTimer && typeof _revalTimer === "object" && "unref" in _revalTimer) {
+    _revalTimer.unref();
+  }
+}
+function stopLicenseRevalidation() {
+  if (_revalTimer) {
+    clearInterval(_revalTimer);
+    _revalTimer = null;
+  }
+}
+var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, RETRY_DELAY_MS, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE, CACHE_MAX_AGE_MS, _revalTimer;
+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");
+    API_BASE = "https://askexe.com/cloud";
+    RETRY_DELAY_MS = 500;
+    LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
+4uj+UqeKCcvtgNHKmOK278HJaJcANe9xAeji8AFYu27q3WtzCi04pHudow==
+-----END PUBLIC KEY-----`;
+    LICENSE_JWT_ALG = "ES256";
+    PLAN_LIMITS = {
+      free: { devices: 1, employees: 1, memories: 5e3 },
+      pro: { devices: 2, employees: 5, memories: 1e5 },
+      team: { devices: 10, employees: 20, memories: 1e6 },
+      agency: { devices: 50, employees: 100, memories: 1e7 },
+      enterprise: { devices: -1, employees: -1, memories: -1 }
+    };
+    FREE_LICENSE = {
+      valid: true,
+      plan: "free",
+      email: "",
+      expiresAt: null,
+      deviceLimit: 1,
+      employeeLimit: 1,
+      memoryLimit: 5e3
+    };
+    CACHE_MAX_AGE_MS = 36e5;
+    _revalTimer = null;
+  }
+});
 
 // src/bin/update.ts
 import { execSync as execSync2 } from "child_process";
@@ -140,6 +607,24 @@ async function runUpdate(cliArgs) {
     console.log("   Try: npm cache clean --force && npm install -g @askexenow/exe-os@latest");
   }
   console.log("   Hooks re-wired, daemon restarted automatically.");
+  try {
+    const { existsSync: exists, readFileSync: readFile2 } = 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 cloud = cfg.cloud;
+      if (cloud?.apiKey) {
+        const { mirrorLicenseKey: mirrorLicenseKey2 } = await Promise.resolve().then(() => (init_license(), license_exports));
+        mirrorLicenseKey2(cloud.apiKey);
+        console.log("   \u{1F511} License key restored from cloud config.");
+      }
+    }
+  } catch {
+  }
   console.log("\n\u{1F680} Ready. Start your COO session to use the new version.\n");
 }
 if (isMainModule(import.meta.url)) {