@checkstack/automation-frontend 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,149 @@
 # @checkstack/automation-frontend
 
+## 0.4.0
+
+### Minor Changes
+
+- 9dcc848: Plugin-owned AI tools: every domain plugin contributes its own AI tools (chat assistant + automation AI action), and `ai-backend` is platform-only.
+
+  Every plugin-specific AI tool is owned by the plugin whose domain it acts on, registered via that plugin's own `aiToolExtensionPoint` / `aiToolProjectionExtensionPoint` from its init - the same path an external plugin author uses. `ai-backend` no longer imports or depends on any capability plugin's `*-common`; the dependency direction is strictly plugin -> ai-platform. Pure helpers (`computeFieldDiff`, capability-summary, `ScriptContextKind`) live in `@checkstack/ai-common`.
+
+  Tools shipped:
+
+  - Health checks and automations: full CRUD - `healthcheck.propose` / `automation.propose` and `*.update` (`mutate`, deep-validated) and `*.delete` (`destructive`, always confirm-gated). `healthcheck.propose`'s dry-run calls the new deep `validateConfiguration` so propose-time validation matches apply-time. Assertions are validated against the collector's result schema and the canonical operator vocabulary. Capability-catalog tools (`ai.listCapabilities`, `ai.getCapabilitySchema`), script context tools (`ai.getScriptContext`, `ai.testScript`), and notify-subscriber tools (`healthcheck.notifySystemSubscribers` / `...GroupSubscribers`).
+  - Catalog: `catalog.createSystem` / `updateSystem` / `createGroup` / `updateGroup` (`mutate`), `catalog.deleteSystem` / `deleteGroup` (`destructive`), membership tools (`mutate`), plus `catalog.listSystems` / `listGroups` read projections.
+  - Incident: `incident.create` / `update` / `addUpdate` / `resolve` / `addLink` (`mutate`), `incident.delete` / `removeLink` (`destructive`), and `incident.get` / `incident.list` read projections.
+  - Maintenance: `maintenance.create` / `update` / `addUpdate` / `close` / `addLink` (`mutate`), `maintenance.delete` / `removeLink` (`destructive`), and `maintenance.list` / `get` read projections.
+  - Read projections for SLO (`slo.listObjectives`), dependency (`dependency.list`), incident (`incident.list`), healthcheck (`healthcheck.status`), and anomaly (`anomaly.explain`), each gated by the source procedure's own access rule and routed as the principal.
+  - Documentation grounding: `ai.searchDocs` / `ai.getDoc` over a build-time bundled docs index (BM25-ish ranking), so the assistant grounds how-to answers in Checkstack's own docs offline.
+  - URL introspection: `ai.probeUrl`, an SSRF-guarded read tool the assistant uses to inspect a real endpoint before drafting a health check. Update tools compute a before -> after field diff rendered on the confirm card (approve mode) or an "Applied" card (auto mode), so a change is never silent.
+
+  `ai_analyze` automation action (automation-backend, with an editor connection picker + audited tool calls): runs a bounded AI agent on the run context as the automation's `runAs` service account, so it can never exceed that identity's permissions; destructive tools are never offered; mutating tools auto-apply through the service account's client. Produces an `automation.analysis` artifact downstream actions can branch on. The agent loop is exposed as a headless `aiAgentRunnerRef` service so automation-backend can drive it without depending on ai-backend.
+
+  `notification.notifyForSubscription` is now callable by user / application principals holding `notification.send` (previously service-only). Every tool routes through the user-scoped client, so handler-side authorization is enforced exactly as a direct UI/RPC action; the resolver gate plus the propose/apply re-check at propose AND apply are the additional authority. A systemic authz regression test asserts every registered tool falls into exactly one safe authorization category.
+
+  A new `ai_transport` enum value `automation` records the AI action's tool calls in the `ai_tool_calls` audit log. No new durable state beyond that; each tool is a thin, deterministic wrapper over an existing RPC, so every pod behaves identically.
+
+  This is a beta minor.
+
+- 9dcc848: Automations now run as a configured service account, removing implicit god-mode from the dispatch path.
+
+  BREAKING: every automation must declare a `runAs` application (service account). Previously every automation action ran as the trusted service client, bypassing all access-rule, per-resource, and team-scope checks - so an automation could touch any team's data. Now each automation runs as a bounded `application` principal, and every data-access call an action makes is authorized exactly as that identity. An automation with no `runAs` fails to run with a clear error rather than falling back to the trusted client; legacy automations must be assigned a service account before they run again.
+
+  What changed:
+
+  - New top-level field `runAs` on automations (a `run_as_application_id` column + create/update inputs; `AutomationSchema.runAs`). Required on create; GitOps sets it via the `run-as` metadata label.
+  - A new `coreServices.rpcClientAs(applicationId)` mints a short-lived, backend-signed app-principal token; the auth service resolves it LIVE to an `application` principal (reusing `enrichApplicationPrincipal`), so it flows through full `autoAuthMiddleware` enforcement. The dispatch engine threads this client into every action's `execute` as the required `context.rpcClient`.
+  - Bind authority (anti-escalation): a user may only bind an application whose access rules are a subset of their own (`isApplicationBindable`); `getBindableApplications` lists only bindable apps, and the create/update handlers enforce the check.
+  - `notification.sendTransactional` moves from service-only to access-gated (`notification.send`, a new access rule), so an automation's `runAs` can call the built-in `notify_user` / `notification.send` actions; trusted services still bypass via short-circuit.
+  - A "Run as (Service Account)" picker in the automation editor, populated from `getBindableApplications` (server-side filtered to bindable apps), seeding from the loaded `runAs` on edit and passing it into create + update. First-class teaching UX: an inline info banner, a blocked Save with an inline hint until one is chosen, and an empty state linking to the Applications admin + docs when none are bindable.
+
+  State and scale: `runAs` resolution is a pure read over shared tables; the app-principal token is self-contained and verified statelessly, so the per-run client is correct under horizontal scale.
+
+  This is a beta minor.
+
+- 9dcc848: Cut initial-load JS: lazy plugin contributions, a hardened lazy-by-default contribution contract, on-demand Monaco, and a lighter icon/chart load.
+
+  - Lazy plugin route pages: each plugin's route `element` references a `React.lazy`-wrapped page rendered inside a shared `<Suspense>` boundary. Plugins still register synchronously, so nav, slots, commands, API factories, and `foreignSignals` are available on first paint. This moves ~37 route-page chunks (~600 KB) out of the entry; the entry chunk drops from ~2.4 MB to ~190 KB. Auth flow pages stay eager. The `@checkstack/scripts` scaffold template generates lazy route pages too.
+  - Hardened contribution contract (BREAKING, frontend plugin contract): plugins declare contributions lazily and let the framework own code-splitting, Suspense, and per-plugin error isolation. Routes use `load: () => import("./Page").then((m) => ({ default: m.Page }))` instead of `element: <Page />` (`element` is still accepted for the rare page that must paint without a chunk fetch; provide exactly one). Slot extensions accept either an eager `component` or a lazy `load`; new `getLazyContribution` + `ExtensionComponent` exports from `@checkstack/frontend-api` render either kind. This also fixes runtime-installed plugins: `ExtensionSlot` subscribes to the plugin registry, and the API registry rebuilds when the plugin set changes (`getPlugins()` returns an immutable snapshot via `useSyncExternalStore`). A per-plugin error boundary contains a bad contribution.
+  - On-demand Monaco: the `@checkstack/ui` barrel no longer pulls the `@codingame/*` / `monaco-languageclient` stack into the initial load. `CodeEditor` lazy-loads its Monaco-backed editor behind `React.lazy` + Suspense, `validateTypeScriptSources` imports the editor API via in-body `await import(...)`, and the "vscode services ready" signal moved to a Monaco-free module. The ~10 MB editor body loads only when a `CodeEditor` mounts. A `react-vendor` `manualChunks` split was added for stable vendor caching.
+  - lucide-react 1.x + lighter icons/charts (BREAKING for icon consumers): lucide-react unified from three drifting ranges to `^1.17.0`. lucide v1 removed brand icons, so the GitHub/GitLab marks are vendored in `@checkstack/ui` (`GithubIcon`, `GitlabIcon`, `brandIcons`); a new `IconName` type (`LucideIconName | BrandIconName`) in `@checkstack/common` is canonical, accepted by `AuthStrategy.icon` and the card components, so data-driven brand names keep working. `DynamicIcon` no longer eagerly imports lucide's ~1600-icon map (~1 MB) - it lives in a `React.lazy` `iconRegistry` chunk fetched on first data-driven render, while statically named-imported icons tree-shake normally. The recharts-backed health-check charts (~300 KB) and the `HealthCheckSystemOverview` drawer leave the initial load.
+
+  BREAKING CHANGES:
+
+  - Frontend plugin contract: routes/slot contributions are lazy-by-default (`load` instead of `element`/eager elements) as described above.
+  - Any external consumer importing a brand icon from `lucide-react` (e.g. `import { Github } from "lucide-react"`) must switch to the vendored `@checkstack/ui` brand icons or a custom SVG.
+
+  This is a beta minor.
+
+- 9dcc848: Add the auto-generated, version-pinned `@checkstack/sdk` package + codegen, and serve its types live to the in-app editor.
+
+  - A new committed workspace package `@checkstack/sdk`, generated from the platform's source of truth by `scripts/generate-sdk.ts` (`generate:sdk` / `generate:sdk:check`): a fully-typed oRPC client (`createCheckstackClient`) over the REST surface with one `InferClient` per plugin contract, real script-authoring helpers (`@checkstack/sdk/healthcheck`, `@checkstack/sdk/integration`) whose runtime body is the same identity function the in-app runner injects, per-subpath `.d.ts` under the package `exports` map, and an editor-only ambient bundle. A `generate:sdk:check` CI guard fails when the committed SDK files drift from a fresh generation. The `@checkstack/sdk` version is stamped from `@checkstack/release` and MUST NOT appear in a changeset (a guard enforces this); the `@checkstack/release` bump here advances the release version so the generated SDK can be published later. The generated client also normalizes its base URL without a backtracking-prone regex, closing a CodeQL `js/polynomial-redos` finding.
+  - Live editor type injection: a new version-keyed route `GET /api/script-packages/sdk-types/:releaseVersion` (raw handler in `@checkstack/script-packages-backend`) serves the generated SDK editor bundle with `Cache-Control: private, max-age=1y, immutable`; the pure path-build/parse module lives in `@checkstack/script-packages-common`, shared by backend and frontend. A mismatched version returns `409` so the editor refetches and never serves stale types after an upgrade. The frontend `useSdkTypeInjection` hook fetches the bundle once per session and mounts it into Monaco via `addExtraLib`. Schema-narrowed `context.config` / `context.event.payload` editor types stay local; the package-resolving module declarations come from the one published `@checkstack/sdk` source.
+
+  BREAKING CHANGES: the script-authoring import surface moves from the bare `@checkstack/healthcheck` / `@checkstack/integration` virtual modules to the `@checkstack/sdk/healthcheck` / `@checkstack/sdk/integration` subpaths of the published `@checkstack/sdk` package. The old bare-name imports no longer resolve (an old import now errors in the editor, surfacing the migration). Existing scripts must update the module specifier:
+
+      - import { defineHealthCheck } from "@checkstack/healthcheck";
+      + import { defineHealthCheck } from "@checkstack/sdk/healthcheck";
+
+      - import { defineIntegration } from "@checkstack/integration";
+      + import { defineIntegration } from "@checkstack/sdk/integration";
+
+  The helper names and their runtime behaviour are unchanged - only the module specifier moves. The global (no-import) helper form continues to work unchanged.
+
+  This is a beta minor.
+
+- 9dcc848: Align workspace dependency versions and migrate React Router to v7.
+
+  BREAKING CHANGES (React Router v7): All frontend packages now depend on `react-router-dom@^7.16.0`. Previously the workspace declared four divergent ranges (`^6.20.0`, `^6.22.0`, `^7.1.1`, `^7.14.2`), which resolved both `react-router@6` and `react-router@7` into a single bundle. Everything is now unified on v7. The public imports the app uses (`BrowserRouter`, `Routes`, `Route`, `Link`, `NavLink`, `MemoryRouter`, `useNavigate`, `useParams`, `useSearchParams`, `useLocation`) are unchanged between v6 and v7, so no source rewrites were required - but any out-of-tree plugin still on react-router v6 should upgrade to v7 (see the React Router v6 -> v7 upgrade guide) to share the host's single router instance via the import map.
+
+  Other unified ranges (no API change): `react` -> `^18.3.1`, the `@orpc/*` family (`contract`, `server`, `client`, `tanstack-query`, `openapi`, `zod`) -> `^1.14.4`, and `better-auth` -> `^1.6.13`.
+
+  Removed the pre-rename `@orpc/react-query` leftover from `@checkstack/frontend-api`; its `createRouterUtils` / `RouterUtils` / `ProcedureUtils` now come from `@orpc/tanstack-query` (the package already in use).
+
+  Stale in-range runtime deps pulled up to current published versions: `hono` `^4.12.23`, `@tanstack/react-query` (+devtools) `^5.100.14`, `date-fns` `^4.4.0`, `jose` `^6.2.3`, `tar` `^7.5.16`, `semver` `^7.8.1`, `@xyflow/react` `^12.11.0`.
+
+### Patch Changes
+
+- 9dcc848: Assorted bug fixes and small hardening across the platform.
+
+  - announcement-backend: `updateAnnouncement` now invalidates the active-announcements and admin-list caches (it was missing the `invalidateAllActive` / `invalidateListAll` calls), so an edited announcement no longer stays stale up to the 45s TTL.
+  - anomaly-backend: anomaly/drift state transitions (confirmations, recoveries, self-resolutions) now log at `debug` instead of info/warn - they are already surfaced via the `ANOMALY_STATE_CHANGED` signal, so logging them louder just added noise; genuine failure paths stay `warn`.
+  - backend: the `/api/:pluginId/*` dispatcher now populates `requestHeaders` on the per-request RPC context, so a handler that re-enters the router as the originating user (e.g. an AI tool's user-scoped client) can forward the caller's session cookie / bearer - previously the loopback failed with "Authentication required". Guarded by a real end-to-end integration test. The HTTP server idle timeout is also raised (default 255s, configurable via `CHECKSTACK_SERVER_IDLE_TIMEOUT_SECONDS`, clamped 0-255, reset on each streamed chunk) so long AI chat SSE turns are not severed mid-stream.
+  - backend: a request for an unknown plugin id (`/api/<unknown>/...`) now returns `404 Not Found` instead of `500` (and logs at warn, not error, since it is a client request) - an unknown _procedure_ on a known plugin already 404'd. The in-app docs namespace `/checkstack/*` now serves Starlight's own `404.html` with a real 404 status for a missing doc, instead of falling through to the SPA catch-all and 200-ing the app shell. Both guarded by tests.
+  - automation-common: remove polynomial-time backtracking from `toShellEnvKey`'s underscore-trim (CodeQL `js/polynomial-redos`); a negative look-behind anchors the trailing run, keeping the trim linear.
+  - common + script-packages-common: the pure transport-safe sandbox-policy schema (`sandboxPolicySchema` and its sub-schemas + inferred types) moved to `@checkstack/common` (the neutral base), removing two inverted deps that existed only to reach the shape; `@checkstack/backend-api` continues to re-export it. The schema is no longer exported from `@checkstack/script-packages-common`. Pure refactor, no behavior change.
+  - catalog-backend: reject duplicate system names (a `CONFLICT` on create/rename, enforced by a pre-write check AND a new DB unique index on `systems.name`, migration 0004 which first resolves pre-existing duplicates by suffixing).
+  - catalog-frontend: detail-page cleanups (use `<NotFound />` not `<AccessDenied />` on the not-found branch, a readable key/value metadata list via `normalizeMetadata`, runtime locale via `formatDate`); and stop the browse view re-rendering on every health report (adopt a new statuses report only when a value actually changed, via `healthStatusesEqual`, so rows stay stable and interactive).
+  - healthcheck-backend: fix the daily-rollup retention step failing with an `ON CONFLICT` mismatch (SQLSTATE 42P10) after `environmentId` joined the `health_check_aggregates` unique constraint - the rollup now groups by (day, environmentId, sourceId) and uses a single exported conflict-target constant (`DAILY_AGGREGATE_CONFLICT_TARGET`) kept in lock-step with the schema by a unit test.
+  - automation-frontend: the service-account picker's "Learn more" links are now absolute URLs to the deployed Astro docs site (they 404ed as in-app relative paths). The Monaco script editor double-init crash is fixed (serialized cold init, a guarded `monacoGuard` accessor, theme/type effects gated on `apiReady`).
+  - auth-frontend: bound the desktop user-menu popover height (`max-h-[var(--radix-popover-content-available-height)]` + `overflow-y-auto`) so it no longer clips on short viewports, and fold the standalone `Account > Profile` item into a focusable name/email header (`profileHref` on `UserMenu`); the now-empty `Account` group no longer renders.
+  - satellite-frontend: picked up via the sidebar-nav migration (account-only user menu).
+
+  (Related UI fixes - the Monaco editor following the app theme, the `DynamicOptionsField` no-flash fix, the shared `Spinner`, GFM tables, and the user-menu popover bound - land their `@checkstack/ui` bump in the UI/perf changesets where `@checkstack/ui` is already minored.)
+
+  This is a beta patch.
+
+- 9dcc848: Move primary navigation into a left sidebar, and serve the user guide in-app.
+
+  Feature navigation (a ~20-item user-menu dropdown) now lives in a persistent left sidebar (a slide-over drawer on mobile), grouped by section with the active route highlighted; the user menu keeps only account actions. A route opts into the sidebar with new `nav` metadata (`{ group, icon, label?, order?, accessRule? }`) on its registration, co-located with path + access + title. The sidebar filters entries with the same access check as page guards. `@checkstack/common` gains `isAccessRuleSatisfied` and a centralized set of in-app doc slugs (`APP_DOC_SLUGS` + `docsPath`, with a test asserting each resolves to a real docs page); `@checkstack/auth-frontend` exports `useAccessRules`.
+
+  The backend now serves the Astro Starlight docs build same-origin at `/checkstack/*` (the same artifact deployed to GitHub Pages), so the user guide is available inside the app including for self-hosted / air-gapped installs (served verbatim, no rebuild, no link rewriting; from `CHECKSTACK_DOCS_DIST`, before the SPA catch-all, degrading gracefully when absent; the Docker image builds and ships `docs/dist`; Vite proxies `/checkstack` in dev). The "Docs" link is a shell-owned external sidebar entry under the Documentation group (book icon), opening `/checkstack/user-guide/` in a new tab; the group renders even when no plugin route contributes to it.
+
+  BREAKING (plugin authors): `UserMenuItemsSlot` is no longer the way to add navigation - registering a top user-menu item no longer surfaces it anywhere. Add `nav` to the page's route instead. `UserMenuItemsBottomSlot` (account items) is unchanged. All bundled plugins have been migrated.
+
+  This is a beta minor.
+
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+  - @checkstack/ui@1.13.0
+  - @checkstack/auth-common@0.8.0
+  - @checkstack/automation-common@0.4.0
+  - @checkstack/catalog-common@2.3.0
+  - @checkstack/common@0.13.0
+  - @checkstack/template-engine@0.4.0
+  - @checkstack/frontend-api@0.7.0
+  - @checkstack/gitops-frontend@0.5.0
+  - @checkstack/script-packages-frontend@0.3.0
+  - @checkstack/secrets-frontend@0.2.0
+  - @checkstack/integration-common@0.7.0
+  - @checkstack/signal-frontend@0.2.0
+
 ## 0.3.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/automation-frontend",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "Elastic-2.0",
   "type": "module",
   "main": "src/index.tsx",
@@ -13,24 +13,25 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/automation-common": "0.2.0",
+    "@checkstack/auth-common": "0.7.2",
+    "@checkstack/automation-common": "0.3.0",
     "@checkstack/catalog-common": "2.2.3",
     "@checkstack/common": "0.12.0",
     "@checkstack/frontend-api": "0.6.0",
-    "@checkstack/gitops-frontend": "0.4.6",
+    "@checkstack/gitops-frontend": "0.4.7",
     "@checkstack/integration-common": "0.6.0",
-    "@checkstack/script-packages-frontend": "0.1.0",
-    "@checkstack/secrets-frontend": "0.0.1",
+    "@checkstack/script-packages-frontend": "0.2.0",
+    "@checkstack/secrets-frontend": "0.1.0",
     "@checkstack/signal-frontend": "0.1.5",
-    "@checkstack/template-engine": "0.2.0",
-    "@checkstack/ui": "1.11.0",
+    "@checkstack/template-engine": "0.3.0",
+    "@checkstack/ui": "1.12.0",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^8.0.0",
     "@dnd-kit/utilities": "^3.2.2",
-    "date-fns": "^4.1.0",
-    "lucide-react": "^0.344.0",
-    "react": "^18.2.0",
-    "react-router-dom": "^6.22.0",
+    "date-fns": "^4.4.0",
+    "lucide-react": "^1.17.0",
+    "react": "^18.3.1",
+    "react-router-dom": "^7.16.0",
     "yaml": "^2.6.1"
   },
   "devDependencies": {

package/src/components/RunAsServiceAccountPicker.tsx

@@ -0,0 +1,170 @@
+import React from "react";
+import { Link } from "react-router-dom";
+import { ExternalLink, KeyRound, ShieldCheck } from "lucide-react";
+import { usePluginClient } from "@checkstack/frontend-api";
+import { AuthApi, authRoutes } from "@checkstack/auth-common";
+import { resolveRoute, APP_DOC_SLUGS, docsPath } from "@checkstack/common";
+import {
+  Label,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  InfoBanner,
+  InfoBannerIcon,
+  InfoBannerContent,
+  InfoBannerDescription,
+  EmptyState,
+  Button,
+} from "@checkstack/ui";
+
+/**
+ * Deep-links into the in-app user guide. The backend serves the Astro Starlight
+ * docs build same-origin at `/checkstack/*`, so these are same-origin paths
+ * opened in a new tab. They are static doc pages, not app routes - hence a plain
+ * anchor (below), never a react-router `<Link>`. Slugs are centralised in
+ * `APP_DOC_SLUGS` and guarded by `docs-links.test.ts` against renames.
+ */
+const DOCS_TEAMS_AND_ACCESS = docsPath(APP_DOC_SLUGS.teamsAndAccess);
+const DOCS_SERVICE_ACCOUNTS = docsPath(APP_DOC_SLUGS.apiKeys);
+
+/** Route to the Applications admin tab in auth settings. */
+const APPLICATIONS_ADMIN_ROUTE = `${resolveRoute(
+  authRoutes.routes.settings,
+)}?tab=applications`;
+
+export interface RunAsServiceAccountPickerProps {
+  /** Selected application id, or empty string when nothing is chosen yet. */
+  value: string;
+  /** Called with the chosen application id. */
+  onValueChange: (next: string) => void;
+  /** When false, the picker is read-only (matches the page's `canManage`). */
+  disabled?: boolean;
+  /** Show the inline "required" validation hint. */
+  showError?: boolean;
+}
+
+/**
+ * "Run as (Service Account)" picker for the automation editor.
+ *
+ * Populated from the auth plugin's `getBindableApplications` query, which
+ * server-side filters to exactly the applications THIS user is allowed to
+ * bind (their access rules are a subset of the caller's). The automation
+ * then runs with the chosen application's permissions, so picking one is
+ * required.
+ *
+ * Teaching UX:
+ *   - An info banner explains what a service account is and why it is
+ *     required.
+ *   - When no applications are bindable, an `EmptyState` points the user to
+ *     the Applications admin and the docs instead of leaving them stuck.
+ */
+export const RunAsServiceAccountPicker: React.FC<
+  RunAsServiceAccountPickerProps
+> = ({ value, onValueChange, disabled, showError }) => {
+  const authClient = usePluginClient(AuthApi);
+  const { data: applications = [], isLoading } =
+    authClient.getBindableApplications.useQuery({});
+
+  const hasNoApplications = !isLoading && applications.length === 0;
+
+  return (
+    <div className="space-y-2">
+      <div className="space-y-1">
+        <Label htmlFor="runAs">Run as (Service Account)</Label>
+        <Select
+          value={value || undefined}
+          onValueChange={onValueChange}
+          disabled={disabled || hasNoApplications || isLoading}
+        >
+          <SelectTrigger
+            id="runAs"
+            aria-invalid={showError ? true : undefined}
+            className={showError ? "border-destructive" : undefined}
+          >
+            <SelectValue
+              placeholder={
+                isLoading ? "Loading service accounts..." : "Select a service account"
+              }
+            />
+          </SelectTrigger>
+          <SelectContent>
+            {applications.map((app) => (
+              <SelectItem key={app.id} value={app.id}>
+                <span className="flex flex-col text-left">
+                  <span className="truncate">{app.name}</span>
+                  {app.description ? (
+                    <span className="text-xs text-muted-foreground truncate">
+                      {app.description}
+                    </span>
+                  ) : null}
+                </span>
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        {showError && !hasNoApplications && (
+          <p className="text-xs text-destructive">
+            A service account is required.
+          </p>
+        )}
+      </div>
+
+      {hasNoApplications ? (
+        <EmptyState
+          icon={<KeyRound className="h-7 w-7" />}
+          title="No service accounts available"
+          description={
+            <>
+              An automation runs with a service account's permissions, but you
+              do not have any to bind yet. Create or get access to one in the
+              Applications admin, then come back here.
+            </>
+          }
+          actions={
+            <>
+              <Link to={APPLICATIONS_ADMIN_ROUTE}>
+                <Button size="sm" variant="outline">
+                  Open Applications admin
+                </Button>
+              </Link>
+              <a
+                href={DOCS_SERVICE_ACCOUNTS}
+                target="_blank"
+                rel="noreferrer"
+              >
+                <Button size="sm" variant="ghost">
+                  Learn more
+                  <ExternalLink className="ml-1 h-3.5 w-3.5" />
+                </Button>
+              </a>
+            </>
+          }
+        />
+      ) : (
+        <InfoBanner variant="info">
+          <InfoBannerIcon>
+            <ShieldCheck className="h-4 w-4" />
+          </InfoBannerIcon>
+          <InfoBannerContent>
+            <InfoBannerDescription>
+              A service account is an application the automation runs as. It
+              executes with that account's permissions (assigned via roles), so
+              picking one is required.{" "}
+              <a
+                href={DOCS_TEAMS_AND_ACCESS}
+                target="_blank"
+                rel="noreferrer"
+                className="inline-flex items-center gap-0.5 underline underline-offset-2 hover:no-underline"
+              >
+                Learn more
+                <ExternalLink className="h-3 w-3" />
+              </a>
+            </InfoBannerDescription>
+          </InfoBannerContent>
+        </InfoBanner>
+      )}
+    </div>
+  );
+};

package/src/editor/ScriptServicesBooter.tsx

@@ -47,6 +47,10 @@ export const ScriptServicesBooter: React.FC = () => {
         minHeight="1px"
         allowPopout={false}
         readOnly
+        // Never let this hidden editor be the sole cold-init driver: a hidden
+        // editor's monaco-vscode init may never complete. It defers to a
+        // visible editor, then attaches once services are up.
+        deferInit
       />
     </div>
   );

package/src/editor/action-leaf-cards.tsx

@@ -34,7 +34,10 @@ import { ItemPicker } from "./ItemPicker";
 import { ConditionEditor } from "./ConditionEditor";
 import { useConnectionOptionResolvers } from "./useConnectionOptionResolvers";
 import { automationScriptTestRenderer } from "./ScriptTestRenderer";
-import { useScriptPackageTypeAcquisition } from "@checkstack/script-packages-frontend";
+import {
+  useScriptPackageTypeAcquisition,
+  useSdkTypeInjection,
+} from "@checkstack/script-packages-frontend";
 import { useSecretNames } from "@checkstack/secrets-frontend";
 import { generateSecretEnvTypes, secretEnvEnvNames } from "../script-context";
 
@@ -85,6 +88,8 @@ export const ProviderActionBody: React.FC<{
   // name itself) before any module is registered.
   const { acquireTypes, acquireResetKey, importablePackages } =
     useScriptPackageTypeAcquisition();
+  // SDK editor types so `@checkstack/sdk/integration` imports resolve.
+  const { sdkTypes, sdkTypesResetKey } = useSdkTypeInjection();
   // Secret names (never values) for the secret -> env mapping editor's
   // ${{ secrets.* }} autocomplete.
   const { secretNames } = useSecretNames();
@@ -179,6 +184,8 @@ export const ProviderActionBody: React.FC<{
         secretNames={secretNames}
         acquireTypes={acquireTypes}
         acquireResetKey={acquireResetKey}
+        sdkTypes={sdkTypes}
+        sdkTypesResetKey={sdkTypesResetKey}
         importablePackages={importablePackages}
       />
     </div>

package/src/index.tsx

@@ -1,19 +1,10 @@
-import {
-  createFrontendPlugin,
-  createSlotExtension,
-  UserMenuItemsSlot,
-} from "@checkstack/frontend-api";
+import { createFrontendPlugin } from "@checkstack/frontend-api";
 import {
   automationRoutes,
   pluginMetadata,
   automationAccess,
 } from "@checkstack/automation-common";
-import { AutomationListPage } from "./pages/AutomationListPage";
-import { AutomationEditPage } from "./pages/AutomationEditPage";
-import { RunsPage } from "./pages/RunsPage";
-import { RunDetailPage } from "./pages/RunDetailPage";
-import { TemplatePlaygroundPage } from "./pages/TemplatePlaygroundPage";
-import { AutomationMenuItems } from "./components/AutomationMenuItems";
+import { Workflow } from "lucide-react";
 
 export {
   generateAutomationContextTypes,
@@ -52,46 +43,55 @@ export default createFrontendPlugin({
   routes: [
     {
       route: automationRoutes.routes.list,
-      element: <AutomationListPage />,
+      load: () =>
+        import("./pages/AutomationListPage").then((m) => ({
+          default: m.AutomationListPage,
+        })),
       title: "Automations",
       accessRule: automationAccess.read,
+      nav: { group: "Automation", icon: Workflow },
     },
     {
       route: automationRoutes.routes.create,
-      element: <AutomationEditPage />,
+      load: () =>
+        import("./pages/AutomationEditPage").then((m) => ({
+          default: m.AutomationEditPage,
+        })),
       title: "New automation",
       accessRule: automationAccess.manage,
     },
     {
       route: automationRoutes.routes.edit,
-      element: <AutomationEditPage />,
+      load: () =>
+        import("./pages/AutomationEditPage").then((m) => ({
+          default: m.AutomationEditPage,
+        })),
       title: "Edit automation",
       accessRule: automationAccess.read,
     },
     {
       route: automationRoutes.routes.runs,
-      element: <RunsPage />,
+      load: () => import("./pages/RunsPage").then((m) => ({ default: m.RunsPage })),
       title: "Run history",
       accessRule: automationAccess.read,
     },
     {
       route: automationRoutes.routes.runDetail,
-      element: <RunDetailPage />,
+      load: () =>
+        import("./pages/RunDetailPage").then((m) => ({
+          default: m.RunDetailPage,
+        })),
       title: "Run details",
       accessRule: automationAccess.read,
     },
     {
       route: automationRoutes.routes.playground,
-      element: <TemplatePlaygroundPage />,
+      load: () =>
+        import("./pages/TemplatePlaygroundPage").then((m) => ({
+          default: m.TemplatePlaygroundPage,
+        })),
       title: "Template playground",
       accessRule: automationAccess.read,
     },
   ],
-  extensions: [
-    createSlotExtension(UserMenuItemsSlot, {
-      id: "automation.user-menu.items",
-      component: AutomationMenuItems,
-      metadata: { group: "Automation" },
-    }),
-  ],
 });

package/src/pages/AutomationEditPage.tsx

@@ -57,6 +57,7 @@ import { assignDefaultTriggerIds } from "../editor/trigger-helpers";
 import { computeYamlMarkers } from "../editor/yaml-markers";
 import { partitionIssues } from "../editor/editor-validation";
 import { AutomationGroupCombobox } from "../components/AutomationGroupCombobox";
+import { RunAsServiceAccountPicker } from "../components/RunAsServiceAccountPicker";
 
 const STARTER_DEFINITION: AutomationDefinition = {
   name: "New Automation",
@@ -133,6 +134,9 @@ const AutomationEditContent: React.FC = () => {
   const [description, setDescription] = React.useState("");
   // Empty string means "Ungrouped" — sent as `null` on save to clear it.
   const [group, setGroup] = React.useState("");
+  // Service account (Application id) the automation runs as. Empty means
+  // "not chosen yet" — save is blocked until one is selected.
+  const [runAsApplicationId, setRunAsApplicationId] = React.useState("");
   const [statusEnabled, setStatusEnabled] = React.useState(true);
 
   // Existing group values for the picker's "pick existing" suggestions.
@@ -172,6 +176,7 @@ const AutomationEditContent: React.FC = () => {
       setName(a.name);
       setDescription(a.description ?? "");
       setGroup(a.group ?? "");
+      setRunAsApplicationId(a.runAs ?? "");
       setStatusEnabled(a.status === "enabled");
       setDefinition(normalized);
       setYamlText(stringifyYaml(normalized));
@@ -337,6 +342,7 @@ const AutomationEditContent: React.FC = () => {
         name,
         description: description || undefined,
         group: trimmedGroup || undefined,
+        runAs: runAsApplicationId,
         status: statusEnabled ? "enabled" : "disabled",
         definition: merged,
       });
@@ -346,6 +352,7 @@ const AutomationEditContent: React.FC = () => {
         name,
         description: description || undefined,
         group: trimmedGroup || null,
+        runAs: runAsApplicationId,
         status: statusEnabled ? "enabled" : "disabled",
         definition: merged,
       });
@@ -393,8 +400,15 @@ const AutomationEditContent: React.FC = () => {
   // "Input validation failed" toast. Validate it here so the Name field can
   // surface the error and Save can be disabled instead.
   const nameError = name.trim().length === 0 ? "Name is required" : undefined;
+  // A service account is required: the automation runs with its permissions,
+  // so the backend rejects a save without one. Block save + hint inline.
+  const runAsError =
+    runAsApplicationId.trim().length === 0
+      ? "A service account is required"
+      : undefined;
   const isSaving = createMutation.isPending || updateMutation.isPending;
-  const canSave = !nameError && validationErrors.length === 0 && !isSaving;
+  const canSave =
+    !nameError && !runAsError && validationErrors.length === 0 && !isSaving;
 
   return (
     <PageLayout
@@ -505,6 +519,12 @@ const AutomationEditContent: React.FC = () => {
                   Optional. Organises the automations list into sections.
                 </p>
               </div>
+              <RunAsServiceAccountPicker
+                value={runAsApplicationId}
+                onValueChange={setRunAsApplicationId}
+                disabled={!canManage}
+                showError={!!runAsError}
+              />
               <div className="flex items-center justify-between">
                 <Label htmlFor="enabled">Enabled</Label>
                 <Toggle

package/src/pages/automation-grouping.test.ts

@@ -26,6 +26,7 @@ function make({
     id,
     name: `Automation ${id}`,
     group,
+    runAs: null,
     status: "enabled",
     definition: DEFINITION,
     createdAt: new Date("2026-01-01T00:00:00Z"),

package/tsconfig.json

@@ -4,6 +4,9 @@
     "src"
   ],
   "references": [
+    {
+      "path": "../auth-common"
+    },
     {
       "path": "../automation-common"
     },

package/src/components/AutomationMenuItems.tsx

@@ -1,37 +0,0 @@
-import React from "react";
-import { Link } from "react-router-dom";
-import { Workflow } from "lucide-react";
-import type { UserMenuItemsContext } from "@checkstack/frontend-api";
-import { DropdownMenuItem } from "@checkstack/ui";
-import { resolveRoute } from "@checkstack/common";
-import {
-  automationRoutes,
-  automationAccess,
-  pluginMetadata,
-} from "@checkstack/automation-common";
-
-/**
- * "Automations" entry in the user menu. Only renders for users with
- * `automation.read` access — mirrors `incident-frontend`'s pattern of
- * gating the menu item rather than the underlying route (the route is
- * also access-gated by `createFrontendPlugin`, but hiding the link is
- * the cleaner UX for unauthorised users).
- */
-export const AutomationMenuItems = ({
-  accessRules: userPerms,
-}: UserMenuItemsContext) => {
-  const qualifiedId = `${pluginMetadata.pluginId}.${automationAccess.read.id}`;
-  const canRead = userPerms.includes("*") || userPerms.includes(qualifiedId);
-
-  if (!canRead) {
-    return <React.Fragment />;
-  }
-
-  return (
-    <Link to={resolveRoute(automationRoutes.routes.list)}>
-      <DropdownMenuItem icon={<Workflow className="w-4 h-4" />}>
-        Automations
-      </DropdownMenuItem>
-    </Link>
-  );
-};