@letta-ai/dreams 0.0.1

package/dist/managed-install.js

@@ -0,0 +1,200 @@
+"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.stableCliPath = stableCliPath;
+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 store_1 = require("./store");
+const version_1 = require("./version");
+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";
+}
+function defaultInstallPackage(directory, _packageSpec) {
+    const packageRoot = path.join(__dirname, "..");
+    const packageDirectory = path.join(directory, "package");
+    fs.mkdirSync(packageDirectory, { recursive: true });
+    for (const name of ["bin", "dist"]) {
+        fs.cpSync(path.join(packageRoot, name), path.join(packageDirectory, name), { recursive: true });
+    }
+    fs.copyFileSync(path.join(packageRoot, "package.json"), path.join(packageDirectory, "package.json"));
+    const result = (0, node_child_process_1.spawnSync)(npmCommand(process.platform), ["install", "--prefix", packageDirectory, "--omit=dev", "--no-audit", "--no-fund"], {
+        encoding: "utf8",
+        env: { ...process.env, npm_config_update_notifier: "false" },
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim() || `npm exited ${result.status}`;
+        throw new Error(`Could not install the durable Dreams CLI: ${detail}`);
+    }
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function launcherContent(platform, nodePath, binPath) {
+    if (platform === "win32") {
+        return `@echo off\r\n"${nodePath}" "${binPath}" %*\r\n`;
+    }
+    return `#!/bin/sh\nexec ${shellQuote(nodePath)} ${shellQuote(binPath)} "$@"\n`;
+}
+function writeAtomic(file, contents, mode) {
+    try {
+        if (fs.readFileSync(file, "utf8") === contents) {
+            if (process.platform !== "win32")
+                fs.chmodSync(file, mode);
+            return;
+        }
+    }
+    catch {
+        // Missing or unreadable launcher: replace it below.
+    }
+    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 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) {
+        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 });
+            };
+        }
+        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);
+        }
+    }
+}
+function installVersion(version, installPackage) {
+    if (installationComplete(version))
+        return false;
+    const releaseLock = waitForInstallLock();
+    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 });
+        }
+    }
+    finally {
+        releaseLock();
+    }
+}
+function ensureManagedInstall(options = {}) {
+    (0, store_1.secureDreamsDir)();
+    if (process.env.DREAMS_SKIP_MANAGED_INSTALL === "1") {
+        return { cli_path: 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);
+    return { cli_path: cliPath, status: changed ? "installed" : "unchanged" };
+}

package/dist/onboard.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandOnboard = commandOnboard;
+const index_1 = require("./auth/index");
+const db_1 = require("./local/db");
+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");
+    return {
+        schema_version: 1,
+        state: "awaiting_auth",
+        completed,
+        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,
+    };
+}
+function errorEnvelope(cliPath, completed, retryCommand, error) {
+    return {
+        schema_version: 1,
+        state: "error",
+        completed,
+        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}`,
+        "",
+        envelope.agent_instructions,
+    ].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)();
+    try {
+        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`);
+        }
+        try {
+            (0, db_1.openDb)({
+                installationId: installation.installation_id,
+                installationCreatedAt: installation.created_at,
+            });
+        }
+        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);
+        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);
+        if (json)
+            console.log(JSON.stringify(envelope, null, 2));
+        else
+            process.stderr.write(`Dreams setup failed: ${envelope.error.message}\n`);
+        return 1;
+    }
+}

package/dist/skill.js

