@letta-ai/dreams 0.0.1 → 0.0.3

package/dist/managed-install.js

@@ -33,30 +33,21 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stableCliPath = stableCliPath;
+exports.stableCliPath = void 0;
 exports.ensureManagedInstall = ensureManagedInstall;
 const node_child_process_1 = require("node:child_process");
 const crypto = __importStar(require("node:crypto"));
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const launcher_1 = require("./launcher");
 const store_1 = require("./store");
 const version_1 = require("./version");
+var launcher_2 = require("./launcher");
+Object.defineProperty(exports, "stableCliPath", { enumerable: true, get: function () { return launcher_2.stableCliPath; } });
 const PACKAGE_NAME = "@letta-ai/dreams";
-function stableCliPath(platform = process.platform) {
-    return path.join((0, store_1.dreamsDir)(), "bin", platform === "win32" ? "dreams.cmd" : "dreams");
-}
 function versionDirectory(version) {
     return path.join((0, store_1.dreamsDir)(), "cli", version);
 }
-function installedBin(version) {
-    return path.join(versionDirectory(version), "package", "bin", "dreams.cjs");
-}
-function completeMarker(version) {
-    return path.join(versionDirectory(version), ".complete");
-}
-function installationComplete(version) {
-    return fs.existsSync(installedBin(version)) && fs.existsSync(completeMarker(version));
-}
 function npmCommand(platform) {
     return platform === "win32" ? "npm.cmd" : "npm";
 }
