Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

fix(server): auto-reply full-access OpenCode permission asks (#252)

Leo0fef1a80b972
diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
index 5fc61752b..f50fa2987 100644
--- a/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
+++ b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
@@ -2,6 +2,7 @@ import * as NodeAssert from "node:assert/strict";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Context from "effect/Context";
+import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
@@ -48,6 +49,10 @@ class OpenCodeAdapter extends Context.Service<OpenCodeAdapter, OpenCodeAdapterSh
const asThreadId = (value: string): ThreadId => ThreadId.make(value);
+class OpenCodePermissionReplyTimeoutError extends Data.TaggedError(
+ "OpenCodePermissionReplyTimeoutError",
+)<{ readonly message: string }> {}
+
type MessageEntry = {
info: {
id: string;
@@ -82,6 +87,11 @@ const runtimeMock = {
sessionUpdateCalls: [] as Array<{ sessionID: string; permission: unknown }>,
forkCalls: [] as Array<{ sessionID: string; directory?: string }>,
mcpAddCalls: [] as Array<{ name: string; config: unknown }>,
+ permissionReplyCalls: [] as Array<{ requestID: string; reply: string }>,
+ permissionReplyError: null as Error | null,
+ permissionReplyImplementation: null as
+ | ((requestID: string, reply: string, signal?: AbortSignal) => Promise<void>)
+ | null,
},
reset() {
this.state.startCalls.length = 0;
@@ -108,6 +118,9 @@ const runtimeMock = {
this.state.sessionUpdateCalls.length = 0;
this.state.forkCalls.length = 0;
this.state.mcpAddCalls.length = 0;
+ this.state.permissionReplyCalls.length = 0;
+ this.state.permissionReplyError = null;
+ this.state.permissionReplyImplementation = null;
},
};
@@ -239,6 +252,22 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = {
})(),
}),
},
+ permission: {
+ reply: async (
+ { requestID, reply }: { requestID: string; reply: string },
+ options?: { signal?: AbortSignal },
+ ) => {
+ runtimeMock.state.permissionReplyCalls.push({ requestID, reply });
+ if (runtimeMock.state.permissionReplyError) {
+ throw runtimeMock.state.permissionReplyError;
+ }
+ await runtimeMock.state.permissionReplyImplementation?.(
+ requestID,
+ reply,
+ options?.signal,
+ );
+ },
+ },
mcp: {
add: async (input: { name: string; config: unknown }) => {
runtimeMock.state.mcpAddCalls.push(input);
@@ -1789,4 +1818,161 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
yield* adapter.stopSession(threadId);
}).pipe(TestClock.withLive),
);
+
+ it.effect("auto-replies full-access permission asks once without opening a dialog", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-full-access-auto-reply");
+ let markReplyCompleted!: () => void;
+ const replyCompleted = new Promise<void>((resolve) => {
+ markReplyCompleted = resolve;
+ });
+ runtimeMock.state.permissionReplyImplementation = async () => {
+ markReplyCompleted();
+ };
+ runtimeMock.state.subscribedEvents = [
+ {
+ type: "permission.asked",
+ properties: {
+ id: "per_full",
+ sessionID: "http://127.0.0.1:9999/session",
+ permission: "bash",
+ patterns: ["git status"],
+ metadata: {},
+ always: [],
+ },
+ },
+ ];
+ const eventsFiber = yield* adapter.streamEvents.pipe(
+ Stream.filter((event) => event.threadId === threadId),
+ Stream.take(3),
+ Stream.runCollect,
+ Effect.forkChild,
+ );
+
+ yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ });
+ yield* Effect.promise(() => replyCompleted).pipe(
+ Effect.timeoutOrElse({
+ duration: "1 second",
+ orElse: () =>
+ Effect.fail(
+ new OpenCodePermissionReplyTimeoutError({
+ message: "OpenCode permission reply did not complete",
+ }),
+ ),
+ }),
+ TestClock.withLive,
+ );
+ NodeAssert.deepEqual(runtimeMock.state.permissionReplyCalls, [
+ { requestID: "per_full", reply: "once" },
+ ]);
+ yield* adapter.stopSession(threadId);
+
+ const events = Array.from(yield* Fiber.join(eventsFiber));
+ NodeAssert.deepEqual(
+ events.map((event) => event.type),
+ ["session.started", "thread.started", "session.exited"],
+ );
+ }),
+ );
+
+ it.effect("falls back to a permission dialog when full-access auto-reply fails", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-full-access-auto-reply-fail");
+ runtimeMock.state.permissionReplyError = new Error("reply failed");
+ runtimeMock.state.subscribedEvents = [
+ {
+ type: "permission.asked",
+ properties: {
+ id: "per_fail",
+ sessionID: "http://127.0.0.1:9999/session",
+ permission: "edit",
+ patterns: ["src/app.ts"],
+ metadata: {},
+ always: [],
+ },
+ },
+ ];
+ const openedFiber = yield* adapter.streamEvents.pipe(
+ Stream.filter((event) => event.threadId === threadId && event.type === "request.opened"),
+ Stream.runHead,
+ Effect.forkChild,
+ );
+
+ yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ });
+ const opened = Option.getOrThrow(
+ yield* Fiber.join(openedFiber).pipe(Effect.timeout("1 second")),
+ );
+ NodeAssert.equal(opened.requestId, "per_fail");
+
+ yield* adapter.stopSession(threadId);
+ }).pipe(TestClock.withLive),
+ );
+
+ it.effect("aborts a timed-out auto-reply before opening the fallback dialog", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-full-access-auto-reply-timeout");
+ let startReply!: () => void;
+ const replyStarted = new Promise<void>((resolve) => {
+ startReply = resolve;
+ });
+ let aborted = false;
+ runtimeMock.state.permissionReplyImplementation = (_requestID, _reply, signal) =>
+ new Promise<void>((_resolve, reject) => {
+ startReply();
+ signal?.addEventListener(
+ "abort",
+ () => {
+ aborted = true;
+ reject(new Error("permission reply aborted"));
+ },
+ { once: true },
+ );
+ });
+ runtimeMock.state.subscribedEvents = [
+ {
+ type: "permission.asked",
+ properties: {
+ id: "per_timeout",
+ sessionID: "http://127.0.0.1:9999/session",
+ permission: "edit",
+ patterns: ["src/app.ts"],
+ metadata: {},
+ always: [],
+ },
+ },
+ ];
+ const openedFiber = yield* adapter.streamEvents.pipe(
+ Stream.filter((event) => event.threadId === threadId && event.type === "request.opened"),
+ Stream.runHead,
+ Effect.forkChild,
+ );
+
+ yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ });
+ yield* Effect.promise(() => replyStarted);
+ yield* TestClock.adjust("10 seconds");
+ const opened = Option.getOrThrow(yield* Fiber.join(openedFiber));
+ NodeAssert.equal(opened.requestId, "per_timeout");
+ NodeAssert.equal(aborted, true);
+ NodeAssert.deepEqual(runtimeMock.state.permissionReplyCalls, [
+ { requestID: "per_timeout", reply: "once" },
+ ]);
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
});
diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.ts
index 42a8ee7ba..9152e0808 100644
--- a/apps/server/src/provider/Layers/OpenCodeAdapter.ts
+++ b/apps/server/src/provider/Layers/OpenCodeAdapter.ts
@@ -263,6 +263,7 @@ interface OpenCodeSessionContext {
readonly openCodeSessionId: string;
readonly relatedSessionIds: Set<string>;
readonly resolvedRequestIds: Set<string>;
+ readonly autoRepliedRequestIds: Set<string>;
readonly requestRelationRetries: Map<string, OpenCodeRequestRelationRetry>;
readonly pendingPermissions: Map<string, PermissionRequest>;
readonly pendingQuestions: Map<string, QuestionRequest>;
@@ -972,6 +973,50 @@ export function makeOpenCodeAdapter(
if (context.pendingPermissions.has(event.properties.id)) {
return;
}
+ if (context.session.runtimeMode === "full-access") {
+ // Reply "once", not "always": OpenCode stores "always" grants per
+ // directory, so an always from a full-access thread would widen a
+ // supervised thread on the same directory.
+ context.resolvedRequestIds.add(event.properties.id);
+ context.autoRepliedRequestIds.add(event.properties.id);
+ yield* runOpenCodeSdk("permission.reply", (signal) =>
+ context.client.permission.reply(
+ {
+ requestID: event.properties.id,
+ reply: "once",
+ },
+ { signal },
+ ),
+ ).pipe(
+ Effect.timeout("10 seconds"),
+ Effect.matchEffect({
+ onSuccess: () => Effect.void,
+ onFailure: () =>
+ Effect.gen(function* () {
+ context.autoRepliedRequestIds.delete(event.properties.id);
+ context.pendingPermissions.set(event.properties.id, event.properties);
+ yield* emit({
+ ...(yield* buildEventBase({
+ threadId: context.session.threadId,
+ turnId,
+ requestId: event.properties.id,
+ raw: event,
+ })),
+ type: "request.opened",
+ payload: {
+ requestType: mapPermissionToRequestType(event.properties.permission),
+ detail:
+ event.properties.patterns.length > 0
+ ? event.properties.patterns.join("\n")
+ : event.properties.permission,
+ },
+ });
+ }),
+ }),
+ Effect.forkIn(context.sessionScope),
+ );
+ return;
+ }
context.pendingPermissions.set(event.properties.id, event.properties);
yield* emit({
...(yield* buildEventBase({
@@ -994,6 +1039,9 @@ export function makeOpenCodeAdapter(
case "permission.replied": {
context.pendingPermissions.delete(event.properties.requestID);
context.resolvedRequestIds.add(event.properties.requestID);
+ if (context.autoRepliedRequestIds.delete(event.properties.requestID)) {
+ return;
+ }
yield* emit({
...(yield* buildEventBase({
threadId: context.session.threadId,
@@ -1727,6 +1775,7 @@ export function makeOpenCodeAdapter(
openCodeSessionId: started.openCodeSession.id,
relatedSessionIds: new Set([started.openCodeSession.id]),
resolvedRequestIds: new Set(),
+ autoRepliedRequestIds: new Set(),
requestRelationRetries: new Map(),
pendingPermissions: new Map(),
pendingQuestions: new Map(),
diff --git a/apps/server/src/provider/opencodeRuntime.ts b/apps/server/src/provider/opencodeRuntime.ts
index b466159a0..042de675b 100644
--- a/apps/server/src/provider/opencodeRuntime.ts
+++ b/apps/server/src/provider/opencodeRuntime.ts
@@ -97,7 +97,7 @@ export function openCodeRuntimeErrorDetail(cause: unknown): string {
export const runOpenCodeSdk = <A>(
operation: string,
- fn: () => Promise<A>,
+ fn: (signal: AbortSignal) => Promise<A>,
): Effect.Effect<A, OpenCodeRuntimeError> =>
Effect.tryPromise({
try: fn,
diff --git a/docs/internals/providers.md b/docs/internals/providers.md
index 56b49a0ff..25fda48f7 100644
--- a/docs/internals/providers.md
+++ b/docs/internals/providers.md
@@ -63,8 +63,9 @@ a Mastra session is absent.
The legacy OpenCode adapter owns child sessions created for subagents. Permission and question events
from a descendant session are routed onto the parent thread after ancestry is verified. Stop and
interrupt walk the child tree and abort every descendant, not only the parent. Unrelated OpenCode
-sessions are left alone. OpenCode Go stays on the Mastra controller and does not use this adapter
-path.
+sessions are left alone. Full-access threads auto-reply permission asks once, without a dialog, and
+fall back to the dialog if that reply fails. OpenCode Go stays on the Mastra controller and does not
+use this adapter path.
Standard OpenCode discovery probes `opencode --version` for at most four seconds. The probe command
runs in its own process group so a hanging wrapper cannot keep provider status running after the