@elench/testkit 0.1.97 → 0.1.98

package/lib/cli/commands/flags.mjs

@@ -0,0 +1,61 @@
+import { Flags } from "@oclif/core";
+
+export const sharedFlags = {
+  dir: Flags.string({
+    description: "Explicit product directory",
+  }),
+  service: Flags.string({
+    description: "Limit the operation or assistant context to one service",
+  }),
+};
+
+export const runFlags = {
+  ...sharedFlags,
+  type: Flags.string({
+    char: "t",
+    multiple: true,
+    description: "Run specific suite type(s): int, e2e, scenario, dal, load, pw, all",
+  }),
+  suite: Flags.string({
+    char: "s",
+    multiple: true,
+    description: "Run specific suite(s)",
+  }),
+  file: Flags.string({
+    char: "f",
+    multiple: true,
+    description: "Run specific file(s)",
+  }),
+  workers: Flags.string({
+    description: "Number of test executors for the whole run",
+  }),
+  "file-timeout-seconds": Flags.string({
+    description: "Per-file wall-clock timeout in seconds",
+  }),
+  shard: Flags.string({
+    description: "Run only shard i of n at suite granularity",
+  }),
+  seed: Flags.string({
+    description: "Deterministic seed for scenario suites",
+  }),
+  "write-status": Flags.boolean({
+    description: "Write a deterministic testkit.status.json snapshot",
+    default: false,
+  }),
+  "allow-partial-status": Flags.boolean({
+    description: "Allow --write-status for filtered runs",
+    default: false,
+  }),
+  "ignore-skip-rules": Flags.boolean({
+    description: "Run files even if testkit.config.ts marks them skipped",
+    default: false,
+  }),
+  "output-mode": Flags.string({
+    description: "Reporter mode",
+    options: ["compact", "debug", "events"],
+  }),
+  debug: Flags.boolean({
+    description: "Alias for --output-mode debug",
+    default: false,
+  }),
+};

package/lib/cli/commands/run.mjs

@@ -1,5 +1,7 @@
 import { Args, Command } from "@oclif/core";
-import { executeRunCommand, runFlags } from "../command-helpers.mjs";
+import { runFlags } from "./flags.mjs";
+import { buildRunRequest, executeRunRequest } from "../operations/run/operation.mjs";
+import { resolveTerminalCapabilities } from "../terminal/capabilities.mjs";
 
 export default class RunCommand extends Command {
   static summary = "Run test suites";
@@ -18,6 +20,12 @@ export default class RunCommand extends Command {
 
   async run() {
     const { args, flags } = await this.parse(RunCommand);
-    return executeRunCommand(this, flags, args.type || null);
+    const request = await buildRunRequest(flags, args.type || null, process.cwd(), process.cwd());
+    return executeRunRequest(request, {
+      outputMode: flags["output-mode"] || "compact",
+      json: this.jsonEnabled(),
+      debug: flags.debug,
+      terminal: resolveTerminalCapabilities(),
+    });
   }
 }

package/lib/cli/commands/status.mjs

@@ -1,5 +1,7 @@
 import { Command } from "@oclif/core";
-import { runStatusLike, sharedFlags } from "../command-helpers.mjs";
+import { sharedFlags } from "./flags.mjs";
+import { executeStatusOperation } from "../operations/status/operation.mjs";
+import { renderStatusResult } from "../renderers/status/text.mjs";
 
 export default class StatusCommand extends Command {
   static summary = "Show local testkit state";
@@ -10,6 +12,12 @@ export default class StatusCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(StatusCommand);
-    return runStatusLike("status", flags);
+    const results = await executeStatusOperation(flags);
+    if (!this.jsonEnabled()) {
+      for (const result of results) {
+        for (const line of renderStatusResult(result)) this.log(line);
+      }
+    }
+    return { ok: true, results };
   }
 }

package/lib/cli/commands/typecheck.mjs

@@ -1,5 +1,6 @@
 import { Command, Flags } from "@oclif/core";