@@ -0,0 +1,138 @@
+"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.skillDir = skillDir;
+exports.skillFilePath = skillFilePath;
+exports.installedSkillVersion = installedSkillVersion;
+exports.installSkill = installSkill;
+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 version_1 = require("./version");
+const SKILL_NAME = "dreams-setup";
+const LEGACY_SKILL_NAME = "dreams-onboarding";
+function skillDir() {
+    return path.join(os.homedir(), ".claude", "skills", SKILL_NAME);
+}
+function skillFilePath() {
+    return path.join(skillDir(), "SKILL.md");
+}
+function skillContent(version) {
+    return `---
+name: dreams-setup
+description: Set up Dreams, Letta's shared organizational memory, or continue an interrupted Dreams setup. Use when the user asks to install Dreams, set up Dreams, or connect this device to Dreams.
+version: ${version}
+---
+
+# Dreams setup
+
+Start or repair the local setup with:
+
+\`\`\`bash
+npx @letta-ai/dreams@latest onboard --json
+\`\`\`
+
+\`onboard\` installs an exact CLI version at a stable local path, creates or reuses the installation identity, installs this skill, initializes local SQLite, and checks authentication. It does not log in or run \`orient\` itself.
+
+## Follow the response
+
+1. Parse the single JSON document from stdout.
+2. Briefly explain \`agent_instructions\` to the user without pasting raw JSON.
+3. Run the exact command in \`next_action.command\`.
+4. Use the absolute \`cli_path\` from the response for later Dreams commands.
+
+When \`state\` is \`awaiting_auth\`, run the returned \`auth login --json\` command and wait for the user to approve in the browser. That login command emits JSON Lines: first \`awaiting_approval\`, then \`authenticated\`. After it succeeds, run the stable CLI's \`onboard --json\` command again.
+
+When \`state\` is \`ready_for_orient\`, run the returned \`orient\` command.
+
+Repeated \`onboard\` calls are safe. They repair missing local setup and return the same next action until authentication state changes.
+
+Never print or summarize access tokens, refresh tokens, credential files, or keychain contents.
+`;
+}
+function readFile(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function writeAtomic(file, contents) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`;
+    try {
+        fs.writeFileSync(temporary, contents);
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+function removeLegacyGeneratedSkill() {
+    const directory = path.join(os.homedir(), ".claude", "skills", LEGACY_SKILL_NAME);
+    const file = path.join(directory, "SKILL.md");
+    const contents = readFile(file);
+    if (contents === null ||
+        !/^name:\s*dreams-onboarding\s*$/m.test(contents) ||
+        !contents.includes("dreams init --json") ||
+        !contents.includes("resumable onboarding")) {
+        return;
+    }
+    fs.rmSync(file, { force: true });
+    try {
+        fs.rmdirSync(directory);
+    }
+    catch {
+        // Preserve the directory when it contains other user-owned files.
+    }
+}
+function installedSkillVersion() {
+    const text = readFile(skillFilePath());
+    if (text === null)
+        return null;
+    const match = text.match(/^version:\s*(\S+)\s*$/m);
+    return match ? match[1] : null;
+}
+function installSkill() {
+    removeLegacyGeneratedSkill();
+    const desired = skillContent((0, version_1.packageVersion)());
+    const existing = readFile(skillFilePath());
+    if (existing === desired)
+        return "unchanged";
+    writeAtomic(skillFilePath(), desired);
+    return existing === null ? "installed" : "updated";
+}

package/dist/store.js

@@ -0,0 +1,133 @@
+"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.dreamsDir = dreamsDir;
+exports.secureDreamsDir = secureDreamsDir;
+exports.installationFilePath = installationFilePath;
+exports.loadOrCreateInstallation = loadOrCreateInstallation;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+function dreamsDir() {
+    return path.join(os.homedir(), ".dreams");
+}
+/**
+ * Create/keep the state directory private (0700) on every load and open, not
+ * only when first minting an installation. On Windows the mode bits are advisory
+ * (NTFS ACLs govern access); best-effort chmod keeps POSIX platforms locked down.
+ */
+function secureDreamsDir() {
+    const dir = dreamsDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32") {
+        try {
+            fs.chmodSync(dir, 0o700);
+        }
+        catch {
+            // Non-fatal: an unwritable mode should not block reads of existing state.
+        }
+    }
+    return dir;
+}
+function installationFilePath() {
+    return path.join(dreamsDir(), "installation.json");
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function fsyncDirectory(dir) {
+    if (process.platform === "win32")
+        return;
+    const fd = fs.openSync(dir, "r");
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Publish a complete JSON file only if no other process has won the race. */
+function writeJsonExclusive(file, value) {
+    const dir = path.dirname(file);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+    const tmp = path.join(dir, `.${path.basename(file)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+    const data = JSON.stringify(value, null, 2) + "\n";
+    const fd = fs.openSync(tmp, "wx", 0o600);
+    try {
+        fs.writeFileSync(fd, data);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    try {
+        // A hard link is an atomic no-replace publish on every supported platform.
+        // Unlike rename, it cannot overwrite another process's winning identity.
+        fs.linkSync(tmp, file);
+        fsyncDirectory(dir);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    finally {
+        fs.rmSync(tmp, { force: true });
+    }
+}
+function loadOrCreateInstallation() {
+    secureDreamsDir();
+    const file = installationFilePath();
+    const existing = readJson(file);
+    if (existing?.installation_id)
+        return existing;
+    if (fs.existsSync(file))
+        throw new Error(`Invalid installation state at ${file}`);
+    writeJsonExclusive(file, {
+        installation_id: "device_" + crypto.randomBytes(8).toString("hex"),
+        created_at: new Date().toISOString(),
+    });
+    // Always reread the published winner; another process may have linked first.
+    const persisted = readJson(file);
+    if (!persisted?.installation_id)
+        throw new Error(`Failed to create installation state at ${file}`);
+    return persisted;
+}

package/dist/version.js

@@ -0,0 +1,48 @@
+"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.packageVersion = packageVersion;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/**
+ * Read the package version at runtime. Works from src/ (tsx dev), dist/
+ * (built), and inside the packed tarball — package.json is one level up in
+ * all three cases.
+ */
+function packageVersion() {
+    const pkgPath = path.join(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return pkg.version;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@letta-ai/dreams",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Dreams CLI - shared organizational memory from coding-agent transcripts",
+  "license": "Apache-2.0",
+  "bin": {
+    "dreams": "bin/dreams.cjs"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.13"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc",
+    "prepack": "npm run build",
+    "test": "npm run build && node --test test/*.test.mjs"
+  },
+  "optionalDependencies": {
+    "@napi-rs/keyring": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}