@rivus/agent 0.1.0

package/examples/langfuse-drive-e2e.mjs

@@ -0,0 +1,175 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import { runLangfuseDriveE2E } from "../dist/testing/index.js";
+
+const execFileAsync = promisify(execFile);
+const baseUrl = requiredEnv("LANGFUSE_BASE_URL");
+const publicKey = requiredEnv("LANGFUSE_PUBLIC_KEY");
+const secretKey = requiredEnv("LANGFUSE_SECRET_KEY");
+const marker = `${new Date()
+  .toISOString()
+  .replace(/[^0-9]/g, "")
+  .slice(0, 14)}-${randomUUID().slice(0, 8)}`;
+const sessionKey = `e2e:langfuse-drive:${marker}`;
+const expectedDriveTitle = `langfuse-e2e-${marker}.html`;
+const discoveredTraceIds = new Set();
+const deploymentStateDirectory = await mkdtemp(join(tmpdir(), "rivus-langfuse-e2e-state-"));
+const prompt = [
+  "Read the granted Langfuse HTML publishing Skill.",
+  "Create a polished, accessible, self-contained Chinese Langfuse introduction page.",
+  `Include the visible E2E marker ${marker}, then upload it as ${expectedDriveTitle}.`,
+  "Return the verified Feishu Drive URL."
+].join(" ");
+
+const result = await runLangfuseDriveE2E({
+  dependencies: {
+    inspectDrive: async (url) => {
+      const output = await command(process.env.RIVUS_LARK_CLI_PATH?.trim() || "lark-cli", [
+        "drive",
+        "+inspect",
+        "--as",
+        "user",
+        "--url",
+        url,
+        "--format",
+        "json"
+      ]);
+      const parsed = JSON.parse(output);
+      return isRecord(parsed.data) ? parsed.data : parsed;
+    },
+    listObservations: async ({ deadlineAt, fromStartTime, sessionKey: expectedSessionKey, toStartTime }) => {
+      if (discoveredTraceIds.size === 0) {
+        let cursor;
+        do {
+          const endpoint = new URL("/api/public/v2/observations", baseUrl);
+          endpoint.searchParams.set("fields", "core,basic");
+          endpoint.searchParams.set("fromStartTime", fromStartTime);
+          endpoint.searchParams.set("limit", "1000");
+          endpoint.searchParams.set("toStartTime", toStartTime);
+          if (cursor) endpoint.searchParams.set("cursor", cursor);
+          const body = await fetchLangfuseJson(endpoint, deadlineAt);
+          if (!isRecord(body) || !Array.isArray(body.data))
+            throw new Error("Langfuse returned an invalid observation page");
+          for (const observation of body.data.filter(isObservation)) {
+            if (observation.sessionId === expectedSessionKey) discoveredTraceIds.add(observation.traceId);
+          }
+          cursor = isRecord(body.meta) && typeof body.meta.cursor === "string" ? body.meta.cursor : undefined;
+        } while (cursor && discoveredTraceIds.size === 0);
+      }
+      const traces = [];
+      for (const traceId of [...discoveredTraceIds].slice(0, 4)) {
+        traces.push(await fetchLangfuseJson(new URL(`/api/public/traces/${traceId}`, baseUrl), deadlineAt));
+      }
+      return traces.flatMap((trace) => {
+        if (
+          !isRecord(trace) ||
+          typeof trace.id !== "string" ||
+          typeof trace.sessionId !== "string" ||
+          !Array.isArray(trace.observations)
+        )
+          return [];
+        return trace.observations.filter(isTraceObservation).map((observation) => ({
+          ...observation,
+          sessionId: trace.sessionId,
+          traceId: trace.id
+        }));
+      });
+    },
+    now: () => new Date(),
+    readDriveFile: async (fileToken) => {
+      const directory = await mkdtemp(join(tmpdir(), "rivus-langfuse-drive-e2e-"));
+      const outputName = `./${expectedDriveTitle}`;
+      try {
+        await command(
+          process.env.RIVUS_LARK_CLI_PATH?.trim() || "lark-cli",
+          ["drive", "+download", "--as", "user", "--file-token", fileToken, "--output", outputName],
+          directory
+        );
+        return await readFile(join(directory, expectedDriveTitle), "utf8");
+      } finally {
+        await rm(directory, { force: true, recursive: true });
+      }
+    },
+    runAgent: ({ prompt: agentPrompt, sessionKey: agentSessionKey }) =>
+      command(
+        process.execPath,
+        [
+          "dist/cli.js",
+          "--bootstrap",
+          "./examples/pi-feishu-deployment.bootstrap.ts",
+          "--manifest",
+          "./examples/rivus-langfuse-demo.config.json",
+          "--prompt",
+          agentPrompt,
+          "--session-key",
+          agentSessionKey
+        ],
+        process.cwd(),
+        { RIVUS_DEPLOYMENT_STATE_DIR: deploymentStateDirectory }
+      ),
+    sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))
+  },
+  expectedDriveContentMarker: marker,
+  expectedDriveTitle,
+  prompt,
+  sessionKey
+}).finally(() => rm(deploymentStateDirectory, { force: true, recursive: true }));
+
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+
+async function fetchLangfuseJson(endpoint, deadlineAt) {
+  const remainingMs = new Date(deadlineAt).getTime() - Date.now();
+  if (!Number.isFinite(remainingMs) || remainingMs <= 0) throw new Error("Langfuse request deadline expired");
+  const response = await fetch(endpoint, {
+    headers: {
+      authorization: `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString("base64")}`
+    },
+    signal: AbortSignal.timeout(Math.min(remainingMs, 10_000))
+  });
+  if (!response.ok) throw new Error(`Langfuse request failed with HTTP ${response.status}`);
+  return response.json();
+}
+
+async function command(executable, args, cwd = process.cwd(), extraEnv = {}) {
+  const { stdout } = await execFileAsync(executable, args, {
+    cwd,
+    env: {
+      ...process.env,
+      ...extraEnv,
+      LARKSUITE_CLI_NO_SKILLS_NOTIFIER: "1",
+      LARKSUITE_CLI_NO_UPDATE_NOTIFIER: "1"
+    },
+    maxBuffer: 2 * 1024 * 1024,
+    timeout: 300_000
+  });
+  return stdout;
+}
+
+function requiredEnv(name) {
+  const value = process.env[name]?.trim();
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+}
+
+function isObservation(value) {
+  return isTraceObservation(value) && typeof value.traceId === "string" && typeof value.sessionId === "string";
+}
+
+function isTraceObservation(value) {
+  return (
+    isRecord(value) &&
+    typeof value.id === "string" &&
+    typeof value.name === "string" &&
+    typeof value.startTime === "string" &&
+    typeof value.type === "string"
+  );
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}