Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
Guard app reads against malformed payloads and invalid dates (#561)
David McKay69ae8c528cbc
diff --git a/Tauri-signing-SKILL.md b/Tauri-signing-SKILL.mdnew file mode 100644index 00000000..76d24706--- /dev/null+++ b/Tauri-signing-SKILL.md@@ -0,0 +1,286 @@+---+name: agui-tauri-windows-signing+description: >+ Configure and troubleshoot Authenticode code signing for Tauri Windows+ builds (.exe / .msi) using the AG-UI organization's DigiCert code-signing+ certificate stored in Azure Key Vault (non-exportable RSA-HSM key), signed+ via AzureSignTool authenticated with GitHub OIDC. Covers tauri.conf.json+ signCommand wiring, the CI signing seam (mode gate: none | keyvault), the+ separation between Authenticode signing, Tauri updater (minisign) keys,+ and NuGet package author signing, plus the Azure/Entra access model —+ including what changes when the Tauri app lives in a DIFFERENT repository+ than the existing NuGet signing lane. USE FOR: adding Windows signing to+ a Tauri app, wiring the release workflow to the vault (same repo or+ cross-repo), debugging signature, login, permission, or SmartScreen+ failures, or answering "which cert / which key / which tool / which+ access right signs what".+---++# Tauri Windows Signing with Azure Key Vault++## Context: what signs what++The org's signing infrastructure has **three independent mechanisms**. Never+conflate them — they use different keys, different tools, and different+verification paths:++| Mechanism | Key | Tool | Applies to |+|---|---|---|---|+| NuGet **author signature** | DigiCert cert, CN=Tawkit, Inc. — private key in Azure Key Vault (non-exportable, RSA-HSM) | `NuGetKeyVaultSignTool` | `*.nupkg` only |+| **Authenticode** (this skill) | Same DigiCert cert, same vault | `AzureSignTool` | Windows PE binaries: `.exe`, `.dll`, `.msi` (incl. Tauri builds) |+| Assembly strong-naming | `AGUI.snk` | MSBuild | .NET assemblies; unrelated to either signature |+| Tauri **updater** signature | Tauri minisign key pair (NOT the vault cert) | `tauri signer` | Update manifests for `tauri-plugin-updater` |++Additional facts that agents routinely get wrong:++- nuget.org applies its own **repository signature** automatically on push.+ The author signature is what flips a package to "signed" on the gallery;+ it is not needed for Authenticode at all.+- Symbol packages (`*.snupkg`) are **intentionally not** author-signed.+- The vault certificate: DigiCert Trusted G4 Code Signing RSA4096 SHA384+ 2021 CA1 issuer chain, OV validation. Because it is OV (not EV), Windows+ SmartScreen reputation builds per-publisher over signed releases rather+ than being granted instantly — an unsigned-looking warning on a brand-new+ app is expected until reputation accrues, and is not a signing failure.+- The private key **never leaves the HSM**. Every signature — NuGet or+ Authenticode — is a `keys/sign` operation executed inside the vault.+ Never attempt to export the key or generate a `.pfx`.++Reference implementation for the NuGet lane (the pattern this skill mirrors):+`.github/workflows/publish-release.yml` (signing step) and+`sdks/dotnet/docs/signing.md` (design doc).++## Task: wire signing into a Tauri build++### 1. Point `signCommand` at a wrapper script++In `tauri.conf.json`, override the default `signtool.exe` invocation.+Tauri calls this command once per binary **and** once per installer,+substituting `%1` with each file path:++```json+{+ "bundle": {+ "windows": {+ "signCommand": "pwsh ./scripts/sign-tauri.ps1 %1"+ }+ }+}+```++Do NOT configure the legacy `certificateThumbprint` / `digestAlgorithm` /+`timestampUrl` fields — those expect a locally installed certificate with a+locally accessible key and cannot reach a Key Vault HSM.++### 2. Create the wrapper script++`scripts/sign-tauri.ps1` — mirrors the NuGetKeyVaultSignTool step in+`publish-release.yml` (same vault URL, cert name, token, digest, and+timestamp authority):++```powershell+param([string]$File)+azuresigntool sign `+ -fd sha256 `+ -tr http://timestamp.digicert.com `+ -td sha256 `+ -kvu $env:AZURE_KEY_VAULT_URL `+ -kvc $env:CODE_SIGNING_CERT_NAME `+ -kva $env:AZURE_ACCESS_TOKEN `+ $File+if ($LASTEXITCODE -ne 0) { throw "Signing failed for $File" }+```++Flag mapping from the NuGet lane (verify you kept them identical):++| NuGetKeyVaultSignTool | AzureSignTool |+|---|---|+| `--file-digest sha256` | `-fd sha256` |+| `--timestamp-rfc3161 http://timestamp.digicert.com` | `-tr http://timestamp.digicert.com` |+| `--timestamp-digest sha256` | `-td sha256` |+| `--azure-key-vault-url` | `-kvu` |+| `--azure-key-vault-certificate` | `-kvc` |+| `--azure-key-vault-accesstoken` | `-kva` |++### 3. Wire the workflow with OIDC (no long-lived secrets)++The release job authenticates to Azure with GitHub OIDC federation — the+same pattern as the NuGet lane. Do not introduce a client secret.++```yaml+- uses: azure/login@v2+ with:+ client-id: ${{ secrets.AZURE_SIGNING_CLIENT_ID }} # federated to GH OIDC+ tenant-id: ${{ secrets.AZURE_TENANT_ID }}+ allow-no-subscriptions: true+- run: dotnet tool install --global AzureSignTool+- run: |+ $env:AZURE_ACCESS_TOKEN = (az account get-access-token `+ --resource https://vault.azure.net --query accessToken -o tsv)+ npm run tauri build+```++The workflow job MUST declare `permissions: id-token: write` (with+`contents: read`) — without it GitHub will not issue an OIDC token at all.+This is the single most common cause of a first-run login failure in a new+workflow or repo.++### 4. Keep the mode gate (safe default)++Follow the established `signing-mode` seam from `publish-release.yml`:+the workflow input defaults to `none` (unsigned, safe to merge before any+vault is provisioned) and only `keyvault` enables signing. For Tauri,+implement the gate by either:++- merging a `tauri.windows.conf.json` overlay containing the `signCommand`+ only in the release job, or+- omitting `signCommand` from the base config and signing the built+ `.exe` / `.msi` as an explicit post-build step when mode = keyvault.++Both are acceptable; the invariant is that an unprovisioned environment+never fails (or silently signs) because the seam exists.++## Access rights: what changes and what doesn't++The vault-side permission model is **identical** for NuGet signing and+Authenticode. AzureSignTool requires exactly: **Key: Sign**, **Secret:+Get**, **Certificate: Get** — the same three operations NuGetKeyVaultSignTool+already performs on every release. Therefore:++- **No new Azure RBAC role assignments** are needed (existing Key Vault+ Crypto User, or legacy access policy, already covers the operations).+- **No vault configuration changes** — same vault, same certificate, same+ `keys/sign` operation.+- **No new access policies, no key export, no `.pfx` generation.**++The ONLY thing that may need an Entra ID change is the **federated+credential** that maps GitHub OIDC tokens to the app registration, and only+when the Tauri build runs from somewhere the current credential does not+cover.++### Same repo / same environment → change nothing++If the Tauri signing job runs in `ag-ui-protocol/ag-ui` under the same+environment or ref as the existing NuGet signing job, the existing+federated credential covers it. The existing `AZURE_SIGNING_CLIENT_ID`+and `AZURE_TENANT_ID` just work.++### Different repo → add one federated credential++Federated credential subjects are **exact-match only** — no wildcards, no+org-wide `repo:org/*` coverage. A credential scoped to+`repo:ag-ui-protocol/ag-ui:...` does not cover any other repository. On+the SAME app registration the NuGet lane uses, add a new federated+credential:++- **Issuer:** `https://token.actions.githubusercontent.com`+- **Audience:** `api://AzureADTokenExchange`+- **Subject:** the new repo's token subject, e.g.+ `repo:other-org/tauri-app:environment:release` or+ `repo:other-org/tauri-app:ref:refs/heads/main`++Subject format caveat (important for 2026+): repositories created after+July 15, 2026 emit an **immutable subject format** by default —+`repo:owner@owner-id/repo@repo-id:ref:...` with numeric IDs embedded.+If the Tauri repo is brand new, its OIDC token's `sub` claim uses that+format and the credential subject must match it exactly. Before creating+the credential, run a debug workflow that requests the OIDC token and+prints the `sub` claim; copy it verbatim.++Alternative for many repos: Entra **flexible federation** (claims-matching+expressions) allows a single credential to cover multiple repositories —+prefer it when a third or fourth signing repo becomes likely.++### Cross-repo checklist (complete)++In the OTHER repository:++1. Add the federated credential on the existing app registration (above).+2. Set repo secrets/variables: `AZURE_TENANT_ID`, `AZURE_SIGNING_CLIENT_ID`+ (same values as the ag-ui repo), plus `AZURE_KEY_VAULT_URL` and+ `CODE_SIGNING_CERT_NAME`. Secrets do NOT share across repos — either+ recreate them per repo, or hoist the non-sensitive values (tenant ID,+ client ID, vault URL, cert name) to organization-level Actions+ variables so both repos read one source of truth.+3. Create the signing environment (e.g., `release`) if the credential+ subject is environment-scoped, and apply protection rules to it.+4. Declare `permissions: id-token: write` on the signing job.+5. Install AzureSignTool in the job: `dotnet tool install --global AzureSignTool`.+6. Add the `tauri.conf.json` signCommand + wrapper script (repo-local).++### Blast radius: shared identity vs separate identity++Adding the credential to the existing app registration means the Tauri+repo shares the exact identity that can invoke `keys/sign` on the org's+code-signing key: anyone who can trigger the signing job in that repo can+sign anything with the Tawkit cert. Since the cert is OV, SmartScreen+reputation accrues to the shared publisher — a compromised signing job in+any repo damages the org's whole signing reputation. Mitigations that cost+nothing in Azure:++- Scope the federated credential to a **protected environment** (subject+ `...:environment:release`) with required reviewers, rather than a plain+ branch ref, so signing only runs after approval.+- Keep the `signing-mode: none | keyvault` gate in the new repo, matching+ the ag-ui seam, so unprovisioned PRs can never trigger signing.++If isolation is required instead, create a SEPARATE app registration for+the Tauri repo — this is the one variant that DOES require new Azure+access rights, because the new service principal must be granted Key Vault+Crypto User on the vault manually.++## Verification++After a build, verify before publishing:++```powershell+# Authenticode + certificate chain + RFC 3161 timestamp+signtool verify /pa /v /all path\to\App.exe++# PowerShell alternative+Get-AuthenticodeSignature path\to\App.exe | Format-List++# Expected: Status Valid, SignerCertificate subject CN=Tawkit, Inc.,+# TimeStamperCertificate from DigiCert, timestamped within the cert validity.+```++For NuGet packages (separate lane, same vault):+`dotnet nuget verify Package.nupkg --verbosity detailed`.++Bringing a new repo online, in order:++1. Debug workflow: request the OIDC token and print the `sub` claim.+2. Create the federated credential with that exact subject.+3. `azure/login`, then read-only smoke test:+ `az keyvault certificate show --vault-name <vault> --name <cert>`.+4. If the smoke test passes, `keys/sign` will pass too — the sign+ permission is already proven by every NuGet release.+5. Full `tauri build` with signing enabled.++## Failure modes and diagnosis++- **azure/login "federated credential not found"**: subject mismatch. Print+ the job's `sub` claim and compare character-for-character with the+ credential subject — watch for the immutable format+ (`owner@owner-id/repo@repo-id`) on repos created after 2026-07-15, and+ for environment vs ref scoping.+- **OIDC token not issued / login gets no token**: the job lacks+ `permissions: id-token: write`.+- **"signCommand" not invoked / binaries unsigned**: check that the config+ landed under `bundle.windows` (not a v1-style top-level `windows` key),+ and that the command exits 0 — a non-zero exit fails the bundle step.+- **AzureSignTool not found**: it must be installed as a `dotnet tool` on+ the runner in the same job that runs the build.+- **401 / invalid token from the vault**: the access token must be scoped+ to `https://vault.azure.net` (Key Vault resource), not Azure Graph or+ management endpoints. Re-check the `--resource` in the token command.+- **403 on sign in a NEW repo but not the old one**: unexpected — same SPN,+ same operations. Check whether someone created a separate app registration+ for the new repo instead of reusing the existing one; if so, that SPN+ needs Key Vault Crypto User on the vault.+- **Signature valid locally but SmartScreen still warns**: expected for OV+ certificates on new apps. It is a reputation state, not a defect — do not+ "fix" it by changing certificates or re-signing repeatedly.+- **Updater verification failing**: updater signatures come from the+ Tauri minisign key pair (`tauri signer generate`), never from the vault+ cert. Generate and configure them separately if updater support is needed.diff --git a/app/src/components/computer/live-screen.tsx b/app/src/components/computer/live-screen.tsxindex cd9e1784..0a05d62a 100644--- a/app/src/components/computer/live-screen.tsx+++ b/app/src/components/computer/live-screen.tsx@@ -101,6 +101,29 @@ export function LiveScreen({ computerId, driving, onProblem }: Props) {return;}if (message.type !== "frame" || !message.data) return;+ // Live-run JSON only checks `typeof type === "string"` upstream. Non-finite or negative+ // dimensions would poison frameSize and every coordinate scaled from it; a huge payload+ // would hit `atob` before any bound. Both are dropped as corrupt frames.+ const width = message.width ?? 1280;+ const height = message.height ?? 800;+ if (+ typeof width !== "number" ||+ typeof height !== "number" ||+ !Number.isFinite(width) ||+ !Number.isFinite(height) ||+ width <= 0 ||+ height <= 0 ||+ width > 8192 ||+ height > 8192+ ) {+ return;+ }+ if (+ typeof message.data !== "string" ||+ message.data.length > 20_000_000+ ) {+ return;+ }const canvas = canvasRef.current;if (!canvas || closed) return;diff --git a/app/src/lib/client.ts b/app/src/lib/client.tsindex 2abae4c4..2e92b282 100644--- a/app/src/lib/client.ts+++ b/app/src/lib/client.ts@@ -98,5 +98,11 @@ export async function client<T>(if (key === undefined) return response;- return ((await response.json()) as Record<string, T>)[key];+ // A 204 or a non-JSON body used to throw a bare SyntaxError, and `null` or an array body threw+ // a TypeError on property access. Malformed success is a failed request with the fallback.+ const body = (await response.json().catch(() => null)) as unknown;+ if (!body || typeof body !== "object" || Array.isArray(body)) {+ throw new Error(options.fallback ?? "That request failed.");+ }+ return (body as Record<string, T>)[key];}diff --git a/app/src/lib/computers/control.ts b/app/src/lib/computers/control.tsindex eddca096..686c2547 100644--- a/app/src/lib/computers/control.ts+++ b/app/src/lib/computers/control.ts@@ -30,7 +30,13 @@ async function callControl(method ? { method } : {},);if (!response.ok) return null;- return (await response.json()) as ControlState;+ // A non-JSON or wrong-shaped body used to throw out of the readers and reject the panel's+ // poll. Reads answer null on failure, so malformed succeeds as missing.+ const body = (await response.json().catch(() => null)) as unknown;+ if (!body || typeof body !== "object" || Array.isArray(body)) return null;+ const holder = (body as { holder?: unknown }).holder;+ if (holder !== "bot" && holder !== "human") return null;+ return body as ControlState;}export function readControl(computerId: string) {diff --git a/app/src/lib/computers/screen.ts b/app/src/lib/computers/screen.tsindex df3025e2..d52608af 100644--- a/app/src/lib/computers/screen.ts+++ b/app/src/lib/computers/screen.ts@@ -35,12 +35,45 @@ export async function readScreenshot(} | null;return { error: body?.error ?? unavailable };}- return { frame: (await response.json()) as Screenshot };+ return parseScreenshot(await response.json().catch(() => null));} catch {return { error: unavailable };}}+function parseScreenshot(body: unknown): {+ frame?: Screenshot;+ error?: string;+} {+ const unavailable = "The screen is not available right now.";+ if (!body || typeof body !== "object" || Array.isArray(body)) {+ return { error: unavailable };+ }+ const frame = (body as { frame?: unknown }).frame ?? body;+ if (!frame || typeof frame !== "object" || Array.isArray(frame)) {+ return { error: unavailable };+ }+ const { base64, width, height } = frame as {+ base64?: unknown;+ width?: unknown;+ height?: unknown;+ };+ // A mistyped frame used to reach `atob` in the viewer and throw there. Refused here instead.+ if (+ typeof base64 !== "string" ||+ !base64 ||+ typeof width !== "number" ||+ !Number.isFinite(width) ||+ width <= 0 ||+ typeof height !== "number" ||+ !Number.isFinite(height) ||+ height <= 0+ ) {+ return { error: unavailable };+ }+ return { frame: frame as Screenshot };+}+/** The frame a page was showing when a Bot opened it. */export type PageFrame = { url: string; title: string | null; frame: string };@@ -61,8 +94,15 @@ export async function readPageFrame(`/api/computers/${computerId}/page-frame/${encodeURIComponent(toolCallId)}`,);if (!response.ok) return null;- const body = (await response.json()) as { frame?: PageFrame | null };- return body.frame ?? null;+ const body = (await response.json().catch(() => null)) as unknown;+ if (!body || typeof body !== "object" || Array.isArray(body)) return null;+ const frame = (body as { frame?: unknown }).frame;+ if (!frame || typeof frame !== "object" || Array.isArray(frame)) {+ return null;+ }+ const { frame: image } = frame as { frame?: unknown };+ if (typeof image !== "string" || !image) return null;+ return frame as PageFrame;} catch {// A missing picture is a smaller sentence, not a broken conversation.return null;diff --git a/app/src/lib/relative-time.ts b/app/src/lib/relative-time.tsindex d05c076d..f9c17d3f 100644--- a/app/src/lib/relative-time.ts+++ b/app/src/lib/relative-time.ts@@ -12,7 +12,11 @@ const relativeFormat = new Intl.RelativeTimeFormat(undefined, {/** Locale-aware relative timestamp, e.g. "2 minutes ago". */export function relativeTime(iso: string): string {- const elapsed = Date.now() - new Date(iso).getTime();+ const time = new Date(iso).getTime();+ // An invalid date used to flow into `Math.abs(NaN)` comparisons and `format(-NaN)`, which+ // answers "NaN weeks ago" or throws depending on ICU. Return the input unchanged instead.+ if (!Number.isFinite(time)) return iso;+ const elapsed = Date.now() - time;const scale =RELATIVE_UNITS.find(({ limit }) => Math.abs(elapsed) < limit) ??RELATIVE_UNITS[RELATIVE_UNITS.length - 1];diff --git a/app/src/lib/socket-url.ts b/app/src/lib/socket-url.tsindex 0822c0fb..5d0d47db 100644--- a/app/src/lib/socket-url.ts+++ b/app/src/lib/socket-url.ts@@ -27,6 +27,16 @@ function announcedPort(): string {: "";}+function validPort(port: string): string {+ // A whitespace, alphabetic, or out-of-range value used to be interpolated into the authority,+ // so `new WebSocket()` threw synchronously inside the effects that open it. Only whole digits+ // in range override same-origin.+ if (!/^\d+$/.test(port.trim())) return "";+ const n = Number(port.trim());+ if (!Number.isInteger(n) || n < 1 || n > 65535) return "";+ return String(n);+}+export function socketUrl(path: string,location: {@@ -39,6 +49,7 @@ export function socketUrl(const scheme = location.protocol === "https:" ? "wss:" : "ws:";// A port only when a Vite runtime named one: the app is not same-origin with the server there.// Otherwise the browser's own host, which is the server's own origin in production.- const authority = port ? `${location.hostname}:${port}` : location.host;+ const usable = validPort(port);+ const authority = usable ? `${location.hostname}:${usable}` : location.host;return `${scheme}//${authority}${path}`;}diff --git a/app/tests/app-resilience-guards.test.ts b/app/tests/app-resilience-guards.test.tsnew file mode 100644index 00000000..2518d2fa--- /dev/null+++ b/app/tests/app-resilience-guards.test.ts@@ -0,0 +1,100 @@+import { afterEach, describe, expect, test } from "bun:test";+import { socketUrl } from "../src/lib/socket-url";+import { relativeTime } from "../src/lib/relative-time";++const at = (protocol: string, hostname: string, host: string) => ({+ protocol,+ hostname,+ host,+});++/**+ * `__OPENBOT_WS_PORT__` was interpolated into the WebSocket authority unchecked, so `" "`,+ * `"abc"` or `"99999"` produced `ws://host:abc/path` and `new WebSocket()` threw synchronously+ * inside the effects that open it. Only whole digits in range override same-origin now.+ */+describe("socketUrl port validation", () => {+ test.each([+ ["whitespace", " "],+ ["letters", "abc"],+ ["too large", "99999"],+ ["zero", "0"],+ ])("falls back to same-origin on %s", (_n, port) => {+ expect(+ socketUrl("/api/channels/events", at("http:", "h", "h:3010"), port),+ ).toBe("ws://h:3010/api/channels/events");+ });++ test("keeps a valid override", () => {+ expect(+ socketUrl("/api/channels/events", at("http:", "h", "h:3010"), "3001"),+ ).toBe("ws://h:3001/api/channels/events");+ });+});++/**+ * An invalid date used to flow into `Math.abs(NaN)` comparisons and `format(-NaN)`, answering+ * "NaN weeks ago" or throwing depending on ICU. The input is returned unchanged instead.+ */+describe("relativeTime", () => {+ test("returns the input for an invalid date", () => {+ expect(relativeTime("not-a-date")).toBe("not-a-date");+ });++ test("still formats a valid date", () => {+ const iso = new Date(Date.now() - 30_000).toISOString();+ expect(relativeTime(iso)).toMatch(/second/);+ });+});++describe("control/screen/client guards", () => {+ const realFetch = globalThis.fetch;++ afterEach(() => {+ globalThis.fetch = realFetch;+ });++ test("readControl answers null on a malformed body", async () => {+ globalThis.fetch = (async () =>+ new Response(JSON.stringify([1, 2]), {+ status: 200,+ headers: { "content-type": "application/json" },+ })) as unknown as typeof fetch;+ const { readControl } = await import("../src/lib/computers/control");+ await expect(readControl("bot-1")).resolves.toBeNull();+ });++ test("client throws the fallback on a malformed envelope", async () => {+ globalThis.fetch = (async () =>+ new Response("null", {+ status: 200,+ headers: { "content-type": "application/json" },+ })) as unknown as typeof fetch;+ const { client } = await import("../src/lib/client");+ await expect(+ client("http://x.test/thing", "thing", { fallback: "Nope." }),+ ).rejects.toThrow("Nope.");+ });++ test("readScreenshot reports unavailable on a mistyped frame", async () => {+ globalThis.fetch = (async () =>+ new Response(JSON.stringify({ base64: 42, width: "x", height: 1 }), {+ status: 200,+ headers: { "content-type": "application/json" },+ })) as unknown as typeof fetch;+ const { readScreenshot } = await import("../src/lib/computers/screen");+ const result = await readScreenshot("bot-1");+ expect(result.frame).toBeUndefined();+ expect(typeof result.error).toBe("string");+ });++ test("readPageFrame answers null on an array frame", async () => {+ globalThis.fetch = (async () =>+ new Response(JSON.stringify({ frame: [] }), {+ status: 200,+ headers: { "content-type": "application/json" },+ })) as unknown as typeof fetch;+ const { readPageFrame } = await import("../src/lib/computers/screen");+ await expect(readPageFrame("bot-1", "turn-1")).resolves.toBeNull();+ });+});