toolnet-memory 0.2.0

package/dist/src/session/codex/adapter.js

@@ -0,0 +1,138 @@
+import { SessionCore, } from "../core.js";
+import { inspectCodexRollout, pathBelongsToProject, } from "./discovery.js";
+import { readCodexRollout, } from "./rollout.js";
+export async function syncCodexSession(options) {
+    const threadId = options.threadId
+        .trim();
+    if (!threadId) {
+        throw new Error("Codex thread ID is required");
+    }
+    const meta = inspectCodexRollout(options.rolloutPath);
+    const cwd = options.cwd ??
+        meta.cwd;
+    if (cwd &&
+        !pathBelongsToProject(options.project
+            .rootPath, cwd)) {
+        throw new Error(`Codex thread does not belong to project: ${cwd}`);
+    }
+    if (meta.threadId &&
+        meta.threadId !==
+            threadId) {
+        throw new Error(`Codex rollout thread mismatch: expected ${threadId}, got ${meta.threadId}`);
+    }
+    const core = new SessionCore({
+        project: options.project,
+        storage: options.storage,
+        agent: "codex",
+        nativeSessionId: threadId,
+        metadata: {
+            source: "codex-rollout",
+            rolloutPath: options.rolloutPath,
+            cwd,
+            client: options.client,
+        },
+    });
+    const state = core.status();
+    const previousPath = state.sourceCursors["codex.rollout.path"];
+    let offset = Number(state.sourceCursors["codex.rollout.offset"] ??
+        0);
+    /*
+     * Future Codex may rotate a resumed thread into another rollout.
+     */
+    if (previousPath &&
+        previousPath !==
+            options.rolloutPath) {
+        offset =
+            0;
+    }
+    if (!Number.isFinite(offset) ||
+        offset < 0) {
+        offset =
+            0;
+    }
+    const rollout = readCodexRollout(options.rolloutPath, offset);
+    const events = [];
+    if (state.lastSequence ===
+        0) {
+        events.push({
+            type: "session_start",
+            sourceEventId: `codex:${threadId}:start`,
+            data: {
+                threadId,
+                cwd,
+                rolloutPath: options.rolloutPath,
+                sessionMeta: meta.raw,
+            },
+            provenance: {
+                source: "codex-rollout",
+                sourcePath: options.rolloutPath,
+            },
+        });
+    }
+    if (previousPath &&
+        previousPath !==
+            options.rolloutPath) {
+        events.push({
+            type: "custom",
+            sourceEventId: `codex:${threadId}:rollout-rotation:${options.rolloutPath}`,
+            data: {
+                event: "rollout_rotation",
+                previousPath,
+                rolloutPath: options.rolloutPath,
+            },
+            provenance: {
+                source: "codex-rollout",
+            },
+        });
+    }
+    if (rollout.reset) {
+        events.push({
+            type: "custom",
+            sourceEventId: `codex:${threadId}:rollout-reset:${rollout.nextOffset}`,
+            data: {
+                event: "rollout_reset",
+            },
+            provenance: {
+                source: "codex-rollout",
+                sourcePath: options.rolloutPath,
+            },
+        });
+    }
+    events.push(...rollout.events);
+    /*
+     * AfterAgent/agent-turn-complete means this TURN is done.
+     * The Codex thread may be resumed later.
+     */
+    if (options.idle &&
+        options.turnId) {
+        events.push({
+            type: "session_idle",
+            sourceEventId: `codex:${threadId}:turn:${options.turnId}:idle`,
+            data: {
+                turnId: options.turnId,
+                client: options.client,
+            },
+            provenance: {
+                source: "codex-notify",
+            },
+        });
+    }
+    const recorded = core.recordMany(events);
+    core.setSourceCursor("codex.rollout.path", options.rolloutPath);
+    core.setSourceCursor("codex.rollout.offset", rollout.nextOffset);
+    if (options.turnId) {
+        core.setSourceCursor("codex.last.turn", options.turnId);
+    }
+    const flushed = await core.flush();
+    return {
+        threadId,
+        imported: recorded.length,
+        rolloutEvents: rollout.events
+            .length,
+        eventCount: flushed.eventCount,
+        chunkCount: flushed.chunkCount,
+        status: flushed.status,
+        rolloutOffset: rollout.nextOffset,
+        reset: rollout.reset,
+    };
+}

package/dist/src/session/codex/cli.js

