@opvs-ai/cli 0.22.0 → 0.24.1

package/runtime-plugins/opencode/opvs-memory.ts

@@ -0,0 +1,94 @@
+// OPVS_MEMORY_PLUGIN_MANAGED: installed by `opvs memory install opencode`.
+import { spawn } from "node:child_process";
+
+const TIMEOUT_MS = 2_000;
+
+type HookChild = {
+  stdin: {
+    end(input: string): unknown;
+    once?(event: "error", listener: () => void): unknown;
+  } | null;
+  once(event: "error" | "close", listener: () => void): unknown;
+  kill?(signal?: NodeJS.Signals): unknown;
+};
+
+type SpawnHook = (
+  command: string,
+  args: string[],
+  options: { stdio: ["pipe", "ignore", "ignore"]; timeout: number; windowsHide: boolean },
+) => HookChild;
+
+function object(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+async function forward(hook: "post-tool" | "stop" | "session-end", event: unknown): Promise<void> {
+  try {
+    const input = JSON.stringify(event) ?? "null";
+    await new Promise<void>((resolve) => {
+      let child: HookChild;
+      try {
+        child = (spawn as unknown as SpawnHook)(
+          "opvs",
+          ["memory", "hook", hook, "--runtime", "opencode"],
+          { stdio: ["pipe", "ignore", "ignore"], timeout: TIMEOUT_MS, windowsHide: true },
+        );
+      } catch {
+        resolve();
+        return;
+      }
+
+      let settled = false;
+      const timer = setTimeout(() => {
+        try {
+          child.kill?.("SIGKILL");
+        } catch {
+          // A hook process that already exited needs no further cleanup.
+        }
+        finish();
+      }, TIMEOUT_MS);
+      timer.unref?.();
+
+      const finish = (): void => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve();
+      };
+
+      try {
+        child.once("error", finish);
+        child.once("close", finish);
+        child.stdin?.once?.("error", finish);
+        if (!child.stdin) finish();
+        else child.stdin.end(input);
+      } catch {
+        try {
+          child.kill?.("SIGKILL");
+        } catch {
+          // Never let runtime hook cleanup break the host session.
+        }
+        finish();
+      }
+    });
+  } catch {
+    // Memory capture is optional and must never break an OpenCode session.
+  }
+}
+
+export const OpvsMemoryPlugin = async () => ({
+  "tool.execute.after": async (event: unknown): Promise<undefined> => {
+    await forward("post-tool", event);
+    return undefined;
+  },
+  event: async (input: unknown): Promise<undefined> => {
+    const envelope = object(input);
+    const event = envelope?.event ?? input;
+    const type = object(event)?.type;
+    if (type === "session.idle") await forward("stop", event);
+    else if (type === "session.deleted") await forward("session-end", event);
+    return undefined;
+  },
+});