Katia Bulatova
4569657923
## What & why This is the system behind the Dashboard Agent — an assistant that answers questions about a project's runs, errors, queues, deploys and health, and can investigate failures end to end. The agent runs as a chat.agent task in its own Trigger project. It has no access to the main database or ClickHouse; all platform data is read through the public API using a delegated, read-only user token. Everything here is behind `canAccessDashboardAgent` and inert with the flag off. The UI that mounts the panel lands in #4529. ## Stack `#4418` (this, base) ← `#4529` UI ← `#4525` Watch ← `#4516` storybook gallery. The scenario/contract reference for the whole stack is `internal-packages/dashboard-agent/GUIDEBOOK.md` (it lands on the Watch branch): it states, per feature, what makes each thing happen and where that is decided. ## What's inside **Agent runtime and tools** — `internal-packages/dashboard-agent`: prompt, tool set (API reads, TRQL query, docs, navigation, evidence/investigations, repo source), conversation compaction, a prompt-prefix token budget pinned by snapshot test, and sampled LLM-judged turn evals. The package cannot import webapp server code, which is what makes the "no DB access" claim structural rather than a convention. **Contracts** — `internal-packages/dashboard-agent-contracts`: `trigger://` URIs, intents, and the block envelope every rendered card travels in. **Conversation store** — `internal-packages/dashboard-agent-db`: drizzle over postgres-js in its own `trigger_dashboard_agent` Postgres schema, plus one additive migration. **Auth boundary** — the user-actor token gains an optional environment claim; one guard (`userActorEnvironment.server.ts`) enforces it so routes don't each re-derive the rule. Token minting, cap ceiling, and the RBAC fallback path for self-hosted. **Transport** — webapp resource routes that mint the token and proxy each turn, and SDK-side mid-turn reconnect. **Public API the agent reads through** — orgs, projects, environments, runs, queue metrics, workers, a run's commit metadata, repo snapshot, reports, and `POST /api/v1/query`. **Reports** — the health report's layout is declared once and shared by the card, the markdown surface and the JSON/MCP surface, so the same report reads the same in the dashboard, the terminal and an editor. **Block renderers** — the report and investigation cards the flows above already emit (`app/components/dashboard-agent/`). The panel that hosts them, and the rest of the chat UI, is #4529. **Query safety and CSP** — see below. ## Key decisions - **The agent is a separate Trigger project, not webapp code.** It reads platform data over the public API with a delegated user-actor token whose `cap` ceilings it to read scopes. No Prisma, no ClickHouse, no webapp imports. - **The PAT-only auth helper now refuses user-actor tokens.** This is an intentional behavioral change: its callers consume only a bare userId and do not enforce delegated-token capabilities. Actor-aware routes continue through the scoped route builders instead. - **RBAC fallback builds a delegated token's ability from its own cap**, never the blanket ability a PAT gets (read-only when the token declares none). Without this, the agent's read-only cap would buy a write JWT on self-hosted. - **Org creation checks RBAC only for user-actor tokens, and only after the env gate**, so an install with `ORG_CREATION_API_ENABLED` off returns 404 rather than 403, and an ordinary PAT never consults an ability the route has no org to scope. Both orderings are pinned by test. - **The query path is read-only in depth.** TRQL rejects write statements at the grammar level (they don't parse, rather than being filtered), ClickHouse runs with `readonly=1`, and the org/project/env filters are injected server-side from the credential — the request body cannot widen scope. An unparseable query denies instead of falling through to the permissive resource. - **Document-wide img-src CSP.** Remote images are an outbound-request/exfiltration surface, so the policy permits only own-origin/data/blob, the required SSO avatar hosts, and the favicon endpoint. Operators can add exact origins through CSP_IMG_SRC_ALLOWLIST; wildcard hosts and bare schemes are intentionally not allowed. - **The chat transport reconnects on a mid-turn EOF** (`@trigger.dev/sdk`). A body that ends without a turn-complete is terminal only when the server says `X-Session-Settled: true`; otherwise the transport resubscribes from `lastEventId` with bounded backoff, and any record re-earns the budget. Previously a closed long-poll window or a proxy restart left the reply stuck as if still generating. - **Conversations live in their own datastore**, schema-scoped and foreign-key-free (it references `organizationId`/`userId` by id, because in cloud it is a different database). It is a display read-model for the History tab and transport resume; `chat.agent`'s object-store snapshot remains the model's source of truth. - **Deterministic first.** Reports and health checks contain no LLM — they are computed from the same data the dashboard shows, and the model only narrates and links them. That is what makes a number in an answer auditable. ## Testing - 63 new test files, run with `pnpm run test --filter webapp` and per-package vitest. Heaviest coverage on the auth boundary (`userActorPatOnlyBoundary`, `userActorTokenClaimsAndScopes`, `contextlessPatRoutes`, `rbacFallbackBranch`), TRQL read-only, the report layout, and the SDK reconnect. - The agent package has a separate eval lane (`pnpm run test:evals`, `vitest.eval.config.ts`) that hits the real model, so it never runs in `pnpm test`. - Live-tested against a local stack scenario by scenario; the GUIDEBOOK lists the condition each behaviour is expected under, which is what those runs were checked against. ## Changelog `.server-changes/dashboard-agent.md`, plus changesets for `@trigger.dev/core` (report schemas), `@trigger.dev/sdk` (chat reconnect) and the CLI's `mint-token` help text.
78 lines
2.9 KiB
TypeScript
78 lines
2.9 KiB
TypeScript
import { describe, it, expect } from "vitest";
|
|
import { isValidTSQLQuery, getTSQLError } from "./tsqlLinter";
|
|
|
|
describe("tsqlLinter", () => {
|
|
describe("isValidTSQLQuery", () => {
|
|
it("should return true for empty queries", () => {
|
|
expect(isValidTSQLQuery("")).toBe(true);
|
|
expect(isValidTSQLQuery(" ")).toBe(true);
|
|
});
|
|
|
|
it("should return true for valid SELECT queries", () => {
|
|
expect(isValidTSQLQuery("SELECT * FROM users")).toBe(true);
|
|
expect(isValidTSQLQuery("SELECT id, name FROM users WHERE status = 'active'")).toBe(true);
|
|
expect(isValidTSQLQuery("SELECT count(*) FROM users GROUP BY status")).toBe(true);
|
|
});
|
|
|
|
it("should return true for queries with ORDER BY", () => {
|
|
expect(isValidTSQLQuery("SELECT * FROM users ORDER BY created_at DESC")).toBe(true);
|
|
});
|
|
|
|
it("should return true for queries with LIMIT", () => {
|
|
expect(isValidTSQLQuery("SELECT * FROM users LIMIT 10")).toBe(true);
|
|
expect(isValidTSQLQuery("SELECT * FROM users LIMIT 10 OFFSET 20")).toBe(true);
|
|
});
|
|
|
|
it("should return true for queries with JOINs", () => {
|
|
expect(isValidTSQLQuery("SELECT * FROM users JOIN orders ON users.id = orders.user_id")).toBe(
|
|
true
|
|
);
|
|
expect(
|
|
isValidTSQLQuery("SELECT * FROM users LEFT JOIN orders ON users.id = orders.user_id")
|
|
).toBe(true);
|
|
});
|
|
|
|
it("should return false for invalid syntax", () => {
|
|
expect(isValidTSQLQuery("SELEC * FROM users")).toBe(false);
|
|
expect(isValidTSQLQuery("SELECT * FORM users")).toBe(false);
|
|
expect(isValidTSQLQuery("SELECT FROM users")).toBe(false);
|
|
});
|
|
|
|
it("should return false for incomplete queries", () => {
|
|
expect(isValidTSQLQuery("SELECT * FROM")).toBe(false);
|
|
expect(isValidTSQLQuery("SELECT")).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("getTSQLError", () => {
|
|
it("should return null for empty queries", () => {
|
|
expect(getTSQLError("")).toBeNull();
|
|
expect(getTSQLError(" ")).toBeNull();
|
|
});
|
|
|
|
it("should return null for valid queries", () => {
|
|
expect(getTSQLError("SELECT * FROM users")).toBeNull();
|
|
expect(getTSQLError("SELECT id, name FROM users WHERE id = 1")).toBeNull();
|
|
});
|
|
|
|
it("should return error message for invalid queries", () => {
|
|
const error = getTSQLError("SELEC * FROM users");
|
|
expect(error).not.toBeNull();
|
|
expect(typeof error).toBe("string");
|
|
});
|
|
|
|
it("should include position information in error", () => {
|
|
const error = getTSQLError("SELECT * FORM users");
|
|
expect(error).not.toBeNull();
|
|
// Error message should contain line/column info
|
|
expect(error).toContain("line");
|
|
});
|
|
|
|
it("should accept a query without a FROM clause", () => {
|
|
// FROM is optional in the grammar (ClickHouse allows e.g. `SELECT 1`),
|
|
// so a FROM-less SELECT is syntactically valid.
|
|
expect(getTSQLError("SELECT * WHERE id = 1")).toBeNull();
|
|
});
|
|
});
|
|
});
|