-import { runTestkitTypecheck } from "../../app/typecheck.mjs";
+import { executeTypecheckOperation } from "../operations/typecheck/operation.mjs";
+import { renderTypecheckResult } from "../renderers/typecheck/text.mjs";
 
 export default class TypecheckCommand extends Command {
   static summary = "Typecheck testkit config, helpers, and suites";
@@ -14,12 +15,11 @@ export default class TypecheckCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(TypecheckCommand);
-    const result = await runTestkitTypecheck({ dir: flags.dir });
+    const result = await executeTypecheckOperation(flags);
 
     if (!this.jsonEnabled()) {
-      this.log(`Typechecked ${result.results.length} testkit program(s) in ${result.productDir}`);
-      for (const entry of result.results) {
-        this.log(`PASS ${entry.label} ${entry.tsconfigPath}`);
+      for (const line of renderTypecheckResult(result)) {
+        this.log(line);
       }
     }
 

package/lib/cli/{tui/inspect-app.mjs → components/blocks/run-tree.mjs}

@@ -1,7 +1,7 @@
 import React, { createElement, useEffect, useMemo, useState } from "react";
 import { Box, Text, useAnimation, useApp, useInput } from "ink";
 import figures from "figures";
-import { formatDuration } from "../../runner/formatting.mjs";
+import { formatDuration } from "../../../runner/formatting.mjs";
 import {
   bold,
   colorService,
@@ -10,61 +10,60 @@ import {
   green,
   red,
   yellow,
-} from "../presentation/colors.mjs";
-import { renderSummaryBox } from "../presentation/summary-box.mjs";
-import { getTerminalWidth } from "../presentation/terminal-layout.mjs";
-import { readContextContent } from "../context-resources.mjs";
-import { applyHighlight } from "./fuzzy-match.mjs";
-import { FilterBar } from "./filter-bar.mjs";
+} from "../../terminal/colors.mjs";
+import { renderSummaryBox } from "../primitives/summary-box.mjs";
+import { applyHighlight } from "../../state/tree/fuzzy-match.mjs";
+import { FilterBar } from "../primitives/filter-bar.mjs";
 
 const SPINNER_FRAMES = ["|", "/", "-", "\\"];
 
-export function InspectApp({
-  inspectState,
+export function RunTreeView({
+  runState,
   stdout,
-  productDir,
   onRequestClose,
+  interactive = true,
 } = {}) {
   const { exit } = useApp();
-  const [snapshot, setSnapshot] = useState(() => inspectState.getSnapshot());
+  const [snapshot, setSnapshot] = useState(() => runState.getSnapshot());
   const { frame } = useAnimation({ interval: 80, isActive: !snapshot.finished });
   const spinnerFrame = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
 
   useEffect(() => {
-    const unsubscribe = inspectState.subscribe(() => {
-      setSnapshot(inspectState.getSnapshot());
+    const unsubscribe = runState.subscribe(() => {
+      setSnapshot(runState.getSnapshot());
     });
     return unsubscribe;
-  }, [inspectState]);
+  }, [runState]);
 
   useInput((input, key) => {
+    if (!interactive) return;
     if (!snapshot.finished) {
       if (input === "q") {
-        inspectState.setNotice("Run is still in progress. Wait for completion before closing.");
+        runState.setNotice("Run is still in progress. Wait for completion before closing.");
       }
       return;
     }
 
     if (snapshot.filter.active) {
       if (key.escape) {
-        inspectState.deactivateFilter();
+        runState.deactivateFilter();
         return;
       }
       if (key.return) return;
       if (key.downArrow || input === "j") {
-        inspectState.moveCursorDown();
+        runState.moveCursorDown();
         return;
       }
       if (key.upArrow || input === "k") {
-        inspectState.moveCursorUp();
+        runState.moveCursorUp();
         return;
       }
       if (key.backspace || key.delete) {
-        inspectState.updateFilterQuery(snapshot.filter.query.slice(0, -1));
+        runState.updateFilterQuery(snapshot.filter.query.slice(0, -1));
         return;
       }
       if (isPrintableInput(input, key)) {
-        inspectState.updateFilterQuery(`${snapshot.filter.query}${input}`);
+        runState.updateFilterQuery(`${snapshot.filter.query}${input}`);
       }
       return;
     }
@@ -74,43 +73,27 @@ export function InspectApp({
       return;
     }
     if (input === "/") {
-      inspectState.activateFilter();
+      runState.activateFilter();
       return;
     }
     if (key.downArrow || input === "j") {
-      inspectState.moveCursorDown();
+      runState.moveCursorDown();
       return;
     }
     if (key.upArrow || input === "k") {
-      inspectState.moveCursorUp();
+      runState.moveCursorUp();
       return;
     }
     if (key.return) {
-      inspectState.toggleExpand();
+      runState.toggleExpand();
       return;
     }
-    if (key.tab) {
-      inspectState.cyclePaneMode();
-      return;
-    }
-  });
+  }, { isActive: interactive });
 
-  const terminalWidth = getTerminalWidth(stdout, 100);
-  const leftWidth = Math.max(42, Math.floor(terminalWidth * 0.52));
-  const rightWidth = Math.max(28, terminalWidth - leftWidth - 1);
   const visibleTreeEntries = useMemo(
-    () => buildTreeViewport(snapshot.visibleEntries, snapshot.selectedEntryId, 17),
+    () => buildTreeViewport(snapshot.visibleEntries, snapshot.selectedEntryId, 24),
     [snapshot.visibleEntries, snapshot.selectedEntryId]
   );
-  const paneContent = useMemo(
-    () =>
-      readContextContent({
-        productDir,
-        snapshot,
-        mode: snapshot.paneMode,
-      }),
-    [productDir, snapshot]
-  );
   const summaryLines = snapshot.finished && snapshot.summaryData
     ? renderSummaryBox(snapshot.summaryData.rows, { stdout })
     : [];
@@ -122,15 +105,8 @@ export function InspectApp({
     snapshot.notice ? createElement(Text, { key: "notice" }, yellow(snapshot.notice)) : null,
     createElement(
       Box,
-      { key: "main", marginTop: 1, flexDirection: "row" },
-      createElement(Box, { width: leftWidth, flexDirection: "column", paddingRight: 1 }, ...visibleTreeEntries.map(renderTreeLine.bind(null, snapshot, spinnerFrame))),
-      createElement(
-        Box,
-        { width: rightWidth, flexDirection: "column", paddingLeft: 1 },
-        createElement(Text, { key: "pane-title" }, bold(paneContent.title)),
-        createElement(Text, { key: "pane-gap" }, ""),
-        ...paneContent.lines.slice(0, 34).map((line, index) => createElement(Text, { key: `pane-${index}` }, line))
-      )
+      { key: "main", marginTop: 1, flexDirection: "column" },
+      ...visibleTreeEntries.map(renderTreeLine.bind(null, snapshot, spinnerFrame))
     ),
     snapshot.filter.active ? createElement(Text, { key: "filter-gap" }, "") : null,
     snapshot.filter.active ? createElement(FilterBar, { key: "filter-bar", filter: snapshot.filter }) : null,
@@ -144,7 +120,7 @@ export function InspectApp({
 export function buildHeaderText(snapshot) {
   const progressText = snapshot.totalCount > 0 ? `[${snapshot.completedCount}/${snapshot.totalCount}]` : "[0/0]";
   const phaseText = snapshot.phase || (snapshot.finished ? "run complete" : "preparing");
-  const sourceText = snapshot.dataSource === "artifact" ? "artifact inspect" : snapshot.finished ? "live summary" : "live run";
+  const sourceText = snapshot.dataSource === "artifact" ? "artifact run" : snapshot.finished ? "live summary" : "live run";
   const filterText = snapshot.filter.active ? `filter ${snapshot.filter.count}` : null;
   return [progressText, phaseText, sourceText, filterText].filter(Boolean).join(" · ");
 }
@@ -154,8 +130,7 @@ export function buildFooterText(snapshot) {
   if (snapshot.filter.active) {
     return "type to filter · ↑/↓ move · Esc clear filter · q quit";
   }
-  const inspectKeys = "↑/↓ move · Enter collapse/expand · Tab cycle pane · / filter";
-  return `${inspectKeys} · q quit`;
+  return "↑/↓ move · Enter collapse/expand · / filter · q quit";
 }
 
 function buildTreeViewport(entries, selectedEntryId, radius) {

package/lib/cli/{tui → components/primitives}/filter-bar.mjs

@@ -1,6 +1,6 @@
 import React, { createElement } from "react";
 import { Text } from "ink";
-import { bold, dim } from "../presentation/colors.mjs";
+import { bold, dim } from "../../terminal/colors.mjs";
 
 export function FilterBar({ filter } = {}) {
   if (!filter?.active) return null;

package/lib/cli/{presentation → components/primitives}/summary-box.mjs

@@ -1,5 +1,5 @@
 import figures from "figures";
-import { clamp, getTerminalWidth, measureWidth, padEndVisible, wrapText } from "./terminal-layout.mjs";
+import { clamp, getTerminalWidth, measureWidth, padEndVisible, wrapText } from "../../terminal/layout.mjs";
 
 export function renderSummaryBox(
   rows,

package/lib/cli/config.mjs

@@ -0,0 +1,63 @@
+import fs from "fs";
+import path from "path";
+
+export const DEFAULT_CLI_CONFIG = Object.freeze({
+  autoCollapsePassedTreeBranches: true,
+});
+
+export function cliConfigPath(productDir) {
+  return path.join(productDir || process.cwd(), ".testkit", "config.json");
+}
+
+export function loadCliConfig(productDir) {
+  try {
+    return normalizeCliConfig(JSON.parse(fs.readFileSync(cliConfigPath(productDir), "utf8")));
+  } catch {
+    return { ...DEFAULT_CLI_CONFIG };
+  }
+}
+
+export function saveCliConfig(productDir, config) {
+  const filePath = cliConfigPath(productDir);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(normalizeCliConfig(config), null, 2)}\n`, "utf8");
+}
+
+export function resetCliConfig(productDir) {
+  fs.rmSync(cliConfigPath(productDir), { force: true });
+  return { ...DEFAULT_CLI_CONFIG };
+}
+
+export function mergeCliConfig(...configs) {
+  let merged = { ...DEFAULT_CLI_CONFIG };
+  for (const config of configs) {
+    if (!config || typeof config !== "object") continue;
+    merged = normalizeCliConfig({ ...merged, ...dropUndefined(config) });
+  }
+  return merged;
+}
+
+export function normalizeCliConfig(config = {}) {
+  return {
+    autoCollapsePassedTreeBranches:
+      config.autoCollapsePassedTreeBranches == null
+        ? DEFAULT_CLI_CONFIG.autoCollapsePassedTreeBranches
+        : Boolean(config.autoCollapsePassedTreeBranches),
+  };
+}
+
+export function formatCliConfig(config) {
+  const normalized = normalizeCliConfig(config);
+  return [
+    `autoCollapsePassedTreeBranches: ${normalized.autoCollapsePassedTreeBranches}`,
+    `path: .testkit/config.json`,
+  ].join("\n");
+}
+
+function dropUndefined(value) {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== undefined) result[key] = entry;
+  }
+  return result;
+}

package/lib/cli/operations/browser/serve/operation.mjs

@@ -0,0 +1,23 @@
+import { startBrowserBridgeServer } from "@elench/testkit-bridge";
+import { loadBrowserBridgeContext } from "../../../../app/browser-bridge.mjs";
+
+export async function executeBrowserServeOperation(flags = {}) {
+  const { productDir, context } = await loadBrowserBridgeContext({ dir: flags.dir });
+
+  const adapter = {
+    loadProductContext: async () => context,
+  };
+
+  const serverRef = await startBrowserBridgeServer(adapter, {
+    host: flags.host,
+    port: flags.port,
+  });
+
+  return {
+    ok: true,
+    productDir,
+    host: serverRef.host,
+    port: serverRef.port,
+    url: serverRef.url,
+  };
+}

package/lib/cli/operations/cleanup/operation.mjs

@@ -0,0 +1,8 @@
+import * as runner from "../../../runner/index.mjs";
+import { loadManagedConfigs } from "../../../app/configs.mjs";
+
+export async function executeCleanupOperation(flags = {}) {
+  const { allConfigs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
+  const productDir = allConfigs[0]?.productDir || process.cwd();
+  return runner.cleanup(productDir);
+}

package/lib/cli/{db.mjs → operations/db/snapshot/capture/operation.mjs}

@@ -1,15 +1,15 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { loadManagedConfigs, resolveTargetConfig, collectRequiredConfigs, topologicallySortConfigs } from "../app/configs.mjs";
-import { resolveProductDir } from "../config/index.mjs";
-import { captureDatabaseTemplateSnapshot, prepareDatabaseRuntime } from "../database/index.mjs";
-import { createRunReporter } from "./presentation/run-reporter.mjs";
-import { createRunLogRegistry } from "../runner/logs.mjs";
-import { createSetupOperationRegistry } from "../runner/setup-operations.mjs";
-import { resolveRuntimeInstanceConfigs } from "../runner/template.mjs";
+import { loadManagedConfigs, resolveTargetConfig, collectRequiredConfigs, topologicallySortConfigs } from "../../../../../app/configs.mjs";
+import { resolveProductDir } from "../../../../../config/index.mjs";
+import { captureDatabaseTemplateSnapshot, prepareDatabaseRuntime } from "../../../../../database/index.mjs";
+import { createRunReporter } from "../../../../renderers/run/text-reporter.mjs";
+import { createRunLogRegistry } from "../../../../../runner/logs.mjs";
+import { createSetupOperationRegistry } from "../../../../../runner/setup-operations.mjs";
+import { resolveRuntimeInstanceConfigs } from "../../../../../runner/template.mjs";
 
-export async function runDatabaseSnapshotCaptureCommand(options = {}) {
+export async function executeDatabaseSnapshotCaptureOperation(options = {}) {
   const productDir = resolveProductDir(process.cwd(), options.dir);
   const { configs } = await loadManagedConfigs({ dir: productDir });
   const target = resolveTargetConfig(configs, options.service);
@@ -51,7 +51,13 @@ export async function runDatabaseSnapshotCaptureCommand(options = {}) {
       logRegistry,
       setupRegistry,
     });
-    console.log(`Wrote ${path.relative(productDir, absoluteOutputPath)}`);
+    return {
+      ok: true,
+      productDir,
+      service: target.name,
+      outputPath: absoluteOutputPath,
+      outputLabel: path.relative(productDir, absoluteOutputPath) || path.basename(absoluteOutputPath),
+    };
   } finally {
     logRegistry.closeAll();
     fs.rmSync(runtimeRoot, { recursive: true, force: true });

package/lib/cli/operations/destroy/operation.mjs

@@ -0,0 +1,12 @@
+import * as runner from "../../../runner/index.mjs";
+import { loadManagedConfigs } from "../../../app/configs.mjs";
+
+export async function executeDestroyOperation(flags = {}) {
+  const { configs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
+  const results = [];
+  for (const config of configs) {
+    await runner.destroy(config);
+    results.push({ name: config.name, destroyed: true });
+  }
+  return results;
+}

package/lib/cli/operations/discover/operation.mjs

@@ -0,0 +1,32 @@
+import fs from "fs";
+import path from "path";
+import { discoverTests } from "../../../discovery/index.mjs";
+import { resolveProductDir } from "../../../config/index.mjs";
+import { resolveRequestedFiles } from "../../args.mjs";
+
+export async function executeDiscoverOperation(flags = {}, cwd = process.cwd()) {
+  const productDir = resolveProductDir(cwd, flags.dir);
+  const fileNames = resolveRequestedFiles(flags.file || [], productDir, cwd);
+  const result = await discoverTests({
+    dir: productDir,
+    service: flags.service || null,
+    type: flags.type || [],
+    suite: flags.suite || [],
+    file: fileNames,
+    runnableOnly: flags["runnable-only"],
+    diagnostics: flags.strict ? "error" : "report",
+  });
+
+  let outputLabel = null;
+  if (flags.output) {
+    const outputPath = path.resolve(productDir, flags.output);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, `${JSON.stringify(result, null, 2)}\n`);
+    outputLabel = path.relative(productDir, outputPath) || path.basename(outputPath);
+  }
+
+  return {
+    ...result,
+    outputLabel,
+  };
+}

package/lib/cli/operations/doctor/operation.mjs

@@ -0,0 +1,5 @@
+import { runDoctor } from "../../../app/doctor.mjs";
+
+export async function executeDoctorOperation(flags = {}) {
+  return runDoctor({ dir: flags.dir, typecheck: flags.typecheck });
+}

package/lib/cli/operations/run/operation.mjs

@@ -0,0 +1,129 @@
+import * as runner from "../../../runner/index.mjs";
+import { loadManagedConfigs } from "../../../app/configs.mjs";
+import {
+  parseFileTimeoutOption,
+  parseShardOption,
+  parseSuiteOption,
+  parseTypeOption,
+  parseWorkersOption,
+  resolveRequestedFiles,
+} from "../../args.mjs";
+import { createRunReporter } from "../../renderers/run/text-reporter.mjs";
+import { createRunEventsReporter } from "../../renderers/run/events.mjs";
+import { createRunSession, renderRunSessionView } from "../../renderers/run/interactive.mjs";
+import { loadCliConfig } from "../../config.mjs";
+import {
+  resolveRunOutputMode,
+  resolveTerminalCapabilities,
+  selectRunRenderer,
+} from "../../terminal/capabilities.mjs";
+
+export async function buildRunRequest(flags, positionalType = null, cwd = process.cwd(), invocationCwd = process.cwd()) {
+  const { allConfigs, configs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
+  const workers = flags.workers == null ? null : parseWorkersOption(flags.workers);
+  const fileTimeoutSeconds =
+    flags["file-timeout-seconds"] == null
+      ? null
+      : parseFileTimeoutOption(flags["file-timeout-seconds"]);
+  const shard = parseShardOption(flags.shard);
+  const typeValues = parseTypeOption(flags.type, positionalType);
+  const suiteSelectors = parseSuiteOption(flags.suite);
+  const rawFileNames = Array.isArray(flags.file) ? flags.file : [flags.file].filter(Boolean);
+  const productDir = allConfigs[0]?.productDir || cwd;
+  const fileNames = resolveRequestedFiles(rawFileNames, productDir, invocationCwd);
+
+  return {
+    allConfigs,
+    configs,
+    productDir,
+    typeValues,
+    suiteSelectors,
+    runOptions: {
+      ...flags,
+      typeValues,
+      fileNames,
+      workers,
+      fileTimeoutSeconds,
+      shard,
+      scenarioSeed: flags.seed || null,
+      serviceFilter: flags.service || null,
+      writeStatus: flags["write-status"],
+      allowPartialStatus: flags["allow-partial-status"],
+      ignoreSkipRules: flags["ignore-skip-rules"],
+    },
+  };
+}
+
+export async function executeRunRequest(
+  request,
+  {
+    outputMode: requestedMode = "compact",
+    json = false,
+    debug = false,
+    terminal = {},
+    attachedRunSession = null,
+  } = {}
+) {
+  const capabilities = resolveTerminalCapabilities(terminal);
+  const outputMode = resolveRunOutputMode({
+    requestedMode,
+    json,
+    debug,
+  });
+  const renderer = selectRunRenderer(outputMode, capabilities);
+  const config = loadCliConfig(request.productDir);
+  let reporter;
+  let mountedView = null;
+  let runSession = attachedRunSession;
+
+  if (attachedRunSession) {
+    runSession = attachedRunSession;
+    reporter = runSession.reporter;
+  } else if (renderer === "tree") {
+    runSession = attachedRunSession || createRunSession({
+      productDir: request.productDir,
+      stderr: capabilities.stderr,
+      config,
+    });
+    reporter = runSession.reporter;
+    mountedView = renderRunSessionView(runSession, {
+      stdout: capabilities.stdout,
+      stderr: capabilities.stderr,
+      interactive: true,
+    });
+  } else if (renderer === "events") {
+    reporter = createRunEventsReporter({
+      stdout: capabilities.stdout,
+      stderr: capabilities.stderr,
+    });
+  } else {
+    reporter = createRunReporter({
+      outputMode,
+      stdout: capabilities.stdout,
+      stderr: capabilities.stderr,
+    });
+  }
+
+  try {
+    const result = await runner.runAll(
+      request.configs,
+      request.typeValues,
+      request.suiteSelectors,
+      {
+        reporter,
+        ...request.runOptions,
+      },
+      request.allConfigs
+    );
+    await mountedView?.finalize;
+    return {
+      outputMode,
+      runSession,
+      ...result,
+    };
+  } catch (error) {
+    mountedView?.close?.();
+    await mountedView?.finalize?.catch?.(() => {});
+    throw error;
+  }
+}

package/lib/cli/operations/status/operation.mjs

@@ -0,0 +1,7 @@
+import * as runner from "../../../runner/index.mjs";
+import { loadManagedConfigs } from "../../../app/configs.mjs";
+
+export async function executeStatusOperation(flags = {}) {
+  const { configs } = await loadManagedConfigs({ dir: flags.dir, service: flags.service });
+  return configs.map((config) => runner.showStatus(config));
+}

package/lib/cli/operations/typecheck/operation.mjs

@@ -0,0 +1,5 @@
+import { runTestkitTypecheck } from "../../../app/typecheck.mjs";
+
+export async function executeTypecheckOperation(flags = {}) {
+  return runTestkitTypecheck({ dir: flags.dir });
+}

package/lib/cli/renderers/browser-serve/text.mjs

@@ -0,0 +1,6 @@
+export function renderBrowserServeResult(result) {
+  return [
+    `testkit browser bridge serving ${result.productDir}`,
+    `Listening on ${result.url}`,
+  ];
+}