@elliotsystems/eai 0.1.1 → 0.1.3

package/plugin/opencode-plugin/src/policy.ts

@@ -0,0 +1,122 @@
+/**
+ * C2-minimal policy: validate the plugin's own options, and identify which
+ * agent-visible tool keys are Elliot knowledge tools.
+ *
+ * Deliberately small. The full bash-policy port (command classification,
+ * hard-deny set) is a later phase — nothing in C2 executes shell commands, and
+ * carrying unused policy code would be scope creep wearing a safety costume.
+ *
+ * `PluginOptions` is untyped upstream (`Record<string, unknown>`), so a typo'd
+ * option would otherwise vanish silently; zod turns that into a load-time
+ * message instead.
+ */
+import { z } from "zod"
+
+import {
+  type Category,
+  classifyCommand,
+  isHardDenied,
+  killsAgentRuntime,
+  looksLikeCredentialExfiltration,
+} from "./classifier.js"
+import { KNOWLEDGE_TOOL, knowledgeToolKey, sanitizeKey } from "./mcp-keys.js"
+
+const OptionsSchema = z
+  .object({
+    /**
+     * MCP server name(s) this plugin should treat as Elliot. Must match the
+     * key(s) under `mcp` in opencode.json. OpenCode composes agent-visible MCP
+     * tool keys as `<client>_<tool>` (mcp/catalog.ts:119), so these names are
+     * what let the hooks recognise Elliot tools.
+     */
+    serverNames: z.array(z.string().min(1)).min(1).default(["elliot"]),
+  })
+  .strict()
+
+export type ElliotPluginOptions = z.infer<typeof OptionsSchema>
+
+/**
+ * Parse options, throwing a load-time error on unknown/invalid keys. A plugin
+ * that starts with wrong options and limps is worse than one that says why it
+ * refused to.
+ */
+export function parseOptions(raw: unknown): ElliotPluginOptions {
+  return OptionsSchema.parse(raw ?? {})
+}
+
+/**
+ * Re-exported so existing importers (and the test suite) keep one entry point
+ * for the key rule, which now lives in `mcp-keys.ts` — see that module for why
+ * it had to become import-free.
+ */
+export { KNOWLEDGE_TOOL, sanitizeKey }
+
+/**
+ * Is this agent-visible tool key Elliot's knowledge tool on one of our
+ * configured servers? Exact composed-key match only — a suffix match would let
+ * an unrelated MCP server named e.g. "not-elliot" receive our scope hints.
+ */
+export function isElliotKnowledgeTool(toolKey: string, options: ElliotPluginOptions): boolean {
+  return options.serverNames.some((server) => toolKey === knowledgeToolKey(server))
+}
+
+// -- Shell policy verdicts ---------------------------------------------------
+
+/**
+ * What the plugin does to a shell permission decision, and — just as importantly —
+ * what it refuses to do.
+ *
+ * `undefined` means "leave the host's decision untouched". That is the default for
+ * anything read-shaped, and it matters: the org's glob policy already decided those,
+ * and a plugin that *widened* a permission it did not grant would be a privilege
+ * escalation wearing a helpful face. This function can therefore only ever tighten.
+ */
+export function shellVerdict(
+  command: string,
+): { status: "deny" | "ask"; category: Category; reason: string } | undefined {
+  if (!command.trim()) {
+    // Nothing to inspect: say nothing rather than guess. The host's own policy
+    // (`bash *: ask` in the org default) remains in force.
+    return undefined
+  }
+
+  if (isHardDenied(command)) {
+    return {
+      status: "deny",
+      category: "DESTRUCTIVE",
+      reason:
+        "catastrophic command shape (org hard-deny list) — refused outright; " +
+        "confirmation adds no safety against a runaway loop",
+    }
+  }
+
+  if (killsAgentRuntime(command)) {
+    return {
+      status: "deny",
+      category: "DESTRUCTIVE",
+      reason:
+        "kills processes by name matching Elliot's own runtime (node/bun/opencode), " +
+        "which terminates this session mid-command and leaves the terminal in " +
+        "mouse-reporting mode — target a specific PID instead (Stop-Process -Id, " +
+        "taskkill /PID), or kill the service by its own process name",
+    }
+  }
+
+  if (looksLikeCredentialExfiltration(command)) {
+    return {
+      status: "deny",
+      category: "DESTRUCTIVE",
+      reason:
+        "names a secret-shaped path AND invokes a network tool — refused as possible " +
+        "credential exfiltration",
+    }
+  }
+
+  const category = classifyCommand(command)
+  if (category === "DESTRUCTIVE" || category === "MUTATION" || category === "UNKNOWN") {
+    return { status: "ask", category, reason: `classified ${category} — needs confirmation` }
+  }
+
+  // READ / TEST / BUILD: the org globs already allow these. Stay out of the way.
+  return undefined
+}

