@neuralnomads/codenomad-dev 0.18.0-dev-20260716-40cee071 → 0.18.0-dev-20260720-4c50829d

package/dist/permissions/auto-accept-manager.js

@@ -13,6 +13,12 @@ export class AutoAcceptManager {
         this.pending = new Map();
         /** instanceId:permissionId -> failure count, to stop retrying stuck permissions */
         this.replyAttempts = new Map();
+        this.hydratedInstances = new Set();
+        this.hydration = new Map();
+        this.queuedEvents = new Map();
+        this.instanceGeneration = new Map();
+        this.sessionWorkspaces = new Map();
+        this.mutations = new Map();
     }
     start() {
         if (this.unsubscribe)
@@ -20,8 +26,25 @@ export class AutoAcceptManager {
         const handler = (payload) => {
             if (!payload || !payload.instanceId || !payload.event)
                 return;
+            if (this.deps.persistence && !this.hydratedInstances.has(payload.instanceId)) {
+                const queued = this.queuedEvents.get(payload.instanceId) ?? [];
+                queued.push(payload.event);
+                this.queuedEvents.set(payload.instanceId, queued);
+                void this.hydrateInstance(payload.instanceId).catch((error) => {
+                    this.deps.logger.warn({ instanceId: payload.instanceId, err: error }, "Failed to hydrate persisted Yolo state");
+                });
+                return;
+            }
             this.handleInstanceEvent(payload.instanceId, payload.event);
         };
+        const onStarted = (event) => {
+            const instanceId = event.workspace?.id;
+            if (!instanceId)
+                return;
+            void this.hydrateInstance(instanceId).catch((error) => {
+                this.deps.logger.warn({ instanceId, err: error }, "Failed to hydrate persisted Yolo state");
+            });
+        };
         const onStopped = (event) => {
             if (event?.workspaceId)
                 this.clearInstance(event.workspaceId);
@@ -31,10 +54,12 @@ export class AutoAcceptManager {
                 this.clearInstance(event.workspace.id);
         };
         this.deps.eventBus.on("instance.event", handler);
+        this.deps.eventBus.on("workspace.started", onStarted);
         this.deps.eventBus.on("workspace.stopped", onStopped);
         this.deps.eventBus.on("workspace.error", onError);
         this.unsubscribe = () => {
             this.deps.eventBus.off("instance.event", handler);
+            this.deps.eventBus.off("workspace.started", onStarted);
             this.deps.eventBus.off("workspace.stopped", onStopped);
             this.deps.eventBus.off("workspace.error", onError);
         };
@@ -46,7 +71,51 @@ export class AutoAcceptManager {
     isEnabled(instanceId, sessionId) {
         return this.store.isEnabled(instanceId, sessionId);
     }
+    hydrateInstance(instanceId) {
+        if (!this.deps.persistence || this.hydratedInstances.has(instanceId))
+            return Promise.resolve();
+        const existing = this.hydration.get(instanceId);
+        if (existing)
+            return existing;
+        const generation = this.instanceGeneration.get(instanceId) ?? 0;
+        let hydrated = false;
+        const pending = this.deps.persistence.loadSessions(instanceId).then((sessions) => {
+            if ((this.instanceGeneration.get(instanceId) ?? 0) !== generation)
+                return;
+            this.store.clearInstance(instanceId);
+            const workspaces = new Map();
+            for (const session of sessions) {
+                this.store.upsertSession(instanceId, session);
+                if (session.workspaceId)
+                    workspaces.set(session.id, session.workspaceId);
+            }
+            this.sessionWorkspaces.set(instanceId, workspaces);
+            for (const session of sessions) {
+                if (!session.yoloEnabled || this.store.familyRoot(instanceId, session.id) !== session.id)
+                    continue;
+                this.store.setEnabled(instanceId, session.id, true);
+                this.deps.eventBus.publish({ type: "yolo.stateChanged", instanceId, sessionId: session.id, enabled: true });
+                this.drainPending(instanceId, session.id);
+            }
+            this.hydratedInstances.add(instanceId);
+            hydrated = true;
+        }).finally(() => {
+            if ((this.instanceGeneration.get(instanceId) ?? 0) !== generation)
+                return;
+            this.hydration.delete(instanceId);
+            if (!hydrated)
+                return;
+            const queued = this.queuedEvents.get(instanceId) ?? [];
+            this.queuedEvents.delete(instanceId);
+            for (const event of queued)
+                this.handleInstanceEvent(instanceId, event);
+        });
+        this.hydration.set(instanceId, pending);
+        return pending;
+    }
     toggle(instanceId, sessionId) {
+        if (this.deps.persistence)
+            return this.togglePersisted(instanceId, sessionId);
         const enabled = this.store.toggle(instanceId, sessionId);
         this.deps.eventBus.publish({ type: "yolo.stateChanged", instanceId, sessionId, enabled });
         if (enabled) {
@@ -54,7 +123,61 @@ export class AutoAcceptManager {
         }
         return enabled;
     }
+    async togglePersisted(instanceId, sessionId) {
+        await this.hydrateInstance(instanceId);
+        const generation = this.instanceGeneration.get(instanceId) ?? 0;
+        const mutation = (this.mutations.get(instanceId) ?? Promise.resolve(false)).catch(() => false).then(async () => {
+            if ((this.instanceGeneration.get(instanceId) ?? 0) !== generation) {
+                return this.store.isEnabled(instanceId, sessionId);
+            }
+            const rootSessionId = this.store.familyRoot(instanceId, sessionId);
+            const traversedRootSessionIds = new Set([rootSessionId]);
+            const enabled = !this.store.isEnabled(instanceId, rootSessionId);
+            await this.deps.persistence.persist(instanceId, rootSessionId, enabled, this.sessionWorkspaces.get(instanceId)?.get(rootSessionId));
+            if ((this.instanceGeneration.get(instanceId) ?? 0) !== generation) {
+                return this.store.isEnabled(instanceId, rootSessionId);
+            }
+            let persistedRootSessionId = rootSessionId;
+            let currentRootSessionId = this.store.familyRoot(instanceId, sessionId);
+            while (currentRootSessionId !== persistedRootSessionId) {
+                traversedRootSessionIds.add(currentRootSessionId);
+                await this.deps.persistence.persist(instanceId, currentRootSessionId, enabled, this.sessionWorkspaces.get(instanceId)?.get(currentRootSessionId));
+                if (enabled) {
+                    await this.deps.persistence.persist(instanceId, persistedRootSessionId, false, this.sessionWorkspaces.get(instanceId)?.get(persistedRootSessionId));
+                }
+                persistedRootSessionId = currentRootSessionId;
+                currentRootSessionId = this.store.familyRoot(instanceId, sessionId);
+            }
+            if ((this.instanceGeneration.get(instanceId) ?? 0) !== generation) {
+                return this.store.isEnabled(instanceId, currentRootSessionId);
+            }
+            if (enabled) {
+                this.store.setEnabled(instanceId, currentRootSessionId, true);
+            }
+            else {
+                for (const traversedRootSessionId of traversedRootSessionIds) {
+                    this.store.setEnabled(instanceId, traversedRootSessionId, false);
+                }
+            }
+            this.deps.eventBus.publish({ type: "yolo.stateChanged", instanceId, sessionId: currentRootSessionId, enabled });
+            if (enabled)
+                this.drainPending(instanceId, currentRootSessionId);
+            return enabled;
+        });
+        const settled = mutation.finally(() => {
+            if (this.mutations.get(instanceId) === settled)
+                this.mutations.delete(instanceId);
+        });
+        this.mutations.set(instanceId, settled);
+        return settled;
+    }
     clearInstance(instanceId) {
+        this.instanceGeneration.set(instanceId, (this.instanceGeneration.get(instanceId) ?? 0) + 1);
+        this.hydratedInstances.delete(instanceId);
+        this.hydration.delete(instanceId);
+        this.queuedEvents.delete(instanceId);
+        this.sessionWorkspaces.delete(instanceId);
+        this.mutations.delete(instanceId);
         this.store.clearInstance(instanceId);
         this.pending.delete(instanceId);
         const prefix = `${instanceId}:`;
@@ -101,13 +224,55 @@ export class AutoAcceptManager {
             return;
         const parentId = session.parentID ?? session.parentId ?? null;
         const revert = session.revert ?? undefined;
+        const enabledBefore = this.store.enabledRoots(instanceId);
         this.store.upsertSession(instanceId, { id: session.id, parentId, revert });
+        if (typeof session.workspaceID === "string" && session.workspaceID) {
+            const workspaces = this.sessionWorkspaces.get(instanceId) ?? new Map();
+            workspaces.set(session.id, session.workspaceID);
+            this.sessionWorkspaces.set(instanceId, workspaces);
+        }
+        this.persistRootMigration(instanceId, enabledBefore, this.store.enabledRoots(instanceId));
         // Session ancestry may have changed (parent discovered, revert toggled).
         // Re-drain pending permissions whose family root may have migrated into
         // an enabled family — mirrors the old UI's drainAutoAcceptPermissions-
         // ForInstance trigger on session.updated (#497).
         this.drainPending(instanceId, session.id);
     }
+    persistRootMigration(instanceId, before, after) {
+        if (!this.deps.persistence)
+            return;
+        const removed = before.filter((id) => !after.includes(id));
+        const added = after.filter((id) => !before.includes(id));
+        if (removed.length === 0 && added.length === 0)
+            return;
+        const generation = this.instanceGeneration.get(instanceId) ?? 0;
+        const mutation = (this.mutations.get(instanceId) ?? Promise.resolve(false)).catch(() => false).then(async () => {
+            if ((this.instanceGeneration.get(instanceId) ?? 0) !== generation)
+                return false;
+            const enabledRoots = new Set(this.store.enabledRoots(instanceId));
+            for (const rootSessionId of added) {
+                if (!enabledRoots.has(rootSessionId))
+                    continue;
+                await this.deps.persistence.persist(instanceId, rootSessionId, true, this.sessionWorkspaces.get(instanceId)?.get(rootSessionId));
+            }
+            for (const rootSessionId of removed) {
+                if (enabledRoots.has(rootSessionId))
+                    continue;
+                if ((this.instanceGeneration.get(instanceId) ?? 0) !== generation)
+                    return false;
+                await this.deps.persistence.persist(instanceId, rootSessionId, false, this.sessionWorkspaces.get(instanceId)?.get(rootSessionId));
+            }
+            return false;
+        });
+        const settled = mutation.finally(() => {
+            if (this.mutations.get(instanceId) === settled)
+                this.mutations.delete(instanceId);
+        });
+        this.mutations.set(instanceId, settled);
+        void settled.catch((error) => {
+            this.deps.logger.warn({ instanceId, err: error }, "Failed to migrate persisted Yolo family root");
+        });
+    }
     handlePermissionRequest(instanceId, eventType, permission) {
         const request = permission;
         if (!request)

package/dist/permissions/auto-accept-manager.test.js

@@ -63,6 +63,214 @@ describe("AutoAcceptManager session tree", () => {
         manager.stop();
     });
 });
+describe("AutoAcceptManager persistence", () => {
+    it("hydrates a persisted family root before processing queued permissions", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        let release;
+        const gate = new Promise((resolve) => { release = resolve; });
+        const persistence = {
+            async loadSessions() {
+                await gate;
+                return [
+                    { id: "root", parentId: null, yoloEnabled: true },
+                    { id: "child", parentId: "root", yoloEnabled: false },
+                ];
+            },
+            async persist() { },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier, persistence });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "child", parentID: "root" });
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "permission", sessionID: "child" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        release();
+        await manager.hydrateInstance("inst");
+        await flushMicrotasks();
+        assert.equal(manager.isEnabled("inst", "child"), true);
+        assert.equal(replier.calls.length, 1);
+        manager.stop();
+    });
+    it("persists before enabling memory and emitting feedback", async () => {
+        const bus = new EventBus(noopLogger);
+        const changes = [];
+        bus.on("yolo.stateChanged", (event) => changes.push(event));
+        let release;
+        const gate = new Promise((resolve) => { release = resolve; });
+        const writes = [];
+        const persistence = {
+            async loadSessions() { return [{ id: "root", parentId: null, yoloEnabled: false }]; },
+            async persist(...args) { writes.push(args); await gate; },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier(), persistence });
+        const toggle = manager.toggle("inst", "root");
+        await flushMicrotasks();
+        assert.deepEqual(writes, [["inst", "root", true, undefined]]);
+        assert.equal(manager.isEnabled("inst", "root"), false);
+        assert.equal(changes.length, 0);
+        release();
+        assert.equal(await toggle, true);
+        assert.equal(manager.isEnabled("inst", "root"), true);
+        assert.equal(changes.length, 1);
+    });
+    it("serializes concurrent toggles", async () => {
+        const bus = new EventBus(noopLogger);
+        const writes = [];
+        const persistence = {
+            async loadSessions() { return [{ id: "root", parentId: null, yoloEnabled: false }]; },
+            async persist(_instanceId, _rootSessionId, enabled) { writes.push(enabled); },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier(), persistence });
+        assert.deepEqual(await Promise.all([manager.toggle("inst", "root"), manager.toggle("inst", "root")]), [true, false]);
+        assert.deepEqual(writes, [true, false]);
+        assert.equal(manager.isEnabled("inst", "root"), false);
+    });
+    it("keeps queued permissions until a failed hydration can retry", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        let attempts = 0;
+        const persistence = {
+            async loadSessions() {
+                if (++attempts === 1)
+                    throw new Error("temporary failure");
+                return [{ id: "root", parentId: null, yoloEnabled: true }];
+            },
+            async persist() { },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier, persistence });
+        manager.start();
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "permission", sessionID: "root" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        await manager.hydrateInstance("inst");
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        manager.stop();
+    });
+    it("does not re-enable memory when a persisted toggle finishes after cleanup", async () => {
+        const bus = new EventBus(noopLogger);
+        const changes = [];
+        bus.on("yolo.stateChanged", (event) => changes.push(event));
+        let release;
+        const gate = new Promise((resolve) => { release = resolve; });
+        let writes = 0;
+        const persistence = {
+            async loadSessions() { return [{ id: "root", parentId: null, yoloEnabled: false }]; },
+            async persist() { writes += 1; await gate; },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier(), persistence });
+        const toggle = manager.toggle("inst", "root");
+        const queued = manager.toggle("inst", "root");
+        await flushMicrotasks();
+        manager.clearInstance("inst");
+        release();
+        assert.equal(await toggle, false);
+        assert.equal(await queued, false);
+        assert.equal(writes, 1);
+        assert.equal(manager.isEnabled("inst", "root"), false);
+        assert.equal(changes.length, 0);
+    });
+    it("moves persisted Yolo state when late ancestry changes the family root", async () => {
+        const bus = new EventBus(noopLogger);
+        const writes = [];
+        const persistence = {
+            async loadSessions() {
+                return [
+                    { id: "parent", parentId: null, workspaceId: "workspace", yoloEnabled: false },
+                    { id: "child", parentId: null, workspaceId: "workspace", yoloEnabled: true },
+                ];
+            },
+            async persist(...args) { writes.push(args); },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier(), persistence });
+        manager.start();
+        await manager.hydrateInstance("inst");
+        publishSession(bus, "inst", "session.updated", { id: "child", parentID: "parent", workspaceID: "workspace" });
+        await flushMicrotasks();
+        assert.equal(manager.isEnabled("inst", "parent"), true);
+        assert.deepEqual(writes, [
+            ["inst", "parent", true, "workspace"],
+            ["inst", "child", false, "workspace"],
+        ]);
+        manager.stop();
+    });
+    it("does not re-enable a family when ancestry repeatedly changes during a disable", async () => {
+        const bus = new EventBus(noopLogger);
+        let releaseFirst;
+        let releaseSecond;
+        const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+        const secondGate = new Promise((resolve) => { releaseSecond = resolve; });
+        const writes = [];
+        const persistence = {
+            async loadSessions() {
+                return [
+                    { id: "grandparent", parentId: null, workspaceId: "workspace", yoloEnabled: false },
+                    { id: "parent", parentId: null, workspaceId: "workspace", yoloEnabled: false },
+                    { id: "child", parentId: null, workspaceId: "workspace", yoloEnabled: true },
+                ];
+            },
+            async persist(...args) {
+                writes.push(args);
+                if (writes.length === 1)
+                    await firstGate;
+                if (writes.length === 2)
+                    await secondGate;
+            },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier(), persistence });
+        manager.start();
+        await manager.hydrateInstance("inst");
+        const toggle = manager.toggle("inst", "child");
+        await flushMicrotasks();
+        publishSession(bus, "inst", "session.updated", { id: "child", parentID: "parent", workspaceID: "workspace" });
+        releaseFirst();
+        await flushMicrotasks();
+        publishSession(bus, "inst", "session.updated", { id: "child", parentID: "grandparent", workspaceID: "workspace" });
+        releaseSecond();
+        assert.equal(await toggle, false);
+        await flushMicrotasks();
+        assert.equal(manager.isEnabled("inst", "grandparent"), false);
+        assert.equal(writes.some(([, , enabled]) => enabled === true), false, JSON.stringify(writes));
+        manager.stop();
+    });
+    it("allows a queued toggle to continue after an earlier persistence failure", async () => {
+        const bus = new EventBus(noopLogger);
+        let attempts = 0;
+        const persistence = {
+            async loadSessions() { return [{ id: "root", parentId: null, yoloEnabled: false }]; },
+            async persist() { if (++attempts === 1)
+                throw new Error("write failed"); },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier(), persistence });
+        const first = manager.toggle("inst", "root");
+        const second = manager.toggle("inst", "root");
+        await assert.rejects(Promise.resolve(first), /write failed/);
+        assert.equal(await second, true);
+        assert.equal(manager.isEnabled("inst", "root"), true);
+    });
+    it("does not restore a late hydration after workspace cleanup", async () => {
+        const bus = new EventBus(noopLogger);
+        let release;
+        const gate = new Promise((resolve) => { release = resolve; });
+        const persistence = {
+            async loadSessions() { await gate; return [{ id: "root", parentId: null, yoloEnabled: true }]; },
+            async persist() { },
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier(), persistence });
+        const hydration = manager.hydrateInstance("inst");
+        manager.clearInstance("inst");
+        release();
+        await hydration;
+        assert.equal(manager.isEnabled("inst", "root"), false);
+    });
+});
 describe("AutoAcceptManager permission interception", () => {
     it("auto-replies to a v2 permission on an enabled family", async () => {
         const bus = new EventBus(noopLogger);

package/dist/permissions/auto-accept-store.js

@@ -8,8 +8,8 @@
  *   - a session with a `revert` snapshot is treated as its own root (fork)
  *   - enabling any session enables its whole family root and vice-versa
  *
- * No persistence: state is lost on server restart, matching the "no
- * persistence for now" milestone.
+ * This store remains in-memory; AutoAcceptManager hydrates and persists it
+ * through OpenCode session metadata.
  */
 /**
  * Resolve the family-root session id for `sessionId` by walking the parent
@@ -94,6 +94,9 @@ export class AutoAcceptStore {
         const tree = this.sessions.get(instanceId);
         return resolveFamilyRoot(sessionId, (id) => tree?.get(id));
     }
+    enabledRoots(instanceId) {
+        return [...(this.enabled.get(instanceId) ?? [])];
+    }
     /**
      * Re-resolves every enabled family root for an instance after the session
      * tree changes (new session, updated parent/revert). If a root now resolves

package/dist/permissions/opencode-yolo-metadata.js

@@ -0,0 +1,81 @@
+import { createInstanceClient } from "../workspaces/instance-client";
+const CODENOMAD_METADATA_VERSION = 1;
+const SESSION_LIST_LIMIT = 10_000;
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+export function hasPersistedYolo(sessionId, metadata) {
+    const codenomad = record(record(metadata).codenomad);
+    const yolo = record(codenomad.yolo);
+    return codenomad.version === CODENOMAD_METADATA_VERSION
+        && yolo.enabled === true
+        && yolo.rootSessionId === sessionId;
+}
+export function mergePersistedYolo(metadata, rootSessionId, enabled) {
+    const current = record(metadata);
+    const codenomad = record(current.codenomad);
+    return {
+        ...current,
+        codenomad: {
+            ...codenomad,
+            version: CODENOMAD_METADATA_VERSION,
+            yolo: { enabled, rootSessionId },
+        },
+    };
+}
+export function mergePersistedWorktreeSlug(metadata, worktreeSlug) {
+    const current = record(metadata);
+    const codenomad = record(current.codenomad);
+    return {
+        ...current,
+        codenomad: { ...codenomad, version: CODENOMAD_METADATA_VERSION, worktreeSlug },
+    };
+}
+export function createOpencodeYoloPersistence(workspaceManager, createClient = createInstanceClient) {
+    const writes = new Map();
+    const clientFor = (instanceId) => {
+        const client = createClient(workspaceManager, instanceId);
+        if (!client)
+            throw new Error(`Yolo: instance ${instanceId} has no open port`);
+        return client;
+    };
+    const updateMetadata = (instanceId, sessionId, workspaceId, update) => {
+        const writeKey = sessionId;
+        const write = (writes.get(writeKey) ?? Promise.resolve()).catch(() => undefined).then(async () => {
+            const client = clientFor(instanceId);
+            const scope = { sessionID: sessionId, ...(workspaceId ? { workspace: workspaceId } : {}) };
+            const { data: session } = await client.session.get(scope, { throwOnError: true });
+            const metadata = update(session.metadata);
+            const { data } = await client.session.update({ ...scope, metadata }, { throwOnError: true });
+            return record(data?.metadata ?? metadata);
+        });
+        const settled = write.finally(() => {
+            if (writes.get(writeKey) === settled)
+                writes.delete(writeKey);
+        });
+        writes.set(writeKey, settled);
+        return settled;
+    };
+    return {
+        async loadSessions(instanceId) {
+            const { data } = await clientFor(instanceId).session.list({ scope: "project", limit: SESSION_LIST_LIMIT }, { throwOnError: true });
+            return (data ?? []).map((session) => ({
+                id: session.id,
+                parentId: session.parentID ?? null,
+                revert: session.revert,
+                workspaceId: session.workspaceID,
+                yoloEnabled: hasPersistedYolo(session.id, session.metadata),
+            }));
+        },
+        persist(instanceId, rootSessionId, enabled, workspaceId) {
+            return updateMetadata(instanceId, rootSessionId, workspaceId, (metadata) => mergePersistedYolo(metadata, rootSessionId, enabled)).then(() => undefined);
+        },
+        async hasProjectSession(instanceId, sessionId) {
+            const { data } = await clientFor(instanceId).session.list({ scope: "project", limit: SESSION_LIST_LIMIT }, { throwOnError: true });
+            return (data ?? []).some((session) => session.id === sessionId);
+        },
+        setWorktreeSlug(instanceId, sessionId, worktreeSlug) {
+            return updateMetadata(instanceId, sessionId, undefined, (metadata) => mergePersistedWorktreeSlug(metadata, worktreeSlug));
+        },
+    };
+}

package/dist/permissions/opencode-yolo-metadata.test.js

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createOpencodeYoloPersistence, hasPersistedYolo, mergePersistedYolo } from "./opencode-yolo-metadata";
+describe("OpenCode Yolo metadata", () => {
+    it("preserves unrelated metadata while replacing Yolo state", () => {
+        assert.deepEqual(mergePersistedYolo({ thirdParty: { keep: true }, codenomad: { version: 1, worktreeSlug: "feature" } }, "root", true), {
+            thirdParty: { keep: true },
+            codenomad: { version: 1, worktreeSlug: "feature", yolo: { enabled: true, rootSessionId: "root" } },
+        });
+    });
+    it("accepts only a marker owned by its session", () => {
+        const metadata = mergePersistedYolo({}, "root", true);
+        assert.equal(hasPersistedYolo("root", metadata), true);
+        assert.equal(hasPersistedYolo("fork", metadata), false);
+        assert.equal(hasPersistedYolo("root", mergePersistedYolo({}, "root", false)), false);
+    });
+    it("uses the session workspace for metadata updates", async () => {
+        const calls = [];
+        const client = {
+            session: {
+                async list() { return { data: [{ id: "root", parentID: null, workspaceID: "workspace", metadata: {} }] }; },
+                async get(parameters) { calls.push(parameters); return { data: { metadata: {} } }; },
+                async update(parameters) { calls.push(parameters); return { data: {} }; },
+            },
+        };
+        const persistence = createOpencodeYoloPersistence({}, () => client);
+        const [session] = await persistence.loadSessions("instance");
+        await persistence.persist("instance", "root", true, session?.workspaceId);
+        assert.equal(session?.workspaceId, "workspace");
+        assert.equal(calls[0]?.workspace, "workspace");
+        assert.equal(calls[1]?.workspace, "workspace");
+    });
+    it("serializes Yolo and worktree metadata writes across instances", async () => {
+        let metadata = { thirdParty: true };
+        const client = {
+            session: {
+                async get() { return { data: { metadata } }; },
+                async update(parameters) {
+                    metadata = parameters.metadata;
+                    return { data: { metadata } };
+                },
+            },
+        };
+        const persistence = createOpencodeYoloPersistence({}, () => client);
+        await Promise.all([
+            persistence.persist("instance-a", "root", true),
+            persistence.setWorktreeSlug("instance-b", "root", "feature"),
+        ]);
+        assert.deepEqual(metadata, {
+            thirdParty: true,
+            codenomad: { version: 1, yolo: { enabled: true, rootSessionId: "root" }, worktreeSlug: "feature" },
+        });
+    });
+});