testeiya 0.2.0 → 0.3.9

package/src/testomatio-auth.ts

@@ -1,299 +0,0 @@
-// 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

@@ -1,98 +0,0 @@
-// 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

@@ -1,30 +0,0 @@
-// 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

@@ -1,94 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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);
-  }
-}