package/plugin/opencode-plugin/src/proxy-provider.ts

@@ -0,0 +1,96 @@
+/**
+ * The Elliot proxy provider: a `config` hook that registers a custom
+ * `elliot` OpenCode provider pointed at the Elliot LightLLM proxy, and an
+ * `auth` hook whose `loader` returns a self-refreshing `fetch` that attaches
+ * a live bearer token per request.
+ *
+ * Mechanism pinned in `.superpowers/sdd/2026-09-03-eai-proxy-auth/task-1-findings.md`:
+ *   - `config` hook mutates its input in place (no separate output param).
+ *   - `auth.loader`'s return value is spread wholesale into the provider's
+ *     resolved `options`, so `{ apiKey, fetch }` land there directly.
+ *   - `apiKey` is baked into the AI-SDK client at construction time and
+ *     never changes; the actually-rotating credential is injected per
+ *     request by `options.fetch`'s `Authorization` header (never the static
+ *     `apiKey`) — same pattern as OpenCode's bundled snowflake-cortex plugin.
+ *   - The loader only runs once a stored auth entry exists for its
+ *     `provider` id (`provider.ts:1584`); the plugin seeds that entry itself
+ *     at init (see `index.ts`) so no interactive `opencode auth login` step
+ *     is ever required.
+ *
+ * Everything here is a no-op when the user isn't logged in
+ * (`readElliotConfig()` returns null) — OpenCode then runs exactly as it
+ * would without this plugin.
+ */
+import { freshToken, readElliotConfig } from "./elliot-auth.js"
+
+export const ELLIOT_LLM_PROXY_URL = "https://backend.elliotsystemsonline.com/llm-proxy"
+export const ELLIOT_PROVIDER_ID = "elliot"
+
+/**
+ * Registers the `elliot` provider (baseURL = the LightLLM proxy) and
+ * defaults `cfg.model` to it, mutating `cfg` in place. No-op when the user
+ * isn't logged in. Never overwrites a model the user already configured, or
+ * any other existing key under `cfg.provider`/`cfg.plugin`/`cfg.mcp`/etc.
+ */
+export function configHook(cfg: any): void {
+  if (!readElliotConfig()) return
+
+  cfg.provider ??= {}
+  cfg.provider[ELLIOT_PROVIDER_ID] = {
+    npm: "@ai-sdk/anthropic",
+    name: "Elliot (governed)",
+    options: { baseURL: ELLIOT_LLM_PROXY_URL },
+    models: { "elliot-governed": { name: "Elliot (governed)" } },
+  }
+
+  cfg.model ??= "elliot/elliot-governed"
+}
+
+/**
+ * Merge `Authorization: Bearer <token>` into whatever headers `init` already
+ * carries, without dropping them. Works whether `init.headers` is a plain
+ * object, a `Headers` instance, or an array of pairs.
+ */
+function withAuthHeader(init: RequestInit | undefined, token: string): RequestInit {
+  const headers = new Headers(init?.headers)
+  headers.set("Authorization", `Bearer ${token}`)
+  return { ...init, headers }
+}
+
+/**
+ * The per-request fetch wrapper: reads `~/.elliot/config.json` fresh on
+ * every call (so a refresh picked up by another process is honored
+ * immediately), refreshes via `freshToken` when needed, and attaches the
+ * bearer token. Never throws — a missing/expired/unrefreshable token just
+ * means the request goes out unauthenticated and the proxy 401s.
+ */
+async function elliotFetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {
+  try {
+    const cfg = readElliotConfig()
+    const token = cfg ? await freshToken(cfg) : null
+    if (token) {
+      return globalThis.fetch(input, withAuthHeader(init, token))
+    }
+    return globalThis.fetch(input, init)
+  } catch {
+    return globalThis.fetch(input, init)
+  }
+}
+
+/**
+ * Builds the `auth` hook object per the Task-1 pinned `AuthHook` shape.
+ * `methods` is empty — this provider is never set up via interactive
+ * `opencode auth login`; the plugin seeds the stored auth entry itself
+ * (see `index.ts`) so the loader always fires once the user is logged into
+ * Elliot.
+ */
+export function makeAuthHook() {
+  return {
+    provider: ELLIOT_PROVIDER_ID,
+    methods: [] as unknown[],
+    loader: async (_auth: () => Promise<unknown>, _provider: unknown) => ({
+      apiKey: "elliot-managed",
+      fetch: elliotFetch,
+    }),
+  }
+}

