testeiya 0.2.0

package/src/testomatio-auth.ts

@@ -0,0 +1,299 @@
+// Testomat.io user-scope JWT bootstrap for the web/desktop app.
+//
+// Ported from the TUI's `src/testomatio-auth.ts` (testomatio/testeiya#11) but
+// trimmed to the pieces a UI flow needs — there are no terminal prompts here.
+// The HTTP layer in `api/testomatio-auth.ts` drives the actual login UI.
+//
+// Flow:
+//   1. The user opens `${baseUrl}/app-auth`, signs in, copies the
+//      pasted token, and submits it from the onboarding screen.
+//   2. We GET /api/projects with that JWT to enumerate accessible projects.
+//   3. The chosen project's per-project `api_key` (`tstmt_...`) is what MCP /
+//      check-tests already expect on the `TESTOMATIO` env var.
+//
+// The user JWT (`eyJ...`) is user-scoped and long-lived. We persist it to
+// `~/.testeiya/testomatio-auth.json` (mode 0600) — deliberately a SEPARATE file
+// from `~/.testeiya/auth.json`, which the SDK's `AuthStorage` owns for the LLM
+// provider key. Writing our own JSON into that file would corrupt it.
+
+import { rmSync } from "node:fs";
+import { HOME_DIR } from "./project-dir.js";
+import { readJson, writeJson } from "./json-store.js";
+import { join } from "node:path";
+
+const AUTH_FILE = join(HOME_DIR, "testomatio-auth.json");
+// Persistent precache of the (slow) project list — survives app restarts, so
+// opening a project never waits on a network round-trip. Holds full projects
+// incl. api_key, same trust level as the JWT in AUTH_FILE, so mode 0600.
+const PROJECTS_CACHE_FILE = join(HOME_DIR, "testomatio-projects.json");
+export const DEFAULT_BASE_URL = "https://app.testomat.io";
+
+export interface StoredAuth {
+  token: string;
+  baseUrl: string;
+  projectId?: string;
+}
+
+export interface Project {
+  id: string;
+  title: string;
+  apiKey: string;
+  framework?: string;
+  testsCount?: number;
+}
+
+export class UnauthorizedError extends Error {
+  constructor(message = "Testomat.io rejected the stored token.") {
+    super(message);
+    this.name = "UnauthorizedError";
+  }
+}
+
+/** Strip a trailing slash so `${baseUrl}/path` never doubles up. */
+export function normalizeBaseUrl(url?: string): string {
+  const raw = (url || process.env.TESTOMATIO_URL || DEFAULT_BASE_URL).trim();
+  return (raw || DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+
+/** Browser URL the user opens to mint a JWT for the app. */
+export function signInUrl(baseUrl: string): string {
+  return `${normalizeBaseUrl(baseUrl)}/app-auth?app_name=Testeiya`;
+}
+
+export function loadStoredAuth(): StoredAuth | null {
+  const raw = readJson<Partial<StoredAuth>>(AUTH_FILE, {});
+  if (typeof raw?.token !== "string" || !raw.token.trim()) return null;
+  return {
+    token: raw.token,
+    baseUrl: raw.baseUrl || DEFAULT_BASE_URL,
+    projectId: typeof raw.projectId === "string" ? raw.projectId : undefined,
+  };
+}
+
+export function saveStoredAuth(auth: StoredAuth): void {
+  // mode 0o600: same trust level as the JWT it stores.
+  writeJson(AUTH_FILE, auth, { mode: 0o600 });
+}
+
+export function clearStoredAuth(): void {
+  try {
+    rmSync(AUTH_FILE, { force: true });
+  } catch {
+    /* best-effort */
+  }
+  clearProjectsCache();
+}
+
+/** Network timeout for Testomat.io API calls, so a hung request surfaces as a
+ *  visible error instead of an infinite spinner. Generous because accounts with
+ *  hundreds of projects can take 10s+ to serialize. Must stay below the Bun
+ *  server's idleTimeout (see app-server.ts) so the handler can return a clean
+ *  error before the client socket is reset. */
+const FETCH_TIMEOUT_MS = 30_000;
+
+// Short-lived server-side cache of the (slow) project list, keyed by token+host.
+// The dialog status check, the connect call, and opening a project all need the
+// same list within seconds of each other — without this each one re-downloads
+// hundreds of projects (~10s every time). Kept brief so freshly-created or
+// renamed projects still show up on the next interaction.
+const PROJECTS_TTL_MS = 60_000;
+const projectsCache = new Map<string, { at: number; projects: Project[] }>();
+
+function projectsCacheKey(token: string, baseUrl: string): string {
+  return `${normalizeBaseUrl(baseUrl)}::${token}`;
+}
+
+function saveProjectsToDisk(token: string, baseUrl: string, projects: Project[]): void {
+  try {
+    // mode 0o600: holds full projects incl. api_key, same trust as the JWT.
+    writeJson(
+      PROJECTS_CACHE_FILE,
+      { key: projectsCacheKey(token, baseUrl), at: Date.now(), projects },
+      { mode: 0o600 }
+    );
+  } catch {
+    /* best-effort — cache is an optimization */
+  }
+}
+
+function loadProjectsFromDisk(
+  token: string,
+  baseUrl: string
+): { at: number; projects: Project[] } | null {
+  try {
+    const raw = readJson<{ key?: string; at?: number; projects?: Project[] }>(
+      PROJECTS_CACHE_FILE,
+      {}
+    );
+    if (raw.key !== projectsCacheKey(token, baseUrl)) return null;
+    if (!Array.isArray(raw.projects) || raw.projects.length === 0) return null;
+    return { at: typeof raw.at === "number" ? raw.at : 0, projects: raw.projects };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Return cached projects without ever hitting the network: fresh in-memory
+ * entry, else any disk cache (regardless of age). Returns null when nothing is
+ * cached. Callers that want freshness should pair this with a background
+ * `fetchProjects(token, baseUrl, { force: true })`.
+ */
+export function getCachedProjects(token: string, baseUrl: string): Project[] | null {
+  const mem = projectsCache.get(projectsCacheKey(token, baseUrl));
+  if (mem && Date.now() - mem.at < PROJECTS_TTL_MS) return mem.projects;
+  const disk = loadProjectsFromDisk(token, baseUrl);
+  if (disk) {
+    // Warm the in-memory cache from disk so repeat calls this session are instant.
+    projectsCache.set(projectsCacheKey(token, baseUrl), {
+      at: disk.at,
+      projects: disk.projects,
+    });
+    return disk.projects;
+  }
+  return null;
+}
+
+export interface FetchProjectsOptions {
+  /** Bypass the cache and always hit the network. */
+  force?: boolean;
+}
+
+export async function fetchProjects(
+  token: string,
+  baseUrl: string,
+  opts: FetchProjectsOptions = {}
+): Promise<Project[]> {
+  const url = `${normalizeBaseUrl(baseUrl)}/api/projects`;
+  const cacheKey = projectsCacheKey(token, baseUrl);
+
+  const cached = projectsCache.get(cacheKey);
+  if (!opts.force && cached && Date.now() - cached.at < PROJECTS_TTL_MS) {
+    console.log(
+      `[tio-auth] using cached project list (${cached.projects.length}, age ${
+        Date.now() - cached.at
+      }ms)`
+    );
+    return cached.projects;
+  }
+
+  console.log(`[tio-auth] GET ${url} (token ${maskToken(token)})`);
+
+  const startedAt = Date.now();
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+  } catch (err) {
+    const timedOut = err instanceof Error && err.name === "TimeoutError";
+    const reason = timedOut
+      ? `timed out after ${FETCH_TIMEOUT_MS}ms`
+      : err instanceof Error
+        ? err.message
+        : String(err);
+    console.error(`[tio-auth] GET ${url} failed: ${reason}`);
+    const hint = timedOut
+      ? ` Check that this machine can reach ${normalizeBaseUrl(baseUrl)} (VPN/DNS/firewall) and that TESTOMATIO_URL is correct.`
+      : "";
+    throw new Error(`Could not reach ${url} — ${reason}.${hint}`);
+  }
+  const ms = Date.now() - startedAt;
+  console.log(`[tio-auth] → HTTP ${res.status} ${res.statusText} (${ms}ms)`);
+
+  // Testomat.io returns 401 for missing tokens and 403 for rejected/expired
+  // tokens — treat both as "re-authorize".
+  if (res.status === 401 || res.status === 403) throw new UnauthorizedError();
+  if (!res.ok) {
+    throw new Error(`Failed to fetch projects: HTTP ${res.status} ${res.statusText}`);
+  }
+  const body = (await res.json()) as {
+    data?: Array<{ id?: string; attributes?: Record<string, unknown> }>;
+  };
+  const list = Array.isArray(body?.data) ? body.data : [];
+  const projects: Project[] = [];
+  let missingKey = 0;
+  for (const entry of list) {
+    const id = typeof entry?.id === "string" ? entry.id : null;
+    const attrs = entry?.attributes ?? {};
+    const title = typeof attrs.title === "string" ? attrs.title : id ?? "";
+    // Testomat.io's JSON:API serializes attributes in kebab-case (`api-key`);
+    // accept the snake_case form too for forward-compatibility.
+    const rawKey = attrs["api-key"] ?? attrs.api_key;
+    const apiKey = typeof rawKey === "string" ? rawKey : "";
+    const framework = typeof attrs.framework === "string" ? attrs.framework : undefined;
+    const rawCount = attrs["tests-count"] ?? attrs.tests_count;
+    const testsCount = typeof rawCount === "number" ? rawCount : undefined;
+    if (!id) continue;
+    if (!apiKey) {
+      missingKey++;
+      continue;
+    }
+    projects.push({ id, title, apiKey, framework, testsCount });
+  }
+  console.log(
+    `[tio-auth] parsed ${projects.length}/${list.length} project(s)` +
+      (missingKey ? ` (${missingKey} skipped — no api-key in response)` : "") +
+      `: ${projects.map((p) => p.id).join(", ") || "(none)"}`
+  );
+  projectsCache.set(cacheKey, { at: Date.now(), projects });
+  saveProjectsToDisk(token, baseUrl, projects);
+  return projects;
+}
+
+/** Drop the cached project list (e.g. on logout). */
+export function clearProjectsCache(): void {
+  projectsCache.clear();
+  try {
+    rmSync(PROJECTS_CACHE_FILE, { force: true });
+  } catch {
+    /* best-effort */
+  }
+}
+
+/** Render a token as `eyJ…abcd` for safe logging — never log the full JWT. */
+export function maskToken(token: string): string {
+  if (!token) return "(empty)";
+  if (token.length <= 12) return `${token.slice(0, 3)}…`;
+  return `${token.slice(0, 4)}…${token.slice(-4)}`;
+}
+
+// ── CLI (TUI) auth restore ───────────────────────────────────────────────────
+// Non-interactive: reuse the stored token + last selected project when they
+// resolve, else return null so the TUI starts unconnected and the in-session
+// `/connect` command takes over. Never prompts, never throws.
+
+export async function restoreTestomatioAuth(
+  opts: RestoreAuthOptions = {}
+): Promise<RestoredAuth | null> {
+  const stored = loadStoredAuth();
+  if (!stored?.projectId) return null;
+  if (opts.baseUrl && normalizeBaseUrl(opts.baseUrl) !== normalizeBaseUrl(stored.baseUrl)) {
+    return null;
+  }
+
+  let projects = getCachedProjects(stored.token, stored.baseUrl);
+  if (!projects) {
+    try {
+      projects = await fetchProjects(stored.token, stored.baseUrl);
+    } catch {
+      return null;
+    }
+  }
+
+  const project = projects.find((p) => p.id === stored.projectId);
+  if (!project) return null;
+  return { token: stored.token, baseUrl: stored.baseUrl, project, projects };
+}
+
+export interface RestoreAuthOptions {
+  baseUrl?: string;
+}
+
+export interface RestoredAuth {
+  token: string;
+  baseUrl: string;
+  project: Project;
+  projects: Project[];
+}

package/src/testomatio.ts

@@ -0,0 +1,98 @@
+// Testomat.io environment/config parsing for the TUI agent.
+// Loads `.env` (so TESTOMATIO* vars are available before the session starts),
+// exposes the parsed config, and reports whether the Testomat.io MCP is wired up.
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const ENV_FILES = [".env", ".env.local"];
+
+/**
+ * Load `.env` / `.env.local` from `cwd` into `process.env`.
+ * Must run BEFORE createTesteiyaSession (it reads the provider API key and
+ * the TESTOMATIO token from the environment). No-op if the file is missing.
+ */
+export function loadDotEnv(cwd = process.cwd()): void {
+  for (const file of ENV_FILES) {
+    const path = join(cwd, file);
+    if (!existsSync(path)) continue;
+    try {
+      // Node ≥ 20.12 / 22 built-in — no dotenv dependency needed.
+      process.loadEnvFile(path);
+    } catch {
+      // Older Node or a parse error — env may still be set another way; ignore.
+    }
+  }
+}
+
+export interface TestomatioConfig {
+  /** `TESTOMATIO` — the API key handed to bash/skills. */
+  token?: string;
+  /** `TESTOMATIO_URL` — backend URL override. */
+  url?: string;
+  /** `TESTOMATIO_PROJECT_ID` (or legacy `TESTOMATIO_PROJECT`). */
+  projectId?: string;
+  /** `TESTOMATIO_PROJECT_TOKEN` — per-project token used by the MCP server. */
+  projectToken?: string;
+  /** `TESTOMATIO_BASE_URL` — base URL passed to the MCP server. */
+  baseUrl?: string;
+}
+
+/** Parse all TESTOMATIO* vars out of the current environment. */
+export function getTestomatioConfig(): TestomatioConfig {
+  const e = process.env;
+  return {
+    token: e.TESTOMATIO,
+    url: e.TESTOMATIO_URL,
+    projectId: e.TESTOMATIO_PROJECT_ID ?? e.TESTOMATIO_PROJECT,
+    projectToken: e.TESTOMATIO_PROJECT_TOKEN,
+    baseUrl: e.TESTOMATIO_BASE_URL,
+  };
+}
+
+/** Whether a `TESTOMATIO` key is present. */
+export function hasTestomatioKey(cfg: TestomatioConfig = getTestomatioConfig()): boolean {
+  return Boolean(cfg.token && cfg.token.trim());
+}
+
+/** Mask a token for display: first 4 + last 4, never the middle. */
+export function maskToken(token?: string): string {
+  if (!token) return "";
+  return token.length <= 8 ? "****" : `${token.slice(0, 4)}…${token.slice(-4)}`;
+}
+
+interface McpLike {
+  getConnectionStatus?(name: string): string;
+  getTools?(): Array<{ name?: string; mcpServerName?: string }>;
+}
+
+/**
+ * True if the Testomat.io MCP server is connected (its tools are loaded).
+ * Checks loaded tools' `mcpServerName`/`name`, then known server names.
+ */
+export function isTestomatioMcpEnabled(mcp: McpLike | undefined): boolean {
+  if (!mcp) return false;
+  const re = /testomat/i;
+  const tools = mcp.getTools?.() ?? [];
+  if (tools.some(t => re.test(t?.mcpServerName ?? "") || re.test(t?.name ?? ""))) {
+    return true;
+  }
+  for (const name of ["testomat-mcp", "testomatio"]) {
+    if (mcp.getConnectionStatus?.(name) === "connected") return true;
+  }
+  return false;
+}
+
+/**
+ * One-line status summary for the startup banner, or null if no key is set.
+ * e.g. "within Testomat.io project 1a2b3c4d (token tstm…ab12) · MCP enabled"
+ */
+export function testomatioStatusLine(
+  mcp: McpLike | undefined,
+  cfg: TestomatioConfig = getTestomatioConfig(),
+): string | null {
+  if (!hasTestomatioKey(cfg)) return null;
+  const where = cfg.projectId ? ` ${cfg.projectId}` : "";
+  const mcpState = isTestomatioMcpEnabled(mcp) ? "MCP enabled" : "MCP not connected";
+  return `within Testomat.io project${where} (token ${maskToken(cfg.token)}) · ${mcpState}`;
+}

package/src/theme.ts

@@ -0,0 +1,30 @@
+// Testeiya branding: theme selection + input border styling.
+// Keeps all raw ANSI / color concerns out of main.ts.
+
+import { setTheme } from "@oh-my-pi/pi-coding-agent";
+import { theme as themeSingleton } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
+
+const TC_GREEN = "\x1b[38;2;0;168;73m"; // #00a849
+const TC_RESET = "\x1b[0m";
+
+/** Colorize a string in the Testeiya input-border green. */
+export const testeiyaBorder = (s: string): string => `${TC_GREEN}${s}${TC_RESET}`;
+
+interface ThemableInteractive {
+  editor: { setBorderVisible(v: boolean): void; borderColor: (s: string) => string };
+}
+
+/**
+ * Apply the Testeiya look: obsidian base theme + green input border that
+ * survives bash/python mode exits (the SDK restores the "off" thinking border).
+ */
+export function applyTesteiyaTheme(interactive: ThemableInteractive): void {
+  setTheme("obsidian"); // alternatives: "dark-sakura", "dark-tokyo-night"
+  interactive.editor.setBorderVisible(true);
+
+  const origThinkingBorder = themeSingleton.getThinkingBorderColor.bind(themeSingleton);
+  (themeSingleton as any).getThinkingBorderColor = (level: any) =>
+    level === "off" ? testeiyaBorder : origThinkingBorder(level);
+
+  interactive.editor.borderColor = testeiyaBorder;
+}

package/src/user-env.ts

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { HOME_DIR, PROJECT_DIR } from "./project-dir.js";
+import { parseEnv } from "./load-env.js";
+
+/**
+ * User-managed environment variables, edited as raw `KEY=value` text in the
+ * Settings UI. Two scopes:
+ *
+ * - **Global** — `~/.testeiya/.env`, shared by every workspace. The same file
+ *   `load-env.ts` loads at startup (so a provider key like OPENROUTER_API_KEY
+ *   resolves) and the one `shell-env.ts` overlays onto every agent bash
+ *   command. Saving applies the vars to the live process; the keys are also
+ *   tracked here so the shell overlay knows which vars to inject.
+ * - **Project** — `<cwd>/.testeiya/.env`, one per workspace. Never applied to
+ *   the server process (sessions with other workspaces must not see it);
+ *   `shell-env.ts` overlays it per session on top of the global vars, so a
+ *   project value wins over a global one with the same name. The `.testeiya`
+ *   dir is self-gitignored so the secrets stay out of the repo.
+ */
+
+const ENV_PATH = join(HOME_DIR, ".env");
+
+// Always surfaced as empty slots in the textarea so the user has a place to
+// paste the common LLM provider keys, even when the file holds other vars.
+const DEFAULT_KEYS = ["OPENAI_API_KEY", "OPENROUTER_API_KEY"];
+
+let cachedKeys: string[] | null = null;
+
+export function readUserEnvText(): string {
+  const raw = readEnvFile();
+  const base = (raw?.trim() ? raw : "").replace(/\n+$/, "");
+  const present = new Set(Object.keys(parseEnv(base)));
+  const missing = DEFAULT_KEYS.filter((key) => !present.has(key)).map(
+    (key) => `${key}=`,
+  );
+  const lines = base ? [base, ...missing] : missing;
+  return `${lines.join("\n")}\n`;
+}
+
+export function saveUserEnvText(text: string): string[] {
+  const previous = parseEnv(readEnvFile() ?? "");
+  const next = parseEnv(text);
+  const normalized = text.endsWith("\n") ? text : `${text}\n`;
+  mkdirSync(HOME_DIR, { recursive: true });
+  writeFileSync(ENV_PATH, normalized, { mode: 0o600 });
+  for (const key of Object.keys(previous)) {
+    if (!(key in next)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(next)) {
+    if (value) process.env[key] = value;
+    else delete process.env[key];
+  }
+  cachedKeys = Object.keys(next);
+  return cachedKeys;
+}
+
+export function userEnvKeys(): string[] {
+  if (cachedKeys) return cachedKeys;
+  cachedKeys = Object.keys(parseEnv(readEnvFile() ?? ""));
+  return cachedKeys;
+}
+
+export function readProjectEnvText(cwd: string): string {
+  const raw = readEnvFile(projectEnvPath(cwd));
+  if (!raw?.trim()) return "";
+  return raw.endsWith("\n") ? raw : `${raw}\n`;
+}
+
+export function saveProjectEnvText(cwd: string, text: string): void {
+  const dir = join(cwd, PROJECT_DIR);
+  mkdirSync(dir, { recursive: true });
+  const gitignore = join(dir, ".gitignore");
+  if (!existsSync(gitignore)) writeFileSync(gitignore, "*\n", "utf8");
+  const normalized = text.endsWith("\n") ? text : `${text}\n`;
+  writeFileSync(projectEnvPath(cwd), normalized, { mode: 0o600 });
+}
+
+export function projectEnvVars(cwd: string): Record<string, string> {
+  return parseEnv(readEnvFile(projectEnvPath(cwd)) ?? "");
+}
+
+function projectEnvPath(cwd: string): string {
+  return join(cwd, PROJECT_DIR, ".env");
+}
+
+function readEnvFile(path = ENV_PATH): string | null {
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}

package/src/welcome.ts

@@ -0,0 +1,127 @@
+import { type Component, padding, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+
+const BRIGHT = "\x1b[38;2;77;255;79m"; // #4dff4f
+const SHADOW = "\x1b[38;2;0;70;28m"; // #00461c — deep forest green
+const PALE = "\x1b[38;2;168;255;233m"; // #a8ffe9
+
+// Top-to-bottom gradient: brightest at the first row, darkening downward.
+const GRAD_TOP = [120, 255, 130]; // light spring green
+const GRAD_BOT = [16, 110, 44]; // deep forest green
+
+function gradientFg(row: number, rows: number): string {
+  const t = rows <= 1 ? 0 : row / (rows - 1);
+  const r = Math.round(GRAD_TOP[0] + (GRAD_BOT[0] - GRAD_TOP[0]) * t);
+  const g = Math.round(GRAD_TOP[1] + (GRAD_BOT[1] - GRAD_TOP[1]) * t);
+  const b = Math.round(GRAD_TOP[2] + (GRAD_BOT[2] - GRAD_TOP[2]) * t);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+const DIM = "\x1b[38;2;107;114;128m";
+const RESET = "\x1b[0m";
+
+// 5-line block-letter "TESTEIYA".
+const WORDMARK_LINES = [
+  "████████ ███████ ███████ ████████ ███████ ██████ ██    ██  █████",
+  "   ██    ██      ██         ██    ██        ██    ██  ██  ██   ██",
+  "   ██    █████   ███████    ██    █████     ██     ████   ███████",
+  "   ██    ██           ██    ██    ██        ██       ██    ██   ██",
+  "   ██    ███████ ███████    ██    ███████ ██████    ██    ██   ██",
+];
+
+const SHADOW_DX = 1;
+const SHADOW_DY = 1;
+const FG_BLOCK = "█";
+const SH_BLOCK = "█";
+
+// Programmatic drop shadow: clones the wordmark offset (dx, dy) in dark green,
+// foreground bright green on top. Returns rendered ANSI lines + visible width.
+function buildShadowedWordmark(): { lines: string[]; width: number } {
+  const srcW = WORDMARK_LINES.reduce((m, l) => Math.max(m, l.length), 0);
+  const padded = WORDMARK_LINES.map(l => l.padEnd(srcW, " "));
+  const totalRows = padded.length + SHADOW_DY;
+  const totalCols = srcW + SHADOW_DX;
+
+  const lines: string[] = [];
+  for (let r = 0; r < totalRows; r++) {
+    let out = "";
+    for (let c = 0; c < totalCols; c++) {
+      const fg = padded[r]?.[c] ?? " ";
+      const sr = r - SHADOW_DY;
+      const sc = c - SHADOW_DX;
+      const sh = sr >= 0 && sc >= 0 ? (padded[sr]?.[sc] ?? " ") : " ";
+      if (fg === FG_BLOCK) out += `${gradientFg(r, padded.length)}${FG_BLOCK}${RESET}`;
+      else if (sh === FG_BLOCK) out += `${SHADOW}${SH_BLOCK}${RESET}`;
+      else out += " ";
+    }
+    lines.push(out);
+  }
+  return { lines, width: totalCols };
+}
+
+const SHADOWED = buildShadowedWordmark();
+const WORDMARK_WIDTH = SHADOWED.width;
+
+const COMPACT_MARK = "▰ TESTEIYA ▰";
+
+export class TesteiyaWelcome implements Component {
+  constructor(
+    private readonly version: string,
+    private modelName: string,
+    private providerName: string,
+    private skills: string[] = [],
+  ) {}
+
+  invalidate(): void {}
+
+  setModel(modelName: string, providerName: string): void {
+    this.modelName = modelName;
+    this.providerName = providerName;
+  }
+
+  setLspServers(_servers: unknown[]): void {}
+
+  render(termWidth: number): string[] {
+    const width = Math.min(80, termWidth);
+    if (width < 20) return [];
+
+    const lines: string[] = [""];
+
+    if (width >= WORDMARK_WIDTH + 2) {
+      const leftPad = padding(Math.floor((width - WORDMARK_WIDTH) / 2));
+      for (const row of SHADOWED.lines) {
+        lines.push(this.#fit(`${leftPad}${row}`, width));
+      }
+    } else {
+      lines.push(this.#center(`${BRIGHT}${COMPACT_MARK}${RESET}`, width));
+    }
+
+    lines.push("");
+    lines.push(this.#center(`${PALE}AI Testing Agent${RESET} ${DIM}·${RESET} ${PALE}Testomat.io${RESET}`, width));
+    lines.push("");
+
+    lines.push(this.#center(`${DIM}${this.modelName} via ${this.providerName}${RESET}`, width));
+
+    if (this.skills.length > 0) {
+      const skillList = this.skills.slice(0, 6).join(`${DIM} · ${RESET}`);
+      lines.push(this.#center(`${DIM}skills:${RESET} ${skillList}`, width));
+    }
+
+    lines.push("");
+    lines.push(this.#center(`${DIM}/model switch · /project switch · /skills list · /help${RESET}`, width));
+    lines.push("");
+
+    return lines;
+  }
+
+  #fit(str: string, width: number): string {
+    const w = visibleWidth(str);
+    if (w > width) return truncateToWidth(str, width);
+    return str + padding(width - w);
+  }
+
+  #center(str: string, width: number): string {
+    const w = visibleWidth(str);
+    if (w >= width) return truncateToWidth(str, width);
+    const left = Math.floor((width - w) / 2);
+    return padding(left) + str + padding(width - w - left);
+  }
+}