@letta-ai/dreams 0.0.1 → 0.0.4

package/dist/local/codex-hooks.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * Codex live-sync hook helpers ([LET-10315]).
+ *
+ * Merge Dreams SessionStart/Stop handlers into ~/.codex/hooks.json and enable
+ * `[features].hooks = true` in ~/.codex/config.toml without a full TOML parser.
+ * Runtime stdout contract lives in bin/dreams-codex-hook.cjs (always `{}`).
+ */
+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.CODEX_HOOK_MARKER = void 0;
+exports.codexHooksJsonPath = codexHooksJsonPath;
+exports.codexConfigTomlPath = codexConfigTomlPath;
+exports.shellQuote = shellQuote;
+exports.buildCodexHookCommand = buildCodexHookCommand;
+exports.mergeCodexHooksJson = mergeCodexHooksJson;
+exports.ensureCodexFeaturesHooks = ensureCodexFeaturesHooks;
+exports.planCodexHooksInstall = planCodexHooksInstall;
+exports.installCodexHooks = installCodexHooks;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+exports.CODEX_HOOK_MARKER = "dreams-sync-hook-codex";
+function codexHooksJsonPath(home = os.homedir()) {
+    return path.join(home, ".codex", "hooks.json");
+}
+function codexConfigTomlPath(home = os.homedir()) {
+    return path.join(home, ".codex", "config.toml");
+}
+/** Quote a path for Codex hook `command` strings (POSIX + Windows-friendly). */
+function shellQuote(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/**
+ * Build the command Codex should run for Dreams.
+ * `hookScriptPath` is the absolute dreams-codex-hook.cjs path;
+ * `cliPath` is the durable Dreams launcher from onboard.
+ * SessionStart uses `wake`; Stop uses `sync`.
+ */
+function buildCodexHookCommand(hookScriptPath, cliPath, mode = "sync") {
+    return `node ${shellQuote(hookScriptPath)} ${shellQuote(cliPath)} ${mode} # ${exports.CODEX_HOOK_MARKER}`;
+}
+function isDreamsCodexHandler(command) {
+    if (typeof command !== "string")
+        return false;
+    return (command.includes(exports.CODEX_HOOK_MARKER) ||
+        /\b(?:wake|sync)\s+--source\s+codex\b/.test(command) ||
+        /\bsync\s+--source\s+codex\b/.test(command));
+}
+function upsertEventHandlers(matchers, command) {
+    const next = matchers.map((matcher) => ({ ...matcher, hooks: [...(matcher.hooks ?? [])] }));
+    let updated = false;
+    for (const matcher of next) {
+        const hooks = matcher.hooks ?? [];
+        for (let i = 0; i < hooks.length; i++) {
+            if (isDreamsCodexHandler(hooks[i]?.command)) {
+                hooks[i] = { ...hooks[i], type: "command", command };
+                updated = true;
+            }
+        }
+        matcher.hooks = hooks;
+    }
+    if (updated)
+        return next;
+    return [...next, { hooks: [{ type: "command", command }] }];
+}
+/**
+ * Merge Dreams Codex handlers into an existing hooks.json document.
+ * Preserves unrelated top-level keys and non-Dreams handlers.
+ * SessionStart → wake; Stop → sync.
+ */
+function mergeCodexHooksJson(existingRaw, hookScriptPath, cliPath) {
+    const wakeCommand = buildCodexHookCommand(hookScriptPath, cliPath, "wake");
+    const syncCommand = buildCodexHookCommand(hookScriptPath, cliPath, "sync");
+    let doc = {};
+    if (existingRaw !== null && existingRaw.trim() !== "") {
+        const parsed = JSON.parse(existingRaw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("codex hooks.json must be a JSON object");
+        }
+        doc = { ...parsed };
+    }
+    const hooksValue = doc.hooks;
+    const hooks = hooksValue && typeof hooksValue === "object" && !Array.isArray(hooksValue)
+        ? { ...hooksValue }
+        : {};
+    const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    const stop = Array.isArray(hooks.Stop) ? hooks.Stop : [];
+    hooks.SessionStart = upsertEventHandlers(sessionStart, wakeCommand);
+    hooks.Stop = upsertEventHandlers(stop, syncCommand);
+    doc.hooks = hooks;
+    return `${JSON.stringify(doc, null, 2)}\n`;
+}
+/**
+ * Ensure `[features].hooks = true` surgically. Does not write deprecated
+ * `codex_hooks`. Preserves unrelated keys, comments, and ordering where possible.
+ */
+function ensureCodexFeaturesHooks(toml) {
+    const lines = toml.replace(/\r\n/g, "\n").split("\n");
+    let featuresStart = -1;
+    let featuresEnd = lines.length;
+    let hooksLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const section = line.match(/^\s*\[([^\]]+)\]\s*(#.*)?$/);
+        if (!section)
+            continue;
+        const name = section[1].trim();
+        if (name === "features") {
+            featuresStart = i;
+            featuresEnd = lines.length;
+            for (let j = i + 1; j < lines.length; j++) {
+                if (/^\s*\[[^\]]+\]\s*(#.*)?$/.test(lines[j])) {
+                    featuresEnd = j;
+                    break;
+                }
+            }
+            for (let j = i + 1; j < featuresEnd; j++) {
+                if (/^\s*hooks\s*=/.test(lines[j]))
+                    hooksLine = j;
+            }
+            break;
+        }
+    }
+    if (featuresStart === -1) {
+        const body = toml.replace(/\s*$/, "");
+        const prefix = body.length === 0 ? "" : `${body}\n\n`;
+        return `${prefix}[features]\nhooks = true\n`;
+    }
+    if (hooksLine !== -1) {
+        const comment = lines[hooksLine].match(/\s*(#.*)$/);
+        lines[hooksLine] = `hooks = true${comment ? ` ${comment[1]}` : ""}`;
+        return normalizeTrailingNewline(lines.join("\n"));
+    }
+    // Insert after [features] header (and any blank line immediately following).
+    let insertAt = featuresStart + 1;
+    while (insertAt < featuresEnd && lines[insertAt].trim() === "")
+        insertAt++;
+    lines.splice(insertAt, 0, "hooks = true");
+    return normalizeTrailingNewline(lines.join("\n"));
+}
+function normalizeTrailingNewline(text) {
+    return text.endsWith("\n") ? text : `${text}\n`;
+}
+function planCodexHooksInstall(options) {
+    const home = options.home ?? os.homedir();
+    const hooksPath = codexHooksJsonPath(home);
+    const configPath = codexConfigTomlPath(home);
+    let existingHooks = null;
+    try {
+        existingHooks = fs.readFileSync(hooksPath, "utf8");
+    }
+    catch {
+        existingHooks = null;
+    }
+    const nextHooks = mergeCodexHooksJson(existingHooks, options.hookScriptPath, options.cliPath);
+    let existingConfig = "";
+    try {
+        existingConfig = fs.readFileSync(configPath, "utf8");
+    }
+    catch {
+        existingConfig = "";
+    }
+    const nextConfig = ensureCodexFeaturesHooks(existingConfig);
+    const stopCommand = buildCodexHookCommand(options.hookScriptPath, options.cliPath, "sync");
+    return {
+        hooks_path: hooksPath,
+        config_path: configPath,
+        hooks_changed: existingHooks !== nextHooks,
+        config_changed: existingConfig !== nextConfig,
+        session_start_command: buildCodexHookCommand(options.hookScriptPath, options.cliPath, "wake"),
+        stop_command: stopCommand,
+        command: stopCommand,
+        next_hooks_contents: nextHooks,
+        next_config_contents: nextConfig,
+    };
+}
+/** Idempotent install/repair of user-level Codex Dreams hooks + feature flag. */
+function installCodexHooks(options) {
+    const plan = planCodexHooksInstall(options);
+    fs.mkdirSync(path.dirname(plan.hooks_path), { recursive: true });
+    if (plan.hooks_changed)
+        writeAtomic(plan.hooks_path, plan.next_hooks_contents);
+    if (plan.config_changed)
+        writeAtomic(plan.config_path, plan.next_config_contents);
+    return plan;
+}
+function writeAtomic(file, contents) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.tmp-${process.pid}-${Math.random().toString(16).slice(2)}`;
+    try {
+        fs.writeFileSync(temporary, contents, { encoding: "utf8" });
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+}