package/plugin/opencode-plugin/src/scope.ts

@@ -0,0 +1,78 @@
+/**
+ * Repository scope from the session worktree — the trusted-context half of the
+ * "the model never names a repository" invariant.
+ *
+ * Ported (trimmed, not imported) from `elliot-cli/src/project.ts`: the same
+ * `execFile` discipline — a fixed, hardcoded argument array, never a string a
+ * shell would parse, and never anything the LLM supplies. The worktree path
+ * comes from OpenCode's own `PluginInput`/`ToolContext`, which is session
+ * truth, not model output.
+ *
+ * Authorization is NOT here and never will be: the derived `owner/name` is a
+ * hint the Elliot backend authorizes via `resolve_repo_scope`. A wrong value
+ * can therefore select nothing the tenant was not already granted — which is
+ * why every failure path below degrades to `null` (tenant-wide search) rather
+ * than throwing. Scope is an optimization, never a gate.
+ */
+import { execFile } from "node:child_process"
+
+export interface RepoScope {
+  owner: string
+  name: string
+}
+
+/**
+ * Handles SSH (git@host:owner/repo.git) and HTTPS (https://host/owner/repo.git)
+ * remote forms generically — not GitHub-specific. Same regex the CLI used.
+ */
+export function parseOwnerRepo(remoteUrl: string | null | undefined): RepoScope | null {
+  if (!remoteUrl) return null
+  const match = remoteUrl.match(/[:/]([^/:]+)\/([^/]+?)(?:\.git)?$/)
+  if (!match) return null
+  return { owner: match[1], name: match[2] }
+}
+
+/** `owner/name`, the wire form `repo_scope_hint` carries. */
+export function formatScope(scope: RepoScope): string {
+  return `${scope.owner}/${scope.name}`
+}
+
+function gitRemoteUrl(worktree: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      ["remote", "get-url", "origin"],
+      { cwd: worktree, timeout: 5_000, windowsHide: true },
+      (err, stdout) => {
+        // Any failure — not a repo, no origin, git absent, timeout — is a
+        // normal discovery miss, never an error to surface.
+        if (err) return resolve(null)
+        const url = stdout.trim()
+        resolve(url.length ? url : null)
+      },
+    )
+  })
+}
+
+/**
+ * Derive `owner/name` for a worktree, or null when it cannot be known.
+ *
+ * Cached per worktree path for the plugin's lifetime: the remote of an open
+ * session's repository does not meaningfully change mid-session, and the CLI's
+ * rule ("detected once, never re-run per tool call") carries over.
+ */
+const cache = new Map<string, Promise<RepoScope | null>>()
+
+export function scopeForWorktree(worktree: string | null | undefined): Promise<RepoScope | null> {
+  if (!worktree) return Promise.resolve(null)
+  const hit = cache.get(worktree)
+  if (hit) return hit
+  const pending = gitRemoteUrl(worktree).then(parseOwnerRepo)
+  cache.set(worktree, pending)
+  return pending
+}
+
+/** Test-only: clear the per-worktree cache. */
+export function resetScopeCache(): void {
+  cache.clear()
+}

package/plugin/opencode-plugin/src/tui/api.ts