@@ -0,0 +1,236 @@
+import { existsSync, readFileSync, } from "node:fs";
+import { spawn, } from "node:child_process";
+import { homedir, } from "node:os";
+import { join, } from "node:path";
+import { loadConfig, ProjectManager, } from "../../core/index.js";
+import { createStorageProvider, ProjectScopedStorageProvider, withStorageRetry, } from "../../storage/index.js";
+import { syncCodexSession, } from "./adapter.js";
+import { findCodexRollout, } from "./discovery.js";
+import { findCodexToolNetProject, } from "./project-resolver.js";
+import { recoverCodexProject, } from "./recovery.js";
+import { installCodexNotify, } from "./notify-installer.js";
+import { installCodexContextHook, } from "./context-hook-installer.js";
+import { refreshStartupBriefCache, } from "../../work-continuity/brief-cache.js";
+function after(args, flag) {
+    const index = args.indexOf(flag);
+    return index >=
+        0
+        ? args[index +
+            1]
+        : undefined;
+}
+function storageFor(project) {
+    const config = loadConfig();
+    const raw = withStorageRetry(createStorageProvider({
+        provider: config.storage
+            .provider,
+        huggingface: config.storage
+            .huggingface,
+        localRoot: config.storage
+            .localRoot,
+    }), {
+        attempts: 3,
+    });
+    return new ProjectScopedStorageProvider(raw, project.id, project.name, project.remote ??
+        project.name);
+}
+async function waitForRollout(threadId) {
+    for (let attempt = 0; attempt <
+        10; attempt +=
+        1) {
+        const file = findCodexRollout(threadId);
+        if (file) {
+            return file;
+        }
+        await new Promise(resolve => setTimeout(resolve, 150));
+    }
+    return null;
+}
+function runPreviousNotify(rawPayload) {
+    const previousFile = join(homedir(), ".config", "toolnet-memory", "codex-notify-previous.json");
+    if (!existsSync(previousFile)) {
+        return;
+    }
+    try {
+        const argv = JSON.parse(readFileSync(previousFile, "utf8"));
+        if (!Array.isArray(argv) ||
+            argv.length ===
+                0 ||
+            !argv.every(item => typeof item ===
+                "string")) {
+            return;
+        }
+        const child = spawn(argv[0], [
+            ...argv.slice(1),
+            rawPayload,
+        ], {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+    }
+    catch {
+        // Existing notifier must never break Codex.
+    }
+}
+async function notify(raw) {
+    let payload;
+    try {
+        payload =
+            JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    const type = payload.type;
+    if (type !==
+        "agent-turn-complete") {
+        return;
+    }
+    const threadId = typeof payload["thread-id"] ===
+        "string"
+        ? payload["thread-id"]
+        : "";
+    const turnId = typeof payload["turn-id"] ===
+        "string"
+        ? payload["turn-id"]
+        : "";
+    const cwd = typeof payload.cwd ===
+        "string"
+        ? payload.cwd
+        : "";
+    const client = typeof payload.client ===
+        "string"
+        ? payload.client
+        : undefined;
+    if (!threadId ||
+        !cwd) {
+        return;
+    }
+    const project = findCodexToolNetProject(cwd);
+    /*
+     * Global Codex notify:
+     * ignore non-ToolNet projects.
+     */
+    if (!project) {
+        return;
+    }
+    const rolloutPath = await waitForRollout(threadId);
+    if (!rolloutPath) {
+        /*
+         * Recovery command will backfill later.
+         */
+        return;
+    }
+    const storage = storageFor(project);
+    await syncCodexSession({
+        project,
+        storage,
+        threadId,
+        rolloutPath,
+        cwd,
+        turnId,
+        client,
+        idle: true,
+    });
+    try {
+        await refreshStartupBriefCache(project, storage, 900);
+    }
+    catch {
+        // Derived cache must never break Codex notify.
+    }
+}
+async function main() {
+    const [command = "help", ...args] = process.argv.slice(2);
+    if (command ===
+        "install-notify") {
+        const binary = after(args, "--bin");
+        const result = installCodexNotify({
+            binary,
+        });
+        const contextHooks = installCodexContextHook({
+            binary,
+        });
+        console.log(`✅ Codex notify installed: ${result.configFile}`);
+        if (result
+            .preservedPrevious) {
+            console.log(`✅ Previous notify preserved: ${result.previousFile}`);
+        }
+        console.log(`✅ Codex SessionStart context hook: ${contextHooks}`);
+        return;
+    }
+    if (command ===
+        "notify") {
+        const raw = args[args.length -
+            1] ??
+            "";
+        try {
+            await notify(raw);
+        }
+        finally {
+            runPreviousNotify(raw);
+        }
+        return;
+    }
+    const projectPath = after(args, "--project") ??
+        process.cwd();
+    const project = new ProjectManager()
+        .detect(projectPath);
+    const storage = storageFor(project);
+    if (command ===
+        "sync") {
+        const threadId = args[0];
+        if (!threadId) {
+            throw new Error("Usage: sync <thread-id>");
+        }
+        const rolloutPath = after(args, "--rollout") ??
+            findCodexRollout(threadId);
+        if (!rolloutPath) {
+            throw new Error(`Codex rollout not found for ${threadId}`);
+        }
+        const result = await syncCodexSession({
+            project,
+            storage,
+            threadId,
+            rolloutPath,
+            idle: args.includes("--idle"),
+        });
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (command ===
+        "recover") {
+        const rawLimit = Number(after(args, "--limit") ??
+            100);
+        const results = await recoverCodexProject(project, storage, Number.isFinite(rawLimit)
+            ? rawLimit
+            : 100);
+        console.log(JSON.stringify({
+            project: project.name,
+            sessions: results.length,
+            imported: results.reduce((total, item) => total +
+                item.imported, 0),
+        }, null, 2));
+        return;
+    }
+    console.log(`Codex Session Adapter
+
+Commands:
+  install-notify
+  sync <thread-id> [--project PATH]
+  recover [--project PATH] [--limit N]
+`);
+}
+main().catch(error => {
+    /*
+     * notify must never make Codex fail.
+     */
+    if (process.argv[2] ===
+        "notify") {
+        process.exit(0);
+    }
+    console.error(error instanceof Error
+        ? error.message
+        : error);
+    process.exit(1);
+});

package/dist/src/session/codex/context-hook-installer.js

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { homedir, } from "node:os";
+import { dirname, join, } from "node:path";
+function quote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function installCodexContextHook(options = {}) {
+    const hooksFile = options.hooksFile ??
+        join(process.env.CODEX_HOME ??
+            join(homedir(), ".codex"), "hooks.json");
+    mkdirSync(dirname(hooksFile), {
+        recursive: true,
+    });
+    let root = {};
+    if (existsSync(hooksFile)) {
+        try {
+            root =
+                JSON.parse(readFileSync(hooksFile, "utf8"));
+        }
+        catch (error) {
+            throw new Error(`Invalid existing Codex hooks.json: ${error instanceof Error
+                ? error.message
+                : String(error)}`);
+        }
+    }
+    const hooks = root.hooks &&
+        typeof root.hooks ===
+            "object" &&
+        !Array.isArray(root.hooks)
+        ? root.hooks
+        : {};
+    root.hooks =
+        hooks;
+    const current = Array.isArray(hooks.SessionStart)
+        ? hooks.SessionStart
+        : [];
+    /*
+     * Remove only ToolNet's previous SessionStart entry.
+     * Every unrelated Codex hook is preserved.
+     */
+    const cleaned = current.filter(item => {
+        try {
+            return !JSON.stringify(item).includes("session:codex-context");
+        }
+        catch {
+            return true;
+        }
+    });
+    const binary = options.binary ??
+        "toolnet-memory";
+    cleaned.push({
+        matcher: "startup|resume|clear|compact",
+        hooks: [
+            {
+                type: "command",
+                command: `${quote(binary)} session:codex-context`,
+                timeout: 15,
+                additionalContextLimit: 1000,
+                statusMessage: "Loading ToolNet project continuity",
+            },
+        ],
+    });
+    hooks.SessionStart =
+        cleaned;
+    writeFileSync(hooksFile, JSON.stringify(root, null, 2) + "\n", {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    return hooksFile;
+}

package/dist/src/session/codex/context-hook.js

@@ -0,0 +1,69 @@
+import { loadConfig, } from "../../core/index.js";
+import { createStorageProvider, ProjectScopedStorageProvider, withStorageRetry, } from "../../storage/index.js";
+import { buildCodexSessionStartOutput, } from "../../work-continuity/index.js";
+import { findCodexToolNetProject, } from "./project-resolver.js";
+async function readInput() {
+    let raw = "";
+    for await (const chunk of process.stdin) {
+        raw +=
+            chunk.toString();
+    }
+    if (!raw.trim()) {
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function main() {
+    const input = await readInput();
+    if (input.hook_event_name !==
+        "SessionStart") {
+        process.stdout.write("{}");
+        return;
+    }
+    const cwd = typeof input.cwd ===
+        "string"
+        ? input.cwd
+        : "";
+    if (!cwd) {
+        process.stdout.write("{}");
+        return;
+    }
+    const project = findCodexToolNetProject(cwd);
+    if (!project) {
+        process.stdout.write("{}");
+        return;
+    }
+    try {
+        const config = loadConfig();
+        const raw = withStorageRetry(createStorageProvider({
+            provider: config.storage
+                .provider,
+            huggingface: config.storage
+                .huggingface,
+            localRoot: config.storage
+                .localRoot,
+        }), {
+            attempts: 2,
+        });
+        const storage = new ProjectScopedStorageProvider(raw, project.id, project.name, project.remote ??
+            project.name);
+        const output = await buildCodexSessionStartOutput({
+            project,
+            storage,
+        });
+        process.stdout.write(JSON.stringify(output));
+    }
+    catch {
+        process.stdout.write("{}");
+    }
+}
+main().catch(() => {
+    process.stdout.write("{}");
+    process.exitCode =
+        0;
+});

package/dist/src/session/codex/discovery.js

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync, readdirSync, statSync, } from "node:fs";
+import { homedir, } from "node:os";
+import { join, resolve, } from "node:path";
+function object(value) {
+    return (value &&
+        typeof value ===
+            "object" &&
+        !Array.isArray(value))
+        ? value
+        : {};
+}
+export function codexHome() {
+    return (process.env
+        .CODEX_HOME ??
+        join(homedir(), ".codex"));
+}
+export function inspectCodexRollout(file) {
+    let content = "";
+    try {
+        const fd = readFileSync(file, "utf8");
+        content =
+            fd.slice(0, 128 * 1024);
+    }
+    catch {
+        return {
+            raw: {},
+        };
+    }
+    for (const line of content.split("\n")) {
+        if (!line) {
+            continue;
+        }
+        try {
+            const row = object(JSON.parse(line));
+            if (row.type !==
+                "session_meta") {
+                continue;
+            }
+            const payload = object(row.payload);
+            const threadId = [
+                payload.id,
+                payload.thread_id,
+                payload.threadId,
+                payload.session_id,
+                payload.sessionId,
+            ].find(item => typeof item ===
+                "string");
+            const cwd = typeof payload.cwd ===
+                "string"
+                ? payload.cwd
+                : undefined;
+            return {
+                threadId,
+                cwd,
+                raw: payload,
+            };
+        }
+        catch {
+            // continue
+        }
+    }
+    return {
+        raw: {},
+    };
+}
+function walk(directory, output) {
+    if (!existsSync(directory)) {
+        return;
+    }
+    let entries;
+    try {
+        entries =
+            readdirSync(directory, {
+                withFileTypes: true,
+            });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            walk(path, output);
+            continue;
+        }
+        if (entry.isFile() &&
+            entry.name.endsWith(".jsonl")) {
+            output.push(path);
+        }
+    }
+}
+export function listCodexRollouts() {
+    const home = codexHome();
+    const files = [];
+    walk(join(home, "sessions"), files);
+    walk(join(home, "archived_sessions"), files);
+    return files.sort((left, right) => {
+        try {
+            return (statSync(right).mtimeMs -
+                statSync(left).mtimeMs);
+        }
+        catch {
+            return 0;
+        }
+    });
+}
+export function findCodexRollout(threadId) {
+    const files = listCodexRollouts();
+    /*
+     * Official rollout filenames contain the UUID.
+     * Cheap path first.
+     */
+    const direct = files.find(file => file.includes(threadId));
+    if (direct) {
+        return direct;
+    }
+    /*
+     * Fallback for future filename layouts:
+     * read session_meta.
+     */
+    for (const file of files) {
+        const meta = inspectCodexRollout(file);
+        if (meta.threadId ===
+            threadId) {
+            return file;
+        }
+    }
+    return null;
+}
+export function pathBelongsToProject(projectRoot, cwd) {
+    const root = resolve(projectRoot);
+    const candidate = resolve(cwd);
+    return (candidate === root ||
+        candidate.startsWith(root +
+            "/") ||
+        root.startsWith(candidate +
+            "/"));
+}

package/dist/src/session/codex/index.js

@@ -0,0 +1,6 @@
+export * from "./rollout.js";
+export * from "./discovery.js";
+export * from "./adapter.js";
+export * from "./project-resolver.js";
+export * from "./recovery.js";
+export * from "./notify-installer.js";