feat(agent-runner): finalize 4.x processor integration

2026-08-31 06:37:14 +00:00 · 2026-07-12 15:44:05 +08:00
parent 457408ad7f
commit 9aa71d54e3
109 changed files with 2200 additions and 1204 deletions
@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+
+import {
+  apiJson,
+  createBrowser,
+  ensureAuthenticatedBrowser,
+  ensureEvidence,
+  evidencePaths,
+  exitCode,
+  loadEnvFiles,
+  localIsoWithOffset,
+  safeScreenshot,
+  scanBrowserDiagnostics,
+  writeResult,
+} from "./lib/langbot-e2e.mjs";
+
+const caseId = "agent-runner-health-visibility";
+await loadEnvFiles();
+const paths = evidencePaths(caseId);
+await ensureEvidence(paths);
+const readyScreenshot = paths.screenshot.replace(/\.png$/, "-ready.png");
+const unavailableScreenshot = paths.screenshot.replace(
+  /\.png$/,
+  "-unavailable.png",
+);
+
+const startedAt = new Date();
+const frontendUrl = process.env.LANGBOT_FRONTEND_URL || "";
+const backendUrl = process.env.LANGBOT_BACKEND_URL || "";
+const missingRunnerId = "plugin:qa/missing-runner/default";
+
+let browser;
+let token = "";
+let agentId = "";
+const result = {
+  source: "automation",
+  case_id: caseId,
+  run_id: paths.runId,
+  started_at: startedAt.toISOString(),
+  started_at_local: localIsoWithOffset(startedAt),
+  finished_at: "",
+  finished_at_local: "",
+  status: "fail",
+  reason: "",
+  url: "",
+  visible_signals: [],
+  api: {},
+  diagnostics: null,
+  cleanup: null,
+  evidence: {
+    console_log: paths.consoleLog,
+    network_log: paths.networkLog,
+    screenshot: paths.screenshot,
+    ready_screenshot: readyScreenshot,
+    unavailable_screenshot: unavailableScreenshot,
+    automation_result_json: paths.automationResultJson,
+    result_json: paths.resultJson,
+  },
+  evidence_collected: ["ui", "screenshot", "console", "api_diagnostic"],
+};
+
+function schemaDefaults(items = []) {
+  return Object.fromEntries(
+    items
+      .filter((item) => item.name && Object.hasOwn(item, "default"))
+      .map((item) => [item.name, item.default]),
+  );
+}
+
+async function openRunnerSettings(page, agentUrl) {
+  await page.goto(agentUrl, { waitUntil: "domcontentloaded" });
+  await page
+    .getByRole("button", { name: /Runner|运行器|ランナー/ })
+    .first()
+    .waitFor({ timeout: 15_000 });
+  await page
+    .getByRole("button", { name: /Runner|运行器|ランナー/ })
+    .first()
+    .click();
+}
+
+try {
+  if (!frontendUrl) throw new Error("LANGBOT_FRONTEND_URL is not configured.");
+  if (!backendUrl) throw new Error("LANGBOT_BACKEND_URL is not configured.");
+
+  browser = await createBrowser(paths);
+  const { page } = browser;
+  await page.goto(frontendUrl, { waitUntil: "domcontentloaded" });
+  const auth = await ensureAuthenticatedBrowser(page, {
+    frontendUrl,
+    backendUrl,
+  });
+  if (auth.status !== "pass") {
+    result.status = auth.status;
+    throw new Error(auth.reason);
+  }
+
+  token = await page.evaluate(() => localStorage.getItem("token") || "");
+  if (!token) {
+    result.status = "blocked";
+    throw new Error("Authenticated browser has no reusable local token.");
+  }
+
+  const pluginStatus = await apiJson(
+    backendUrl,
+    "/api/v1/system/status/plugin-system",
+    { token },
+  );
+  const pluginData = pluginStatus.json.data || {};
+  result.api.plugin_status = {
+    http_status: pluginStatus.status,
+    code: pluginStatus.json.code ?? null,
+    is_enable: pluginData.is_enable ?? null,
+    is_connected: pluginData.is_connected ?? null,
+  };
+  if (pluginStatus.status >= 400 || pluginStatus.json.code !== 0) {
+    result.status = "env_issue";
+    throw new Error(pluginStatus.json.msg || "Plugin status request failed.");
+  }
+  if (!pluginData.is_enable || !pluginData.is_connected) {
+    result.status = "env_issue";
+    throw new Error("The plugin runtime is not enabled and connected.");
+  }
+
+  const metadata = await apiJson(backendUrl, "/api/v1/agents/_/metadata", {
+    token,
+  });
+  const runnerTab = metadata.json.data?.runner_config;
+  const runnerStage = runnerTab?.stages?.find(
+    (stage) => stage.name === "runner",
+  );
+  const runnerOptions =
+    runnerStage?.config?.find((item) => item.name === "id")?.options || [];
+  const runner = runnerOptions[0];
+  result.api.agent_metadata = {
+    http_status: metadata.status,
+    code: metadata.json.code ?? null,
+    runner_count: runnerOptions.length,
+    selected_runner: runner?.name || null,
+  };
+  if (metadata.status >= 400 || metadata.json.code !== 0) {
+    throw new Error(metadata.json.msg || "Agent metadata request failed.");
+  }
+  if (!runner?.name) {
+    result.status = "blocked";
+    throw new Error("No registered AgentRunner is available for the UI check.");
+  }
+
+  const runnerConfigStage = runnerTab.stages.find(
+    (stage) => stage.name === runner.name,
+  );
+  const create = await apiJson(backendUrl, "/api/v1/agents", {
+    method: "POST",
+    token,
+    body: {
+      kind: "agent",
+      name: `Runner Health ${paths.runId.slice(-40)}`,
+      description: "Temporary AgentRunner health visibility fixture",
+      emoji: "H",
+      component_ref: runner.name,
+      config: {
+        runner: { id: runner.name, "expire-time": 0 },
+        runner_config: {
+          [runner.name]: schemaDefaults(runnerConfigStage?.config),
+        },
+      },
+      enabled: true,
+      supported_event_patterns: ["message.*"],
+    },
+  });
+  agentId = create.json.data?.uuid || "";
+  result.api.create_agent = {
+    http_status: create.status,
+    code: create.json.code ?? null,
+  };
+  if (create.status >= 400 || create.json.code !== 0 || !agentId) {
+    throw new Error(create.json.msg || "Failed to create the temporary Agent.");
+  }
+
+  const agentUrl = `${frontendUrl.replace(/\/$/, "")}/home/agents?id=${encodeURIComponent(agentId)}`;
+  result.url = agentUrl;
+  await openRunnerSettings(page, agentUrl);
+  await page
+    .getByText(/Runner ready|运行器已就绪|Runner の準備完了/, { exact: true })
+    .waitFor({ timeout: 15_000 });
+  result.visible_signals.push("registered-runner-ready");
+  await safeScreenshot(page, readyScreenshot);
+
+  const staleUpdate = await apiJson(
+    backendUrl,
+    `/api/v1/agents/${encodeURIComponent(agentId)}`,
+    {
+      method: "PUT",
+      token,
+      body: {
+        component_ref: missingRunnerId,
+        config: {
+          runner: { id: missingRunnerId, "expire-time": 0 },
+          runner_config: { [missingRunnerId]: {} },
+        },
+      },
+    },
+  );
+  result.api.set_stale_runner = {
+    http_status: staleUpdate.status,
+    code: staleUpdate.json.code ?? null,
+  };
+  if (staleUpdate.status >= 400 || staleUpdate.json.code !== 0) {
+    throw new Error(
+      staleUpdate.json.msg || "Failed to set the stale runner fixture.",
+    );
+  }
+
+  await openRunnerSettings(page, agentUrl);
+  await page
+    .getByText(
+      /Selected runner is unavailable|所选运行器不可用|選択した Runner は利用できません/,
+      { exact: true },
+    )
+    .waitFor({ timeout: 15_000 });
+  await page.getByRole("link", { name: /Extensions|扩展|拡張機能/ }).waitFor();
+  result.visible_signals.push("stale-runner-unavailable", "recovery-action");
+  await safeScreenshot(page, unavailableScreenshot);
+  await safeScreenshot(page, paths.screenshot);
+
+  result.diagnostics = await scanBrowserDiagnostics(paths);
+  if (result.diagnostics.status !== "pass") {
+    throw new Error(result.diagnostics.reason);
+  }
+  result.status = "pass";
+  result.reason =
+    "Agent Runner settings visibly distinguished a registered runner from a stale binding.";
+} catch (error) {
+  if (!["blocked", "env_issue"].includes(result.status)) result.status = "fail";
+  result.reason = result.reason || error.message;
+  if (browser?.page) await safeScreenshot(browser.page, paths.screenshot);
+} finally {
+  const cleanup = {};
+  if (agentId && token && backendUrl) {
+    const deletedAgent = await apiJson(
+      backendUrl,
+      `/api/v1/agents/${encodeURIComponent(agentId)}`,
+      { method: "DELETE", token },
+    ).catch((error) => ({
+      status: 0,
+      json: { code: null, msg: error.message },
+    }));
+    cleanup.agent_deleted =
+      deletedAgent.status < 400 && deletedAgent.json.code === 0;
+    cleanup.agent_http_status = deletedAgent.status;
+  }
+  result.cleanup = cleanup;
+  if (agentId && !cleanup.agent_deleted && result.status === "pass") {
+    result.status = "fail";
+    result.reason = "The temporary runner health Agent was not deleted.";
+  }
+  if (browser) await browser.close().catch(() => {});
+  const finishedAt = new Date();
+  result.finished_at = finishedAt.toISOString();
+  result.finished_at_local = localIsoWithOffset(finishedAt);
+  await writeResult(paths, result);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+process.exit(exitCode(result.status));