@@ -0,0 +1,117 @@
+/**
+ * Structural mirror of the slice of `TuiPluginApi` this chrome uses.
+ *
+ * `@opencode-ai/plugin/tui` is deliberately absent from the module list the host
+ * shares with runtime-loaded plugins (see `host.d.ts`), so its types cannot be
+ * imported. The host validates plugins by SHAPE, not by nominal type, which is
+ * what makes a local mirror correct rather than a workaround.
+ *
+ * Only the members the chrome actually reads appear here. A mirror that copied
+ * the whole surface would be a second copy of upstream's API to keep in sync,
+ * and every unused member in it is a silent drift risk.
+ */
+import type { RGBA } from "@opentui/core"
+
+/** Theme roles this chrome paints with. Names match upstream's exactly. */
+export interface ThemeCurrent {
+  readonly primary: RGBA
+  readonly text: RGBA
+  readonly textMuted: RGBA
+  readonly background: RGBA
+  readonly backgroundPanel: RGBA
+  readonly border: RGBA
+  readonly success: RGBA
+  readonly warning: RGBA
+  readonly error: RGBA
+}
+
+/** `TuiSidebarFileItem`. */
+export interface FileItem {
+  readonly file: string
+  readonly additions: number
+  readonly deletions: number
+}
+
+/** `TuiSidebarMcpItem`. */
+export interface McpStatusItem {
+  readonly name: string
+  readonly status: string
+  readonly error?: string
+}
+
+/** A `Message`, narrowed to the id needed to fetch its parts. */
+export interface MessageLike {
+  readonly id: string
+}
+
+/** A `Part`, narrowed to what a knowledge citation needs. */
+export interface PartLike {
+  readonly type: string
+  readonly tool?: string
+  readonly state?: {
+    readonly status?: string
+    readonly output?: string
+  }
+}
+
+/** `TuiState` — the read-only session view the chrome derives everything from. */
+export interface StateApi {
+  readonly ready: boolean
+  readonly path: {
+    readonly worktree: string
+    readonly directory: string
+  }
+  readonly vcs: { readonly branch?: string; readonly default_branch?: string } | undefined
+  readonly session: {
+    count: () => number
+    diff: (sessionID: string) => ReadonlyArray<FileItem>
+    messages: (sessionID: string) => ReadonlyArray<MessageLike>
+  }
+  part: (messageID: string) => ReadonlyArray<PartLike>
+  mcp: () => ReadonlyArray<McpStatusItem>
+}
+
+/** `TuiPromptProps` — the host's prompt component, reused rather than rebuilt. */
+export interface PromptProps {
+  sessionID?: string
+  visible?: boolean
+  disabled?: boolean
+  onSubmit?: () => void
+  ref?: (ref: unknown) => void
+  hint?: unknown
+  right?: unknown
+  showPlaceholder?: boolean
+  placeholders?: { normal?: string[]; shell?: string[] }
+}
+
+export interface TuiPluginApi {
+  readonly app: { readonly version: string }
+  readonly theme: {
+    readonly current: ThemeCurrent
+    /**
+     * Copies a theme file from the plugin root into a directory the host's
+     * theme discovery scans. Resolved relative to the plugin root by
+     * `createThemeInstaller` (packages/opencode/src/plugin/tui/runtime.ts:245).
+     */
+    install: (jsonPath: string) => Promise<void>
+    has: (name: string) => boolean
+  }
+  readonly state: StateApi
+  readonly ui: {
+    Prompt: (props: PromptProps) => unknown
+  }
+  readonly slots: {
+    register(input: { order?: number; slots: Record<string, unknown> }): unknown
+  }
+}
+
+export type TuiPlugin = (api: TuiPluginApi) => Promise<void>
+
+/** Props the host passes to the session-scoped slots. */
+export interface SessionSlotProps {
+  readonly session_id: string
+  readonly visible?: boolean
+  readonly disabled?: boolean
+  readonly on_submit?: () => void
+  readonly ref?: (ref: unknown) => void
+}

package/plugin/opencode-plugin/src/tui/format.ts

