@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/loop/dist/infrastructure/persistence/session-validator.js

@@ -0,0 +1,5 @@
+import { sessionSchema, } from "@ocean/core/domain/sessions/session.js";
+export function validateSession(input) {
+    return sessionSchema.parse(input);
+}
+//# sourceMappingURL=session-validator.js.map

package/node_modules/@ocean/loop/dist/loops/iteration-graph.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { Annotation, END, MemorySaver, START, StateGraph, } from "@langchain/langgraph";
+const IterationState = Annotation.Root({
+    loop: Annotation(),
+    next: Annotation(),
+    ran: Annotation(),
+});
+// Only record is retried in place, and only on a filesystem error: it writes files and is safe
+// to repeat. work (a provider run) and verify (the task's own checks, a test suite say) are
+// never re-run here; the loop's interval and attempt budget decide when they run again. No
+// jitter and no log line: retries must not write to stdout, which carries command JSON.
+const recordRetry = {
+    maxAttempts: 3,
+    initialInterval: 200,
+    jitter: false,
+    logWarning: false,
+    retryOn: (error) => typeof error?.code === "string",
+};
+export function iterationGraph(steps, checkpointer) {
+    return new StateGraph(IterationState)
+        .addNode("work", (state) => steps.work(state.loop))
+        .addNode("verify", async (state) => ({
+        loop: await steps.verify(state.loop),
+    }))
+        .addNode("record", async (state) => ({ loop: await steps.record(state.loop), ran: true }), { retryPolicy: recordRetry })
+        .addEdge(START, "work")
+        .addConditionalEdges("work", (state) => (state.next === "verify" ? "verify" : END), ["verify", END])
+        .addEdge("verify", "record")
+        .addEdge("record", END)
+        .compile({ checkpointer });
+}
+// LangChain sends every run to LangSmith when one of these is "true", which a shell set up for
+// another project may well have. It reads them only from process.env, with no per-run switch,
+// so loop state (prompts, task ids, paths) stays on this machine by turning off just the ones
+// that are on; processes the loop starts inherit that.
+export function keepRunsLocal(env = process.env) {
+    for (const name of [
+        "LANGSMITH_TRACING_V2",
+        "LANGCHAIN_TRACING_V2",
+        "LANGSMITH_TRACING",
+        "LANGCHAIN_TRACING",
+    ])
+        if (env[name] === "true")
+            env[name] = "false";
+}
+const bytesKey = "$bytes";
+const safeThreadId = /^[A-Za-z0-9_-]+$/;
+// MemorySaver keeps its maps prototype-free so no key can reach Object.prototype; JSON.parse
+// does not, so rebuild them that way.
+function prototypeFree(value, depth) {
+    const out = Object.create(null);
+    for (const [key, item] of Object.entries(value))
+        out[key] = depth > 0 ? prototypeFree(item, depth - 1) : item;
+    return out;
+}
+// MemorySaver's checkpoints kept on disk, one file per thread (a loop), so a thread resumes after
+// the process is gone and two processes working different loops never overwrite each other.
+// The LangGraph version is pinned exactly because this relies on MemorySaver's typed `storage`
+// and `writes` maps and its `[thread, namespace, checkpoint]` write keys.
+export class FileCheckpointSaver extends MemorySaver {
+    dir;
+    #saving = new Map();
+    constructor(dir) {
+        super();
+        this.dir = dir;
+    }
+    static async open(dir) {
+        const saver = new FileCheckpointSaver(dir);
+        let files = [];
+        try {
+            files = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        for (const file of files.filter((name) => name.endsWith(".json"))) {
+            const full = path.join(dir, file);
+            try {
+                const saved = JSON.parse(await readFile(full, "utf8"), (_key, value) => value &&
+                    typeof value === "object" &&
+                    typeof value[bytesKey] === "string" &&
+                    Object.keys(value).length === 1
+                    ? new Uint8Array(Buffer.from(value[bytesKey], "base64"))
+                    : value);
+                if (!safeThreadId.test(saved.threadId))
+                    throw new Error("unsafe thread id");
+                saver.storage[saved.threadId] = prototypeFree(saved.storage, 1);
+                for (const [key, writes] of Object.entries(saved.writes))
+                    saver.writes[key] = prototypeFree(writes, 0);
+            }
+            catch {
+                // An unreadable thread is set aside rather than stopping every loop; the worst case is
+                // that its iteration runs again from the start.
+                await rename(full, `${full}.unreadable-${Date.now()}`).catch(() => undefined);
+            }
+        }
+        return saver;
+    }
+    async put(...args) {
+        const result = await super.put(...args);
+        await this.#save(args[0].configurable?.thread_id);
+        return result;
+    }
+    async putWrites(...args) {
+        await super.putWrites(...args);
+        await this.#save(args[0].configurable?.thread_id);
+    }
+    async deleteThread(threadId) {
+        await super.deleteThread(threadId);
+        await this.#save(threadId);
+    }
+    // One thread's saves run one after another, each writing what is current when it starts; a
+    // failed save fails its own caller, not the ones after it.
+    #save(threadId) {
+        if (typeof threadId !== "string" || !safeThreadId.test(threadId))
+            return Promise.reject(new Error(`Unsafe checkpoint thread id: ${String(threadId)}`));
+        const file = path.join(this.dir, `${threadId}.json`);
+        const run = (this.#saving.get(threadId) ?? Promise.resolve())
+            .catch(() => undefined)
+            .then(async () => {
+            const storage = this.storage[threadId];
+            const writes = Object.fromEntries(Object.entries(this.writes).filter(([key]) => JSON.parse(key)[0] === threadId));
+            if (!storage && !Object.keys(writes).length) {
+                await rm(file, { force: true });
+                return;
+            }
+            const payload = JSON.stringify({ threadId, storage: storage ?? {}, writes }, 
+            // `this[key]` is the value before toJSON (a Buffer would otherwise arrive as JSON).
+            function (key, value) {
+                const raw = this[key];
+                return raw instanceof Uint8Array
+                    ? { [bytesKey]: Buffer.from(raw).toString("base64") }
+                    : value;
+            });
+            await mkdir(this.dir, { recursive: true });
+            const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+            await writeFile(temp, `${payload}\n`, { mode: 0o600 });
+            await rename(temp, file);
+        });
+        this.#saving.set(threadId, run);
+        return run;
+    }
+}
+//# sourceMappingURL=iteration-graph.js.map

package/node_modules/@ocean/loop/dist/loops/task-loop-record.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=task-loop-record.js.map

package/node_modules/@ocean/loop/dist/loops/task-loop.js

@@ -0,0 +1,281 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { TASK_ID } from "@ocean/core/domain/tasks/task-id.js";
+import { oceanPath, projectDir, resolveWithin, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+import { folderProject } from "@ocean/core/shared/project-resolution.js";
+import { resolveTaskReference, } from "@ocean/core/shared/task-reference.js";
+import { runAgent } from "../runs/run-agent.js";
+import { checkpointTask } from "../tasks/checkpoint-task.js";
+import { verifyTask } from "../tasks/verify-task.js";
+const loopsFile = () => oceanPath(SYSTEM_DIR, "loops.json");
+const checkpointsDir = () => oceanPath(SYSTEM_DIR, "loop-checkpoints");
+export async function listTaskLoops() {
+    try {
+        return JSON.parse(await readFile(loopsFile(), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function startTaskLoop(input) {
+    if (!input.approved)
+        throw new Error("Loop start requires explicit approval.");
+    if (!input.taskId || !TASK_ID.test(input.taskId))
+        throw new Error("Loop requires a valid task id.");
+    const loop = {
+        id: `loop-${randomUUID()}`,
+        taskId: input.taskId,
+        projectId: await folderProject(input.cwd),
+        profile: input.profile,
+        prompt: input.prompt.trim(),
+        cwd: input.cwd,
+        status: "active",
+        approved: true,
+        maxIterations: bounded(input.maxIterations ?? 10, 1, 100),
+        intervalMs: bounded(input.intervalMs ?? 60_000, 1_000, 86_400_000),
+        maxAttempts: bounded(input.maxAttempts ?? 2, 1, 5),
+        iterations: 0,
+        failures: 0,
+        nextRunAt: new Date().toISOString(),
+        lastSessionId: null,
+        lastError: null,
+        checkpoint: "Loop created; inspect the task and choose the first bounded action.",
+        resultPath: null,
+    };
+    await saveLoops([...(await listTaskLoops()), loop]);
+    return loop;
+}
+export async function stopTaskLoop(id) {
+    const loops = await listTaskLoops();
+    const loop = loops.find((item) => item.id === id);
+    if (!loop)
+        throw new Error(`Loop not found: ${id}`);
+    loop.status = "stopped";
+    await saveLoops(loops);
+    return loop;
+}
+export async function runTaskLoopsOnce(cwd, runtime, options = {}) {
+    // LangGraph loads only when loops actually run, not on every `ocean` command.
+    const { FileCheckpointSaver, iterationGraph, keepRunsLocal } = await import("./iteration-graph.js");
+    keepRunsLocal();
+    const checkpointer = await FileCheckpointSaver.open(checkpointsDir());
+    const graph = iterationGraph(iterationSteps(cwd, runtime, options), checkpointer);
+    const loops = await listTaskLoops();
+    const ran = [];
+    for (const loop of loops) {
+        const config = { configurable: { thread_id: loop.id } };
+        try {
+            const saved = await graph.getState(config);
+            const reached = saved.values.loop;
+            if (reached && ["stopped", "completed", "failed"].includes(loop.status)) {
+                // Stopped (or finished) since the process died: its iteration is dropped, not resumed.
+                await checkpointer.deleteThread(loop.id);
+                continue;
+            }
+            if (reached && saved.next.length === 0) {
+                // The iteration finished but its result never reached loops.json: take it, don't redo it.
+                Object.assign(loop, reached);
+                await saveLoops(loops);
+                await checkpointer.deleteThread(loop.id);
+                continue;
+            }
+            // An iteration the process died in resumes at its step; a paused loop keeps it for later.
+            const interrupted = saved.next.length > 0;
+            if (loop.status !== "active")
+                continue;
+            if (!interrupted && Date.parse(loop.nextRunAt) > Date.now())
+                continue;
+            try {
+                // "sync": a step's checkpoint is on disk before the next step starts, so a crash in
+                // verify never re-runs the agent session.
+                const result = await graph.invoke(interrupted ? null : { loop: { ...loop }, ran: false }, { ...config, durability: "sync" });
+                Object.assign(loop, result.loop);
+                if (result.ran)
+                    ran.push(loop.id);
+            }
+            catch (error) {
+                // A step that fails (record: after its retries) is one failed attempt of the loop.
+                const failed = (await graph.getState(config)).values.loop;
+                if (failed)
+                    Object.assign(loop, failed);
+                recordFailure(loop, error);
+            }
+            // The record first, then the checkpoint: a crash between the two leaves a finished
+            // thread, which the next pass takes instead of running again.
+            await saveLoops(loops);
+            await checkpointer.deleteThread(loop.id);
+        }
+        catch (error) {
+            // Checkpoint storage failing for one loop is that loop's failed attempt, not the pass's.
+            recordFailure(loop, error);
+        }
+    }
+    await saveLoops(loops);
+    return ran;
+}
+function recordFailure(loop, error) {
+    loop.failures += 1;
+    loop.lastError = error instanceof Error ? error.message : String(error);
+    loop.nextRunAt = new Date(Date.now() + loop.intervalMs).toISOString();
+    if (loop.failures >= loop.maxAttempts)
+        loop.status = "failed";
+}
+// The loop's policy, step by step. Each step takes the record as the graph checkpointed it and
+// returns the next one; none of them mutates its input, so a resumed step starts clean.
+function iterationSteps(cwd, runtime, options) {
+    return {
+        async work(current) {
+            const loop = { ...current };
+            if (loop.iterations >= loop.maxIterations) {
+                loop.status = "failed";
+                loop.lastError = "iteration budget exhausted";
+                return { loop, next: "end" };
+            }
+            const sessionId = randomUUID();
+            loop.iterations += 1;
+            loop.lastSessionId = sessionId;
+            try {
+                const session = await runAgent({
+                    sessionId,
+                    profileName: loop.profile,
+                    prompt: `${loop.prompt}\n\nLoop checkpoint: ${loop.checkpoint}\nWork only on task ${loop.taskId}. Complete one bounded action, verify it, and record the next checkpoint.`,
+                    cwd: loop.cwd || cwd,
+                    taskId: loop.taskId,
+                    runContract: {
+                        runId: loop.id,
+                        sessionId,
+                        profile: loop.profile,
+                        workingDirectory: loop.cwd || cwd,
+                        allowedTools: [],
+                        deniedTools: [],
+                        stopConditions: [
+                            "task complete",
+                            "missing input",
+                            "approval required",
+                            "verification failure",
+                            "budget exhausted",
+                        ],
+                        approval: { required: true, approved: loop.approved },
+                        budget: {
+                            timeoutMs: loop.intervalMs,
+                            maxAttempts: loop.maxAttempts,
+                            maxOutputBytes: 1_000_000,
+                        },
+                    },
+                }, runtime);
+                if (session.status !== "completed")
+                    throw new Error(`session ${session.status}`);
+            }
+            catch (error) {
+                recordFailure(loop, error);
+                return { loop, next: "end" };
+            }
+            loop.checkpoint = `Iteration ${loop.iterations} completed; inspect task ${loop.taskId} before continuing.`;
+            loop.lastError = null;
+            loop.nextRunAt = new Date(Date.now() + loop.intervalMs).toISOString();
+            return { loop, next: "verify" };
+        },
+        // A task is only complete when it claims done AND an independent verifier agrees. A
+        // self-reported `state: done` whose checks fail keeps the loop active and records why.
+        async verify(current) {
+            const loop = { ...current };
+            const task = await loopTask(loop, cwd);
+            if (await taskClaimsDone(task.file)) {
+                const outcome = await verifyTask(task.id, tasksRootOf(task), {
+                    cwd: loop.cwd || cwd,
+                    run: options.verifyRun,
+                });
+                if (outcome.passed)
+                    loop.status = "completed";
+                else
+                    loop.lastError = `not complete: ${outcome.reason}`;
+            }
+            return loop;
+        },
+        // Durable per-step checkpoint: survives a cold restart because it is written into the task
+        // file, not just held in loops.json. The result file (an idempotent overwrite) goes first
+        // and the task note (an append that never throws) last, so a retried record adds no
+        // duplicate note.
+        async record(current) {
+            const loop = { ...current };
+            const sessionId = loop.lastSessionId;
+            if (!sessionId)
+                throw new Error("record step reached without a session");
+            const task = await loopTask(loop, cwd);
+            loop.resultPath = await persistWorkerResult(loop, sessionId, "completed");
+            await recordStepCheckpoint(loop, task, tasksRootOf(task), "completed");
+            return loop;
+        },
+    };
+}
+// The loop's task, found where it lives now (renumbered or archived tasks included).
+function loopTask(loop, cwd) {
+    return resolveTaskReference(loop.taskId, {
+        projectId: loop.projectId ?? undefined,
+        cwd: loop.projectId ? undefined : loop.cwd || cwd,
+    });
+}
+const tasksRootOf = (task) => oceanPath(projectDir(task.projectId), "tasks");
+async function recordStepCheckpoint(loop, task, root, status) {
+    try {
+        await checkpointTask(task.id, root, {
+            note: `loop ${loop.id} iteration ${loop.iterations}: session ${status}; ${loop.lastError ?? "verified progress"}`,
+        });
+    }
+    catch {
+        // The task file may live under a non-default project; a missing file must
+        // not crash the loop. Loop-level state in loops.json still persists.
+    }
+}
+async function persistWorkerResult(loop, sessionId, status) {
+    const payload = JSON.stringify({
+        loopId: loop.id,
+        taskId: loop.taskId,
+        iteration: loop.iterations,
+        sessionId,
+        status,
+        checkpoint: loop.checkpoint,
+        lastError: loop.lastError,
+        recordedAt: new Date().toISOString(),
+    }, null, 2);
+    const dir = oceanPath(SYSTEM_DIR, "runs");
+    await mkdir(dir, { recursive: true });
+    const target = resolveWithin(dir, `${sessionId}.json`);
+    const temp = `${target}.${process.pid}.tmp`;
+    await writeFile(temp, `${payload}\n`, { mode: 0o600 });
+    await rename(temp, target);
+    return target;
+}
+export async function runTaskLoopWorker(cwd, runtime, options = {}) {
+    const pollMs = options.pollMs ?? 30_000;
+    while (!options.signal?.aborted) {
+        await runTaskLoopsOnce(cwd, runtime);
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, pollMs);
+            options.signal?.addEventListener("abort", () => {
+                clearTimeout(timer);
+                resolve();
+            }, { once: true });
+        });
+    }
+}
+async function taskClaimsDone(file) {
+    const source = await readFile(file, "utf8");
+    return /^state:\s*done\s*$/m.test(source);
+}
+async function saveLoops(loops) {
+    const target = loopsFile();
+    await mkdir(path.dirname(target), { recursive: true });
+    const temp = `${target}.${process.pid}.tmp`;
+    await writeFile(temp, `${JSON.stringify(loops, null, 2)}\n`, { mode: 0o600 });
+    await rename(temp, target);
+}
+function bounded(value, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max)
+        throw new Error(`Value must be an integer between ${min} and ${max}.`);
+    return value;
+}
+//# sourceMappingURL=task-loop.js.map