testeiya 0.2.1 → 0.3.10

package/src/api/testomatio-run-stats.ts

@@ -1,81 +0,0 @@
-import { getSession } from "../session-store.js";
-import { resolveTestomatioTarget } from "./testomatio-proxy.js";
-import { loadStoredAuth } from "../testomatio-auth.js";
-import { loggedServerFetch } from "../debug-bus.js";
-
-/*
- * Pass/fail/skip counters for the run detail widget:
- *
- *   GET /api/testomatio/run-stats?session=<sid>&run_id=<id>
- *
- * The v2 Run schema carries no counters, so we read them from the app API
- * (`${baseUrl}/api/{project_slug}/runs/{id}`), which — like transcription /
- * attachment — authenticates the *user JWT* (`eyJ...`), not the per-project
- * `tstmt_` token. It returns `attributes.{tests-count,passed,failed,skipped}`
- * in a single request, so the widget no longer has to page through every
- * testrun to tally statuses.
- */
-
-export async function testomatioRunStats(req: Request): Promise<Response> {
-  const url = new URL(req.url);
-  const sessionId = url.searchParams.get("session");
-  const runId = url.searchParams.get("run_id");
-  if (!sessionId) {
-    return Response.json({ error: "session required" }, { status: 400 });
-  }
-  if (!runId) {
-    return Response.json({ error: "run_id required" }, { status: 400 });
-  }
-  const session = getSession(sessionId);
-  if (!session) {
-    return Response.json({ error: "session not found" }, { status: 404 });
-  }
-  const target = resolveTestomatioTarget(session);
-  if ("error" in target) {
-    return Response.json({ error: target.error }, { status: 400 });
-  }
-  const auth = loadStoredAuth();
-  if (!auth) {
-    return Response.json({ error: "Sign in to Testomat.io" }, { status: 401 });
-  }
-
-  const upstream = new URL(
-    `/api/${encodeURIComponent(target.projectSlug)}/runs/${encodeURIComponent(runId)}`,
-    target.baseUrl
-  );
-  const { res, text } = await loggedServerFetch(upstream.toString(), {
-    headers: { Authorization: `Bearer ${auth.token}`, Accept: "application/json" },
-    cache: "no-store",
-  });
-  if (!res.ok) {
-    return Response.json(
-      { error: `run stats failed (HTTP ${res.status})` },
-      { status: res.status }
-    );
-  }
-
-  const attrs = runAttributes(text);
-  return Response.json({
-    tests_count: numberOrUndefined(attrs["tests-count"]),
-    passed: numberOrUndefined(attrs["passed"]),
-    failed: numberOrUndefined(attrs["failed"]),
-    skipped: numberOrUndefined(attrs["skipped"]),
-    status: typeof attrs["status"] === "string" ? attrs["status"] : undefined,
-  });
-}
-
-function runAttributes(text: string): Record<string, unknown> {
-  try {
-    const json = JSON.parse(text) as {
-      data?: { attributes?: Record<string, unknown> };
-    };
-    return json?.data?.attributes ?? {};
-  } catch {
-    return {};
-  }
-}
-
-function numberOrUndefined(v: unknown): number | undefined {
-  if (typeof v === "number") return v;
-  return undefined;
-}

package/src/api/testomatio-target.ts