@@ -0,0 +1,73 @@
+/**
+ * Display formatting for the Elliot TUI chrome. Pure functions only, so the
+ * decisions that are easy to get subtly wrong — where a path gets cut, what a
+ * missing branch renders as — are unit-testable without a terminal.
+ */
+
+/** Separator-agnostic: the worktree arrives with `\` on Windows, `/` elsewhere. */
+const SEPARATOR = /[\\/]+/g
+
+/**
+ * A path short enough to sit on one line of chrome, without lying about it.
+ *
+ * Truncation happens on the LEFT and is marked with `…/`, because the
+ * informative end of a project path is its tail. A `home` prefix collapses to
+ * `~` first — that is both shorter and the form a developer recognises.
+ *
+ * Returns forward slashes on every platform: this string is chrome, not a path
+ * to hand back to the filesystem, and mixed separators in one line of UI read
+ * as a bug.
+ */
+export function shortenPath(directory: string, home?: string, maxSegments = 3): string {
+  if (!directory) return ""
+
+  const normalized = directory.replace(SEPARATOR, "/").replace(/\/+$/, "")
+  const collapsed = collapseHome(normalized, home)
+  if (collapsed !== normalized) return collapsed
+
+  const segments = normalized.split("/").filter(Boolean)
+  if (segments.length <= maxSegments) return normalized
+  return `…/${segments.slice(-maxSegments).join("/")}`
+}
+
+/**
+ * Replace a `home` prefix with `~`, matching whole segments only.
+ *
+ * The segment check is the point: a plain `startsWith` would turn
+ * `C:/Users/ganesh-old/repo` into `~-old/repo` when home is `C:/Users/ganesh`.
+ * Comparison is case-insensitive because Windows paths are.
+ */
+function collapseHome(normalized: string, home?: string): string {
+  if (!home) return normalized
+  const prefix = home.replace(SEPARATOR, "/").replace(/\/+$/, "")
+  if (!prefix) return normalized
+  if (normalized.toLowerCase() === prefix.toLowerCase()) return "~"
+  if (!normalized.toLowerCase().startsWith(`${prefix.toLowerCase()}/`)) return normalized
+  return `~${normalized.slice(prefix.length)}`
+}
+
+/**
+ * The home directory, or `undefined` where the runtime does not expose one.
+ *
+ * `process` is reached through `globalThis` rather than imported: this module is
+ * loaded into the TUI plugin runtime, whose shared module list does not include
+ * `node:process`, and an absent global must degrade to a full path rather than
+ * throwing during slot render.
+ */
+export function homeDirectory(): string | undefined {
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env
+  return env?.HOME || env?.USERPROFILE || undefined
+}
+
+/** `+12 −3`, with either side omitted when it is zero. Empty when both are. */
+export function formatDiffStat(additions: number, deletions: number): string {
+  const parts: string[] = []
+  if (additions > 0) parts.push(`+${additions}`)
+  if (deletions > 0) parts.push(`−${deletions}`)
+  return parts.join(" ")
+}
+
+/** `n thing` / `n things` — an English plural, not `n thing(s)`. */
+export function pluralize(count: number, singular: string, plural = `${singular}s`): string {
+  return `${count} ${count === 1 ? singular : plural}`
+}

package/plugin/opencode-plugin/src/tui/home.tsx

@@ -0,0 +1,88 @@
+/**
+ * The welcome screen's copy, filling `home_bottom`.
+ *
+ * Three deliberate reductions from what shipped before. The four-key hint row is
+ * gone: the same keys are named in the tips, and printing them twice is the kind
+ * of chrome this redesign exists to remove. The context line is new, and is the
+ * one thing a terminal welcome genuinely owes the reader — where am I, on what
+ * branch. And the tips are numbered rather than bulleted, which is what makes a
+ * short list read as "here are three things" instead of as decoration.
+ *
+ * `tui.json` disables `internal:home-tips`; without that, upstream's tips
+ * carousel stacks under this block and the screen carries two tip lists.
+ */
+import { For, Show } from "solid-js"
+
+import type { TuiPluginApi } from "./api.js"
+import { homeDirectory, shortenPath } from "./format.js"
+
+const TAGLINE = "the engineering terminal"
+
+/**
+ * Three tips, in the order a new user needs them.
+ *
+ * The first names Elliot's actual differentiator rather than a generic prompt
+ * idea. The second says `/init` and `AGENTS.md` — AGENTS.md is the file OpenCode
+ * really reads (`session/instruction.ts`); the original design's "AGENT.md" was
+ * a bug wearing a designer's clothes. The third collapses the old hint row.
+ */
+const TIPS: ReadonlyArray<readonly [string, string]> = [
+  ["Ask about this repo", "Elliot searches your organisation's indexed sources"],
+  ["Run /init", "generates an AGENTS.md so every session starts informed"],
+  ["Press / or @", "commands and file context; tab switches agents"],
+]
+
+/** `~/Documents/Elliot-AI · feat/tui-elliot-redesign` */
+function ContextLine(props: { api: TuiPluginApi }) {
+  const theme = props.api.theme.current
+  const state = props.api.state
+  const directory = () => shortenPath(state.path.directory || state.path.worktree, homeDirectory())
+  const branch = () => state.vcs?.branch
+
+  return (
+    <box flexDirection="row" gap={1}>
+      <text fg={theme.textMuted} selectable={false}>
+        {directory()}
+      </text>
+      <Show when={branch()}>
+        <text fg={theme.border} selectable={false}>
+          ·
+        </text>
+        <text fg={theme.textMuted} selectable={false}>
+          {branch()}
+        </text>
+      </Show>
+    </box>
+  )
+}
+
+export function HomeBottom(props: { api: TuiPluginApi }) {
+  const theme = props.api.theme.current
+  return (
+    <box paddingTop={1} gap={1}>
+      <text fg={theme.textMuted} selectable={false}>
+        {TAGLINE}
+      </text>
+
+      <ContextLine api={props.api} />
+
+      <box>
+        <For each={TIPS}>
+          {(tip, index) => (
+            <box flexDirection="row" gap={1}>
+              <text fg={theme.border} selectable={false}>
+                {`${index() + 1}.`}
+              </text>
+              <text fg={theme.text} selectable={false}>
+                {tip[0]}
+              </text>
+              <text fg={theme.textMuted} selectable={false}>
+                {`— ${tip[1]}`}
+              </text>
+            </box>
+          )}
+        </For>
+      </box>
+    </box>
+  )
+}

