testeiya 0.2.0 → 0.3.1-0.1

package/src/telemetry.ts

@@ -1,239 +0,0 @@
-// OpenTelemetry → Langfuse observability for the agent.
-//
-// Two parts:
-//   1. initTelemetry() — one-time NodeSDK + LangfuseSpanProcessor bootstrap,
-//      gated on LANGFUSE_PUBLIC_KEY + LANGFUSE_SECRET_KEY. A no-op (and no
-//      dependency cost at runtime) when the keys are absent. Called from
-//      app-server.ts right after the .env files are loaded.
-//   2. createTelemetryExtension() — a per-session extension that turns the
-//      agent's hook events into a Langfuse trace tree:
-//        before_agent_start → root (agent) observation = one trace per prompt
-//          message_start/_end → child generation (LLM call) with usage + cost
-//          tool_execution_start/_end → child tool observation (args + result)
-//        agent_end → close the trace and flush
-//      All prompts of one agent session share the SDK sessionId, so Langfuse
-//      groups them into a single session.
-
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { startObservation, LangfuseOtelSpanAttributes } from "@langfuse/tracing";
-import type {
-  LangfuseAgent,
-  LangfuseGeneration,
-  LangfuseTool,
-  ObservationLevel,
-} from "@langfuse/tracing";
-import type { ExtensionFactory } from "@oh-my-pi/pi-coding-agent";
-
-let processor: LangfuseSpanProcessor | undefined;
-let sdk: NodeSDK | undefined;
-let enabled = false;
-
-export function initTelemetry(): void {
-  if (sdk) return;
-
-  const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
-  const secretKey = process.env.LANGFUSE_SECRET_KEY;
-  if (!publicKey || !secretKey) {
-    console.log(
-      "[telemetry] Langfuse disabled — set LANGFUSE_PUBLIC_KEY + LANGFUSE_SECRET_KEY to enable",
-    );
-    return;
-  }
-
-  const baseUrl = process.env.LANGFUSE_BASE_URL ?? process.env.LANGFUSE_BASEURL;
-  processor = new LangfuseSpanProcessor({ publicKey, secretKey, baseUrl });
-  sdk = new NodeSDK({ spanProcessors: [processor] });
-  sdk.start();
-  enabled = true;
-  console.log(`[telemetry] Langfuse enabled → ${baseUrl ?? "https://cloud.langfuse.com"}`);
-}
-
-export function isTelemetryEnabled(): boolean {
-  return enabled;
-}
-
-export async function flushTelemetry(): Promise<void> {
-  if (!processor) return;
-  try {
-    await processor.forceFlush();
-  } catch (err) {
-    console.error(
-      "[telemetry] flush failed:",
-      err instanceof Error ? err.message : err,
-    );
-  }
-}
-
-export function createTelemetryExtension(meta: TelemetryMeta): ExtensionFactory {
-  return ((pi: any) => {
-    let root: LangfuseAgent | undefined;
-    let generation: LangfuseGeneration | undefined;
-    let contextMessages: unknown;
-    const tools = new Map<string, LangfuseTool>();
-
-    pi.on("before_agent_start", (event: any, ctx: any) => {
-      if (root) endTrace();
-      const prompt = event?.prompt ?? "";
-      const name = traceName(prompt);
-      root = startObservation(name, { input: prompt }, { asType: "agent" });
-      root.update({
-        metadata: {
-          cwd: meta.cwd,
-          model: meta.modelId,
-          provider: meta.provider,
-          projectIds: meta.projectIds,
-        },
-      });
-      const span = root.otelSpan;
-      span.setAttribute(LangfuseOtelSpanAttributes.TRACE_NAME, name);
-      span.setAttribute(LangfuseOtelSpanAttributes.TRACE_INPUT, serialize(prompt));
-      span.setAttribute(
-        LangfuseOtelSpanAttributes.TRACE_TAGS,
-        JSON.stringify(["testeiya", meta.mode]),
-      );
-      const sessionId = ctx?.sessionManager?.getSessionId?.();
-      if (sessionId) {
-        span.setAttribute(LangfuseOtelSpanAttributes.TRACE_SESSION_ID, sessionId);
-      }
-    });
-
-    pi.on("context", (event: any) => {
-      contextMessages = event?.messages;
-    });
-
-    pi.on("message_start", (event: any) => {
-      if (!root) return;
-      if (event?.message?.role !== "assistant") return;
-      generation = root.startObservation(
-        "llm-generation",
-        { input: contextMessages ?? [], model: meta.modelId },
-        { asType: "generation" },
-      );
-    });
-
-    pi.on("message_end", (event: any) => {
-      const msg = event?.message;
-      if (!generation || msg?.role !== "assistant") return;
-      generation.update({
-        model: msg.model ?? meta.modelId,
-        output: msg.content,
-        usageDetails: usageDetails(msg.usage),
-        costDetails: costDetails(msg.usage),
-      });
-      generation.end();
-      generation = undefined;
-    });
-
-    pi.on("tool_execution_start", (event: any) => {
-      if (!root) return;
-      const name = event?.toolName ?? "tool";
-      tools.set(
-        event.toolCallId,
-        root.startObservation(
-          name,
-          { input: event?.args, metadata: { toolName: name, intent: event?.intent } },
-          { asType: "tool" },
-        ),
-      );
-    });
-
-    pi.on("tool_execution_end", (event: any) => {
-      const span = tools.get(event?.toolCallId);
-      if (!span) return;
-      let level: ObservationLevel = "DEFAULT";
-      if (event?.isError) level = "ERROR";
-      span.update({ output: event?.result, level });
-      span.end();
-      tools.delete(event.toolCallId);
-    });
-
-    pi.on("agent_end", (event: any) => {
-      if (!root) return;
-      const output = finalText(event?.messages);
-      root.otelSpan.setAttribute(
-        LangfuseOtelSpanAttributes.TRACE_OUTPUT,
-        serialize(output),
-      );
-      root.update({ output });
-      endTrace();
-      void flushTelemetry();
-    });
-
-    function endTrace(): void {
-      for (const span of tools.values()) span.end();
-      tools.clear();
-      if (generation) {
-        generation.end();
-        generation = undefined;
-      }
-      if (root) {
-        root.end();
-        root = undefined;
-      }
-    }
-  }) as ExtensionFactory;
-}
-
-function usageDetails(usage: any): Record<string, number> | undefined {
-  if (!usage) return undefined;
-  return {
-    input: usage.input,
-    output: usage.output,
-    cache_read_input_tokens: usage.cacheRead,
-    cache_creation_input_tokens: usage.cacheWrite,
-    total: usage.totalTokens,
-  };
-}
-
-function costDetails(usage: any): Record<string, number> | undefined {
-  if (!usage?.cost) return undefined;
-  return {
-    input: usage.cost.input,
-    output: usage.cost.output,
-    total: usage.cost.total,
-  };
-}
-
-function finalText(messages: any): string | undefined {
-  if (!Array.isArray(messages)) return undefined;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "assistant") return textOf(messages[i].content);
-  }
-  return undefined;
-}
-
-function textOf(content: any): string | undefined {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return undefined;
-  return content
-    .filter((c) => c?.type === "text")
-    .map((c) => c.text)
-    .join("\n");
-}
-
-function traceName(prompt: unknown): string {
-  let text = "";
-  if (typeof prompt === "string") text = prompt;
-  const firstLine = text.split("\n")[0]?.trim() ?? "";
-  if (!firstLine) return "agent-run";
-  if (firstLine.length <= 60) return firstLine;
-  return `${firstLine.slice(0, 60)}…`;
-}
-
-function serialize(value: unknown): string {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return String(value);
-  }
-}
-
-interface TelemetryMeta {
-  cwd: string;
-  mode: string;
-  modelId?: string;
-  provider?: string;
-  projectIds?: string[];
-}

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;
-}