789 lines
29 KiB
Cheetah
789 lines
29 KiB
Cheetah
// caveman:native-pi — GENERATED by `caveman enable pi`.
|
|
process.env.CAVEMAN_PI_HOOK_CMD ??= "[\"{{ .chezmoi.homeDir }}/.npm-global/bin/caveman\"]";
|
|
// ../pi-extension/src/index.ts
|
|
import { readFileSync as readFileSync2 } from "node:fs";
|
|
import { homedir as homedir3 } from "node:os";
|
|
import { join as join4 } from "node:path";
|
|
import { Type } from "typebox";
|
|
|
|
// ../pi-extension/src/lifecycle.ts
|
|
import { execFile } from "node:child_process";
|
|
import { createHash } from "node:crypto";
|
|
import { homedir } from "node:os";
|
|
import { join as join2 } from "node:path";
|
|
|
|
// ../pi-extension/src/portable-command.ts
|
|
import { existsSync, readFileSync, statSync } from "node:fs";
|
|
import { dirname, extname, isAbsolute, join, resolve } from "node:path";
|
|
function parseWindowsNodeShim(source) {
|
|
for (const line of source.split(/\r?\n/)) {
|
|
if (!/(?:\bnode(?:\.exe)?\b|_prog)/i.test(line) || !/%\*/.test(line)) continue;
|
|
const match = line.match(/"%(?:dp0%|~dp0)\\([^"\r\n]+\.(?:cjs|mjs|js))"\s+%\*/i) ?? line.match(/"([A-Za-z]:[\\/][^"\r\n]+\.(?:cjs|mjs|js))"\s+%\*/i);
|
|
if (match) return match[1];
|
|
}
|
|
return null;
|
|
}
|
|
function envValue(env, name) {
|
|
const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
|
|
return key === void 0 ? void 0 : env[key];
|
|
}
|
|
function resolveWindowsCommand(command, env) {
|
|
const pathExt = envValue(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD";
|
|
const names = extname(command) ? [command] : pathExt.split(";").map((extension) => `${command}${extension.startsWith(".") ? extension : `.${extension}`}`);
|
|
if (isAbsolute(command) || /[\\/]/.test(command)) {
|
|
for (const name of names) if (existsSync(name)) return name;
|
|
return existsSync(command) ? command : void 0;
|
|
}
|
|
for (const directory of (envValue(env, "PATH") ?? "").split(";")) {
|
|
if (!directory) continue;
|
|
for (const name of names) {
|
|
const candidate = join(directory, name);
|
|
if (existsSync(candidate)) return candidate;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function portableInvocation(command, args, platform = process.platform, env = process.env) {
|
|
if (platform !== "win32") return { command, args: [...args] };
|
|
const executable = resolveWindowsCommand(command, env) ?? command;
|
|
if (!/\.(?:cmd|bat)$/i.test(executable)) return { command: executable, args: [...args] };
|
|
const stat = statSync(executable);
|
|
if (!stat.isFile() || stat.size > 256 * 1024) {
|
|
throw new Error(`cannot safely launch Windows command shim: ${executable}`);
|
|
}
|
|
const shimScript = parseWindowsNodeShim(readFileSync(executable, "utf8"));
|
|
if (!shimScript) {
|
|
throw new Error(`cannot safely launch non-Node Windows command shim: ${executable}; install a native .exe`);
|
|
}
|
|
const script = /^[A-Za-z]:[\\/]/.test(shimScript) ? shimScript : resolve(dirname(executable), ...shimScript.split(/[\\/]+/));
|
|
if (!statSync(script).isFile()) {
|
|
throw new Error(`Windows command shim target is missing: ${script}`);
|
|
}
|
|
return { command: process.execPath, args: [script, ...args] };
|
|
}
|
|
|
|
// ../pi-extension/src/protocol.ts
|
|
var MAX_CONTEXT_BYTES = 64 * 1024;
|
|
var MAX_MESSAGE_BYTES = 4 * 1024;
|
|
var MAX_OUTPUT_REPLACEMENT_BYTES = 2 * 1024 * 1024;
|
|
var MAX_RECOVERY_REF_BYTES = 1024;
|
|
var MAX_DECISION_ID_BYTES = 256;
|
|
var MAX_TOOL_OUTPUT_BYTES = 2 * 1024 * 1024;
|
|
function fits(value, max) {
|
|
return typeof value === "string" && Buffer.byteLength(value, "utf8") <= max;
|
|
}
|
|
function sanitizeHookResponse(raw) {
|
|
if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
|
|
const value = raw;
|
|
const out = {};
|
|
if (fits(value.context, MAX_CONTEXT_BYTES)) out.context = value.context;
|
|
if (fits(value.message, MAX_MESSAGE_BYTES)) out.message = value.message;
|
|
if (fits(value.output_replacement, MAX_OUTPUT_REPLACEMENT_BYTES)) out.output_replacement = value.output_replacement;
|
|
if (fits(value.recovery_ref, MAX_RECOVERY_REF_BYTES)) out.recovery_ref = value.recovery_ref;
|
|
if (fits(value.decision_id, MAX_DECISION_ID_BYTES)) out.decision_id = value.decision_id;
|
|
if (typeof value.action === "string") out.action = value.action;
|
|
const hso = value.hookSpecificOutput;
|
|
if (hso && typeof hso === "object" && !Array.isArray(hso)) {
|
|
const nested = hso;
|
|
const cleaned = {};
|
|
if (typeof nested.hookEventName === "string") cleaned.hookEventName = nested.hookEventName;
|
|
if (fits(nested.additionalContext, MAX_CONTEXT_BYTES)) cleaned.additionalContext = nested.additionalContext;
|
|
if (fits(nested.updatedToolOutput, MAX_OUTPUT_REPLACEMENT_BYTES)) cleaned.updatedToolOutput = nested.updatedToolOutput;
|
|
out.hookSpecificOutput = cleaned;
|
|
}
|
|
return out;
|
|
}
|
|
function additionalContextOf(response) {
|
|
const context = response?.hookSpecificOutput?.additionalContext ?? response?.context;
|
|
return context ? context : void 0;
|
|
}
|
|
function outputReplacementOf(response) {
|
|
const replacement = response?.hookSpecificOutput?.updatedToolOutput ?? response?.output_replacement;
|
|
return replacement ? replacement : void 0;
|
|
}
|
|
var ROUTES_BY_API = {
|
|
"anthropic-messages": "/w/pi",
|
|
"openai-completions": "/w/pi/openai/v1",
|
|
"openai-responses": "/w/pi/openai/v1",
|
|
"google-generative-ai": "/w/pi/v1beta"
|
|
};
|
|
function routeForApi(gateway, api) {
|
|
const path = api ? ROUTES_BY_API[api] : void 0;
|
|
return path ? joinUrl(gateway, path) : void 0;
|
|
}
|
|
function joinUrl(base, path) {
|
|
return `${base.replace(/\/+$/, "")}${path}`;
|
|
}
|
|
function isLoopbackUrl(url) {
|
|
try {
|
|
const host = new URL(url).hostname;
|
|
return host === "127.0.0.1" || host === "::1" || host === "[::1]" || host === "localhost";
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// ../pi-extension/src/lifecycle.ts
|
|
var HOOK_TIMEOUT_MS = 2e3;
|
|
var SESSION_START_TIMEOUT_MS = 6e3;
|
|
var HOOK_MAX_BUFFER = 2 * 1024 * 1024;
|
|
function resolveHookInvocations(env = process.env) {
|
|
const localBin = join2(env.CAVEMAN_HOME || join2(homedir(), ".caveman"), "bin", "caveman");
|
|
const candidates = [
|
|
{ command: "caveman", args: [] },
|
|
{ command: "cave", args: [] },
|
|
{ command: localBin, args: [] }
|
|
];
|
|
const stamped = env.CAVEMAN_PI_HOOK_CMD;
|
|
if (stamped) {
|
|
try {
|
|
const parsed = JSON.parse(stamped);
|
|
if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((part) => typeof part === "string" && part.length > 0)) {
|
|
candidates.unshift({ command: parsed[0], args: parsed.slice(1) });
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
return candidates;
|
|
}
|
|
var TRY_NEXT = "__caveman_try_next__";
|
|
var HookBridge = class {
|
|
invocations;
|
|
constructor(invocations = resolveHookInvocations()) {
|
|
this.invocations = invocations;
|
|
}
|
|
// call runs one native-hook event. Fail-open by contract: any spawn error,
|
|
// timeout, or unparseable output resolves to undefined.
|
|
async call(event, payload) {
|
|
const input = JSON.stringify({ event_name: event, surface: "cli", ...payload });
|
|
for (const invocation of this.invocations) {
|
|
const raw = await this.invoke(invocation, event, input);
|
|
if (raw === TRY_NEXT) continue;
|
|
if (raw === void 0 || !raw.trim()) return void 0;
|
|
try {
|
|
return sanitizeHookResponse(JSON.parse(raw));
|
|
} catch {
|
|
return void 0;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
invoke(invocation, event, input) {
|
|
return new Promise((resolve2) => {
|
|
let portable;
|
|
try {
|
|
portable = portableInvocation(invocation.command, [...invocation.args, "native-hook", "pi", event]);
|
|
} catch {
|
|
resolve2(TRY_NEXT);
|
|
return;
|
|
}
|
|
const child = execFile(
|
|
portable.command,
|
|
portable.args,
|
|
{ timeout: event === "SessionStart" ? SESSION_START_TIMEOUT_MS : HOOK_TIMEOUT_MS, maxBuffer: HOOK_MAX_BUFFER, encoding: "utf8" },
|
|
(error, stdout) => {
|
|
const timedOut = !!error && error.killed === true;
|
|
if (error && stdout === "") return resolve2(timedOut ? void 0 : TRY_NEXT);
|
|
resolve2(stdout);
|
|
}
|
|
);
|
|
child.stdin?.on("error", () => {
|
|
});
|
|
child.stdin?.end(input);
|
|
});
|
|
}
|
|
};
|
|
function promptDigest(prompt) {
|
|
return {
|
|
bytes: Buffer.byteLength(prompt, "utf8"),
|
|
sha256: `sha256:${createHash("sha256").update(prompt, "utf8").digest("hex")}`
|
|
};
|
|
}
|
|
function taskType(text) {
|
|
const lower = text.toLowerCase();
|
|
const has = (...terms) => terms.some((term) => lower.includes(term));
|
|
if (has("migration", "migrate", "schema change", "backfill", "rollback")) return "migration";
|
|
if (has("bug", "fix", "broken", "regression", "crash", "error", "incorrect")) return "bugfix";
|
|
if (has("investigate", "diagnose", "root cause", "why does", "trace")) return "investigation";
|
|
if (has("refactor", "restructure", "reorganize", "cleanup")) return "refactor";
|
|
if (has("review", "audit", "critique", "assess")) return "review";
|
|
if (has("verify", "verification", "prove", "validate", "check that")) return "verification";
|
|
if (has("build", "implement", "add", "create", "ship", "feature")) return "feature";
|
|
return "general";
|
|
}
|
|
var TASK_STOPWORDS = /* @__PURE__ */ new Set(["about", "after", "agent", "before", "build", "change", "code", "create", "from", "have", "help", "implement", "into", "make", "please", "project", "repository", "should", "spec", "task", "that", "then", "there", "these", "they", "this", "through", "user", "want", "what", "when", "where", "which", "with", "would", "your"]);
|
|
function taskTerms(text) {
|
|
const out = [];
|
|
const seen = /* @__PURE__ */ new Set();
|
|
for (const raw of text.match(/[A-Za-z][A-Za-z0-9_./-]{2,63}/g) ?? []) {
|
|
const term = raw.toLowerCase().replace(/^[-./]+|[-./]+$/g, "");
|
|
if (!term || term.includes("..") || TASK_STOPWORDS.has(term) || seen.has(term)) continue;
|
|
if (/^(?:sk|pk|rk|ghp|github_pat|xox[baprs]|akia)[-_]/i.test(term) || /^[a-z0-9_-]{40,}$/i.test(term)) continue;
|
|
seen.add(term);
|
|
out.push(term);
|
|
if (out.length === 12) break;
|
|
}
|
|
return out;
|
|
}
|
|
function taskContinuation(text) {
|
|
const prompt = text.trim().toLowerCase();
|
|
if (!prompt || prompt.length > 160 || prompt.split(/\s+/).length > 14) return false;
|
|
return /^(?:please\s+)?(?:continue|go ahead|keep going|proceed|do (?:it|that)|fix (?:it|that)|retry|try again|explain (?:it|that)|what do you mean|yes|yep|yeah|why\??|how\??)[.!?\s]*$/.test(prompt);
|
|
}
|
|
|
|
// ../pi-extension/src/provider.ts
|
|
var ProviderRouter = class {
|
|
pi;
|
|
notify;
|
|
gateway;
|
|
gateOpen = false;
|
|
overridden = /* @__PURE__ */ new Set();
|
|
applying = false;
|
|
warnedModels = /* @__PURE__ */ new Set();
|
|
constructor(pi, notify) {
|
|
this.pi = pi;
|
|
this.notify = notify;
|
|
}
|
|
// openGate is called once per session after the recovery gate held. Refuses
|
|
// non-loopback gateways: managed routing needs auth proof v1 does not carry.
|
|
async openGate(gateway, ctx) {
|
|
if (!isLoopbackUrl(gateway)) {
|
|
this.notify("Caveman: direct mode, no compression this session (gateway is not loopback)", "warning");
|
|
return;
|
|
}
|
|
this.gateway = gateway;
|
|
this.gateOpen = true;
|
|
await this.apply(ctx.model, ctx);
|
|
}
|
|
closeGate() {
|
|
this.gateOpen = false;
|
|
this.clearOverrides();
|
|
}
|
|
routing() {
|
|
return this.gateOpen && this.overridden.size > 0;
|
|
}
|
|
// apply routes one model's provider, or restores direct mode when the model
|
|
// has no verified route. Called from the gate and from model_select; the
|
|
// applying flag swallows the model_select echo of our own setModel call.
|
|
async apply(model, ctx) {
|
|
if (!this.gateOpen || this.applying || !this.gateway) return;
|
|
if (!model) return;
|
|
const route = routeForApi(this.gateway, model.api);
|
|
let oauth = true;
|
|
try {
|
|
oauth = ctx.modelRegistry.isUsingOAuth(model);
|
|
} catch {
|
|
}
|
|
if (!route || oauth) {
|
|
this.clearOverrides();
|
|
const key = `${model.provider}/${model.id}`;
|
|
if (!this.warnedModels.has(key)) {
|
|
this.warnedModels.add(key);
|
|
const reason = oauth ? "OAuth/subscription credentials are not routed" : `unsupported API "${model.api}"`;
|
|
this.notify(`Caveman: pass-through for ${key} (${reason}); no compression`, "warning");
|
|
}
|
|
return;
|
|
}
|
|
this.applying = true;
|
|
try {
|
|
for (const provider of this.overridden) {
|
|
if (provider !== model.provider) {
|
|
this.pi.unregisterProvider(provider);
|
|
this.overridden.delete(provider);
|
|
}
|
|
}
|
|
this.pi.registerProvider(model.provider, { baseUrl: route });
|
|
this.overridden.add(model.provider);
|
|
const refreshed = ctx.modelRegistry.find(model.provider, model.id);
|
|
if (!refreshed || !await this.pi.setModel(refreshed)) {
|
|
this.clearOverrides();
|
|
this.notify("Caveman: direct mode, no compression this session (model re-resolution failed)", "warning");
|
|
return;
|
|
}
|
|
} catch {
|
|
this.clearOverrides();
|
|
this.notify("Caveman: direct mode, no compression this session (provider override failed)", "warning");
|
|
} finally {
|
|
this.applying = false;
|
|
}
|
|
}
|
|
clearOverrides() {
|
|
for (const provider of this.overridden) {
|
|
try {
|
|
this.pi.unregisterProvider(provider);
|
|
} catch {
|
|
}
|
|
}
|
|
this.overridden.clear();
|
|
}
|
|
};
|
|
|
|
// ../pi-extension/src/recovery.ts
|
|
import { execFile as execFile2, spawn } from "node:child_process";
|
|
import { existsSync as existsSync2 } from "node:fs";
|
|
import { homedir as homedir2 } from "node:os";
|
|
import { delimiter, join as join3 } from "node:path";
|
|
var PROBE_TIMEOUT_MS = 2e3;
|
|
var CALL_TIMEOUT_MS = 3e4;
|
|
var INIT_TIMEOUT_MS = 2e3;
|
|
function resolveMcpBinary(env = process.env) {
|
|
const explicit = env.CAVEMAN_MCP_BIN?.trim();
|
|
if (explicit) return explicit;
|
|
const name = process.platform === "win32" ? "caveman-mcp.exe" : "caveman-mcp";
|
|
for (const dir of (env.PATH ?? "").split(delimiter)) {
|
|
if (dir && existsSync2(join3(dir, name))) return join3(dir, name);
|
|
}
|
|
const local = join3(env.CAVEMAN_HOME || join3(homedir2(), ".caveman"), "bin", name);
|
|
return existsSync2(local) ? local : void 0;
|
|
}
|
|
var RecoveryClient = class {
|
|
binary;
|
|
child;
|
|
initialized = false;
|
|
probed;
|
|
ensuring;
|
|
nextId = 1;
|
|
pending = /* @__PURE__ */ new Map();
|
|
buffer = "";
|
|
disposed = false;
|
|
constructor(binary = resolveMcpBinary()) {
|
|
this.binary = binary;
|
|
}
|
|
// ensure probes the binary once and brings up an initialized child. Returns
|
|
// false (never throws) when recovery cannot hold — the caller passes through.
|
|
async ensure() {
|
|
if (this.disposed || !this.binary) return false;
|
|
if (this.child && this.initialized) return true;
|
|
this.ensuring ??= this.bringUp().finally(() => {
|
|
this.ensuring = void 0;
|
|
});
|
|
return this.ensuring;
|
|
}
|
|
async bringUp() {
|
|
if (this.probed === void 0) this.probed = await this.probe();
|
|
if (!this.probed || this.disposed) return false;
|
|
if (this.child && this.initialized) return true;
|
|
return this.start();
|
|
}
|
|
ready() {
|
|
return Boolean(this.child && this.initialized && !this.disposed);
|
|
}
|
|
async retrieve(handle, query, signal) {
|
|
if (!await this.ensure()) {
|
|
return { text: JSON.stringify({ error: "cave_recovery_unavailable", message: "caveman-mcp is not available this session" }), isError: true };
|
|
}
|
|
try {
|
|
const result = await this.call("tools/call", {
|
|
name: "caveman_retrieve",
|
|
arguments: { recovery_handle: handle, ...query ? { query } : {} }
|
|
}, signal);
|
|
const value = result;
|
|
const text = (value.content ?? []).map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("");
|
|
return { text, isError: Boolean(value.isError) };
|
|
} catch (error) {
|
|
return { text: JSON.stringify({ error: "cave_recovery_transport", message: error.message }), isError: true };
|
|
}
|
|
}
|
|
dispose() {
|
|
this.disposed = true;
|
|
const child = this.child;
|
|
this.child = void 0;
|
|
this.initialized = false;
|
|
for (const [, entry] of this.pending) {
|
|
clearTimeout(entry.timer);
|
|
entry.reject(new Error("recovery client disposed"));
|
|
}
|
|
this.pending.clear();
|
|
this.stop(child);
|
|
void this.ensuring?.then(() => {
|
|
const late = this.child;
|
|
this.child = void 0;
|
|
this.stop(late);
|
|
});
|
|
}
|
|
// resolveMcpBinary appends .exe on win32, but CAVEMAN_MCP_BIN is an operator
|
|
// override that can name anything — including a .cmd shim, which execFile
|
|
// and spawn both refuse with EFTYPE. Route through the same resolver the hook
|
|
// bridge uses so the override is as spawnable as the default. Fail-closed:
|
|
// callers treat a throw as "recovery cannot hold" and pass through.
|
|
invocation(args) {
|
|
try {
|
|
return portableInvocation(this.binary, args);
|
|
} catch {
|
|
return void 0;
|
|
}
|
|
}
|
|
probe() {
|
|
return new Promise((resolve2) => {
|
|
const portable = this.invocation(["version", "--json"]);
|
|
if (!portable) return resolve2(false);
|
|
execFile2(portable.command, portable.args, { timeout: PROBE_TIMEOUT_MS, encoding: "utf8" }, (error, stdout) => {
|
|
if (error) return resolve2(false);
|
|
try {
|
|
const parsed = JSON.parse(stdout);
|
|
resolve2(Array.isArray(parsed?.capabilities) && parsed.capabilities.includes("mcp_recovery"));
|
|
} catch {
|
|
resolve2(false);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
async start() {
|
|
let child;
|
|
try {
|
|
const portable = this.invocation([]);
|
|
if (!portable) return false;
|
|
child = spawn(portable.command, portable.args, { stdio: ["pipe", "pipe", "ignore"] });
|
|
} catch {
|
|
return false;
|
|
}
|
|
this.child = child;
|
|
this.initialized = false;
|
|
this.buffer = "";
|
|
child.on("error", () => this.onChildGone(child));
|
|
child.on("exit", () => this.onChildGone(child));
|
|
child.stdin?.on("error", () => this.onChildGone(child));
|
|
child.stdout?.setEncoding("utf8");
|
|
child.stdout?.on("data", (chunk) => this.onData(chunk));
|
|
try {
|
|
await this.call("initialize", {
|
|
protocolVersion: "2024-11-05",
|
|
capabilities: {},
|
|
clientInfo: { name: "caveman-pi-extension", version: "0.1.0" }
|
|
}, void 0, INIT_TIMEOUT_MS);
|
|
this.notify("notifications/initialized");
|
|
if (this.disposed) {
|
|
this.onChildGone(child);
|
|
this.stop(child);
|
|
return false;
|
|
}
|
|
this.initialized = true;
|
|
return true;
|
|
} catch {
|
|
this.onChildGone(child);
|
|
this.stop(child);
|
|
return false;
|
|
}
|
|
}
|
|
stop(child) {
|
|
if (!child) return;
|
|
try {
|
|
child.stdin?.end();
|
|
} catch {
|
|
}
|
|
const term = setTimeout(() => {
|
|
try {
|
|
child.kill("SIGTERM");
|
|
} catch {
|
|
}
|
|
}, 500);
|
|
const kill = setTimeout(() => {
|
|
try {
|
|
child.kill("SIGKILL");
|
|
} catch {
|
|
}
|
|
}, 2e3);
|
|
child.once("exit", () => {
|
|
clearTimeout(term);
|
|
clearTimeout(kill);
|
|
});
|
|
}
|
|
onChildGone(child) {
|
|
if (this.child !== child) return;
|
|
this.child = void 0;
|
|
this.initialized = false;
|
|
for (const [, entry] of this.pending) {
|
|
clearTimeout(entry.timer);
|
|
entry.reject(new Error("caveman-mcp exited"));
|
|
}
|
|
this.pending.clear();
|
|
}
|
|
onData(chunk) {
|
|
this.buffer += chunk;
|
|
let newline;
|
|
while ((newline = this.buffer.indexOf("\n")) !== -1) {
|
|
const line = this.buffer.slice(0, newline).trim();
|
|
this.buffer = this.buffer.slice(newline + 1);
|
|
if (!line) continue;
|
|
let message;
|
|
try {
|
|
message = JSON.parse(line);
|
|
} catch {
|
|
continue;
|
|
}
|
|
if (typeof message.id !== "number") continue;
|
|
const entry = this.pending.get(message.id);
|
|
if (!entry) continue;
|
|
this.pending.delete(message.id);
|
|
clearTimeout(entry.timer);
|
|
if (message.error) entry.reject(new Error(message.error.message || "caveman-mcp error"));
|
|
else entry.resolve(message.result);
|
|
}
|
|
}
|
|
call(method, params, signal, timeoutMs = CALL_TIMEOUT_MS) {
|
|
const child = this.child;
|
|
if (!child?.stdin?.writable) return Promise.reject(new Error("caveman-mcp not running"));
|
|
if (signal?.aborted) return Promise.reject(new Error("retrieve cancelled"));
|
|
const id = this.nextId++;
|
|
return new Promise((resolve2, reject) => {
|
|
const timer = setTimeout(() => {
|
|
this.pending.delete(id);
|
|
reject(new Error(`caveman-mcp ${method} timed out`));
|
|
}, timeoutMs);
|
|
timer.unref?.();
|
|
const onAbort = () => {
|
|
this.pending.delete(id);
|
|
clearTimeout(timer);
|
|
reject(new Error("retrieve cancelled"));
|
|
};
|
|
signal?.addEventListener("abort", onAbort, { once: true });
|
|
this.pending.set(id, {
|
|
resolve: (value) => {
|
|
signal?.removeEventListener("abort", onAbort);
|
|
resolve2(value);
|
|
},
|
|
reject: (error) => {
|
|
signal?.removeEventListener("abort", onAbort);
|
|
reject(error);
|
|
},
|
|
timer
|
|
});
|
|
child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n", (error) => {
|
|
if (error) {
|
|
this.pending.delete(id);
|
|
clearTimeout(timer);
|
|
signal?.removeEventListener("abort", onAbort);
|
|
reject(error);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
notify(method) {
|
|
try {
|
|
this.child?.stdin?.write(JSON.stringify({ jsonrpc: "2.0", method }) + "\n");
|
|
} catch {
|
|
}
|
|
}
|
|
};
|
|
|
|
// ../pi-extension/src/tool-output.ts
|
|
async function shrinkToolResult(bridge, sessionId, event) {
|
|
const text = event.content.map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("");
|
|
if (!text) return void 0;
|
|
if (Buffer.byteLength(text, "utf8") > MAX_TOOL_OUTPUT_BYTES) return void 0;
|
|
const response = await bridge.call(event.isError ? "PostToolUseFailure" : "PostToolUse", {
|
|
session_id: sessionId,
|
|
tool_name: event.toolName,
|
|
tool_input: event.input,
|
|
tool_output: text
|
|
});
|
|
const replacement = outputReplacementOf(response);
|
|
if (!replacement) return void 0;
|
|
return { content: [{ type: "text", text: replacement }, ...event.content.filter((block) => block.type !== "text")] };
|
|
}
|
|
|
|
// ../pi-extension/src/index.ts
|
|
var HEALTH_TIMEOUT_MS = 750;
|
|
var RECOVERY_TOOL = "caveman_retrieve";
|
|
function cavemanHome() {
|
|
return process.env.CAVEMAN_HOME || join4(homedir3(), ".caveman");
|
|
}
|
|
function gatewayUrl() {
|
|
const env = process.env.CAVE_GATEWAY_URL?.trim();
|
|
if (env) return env;
|
|
try {
|
|
const config = JSON.parse(readFileSync2(join4(homedir3(), ".caveman-cloud", "config.json"), "utf8"));
|
|
if (typeof config.gatewayUrl === "string" && config.gatewayUrl) return config.gatewayUrl;
|
|
} catch {
|
|
}
|
|
return "http://127.0.0.1:8787";
|
|
}
|
|
function runStateRecoveryViaMcp(gateway) {
|
|
let port;
|
|
try {
|
|
const url = new URL(gateway);
|
|
port = url.port || (url.protocol === "https:" ? "443" : "80");
|
|
} catch {
|
|
return void 0;
|
|
}
|
|
try {
|
|
const state = JSON.parse(readFileSync2(join4(cavemanHome(), "run", `${port}.json`), "utf8"));
|
|
if (state?.schema !== "caveman.proxy.run.v1") return void 0;
|
|
if (typeof state.pid !== "number" || typeof state.instance_token !== "string") return void 0;
|
|
if (state.owner !== "wrap" && state.owner !== "start") return void 0;
|
|
try {
|
|
process.kill(state.pid, 0);
|
|
} catch {
|
|
return void 0;
|
|
}
|
|
return Boolean(state.recovery_via_mcp);
|
|
} catch {
|
|
return void 0;
|
|
}
|
|
}
|
|
async function proxyAliveOnce(gateway) {
|
|
const controller = new AbortController();
|
|
const timer = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
|
|
try {
|
|
const response = await fetch(`${gateway.replace(/\/+$/, "")}/health/live`, { signal: controller.signal });
|
|
await response.body?.cancel();
|
|
return response.ok;
|
|
} catch {
|
|
return false;
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
async function proxyAlive(gateway) {
|
|
for (let attempt = 0; attempt < 3; attempt++) {
|
|
if (await proxyAliveOnce(gateway)) return true;
|
|
await new Promise((resolve2) => setTimeout(resolve2, 300));
|
|
}
|
|
return false;
|
|
}
|
|
function index_default(pi) {
|
|
const bridge = new HookBridge();
|
|
const recovery = new RecoveryClient();
|
|
let router;
|
|
let sessionId = "default";
|
|
let coreContext;
|
|
let pendingContext = [];
|
|
let pendingBytes = 0;
|
|
let gateDone = false;
|
|
const notify = (ctx, message, kind) => {
|
|
if (ctx?.hasUI) ctx.ui.notify(message, kind);
|
|
else process.stderr.write(`${message}
|
|
`);
|
|
};
|
|
const debug = (message) => {
|
|
if (process.env.CAVEMAN_PI_DEBUG === "1") process.stderr.write(`[caveman-pi] ${message}
|
|
`);
|
|
};
|
|
const guardedBase = (fn, label = fn.name || "handler") => (async (...args) => {
|
|
try {
|
|
debug(`enter ${label}`);
|
|
const result = await fn(...args);
|
|
debug(`exit ${label}`);
|
|
return result;
|
|
} catch (error) {
|
|
process.stderr.write(`caveman pi extension: ${error.message}
|
|
`);
|
|
return void 0;
|
|
}
|
|
});
|
|
const GUARD = (label) => (fn) => guardedBase(fn, label);
|
|
const GUARD_session_start = GUARD("session_start");
|
|
const GUARD_model_select = GUARD("model_select");
|
|
const GUARD_before_agent_start = GUARD("before_agent_start");
|
|
const GUARD_turn_start = GUARD("turn_start");
|
|
const GUARD_turn_end = GUARD("turn_end");
|
|
const GUARD_tool_call = GUARD("tool_call");
|
|
const GUARD_tool_result = GUARD("tool_result");
|
|
const GUARD_session_before_compact = GUARD("session_before_compact");
|
|
const GUARD_session_compact = GUARD("session_compact");
|
|
const GUARD_session_shutdown = GUARD("session_shutdown");
|
|
pi.registerTool({
|
|
name: RECOVERY_TOOL,
|
|
label: "Retrieve compressed context",
|
|
description: "Recover exact original content from a Caveman recovery handle.",
|
|
parameters: Type.Object({
|
|
recovery_handle: Type.String({ description: "Exact ccr_ handle returned by Caveman or copied from a <<ccr:HANDLE>> marker." }),
|
|
query: Type.Optional(Type.String({ description: "One broad description covering every detail needed from this handle." }))
|
|
}),
|
|
async execute(_toolCallId, params, signal) {
|
|
const result = await recovery.retrieve(params.recovery_handle, params.query, signal);
|
|
if (result.isError) throw new Error(result.text || "caveman_retrieve failed");
|
|
return { content: [{ type: "text", text: result.text }], details: { recovery_handle: params.recovery_handle } };
|
|
}
|
|
});
|
|
pi.on("session_start", GUARD_session_start(async (_event, ctx) => {
|
|
router ??= new ProviderRouter(pi, (message, kind) => notify(ctx, message, kind));
|
|
gateDone = false;
|
|
coreContext = void 0;
|
|
pendingContext = [];
|
|
pendingBytes = 0;
|
|
try {
|
|
sessionId = ctx.sessionManager.getSessionId() || "default";
|
|
} catch {
|
|
sessionId = "default";
|
|
}
|
|
const start = await bridge.call("SessionStart", { session_id: sessionId });
|
|
coreContext = additionalContextOf(start);
|
|
if (!start) {
|
|
gateDone = true;
|
|
notify(ctx, "Caveman: direct mode, no compression this session (caveman native runtime unreachable)", "warning");
|
|
return;
|
|
}
|
|
const gateway = gatewayUrl();
|
|
const alive = await proxyAlive(gateway);
|
|
const published = runStateRecoveryViaMcp(gateway);
|
|
const recoveryReady = alive ? await recovery.ensure() : false;
|
|
gateDone = true;
|
|
if (!alive || published === void 0) {
|
|
notify(ctx, "Caveman: direct mode, no compression this session (local proxy not running)", "warning");
|
|
return;
|
|
}
|
|
if (!published || !recoveryReady) {
|
|
notify(ctx, "Caveman: direct mode, no compression this session (recovery not available \u2014 run `caveman doctor pi`)", "warning");
|
|
return;
|
|
}
|
|
await router.openGate(gateway, ctx);
|
|
}));
|
|
pi.on("model_select", GUARD_model_select(async (event, ctx) => {
|
|
if (gateDone) await router?.apply(event.model, ctx);
|
|
}));
|
|
pi.on("before_agent_start", GUARD_before_agent_start(async (event, ctx) => {
|
|
const response = await bridge.call("UserPromptSubmit", {
|
|
session_id: sessionId,
|
|
model: ctx.model?.id,
|
|
provider: ctx.model?.provider,
|
|
prompt: promptDigest(event.prompt),
|
|
task_type: taskType(event.prompt),
|
|
task_terms: taskTerms(event.prompt),
|
|
task_continuation: taskContinuation(event.prompt)
|
|
});
|
|
const dynamic = [additionalContextOf(response), ...pendingContext].filter(Boolean);
|
|
pendingContext = [];
|
|
pendingBytes = 0;
|
|
if (!coreContext && dynamic.length === 0) return void 0;
|
|
const parts = [event.systemPrompt, coreContext, ...dynamic].filter(Boolean);
|
|
return { systemPrompt: parts.join("\n\n") };
|
|
}));
|
|
pi.on("turn_start", GUARD_turn_start(() => {
|
|
void bridge.call("ModelBefore", { session_id: sessionId });
|
|
}));
|
|
pi.on("turn_end", GUARD_turn_end(async () => {
|
|
await bridge.call("ModelAfter", { session_id: sessionId });
|
|
void bridge.call("Stop", { session_id: sessionId });
|
|
}));
|
|
pi.on("tool_call", GUARD_tool_call(async (event) => {
|
|
const response = await bridge.call("PreToolUse", {
|
|
session_id: sessionId,
|
|
tool_name: event.toolName,
|
|
tool_input: event.input
|
|
});
|
|
const context = additionalContextOf(response);
|
|
const bytes = context ? Buffer.byteLength(context, "utf8") : 0;
|
|
if (context && pendingBytes + bytes <= MAX_CONTEXT_BYTES) {
|
|
pendingContext.push(context);
|
|
pendingBytes += bytes;
|
|
}
|
|
}));
|
|
pi.on("tool_result", GUARD_tool_result((event) => event.toolName === RECOVERY_TOOL ? void 0 : shrinkToolResult(bridge, sessionId, event)));
|
|
pi.on("session_before_compact", GUARD_session_before_compact(() => {
|
|
void bridge.call("PreCompact", { session_id: sessionId });
|
|
}));
|
|
pi.on("session_compact", GUARD_session_compact(async () => {
|
|
const response = await bridge.call("PostCompact", { session_id: sessionId });
|
|
const context = additionalContextOf(response);
|
|
if (context) coreContext = context;
|
|
}));
|
|
pi.on("session_shutdown", GUARD_session_shutdown(async () => {
|
|
await bridge.call("SessionEnd", { session_id: sessionId });
|
|
router?.closeGate();
|
|
recovery.dispose();
|
|
}));
|
|
}
|
|
export {
|
|
index_default as default
|
|
};
|