@di-code/coding-agent 0.2.1 → 0.2.2

package/dist/rpc/dispatcher.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { redactSensitiveText } from "@di-code/plugin-runtime";
 import { RPC_PROTOCOL_VERSION, RpcProtocolError, } from "./protocol.js";
+const MAX_PROJECTION_BYTES = 256 * 1024;
+const FORBIDDEN_PROJECTION_KEYS = /(?:^|[_-])(path|cwd|root|token|secret|authorization|api[_-]?key)(?:$|[_-])/iu;
 function transcriptEntryIds(tree, leafId) {
     if (!leafId)
         return [];
@@ -108,6 +110,7 @@ export class RpcDispatcher {
     methods;
     onError;
     approvals = new Map();
+    interactions = new Map();
     maxEvents;
     productState;
     productHost;
@@ -168,6 +171,33 @@ export class RpcDispatcher {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
     }
+    /** Publishes a versioned projection only to clients that negotiated projection events. */
+    emitProjection(input) {
+        if (!this.negotiatedEvents.has("projection"))
+            return;
+        if (!isBrowserSafeProjection(input.state)) {
+            this.onError(new Error("Skipped an unsafe extension projection."));
+            return;
+        }
+        const record = {
+            version: RPC_PROTOCOL_VERSION,
+            kind: "event",
+            requestId: input.requestId ?? "projection",
+            sessionId: this.activeSessionId(),
+            sequence: ++this.sequence,
+            event: {
+                type: "projection",
+                namespace: input.namespace,
+                projectionName: input.projectionName,
+                version: input.version,
+                state: structuredClone(input.state),
+            },
+        };
+        this.events.push(record);
+        if (this.events.length > this.maxEvents)
+            this.events.shift();
+        this.emit(record);
+    }
     async dispatch(request) {
         this.pruneOperations();
         if (this.disposed)
@@ -203,6 +233,16 @@ export class RpcDispatcher {
         for (const operation of this.operations.values())
             if (operation.status === "queued" || operation.status === "running")
                 operation.controller.abort();
+        for (const pending of this.approvals.values())
+            pending.resolve(false);
+        this.approvals.clear();
+        for (const pending of this.interactions.values())
+            pending.resolve({
+                requestId: pending.request.requestId,
+                toolCallId: pending.request.toolCallId,
+                status: "disposed",
+            });
+        this.interactions.clear();
         await Promise.allSettled([...this.operations.values()].map((operation) => operation.promise));
         await this.attachments.dispose();
         this.listeners.clear();
@@ -256,13 +296,19 @@ export class RpcDispatcher {
                     });
                 case "get_usage":
                     return this.success(request.id, { method: "get_usage", usage: this.host().usage() });
-                case "list_skills":
+                case "list_skills": {
+                    const host = this.host();
+                    const ui = host.ui();
+                    const skills = ui.availableSkills.map(({ name, description, scope }) => ({ name, description, scope }));
+                    const projectResourcesDetected = host
+                        .startupStatus()
+                        .resourceDiagnostics.some((diagnostic) => diagnostic.kind === "skill" && diagnostic.stage === "trust");
                     return this.success(request.id, {
                         method: "list_skills",
-                        skills: this.host()
-                            .ui()
-                            .availableSkills.map(({ name, description, scope }) => ({ name, description, scope })),
+                        skills,
+                        projectResourcesDetected,
                     });
+                }
                 case "get_resources":
                     return this.success(request.id, {
                         method: "get_resources",
@@ -331,6 +377,22 @@ export class RpcDispatcher {
                         approvalId: request.params.approvalId,
                         approved: request.params.approved,
                     });
+                case "respond_interaction": {
+                    const interactionId = request.params.requestId;
+                    const pending = this.interactions.get(interactionId);
+                    if (pending) {
+                        this.interactions.delete(interactionId);
+                        pending.resolve({
+                            requestId: interactionId,
+                            toolCallId: pending.request.toolCallId,
+                            status: request.params.status,
+                            ...(typeof request.params.approved === "boolean" ? { approved: request.params.approved } : {}),
+                            ...(typeof request.params.value === "string" ? { value: request.params.value } : {}),
+                            ...(typeof request.params.feedback === "string" ? { feedback: request.params.feedback } : {}),
+                        });
+                    }
+                    return this.success(request.id, { method: "respond_interaction", requestId: interactionId });
+                }
                 case "run_command":
                     return this.failure(request.id, "METHOD_NOT_FOUND", "Command execution requires operation dispatch.");
                 default:
@@ -343,8 +405,12 @@ export class RpcDispatcher {
     }
     /** Waits for the browser to approve a specific tool invocation. */
     async requestToolApproval(toolName, parameters, signal) {
-        if (!this.negotiatedEvents.has("tool_approval"))
-            return true;
+        if (!this.negotiatedEvents.has("tool_approval") && !this.negotiatedEvents.has("interaction_request"))
+            return false;
+        if (this.negotiatedEvents.has("interaction_request")) {
+            const result = await this.requestInteraction({ kind: "approval", prompt: `Allow tool ${toolName}?`, toolCallId: randomUUID(), intent: "tool-approval" }, signal);
+            return result.status === "answered" && result.approved === true;
+        }
         const approvalId = randomUUID();
         const requestId = [...this.operations.values()].find((operation) => operation.status === "running")?.requestId ?? approvalId;
         return await new Promise((resolve, reject) => {
@@ -361,7 +427,7 @@ export class RpcDispatcher {
                     resolve(approved);
                 },
             });
-            this.emit({
+            const record = {
                 version: RPC_PROTOCOL_VERSION,
                 kind: "event",
                 requestId,
@@ -373,7 +439,71 @@ export class RpcDispatcher {
                     toolName,
                     arguments: typeof parameters === "object" && parameters !== null ? parameters : {},
                 },
+            };
+            this.events.push(record);
+            if (this.events.length > this.maxEvents)
+                this.events.shift();
+            this.emit(record);
+        });
+    }
+    /** Requests a structured user response through the negotiated interaction channel. */
+    async requestInteraction(input, signal) {
+        if (!this.negotiatedEvents.has("interaction_request")) {
+            throw Object.assign(new Error("No user interaction channel is available."), { code: "INTERACTION_UNAVAILABLE" });
+        }
+        const requestId = input.requestId ?? randomUUID();
+        const request = { ...input, requestId };
+        const existing = this.interactions.get(requestId);
+        if (existing)
+            return await new Promise((resolve) => {
+                const original = existing.resolve;
+                existing.resolve = (result) => {
+                    original(result);
+                    resolve(result);
+                };
+            });
+        return await new Promise((resolve, reject) => {
+            let timer;
+            const abort = () => {
+                this.interactions.delete(requestId);
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                reject(Object.assign(new Error("User interaction was cancelled."), { code: "CANCELLED" }));
+            };
+            if (signal?.aborted)
+                return abort();
+            signal?.addEventListener("abort", abort, { once: true });
+            this.interactions.set(requestId, {
+                request,
+                resolve: (result) => {
+                    signal?.removeEventListener("abort", abort);
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    resolve(result);
+                },
             });
+            if (input.timeoutMs !== undefined) {
+                timer = setTimeout(() => {
+                    const current = this.interactions.get(requestId);
+                    if (!current)
+                        return;
+                    this.interactions.delete(requestId);
+                    signal?.removeEventListener("abort", abort);
+                    resolve({ requestId, toolCallId: input.toolCallId, status: "timeout" });
+                }, input.timeoutMs);
+            }
+            const record = {
+                version: RPC_PROTOCOL_VERSION,
+                kind: "event",
+                requestId,
+                sessionId: this.activeSessionId(),
+                sequence: ++this.sequence,
+                event: { type: "interaction_request", interactionRequestId: requestId, ...request },
+            };
+            this.events.push(record);
+            if (this.events.length > this.maxEvents)
+                this.events.shift();
+            this.emit(record);
         });
     }
     async runOperation(operation, request) {
@@ -729,11 +859,27 @@ export class RpcDispatcher {
             description: skill.description,
             kind: "skill",
         }));
+        if (sessionHost(this.session) && !commands.some((command) => command.name === "plan")) {
+            commands.push({ name: "plan", description: "Enter or leave plan mode.", kind: "command" });
+        }
         return [...commands, ...skills].sort((left, right) => left.name.localeCompare(right.name));
     }
     async runCommand(request, signal) {
         const name = request.params.name;
         const args = request.params.args ?? "";
+        if (name === "plan" && sessionHost(this.session)) {
+            await this.session.planCommand(args);
+            const projection = this.session.planMode();
+            if (projection)
+                this.emitProjection({
+                    namespace: "plan",
+                    projectionName: "mode",
+                    version: 1,
+                    state: projection,
+                    requestId: request.id,
+                });
+            return { method: "run_command", command: name, action: { command: name, args } };
+        }
         if (!this.commandRegistry?.list().some((command) => command.name === name))
             throw new RpcProtocolError("NOT_FOUND", `Unknown command: /${name}`, request.id);
         let action;
@@ -765,9 +911,32 @@ export class RpcDispatcher {
                         "snapshot_required",
                         "session_changed",
                         "tool_approval",
+                        "interaction_request",
                         "product_audit",
+                        "projection",
                     ].includes(event))
                     this.negotiatedEvents.add(event);
+        if (this.negotiatedEvents.has("projection") && sessionHost(this.session)) {
+            const host = this.session;
+            const plan = host.planMode?.();
+            if (plan)
+                this.emitProjection({ namespace: "plan", projectionName: "mode", version: 1, state: plan });
+            for (const projection of host.projections?.() ?? [])
+                this.emitProjection({
+                    namespace: projection.namespace,
+                    projectionName: projection.projectionName,
+                    version: projection.version,
+                    state: projection.state,
+                });
+            const extensions = host.extensions?.();
+            if (extensions)
+                this.emitProjection({
+                    namespace: "extension",
+                    projectionName: "ui",
+                    version: extensions.apiVersion,
+                    state: { badges: extensions.badges, ui: extensions.ui },
+                });
+        }
         return this.success(request.id, {
             method: "get_capabilities",
             methods: RPC_METHODS_FOR_CAPABILITIES,
@@ -858,6 +1027,7 @@ export class RpcDispatcher {
                 },
                 transcript: snapshot.transcript,
                 tree: snapshot.tree,
+                ...(snapshot.events ? { events: snapshot.events } : {}),
                 stats: snapshot.stats,
                 readOnly: true,
             },
@@ -912,6 +1082,27 @@ export class RpcDispatcher {
         });
     }
     onSessionEvent(event) {
+        if (sessionHost(this.session) && this.negotiatedEvents.has("projection")) {
+            const host = this.session;
+            const plan = host.planMode?.();
+            if (plan)
+                this.emitProjection({ namespace: "plan", projectionName: "mode", version: 1, state: plan });
+            for (const projection of host.projections?.() ?? [])
+                this.emitProjection({
+                    namespace: projection.namespace,
+                    projectionName: projection.projectionName,
+                    version: projection.version,
+                    state: projection.state,
+                });
+            const extensions = host.extensions?.();
+            if (extensions)
+                this.emitProjection({
+                    namespace: "extension",
+                    projectionName: "ui",
+                    version: extensions.apiVersion,
+                    state: { badges: extensions.badges, ui: extensions.ui },
+                });
+        }
         const operation = [...this.operations.values()].find((item) => item.status === "running");
         const extended = event.type === "session_changed";
         if (extended && !this.negotiatedEvents.has("session_changed"))
@@ -943,6 +1134,30 @@ export class RpcDispatcher {
         }
     }
 }
+function isBrowserSafeProjection(value) {
+    const visit = (candidate) => {
+        if (candidate === null || typeof candidate === "string" || typeof candidate === "boolean")
+            return true;
+        if (typeof candidate === "number")
+            return Number.isFinite(candidate);
+        if (Array.isArray(candidate))
+            return candidate.every(visit);
+        if (typeof candidate !== "object")
+            return false;
+        for (const [key, item] of Object.entries(candidate))
+            if (FORBIDDEN_PROJECTION_KEYS.test(key) || !visit(item))
+                return false;
+        return true;
+    };
+    if (!visit(value))
+        return false;
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8") <= MAX_PROJECTION_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
 const RPC_METHODS_FOR_CAPABILITIES = [
     "get_state",
     "get_capabilities",