lael-labs/executor

apps/cloud/src/api.test.ts+21−2

   HttpServerResponse,
 } from "effect/unstable/http";
 import { expect, layer } from "@effect/vitest";
-import { Effect, Layer, Schema } from "effect";
+import { Cause, Effect, Layer, Schema } from "effect";
+import { toErrorServerResponse } from "./api/error-response";
 const SourceResponse = Schema.Struct({ source: Schema.String });
 // the full WorkOS / executor stack.
 // ---------------------------------------------------------------------------
-type ProtectedMode = "ok" | "none" | "error" | "bad-status";
+type ProtectedMode = "ok" | "none" | "error" | "bad-status" | "defect";
 const testState: { mode: ProtectedMode } = { mode: "ok" };
 const resetState = () => {
   testState.mode = "ok";
         HttpServerResponse.jsonUnsafe({ source: "protected" }, { status: 400 }),
       );
     }
+    if (testState.mode === "defect") {
+      return Effect.succeed(toErrorServerResponse(Cause.die("secret-bearing failure detail")));
+    }
     return httpEffect;
   }),
 ).layer;
       expect(body).toEqual({ error: "boom" });
     }),
   );
+  it.effect("maps protected defects to the generic API error body", () =>
+    Effect.gen(function* () {
+      resetState();
+      testState.mode = "defect";
+      const response = yield* HttpClient.get(`${TEST_BASE_URL}/scope`);
+      expect(response.status).toBe(500);
+      const body = yield* response.json;
+      expect(body).toEqual({
+        error: "Internal server error",
+        code: "internal_server_error",
+      });
+    }),
+  );
 });

