@rivus/gateway 0.16.2

package/templates/https-response-reader.mjs

@@ -0,0 +1,36 @@
+import { get } from "node:https";
+
+export function readBoundedHttpsResponse(url, options) {
+  return new Promise((resolve, reject) => {
+    const request = get(
+      url,
+      {
+        family: 4,
+        headers: options.headers,
+        signal: AbortSignal.timeout(options.timeoutMs ?? 10_000)
+      },
+      (response) => {
+        const status = response.statusCode ?? 0;
+        response.once("error", reject);
+        if (status < 200 || status >= 300) {
+          response.resume();
+          resolve({ body: Buffer.alloc(0), status });
+          return;
+        }
+        const chunks = [];
+        let length = 0;
+        response.on("data", (chunk) => {
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          length += buffer.length;
+          if (length > options.maxBytes) {
+            request.destroy(new Error(`HTTPS response exceeds ${options.maxBytes} bytes`));
+            return;
+          }
+          chunks.push(buffer);
+        });
+        response.once("end", () => resolve({ body: Buffer.concat(chunks), status }));
+      }
+    );
+    request.once("error", reject);
+  });
+}

package/templates/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);
+}

package/templates/pi-feishu-deployment.bootstrap.ts

@@ -0,0 +1,3 @@
+// Projects initialized by Gateway keep the historical bootstrap specifier while
+// the implementation remains in the Gateway package canonical owner.
+export { createRivusDeploymentAdapters } from "@rivus/agent/bootstrap/pi-feishu";

package/templates/pi-feishu.bootstrap.ts

