toolnet-memory 0.2.0 → 0.2.2

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

@@ -1,138 +0,0 @@
-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

@@ -1,236 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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";