@@ -82,11 +73,11 @@ function defaultInstallPackage(directory, _packageSpec) {
 function shellQuote(value) {
     return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
-function launcherContent(platform, nodePath, binPath) {
+function launcherContent(platform, nodePath, controllerPath) {
     if (platform === "win32") {
-        return `@echo off\r\n"${nodePath}" "${binPath}" %*\r\n`;
+        return `@echo off\r\n"${nodePath}" "${controllerPath}" %*\r\n`;
     }
-    return `#!/bin/sh\nexec ${shellQuote(nodePath)} ${shellQuote(binPath)} "$@"\n`;
+    return `#!/bin/sh\nexec ${shellQuote(nodePath)} ${shellQuote(controllerPath)} "$@"\n`;
 }
 function writeAtomic(file, contents, mode) {
     try {
@@ -97,7 +88,7 @@ function writeAtomic(file, contents, mode) {
         }
     }
     catch {
-        // Missing or unreadable launcher: replace it below.
+        // Missing or unreadable file: replace it below.
     }
     fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
     const temporary = `${file}.tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`;
@@ -111,90 +102,87 @@ function writeAtomic(file, contents, mode) {
         fs.rmSync(temporary, { force: true });
     }
 }
-function waitForInstallLock() {
-    const lock = path.join((0, store_1.dreamsDir)(), "install.lock");
-    const sleeper = new Int32Array(new SharedArrayBuffer(4));
-    const deadline = Date.now() + 30_000;
-    while (true) {
+function installVersionLocked(version, installPackage) {
+    if ((0, launcher_1.installationComplete)(version))
+        return false;
+    const target = versionDirectory(version);
+    const nonce = `${process.pid}-${crypto.randomBytes(4).toString("hex")}`;
+    const staging = `${target}.tmp-${nonce}`;
+    const replaced = `${target}.replaced-${nonce}`;
+    fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+    fs.mkdirSync(staging, { recursive: true, mode: 0o700 });
+    try {
+        installPackage(staging, `${PACKAGE_NAME}@${version}`);
+        const stagedBin = path.join(staging, "package", "bin", "dreams.cjs");
+        if (!fs.existsSync(stagedBin)) {
+            throw new Error(`Durable Dreams CLI install did not contain ${PACKAGE_NAME}/bin/dreams.cjs`);
+        }
+        fs.writeFileSync(path.join(staging, ".complete"), JSON.stringify({ package: PACKAGE_NAME, version, installed_at: new Date().toISOString() }) + "\n");
+        if (fs.existsSync(target))
+            fs.renameSync(target, replaced);
         try {
-            const descriptor = fs.openSync(lock, "wx", 0o600);
-            fs.writeFileSync(descriptor, `${process.pid}\n${new Date().toISOString()}\n`);
-            return () => {
-                fs.closeSync(descriptor);
-                fs.rmSync(lock, { force: true });
-            };
+            fs.renameSync(staging, target);
         }
         catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            try {
-                const age = Date.now() - fs.statSync(lock).mtimeMs;
-                if (age > 5 * 60_000) {
-                    fs.rmSync(lock, { force: true });
-                    continue;
-                }
-            }
-            catch {
-                continue;
-            }
-            if (Date.now() >= deadline) {
-                throw new Error("Timed out waiting for another Dreams CLI installation to finish.");
-            }
-            Atomics.wait(sleeper, 0, 0, 100);
+            if (fs.existsSync(replaced) && !fs.existsSync(target))
+                fs.renameSync(replaced, target);
+            throw error;
         }
+        fs.rmSync(replaced, { recursive: true, force: true });
+        return true;
+    }
+    finally {
+        fs.rmSync(staging, { recursive: true, force: true });
+        fs.rmSync(replaced, { recursive: true, force: true });
     }
 }
-function installVersion(version, installPackage) {
-    if (installationComplete(version))
-        return false;
-    const releaseLock = waitForInstallLock();
+function detectLegacyActiveVersion() {
+    if ((0, launcher_1.readActivation)())
+        return null;
+    let launcher;
     try {
-        if (installationComplete(version))
-            return false;
-        const target = versionDirectory(version);
-        const nonce = `${process.pid}-${crypto.randomBytes(4).toString("hex")}`;
-        const staging = `${target}.tmp-${nonce}`;
-        const replaced = `${target}.replaced-${nonce}`;
-        fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
-        fs.mkdirSync(staging, { recursive: true, mode: 0o700 });
-        try {
-            installPackage(staging, `${PACKAGE_NAME}@${version}`);
-            const stagedBin = path.join(staging, "package", "bin", "dreams.cjs");
-            if (!fs.existsSync(stagedBin)) {
-                throw new Error(`Durable Dreams CLI install did not contain ${PACKAGE_NAME}/bin/dreams.cjs`);
-            }
-            fs.writeFileSync(path.join(staging, ".complete"), JSON.stringify({ package: PACKAGE_NAME, version, installed_at: new Date().toISOString() }) + "\n");
-            if (fs.existsSync(target))
-                fs.renameSync(target, replaced);
-            try {
-                fs.renameSync(staging, target);
-            }
-            catch (error) {
-                if (fs.existsSync(replaced) && !fs.existsSync(target))
-                    fs.renameSync(replaced, target);
-                throw error;
-            }
-            fs.rmSync(replaced, { recursive: true, force: true });
-            return true;
-        }
-        finally {
-            fs.rmSync(staging, { recursive: true, force: true });
-            fs.rmSync(replaced, { recursive: true, force: true });
-        }
+        launcher = fs.readFileSync((0, launcher_1.stableCliPath)(), "utf8");
     }
-    finally {
-        releaseLock();
+    catch {
+        return null;
+    }
+    const cliDirectory = path.join((0, store_1.dreamsDir)(), "cli");
+    let entries;
+    try {
+        entries = fs.readdirSync(cliDirectory, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory() && (0, launcher_1.installationComplete)(entry.name) && launcher.includes((0, launcher_1.installedBin)(entry.name))) {
+            return entry.name;
+        }
     }
+    return null;
+}
+function launcherControllerSource() {
+    return path.join(__dirname, "..", "dist", "launcher.js");
 }
 function ensureManagedInstall(options = {}) {
     (0, store_1.secureDreamsDir)();
     if (process.env.DREAMS_SKIP_MANAGED_INSTALL === "1") {
-        return { cli_path: stableCliPath(options.platform), status: "skipped" };
+        return { cli_path: (0, launcher_1.stableCliPath)(options.platform), status: "skipped" };
     }
     const version = options.version ?? (0, version_1.packageVersion)();
     const platform = options.platform ?? process.platform;
-    const changed = installVersion(version, options.installPackage ?? defaultInstallPackage);
-    const cliPath = stableCliPath(platform);
-    writeAtomic(cliPath, launcherContent(platform, options.nodePath ?? process.execPath, installedBin(version)), platform === "win32" ? 0o600 : 0o700);
+    const cliPath = (0, launcher_1.stableCliPath)(platform);
+    let changed = false;
+    (0, launcher_1.withInstallLock)(() => {
+        const legacyActiveVersion = detectLegacyActiveVersion();
+        changed = installVersionLocked(version, options.installPackage ?? defaultInstallPackage);
+        const controllerSource = launcherControllerSource();
+        if (!fs.existsSync(controllerSource)) {
+            throw new Error(`Dreams launcher controller is missing at ${controllerSource}`);
+        }
+        writeAtomic((0, launcher_1.stableLauncherControllerPath)(), fs.readFileSync(controllerSource, "utf8"), 0o600);
+        (0, launcher_1.activateVersionLocked)(version, legacyActiveVersion);
+        writeAtomic(cliPath, launcherContent(platform, options.nodePath ?? process.execPath, (0, launcher_1.stableLauncherControllerPath)()), platform === "win32" ? 0o600 : 0o700);
+    });
     return { cli_path: cliPath, status: changed ? "installed" : "unchanged" };
 }

package/dist/onboard.js

@@ -1,100 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandOnboard = commandOnboard;
-const index_1 = require("./auth/index");
 const db_1 = require("./local/db");
+const state_lock_1 = require("./local/state-lock");
 const managed_install_1 = require("./managed-install");
 const skill_1 = require("./skill");
 const store_1 = require("./store");
 const version_1 = require("./version");
-const LOCAL_SETUP = [
-    "cli_installed",
-    "installation_initialized",
-    "skill_installed",
-    "local_state_initialized",
-];
-function command(cliPath, args) {
-    return `${JSON.stringify(cliPath)} ${args}`;
-}
-function awaitingAuthEnvelope(cliPath, completed) {
-    const loginCommand = command(cliPath, "auth login --json");
-    const resumeCommand = command(cliPath, "onboard --json");
+function readyEnvelope(cliPath) {
     return {
         schema_version: 1,
-        state: "awaiting_auth",
-        completed,
+        status: "ready",
         cli_path: cliPath,
-        next_action: { kind: "run_command", command: loginCommand },
-        agent_instructions: `Run ${loginCommand} and wait for the user to authorize in the browser. ` +
-            `After login succeeds, run ${resumeCommand} to continue setup.`,
-        ui: { milestone: "authentication" },
-        done: false,
-    };
-}
-function orientReadyEnvelope(cliPath, completed) {
-    const orientCommand = command(cliPath, "orient --json");
-    return {
-        schema_version: 1,
-        state: "ready_for_orient",
-        completed,
-        cli_path: cliPath,
-        next_action: { kind: "run_command", command: orientCommand },
-        agent_instructions: `Dreams is installed and authenticated. Run ${orientCommand} to begin orient.`,
-        ui: { milestone: "orient" },
-        done: false,
+        skill: {
+            name: "dreams-setup",
+            path: (0, skill_1.skillFilePath)(),
+            version: (0, version_1.packageVersion)(),
+        },
+        message: "Continue setup using the installed Dreams setup skill. Start at step 1 (Authenticate).",
     };
 }
-function errorEnvelope(cliPath, completed, retryCommand, error) {
+function errorEnvelope(cliPath, error) {
     return {
         schema_version: 1,
-        state: "error",
-        completed,
+        status: "error",
         cli_path: cliPath,
-        next_action: {
-            kind: "run_command",
-            command: retryCommand,
-        },
         error: { message: error instanceof Error ? error.message : String(error) },
-        done: false,
     };
 }
 function renderEnvelope(envelope) {
     return [
         "Dreams setup",
         "",
-        `  State:          ${envelope.state}`,
-        `  Durable CLI:    ${envelope.cli_path}`,
-        `  Local database: ${(0, db_1.dbFilePath)()}`,
-        `  Next command:   ${envelope.next_action.command}`,
+        `  Status:       ${envelope.status}`,
+        `  Durable CLI:  ${envelope.cli_path}`,
+        `  Setup skill:  ${envelope.skill.path}`,
+        `  Skill dir:    ${(0, skill_1.skillDir)()}`,
         "",
-        envelope.agent_instructions,
+        envelope.message,
     ].join("\n");
 }
-async function isAuthenticated() {
-    try {
-        await (0, index_1.resolveAccessToken)();
-        return true;
-    }
-    catch (error) {
-        if (error instanceof index_1.NotAuthenticatedError)
-            return false;
-        throw error;
-    }
-}
 async function commandOnboard(json) {
-    const completed = [];
     let cliPath = (0, managed_install_1.stableCliPath)();
+    let stateLock = null;
     try {
+        stateLock = (0, state_lock_1.acquireLocalStateLock)();
+        if (stateLock === null)
+            throw new Error("Another Dreams command is using local state. Try again after it finishes.");
         const managedInstall = (0, managed_install_1.ensureManagedInstall)();
         cliPath = managedInstall.cli_path;
-        completed.push("cli_installed");
         if (managedInstall.status === "installed") {
             process.stderr.write(`Installed durable Dreams CLI at ${cliPath}\n`);
         }
         const installation = (0, store_1.loadOrCreateInstallation)();
-        completed.push("installation_initialized");
         const skill = (0, skill_1.installSkill)();
-        completed.push("skill_installed");
         if (skill !== "unchanged") {
             process.stderr.write(`${skill === "installed" ? "Installed" : "Updated"} setup skill v${(0, version_1.packageVersion)()} at ${(0, skill_1.skillFilePath)()}\n`);
         }
@@ -107,25 +66,20 @@ async function commandOnboard(json) {
         finally {
             (0, db_1.closeDb)();
         }
-        completed.push("local_state_initialized");
-        const authenticated = await isAuthenticated();
-        if (authenticated)
-            completed.push("authenticated");
-        const envelope = authenticated
-            ? orientReadyEnvelope(cliPath, completed)
-            : awaitingAuthEnvelope(cliPath, completed);
+        const envelope = readyEnvelope(cliPath);
         console.log(json ? JSON.stringify(envelope, null, 2) : renderEnvelope(envelope));
         return 0;
     }
     catch (error) {
-        const retryCommand = completed.includes("cli_installed")
-            ? command(cliPath, `onboard${json ? " --json" : ""}`)
-            : `npx @letta-ai/dreams@latest onboard${json ? " --json" : ""}`;
-        const envelope = errorEnvelope(cliPath, completed, retryCommand, error);
+        const envelope = errorEnvelope(cliPath, error);
         if (json)
             console.log(JSON.stringify(envelope, null, 2));
         else
             process.stderr.write(`Dreams setup failed: ${envelope.error.message}\n`);
         return 1;
     }
+    finally {
+        if (stateLock !== null)
+            (0, state_lock_1.releaseLocalStateLock)(stateLock);
+    }
 }