@neuralnomads/codenomad-dev 0.18.0-dev-20260628-e8623d31 → 0.18.0-dev-20260709-ca06bd99

package/dist/events/bus.js

@@ -27,6 +27,8 @@ export class EventBus extends EventEmitter {
         this.on("instance.dataChanged", handler);
         this.on("instance.event", handler);
         this.on("instance.eventStatus", handler);
+        this.on("yolo.stateChanged", handler);
+        this.on("yolo.autoAccepted", handler);
         return () => {
             this.off("workspace.created", handler);
             this.off("workspace.started", handler);
@@ -40,6 +42,8 @@ export class EventBus extends EventEmitter {
             this.off("instance.dataChanged", handler);
             this.off("instance.event", handler);
             this.off("instance.eventStatus", handler);
+            this.off("yolo.stateChanged", handler);
+            this.off("yolo.autoAccepted", handler);
         };
     }
 }

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

@@ -0,0 +1,215 @@
+import { AutoAcceptStore } from "./auto-accept-store";
+const PERMISSION_ASK_TYPES = new Set(["permission.v2.asked", "permission.asked", "permission.updated"]);
+const PERMISSION_REPLIED_TYPES = new Set(["permission.v2.replied", "permission.replied"]);
+const SESSION_UPSERT_TYPES = new Set(["session.updated", "session.created"]);
+const SESSION_REMOVE_TYPES = new Set(["session.deleted"]);
+export class AutoAcceptManager {
+    constructor(deps) {
+        this.deps = deps;
+        this.store = new AutoAcceptStore();
+        /** instanceId:permissionId entries currently being replied, to dedupe re-emissions */
+        this.inFlight = new Set();
+        /** instanceId -> (permissionId -> pending permission) awaiting a reply */
+        this.pending = new Map();
+        /** instanceId:permissionId -> failure count, to stop retrying stuck permissions */
+        this.replyAttempts = new Map();
+    }
+    start() {
+        if (this.unsubscribe)
+            return;
+        const handler = (payload) => {
+            if (!payload || !payload.instanceId || !payload.event)
+                return;
+            this.handleInstanceEvent(payload.instanceId, payload.event);
+        };
+        const onStopped = (event) => {
+            if (event?.workspaceId)
+                this.clearInstance(event.workspaceId);
+        };
+        const onError = (event) => {
+            if (event?.workspace?.id)
+                this.clearInstance(event.workspace.id);
+        };
+        this.deps.eventBus.on("instance.event", handler);
+        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.stopped", onStopped);
+            this.deps.eventBus.off("workspace.error", onError);
+        };
+    }
+    stop() {
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+    }
+    isEnabled(instanceId, sessionId) {
+        return this.store.isEnabled(instanceId, sessionId);
+    }
+    toggle(instanceId, sessionId) {
+        const enabled = this.store.toggle(instanceId, sessionId);
+        this.deps.eventBus.publish({ type: "yolo.stateChanged", instanceId, sessionId, enabled });
+        if (enabled) {
+            this.drainPending(instanceId, sessionId);
+        }
+        return enabled;
+    }
+    clearInstance(instanceId) {
+        this.store.clearInstance(instanceId);
+        this.pending.delete(instanceId);
+        const prefix = `${instanceId}:`;
+        for (const key of Array.from(this.inFlight.keys())) {
+            if (key.startsWith(prefix))
+                this.inFlight.delete(key);
+        }
+        for (const key of Array.from(this.replyAttempts.keys())) {
+            if (key.startsWith(prefix))
+                this.replyAttempts.delete(key);
+        }
+    }
+    handleInstanceEvent(instanceId, event) {
+        if (!event || typeof event.type !== "string")
+            return;
+        if (SESSION_UPSERT_TYPES.has(event.type)) {
+            this.ingestSession(instanceId, event.properties);
+            return;
+        }
+        if (SESSION_REMOVE_TYPES.has(event.type)) {
+            const info = event.properties?.info;
+            const id = readString(info?.id) ?? readString(event.properties?.id);
+            if (id) {
+                this.store.removeSession(instanceId, id);
+                this.removePendingForSession(instanceId, id);
+            }
+            return;
+        }
+        if (PERMISSION_REPLIED_TYPES.has(event.type)) {
+            this.handlePermissionReplied(instanceId, event.properties);
+            return;
+        }
+        if (PERMISSION_ASK_TYPES.has(event.type)) {
+            this.handlePermissionRequest(instanceId, event.type, event.properties);
+        }
+    }
+    ingestSession(instanceId, properties) {
+        // OpenCode wraps session records under `properties.info` for
+        // session.created/updated/deleted (see SDK EventSessionUpdated). Accept a
+        // flat fallback only for defensive compatibility.
+        const info = properties;
+        const session = (info && typeof info === "object" && "info" in info ? info.info : info);
+        if (!session || typeof session.id !== "string")
+            return;
+        const parentId = session.parentID ?? session.parentId ?? null;
+        const revert = session.revert ?? undefined;
+        this.store.upsertSession(instanceId, { id: session.id, parentId, revert });
+        // 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);
+    }
+    handlePermissionRequest(instanceId, eventType, permission) {
+        const request = permission;
+        if (!request)
+            return;
+        const permissionId = readString(request.id);
+        const sessionId = readString(request.sessionID) ?? readString(request.sessionId);
+        if (!permissionId || !sessionId)
+            return;
+        // Infer source from the event type, but prefer the already-tracked source
+        // for permission.updated (which may belong to a v2 permission).
+        const existing = this.pending.get(instanceId)?.get(permissionId);
+        const source = eventType === "permission.v2.asked" ? "v2" : (existing?.source ?? "legacy");
+        // `permission.updated` represents a detail change for a permission that
+        // is *already* pending. If it is no longer in our pending set it was
+        // already replied to (by us or the user) — skip to avoid a duplicate reply.
+        if (eventType === "permission.updated" && !this.pending.get(instanceId)?.has(permissionId)) {
+            return;
+        }
+        this.addPending(instanceId, { permissionId, sessionId, source });
+        if (!this.store.isEnabled(instanceId, sessionId))
+            return;
+        this.tryAutoAccept(instanceId, permissionId, sessionId, source);
+    }
+    handlePermissionReplied(instanceId, properties) {
+        const request = properties ?? {};
+        const permissionId = readString(request.id) ??
+            readString(request.requestID) ??
+            readString(request.permissionID) ??
+            readString(request.requestId) ??
+            readString(request.permissionId);
+        if (permissionId)
+            this.removePending(instanceId, permissionId);
+    }
+    tryAutoAccept(instanceId, permissionId, sessionId, source) {
+        const key = `${instanceId}:${permissionId}`;
+        if (this.inFlight.has(key))
+            return;
+        const attempts = this.replyAttempts.get(key) ?? 0;
+        if (attempts >= AutoAcceptManager.MAX_REPLY_ATTEMPTS)
+            return;
+        this.inFlight.add(key);
+        this.replyAttempts.set(key, attempts + 1);
+        const reply = { instanceId, permissionId, sessionId, source, reply: "once" };
+        void this.deps.replier(reply)
+            .then(() => {
+            this.replyAttempts.delete(key);
+            this.removePending(instanceId, permissionId);
+            this.deps.eventBus.publish({ type: "yolo.autoAccepted", instanceId, sessionId, permissionId });
+        })
+            .catch((error) => {
+            this.deps.logger.error({ instanceId, permissionId, err: error, attempt: attempts + 1 }, "Yolo auto-accept reply failed");
+            if (attempts + 1 >= AutoAcceptManager.MAX_REPLY_ATTEMPTS) {
+                this.removePending(instanceId, permissionId);
+            }
+        })
+            .finally(() => {
+            this.inFlight.delete(key);
+        });
+    }
+    /** Auto-accept all pending permissions belonging to the same family root. */
+    drainPending(instanceId, sessionId) {
+        const instancePending = this.pending.get(instanceId);
+        if (!instancePending || instancePending.size === 0)
+            return;
+        const root = this.store.familyRoot(instanceId, sessionId);
+        for (const entry of Array.from(instancePending.values())) {
+            if (this.store.familyRoot(instanceId, entry.sessionId) === root) {
+                this.tryAutoAccept(instanceId, entry.permissionId, entry.sessionId, entry.source);
+            }
+        }
+    }
+    addPending(instanceId, entry) {
+        let instancePending = this.pending.get(instanceId);
+        if (!instancePending) {
+            instancePending = new Map();
+            this.pending.set(instanceId, instancePending);
+        }
+        instancePending.set(entry.permissionId, entry);
+    }
+    removePending(instanceId, permissionId) {
+        const instancePending = this.pending.get(instanceId);
+        if (instancePending?.delete(permissionId)) {
+            this.replyAttempts.delete(`${instanceId}:${permissionId}`);
+            if (instancePending.size === 0)
+                this.pending.delete(instanceId);
+        }
+    }
+    removePendingForSession(instanceId, sessionId) {
+        const instancePending = this.pending.get(instanceId);
+        if (!instancePending)
+            return;
+        for (const [permId, entry] of Array.from(instancePending)) {
+            if (entry.sessionId === sessionId) {
+                instancePending.delete(permId);
+                this.replyAttempts.delete(`${instanceId}:${permId}`);
+            }
+        }
+        if (instancePending.size === 0)
+            this.pending.delete(instanceId);
+    }
+}
+AutoAcceptManager.MAX_REPLY_ATTEMPTS = 3;
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}