package/plugin/opencode-plugin/src/tui/host.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Ambient declarations for the host modules this TUI plugin imports at runtime.
+ *
+ * `solid-js`, `solid-js/store`, `@opentui/core` and `@opentui/solid/jsx-runtime`
+ * are provided to runtime-loaded plugins by the host — verified in
+ * `@opentui/solid/scripts/runtime-plugin-support-configure.js`, whose shared
+ * specifier list is exactly:
+ *   @opentui/core, @opentui/core/runtime-plugin, @opentui/solid,
+ *   @opentui/solid/components, @opentui/solid/jsx-runtime,
+ *   @opentui/solid/jsx-dev-runtime, solid-js, solid-js/store, bun
+ *
+ * They are therefore not RUNTIME dependencies of this package: they are declared
+ * as peers, and installed here only so the package type-checks and tests on its
+ * own. Declaring the handful of members we use keeps `tsc` meaningful without
+ * pulling the whole opencode workspace onto the module path — the same approach
+ * `src/index.ts` already takes for the server plugin's host types.
+ *
+ * Note `@opencode-ai/plugin/tui` is deliberately absent from the shared list, so
+ * the plugin's own API types are mirrored structurally in `index.tsx` rather than
+ * imported. The host validates plugins by shape, not by nominal type.
+ */
+
+declare module "solid-js" {
+  export function For<T>(props: {
+    each: readonly T[] | undefined
+    children: (item: T, index: () => number) => unknown
+  }): unknown
+
+  /**
+   * Solid's conditional. `when` is truthiness-tested, and `children` may be an
+   * element or a function of the narrowed value — only the element form is
+   * declared, because that is the only form this chrome uses.
+   */
+  export function Show<T>(props: {
+    when: T | undefined | null | false
+    fallback?: unknown
+    children?: unknown
+  }): unknown
+}
+
+declare module "@opentui/core" {
+  /**
+   * Mostly opaque: produced by the host theme and handed straight back. Not
+   * FULLY opaque, though, and the difference matters -- `wordmark.tsx` has to
+   * construct one. A plain object of the same shape is rejected at opentui's FFI
+   * boundary ("Expected ArrayBufferView but received Cell"), so the constructor
+   * is declared here and the real class must be used.
+   */
+  export class RGBA {
+    readonly r: number
+    readonly g: number
+    readonly b: number
+    readonly a: number
+    static fromValues(r: number, g: number, b: number, a?: number): RGBA
+  }
+  export const TextAttributes: { readonly BOLD: number }
+}
+
+declare namespace JSX {
+  type Element = unknown
+
+  interface BoxProps {
+    flexDirection?: "row" | "column"
+    flexGrow?: number
+    flexShrink?: number
+    alignItems?: "center" | "flex-start" | "flex-end" | "stretch" | "baseline"
+    justifyContent?: "center" | "flex-start" | "flex-end" | "space-between"
+    gap?: number
+    width?: number | string
+    maxWidth?: number
+    height?: number
+    minHeight?: number
+    paddingTop?: number
+    paddingLeft?: number
+    paddingRight?: number
+    children?: unknown
+  }
+
+  interface TextProps {
+    fg?: unknown
+    bg?: unknown
+    attributes?: number
+    selectable?: boolean
+    children?: unknown
+  }
+
+  interface IntrinsicElements {
+    box: BoxProps
+    text: TextProps
+  }
+
+  interface ElementChildrenAttribute {
+    children: {}
+  }
+}