Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
/**
* Async write-path helper for hook-based memory plugins.
*
* When `cfg.writePathAsync` is true and we're not already the worker, we:
* 1. Drain the parent's stdin (the hook payload)
* 2. Emit the harness-specific approve/no-op response on stdout immediately
* 3. Spawn a detached clone of ourselves with env OV_HOOK_WORKER=1
* 4. Feed the drained payload to the worker's stdin, unref, and exit
*
* The worker re-enters the same script, maybeDetach returns false (because
* OV_HOOK_WORKER=1), and the hook's normal synchronous code path reads its
* own stdin and runs the OV HTTP work with nobody waiting.
*
* Call this BEFORE the hook reads stdin itself. When it returns true, the
* caller must `return` out of main() immediately.
*/
import { spawn } from "node:child_process";
const WORKER_ENV = "OV_HOOK_WORKER";
export async function maybeDetach(cfg, { approve }) {
if (!cfg.writePathAsync) return false;
if (process.env[WORKER_ENV] === "1") return false;
// Drain parent stdin so we can forward to the worker.
let raw;
try {
const chunks = [];
for await (const chunk of process.stdin) chunks.push(chunk);
raw = Buffer.concat(chunks);
} catch {
// stdin read failed - let the synchronous path handle it.
return false;
}
let child;
try {
child = spawn(process.execPath, [process.argv[1]], {
detached: true,
stdio: ["pipe", "ignore", "ignore"],
env: { ...process.env, [WORKER_ENV]: "1" },
});
} catch {
// spawn failed - fall through to sync mode, but we've already drained
// stdin so hand the payload back via env var path below.
process.env.OPENVIKING_HOOK_STDIN_CACHE = raw.toString();
return false;
}
// Approve first, then write to the detached child. Ordering matters for
// harnesses that read stdout before waiting for the hook process to exit.
approve();
try {
child.stdin.write(raw);
child.stdin.end();
} catch { /* worker may have already exited; nothing useful to recover */ }
child.unref();
return true;
}
/**
* Fallback stdin reader used when the async path drained stdin but spawn
* failed; hooks should call this instead of reading stdin directly when
* possible so the sync fallback still works after a failed detach.
*/
export async function readHookStdin() {
if (process.env.OPENVIKING_HOOK_STDIN_CACHE) {
const cached = process.env.OPENVIKING_HOOK_STDIN_CACHE;
delete process.env.OPENVIKING_HOOK_STDIN_CACHE;
return cached;
}
const chunks = [];
for await (const chunk of process.stdin) chunks.push(chunk);
return Buffer.concat(chunks).toString();
}