@letta-ai/dreams 0.0.1 → 0.0.3

package/dist/development-reset.js

@@ -0,0 +1,359 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandDevelopmentReset = commandDevelopmentReset;
+const node_sqlite_1 = require("node:sqlite");
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const credentials_1 = require("./auth/credentials");
+const blobs_1 = require("./local/blobs");
+const db_1 = require("./local/db");
+const leases_1 = require("./local/leases");
+const state_lock_1 = require("./local/state-lock");
+const store_1 = require("./store");
+const PRESERVED_LOCAL = [
+    "stored credentials",
+    "installation identity",
+    "installed CLI versions and activation",
+    "stable launcher",
+    "setup skill",
+    "Cloud workspace and all Cloud data",
+];
+const PRESERVED_IDENTITY = [
+    "installed CLI versions and activation",
+    "stable launcher",
+    "setup skill",
+    "Cloud workspace and all Cloud data",
+];
+function localStatePaths() {
+    const database = (0, db_1.dbFilePath)();
+    return [database, `${database}-wal`, `${database}-shm`, (0, blobs_1.blobsDir)()];
+}
+function resetPaths(scope) {
+    return scope === "local"
+        ? localStatePaths()
+        : [...localStatePaths(), (0, credentials_1.credentialsFilePath)(), (0, store_1.installationFilePath)()];
+}
+function preserved(scope) {
+    return scope === "local" ? PRESERVED_LOCAL : PRESERVED_IDENTITY;
+}
+function assertPathIsLocal(file) {
+    const root = path.resolve((0, store_1.dreamsDir)());
+    const resolved = path.resolve(file);
+    if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+        throw new Error(`Refusing to reset path outside ${root}: ${resolved}`);
+    }
+}
+function acquireLegacySourceLease() {
+    const database = (0, db_1.dbFilePath)();
+    if (!fs.existsSync(database) || fs.lstatSync(database).isSymbolicLink())
+        return null;
+    let db = null;
+    try {
+        db = new node_sqlite_1.DatabaseSync(database);
+        db.exec("PRAGMA busy_timeout = 0; BEGIN IMMEDIATE");
+        const table = db
+            .prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'leases'")
+            .get();
+        if (table) {
+            const active = db
+                .prepare("SELECT 1 AS active FROM leases WHERE name = ? AND expires_at > ?")
+                .get(leases_1.SOURCE_LEASE, Date.now());
+            if (active)
+                throw new Error("active source operation");
+        }
+        return { db, owner: `development-reset-${process.pid}`, canPublish: table !== undefined };
+    }
+    catch (error) {
+        try {
+            db?.exec("ROLLBACK");
+        }
+        catch {
+            // No transaction was opened.
+        }
+        try {
+            db?.close();
+        }
+        catch {
+            // Reset can still remove a corrupt database after the connection closes.
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        if (/busy|locked|active source operation/i.test(message)) {
+            throw new Error("Local Dreams state is busy. Wait for the active source operation to finish.");
+        }
+        return null;
+    }
+}
+function releaseLegacySourceLease(lease) {
+    try {
+        lease.db.exec("ROLLBACK");
+    }
+    finally {
+        lease.db.close();
+    }
+}
+function publishLegacyResetLeaseAndClose(lease) {
+    if (!lease.canPublish) {
+        releaseLegacySourceLease(lease);
+        return;
+    }
+    const now = Date.now();
+    try {
+        lease.db.prepare("INSERT INTO leases (name, owner, acquired_at, expires_at) VALUES (?, ?, ?, ?) " +
+            "ON CONFLICT(name) DO UPDATE SET owner = excluded.owner, acquired_at = excluded.acquired_at, expires_at = excluded.expires_at").run(leases_1.SOURCE_LEASE, lease.owner, now, now + 60_000);
+        lease.db.exec("COMMIT");
+        const checkpoint = lease.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+        if (checkpoint.busy !== 0)
+            throw new Error("Could not checkpoint local state before reset");
+    }
+    finally {
+        lease.db.close();
+    }
+}
+function stagePath(file, stagingDirectory, staged) {
+    if (!fs.existsSync(file))
+        return;
+    const destination = path.join(stagingDirectory, `${String(staged.length).padStart(2, "0")}-${path.basename(file)}`);
+    fs.renameSync(file, destination);
+    staged.push({ source: file, destination });
+}
+function restoreStagedPaths(staged) {
+    for (const item of [...staged].reverse()) {
+        if (!fs.existsSync(item.destination) || fs.existsSync(item.source))
+            continue;
+        fs.renameSync(item.destination, item.source);
+    }
+}
+function recoverAbandonedResets() {
+    const root = (0, store_1.dreamsDir)();
+    const allowed = new Set([
+        path.basename((0, db_1.dbFilePath)()),
+        path.basename((0, db_1.dbFilePath)()) + "-wal",
+        path.basename((0, db_1.dbFilePath)()) + "-shm",
+        path.basename((0, blobs_1.blobsDir)()),
+        path.basename((0, credentials_1.credentialsFilePath)()),
+        path.basename((0, store_1.installationFilePath)()),
+    ]);
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const directory = path.join(root, entry.name);
+        if (entry.name.startsWith(".reset-delete-")) {
+            fs.rmSync(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+            continue;
+        }
+        if (!entry.name.startsWith(".reset-staging-"))
+            continue;
+        const stagedNames = fs.readdirSync(directory).sort().reverse();
+        for (const stagedName of stagedNames) {
+            const basename = stagedName.replace(/^\d+-/, "");
+            if (!allowed.has(basename)) {
+                throw new Error(`Unknown abandoned reset entry at ${path.join(directory, stagedName)}`);
+            }
+            const source = path.join(root, basename);
+            const staged = path.join(directory, stagedName);
+            if (fs.existsSync(source)) {
+                throw new Error(`Cannot recover abandoned reset because both ${source} and ${staged} exist`);
+            }
+            fs.renameSync(staged, source);
+        }
+        fs.rmSync(directory, { recursive: true, force: true });
+    }
+}
+function preview(scope) {
+    return {
+        schema_version: 1,
+        status: "preview",
+        scope,
+        removes: resetPaths(scope),
+        preserves: preserved(scope),
+        stored_credentials: scope === "local"
+            ? "preserved"
+            : process.env.DREAMS_CREDENTIALS_BACKEND === "file"
+                ? "file_cleared_keychain_not_checked_on_confirm"
+                : "cleared_on_confirm",
+        cloud_workspace: "preserved",
+        confirmation_command: `dreams dev reset ${scope} --confirm --json`,
+    };
+}
+function executeLocked(scope, legacyLease) {
+    (0, db_1.closeDb)();
+    const paths = resetPaths(scope);
+    for (const file of paths)
+        assertPathIsLocal(file);
+    const existing = new Set(paths.filter((file) => fs.existsSync(file)));
+    const stagingDirectory = path.join((0, store_1.dreamsDir)(), `.reset-staging-${process.pid}-${crypto.randomUUID()}`);
+    fs.mkdirSync(stagingDirectory, { mode: 0o700 });
+    const staged = [];
+    let storedCredentials = "preserved";
+    let legacyLeaseOpen = legacyLease !== null;
+    let cutoverComplete = false;
+    try {
+        stagePath((0, blobs_1.blobsDir)(), stagingDirectory, staged);
+        if (scope === "identity") {
+            stagePath((0, credentials_1.credentialsFilePath)(), stagingDirectory, staged);
+            stagePath((0, store_1.installationFilePath)(), stagingDirectory, staged);
+            const credentials = (0, credentials_1.clearCredentials)({ strictKeychain: true });
+            storedCredentials =
+                credentials.keychain === "cleared" ? "cleared" : "file_cleared_keychain_not_checked";
+        }
+        if (legacyLease !== null) {
+            publishLegacyResetLeaseAndClose(legacyLease);
+            legacyLeaseOpen = false;
+        }
+        const database = (0, db_1.dbFilePath)();
+        stagePath(`${database}-wal`, stagingDirectory, staged);
+        stagePath(`${database}-shm`, stagingDirectory, staged);
+        stagePath(database, stagingDirectory, staged);
+        const deletionDirectory = stagingDirectory.replace(`${path.sep}.reset-staging-`, `${path.sep}.reset-delete-`);
+        fs.renameSync(stagingDirectory, deletionDirectory);
+        cutoverComplete = true;
+        fs.rmSync(deletionDirectory, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+    }
+    catch (error) {
+        if (legacyLease !== null && legacyLeaseOpen) {
+            try {
+                releaseLegacySourceLease(legacyLease);
+            }
+            catch {
+                // Preserve the original reset failure.
+            }
+        }
+        if (!cutoverComplete) {
+            try {
+                restoreStagedPaths(staged);
+                if (!staged.some((item) => fs.existsSync(item.destination))) {
+                    fs.rmSync(stagingDirectory, { recursive: true, force: true });
+                }
+            }
+            catch {
+                // Preserve the original reset failure and leave staged data for manual recovery.
+            }
+        }
+        throw error;
+    }
+    return {
+        schema_version: 1,
+        status: "completed",
+        scope,
+        removed: paths.filter((file) => existing.has(file)),
+        already_absent: paths.filter((file) => !existing.has(file)),
+        preserves: preserved(scope),
+        stored_credentials: storedCredentials,
+        cloud_workspace: "preserved",
+        environment_api_key_preserved: Boolean(process.env.LETTA_API_KEY),
+    };
+}
+async function execute(scope) {
+    const stateLock = (0, state_lock_1.acquireLocalStateLock)({ allowAbandonedReset: true });
+    if (stateLock === null) {
+        throw new Error("Another Dreams command is using local state. Try again after it finishes.");
+    }
+    try {
+        recoverAbandonedResets();
+        const legacyLease = acquireLegacySourceLease();
+        return executeLocked(scope, legacyLease);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(stateLock);
+    }
+}
+function renderPlan(plan) {
+    return [
+        `Dreams development reset preview (${plan.scope})`,
+        "",
+        "Would remove:",
+        ...plan.removes.map((file) => `  ${file}`),
+        "",
+        "Preserves:",
+        ...plan.preserves.map((item) => `  ${item}`),
+        "",
+        `Stored credentials: ${plan.stored_credentials === "preserved"
+            ? "preserved"
+            : plan.stored_credentials === "cleared_on_confirm"
+                ? "will be cleared from file and OS keychain"
+                : "file credentials will be cleared; OS keychain will not be checked while the file backend is forced"}`,
+        `Run \`${plan.confirmation_command.replace(" --json", "")}\` to confirm.`,
+    ].join("\n");
+}
+function renderCompleted(result) {
+    return [
+        `Dreams development reset complete (${result.scope})`,
+        "",
+        `  Removed:         ${result.removed.length}`,
+        `  Already absent:  ${result.already_absent.length}`,
+        `  Credentials:     ${result.stored_credentials === "preserved"
+            ? "preserved"
+            : result.stored_credentials === "cleared"
+                ? "cleared from file and OS keychain"
+                : "file cleared; OS keychain not checked (file backend forced)"}`,
+        "  Cloud workspace: preserved",
+        ...(result.environment_api_key_preserved
+            ? ["", "LETTA_API_KEY remains set in the environment and was not cleared."]
+            : []),
+    ].join("\n");
+}
+async function commandDevelopmentReset(scope, confirmed, json) {
+    if (scope === "test-workspace") {
+        const message = "Test-workspace cleanup is a separate internal Cloud operation. This local CLI never deletes Cloud data.";
+        if (json)
+            console.log(JSON.stringify({ status: "error", code: "cloud_cleanup_separate", message }));
+        else
+            process.stderr.write(message + "\n");
+        return 1;
+    }
+    if (scope !== "local" && scope !== "identity") {
+        const message = `Unknown development reset scope: ${scope ?? "(none)"}; expected local or identity`;
+        if (json)
+            console.log(JSON.stringify({ status: "error", code: "invalid_scope", message }));
+        else
+            process.stderr.write(message + "\n");
+        return 1;
+    }
+    try {
+        const result = confirmed ? await execute(scope) : preview(scope);
+        console.log(json ? JSON.stringify(result, null, 2) : result.status === "preview" ? renderPlan(result) : renderCompleted(result));
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (json)
+            console.log(JSON.stringify({ status: "error", code: "reset_failed", message }));
+        else
+            process.stderr.write(`Dreams development reset failed: ${message}\n`);
+        return 1;
+    }
+}

package/dist/launcher.js

@@ -0,0 +1,311 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installedBin = installedBin;
+exports.installationComplete = installationComplete;
+exports.activationFilePath = activationFilePath;
+exports.stableLauncherControllerPath = stableLauncherControllerPath;
+exports.stableCliPath = stableCliPath;
+exports.readActivation = readActivation;
+exports.withInstallLock = withInstallLock;
+exports.activateVersionLocked = activateVersionLocked;
+exports.rollbackActivation = rollbackActivation;
+exports.commandRollback = commandRollback;
+exports.signalLauncherReady = signalLauncherReady;
+exports.runLauncher = runLauncher;
+exports.main = main;
+const node_child_process_1 = require("node:child_process");
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const PACKAGE_NAME = "@letta-ai/dreams";
+const READY_FILE_ENV = "DREAMS_LAUNCH_READY_FILE";
+const ACTIVATION_SCHEMA_VERSION = 1;
+function dreamsDir() {
+    return path.join(os.homedir(), ".dreams");
+}
+function versionDirectory(version) {
+    return path.join(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 activationFilePath() {
+    return path.join(dreamsDir(), "cli", "activation.json");
+}
+function stableLauncherControllerPath() {
+    return path.join(dreamsDir(), "bin", "launcher.cjs");
+}
+function stableCliPath(platform = process.platform) {
+    return path.join(dreamsDir(), "bin", platform === "win32" ? "dreams.cmd" : "dreams");
+}
+function readActivation() {
+    try {
+        const value = JSON.parse(fs.readFileSync(activationFilePath(), "utf8"));
+        if (value.schema_version !== ACTIVATION_SCHEMA_VERSION ||
+            typeof value.active_version !== "string" ||
+            (value.previous_version !== null && typeof value.previous_version !== "string") ||
+            typeof value.activated_at !== "string") {
+            return null;
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function writeAtomic(file, contents, mode = 0o600) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`;
+    try {
+        fs.writeFileSync(temporary, contents, { mode });
+        fs.renameSync(temporary, file);
+        if (process.platform !== "win32")
+            fs.chmodSync(file, mode);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+function writeActivation(state) {
+    writeAtomic(activationFilePath(), JSON.stringify(state, null, 2) + "\n");
+}
+function withInstallLock(fn) {
+    fs.mkdirSync(dreamsDir(), { recursive: true, mode: 0o700 });
+    const lock = path.join(dreamsDir(), "install.lock");
+    const sleeper = new Int32Array(new SharedArrayBuffer(4));
+    const deadline = Date.now() + 30_000;
+    let descriptor;
+    while (true) {
+        try {
+            descriptor = fs.openSync(lock, "wx", 0o600);
+            fs.writeFileSync(descriptor, `${process.pid}\n${new Date().toISOString()}\n`);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            try {
+                if (Date.now() - fs.statSync(lock).mtimeMs > 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);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        fs.closeSync(descriptor);
+        fs.rmSync(lock, { force: true });
+    }
+}
+function activateVersionLocked(version, previousHint = null) {
+    if (!installationComplete(version)) {
+        throw new Error(`Cannot activate incomplete Dreams CLI version ${version}.`);
+    }
+    const current = readActivation();
+    if (current?.active_version === version)
+        return current;
+    const previousCandidate = current?.active_version ?? previousHint;
+    const previousVersion = previousCandidate && previousCandidate !== version && installationComplete(previousCandidate)
+        ? previousCandidate
+        : null;
+    const state = {
+        schema_version: ACTIVATION_SCHEMA_VERSION,
+        active_version: version,
+        previous_version: previousVersion,
+        activated_at: new Date().toISOString(),
+    };
+    writeActivation(state);
+    return state;
+}
+function rollbackLocked(reason) {
+    const current = readActivation();
+    if (!current) {
+        return {
+            rolled_back: false,
+            from_version: null,
+            to_version: null,
+            cli_path: stableCliPath(),
+            error: "Dreams CLI activation state is missing or invalid.",
+        };
+    }
+    if (!current.previous_version) {
+        return {
+            rolled_back: false,
+            from_version: current.active_version,
+            to_version: null,
+            cli_path: stableCliPath(),
+            error: "No previous Dreams CLI version is available.",
+        };
+    }
+    if (!installationComplete(current.previous_version)) {
+        return {
+            rolled_back: false,
+            from_version: current.active_version,
+            to_version: current.previous_version,
+            cli_path: stableCliPath(),
+            error: `Previous Dreams CLI version ${current.previous_version} is incomplete.`,
+        };
+    }
+    const now = new Date().toISOString();
+    const result = {
+        rolled_back: true,
+        from_version: current.active_version,
+        to_version: current.previous_version,
+        cli_path: stableCliPath(),
+    };
+    writeActivation({
+        schema_version: ACTIVATION_SCHEMA_VERSION,
+        active_version: current.previous_version,
+        previous_version: null,
+        activated_at: now,
+        last_rollback: {
+            from_version: current.active_version,
+            to_version: current.previous_version,
+            reason,
+            rolled_back_at: now,
+        },
+    });
+    return result;
+}
+function rollbackActivation(reason = "explicit") {
+    return withInstallLock(() => rollbackLocked(reason));
+}
+function recoverStartupFailure(activeVersion, previousVersion) {
+    return withInstallLock(() => {
+        const current = readActivation();
+        if (current?.active_version === previousVersion && installationComplete(previousVersion)) {
+            return {
+                rolled_back: true,
+                from_version: activeVersion,
+                to_version: previousVersion,
+                cli_path: stableCliPath(),
+            };
+        }
+        if (current?.active_version !== activeVersion ||
+            current.previous_version !== previousVersion) {
+            return {
+                rolled_back: false,
+                from_version: current?.active_version ?? null,
+                to_version: current?.previous_version ?? null,
+                cli_path: stableCliPath(),
+                error: "Dreams CLI activation changed while startup recovery was running.",
+            };
+        }
+        return rollbackLocked("startup_failure");
+    });
+}
+function commandRollback(json) {
+    const result = rollbackActivation("explicit");
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (result.rolled_back) {
+        console.log(`Rolled back Dreams CLI from ${result.from_version} to ${result.to_version}.`);
+    }
+    else {
+        process.stderr.write(`Dreams CLI rollback failed: ${result.error}\n`);
+    }
+    return result.rolled_back ? 0 : 1;
+}
+function signalLauncherReady() {
+    const readyFile = process.env[READY_FILE_ENV];
+    if (!readyFile)
+        return;
+    try {
+        fs.writeFileSync(readyFile, `${process.pid}\n`, { flag: "wx", mode: 0o600 });
+    }
+    catch {
+        // The launcher treats a missing marker as a startup failure. Never let a
+        // marker write mask the command the user asked to run.
+    }
+}
+function launchVersion(version, args) {
+    const readyFile = path.join(dreamsDir(), `.launch-ready-${process.pid}-${crypto.randomBytes(4).toString("hex")}`);
+    fs.rmSync(readyFile, { force: true });
+    const result = (0, node_child_process_1.spawnSync)(process.execPath, [installedBin(version), ...args], {
+        stdio: "inherit",
+        env: { ...process.env, [READY_FILE_ENV]: readyFile },
+    });
+    const ready = fs.existsSync(readyFile);
+    fs.rmSync(readyFile, { force: true });
+    return { status: result.status ?? 1, ready };
+}
+function runLauncher(args = process.argv.slice(2)) {
+    if (args[0] === "rollback") {
+        const unknown = args.slice(1).filter((arg) => arg !== "--json");
+        if (unknown.length > 0) {
+            process.stderr.write(`Unexpected argument(s): ${unknown.join(", ")}\n`);
+            return 1;
+        }
+        return commandRollback(args.includes("--json"));
+    }
+    const activation = readActivation();
+    if (!activation || !installationComplete(activation.active_version)) {
+        process.stderr.write(`Dreams CLI activation is missing or invalid. Repair it with \`npx ${PACKAGE_NAME}@latest onboard\`.\n`);
+        return 1;
+    }
+    const first = launchVersion(activation.active_version, args);
+    if (first.status === 0 || first.ready || !activation.previous_version)
+        return first.status;
+    const rollback = recoverStartupFailure(activation.active_version, activation.previous_version);
+    if (!rollback.rolled_back || !rollback.to_version)
+        return first.status;
+    process.stderr.write(`Dreams CLI ${rollback.from_version} failed to start; rolled back to ${rollback.to_version}.\n`);
+    return launchVersion(rollback.to_version, args).status;
+}
+function main() {
+    process.exit(runLauncher());
+}
+if (require.main === module) {
+    main();
+}