@@ -1,225 +0,0 @@
-// Resolve a workspace to a Testomat.io v2 call target — token, base URL, and the
-// project identifier (slug or id) for the `/api/v2/{project}/...` path — and a
-// thin DELETE helper. Shared by workspace sync (token + base URL only) and the
-// file-delete endpoint (which also needs the project identifier and method).
-
-import fs from "node:fs";
-import path from "node:path";
-import type { StoredSession } from "../session-store.js";
-import { readProjectMeta } from "../workspace-model.js";
-import { PROJECT_DIR } from "../project-dir.js";
-import {
-  loadStoredAuth,
-  getCachedProjects,
-  fetchProjects,
-  normalizeBaseUrl,
-} from "../testomatio-auth.js";
-import { readEnvToken } from "./read-env-token.js";
-
-export async function resolveProjectTarget(
-  session: Pick<StoredSession, "tokens" | "backendUrl" | "projects">,
-  cwd: string
-): Promise<ProjectTarget | null> {
-  // 1. A managed (project-pulled) session carries the project slug + token.
-  const slug = session.projects?.[0]?.slug;
-  const sessionToken = slug ? session.tokens?.[slug] : undefined;
-  if (slug && sessionToken) {
-    return { token: sessionToken, baseUrl: normalizeBaseUrl(session.backendUrl), project: slug };
-  }
-
-  // 2. A linked folder: recover the project from `.testeiya/testeiya.json` and
-  //    resolve its write-token from the connected account.
-  const meta = readProjectMeta(cwd);
-  const stored = loadStoredAuth();
-  if (meta && stored?.token) {
-    const baseUrl = normalizeBaseUrl(meta.baseUrl || stored.baseUrl);
-    const token = await projectApiKey(stored.token, baseUrl, meta.projectId);
-    if (token) return { token, baseUrl, project: meta.projectId };
-  }
-
-  // 3. An unlinked folder, but an account is connected with a currently-selected
-  //    project: use that project's write-token + base URL. This is what makes a
-  //    plain folder sync against the connected project instead of falling back
-  //    to whatever stale token happens to sit in the folder's own `.env`.
-  if (stored?.token && stored.projectId) {
-    const baseUrl = normalizeBaseUrl(stored.baseUrl);
-    const token = await projectApiKey(stored.token, baseUrl, stored.projectId);
-    if (token) return { token, baseUrl, project: stored.projectId };
-  }
-
-  // 4. A folder's own `.env` carries a token but not a project id, so the v2
-  //    REST path can't be built — usable for sync, not for a targeted delete.
-  return null;
-}
-
-export async function deleteTestomatioResource(
-  target: ProjectTarget,
-  resource: "suites" | "tests",
-  id: string
-): Promise<boolean> {
-  const res = await mutate(target, "DELETE", resource, id);
-  // 404 = already gone upstream; treat as success so a stale local file deletes.
-  return res.ok || res.status === 404;
-}
-
-export async function updateTestomatioResource(
-  target: ProjectTarget,
-  resource: "suites" | "tests",
-  id: string,
-  body: Record<string, unknown>
-): Promise<boolean> {
-  const res = await mutate(target, "PUT", resource, id, body);
-  // 404 = gone upstream; nothing to update, so the local rename can still proceed.
-  return res.ok || res.status === 404;
-}
-
-/** Token + base URL for a workspace, ignoring the project identifier (sync use). */
-export async function resolveProjectCreds(
-  session: Pick<StoredSession, "tokens" | "backendUrl" | "projects">,
-  cwd: string
-): Promise<{ token: string; baseUrl: string } | null> {
-  const target = await resolveProjectTarget(session, cwd);
-  if (target) return { token: target.token, baseUrl: target.baseUrl };
-  return readEnvToken(cwd);
-}
-
-/**
- * The `TESTOMATIO*` env vars a session's shell commands should run with —
- * resolved from any workspace shape: managed session tokens, a linked folder,
- * the connected account, the folder's own `.env`, or a `.testeiya/mcp.json`
- * whose testomatio server already embeds the token in its `--token` arg.
- */
-export async function resolveSessionShellEnv(
-  session: Pick<StoredSession, "tokens" | "backendUrl" | "projects">,
-  cwd: string
-): Promise<SessionShellEnv | null> {
-  const meta = readProjectMeta(cwd);
-  const target = await resolveProjectTarget(session, cwd);
-  if (target) {
-    const env: Record<string, string> = {
-      TESTOMATIO: target.token,
-      TESTOMATIO_URL: target.baseUrl,
-      TESTOMATIO_PROJECT_ID: target.project,
-    };
-    const slug = session.projects?.[0]?.slug;
-    let source: SessionShellEnv["source"] = "account";
-    if (slug && session.tokens?.[slug]) source = "managed";
-    else if (meta) source = "linked";
-    const resolved: SessionShellEnv = { env, source, projectId: target.project };
-    if (meta?.projectId === target.project && meta.title) resolved.title = meta.title;
-    return resolved;
-  }
-
-  const dotenv = readEnvToken(cwd);
-  if (dotenv) {
-    return {
-      env: { TESTOMATIO: dotenv.token, TESTOMATIO_URL: dotenv.baseUrl },
-      source: "dotenv",
-    };
-  }
-
-  return readMcpToken(cwd);
-}
-
-async function mutate(
-  target: ProjectTarget,
-  method: "DELETE" | "PUT",
-  resource: "suites" | "tests",
-  id: string,
-  body?: Record<string, unknown>
-): Promise<Response> {
-  const path = `/api/v2/${encodeURIComponent(target.project)}/${resource}/${encodeURIComponent(id)}`;
-  const upstream = new URL(path, target.baseUrl);
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${target.token}`,
-    Accept: "application/json",
-  };
-  if (body) headers["Content-Type"] = "application/json";
-  console.log(`[testomatio] → ${method} ${upstream.toString()}`);
-  const res = await fetch(upstream.toString(), {
-    method,
-    headers,
-    body: body ? JSON.stringify(body) : undefined,
-    cache: "no-store",
-  });
-  console.log(`[testomatio] ← ${res.status} ${method} ${resource}/${id}`);
-  return res;
-}
-
-async function projectApiKey(
-  jwt: string,
-  baseUrl: string,
-  projectId: string
-): Promise<string | null> {
-  let projects = getCachedProjects(jwt, baseUrl);
-  if (!projects) {
-    try {
-      projects = await fetchProjects(jwt, baseUrl);
-    } catch {
-      return null;
-    }
-  }
-  const project = projects.find((p) => p.id === projectId);
-  if (!project?.apiKey) return null;
-  return project.apiKey;
-}
-
-function readMcpToken(cwd: string): SessionShellEnv | null {
-  let raw: string;
-  try {
-    raw = fs.readFileSync(path.join(cwd, PROJECT_DIR, "mcp.json"), "utf8");
-  } catch {
-    return null;
-  }
-  let servers: Record<string, { args?: unknown; env?: Record<string, string> }>;
-  try {
-    servers = JSON.parse(raw)?.mcpServers ?? {};
-  } catch {
-    return null;
-  }
-
-  const found: { token: string; project?: string; baseUrl?: string }[] = [];
-  for (const [name, server] of Object.entries(servers)) {
-    if (!name.startsWith("testomatio-")) continue;
-    const args: string[] = [];
-    if (Array.isArray(server?.args)) {
-      for (const arg of server.args) args.push(String(arg));
-    }
-    const tokenIdx = args.indexOf("--token");
-    if (tokenIdx < 0 || !args[tokenIdx + 1]) continue;
-    const entry: { token: string; project?: string; baseUrl?: string } = {
-      token: args[tokenIdx + 1],
-      baseUrl: server.env?.TESTOMATIO_BASE_URL,
-    };
-    const projectIdx = args.indexOf("--project");
-    if (projectIdx >= 0) entry.project = args[projectIdx + 1];
-    found.push(entry);
-  }
-  // 2+ tokened servers = a multi-project workspace; no single TESTOMATIO is right.
-  if (found.length !== 1) return null;
-
-  const entry = found[0];
-  const env: Record<string, string> = {
-    TESTOMATIO: entry.token,
-    TESTOMATIO_URL: normalizeBaseUrl(entry.baseUrl),
-  };
-  const resolved: SessionShellEnv = { env, source: "mcp" };
-  if (entry.project) {
-    env.TESTOMATIO_PROJECT_ID = entry.project;
-    resolved.projectId = entry.project;
-  }
-  return resolved;
-}
-
-export interface ProjectTarget {
-  token: string;
-  baseUrl: string;
-  project: string;
-}
-
-export interface SessionShellEnv {
-  env: Record<string, string>;
-  source: "managed" | "linked" | "account" | "dotenv" | "mcp";
-  projectId?: string;
-  title?: string;
-}

package/src/api/testomatio-transcription.ts

@@ -1,82 +0,0 @@
-import { getSession } from "../session-store.js";
-import { resolveTestomatioTarget } from "./testomatio-proxy.js";
-import { loadStoredAuth } from "../testomatio-auth.js";
-import { loggedServerFetch } from "../debug-bus.js";
-
-/*
- * Speech-to-text for the chat voice input:
- *
- *   POST /api/testomatio/transcription?session=<sid>  (multipart "file" [+ "language"])
- *
- * Upstream call: `${baseUrl}/api/{project_slug}/transcriptions` with the audio as
- * multipart/form-data field `file` and `Authorization: Bearer <jwt>` (Groq Whisper).
- * Unlike the v2 proxy, this endpoint lives on the app API (`Api::ApiController`),
- * which authenticates the *user JWT* (`eyJ...`) — the per-project `tstmt_` token
- * is rejected here (403 Unauthorized). So we resolve the project slug + baseUrl
- * from the session but send the stored user JWT for auth.
- */
-
-export async function testomatioTranscribe(req: Request): Promise<Response> {
-  const url = new URL(req.url);
-  const sessionId = url.searchParams.get("session");
-  if (!sessionId) {
-    return Response.json({ error: "session required" }, { status: 400 });
-  }
-  const session = getSession(sessionId);
-  if (!session) {
-    return Response.json({ error: "session not found" }, { status: 404 });
-  }
-  const target = resolveTestomatioTarget(session);
-  if ("error" in target) {
-    return Response.json({ error: target.error }, { status: 400 });
-  }
-  const auth = loadStoredAuth();
-  if (!auth) {
-    return Response.json(
-      { error: "Sign in to Testomat.io to use voice input" },
-      { status: 401 }
-    );
-  }
-
-  const form = await req.formData();
-  const file = form.get("file");
-  if (!(file instanceof Blob)) {
-    return Response.json({ error: "file required" }, { status: 400 });
-  }
-  const filename = file instanceof File ? file.name : "recording.webm";
-  const language = form.get("language");
-
-  const upstream = new URL(
-    `/api/${encodeURIComponent(target.projectSlug)}/transcriptions`,
-    target.baseUrl
-  );
-
-  const body = new FormData();
-  body.append("file", file, filename);
-  if (typeof language === "string" && language) body.append("language", language);
-
-  const { res, text } = await loggedServerFetch(
-    upstream.toString(),
-    {
-      method: "POST",
-      headers: { Authorization: `Bearer ${auth.token}`, Accept: "application/json" },
-      body,
-    },
-    `[multipart] ${filename}`
-  );
-  if (!res.ok) {
-    let error = text || `transcription failed (HTTP ${res.status})`;
-    try {
-      const parsed = JSON.parse(text) as { error?: string };
-      if (parsed?.error) error = parsed.error;
-    } catch {}
-    return Response.json({ error }, { status: res.status });
-  }
-  let transcript = "";
-  try {
-    transcript = (JSON.parse(text) as { text?: string })?.text ?? "";
-  } catch {
-    transcript = "";
-  }
-  return Response.json({ text: transcript });
-}

package/src/api/workspace-search.ts

@@ -1,96 +0,0 @@
-import path from "node:path";
-import { grep, type ContextLine, type GrepMatch } from "@oh-my-pi/pi-natives";
-import { getSession } from "../session-store.js";
-import { safeResolve } from "../workspace/safe-path.js";
-import { resolveManualTestsDir, VENDOR_DIRS } from "../workspace-model.js";
-
-const MAX_MATCHES = 200;
-const CONTEXT_LINES = 2;
-
-export async function workspaceSearch(request: Request): Promise<Response> {
-  const url = new URL(request.url);
-  const sessionId = url.searchParams.get("session");
-  const q = url.searchParams.get("q");
-  const scope = url.searchParams.get("scope") === "all" ? "all" : "manual";
-  if (!sessionId || !q?.trim()) {
-    return Response.json({ error: "session and q required" }, { status: 400 });
-  }
-  const session = getSession(sessionId);
-  if (!session) return Response.json({ error: "Session not found" }, { status: 404 });
-
-  const cwd = session.cwd;
-  let searchRel = "";
-  if (scope === "manual") searchRel = resolveManualTestsDir(cwd) ?? "";
-  const abs = safeResolve(cwd, searchRel || ".");
-  if (!abs) return Response.json({ error: "path outside workspace" }, { status: 400 });
-
-  // The manual-tests dir is an intentionally-gitignored cache, so manual scope
-  // must not honor .gitignore (else it could match nothing); all scope respects
-  // the user's repo ignores to skip build artifacts and dependencies.
-  let result: { matches: GrepMatch[]; limitReached?: boolean };
-  try {
-    result = await grep({
-      pattern: escapeRegex(q.trim()),
-      path: abs,
-      ignoreCase: true,
-      gitignore: scope === "all",
-      hidden: false,
-      contextBefore: CONTEXT_LINES,
-      contextAfter: CONTEXT_LINES,
-      maxCount: MAX_MATCHES,
-      mode: "content",
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.startsWith("regex parse error")) {
-      return Response.json({ error: message }, { status: 400 });
-    }
-    throw err;
-  }
-
-  const fileOrder: string[] = [];
-  const byFile = new Map<string, SearchMatch[]>();
-  let totalMatches = 0;
-  for (const match of result.matches) {
-    const rel = toCwdRelative(cwd, abs, match.path);
-    if (rel.split("/").some((segment) => VENDOR_DIRS.has(segment))) continue;
-    if (!byFile.has(rel)) {
-      fileOrder.push(rel);
-      byFile.set(rel, []);
-    }
-    byFile.get(rel)!.push({
-      lineNumber: match.lineNumber,
-      line: match.line,
-      before: match.contextBefore ?? [],
-      after: match.contextAfter ?? [],
-    });
-    totalMatches++;
-  }
-
-  const files = fileOrder.map((p) => ({ path: p, matches: byFile.get(p)! }));
-  return Response.json({
-    query: q.trim(),
-    scope,
-    scopePath: searchRel,
-    totalMatches,
-    totalFiles: files.length,
-    truncated: Boolean(result.limitReached),
-    files,
-  });
-}
-
-function toCwdRelative(cwd: string, searchRoot: string, matchPath: string): string {
-  const absMatch = path.resolve(searchRoot, matchPath);
-  return path.relative(cwd, absMatch).split(path.sep).join("/");
-}
-
-function escapeRegex(input: string): string {
-  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-interface SearchMatch {
-  lineNumber: number;
-  line: string;
-  before: ContextLine[];
-  after: ContextLine[];
-}

package/src/api/workspace-sync.ts

@@ -1,151 +0,0 @@
-// POST /api/workspace/sync  { session, action: "pull" | "push", files?, suiteIds?, auto? }
-//
-// Runs `check-tests` for the session's workspace. Resolves the manual-tests
-// dir and the project write-token, preferring the connected Testomat.io account
-// and falling back to the folder's own `.env` (the check-tests convention).
-//
-//   pull              → fetch all suites (with `--export-automated`, unless the
-//                       workspace is itself an automated-tests repo)
-//   pull + suiteIds   → fetch only those suites (`--suite-ids`)
-//   push              → partial push of only the changed files (full dir when
-//                       nothing is detected as changed)
-//   push + files      → push only those suites
-//   push + auto       → background push-on-save: only suites that already exist
-//                       on Testomat.io (carry an `@S` id) — local-only drafts are
-//                       skipped until pushed explicitly.
-
-import fs from "node:fs";
-import path from "node:path";
-import { getSession } from "../session-store.js";
-import {
-  runCheckTests,
-  type CheckTestsAction,
-  type RunCheckTestsOptions,
-} from "../check-tests.js";
-import { resolveManualTestsDir, hasAutomationConfig } from "../workspace-model.js";
-import { computeChangedFiles } from "../sync-snapshot.js";
-import { PROJECT_DIR, MANUAL_TESTS_SUBDIR } from "../project-dir.js";
-import { safeResolve } from "../workspace/safe-path.js";
-import { suiteId } from "../workspace/test-md.js";
-import { resolveProjectCreds } from "./testomatio-target.js";
-
-export async function workspaceSync(request: Request): Promise<Response> {
-  let body: {
-    session?: string;
-    action?: string;
-    files?: string[];
-    suiteIds?: string[];
-    auto?: boolean;
-  };
-  try {
-    body = await request.json();
-  } catch {
-    return Response.json({ error: "invalid JSON body" }, { status: 400 });
-  }
-
-  const action = body.action;
-  if (action !== "pull" && action !== "push") {
-    return Response.json({ error: "action must be 'pull' or 'push'" }, { status: 400 });
-  }
-  const session = getSession(body.session ?? "");
-  if (!session) {
-    return Response.json({ error: "Session not found" }, { status: 404 });
-  }
-  const cwd = path.resolve(session.cwd);
-  if (!fs.existsSync(cwd)) {
-    return Response.json({ error: "Workspace missing" }, { status: 410 });
-  }
-
-  const dir = syncDir(cwd, action);
-  if (dir === null) {
-    if (action === "push" && body.auto) return Response.json({ ok: true, skipped: true });
-    return Response.json(
-      { error: "No manual tests in this workspace to push." },
-      { status: 400 }
-    );
-  }
-
-  const creds = await resolveProjectCreds(session, cwd);
-  if (!creds) {
-    if (action === "push" && body.auto) return Response.json({ ok: true, skipped: true });
-    return Response.json(
-      {
-        error:
-          "Can't sync: no Testomat.io project is linked to this workspace. Connect a project, or add a TESTOMATIO token to the folder's .env.",
-      },
-      { status: 400 }
-    );
-  }
-
-  const run: RunCheckTestsOptions = {
-    cwd,
-    dir,
-    token: creds.token,
-    baseUrl: creds.baseUrl,
-  };
-  let files = pickFiles(cwd, body.files);
-
-  if (action === "pull") {
-    if (!hasAutomationConfig(cwd)) run.exportAutomated = true;
-    if (Array.isArray(body.suiteIds) && body.suiteIds.length) run.suiteIds = body.suiteIds;
-  }
-
-  // Bulk push: restrict to the changed files (partial push). When nothing is
-  // detected as changed, fall through to a full-dir push so an opened folder can
-  // still be pushed wholesale.
-  if (action === "push" && !files && !body.auto) {
-    const changed = Object.keys(computeChangedFiles(cwd));
-    if (changed.length > 0) files = changed;
-  }
-
-  // Auto push-on-save: only suites that already live on Testomat.io.
-  if (action === "push" && body.auto) {
-    files = (files ?? []).filter((rel) => hasSuiteId(cwd, rel));
-    if (files.length === 0) return Response.json({ ok: true, action, dir, skipped: true });
-  }
-
-  if (files?.length) run.files = files;
-
-  const result = await runCheckTests(action as CheckTestsAction, run);
-  if (!result.ok) {
-    return Response.json(
-      { error: `check-tests ${action} failed`, output: tail(result.output) },
-      { status: 502 }
-    );
-  }
-  return Response.json({ ok: true, action, dir, skipped: false, output: tail(result.output) });
-}
-
-/** Sync target dir relative to cwd; null when push has nothing to push. */
-function syncDir(cwd: string, action: CheckTestsAction): string | null {
-  const resolved = resolveManualTestsDir(cwd);
-  if (resolved !== null) return resolved || ".";
-  // Nothing loaded yet: a pull seeds the gitignored cache; a push has no source.
-  if (action === "push") return null;
-  return `${PROJECT_DIR}/${MANUAL_TESTS_SUBDIR}`;
-}
-
-/** Keep only the client-supplied paths that resolve safely inside the workspace. */
-function pickFiles(cwd: string, files: string[] | undefined): string[] | undefined {
-  if (!Array.isArray(files) || files.length === 0) return undefined;
-  const out: string[] = [];
-  for (const rel of files) {
-    if (typeof rel === "string" && safeResolve(cwd, rel)) out.push(rel);
-  }
-  return out.length > 0 ? out : undefined;
-}
-
-/** Whether a `*.test.md` already carries a Testomat.io suite id (`@S…`). */
-function hasSuiteId(cwd: string, rel: string): boolean {
-  const abs = safeResolve(cwd, rel);
-  if (!abs) return false;
-  try {
-    return !!suiteId(fs.readFileSync(abs, "utf8"));
-  } catch {
-    return false;
-  }
-}
-
-function tail(output: string, lines = 12): string {
-  return output.split("\n").slice(-lines).join("\n");
-}