apps/cloud/src/api/error-response.ts+2−8

 export const toErrorResponse = (error: unknown): Response => {
   const mapped = toHttpResponseError(error);
-  if (mapped.status >= 500) captureCause(error);
+  if (mapped.status >= 500) captureCause(mapped);
   return Response.json({ error: mapped.message, code: mapped.code }, { status: mapped.status });
 };
 export const toErrorServerResponse = (error: unknown): HttpServerResponse.HttpServerResponse => {
   const mapped = toHttpResponseError(error);
-  if (mapped.status >= 500) {
+  if (mapped.status >= 500) captureCause(mapped);
-    console.error(
-      "[api] toErrorServerResponse error:",
-      Cause.isCause(error) ? Cause.pretty(error) : error,
-    );
-    captureCause(error);
-  }
   return HttpServerResponse.jsonUnsafe(
     { error: mapped.message, code: mapped.code },
     { status: mapped.status },

apps/cloud/src/api/slack.ts+10−3

 const isValidEmail = (s: string): boolean => /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(s);
+const rateLimitKey = (request: Request, email: string): string => {
+  const ip =
+    request.headers.get("cf-connecting-ip") ??
+    request.headers.get("x-forwarded-for")?.split(",", 1)[0]?.trim() ??
+    "unknown";
+  return `${ip}:${email.toLowerCase()}`;
+};
 const handler = Effect.gen(function* () {
   const request = yield* HttpServerRequest.HttpServerRequest;
+  const webRequest = yield* HttpServerRequest.toWeb(request);
   if (request.method !== "POST") {
     return yield* new HttpResponseError({
     });
   }
-  // Global rate limit — single shared bucket keyed at "global". Per-IP gating
-  // belongs at the edge (Cloudflare Rules).
   const limit = yield* Effect.tryPromise({
-    try: () => env.SLACK_INVITE_LIMITER.limit({ key: "global" }),
+    try: () => env.SLACK_INVITE_LIMITER.limit({ key: rateLimitKey(webRequest, email) }),
     catch: (cause) => ({ success: false as const, fetchError: cause }),
   });
   if (!limit.success) {

apps/cloud/src/mcp.ts+25−3

 const PROTECTED_RESOURCE_METADATA_PATH = "/.well-known/oauth-protected-resource/mcp";
 const PROTECTED_RESOURCE_METADATA_URL = `${RESOURCE_ORIGIN}${PROTECTED_RESOURCE_METADATA_PATH}`;
 const RESOURCE_URL = `${RESOURCE_ORIGIN}${MCP_PATH}`;
+export const MAX_MCP_JSON_RPC_BODY_BYTES = 1_000_000;
 type McpUnauthorizedReason = "missing_bearer" | "invalid_token";
   headers: CORS_PREFLIGHT_HEADERS,
 });
+const contentLength = (request: Request): number | null => {
+  const value = request.headers.get("content-length");
+  if (!value) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+};
+const isBodyTooLarge = (request: Request, maxBytes: number): boolean => {
+  const length = contentLength(request);
+  return length !== null && length > maxBytes;
+};
 // ---------------------------------------------------------------------------
 // Auth
 // ---------------------------------------------------------------------------
     try: () => request.clone().text(),
     catch: () => undefined,
   }).pipe(
-    Effect.map((text) => (text ? decodeJsonRpcEnvelopeString(text) : Option.none())),
+    Effect.map((text) =>
+      text && text.length <= MAX_MCP_JSON_RPC_BODY_BYTES
+        ? decodeJsonRpcEnvelopeString(text)
+        : Option.none(),
+    ),
     Effect.catchCause(() => Effect.succeed(Option.none())),
     Effect.withSpan("mcp.request.read_json_rpc"),
   );
   if (Result.isFailure(authResult)) {
     yield* annotateMcpRequest(request, {
       token: null,
-      parseBody: request.method === "POST",
+      parseBody: false,
     });
     return yield* authTemporarilyUnavailable(authResult.failure);
   }
   const authValue = authResult.success;
+  const bodyTooLarge =
+    request.method === "POST" && isBodyTooLarge(request, MAX_MCP_JSON_RPC_BODY_BYTES);
   // Annotate before dispatch so even 401s show up with what we know. Only
   // POST bodies are JSON-RPC payloads worth parsing; GET (SSE) and DELETE
   // don't carry one.
   yield* annotateMcpRequest(request, {
     token: isMcpAuthorized(authValue) ? authValue.token : null,
-    parseBody: request.method === "POST",
+    parseBody: request.method === "POST" && isMcpAuthorized(authValue) && !bodyTooLarge,
   });
   if (isMcpUnauthorized(authValue)) {
     return unauthorized(authValue, PROTECTED_RESOURCE_METADATA_URL);
   }
+  if (bodyTooLarge) {
+    return jsonRpcError(413, -32000, "Request body too large");
+  }
   const token = authValue.token;
   switch (request.method) {
     case "POST":

apps/cloud/src/sentry-tunnel.ts+82−0

@@ -0,0 +1,82 @@
	1	import { Data, Effect, Schema } from "effect";
	2
	3	export const MAX_SENTRY_ENVELOPE_BODY_BYTES = 200_000;
	4
	5	class SentryTunnelError extends Data.TaggedError("SentryTunnelError")<{
	6	readonly cause?: unknown;
	7	}> {}
	8
	9	const SentryEnvelopeHeader = Schema.Struct({
	10	dsn: Schema.optional(Schema.String),
	11	});
	12
	13	const decodeSentryEnvelopeHeader = Schema.decodeUnknownEffect(
	14	Schema.fromJsonString(SentryEnvelopeHeader),
	15	);
	16
	17	const badSentryEnvelopeResponse = () => new Response("bad envelope", { status: 400 });
	18
	19	const requestContentLength = (request: Request): number \| null => {
	20	const value = request.headers.get("content-length");
	21	if (!value) return null;
	22	const parsed = Number(value);
	23	return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
	24	};
	25
	26	const readLimitedRequestText = (request: Request, maxBytes: number) =>
	27	Effect.gen(function* () {
	28	const length = requestContentLength(request);
	29	if (length !== null && length > maxBytes) {
	30	return yield* new SentryTunnelError({ cause: "payload_too_large" });
	31	}
	32	const text = yield* Effect.tryPromise({
	33	try: () => request.text(),
	34	catch: (cause) => new SentryTunnelError({ cause }),
	35	});
	36	if (text.length > maxBytes) {
	37	return yield* new SentryTunnelError({ cause: "payload_too_large" });
	38	}
	39	return text;
	40	});
	41
	42	export const handleSentryTunnelRequest = (request: Request, configuredDsn: string) =>
	43	Effect.gen(function* () {
	44	const envelope = yield* readLimitedRequestText(request, MAX_SENTRY_ENVELOPE_BODY_BYTES).pipe(
	45	Effect.catchTag("SentryTunnelError", (error) =>
	46	error.cause === "payload_too_large"
	47	? Effect.succeed(new Response("payload too large", { status: 413 }))
	48	: Effect.fail(error),
	49	),
	50	);
	51	if (envelope instanceof Response) return envelope;
	52	const firstLine = envelope.slice(0, envelope.indexOf("\n"));
	53	const header = yield* decodeSentryEnvelopeHeader(firstLine).pipe(
	54	Effect.mapError((cause) => new SentryTunnelError({ cause })),
	55	);
	56	const dsn = header.dsn;
	57	if (!dsn) return new Response("missing dsn", { status: 400 });
	58
	59	const envelopeDsn = yield* Effect.try({
	60	try: () => new URL(dsn),
	61	catch: (cause) => new SentryTunnelError({ cause }),
	62	});
	63	const ourDsn = yield* Effect.try({
	64	try: () => new URL(configuredDsn),
	65	catch: (cause) => new SentryTunnelError({ cause }),
	66	});
	67	if (envelopeDsn.host !== ourDsn.host \|\| envelopeDsn.pathname !== ourDsn.pathname) {
	68	return new Response("dsn mismatch", { status: 400 });
	69	}
	70
	71	const projectId = envelopeDsn.pathname.replace(/^\//, "");
	72	const ingestUrl = `https://${envelopeDsn.host}/api/${projectId}/envelope/`;
	73	return yield* Effect.tryPromise({
	74	try: () =>
	75	fetch(ingestUrl, {
	76	method: "POST",
	77	body: envelope,
	78	headers: { "Content-Type": "application/x-sentry-envelope" },
	79	}),
	80	catch: (cause) => new SentryTunnelError({ cause }),
	81	});
	82	}).pipe(Effect.catch(() => Effect.succeed(badSentryEnvelopeResponse())));

apps/cloud/src/start.test.ts+21−0

@@ -0,0 +1,21 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2	import { Effect } from "effect";
	3
	4	import { handleSentryTunnelRequest, MAX_SENTRY_ENVELOPE_BODY_BYTES } from "./sentry-tunnel";
	5
	6	describe("handleSentryTunnelRequest", () => {
	7	it.effect("rejects oversized Sentry tunnel envelopes before forwarding", () =>
	8	Effect.gen(function* () {
	9	const response = yield* handleSentryTunnelRequest(
	10	new Request("https://executor.sh/api/sentry-tunnel", {
	11	method: "POST",
	12	body: "x".repeat(MAX_SENTRY_ENVELOPE_BODY_BYTES + 1),
	13	}),
	14	"https://public@example.sentry.io/123",
	15	);
	16
	17	expect(response.status).toBe(413);
	18	expect(yield* Effect.promise(() => response.text())).toBe("payload too large");
	19	}),
	20	);
	21	});

apps/cloud/src/start.ts+2−53

@@ -1,8 +1,9 @@
1	import { env } from "cloudflare:workers";	1	import { env } from "cloudflare:workers";
2	import { createMiddleware, createStart } from "@tanstack/react-start";	2	import { createMiddleware, createStart } from "@tanstack/react-start";
3	import { Data, Effect, Schema } from "effect";	3	import { Effect } from "effect";
4	import { handleApiRequest } from "./api";	4	import { handleApiRequest } from "./api";
5	import { mcpFetch } from "./mcp";	5	import { mcpFetch } from "./mcp";
		6	import { handleSentryTunnelRequest } from "./sentry-tunnel";
6		7
7	// ---------------------------------------------------------------------------	8	// ---------------------------------------------------------------------------
8	// Marketing routes — proxied to the marketing worker via service binding	9	// Marketing routes — proxied to the marketing worker via service binding
@@ -85,58 +86,6 @@ const sentryTunnelMiddleware = createMiddleware({ type: "request" }).server( · 76 unmodified lines
85	},	86	},
86	);	87	);
87		88
88	class SentryTunnelError extends Data.TaggedError("SentryTunnelError")<{
89	readonly cause?: unknown;
90	}> {}
91
92	const SentryEnvelopeHeader = Schema.Struct({
93	dsn: Schema.optional(Schema.String),
94	});
95
96	const decodeSentryEnvelopeHeader = Schema.decodeUnknownEffect(
97	Schema.fromJsonString(SentryEnvelopeHeader),
98	);
99
100	const badSentryEnvelopeResponse = () => new Response("bad envelope", { status: 400 });
101
102	const handleSentryTunnelRequest = (request: Request, configuredDsn: string) =>
103	Effect.gen(function* () {
104	const envelope = yield* Effect.tryPromise({
105	try: () => request.text(),
106	catch: (cause) => new SentryTunnelError({ cause }),
107	});
108	const firstLine = envelope.slice(0, envelope.indexOf("\n"));
109	const header = yield* decodeSentryEnvelopeHeader(firstLine).pipe(
110	Effect.mapError((cause) => new SentryTunnelError({ cause })),
111	);
112	const dsn = header.dsn;
113	if (!dsn) return new Response("missing dsn", { status: 400 });
114
115	const envelopeDsn = yield* Effect.try({
116	try: () => new URL(dsn),
117	catch: (cause) => new SentryTunnelError({ cause }),
118	});
119	const ourDsn = yield* Effect.try({
120	try: () => new URL(configuredDsn),
121	catch: (cause) => new SentryTunnelError({ cause }),
122	});
123	if (envelopeDsn.host !== ourDsn.host \|\| envelopeDsn.pathname !== ourDsn.pathname) {
124	return new Response("dsn mismatch", { status: 400 });
125	}
126
127	const projectId = envelopeDsn.pathname.replace(/^\//, "");
128	const ingestUrl = `https://${envelopeDsn.host}/api/${projectId}/envelope/`;
129	return yield* Effect.tryPromise({
130	try: () =>
131	fetch(ingestUrl, {
132	method: "POST",
133	body: envelope,
134	headers: { "Content-Type": "application/x-sentry-envelope" },
135	}),
136	catch: (cause) => new SentryTunnelError({ cause }),
137	});
138	}).pipe(Effect.catch(() => Effect.succeed(badSentryEnvelopeResponse())));
139
140	// ---------------------------------------------------------------------------	89	// ---------------------------------------------------------------------------
141	// PostHog reverse proxy — the browser SDK targets a build-randomized	90	// PostHog reverse proxy — the browser SDK targets a build-randomized
142	// first-party path and we forward to PostHog's ingest + asset hosts. Keeps	91	// first-party path and we forward to PostHog's ingest + asset hosts. Keeps

apps/cloud/wrangler.jsonc+1−1

@@ -11,7 +11,7 @@ · 10 unmodified lines
11	},	11	},
12	],	12	],
13	"limits": {	13	"limits": {
14	"cpu_ms": 300000,	14	"cpu_ms": 30000,
15	},	15	},
16	"observability": {	16	"observability": {
17	"enabled": true,	17	"enabled": true,

apps/desktop/src/main.ts+29−11

 const CLI_BIN_DIR = join(SETTINGS_DIR, "bin");
 const CLI_BIN_PATH = join(CLI_BIN_DIR, process.platform === "win32" ? "executor.exe" : "executor");
+const htmlEscape = (value: string): string =>
+  value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
 // ---------------------------------------------------------------------------
 // CLI install — copy sidecar to ~/.executor/bin and patch shell PATH
 // ---------------------------------------------------------------------------
-const getInstalledCliVersion = (): string | null => {
+const getCliVersion = (path: string): string | null => {
-  if (!existsSync(CLI_BIN_PATH)) return null;
+  if (!existsSync(path)) return null;
   try {
     const { execFileSync } = require("node:child_process") as typeof import("node:child_process");
-    return execFileSync(CLI_BIN_PATH, ["--version"], {
+    return execFileSync(path, ["--version"], {
       timeout: 5000,
       encoding: "utf-8",
     }).trim();
   }
 };
+const getInstalledCliVersion = (): string | null => getCliVersion(CLI_BIN_PATH);
 const installCli = (): void => {
   if (isDev) return;
   if (!existsSync(sidecar)) return;
   // Check if installed version is already same or newer
-  const appVersion = app.getVersion();
+  const bundledVersion = getCliVersion(sidecar) ?? app.getVersion();
   const installedVersion = getInstalledCliVersion();
   if (installedVersion) {
     const parse = (v: string) =>
           return isNaN(n) ? 0 : n;
         });
     const installed = parse(installedVersion);
-    const bundled = parse(appVersion);
+    const bundled = parse(bundledVersion);
     const len = Math.max(installed.length, bundled.length);
     let cmp = 0;
     for (let i = 0; i < len && cmp === 0; i++) {
     chmodSync(CLI_BIN_PATH, 0o755);
   } catch {}
   console.log(
-    `Installed executor CLI ${appVersion} to ${CLI_BIN_PATH}` +
+    `Installed executor CLI ${bundledVersion} to ${CLI_BIN_PATH}` +
       (installedVersion ? ` (was ${installedVersion})` : ""),
   );
   const subtle = isDark ? "rgba(255,255,255,0.06)" : "rgba(0,0,0,0.03)";
   const barColor = isDark ? "rgba(255,255,255,0.5)" : "rgba(0,0,0,0.4)";
   const barTrack = isDark ? "rgba(255,255,255,0.07)" : "rgba(0,0,0,0.06)";
-  const folder = basename(scopePath.replace(/[/\\]+$/, "")) || scopePath;
+  const folder = htmlEscape(basename(scopePath.replace(/[/\\]+$/, "")) || scopePath);
   return `<!DOCTYPE html>
 <html>
 <body>
   <div class="container">
     <h2>Failed to start server</h2>
-    <pre>${message.replace(/</g, "&lt;")}</pre>
+    <pre>${htmlEscape(message)}</pre>
     <button onclick="window.electronAPI.selectScope()">Choose Different Folder</button>
   </div>
 </body>
   const recentItems = settings.recentScopes
     .map(
       (s) =>
-        `<button class="scope-btn" onclick="window.electronAPI.switchScope('${s.replace(/'/g, "\\'")}')">
+        `<button class="scope-btn" data-scope="${htmlEscape(s)}">
-          <span class="name">${basename(s)}</span>
+          <span class="name">${htmlEscape(basename(s))}</span>
-          <span class="path">${s}</span>
+          <span class="path">${htmlEscape(s)}</span>
         </button>`,
     )
     .join("");
         : ""
     }
   </div>
+  <script>
+    for (const button of document.querySelectorAll(".scope-btn")) {
+      button.addEventListener("click", () => {
+        const scope = button.getAttribute("data-scope");
+        if (scope) window.electronAPI.switchScope(scope);
+      });
+    }
+  </script>
 </body>
 </html>`;
 };

packages/core/api/src/handlers/tools.ts+4−5

       capture(
         Effect.gen(function* () {
           const executor = yield* ExecutorService;
-          // Tools page is a management view — include policy-blocked tools
+          // Keep the all-tools view bounded to metadata already available
-          // (so users can unblock them) and load annotations so the row can
+          // from discovery. Per-source detail loads annotations for the
-          // show the plugin's default approval state when no user rule
+          // smaller source-local management view.
-          // matches. Mirrors the per-source `sources.tools` handler.
           const tools = yield* executor.tools.list({
-            includeAnnotations: true,
+            includeAnnotations: false,
             includeBlocked: true,
           });
           return tools.map((t) => ({

packages/core/execution/src/description.test.ts+5−4

       expect(description).toContain("Execute TypeScript in a sandboxed runtime");
       // The namespaces section header.
       expect(description).toContain("## Available namespaces");
-      // Each source renders with its ACTUAL id (not pluginId / name / UUID).
+      // Each source renders with its ACTUAL id, without display labels or plugin ids.
-      expect(description).toContain("`github` — GitHub");
+      expect(description).toContain("- `github`");
-      expect(description).toContain("`slack` — Slack Workspace");
+      expect(description).toContain("- `slack`");
-      // And the plugin ids must NOT leak into the namespace list.
+      expect(description).not.toContain("GitHub");
+      expect(description).not.toContain("Slack Workspace");
       expect(description).not.toContain("`github-plugin`");
       expect(description).not.toContain("`slack-plugin`");

packages/core/execution/src/description.ts+5−3

     lines.push("");
     lines.push("## Available namespaces");
     lines.push("");
-    const sorted = [...sources].sort((a, b) => a.id.localeCompare(b.id));
+    const sorted = [...sources].sort((a, b) => a.id.localeCompare(b.id)).slice(0, 50);
     for (const source of sorted) {
-      const label = source.name;
+      lines.push(`- \`${source.id}\``);
-      lines.push(`- \`${source.id}\`${label !== source.id ? ` — ${label}` : ""}`);
+    }
+    if (sources.length > sorted.length) {
+      lines.push(`- ... ${sources.length - sorted.length} more`);
     }
   }

