diff --git a/apps/server/src/isolatedApprovalHttp.test.ts b/apps/server/src/isolatedApprovalHttp.test.ts new file mode 100644 index 0000000000000..203f233a6bf10 --- /dev/null +++ b/apps/server/src/isolatedApprovalHttp.test.ts @@ -0,0 +1,75 @@ +import { AuthSessionId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import { FetchHttpClient, HttpRouter } from "effect/http"; +import { expect, it, vi } from "vite-plus/test"; + +import { EnvironmentAuth } from "./auth/EnvironmentAuth.ts"; +import { layer } from "./isolatedApprovalHttp.ts"; + +it("forwards only explicit approvals from the configured authenticated operator", async () => { + vi.stubEnv("T3CODE_ISOLATED_APPROVAL_PORT", "45678"); + vi.stubEnv("T3CODE_ISOLATED_APPROVAL_TOKEN", "sidecar-test-token"); + vi.stubEnv("T3CODE_ISOLATED_APPROVAL_SUBJECT", "operator"); + let subject = "different-account"; + const upstream = vi + .spyOn(globalThis, "fetch") + .mockImplementation(async () => + Response.json({ runId: "existing-run", revision: "a".repeat(64) }), + ); + const { handler, dispose } = HttpRouter.toWebHandler( + layer.pipe( + Layer.provideMerge(FetchHttpClient.layer), + Layer.provideMerge( + Layer.mock(EnvironmentAuth)({ + authenticateHttpRequest: () => + Effect.succeed({ + sessionId: AuthSessionId.make("fixture-session"), + subject, + method: "bearer-access-token", + scopes: ["orchestration:operate"], + }), + }), + ), + ), + { disableLogger: true }, + ); + try { + const send = (body: string, auth?: string, cookie?: string, action = "approve") => + handler( + new Request(`http://localhost/api/isolated-approval/v1/${action}`, { + method: "POST", + headers: { + "content-type": "application/json", + "content-length": String(body.length), + ...(auth ? { authorization: auth } : {}), + ...(cookie ? { cookie } : {}), + }, + body, + }), + ); + const body = JSON.stringify({ ticket: "fixture", revision: "a".repeat(64) }); + expect((await send(body)).status).toBe(401); + expect((await send(body, "Bearer t3-session")).status).toBe(403); + subject = "operator"; + expect((await send(body, "Bearer t3-session", "session=fixture")).status).toBe(401); + expect((await send("{}", "Bearer t3-session")).status).toBe(400); + expect(upstream).not.toHaveBeenCalled(); + expect((await send(body, "Bearer t3-session")).status).toBe(200); + const [url, forwarded] = upstream.mock.calls[0] ?? []; + expect(String(url)).toBe("http://127.0.0.1:45678/isolated-approval/v1/approve"); + expect(forwarded?.redirect).toBe("error"); + expect(new Headers(forwarded?.headers).get("authorization")).toBe("Bearer sidecar-test-token"); + expect(forwarded?.body).toBeInstanceOf(Uint8Array); + expect(new TextDecoder().decode(forwarded?.body as Uint8Array)).toBe(body); + const draft = JSON.stringify({ ticket: "fixture", scope: "Update fixture" }); + expect((await send(draft, "Bearer t3-session", undefined, "prepare")).status).toBe(200); + const [prepareUrl, prepared] = upstream.mock.calls[1] ?? []; + expect(String(prepareUrl)).toBe("http://127.0.0.1:45678/isolated-approval/v1/prepare"); + expect(new TextDecoder().decode(prepared?.body as Uint8Array)).toBe(draft); + } finally { + await dispose(); + upstream.mockRestore(); + vi.unstubAllEnvs(); + } +}); diff --git a/apps/server/src/isolatedApprovalHttp.ts b/apps/server/src/isolatedApprovalHttp.ts new file mode 100644 index 0000000000000..378521246c6a8 --- /dev/null +++ b/apps/server/src/isolatedApprovalHttp.ts @@ -0,0 +1,111 @@ +/** Isolated operator-only access to the loopback brief approval service. */ +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; +import { + FetchHttpClient, + HttpClient, + HttpClientRequest, + HttpRouter, + HttpServerRequest, + HttpServerResponse, +} from "effect/http"; + +import { EnvironmentAuth } from "./auth/EnvironmentAuth.ts"; + +const ticket = Schema.String.check(Schema.isPattern(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,99}$/)); +const prepareBody = Schema.Struct({ + ticket, + scope: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(4000)), +}); +const reviewBody = Schema.Struct({ ticket }); +const approveBody = Schema.Struct({ + ticket, + revision: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)), +}); + +function isolatedConfig() { + return { + port: Number(process.env.T3CODE_ISOLATED_APPROVAL_PORT), + token: process.env.T3CODE_ISOLATED_APPROVAL_TOKEN, + operator: process.env.T3CODE_ISOLATED_APPROVAL_SUBJECT, + }; +} + +const bodies = { prepare: prepareBody, review: reviewBody, approve: approveBody }; + +const route = (action: keyof typeof bodies) => + HttpRouter.add( + "POST", + `/api/isolated-approval/v1/${action}`, + Effect.gen(function* () { + const { port, token, operator } = isolatedConfig(); + if (!Number.isInteger(port) || port < 1 || port > 65535 || !token || !operator) { + return HttpServerResponse.empty({ status: 404 }); + } + + const request = yield* HttpServerRequest.HttpServerRequest; + if ( + request.headers.cookie !== undefined || + !/^Bearer \S+$/i.test(request.headers.authorization ?? "") + ) { + return HttpServerResponse.empty({ status: 401 }); + } + const auth = yield* EnvironmentAuth; + const session = yield* auth.authenticateHttpRequest(request).pipe(Effect.option); + if (Option.isNone(session)) { + return HttpServerResponse.empty({ status: 401 }); + } + if ( + session.value.subject !== operator || + !session.value.scopes.includes("orchestration:operate") + ) { + return HttpServerResponse.empty({ status: 403 }); + } + + const length = Number(request.headers["content-length"]); + if ( + !Number.isInteger(length) || + length < 1 || + length > 8192 || + request.headers["content-encoding"] !== undefined || + request.headers["content-type"]?.split(";")[0]?.trim().toLowerCase() !== "application/json" + ) { + return HttpServerResponse.empty({ status: 400 }); + } + const body = yield* request.json.pipe(Effect.option); + if (Option.isNone(body)) { + return HttpServerResponse.empty({ status: 400 }); + } + const schema = bodies[action]; + const input = Schema.decodeUnknownOption(schema)(body.value); + if (Option.isNone(input)) { + return HttpServerResponse.empty({ status: 400 }); + } + const client = yield* HttpClient.HttpClient; + const response = yield* HttpClientRequest.post( + `http://127.0.0.1:${port}/isolated-approval/v1/${action}`, + ).pipe( + HttpClientRequest.setHeader("authorization", `Bearer ${token}`), + HttpClientRequest.bodyJson(input.value), + Effect.flatMap((outbound) => client.execute(outbound)), + Effect.flatMap((result) => + Effect.map(result.text, (body) => ({ status: result.status, body })), + ), + Effect.provideService(FetchHttpClient.RequestInit, { redirect: "error" }), + Effect.timeout("15 seconds"), + Effect.option, + ); + if (Option.isNone(response) || ![200, 400, 404, 409].includes(response.value.status)) { + return HttpServerResponse.empty({ status: 502, headers: { "cache-control": "no-store" } }); + } + return HttpServerResponse.text(response.value.body, { + status: response.value.status, + contentType: "application/json", + headers: { "cache-control": "no-store" }, + }); + }), + ); + +export const layer = Layer.mergeAll(route("prepare"), route("review"), route("approve")); diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts index 47c4a4c9a20ec..23e91d378a3a3 100644 --- a/apps/server/src/server.ts +++ b/apps/server/src/server.ts @@ -33,6 +33,7 @@ import * as NonBlockingSpawner from "./process/NonBlockingSpawner.ts"; import * as KeepAwake from "./background/KeepAwake.ts"; import * as ServerConfig from "./config.ts"; import { withUntracedRequests } from "./http.ts"; +import * as IsolatedApprovalHttp from "./isolatedApprovalHttp.ts"; import * as ServerHttp from "./http.ts"; import { guardHttpResponseWriteErrors, @@ -837,6 +838,7 @@ const layerMakeRoutes = Layer.mergeAll( Layer.provide(WebhookRoute.layer.pipe(Layer.provide(RelayDeliveryProof.layer))), Layer.provide(AuthHttp.layerAuthenticatedAuth), ), + IsolatedApprovalHttp.layer, ServerHttp.layerOtlpTracesProxyRoute, ServerHttp.layerAssetRoute, ServerHttp.layerAttachmentUploadRoute, diff --git a/apps/web/src/components/chat/ChatHeader.browser.test.tsx b/apps/web/src/components/chat/ChatHeader.browser.test.tsx index 2f54eef77c8d3..0ea4ee8711fe0 100644 --- a/apps/web/src/components/chat/ChatHeader.browser.test.tsx +++ b/apps/web/src/components/chat/ChatHeader.browser.test.tsx @@ -4,6 +4,11 @@ import { userEvent } from "vite-plus/test/browser"; const persisted = vi.hoisted(() => ({ title: "" })); const openMenu = vi.hoisted(() => vi.fn()); +vi.mock(import("../../state/environments"), async (importOriginal) => ({ + ...(await importOriginal()), + usePrimaryEnvironmentId: () => EnvironmentId.make("local-backend-generated-id"), +})); + vi.mock(import("../../state/session"), async (importOriginal) => ({ ...(await importOriginal()), useEnvironmentScope: () => true, @@ -24,14 +29,14 @@ vi.mock(import("~/hooks/useThreadActionMenu"), () => ({ import { render, stubGlobal } from "../../../test/render"; import { ChatHeader } from "./ChatHeader"; -function header(title: string) { +function header(title: string, environment = "environment", isServerThread = true) { return ( <> {}} @@ -103,3 +108,13 @@ it("keeps the Escape that cancels a rename from also reaching window shortcuts", expect(persisted.title).toBe("New thread"); expect(windowEscapes).toEqual([true]); }); + +it("offers isolated brief review on a draft in the resolved primary desktop environment", async () => { + using _bridge = stubGlobal("desktopBridge", {}); + await using screen = await render(header("New thread", "local-backend-generated-id", false)); + const review = screen.getByRole("button", { name: "Review isolated brief" }); + await expect.element(review).toBeVisible(); + + await screen.rerender(header("Other thread", "linked-environment", false)); + await expect.element(review).not.toBeInTheDocument(); +}); diff --git a/apps/web/src/components/chat/ChatHeader.tsx b/apps/web/src/components/chat/ChatHeader.tsx index 22e02b228a24d..60e9c9b7878cb 100644 --- a/apps/web/src/components/chat/ChatHeader.tsx +++ b/apps/web/src/components/chat/ChatHeader.tsx @@ -27,6 +27,7 @@ import { toastManager } from "../ui/toast"; import { useThreadActionMenu } from "~/hooks/useThreadActionMenu"; import { readLocalApi } from "~/localApi"; import { threadEnvironment } from "../../state/threads"; +import { usePrimaryEnvironmentId } from "../../state/environments"; import { canShareWithGuestAtom } from "./guestShareAvailability"; import { useAtomValue } from "@effect/atom-react"; import { useOrchestrationCommand } from "../../state/use-orchestration-command"; @@ -43,6 +44,7 @@ import { cn } from "~/lib/utils"; import { textDirection } from "~/textDirection"; import { useClientSettings } from "../../hooks/useSettings"; import { GuestShareIndicator } from "./GuestShareControls"; +import { IsolatedBriefDialog } from "./IsolatedBriefDialog"; interface ChatHeaderProps { activeThreadEnvironmentId: EnvironmentId; @@ -88,6 +90,7 @@ export const ChatHeader = memo(function ChatHeader({ const interfaceFont = useClientSettings((settings) => settings.fontFamilySans); const breadcrumbContainerRef = useRef(null); const [collapseParentTitle, setCollapseParentTitle] = useState(false); + const primaryEnvironmentId = usePrimaryEnvironmentId(); const activeThreadRef = scopeThreadRef(activeThreadEnvironmentId, activeThreadId); const canOperateThread = useEnvironmentScope( activeThreadEnvironmentId, @@ -398,6 +401,10 @@ export const ChatHeader = memo(function ChatHeader({ ) : null} + {canOperateThread && + activeThreadEnvironmentId === primaryEnvironmentId && + typeof window !== "undefined" && + window.desktopBridge && } {isServerThread ? : null} ); diff --git a/apps/web/src/components/chat/IsolatedBriefDialog.browser.test.tsx b/apps/web/src/components/chat/IsolatedBriefDialog.browser.test.tsx new file mode 100644 index 0000000000000..d08e7bbd422fe --- /dev/null +++ b/apps/web/src/components/chat/IsolatedBriefDialog.browser.test.tsx @@ -0,0 +1,78 @@ +import "~/index.css"; +import { expect, it, vi } from "vite-plus/test"; +import { page } from "vite-plus/test/browser"; +import { render, stubGlobal } from "../../../test/render"; +import { IsolatedBriefDialog } from "./IsolatedBriefDialog"; + +vi.mock(import("~/environments/primary/desktopAuth"), () => ({ + readDesktopPrimaryBearerToken: async () => "fixture-session", +})); +vi.mock(import("~/environments/primary/target"), () => ({ + resolvePrimaryEnvironmentHttpUrl: (pathname: string) => `http://127.0.0.1:3210${pathname}`, +})); + +it.each(["review", "prepare"] as const)( + "requires explicit approval after %s and can recover a missing receipt", + async (action) => { + const revision = "a".repeat(64); + const baseSha = "b".repeat(40); + const runId = "a16fdb25-00e8-4061-97c2-14cd6e10c27b"; + const fetchApproval = vi + .fn() + .mockResolvedValueOnce( + Response.json({ + ticket: "fixture", + revision, + brief: { + repository: "lab/fixture", + workspaceId: "isolated", + scope: "Update the clamp fixture", + baseSha, + tokens: 1000, + nativeStages: { + lead: { + projectId: "fixture-project", + message: "Review the clamp brief", + tokens: 100, + modelSelection: { instanceId: "codex-lab", model: "codex-fixture" }, + }, + }, + }, + }), + ) + .mockRejectedValueOnce(new Error("Reply lost")) + .mockResolvedValueOnce(Response.json({ runId, revision })); + using _fetch = stubGlobal("fetch", fetchApproval); + await using screen = await render(); + await screen.getByRole("button", { name: "Review isolated brief" }).click(); + const dialog = page.getByRole("dialog"); + const approve = dialog.getByRole("button", { name: "Approve isolated run" }); + await expect.element(approve).not.toBeInTheDocument(); + await dialog.getByRole("textbox", { name: "Ticket", exact: true }).fill("fixture"); + if (action === "prepare") { + await dialog.getByRole("textbox", { name: "Task scope" }).fill("Update the clamp fixture"); + } + await dialog + .getByRole("button", { + name: action === "prepare" ? "Prepare draft" : "Review existing draft", + exact: true, + }) + .click(); + await expect.element(dialog.getByText(`Base commit ${baseSha}`)).toBeVisible(); + await expect.element(dialog.getByText("lead · codex-lab · codex-fixture")).toBeVisible(); + expect(fetchApproval).toHaveBeenCalledTimes(1); + expect(fetchApproval.mock.calls[0]?.[0]).toMatch(new RegExp(`/${action}$`)); + await approve.click(); + await expect.element(dialog.getByRole("alert")).toHaveTextContent("Reply lost"); + await approve.click(); + await expect + .element(dialog.getByRole("link", { name: "Open run in Delivery" })) + .toHaveAttribute("href", `/delivery?run=${runId}`); + const approvalCalls = fetchApproval.mock.calls.slice(1); + expect(approvalCalls).toHaveLength(2); + expect(approvalCalls[0]).toEqual(approvalCalls[1]); + expect(approvalCalls[0]?.[0]).toMatch(/\/approve$/); + expect(approvalCalls[0]?.[1]?.body).toBe(JSON.stringify({ ticket: "fixture", revision })); + expect(approvalCalls[0]?.[1]?.credentials).toBe("omit"); + }, +); diff --git a/apps/web/src/components/chat/IsolatedBriefDialog.tsx b/apps/web/src/components/chat/IsolatedBriefDialog.tsx new file mode 100644 index 0000000000000..611b59375ed25 --- /dev/null +++ b/apps/web/src/components/chat/IsolatedBriefDialog.tsx @@ -0,0 +1,230 @@ +import { Link } from "@tanstack/react-router"; +import * as Schema from "effect/Schema"; +import { type FormEvent, useState } from "react"; +import { readDesktopPrimaryBearerToken } from "~/environments/primary/desktopAuth"; +import { resolvePrimaryEnvironmentHttpUrl } from "~/environments/primary/target"; +import { parseManagedRunId } from "~/lib/managedRunDelivery"; +import { Button } from "../ui/button"; +import { Dialog, DialogDescription, DialogPopup, DialogTitle, DialogTrigger } from "../ui/dialog"; + +const ticketPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/; +const Tokens = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })); +const Stage = Schema.Struct({ + projectId: Schema.String, + message: Schema.String, + tokens: Tokens, + modelSelection: Schema.Struct({ + instanceId: Schema.String, + model: Schema.String, + options: Schema.optionalKey(Schema.Unknown), + }), +}); +const Draft = Schema.Struct({ + ticket: Schema.String, + revision: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)), + brief: Schema.Struct({ + workspaceId: Schema.String, + repository: Schema.String, + baseSha: Schema.String.check(Schema.isPattern(/^[a-f0-9]{40}$/)), + scope: Schema.String, + tokens: Tokens, + nativeStages: Schema.optionalKey( + Schema.Struct({ + lead: Stage, + implementation: Schema.optionalKey(Stage), + qa: Schema.optionalKey(Stage), + }), + ), + }), +}); +const isDraft = Schema.is(Draft); +const isApproval = Schema.is(Schema.Struct({ runId: Schema.String, revision: Schema.String })); + +async function postApproval( + action: "prepare" | "review" | "approve", + input: { ticket: string; revision?: string; scope?: string }, +): Promise { + const token = await readDesktopPrimaryBearerToken(); + if (!token) throw new Error("Sign in to the local desktop environment."); + const response = await fetch( + resolvePrimaryEnvironmentHttpUrl(`/api/isolated-approval/v1/${action}`), + { + method: "POST", + headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, + body: JSON.stringify(input), + credentials: "omit", + redirect: "error", + cache: "no-store", + }, + ); + if (response.status === 400 || response.status === 409) { + const value: unknown = await response.json().catch(() => undefined); + const error = Schema.is(Schema.Struct({ error: Schema.String })); + throw new Error( + error(value) ? value.error : "Check your ticket and scope, then review the latest draft.", + ); + } + if (response.status === 404) + throw new Error( + action === "prepare" + ? "Draft preparation is disabled in this environment." + : "Isolated approval is disabled in this environment.", + ); + if (response.status === 401 || response.status === 403) { + throw new Error("This session cannot approve isolated runs."); + } + if (!response.ok) throw new Error("The isolated approval service is unavailable."); + return response.json(); +} + +function BriefForm() { + const [draft, setDraft] = useState(null); + const [runId, setRunId] = useState(); + const [error, setError] = useState(); + const [pending, setPending] = useState(false); + + async function loadDraft(event: FormEvent) { + event.preventDefault(); + const form = new FormData(event.currentTarget); + const ticket = String(form.get("ticket") ?? "").trim(); + const scope = String(form.get("scope") ?? "").trim(); + const submitter = (event.nativeEvent as SubmitEvent).submitter; + const action = + submitter instanceof HTMLButtonElement && submitter.value === "prepare" + ? "prepare" + : "review"; + if (pending) return; + if (!ticketPattern.test(ticket)) { + setError("Enter a ticket using letters, digits, hyphens or underscores."); + return; + } + if (action === "prepare" && !scope) { + setError("Enter a task scope to prepare a draft."); + return; + } + setPending(true); + setDraft(null); + setRunId(undefined); + setError(undefined); + try { + const value = await postApproval( + action, + action === "prepare" ? { ticket, scope } : { ticket }, + ); + if (isDraft(value) && value.ticket === ticket) { + setDraft(value); + } else { + setError("Invalid prepared brief."); + } + } catch (cause) { + setError(cause instanceof Error ? cause.message : "Review failed."); + } + setPending(false); + } + + async function approve() { + if (!draft || pending || runId) return; + setPending(true); + setError(undefined); + try { + const value = await postApproval("approve", { + ticket: draft.ticket, + revision: draft.revision, + }); + const id = + isApproval(value) && value.revision === draft.revision + ? parseManagedRunId(value.runId) + : undefined; + if (id) { + setRunId(id); + } else { + setError("Approval receipt is unavailable. Retry the same revision to recover it."); + } + } catch (cause) { + setError(cause instanceof Error ? cause.message : "Approval failed."); + } + setPending(false); + } + + return ( +
+
void loadDraft(event)} className="space-y-3"> + +