testeiya 0.2.1 → 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_VIOLET = "\x1b[38;2;139;92;246m"; // #8b5cf6 brand primary
-const TC_RESET = "\x1b[0m";
-
-/** Colorize a string in the Testeiya input-border violet. */
-export const testeiyaBorder = (s: string): string => `${TC_VIOLET}${s}${TC_RESET}`;
-
-interface ThemableInteractive {
-  editor: { setBorderVisible(v: boolean): void; borderColor: (s: string) => string };
-}
-
-/**
- * Apply the Testeiya look: obsidian base theme + violet 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;
-  }
-}