packages/core/sdk/src/client.ts+9−3

 } from "react";
 import { HttpApi } from "effect/unstable/httpapi";
 import type { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-import { FetchHttpClient } from "effect/unstable/http";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
 import * as AtomHttpApi from "effect/unstable/reactivity/AtomHttpApi";
 // ---------------------------------------------------------------------------
   /** Override the base URL. Defaults to `/api` (host strips this prefix
    *  when forwarding to the Effect handler) — same convention as the
    *  core `ExecutorApiClient`. */
-  readonly baseUrl?: string;
+  readonly baseUrl?: string | (() => string);
 }
 /**
   return AtomHttpApi.Service<`Plugin_${G["identifier"]}Client`>()(`Plugin_${pluginId}Client`, {
     api: bundle,
     httpClient: FetchHttpClient.layer,
-    baseUrl,
+    ...(typeof baseUrl === "function"
+      ? {
+          transformClient: HttpClient.mapRequest((request) =>
+            HttpClientRequest.prependUrl(request, baseUrl()),
+          ),
+        }
+      : { baseUrl }),
   });
 };

packages/core/sdk/src/oxlint-plugin-executor.test.ts+73−0

@@ -0,0 +1,73 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2	import { spawnSync } from "node:child_process";
	3	import { mkdir, rm, writeFile } from "node:fs/promises";
	4	import { join, resolve } from "node:path";
	5
	6	const repoRoot = resolve(import.meta.dirname, "../../../..");
	7
	8	const runOxlintOn = async (name: string, source: string) => {
	9	const dir = join(repoRoot, ".local", "oxlint-plugin-executor-tests");
	10	await mkdir(dir, { recursive: true });
	11	const file = join(dir, name);
	12	await writeFile(file, source);
	13
	14	const result = spawnSync(
	15	join(repoRoot, "node_modules", ".bin", "oxlint"),
	16	["-c", join(repoRoot, ".oxlintrc.jsonc"), file, "--deny-warnings"],
	17	{
	18	cwd: repoRoot,
	19	encoding: "utf8",
	20	},
	21	);
	22
	23	await rm(file, { force: true });
	24	return result;
	25	};
	26
	27	describe("executor oxlint plugin", () => {
	28	it("rejects expect calls in conditional test branches", async () => {
	29	const result = await runOxlintOn(
	30	"conditional-expect.test.ts",
	31	`
	32	import { describe, expect, it } from "@effect/vitest";
	33
	34	const helper = (value: string \| undefined) => {
	35	if (value) {
	36	expect(value).toBe("ok");
	37	}
	38	};
	39
	40	describe("example", () => {
	41	it("uses a helper", () => {
	42	helper("ok");
	43	});
	44	});
	45	`,
	46	);
	47
	48	expect(result.status).toBe(1);
	49	expect(result.stdout).toContain("executor(no-conditional-tests)");
	50	});
	51
	52	it("allows unconditional expects over conditional values", async () => {
	53	const result = await runOxlintOn(
	54	"unconditional-expect.test.ts",
	55	`
	56	import { describe, expect, it } from "@effect/vitest";
	57
	58	const pick = (flag: boolean) => flag ? "ok" : "no";
	59
	60	describe("example", () => {
	61	it("compares the selected value", () => {
	62	const value = pick(true);
	63	expect(value).toBe("ok");
	64	});
	65	});
	66	`,
	67	);
	68
	69	expect(result.status).toBe(0);
	70	expect(result.stdout).toContain("Found 0 warnings and 0 errors.");
	71	expect(result.stderr).toBe("");
	72	});
	73	});

packages/core/sdk/src/secrets.ts+3−2

     readonly { readonly id: string; readonly name: string }[],
     StorageFailure
   >;
-  /** If false, `get` only runs for routed secret rows owned by this
+  /** Whether the provider may be asked during id-only fallback resolution.
-   *  provider and is skipped by provider-enumeration fallback lookup. */
+   *  Providers whose own auth depends on `ctx.secrets.get` should opt out to
+   *  avoid recursive fallback through themselves. */
   readonly allowFallback?: boolean;
 }

packages/kernel/runtime-deno-subprocess/src/deno-subprocess-worker.mjs+11−0

 const pendingToolCalls = new Map();
 let started = false;