@@ -0,0 +1,242 @@
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { Effect } from "effect";
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { createAgentSession, ModelRuntime, SessionManager } from "@earendil-works/pi-coding-agent";
+import {
+  createJsonFetchRequest,
+  createJsonFileFeishuCardTargetRegistry,
+  createJsonlAgentEventLog,
+  createLazyFeishuWebSocketEventDispatcher,
+  mergePiProviderBaseUrlOverride,
+  createRivusDaemonStatusHttpServer,
+  createPiAgentLoop,
+  createPiSessionRegistry,
+  createSystemClock,
+  createUuidRunIds,
+  restoreConfiguredRivusDaemonBootstrap,
+  type ConfiguredRivusDaemonBootstrapRequest,
+  type ConfiguredRivusDaemonBootstrapResponse,
+  type FeishuWebSocketClient,
+  type RivusDaemonBootstrapContext,
+  type RivusDaemonFeishuReplayRunner,
+  type RivusDaemonProcess,
+  type RivusDaemonPromptRunner,
+  type RivusDaemonStatusReporter,
+  type FeishuReceiveMessagePayload,
+  type FeishuReceiveMessageReplayOptions
+} from "@rivus/agent";
+import {
+  createPiSkillReadTools,
+  createPiSessionResources,
+  resolvePiSessionToolNames,
+  validatePiSkillCommand
+} from "@rivus/agent/pi";
+
+type PiSessionOptions = NonNullable<Parameters<typeof createAgentSession>[0]>;
+
+const STATE_DIR = "./.rivus";
+const CARD_TARGETS_FILE = `${STATE_DIR}/feishu-card-targets.json`;
+const EVENT_LOG_FILE = `${STATE_DIR}/agent-events.jsonl`;
+const PI_AUTH_FILE = `${STATE_DIR}/pi-auth.json`;
+const PI_MODELS_FILE = `${STATE_DIR}/pi-models.json`;
+const PI_AGENT_DIR = `${STATE_DIR}/pi-agent`;
+
+export async function createRivusDaemonProcess(
+  context: RivusDaemonBootstrapContext
+): Promise<RivusDaemonProcess & RivusDaemonPromptRunner & RivusDaemonStatusReporter & RivusDaemonFeishuReplayRunner> {
+  await mkdir(PI_AGENT_DIR, { recursive: true });
+
+  const piSessionOptions = await createPiSessionOptions(context);
+  const sessionRegistry = createPiSessionRegistry({
+    createSession: async () => {
+      const cwd = process.cwd();
+      const resources = await createPiSessionResources({
+        agentDir: PI_AGENT_DIR,
+        cwd,
+        homeDirectory: homedir()
+      });
+      const customTools = createPiSkillReadTools({
+        cwd,
+        runtimeToolIds: [],
+        skillPaths: resources.skillNames.size > 0 ? resources.skillPaths : []
+      });
+      const result = await createAgentSession(
+        resources.withSessionOptions({
+          ...piSessionOptions,
+          customTools,
+          excludeTools: [],
+          sessionManager: SessionManager.create(cwd),
+          tools: [...resolvePiSessionToolNames([], customTools)]
+        })
+      );
+      return {
+        dispose: () => result.session.dispose(),
+        preparePrompt: (input) => {
+          validatePiSkillCommand(input.text, resources.skillNames);
+          return input.text;
+        },
+        session: result.session
+      };
+    }
+  });
+  const piLoop = createPiAgentLoop({
+    supportsSteering: true,
+    disposeSessionAfterRun: false,
+    resolveSession: (input) => sessionRegistry.resolve(input)
+  });
+  const statusPort = readOptionalPort(context.env.RIVUS_STATUS_PORT);
+  const request = createJsonFetchRequest();
+
+  const bootstrap = await Effect.runPromise(
+    restoreConfiguredRivusDaemonBootstrap({
+      cardTargets: createJsonFileFeishuCardTargetRegistry({
+        filePath: CARD_TARGETS_FILE
+      }),
+      clock: createSystemClock(),
+      config: context.config,
+      ...(statusPort === undefined
+        ? {}
+        : {
+            createStatusTransport: (statusReporter: RivusDaemonStatusReporter) =>
+              createRivusDaemonStatusHttpServer({
+                port: statusPort,
+                statusReporter
+              })
+          }),
+      eventDispatcher: createLazyFeishuWebSocketEventDispatcher(() => new Lark.EventDispatcher({})),
+      eventLog: createJsonlAgentEventLog({
+        filePath: EVENT_LOG_FILE
+      }),
+      loop: piLoop,
+      request: (input: ConfiguredRivusDaemonBootstrapRequest) =>
+        request(input).pipe(Effect.map((response) => response as ConfiguredRivusDaemonBootstrapResponse)),
+      runIds: createUuidRunIds(),
+      sleep: (ms) => Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, ms))),
+      websocketClient: createLazyFeishuWebSocketClient({
+        appId: context.config.feishu.appId,
+        appSecret: context.config.feishu.appSecret
+      })
+    })
+  );
+
+  return {
+    promptText: (command) => bootstrap.promptText(command),
+    replayReceiveMessage: (payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions) =>
+      bootstrap.runtime.replayReceiveMessage(payload, options),
+    running: () => bootstrap.process.running(),
+    start: () => bootstrap.process.start(),
+    status: () => bootstrap.status(),
+    stop: () =>
+      Effect.gen(function* () {
+        yield* bootstrap.process.stop();
+        yield* Effect.tryPromise({
+          try: () => sessionRegistry.disposeAll(),
+          catch: (error) => error
+        });
+      })
+  };
+}
+
+function createLazyFeishuWebSocketClient(options: {
+  readonly appId: string;
+  readonly appSecret: string;
+}): FeishuWebSocketClient {
+  let client:
+    | {
+        close(): void;
+        start(options: Parameters<FeishuWebSocketClient["start"]>[0]): Promise<void> | void;
+      }
+    | undefined;
+
+  return {
+    start: (startOptions) => {
+      client ??= new Lark.WSClient({
+        appId: options.appId,
+        appSecret: options.appSecret
+      });
+      return client.start(startOptions);
+    },
+    close: () => {
+      client?.close();
+      client = undefined;
+    }
+  };
+}
+
+async function createPiSessionOptions(context: RivusDaemonBootstrapContext): Promise<PiSessionOptions> {
+  const provider = readProviderFromModel(context.config.pi.model);
+
+  if (context.config.pi.baseUrl) {
+    if (!provider) {
+      throw new Error("PI_BASE_URL requires PI_MODEL in provider/model form, for example zai/glm-5.2");
+    }
+    await writeProviderBaseUrlOverride(provider, context.config.pi.baseUrl);
+  }
+
+  const modelRuntime = await ModelRuntime.create({
+    allowModelNetwork: false,
+    authPath: PI_AUTH_FILE,
+    modelsPath: context.config.pi.baseUrl ? PI_MODELS_FILE : null
+  });
+  if (context.config.pi.apiKey) {
+    if (!provider) {
+      throw new Error("PI_API_KEY requires PI_MODEL in provider/model form, for example zai/glm-5.2");
+    }
+    await modelRuntime.setRuntimeApiKey(provider, context.config.pi.apiKey);
+  }
+  const model = context.config.pi.model ? resolveConfiguredPiModel(modelRuntime, context.config.pi.model) : undefined;
+  return {
+    cwd: process.cwd(),
+    modelRuntime,
+    ...(model ? { model } : {}),
+    ...(context.config.pi.thinkingLevel ? { thinkingLevel: context.config.pi.thinkingLevel } : {})
+  };
+}
+
+function resolveConfiguredPiModel(modelRuntime: ModelRuntime, modelReference: string): PiSessionOptions["model"] {
+  const provider = readProviderFromModel(modelReference);
+  const modelId = readModelIdFromModel(modelReference);
+  if (!provider || !modelId) {
+    throw new Error("PI_MODEL must use provider/model form, for example zai/glm-5.2");
+  }
+
+  const model = modelRuntime.getModel(provider, modelId);
+  if (!model) {
+    throw new Error(`PI_MODEL ${modelReference} was not found in the Pi model runtime`);
+  }
+  return model as PiSessionOptions["model"];
+}
+
+function readProviderFromModel(model: string | undefined): string | undefined {
+  const slashIndex = model?.indexOf("/") ?? -1;
+  if (!model || slashIndex <= 0) {
+    return undefined;
+  }
+  return model.slice(0, slashIndex);
+}
+
+function readModelIdFromModel(model: string | undefined): string | undefined {
+  const slashIndex = model?.indexOf("/") ?? -1;
+  if (!model || slashIndex < 0 || slashIndex === model.length - 1) {
+    return undefined;
+  }
+  return model.slice(slashIndex + 1);
+}
+
+function readOptionalPort(value: string | undefined): number | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const port = Number(trimmed);
+  if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+    throw new Error("RIVUS_STATUS_PORT must be an integer between 0 and 65535");
+  }
+  return port;
+}
+
+async function writeProviderBaseUrlOverride(provider: string, baseUrl: string): Promise<void> {
+  await mergePiProviderBaseUrlOverride({ baseUrl, filePath: PI_MODELS_FILE, provider });
+}