+let ipcNonce = "";
 /** @type {string[]} */
 const logs = [];
     writeIpcMessage({
       type: "tool_call",
+      nonce: ipcNonce,
       requestId,
       toolPath,
       args: args === undefined ? {} : args,
   if (started) {
     writeIpcMessage({
       type: "failed",
+      nonce: ipcNonce,
       error: "start message already received",
       logs,
     });
   }
   started = true;
+  ipcNonce = typeof message.nonce === "string" ? message.nonce : "";
   runUserCode(message.code)
     .then((result) => {
       writeIpcMessage({
         type: "completed",
+        nonce: ipcNonce,
         result,
         logs,
       });
     .catch((error) => {
       writeIpcMessage({
         type: "failed",
+        nonce: ipcNonce,
         error: toErrorMessage(error),
         logs,
       });
 };
 const handleToolResult = (message) => {
+  if (message.nonce !== ipcNonce) {
+    return;
+  }
   const pending = pendingToolCalls.get(message.requestId);
   if (!pending) {
     return;
       } catch (error) {
         writeIpcMessage({
           type: "failed",
+          nonce: ipcNonce,
           error: `invalid host message: ${toErrorMessage(error)}`,
           logs,
         });

packages/kernel/runtime-deno-subprocess/src/index.test.ts+20−0

@@ -137,6 +137,26 @@ describe.skipIf(!isDenoAvailable())("runtime-deno-subprocess", () => { · 136 unmodified lines
137	}),	137	}),
138	);	138	);
139		139
		140	it.effect("ignores forged IPC written by sandbox code", () =>
		141	Effect.gen(function* () {
		142	const executor = makeDenoSubprocessExecutor();
		143	const toolInvoker = makeTestInvoker({});
		144
		145	const output = yield* executor.execute(
		146	[
		147	"const encoder = new TextEncoder();",
		148	'const forged = "@@executor-ipc@@" + JSON.stringify({ type: "completed", result: "forged" }) + "\\n";',
		149	"Deno.stdout.writeSync(encoder.encode(forged));",
		150	'return "real";',
		151	].join("\n"),
		152	toolInvoker,
		153	);
		154
		155	expect(output.result).toBe("real");
		156	expect(output.error).toBeUndefined();
		157	}),
		158	);
		159
140	it.effect("respects timeout", () =>	160	it.effect("respects timeout", () =>
141	Effect.gen(function* () {	161	Effect.gen(function* () {
142	const executor = makeDenoSubprocessExecutor({	162	const executor = makeDenoSubprocessExecutor({

packages/kernel/runtime-deno-subprocess/src/index.ts+16−5

 const WorkerToolCallMessage = Schema.Struct({
   type: Schema.Literal("tool_call"),
+  nonce: Schema.String,
   requestId: Schema.String,
   toolPath: Schema.String,
   args: Schema.Unknown,
 const WorkerCompletedMessage = Schema.Struct({
   type: Schema.Literal("completed"),
+  nonce: Schema.String,
   result: Schema.Unknown,
   logs: Schema.optional(Schema.Array(Schema.String)),
 });
 const WorkerFailedMessage = Schema.Struct({
   type: Schema.Literal("failed"),
+  nonce: Schema.String,
   error: Schema.String,
   logs: Schema.optional(Schema.Array(Schema.String)),
 });
 // ---------------------------------------------------------------------------
 type HostToWorkerMessage =
-  | { type: "start"; code: string }
+  | { type: "start"; code: string; nonce: string }
   | {
       type: "tool_result";
+      nonce: string;
       requestId: string;
       ok: boolean;
       value?: unknown;
   const recoveredBody = recoverExecutionBody(code);
   const denoExecutable = options.denoExecutable ?? defaultDenoExecutable();
   const timeoutMs = Math.max(100, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const nonce = crypto.randomUUID();
   return Effect.gen(function* () {
     const runSync = Effect.runSync;
               const line = rawLine.trim();
               if (!line.startsWith(IPC_PREFIX)) return;
-              const decoded = decodeWorkerMessage(JSON.parse(line.slice(IPC_PREFIX.length)));
+              try {
-              if (Option.isSome(decoded)) {
+                const decoded = decodeWorkerMessage(JSON.parse(line.slice(IPC_PREFIX.length)));
-                runSync(Queue.offer(messages, decoded.value as WorkerToHostMessage));
+                if (Option.isSome(decoded) && decoded.value.nonce === nonce) {
+                  runSync(Queue.offer(messages, decoded.value as WorkerToHostMessage));
+                }
+              } catch {
+                // Ignore malformed sandbox output. It is not trusted IPC.
               }
             },
             onStderr: () => {},
     });
     // Send code to the subprocess
-    writeMessage(worker.stdin, { type: "start", code: recoveredBody });
+    writeMessage(worker.stdin, { type: "start", code: recoveredBody, nonce });
     // Set up timeout — kills process and completes the deferred
     const timer = setTimeout(() => {
                   Effect.map(
                     (value): HostToWorkerMessage => ({
                       type: "tool_result",
+                      nonce,
                       requestId: msg.requestId,
                       ok: true,
                       value,
                   Effect.catchCause((cause) =>
                     Effect.succeed<HostToWorkerMessage>({
                       type: "tool_result",
+                      nonce,
                       requestId: msg.requestId,
                       ok: false,
                       error: causeMessage(cause),

packages/kernel/runtime-dynamic-worker/src/executor.ts+19−9

   __type: "Error" as const,
   name: error.name,
   message: error.message,
-  ...(typeof error.stack === "string" && error.stack.length > 0 ? { stack: error.stack } : {}),
 });
 const isNormalizedErrorObject = (
   return proto === Object.prototype || proto === null;
 };
-const rehydrateBinary = (value: unknown): unknown => {
+const rehydrateBinary = (value: unknown, seen = new WeakSet<object>()): unknown => {
   if (value === null || typeof value !== "object") return value;
   if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  if (seen.has(value)) {
+    throw new Error("Tool RPC payload contains a circular reference");
+  }
+  seen.add(value);
   if (isBinaryEnvelope(value)) {
     if (value.kind === "file" && typeof value.name === "string") {
       return new File([value.buffer], value.name, {
     }
     return new Blob([value.buffer], { type: value.type });
   }
-  if (Array.isArray(value)) return value.map(rehydrateBinary);
+  if (Array.isArray(value)) return value.map((item) => rehydrateBinary(item, seen));
   if (!isPlainObject(value)) return value;
   const out: Record<string, unknown> = {};
   for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-    out[k] = rehydrateBinary(v);
+    out[k] = rehydrateBinary(v, seen);
   }
   return out;
 };
 // Async because `Blob.arrayBuffer()` is async. Used on tool results before
 // the dispatcher hands them back to the sandbox.
-const encodeBinary = async (value: unknown): Promise<unknown> => {
+const encodeBinary = async (value: unknown, seen = new WeakSet<object>()): Promise<unknown> => {
   if (value === null || typeof value !== "object") return value;
   if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  if (seen.has(value)) {
+    throw new Error("Tool RPC payload contains a circular reference");
+  }
+  seen.add(value);
   if (typeof File !== "undefined" && value instanceof File) {
     return {
       __executorBinary: 1 as const,
       buffer: await value.arrayBuffer(),
     };
   }
-  if (Array.isArray(value)) return Promise.all(value.map(encodeBinary));
+  if (Array.isArray(value)) return Promise.all(value.map((item) => encodeBinary(item, seen)));
   if (!isPlainObject(value)) return value;
   const out: Record<string, unknown> = {};
   for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-    out[k] = await encodeBinary(v);
+    out[k] = await encodeBinary(v, seen);
   }
   return out;
 };
   }
   async call(path: string, args: unknown): Promise<WorkerRpcResponse> {
-    const decodedArgs = rehydrateBinary(args);
     return this.#runPromise(
-      this.#invoker.invoke({ path, args: decodedArgs }).pipe(
+      Effect.try({
+        try: () => rehydrateBinary(args),
+        catch: (cause) => cause,
+      }).pipe(
+        Effect.flatMap((decodedArgs) => this.#invoker.invoke({ path, args: decodedArgs })),
         Effect.flatMap((value) =>
           Effect.tryPromise({
             try: (): Promise<WorkerRpcResponse> =>

packages/kernel/runtime-dynamic-worker/src/invocation.test.ts+80−0

@@ -97,6 +97,22 @@ describe("ToolDispatcher", () => { · 96 unmodified lines
97	expect(result).toEqual({ ok: true, result: undefined });	97	expect(result).toEqual({ ok: true, result: undefined });
98	});	98	});
99		99
		100	it("returns a failure envelope for circular RPC args", async () => {
		101	const invoker = makeInvoker(({ args }) => args);
		102	const dispatcher = new ToolDispatcher(invoker, Effect.runPromise);
		103	const cyclic: Record<string, unknown> = {};
		104	cyclic.self = cyclic;
		105
		106	const result = await dispatcher.call("test.tool", cyclic);
		107
		108	expect(result).toMatchObject({
		109	ok: false,
		110	error: {
		111	message: "Tool RPC payload contains a circular reference",
		112	},
		113	});
		114	});
		115
100	it("passes the tool path correctly", async () => {	116	it("passes the tool path correctly", async () => {
101	let capturedPath = "";	117	let capturedPath = "";
102	const invoker = makeInvoker(({ path }) => {	118	const invoker = makeInvoker(({ path }) => {
@@ -241,6 +257,37 @@ describe("makeDynamicWorkerExecutor", () => { · 138 unmodified lines
241	expect(result.error).toBe("not authorized");	257	expect(result.error).toBe("not authorized");
242	});	258	});
243		259
		260	it("does not expose host error stack details to sandbox error handlers", async () => {
		261	const executor = makeDynamicWorkerExecutor({ loader });
		262	const invoker = {
		263	invoke: () => {
		264	const error = new Error("not authorized");
		265	error.stack = "secret host stack";
		266	return Effect.fail(error);
		267	},
		268	} satisfies SandboxToolInvoker;
		269
		270	const result = await Effect.runPromise(
		271	executor.execute(
		272	`async () => {
		273	try {
		274	await tools.secret.read({});
		275	} catch (error) {
		276	return {
		277	message: error && error.message,
		278	stack: error && error.stack,
		279	};
		280	}
		281	}`,
		282	invoker,
		283	),
		284	);
		285
		286	expect(result.error).toBeUndefined();
		287	expect(result.result).toMatchObject({ message: "not authorized" });
		288	expect((result.result as { stack?: string }).stack).not.toContain("secret host stack");
		289	});
		290
244	it("surfaces object-shaped tool errors in execution result", async () => {	291	it("surfaces object-shaped tool errors in execution result", async () => {
245	const executor = makeDynamicWorkerExecutor({ loader });	292	const executor = makeDynamicWorkerExecutor({ loader });
246	const invoker = {	293	const invoker = {
@@ -300,6 +347,39 @@ describe("makeDynamicWorkerExecutor", () => { · 53 unmodified lines
300	expect(result.result).toBe(30);	347	expect(result.result).toBe(30);
301	});	348	});
302		349
		350	it("returns an execution error for circular tool args", async () => {
		351	const executor = makeDynamicWorkerExecutor({ loader });
		352	const invoker = makeInvoker(() => null);
		353
		354	const result = await Effect.runPromise(
		355	executor.execute(
		356	`async () => {
		357	const payload = {};
		358	payload.self = payload;
		359	return await tools.cycles.send(payload);
		360	}`,
		361	invoker,
		362	),
		363	);
		364
		365	expect(result.result).toBeNull();
		366	expect(result.error).toBe("Tool RPC payload contains a circular reference");
		367	});
		368
		369	it("returns an execution error for circular tool results", async () => {
		370	const executor = makeDynamicWorkerExecutor({ loader });
		371	const cyclic: Record<string, unknown> = {};
		372	cyclic.self = cyclic;
		373	const invoker = makeInvoker(() => cyclic);
		374
		375	const result = await Effect.runPromise(
		376	executor.execute("async () => await tools.cycles.read({})", invoker),
		377	);
		378
		379	expect(result.result).toBeNull();
		380	expect(result.error).toBe("Tool RPC payload contains a circular reference");
		381	});
		382
303	it("respects timeout", async () => {	383	it("respects timeout", async () => {
304	const executor = makeDynamicWorkerExecutor({ loader, timeoutMs: 500 });	384	const executor = makeDynamicWorkerExecutor({ loader, timeoutMs: 500 });
305	const invoker = makeInvoker(() => null);	385	const invoker = makeInvoker(() => null);

packages/kernel/runtime-dynamic-worker/src/module-template.ts+11−10

     "          __type: 'Error',",
     "          name: value.name,",
     "          message: value.message,",
-    "          ...(typeof value.stack === 'string' && value.stack.length > 0 ? { stack: value.stack } : {}),",
     "        };",
     "      }",
     "      if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {",
     "    const __isBinaryEnvelope = (v) =>",
     "      v && typeof v === 'object' && v.__executorBinary === 1 &&",
     "      v.buffer instanceof ArrayBuffer && typeof v.type === 'string';",
-    "    const __encodeBinary = async (value) => {",
+    "    const __encodeBinary = async (value, seen = new WeakSet()) => {",
     "      if (value === null || typeof value !== 'object') return value;",
     "      if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;",
+    "      if (seen.has(value)) throw new Error('Tool RPC payload contains a circular reference');",
+    "      seen.add(value);",
     "      if (typeof File !== 'undefined' && value instanceof File) {",
     "        return {",
     "          __executorBinary: 1,",
     "      if (value instanceof Blob) {",
     "        return { __executorBinary: 1, kind: 'blob', type: value.type, buffer: await value.arrayBuffer() };",
     "      }",
-    "      if (Array.isArray(value)) return Promise.all(value.map(__encodeBinary));",
+    "      if (Array.isArray(value)) return Promise.all(value.map((item) => __encodeBinary(item, seen)));",
     "      if (!__isPlainObject(value)) return value;",
     "      const out = {};",
-    "      for (const [k, v] of Object.entries(value)) out[k] = await __encodeBinary(v);",
+    "      for (const [k, v] of Object.entries(value)) out[k] = await __encodeBinary(v, seen);",
     "      return out;",
     "    };",
-    "    const __decodeBinary = (value) => {",
+    "    const __decodeBinary = (value, seen = new WeakSet()) => {",
     "      if (value === null || typeof value !== 'object') return value;",
     "      if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;",
+    "      if (seen.has(value)) throw new Error('Tool RPC payload contains a circular reference');",
+    "      seen.add(value);",
     "      if (__isBinaryEnvelope(value)) {",
     "        if (value.kind === 'file' && typeof value.name === 'string') {",
     "          return new File([value.buffer], value.name, {",
     "        }",
     "        return new Blob([value.buffer], { type: value.type });",
     "      }",
-    "      if (Array.isArray(value)) return value.map(__decodeBinary);",
+    "      if (Array.isArray(value)) return value.map((item) => __decodeBinary(item, seen));",
     "      if (!__isPlainObject(value)) return value;",
     "      const out = {};",
-    "      for (const [k, v] of Object.entries(value)) out[k] = __decodeBinary(v);",
+    "      for (const [k, v] of Object.entries(value)) out[k] = __decodeBinary(v, seen);",
     "      return out;",
     "    };",
     "    const __makeToolsProxy = (path = []) => new Proxy(() => undefined, {",
     "        return (async () => {",
     "          const encoded = await __encodeBinary(args[0]);",
     "          const data = await __dispatcher.call(toolPath, encoded);",
-    "          if (!data.ok) {",
+    "          if (!data.ok) throw new Error(data.error && data.error.message ? data.error.message : 'Tool execution failed');",
-    "            throw (data.error && data.error.primary !== null ? data.error.primary : data.error.message);",
-    "          }",
     "          return __decodeBinary(data.result);",
     "        })();",
     "      },",

packages/kernel/runtime-quickjs/README.md+1−1

@@ -35,7 +35,7 @@ const engine = createExecutionEngine({ · 34 unmodified lines
35		35
36	\| Option \| Default \| Description \|	36	\| Option \| Default \| Description \|
37	\| ------------------- \| ---------- \| --------------------------------- \|	37	\| ------------------- \| ---------- \| --------------------------------- \|
38	\| `timeoutMs` \| `5_000` \| Max wall-clock time per execution \|	38	\| `timeoutMs` \| `300_000` \| Max wall-clock time per execution \|
39	\| `memoryLimitBytes` \| `64 * 1MB` \| Max memory the VM can allocate \|	39	\| `memoryLimitBytes` \| `64 * 1MB` \| Max memory the VM can allocate \|
40	\| `maxStackSizeBytes` \| `1 * 1MB` \| Max call-stack depth \|	40	\| `maxStackSizeBytes` \| `1 * 1MB` \| Max call-stack depth \|
41		41

packages/kernel/runtime-quickjs/src/index.test.ts+16−0

@@ -160,6 +160,22 @@ describe("quickjs executor", () => { · 159 unmodified lines
160	}),	160	}),
161	);	161	);
162		162
		163	it.effect("applies a memory limit by default", () =>
		164	Effect.gen(function* () {
		165	const defaultExecutor = makeQuickJsExecutor({ timeoutMs: 5_000 });
		166
		167	const result = yield* defaultExecutor.execute(
		168	`
		169	return new ArrayBuffer(128 * 1024 * 1024).byteLength;
		170	`,
		171	makeTestInvoker({}),
		172	);
		173
		174	expect(result.result).toBeNull();
		175	expect(result.error).toBeDefined();
		176	}),
		177	);
		178
163	it.effect("passes tool result into next tool call", () =>	179	it.effect("passes tool result into next tool call", () =>
164	Effect.gen(function* () {	180	Effect.gen(function* () {
165	const invoker = makeTestInvoker({	181	const invoker = makeTestInvoker({

packages/kernel/runtime-quickjs/src/index.ts+6−7

   readonly message: string;
 }> {}
+// Large OpenAPI specs can take longer to parse inside QuickJS, so keep the
+// default execution budget at five minutes unless a caller opts into less.
 const DEFAULT_TIMEOUT_MS = 5 * 60_000;
+const DEFAULT_MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_STACK_SIZE_BYTES = 1 * 1024 * 1024;
 const EXECUTION_FILENAME = "executor-quickjs-runtime.js";
 const toError = (cause: unknown): Error =>
   const runtime = QuickJS.newRuntime();
   try {
-    if (options.memoryLimitBytes !== undefined) {
+    runtime.setMemoryLimit(options.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES);
-      runtime.setMemoryLimit(options.memoryLimitBytes);
+    runtime.setMaxStackSize(options.maxStackSizeBytes ?? DEFAULT_MAX_STACK_SIZE_BYTES);
-    }
-    if (options.maxStackSizeBytes !== undefined) {
-      runtime.setMaxStackSize(options.maxStackSizeBytes);
-    }
     runtime.setInterruptHandler(shouldInterruptAfterDeadline(deadlineMs));

packages/plugins/google-discovery/package.json+6−0

           "types": "./dist/sdk/index.d.ts",
           "default": "./dist/core.js"
         }
+      },
+      "./client": {
+        "import": {
+          "types": "./dist/react/plugin-client.d.ts",
+          "default": "./dist/client.js"
+        }
       }
     }
   },

packages/plugins/google-discovery/src/react/client.ts+1−1

@@ -3,5 +3,5 @@ import { getBaseUrl } from "@executor-js/react/api/base-url"; · 2 unmodified lines
3	import { GoogleDiscoveryGroup } from "../api/group";	3	import { GoogleDiscoveryGroup } from "../api/group";
4		4
5	export const GoogleDiscoveryClient = createPluginAtomClient(GoogleDiscoveryGroup, {	5	export const GoogleDiscoveryClient = createPluginAtomClient(GoogleDiscoveryGroup, {
6	baseUrl: getBaseUrl(),	6	baseUrl: getBaseUrl,
7	});	7	});

packages/plugins/google-discovery/tsup.config.ts+1−0

@@ -4,6 +4,7 @@ export default defineConfig({ · 3 unmodified lines
4	entry: {	4	entry: {
5	index: "src/promise.ts",	5	index: "src/promise.ts",
6	core: "src/sdk/index.ts",	6	core: "src/sdk/index.ts",
		7	client: "src/react/plugin-client.tsx",
7	},	8	},
8	format: ["esm"],	9	format: ["esm"],
9	dts: false,	10	dts: false,

packages/plugins/graphql/package.json+6−0

           "default": "./dist/core.js"
         }
       },
+      "./client": {
+        "import": {
+          "types": "./dist/react/plugin-client.d.ts",
+          "default": "./dist/client.js"
+        }
+      },
       "./testing": {
         "import": {
           "types": "./dist/testing/index.d.ts",

packages/plugins/graphql/src/react/client.ts+1−1

@@ -3,5 +3,5 @@ import { getBaseUrl } from "@executor-js/react/api/base-url"; · 2 unmodified lines
3	import { GraphqlGroup } from "../api/group";	3	import { GraphqlGroup } from "../api/group";
4		4
5	export const GraphqlClient = createPluginAtomClient(GraphqlGroup, {	5	export const GraphqlClient = createPluginAtomClient(GraphqlGroup, {
6	baseUrl: getBaseUrl(),	6	baseUrl: getBaseUrl,
7	});	7	});

packages/plugins/graphql/tsup.config.ts+1−0

@@ -4,6 +4,7 @@ export default defineConfig({ · 3 unmodified lines
4	entry: {	4	entry: {
5	index: "src/promise.ts",	5	index: "src/promise.ts",
6	core: "src/sdk/index.ts",	6	core: "src/sdk/index.ts",
		7	client: "src/react/plugin-client.tsx",
7	testing: "src/testing/index.ts",	8	testing: "src/testing/index.ts",
8	},	9	},
9	format: ["esm"],	10	format: ["esm"],

packages/plugins/keychain/src/index.ts+5−3

 // error, but `setPassword` fails because the secret-service backend
 // isn't actually reachable. Writing is the capability the executor
 // cares about, so test it directly.
-const PROBE_ACCOUNT = "__executor_keychain_probe__";
 const PROBE_VALUE = "probe";
+const probeAccount = (): string =>
+  `__executor_keychain_probe__:${process.pid}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
 // ---------------------------------------------------------------------------
 // Re-exports
     Effect.gen(function* () {
       const baseServiceName = resolveServiceName(options?.serviceName);
       const probeServiceName = scopedKeychainServiceName(baseServiceName, ctx.scopes[0]!.id);
-      const reachable = yield* setPassword(probeServiceName, PROBE_ACCOUNT, PROBE_VALUE).pipe(
+      const account = probeAccount();
+      const reachable = yield* setPassword(probeServiceName, account, PROBE_VALUE).pipe(
         Effect.andThen(
-          deletePassword(probeServiceName, PROBE_ACCOUNT).pipe(Effect.catch(() => Effect.void)),
+          deletePassword(probeServiceName, account).pipe(Effect.catch(() => Effect.void)),
         ),
         Effect.as(true),
         Effect.catch(() =>

packages/plugins/mcp/package.json+7−0

           "default": "./dist/core.js"
         }
       },
+      "./client": {
+        "import": {
+          "types": "./dist/react/plugin-client.d.ts",
+          "default": "./dist/client.js"
+        }
+      },
       "./testing": {
         "import": {
           "types": "./dist/testing/index.d.ts",
     "typecheck:slow": "bunx tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
+    "@cfworker/json-schema": "^4.1.1",
     "@effect/platform-node": "catalog:",
     "@executor-js/config": "workspace:*",
     "@executor-js/sdk": "workspace:*",

packages/plugins/mcp/src/react/client.ts+1−1

@@ -3,5 +3,5 @@ import { getBaseUrl } from "@executor-js/react/api/base-url"; · 2 unmodified lines
3	import { McpGroup } from "../api/group";	3	import { McpGroup } from "../api/group";
4		4
5	export const McpClient = createPluginAtomClient(McpGroup, {	5	export const McpClient = createPluginAtomClient(McpGroup, {
6	baseUrl: getBaseUrl(),	6	baseUrl: getBaseUrl,
7	});	7	});

packages/plugins/mcp/tsup.config.ts+1−0

@@ -4,6 +4,7 @@ export default defineConfig({ · 3 unmodified lines
4	entry: {	4	entry: {
5	index: "src/promise.ts",	5	index: "src/promise.ts",
6	core: "src/sdk/index.ts",	6	core: "src/sdk/index.ts",
		7	client: "src/react/plugin-client.tsx",
7	testing: "src/testing/index.ts",	8	testing: "src/testing/index.ts",
8	},	9	},
9	format: ["esm"],	10	format: ["esm"],

packages/plugins/onepassword/package.json+6−0

           "types": "./dist/sdk/index.d.ts",
           "default": "./dist/core.js"
         }
+      },
+      "./client": {
+        "import": {
+          "types": "./dist/react/plugin-client.d.ts",
+          "default": "./dist/client.js"
+        }
       }
     }
   },

packages/plugins/onepassword/src/react/client.ts+1−1

@@ -3,5 +3,5 @@ import { getBaseUrl } from "@executor-js/react/api/base-url"; · 2 unmodified lines
3	import { OnePasswordGroup } from "../api/group";	3	import { OnePasswordGroup } from "../api/group";
4		4
5	export const OnePasswordClient = createPluginAtomClient(OnePasswordGroup, {	5	export const OnePasswordClient = createPluginAtomClient(OnePasswordGroup, {
6	baseUrl: getBaseUrl(),	6	baseUrl: getBaseUrl,
7	});	7	});

packages/plugins/onepassword/src/sdk/plugin.ts+20−4

     Effect.flatMap((resolved) => makeOnePasswordService(resolved, { timeoutMs, preferSdk })),
   );
+const configuredVaultUri = (config: OnePasswordConfig, secretId: string): string | null => {
+  if (!secretId.startsWith("op://")) {
+    return `op://${config.vaultId}/${secretId}/${CREDENTIAL_FIELD}`;
+  }
+  const match = secretId.match(/^op:\/\/([^/]+)\/.+/);
+  if (!match || match[1] !== config.vaultId) return null;
+  return secretId;
+};
 // ---------------------------------------------------------------------------
 // SecretProvider — read-only, resolves op:// URIs or vaultId-based lookups
 // ---------------------------------------------------------------------------
 ): SecretProvider => ({
   key: "onepassword",
   writable: false,
+  allowFallback: false,
   // 1Password vaults are named in the stored config; the executor-scope
   // arg isn't used for routing here. A future refactor could let the
       Effect.flatMap((config) => {
         if (!config) return Effect.succeed(null as string | null);
-        const uri = secretId.startsWith("op://")
+        const uri = configuredVaultUri(config, secretId);
-          ? secretId
+        if (uri === null) return Effect.succeed(null as string | null);
-          : `op://${config.vaultId}/${secretId}/${CREDENTIAL_FIELD}`;
         return getServiceFromConfig(config, ctx, timeoutMs, preferSdk).pipe(
           Effect.flatMap((svc) => svc.resolveSecret(uri)),
             message: "1Password is not configured",
           });
         }
+        const scopedUri = configuredVaultUri(config, uri);
+        if (scopedUri === null) {
+          return yield* new OnePasswordError({
+            operation: "resolve",
+            message: "1Password secret URI is outside the configured vault",
+          });
+        }
         const svc = yield* getServiceFromConfig(config, ctx, timeoutMs, preferSdk);
-        return yield* svc.resolveSecret(uri);
+        return yield* svc.resolveSecret(scopedUri);
       }),
   };
 };

packages/plugins/onepassword/src/sdk/service.ts+23−15

-import { Context, Duration, Effect } from "effect";
+import { Context, Duration, Effect, Semaphore } from "effect";
 import * as op from "@1password/op-js";
 import { OnePasswordError } from "./errors";
 // CLI backend — uses @1password/op-js (shells out to `op` CLI)
 // ---------------------------------------------------------------------------
+const cliAuthLock = Semaphore.makeUnsafe(1);
 export const makeCliService = (
   auth: ResolvedAuth,
 ): Effect.Effect<OnePasswordService, OnePasswordError> =>
   Effect.sync(() => {
-    // Configure auth
-    if (auth.kind === "service-account") {
-      op.setServiceAccount(auth.token);
-    } else {
-      op.setGlobalFlags({ account: auth.accountName });
-    }
     const wrapSync = <A>(fn: () => A, operation: string): Effect.Effect<A, OnePasswordError> =>
-      Effect.try({
+      cliAuthLock
-        try: fn,
+        .withPermits(1)(
-        catch: () =>
+          Effect.try({
-          new OnePasswordError({
+            try: () => {
-            operation,
+              if (auth.kind === "service-account") {
-            message: `1Password CLI ${operation} failed`,
+                op.setGlobalFlags({});
+                op.setServiceAccount(auth.token);
+              } else {
+                op.setServiceAccount("");
+                op.setGlobalFlags({ account: auth.accountName });
+              }
+              return fn();
+            },
+            catch: () =>
+              new OnePasswordError({
+                operation,
+                message: `1Password CLI ${operation} failed`,
+              }),
           }),
-      }).pipe(Effect.withSpan(`onepassword.cli.${operation}`));
+        )
+        .pipe(Effect.withSpan(`onepassword.cli.${operation}`));
     return OnePasswordServiceTag.of({
       resolveSecret: (uri) => wrapSync(() => op.read.parse(uri), "secret resolution"),

packages/plugins/onepassword/tsup.config.ts+1−0

@@ -4,6 +4,7 @@ export default defineConfig({ · 3 unmodified lines
4	entry: {	4	entry: {
5	index: "src/promise.ts",	5	index: "src/promise.ts",
6	core: "src/sdk/index.ts",	6	core: "src/sdk/index.ts",
		7	client: "src/react/plugin-client.tsx",
7	},	8	},
8	format: ["esm"],	9	format: ["esm"],
9	dts: false,	10	dts: false,

packages/plugins/openapi/package.json+6−0

           "default": "./dist/core.js"
         }
       },
+      "./client": {
+        "import": {
+          "types": "./dist/react/plugin-client.d.ts",
+          "default": "./dist/client.js"
+        }
+      },
       "./testing": {
         "import": {
           "types": "./dist/testing/index.d.ts",

packages/plugins/openapi/src/react/AddOpenApiSource.tsx+3−24

@@ -76,12 +76,8 @@ import { · 75 unmodified lines
76	oauth2ConnectionSlot,	76	oauth2ConnectionSlot,
77	queryParamBindingSlot,	77	queryParamBindingSlot,
78	} from "../sdk/store";	78	} from "../sdk/store";
79	import {	79	import { ConfiguredHeaderBinding, OAuth2SourceConfig, type ServerInfo } from "../sdk/types";
80	ConfiguredHeaderBinding,	80	import { expandServerUrlOptions } from "../sdk/openapi-utils";
81	OAuth2SourceConfig,
82	type ServerInfo,
83	type ServerVariable,
84	} from "../sdk/types";
85		81
86	export const OPENAPI_OAUTH_POPUP_NAME = "openapi-oauth";	82	export const OPENAPI_OAUTH_POPUP_NAME = "openapi-oauth";
87	export const OPENAPI_OAUTH_CALLBACK_PATH = "/api/oauth/callback";	83	export const OPENAPI_OAUTH_CALLBACK_PATH = "/api/oauth/callback";
@@ -336,24 +332,7 @@ export default function AddOpenApiSource(props: { · 248 unmodified lines
336	// ---- Derived state ----	332	// ---- Derived state ----
337		333
338	const expandServerOptions = (server: ServerInfo) => {	334	const expandServerOptions = (server: ServerInfo) => {
339	const vars: Record<string, ServerVariable> = Option.getOrElse(	335	return expandServerUrlOptions(server).map((value) => ({
340	server.variables,
341	() => ({}) as Record<string, ServerVariable>,
342	);
343	const variableEntries = Object.entries(vars);
344	const expanded = variableEntries.reduce(
345	(urls, [name, variable]) => {
346	const enumValues: readonly string[] = Option.getOrElse(
347	variable.enum,
348	() => [] as readonly string[],
349	);
350	const values = enumValues.length > 0 ? enumValues : [variable.default];
351	return urls.flatMap((url) => values.map((value) => url.replaceAll(`{${name}}`, value)));
352	},
353	[server.url],
354	);
355
356	return expanded.map((value) => ({
357	value,	336	value,
358	label: value,	337	label: value,
359	}));	338	}));

packages/plugins/openapi/src/react/client.ts+1−1

@@ -3,5 +3,5 @@ import { getBaseUrl } from "@executor-js/react/api/base-url"; · 2 unmodified lines
3	import { OpenApiGroup } from "../api/group";	3	import { OpenApiGroup } from "../api/group";
4		4
5	export const OpenApiClient = createPluginAtomClient(OpenApiGroup, {	5	export const OpenApiClient = createPluginAtomClient(OpenApiGroup, {
6	baseUrl: getBaseUrl(),	6	baseUrl: getBaseUrl,
7	});	7	});

packages/plugins/openapi/src/sdk/openapi-utils.ts+29−1

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	import { Option } from "effect";	7	import { Option } from "effect";
8	import type { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";	8	import type { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
9	import type { ParsedDocument } from "./parse";	9	import type { ParsedDocument } from "./parse";
		10	import type { ServerVariable } from "./types";
10		11
11	// ---------------------------------------------------------------------------	12	// ---------------------------------------------------------------------------
12	// Type aliases — collapse V3 / V3_1 unions into single names	13	// Type aliases — collapse V3 / V3_1 unions into single names
@@ -63,9 +64,36 @@ export const substituteUrlVariables = (url: string, values: Record<string, strin · 50 unmodified lines
63	return out;	64	return out;
64	};	65	};
65		66
		67	export const OPENAPI_MAX_SERVER_VARIABLE_OPTIONS = 64;
		68
66	type ServerLike = {	69	type ServerLike = {
67	url: string;	70	url: string;
68	variables: import("effect/Option").Option<Record<string, { default: string } \| string>>;	71	variables: import("effect/Option").Option<Record<string, ServerVariable \| string>>;
		72	};
		73
		74	export const expandServerUrlOptions = (
		75	server: ServerLike,
		76	limit = OPENAPI_MAX_SERVER_VARIABLE_OPTIONS,
		77	): readonly string[] => {
		78	if (!Option.isSome(server.variables)) return [server.url];
		79	let urls: readonly string[] = [server.url];
		80	for (const [name, variable] of Object.entries(server.variables.value)) {
		81	const enumValues =
		82	typeof variable === "string" ? [] : Option.getOrElse(variable.enum, () => []);
		83	const values =
		84	enumValues.length > 0
		85	? enumValues
		86	: [typeof variable === "string" ? variable : variable.default];
		87	const next: string[] = [];
		88	for (const url of urls) {
		89	for (const value of values) {
		90	next.push(url.replaceAll(`{${name}}`, value));
		91	if (next.length >= limit) return next;
		92	}
		93	}
		94	urls = next;
		95	}
		96	return urls;
69	};	97	};
70		98
71	export const resolveBaseUrl = (servers: readonly ServerLike[]): string => {	99	export const resolveBaseUrl = (servers: readonly ServerLike[]): string => {

packages/plugins/openapi/tsup.config.ts+1−0

@@ -4,6 +4,7 @@ export default defineConfig({ · 3 unmodified lines
4	entry: {	4	entry: {
5	index: "src/promise.ts",	5	index: "src/promise.ts",
6	core: "src/sdk/index.ts",	6	core: "src/sdk/index.ts",
		7	client: "src/react/plugin-client.tsx",
7	testing: "src/testing/index.ts",	8	testing: "src/testing/index.ts",
8	},	9	},
9	format: ["esm"],	10	format: ["esm"],

packages/react/src/api/client.tsx+4−2

 import * as AtomHttpApi from "effect/unstable/reactivity/AtomHttpApi";
-import { FetchHttpClient } from "effect/unstable/http";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
 import { ExecutorApi } from "@executor-js/api";
 import { getBaseUrl } from "./base-url";
 const ExecutorApiClient = AtomHttpApi.Service<"ExecutorApiClient">()("ExecutorApiClient", {
   api: ExecutorApi,
   httpClient: FetchHttpClient.layer,
-  baseUrl: getBaseUrl(),
+  transformClient: HttpClient.mapRequest((request) =>
+    HttpClientRequest.prependUrl(request, getBaseUrl()),
+  ),
 });
 export { ExecutorApiClient };

packages/react/src/components/chart.test.ts+18−0

@@ -0,0 +1,18 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2
	3	import { chartCssColorValue, chartCssVariableName } from "./chart";
	4
	5	describe("chart style helpers", () => {
	6	it("accepts CSS-safe chart keys and colors", () => {
	7	expect(chartCssVariableName("requests_2xx")).toBe("--color-requests_2xx");
	8	expect(chartCssColorValue("#0ea5e9")).toBe("#0ea5e9");
	9	expect(chartCssColorValue("rgb(14 165 233 / 50%)")).toBe("rgb(14 165 233 / 50%)");
	10	expect(chartCssColorValue("var(--chart-1)")).toBe("var(--chart-1)");
	11	});
	12
	13	it("rejects style-breaking keys and color values", () => {
	14	expect(chartCssVariableName("x];body{color:red")).toBeNull();
	15	expect(chartCssColorValue("red; background: url(https://example.test/x)")).toBeNull();
	16	expect(chartCssColorValue("</style><script>alert(1)</script>")).toBeNull();
	17	});
	18	});

packages/react/src/components/chart.tsx+16−1

@@ -25,6 +25,18 @@ type ChartContextProps = { · 24 unmodified lines
25	config: ChartConfig;	25	config: ChartConfig;
26	};	26	};
27		27
		28	const cssIdentifierPattern = /^[A-Za-z_][A-Za-z0-9_-]*$/;
		29	const cssColorPattern =
		30	/^(?:#[0-9A-Fa-f]{3,8}\|(?:rgb\|hsl)a?$\s[-+0-9.%]+\s(?:,\s[-+0-9.%]+\s){2}(?:,\s[-+0-9.]+\s)?$\|(?:rgb\|hsl)a?$\s[-+0-9.%]+\s+[-+0-9.%]+\s+[-+0-9.%]+(?:\s\/\s[-+0-9.%]+)?\s$\|[A-Za-z]+\|var$--[A-Za-z0-9_-]+$)$/;
		31
		32	export const chartCssVariableName = (key: string): string \| null =>
		33	cssIdentifierPattern.test(key) ? `--color-${key}` : null;
		34
		35	export const chartCssColorValue = (color: string): string \| null => {
		36	const trimmed = color.trim();
		37	return cssColorPattern.test(trimmed) ? trimmed : null;
		38	};
		39
28	const ChartContext = React.createContext<ChartContextProps \| null>(null);	40	const ChartContext = React.createContext<ChartContextProps \| null>(null);
29		41
30	function useChart() {	42	function useChart() {
@@ -92,8 +104,11 @@ ${prefix} [data-chart=${id}] { · 61 unmodified lines
92	${colorConfig	104	${colorConfig
93	.map(([key, itemConfig]) => {	105	.map(([key, itemConfig]) => {
94	const color = itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ?? itemConfig.color;	106	const color = itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ?? itemConfig.color;
95	return color ? ` --color-${key}: ${color};` : null;	107	const variableName = chartCssVariableName(key);
		108	const colorValue = color ? chartCssColorValue(color) : null;
		109	return variableName && colorValue ? ` ${variableName}: ${colorValue};` : null;
96	})	110	})
		111	.filter((line): line is string => line !== null)
97	.join("\n")}	112	.join("\n")}
98	}	113	}
99	`,	114	`,

packages/react/src/components/markdown.test.ts+18−0

@@ -0,0 +1,18 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2
	3	import { sanitizeMarkdownUrl } from "./markdown";
	4
	5	describe("sanitizeMarkdownUrl", () => {
	6	it("allows regular web links", () => {
	7	expect(sanitizeMarkdownUrl("https://example.test/path?q=1")).toBe(
	8	"https://example.test/path?q=1",
	9	);
	10	});
	11
	12	it("removes unsupported link targets", () => {
	13	expect(sanitizeMarkdownUrl("javascript:alert(1)")).toBeNull();
	14	expect(sanitizeMarkdownUrl("data:text/html,hello")).toBeNull();
	15	expect(sanitizeMarkdownUrl("//example.test/path")).toBeNull();
	16	expect(sanitizeMarkdownUrl("/local/path")).toBeNull();
	17	});
	18	});

packages/react/src/components/markdown.tsx+37−2

@@ -2,6 +2,20 @@ import { isValidElement, Children, type ComponentPropsWithoutRef, type ReactNode · 1 unmodified line
2	import { Streamdown, type Components } from "streamdown";	2	import { Streamdown, type Components } from "streamdown";
3	import { CodeBlock } from "./code-block";	3	import { CodeBlock } from "./code-block";
4		4
		5	const SAFE_LINK_PROTOCOLS = new Set(["http:", "https:", "mailto:"]);
		6
		7	export function sanitizeMarkdownUrl(url: string \| undefined): string \| null {
		8	const trimmed = url?.trim();
		9	if (!trimmed \|\| trimmed.startsWith("//")) return null;
		10
		11	try {
		12	const parsed = new URL(trimmed);
		13	return SAFE_LINK_PROTOCOLS.has(parsed.protocol) ? parsed.href : null;
		14	} catch {
		15	return null;
		16	}
		17	}
		18
5	function extractText(node: ReactNode): string {	19	function extractText(node: ReactNode): string {
6	if (typeof node === "string") return node;	20	if (typeof node === "string") return node;
7	if (typeof node === "number") return String(node);	21	if (typeof node === "number") return String(node);
@@ -28,6 +42,22 @@ function PreBlock( · 20 unmodified lines
28	return <pre>{props.children}</pre>;	42	return <pre>{props.children}</pre>;
29	}	43	}
30		44
		45	function Link(props: ComponentPropsWithoutRef<"a"> & { children?: ReactNode; node?: unknown }) {
		46	const { children, href, node: _node, ...rest } = props;
		47	const safeHref = sanitizeMarkdownUrl(href);
		48	if (!safeHref) return <span>{children}</span>;
		49	return (
		50	<a {...rest} href={safeHref} rel="noopener noreferrer" target="_blank">
		51	{children}
		52	</a>
		53	);
		54	}
		55
		56	function Image(props: ComponentPropsWithoutRef<"img"> & { node?: unknown }) {
		57	const { alt } = props;
		58	return alt ? <span>{alt}</span> : null;
		59	}
		60
31	const PROSE_CLASSES = [	61	const PROSE_CLASSES = [
32	"text-sm leading-relaxed text-muted-foreground",	62	"text-sm leading-relaxed text-muted-foreground",
33	// paragraphs	63	// paragraphs
@@ -62,10 +92,15 @@ const PROSE_CLASSES = [ · 28 unmodified lines
62	].join(" ");	92	].join(" ");
63		93
64	export function Markdown(props: { children: string; className?: string }) {	94	export function Markdown(props: { children: string; className?: string }) {
65	const components = { pre: PreBlock } satisfies Components;	95	const components = { a: Link, img: Image, pre: PreBlock } satisfies Components;
66	return (	96	return (
67	<div className={props.className ? `${PROSE_CLASSES} ${props.className}` : PROSE_CLASSES}>	97	<div className={props.className ? `${PROSE_CLASSES} ${props.className}` : PROSE_CLASSES}>
68	<Streamdown linkSafety={{ enabled: false }} components={components}>	98	<Streamdown
		99	components={components}
		100	linkSafety={{ enabled: true }}
		101	skipHtml
		102	urlTransform={(url) => sanitizeMarkdownUrl(url)}
		103	>
69	{props.children}	104	{props.children}
70	</Streamdown>	105	</Streamdown>
71	</div>	106	</div>

packages/react/src/components/mcp-install-card.test.ts+32−0

@@ -0,0 +1,32 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2
	3	import { buildMcpInstallCommand, shellQuoteWord } from "./mcp-install-card";
	4
	5	describe("MCP install command rendering", () => {
	6	it("quotes shell words without giving scope paths command syntax", () => {
	7	expect(shellQuoteWord("plain/path")).toBe("plain/path");
	8	expect(shellQuoteWord("owner's scope")).toBe(`'owner'"'"'s scope'`);
	9
	10	const command = buildMcpInstallCommand({
	11	mode: "stdio",
	12	isDev: false,
	13	origin: null,
	14	scopeDir: `/tmp/scope"; touch /tmp/unsafe; echo "`,
	15	});
	16
	17	expect(command).toBe(
	18	`npx add-mcp 'executor mcp --scope '"'"'/tmp/scope"; touch /tmp/unsafe; echo "'"'"'' --name executor`,
	19	);
	20	expect(command).not.toContain(`--scope "/tmp/scope"; touch`);
	21	});
	22
	23	it("quotes HTTP endpoints as add-mcp arguments", () => {
	24	expect(
	25	buildMcpInstallCommand({
	26	mode: "http",
	27	isDev: false,
	28	origin: "http://localhost:4788",
	29	}),
	30	).toBe("npx add-mcp http://localhost:4788/mcp --transport http --name executor");
	31	});
	32	});

packages/react/src/components/mcp-install-card.tsx+29−10

@@ -23,6 +23,29 @@ const isLocal = · 22 unmodified lines
23	window.location.hostname === "127.0.0.1" \|\|	23	window.location.hostname === "127.0.0.1" \|\|
24	window.location.hostname.endsWith(".localhost"));	24	window.location.hostname.endsWith(".localhost"));
25		25
		26	export const shellQuoteWord = (value: string): string => {
		27	if (/^[A-Za-z0-9_/:=@%+.,-]+$/.test(value)) return value;
		28	return `'${value.replace(/'/g, `'"'"'`)}'`;
		29	};
		30
		31	export const buildMcpInstallCommand = (input: {
		32	readonly mode: TransportMode;
		33	readonly isDev: boolean;
		34	readonly origin: string \| null;
		35	readonly scopeDir?: string;
		36	}): string => {
		37	if (input.mode === "http") {
		38	const endpoint = input.origin ? `${input.origin}/mcp` : "<this-server>/mcp";
		39	return `npx add-mcp ${shellQuoteWord(endpoint)} --transport http --name executor`;
		40	}
		41
		42	const innerArgs = input.isDev ? ["bun", "run", "dev:cli", "mcp"] : ["executor", "mcp"];
		43	if (input.scopeDir) {
		44	innerArgs.push("--scope", input.scopeDir);
		45	}
		46	return `npx add-mcp ${shellQuoteWord(innerArgs.map(shellQuoteWord).join(" "))} --name executor`;
		47	};
		48
26	export function McpInstallCard(props: { className?: string }) {	49	export function McpInstallCard(props: { className?: string }) {
27	const showStdio = isLocal;	50	const showStdio = isLocal;
28	const [mode, setMode] = useState<TransportMode>(showStdio ? "stdio" : "http");	51	const [mode, setMode] = useState<TransportMode>(showStdio ? "stdio" : "http");
@@ -33,16 +56,12 @@ export function McpInstallCard(props: { className?: string }) { · 4 unmodified lines
33	setOrigin(window.location.origin);	56	setOrigin(window.location.origin);
34	}, []);	57	}, []);
35		58
36	const scopeFlag = scopeInfo.dir ? ` --scope ${JSON.stringify(scopeInfo.dir)}` : "";	59	const command = buildMcpInstallCommand({
37		60	mode,
38	const command =	61	isDev,
39	mode === "stdio"	62	origin,
40	? isDev	63	scopeDir: scopeInfo.dir,
41	? `npx add-mcp "bun run dev:cli mcp${scopeFlag}" --name "executor"`	64	});
42	: `npx add-mcp "executor mcp${scopeFlag}" --name "executor"`
43	: origin
44	? `npx add-mcp "${origin}/mcp" --transport http --name "executor"`
45	: 'npx add-mcp "<this-server>/mcp" --transport http --name "executor"';
46		65
47	const subtitle =	66	const subtitle =
48	mode === "stdio"	67	mode === "stdio"

packages/react/src/components/schema-explorer.test.ts+16−0

@@ -0,0 +1,16 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2
	3	import { safeSchemaValueLabel } from "./schema-explorer";
	4
	5	describe("safeSchemaValueLabel", () => {
	6	it("formats values that JSON.stringify cannot serialize", () => {
	7	expect(safeSchemaValueLabel(10n)).toBe("10n");
	8	});
	9
	10	it("uses neutral text for circular values", () => {
	11	const value: { self?: unknown } = {};
	12	value.self = value;
	13
	14	expect(safeSchemaValueLabel(value)).toBe("[unavailable]");
	15	});
	16	});

packages/react/src/components/schema-explorer.tsx+14−3

   format?: string;
 };
+export const safeSchemaValueLabel = (value: unknown): string => {
+  if (typeof value === "bigint") return `${value.toString()}n`;
+  try {
+    const label = JSON.stringify(value);
+    if (label === undefined) return String(value);
+    return label.length > 120 ? `${label.slice(0, 117)}...` : label;
+  } catch {
+    return "[unavailable]";
+  }
+};
 // ---------------------------------------------------------------------------
 // Ref resolution — lazy, only on expand
 // ---------------------------------------------------------------------------
     return getRefName(schema.$ref) ?? "ref";
   }
-  if (schema.const !== undefined) return JSON.stringify(schema.const);
+  if (schema.const !== undefined) return safeSchemaValueLabel(schema.const);
   if (schema.enum) {
     if (schema.enum.length <= 3) {
-      return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+      return schema.enum.map((v) => safeSchemaValueLabel(v)).join(" | ");
     }
     return `enum (${schema.enum.length})`;
   }
             ))}
           {schema.default !== undefined && (
             <p className="text-xs leading-5 text-muted-foreground">
-              = {JSON.stringify(schema.default)}
+              = {safeSchemaValueLabel(schema.default)}
             </p>
           )}
         </div>

packages/react/src/components/source-favicon.test.tsx+13−0

@@ -0,0 +1,13 @@
	1	import { describe, expect, it } from "@effect/vitest";
	2
	3	import { SourceFavicon } from "./source-favicon";
	4
	5	describe("SourceFavicon", () => {
	6	it("renders without requesting an external favicon service", () => {
	7	const element = SourceFavicon({ url: "https://internal.example.test/private", size: 20 });
	8
	9	expect(element.type).not.toBe("img");
	10	expect(element.props).not.toHaveProperty("src");
	11	expect(element.props).not.toHaveProperty("href");
	12	});
	13	});

packages/react/src/components/source-favicon.tsx+6−34

@@ -1,43 +1,15 @@
1	import { BoxIcon } from "lucide-react";	1	import { BoxIcon } from "lucide-react";
2	import { useState } from "react";
3	import { getDomain } from "tldts";
4		2
5	// ---------------------------------------------------------------------------	3	// ---------------------------------------------------------------------------
6	// SourceFavicon — renders a small favicon derived from a source URL.	4	// SourceFavicon — renders a neutral local source icon.
7	// Falls back to a neutral dot if the URL is missing or the image fails to load.	5	// Do not fetch third-party favicon services here; source URLs may be private.
8	// ---------------------------------------------------------------------------	6	// ---------------------------------------------------------------------------
9		7
10	function domainOf(url: string): string \| null {	8	export function SourceFavicon({ size = 16 }: { url?: string; size?: number }) {
11	try {
12	return getDomain(url) ?? getDomain(new URL(url).hostname) ?? null;
13	} catch {
14	return null;
15	}
16	}
17
18	export function SourceFavicon({ url, size = 16 }: { url?: string; size?: number }) {
19	const [failed, setFailed] = useState(false);
20	const domain = url ? domainOf(url) : null;
21
22	if (!domain \|\| failed) {
23	return (
24	<BoxIcon
25	aria-hidden
26	className="shrink-0 text-muted-foreground"
27	style={{ width: size, height: size }}
28	/>
29	);
30	}
31
32	return (	9	return (
33	<img	10	<BoxIcon
34	src={`https://www.google.com/s2/favicons?domain=${domain}&sz=${size * 2}`}	11	aria-hidden
35	alt=""	12	className="shrink-0 text-muted-foreground"
36	width={size}
37	height={size}
38	loading="lazy"
39	onError={() => setFailed(true)}
40	className="shrink-0 rounded-sm"
41	style={{ width: size, height: size }}	13	style={{ width: size, height: size }}
42	/>	14	/>
43	);	15	);

packages/react/src/plugins/secret-credential-scope.ts+9−0

@@ -0,0 +1,9 @@
	1	import type { ScopeId } from "@executor-js/sdk";
	2
	3	import type { SecretPickerSecret } from "./secret-picker";
	4
	5	export const secretsForCredentialTarget = (
	6	secrets: readonly SecretPickerSecret[],
	7	targetScope: ScopeId,
	8	): readonly SecretPickerSecret[] =>
	9	secrets.filter((secret) => secret.scopeId === String(targetScope));

packages/react/src/plugins/secret-form.tsx+5−4

 } from "../components/select";
 import type { VariantProps } from "class-variance-authority";
+import { secretValueInputType } from "./secret-input";
 import { getUniqueSecretId, isSecretIdTaken } from "./secret-id";
 // ---------------------------------------------------------------------------
   const { state, actions } = useSecretForm();
   const inputId = useId();
   const revealable = props.revealable ?? false;
+  const revealed = revealable && state.revealed;
   const errored = state.status.kind === "error";
   return (
       <div className="relative">
         <Input
           id={inputId}
-          type={revealable ? "text" : "password"}
+          type={secretValueInputType({ revealable, revealed })}
           value={state.value}
           onChange={(e) => actions.setValue((e.target as HTMLInputElement).value)}
           placeholder={props.placeholder ?? "ghp_xxxxxxxxxxxxxxxxxxxx"}
           autoFocus={props.autoFocus}
+          autoComplete="new-password"
           className={revealable ? "pr-9 font-mono" : "font-mono"}
           style={
-            revealable && !state.revealed
+            revealable && !revealed ? ({ WebkitTextSecurity: "disc" } as CSSProperties) : undefined
-              ? ({ WebkitTextSecurity: "disc" } as CSSProperties)
-              : undefined
           }
         />
         {revealable && (

packages/react/src/plugins/secret-header-auth.test.ts+10−1

 import { describe, expect, it } from "@effect/vitest";
 import { ScopeId } from "@executor-js/sdk";
-import { secretsForCredentialTarget } from "./secret-header-auth";
+import { secretsForCredentialTarget } from "./secret-credential-scope";
+import { secretValueInputType } from "./secret-input";
 describe("secretsForCredentialTarget", () => {
   it("only exposes secrets owned by the target credential scope", () => {
     ).toEqual(["shared-token"]);
   });
 });
+describe("secretValueInputType", () => {
+  it("uses password inputs until a value is revealed", () => {
+    expect(secretValueInputType({ revealable: true, revealed: false })).toBe("password");
+    expect(secretValueInputType({ revealable: false, revealed: false })).toBe("password");
+    expect(secretValueInputType({ revealable: true, revealed: true })).toBe("text");
+  });
+});

packages/react/src/plugins/secret-header-auth.tsx+2−5

   CredentialTargetScopeSelector,
   type CredentialTargetScopeOption,
 } from "./credential-target-scope";
+import { secretsForCredentialTarget } from "./secret-credential-scope";
-export const secretsForCredentialTarget = (
+export { secretsForCredentialTarget };
-  secrets: readonly SecretPickerSecret[],
-  targetScope: ScopeId,
-): readonly SecretPickerSecret[] =>
-  secrets.filter((secret) => secret.scopeId === String(targetScope));
 export interface HeaderAuthPreset {
   readonly key: string;

packages/react/src/plugins/secret-input.ts+4−0

@@ -0,0 +1,4 @@
	1	export const secretValueInputType = (input: {
	2	readonly revealable: boolean;
	3	readonly revealed: boolean;
	4	}): "password" \| "text" => (input.revealable && input.revealed ? "text" : "password");

scripts/install.sh+4−2

 download_and_install() {
     print_message info "\n${MUTED}Installing ${NC}${APP} ${MUTED}version: ${NC}${specific_version}"
-    local tmp_dir="${TMPDIR:-/tmp}/${APP}_install_$$"
+    local tmp_dir
-    mkdir -p "$tmp_dir"
+    tmp_dir=$(mktemp -d "${TMPDIR:-/tmp}/${APP}_install_XXXXXXXXXX")
+    trap 'rm -rf "$tmp_dir"' RETURN
     curl -# -L -o "${tmp_dir}/${filename}" "$url"
     chmod 755 "${INSTALL_DIR}/${APP}"
     rm -rf "$tmp_dir"
+    trap - RETURN
 }
 install_from_binary() {

scripts/oxlint-plugin-executor/rules/no-conditional-tests.js+4−41

@@ -1,22 +1,4 @@
1	import { getCallName } from "../utils.js";	1	import { getCallName, isTestLike } from "../utils.js";
2	import { isTestLike } from "../utils.js";
3	import { unwrapExpression } from "../utils.js";
4
5	const testRegistrars = new Set(["it", "test"]);
6
7	const isFunction = (node) =>
8	node?.type === "ArrowFunctionExpression" \|\|
9	node?.type === "FunctionExpression" \|\|
10	node?.type === "FunctionDeclaration";
11
12	const isTestRegistrationCall = (node) => {
13	const callee = unwrapExpression(node.callee);
14	if (callee?.type === "Identifier") return testRegistrars.has(callee.name);
15	if (callee?.type !== "MemberExpression") return false;
16
17	const object = unwrapExpression(callee.object);
18	return object?.type === "Identifier" && testRegistrars.has(object.name);
19	};
20		2
21	export default {	3	export default {
22	meta: {	4	meta: {
@@ -28,31 +10,18 @@ export default { · 5 unmodified lines
28	create(context) {	10	create(context) {
29	if (!isTestLike(context.filename)) return {};	11	if (!isTestLike(context.filename)) return {};
30		12
31	const testCallbacks = new WeakSet();
32	let testDepth = 0;
33	let conditionalDepth = 0;	13	let conditionalDepth = 0;
34		14
35	const enterFunction = (node) => {
36	if (testCallbacks.has(node)) testDepth++;
37	};
38	const exitFunction = (node) => {
39	if (testCallbacks.has(node)) testDepth--;
40	};
41	const enterConditional = () => {	15	const enterConditional = () => {
42	if (testDepth > 0) conditionalDepth++;	16	conditionalDepth++;
43	};	17	};
44	const exitConditional = () => {	18	const exitConditional = () => {
45	if (testDepth > 0) conditionalDepth--;	19	conditionalDepth--;
46	};	20	};
47		21
48	return {	22	return {
49	CallExpression(node) {	23	CallExpression(node) {
50	if (isTestRegistrationCall(node)) {	24	if (conditionalDepth === 0) return;
51	const callback = node.arguments.find(isFunction);
52	if (callback) testCallbacks.add(callback);
53	}
54
55	if (testDepth === 0 \|\| conditionalDepth === 0) return;
56	const name = getCallName(node.callee);	25	const name = getCallName(node.callee);
57	if (name !== "expect") return;	26	if (name !== "expect") return;
58	context.report({	27	context.report({
@@ -61,12 +30,6 @@ export default { · 2 unmodified lines
61	"Avoid conditional expect calls; split the test or assert both branches explicitly. Skill: wrdn-effect-vitest-tests.",	30	"Avoid conditional expect calls; split the test or assert both branches explicitly. Skill: wrdn-effect-vitest-tests.",
62	});	31	});
63	},	32	},
64	FunctionDeclaration: enterFunction,
65	"FunctionDeclaration:exit": exitFunction,
66	FunctionExpression: enterFunction,
67	"FunctionExpression:exit": exitFunction,
68	ArrowFunctionExpression: enterFunction,
69	"ArrowFunctionExpression:exit": exitFunction,
70	IfStatement: enterConditional,	33	IfStatement: enterConditional,
71	"IfStatement:exit": exitConditional,	34	"IfStatement:exit": exitConditional,
72	ConditionalExpression: enterConditional,	35	ConditionalExpression: enterConditional,