@dougbots/avenor-core 0.1.0 → 0.2.1

package/README.md

@@ -44,11 +44,13 @@ const result = await spawnTool({
   prompt: 'Write a function to reverse a string',
   label: 'reverse-string',
   model: 'claude-sonnet-4',
+  backend: 'opencode-http',
+  serverUrl: 'http://127.0.0.1:4096',
 })
 // { run_id: '...', label: 'reverse-string', supervisor_id: '/path/to/socket' }
 ```
 
-Accepts `agent`, `prompt`, `promptFile`, `label`, `dir`, `timeout`, `model`, `sessionId`, and `supervisorId` (to target a specific socket).
+Accepts `agent`, `prompt`, `promptFile`, `label`, `dir`, `timeout`, `model`, `backend`, `serverUrl`, `sessionId`, and `supervisorId` (to target a specific socket).
 
 ### `statusTool`
 

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-DagQIDKB.js";
 import * as net from "node:net";
 
 //#region src/client.d.ts
@@ -15,6 +16,8 @@ interface SpawnParams {
   label?: string;
   timeout?: number;
   model?: string;
+  backend?: string;
+  server_url?: string;
   session_id?: string;
   sentinel_file?: string;
   on_event?: string;
@@ -98,6 +101,8 @@ declare function spawnTool(args: {
   dir?: string;
   timeout?: string;
   model?: string;
+  backend?: string;
+  serverUrl?: string;
   sessionId?: string;
   supervisorId?: string;
 }): Promise<{
@@ -157,11 +162,13 @@ declare function eventsTool(args: {
   types?: string[];
   limit?: number;
   supervisorId?: string;
-}): Promise<Array<{
-  type: string;
-  ts: number;
-  [key: string]: unknown;
-}>>;
+}): Promise<{
+  events: Array<{
+    type: string;
+    ts: number;
+    [key: string]: unknown;
+  }>;
+}>;
 //#endregion
 //#region src/tools/shutdown.d.ts
 declare function shutdownTool(args: {
@@ -172,4 +179,4 @@ declare function shutdownTool(args: {
   cleaned_up: string[];
 }>;
 //#endregion
-export { type Client, type Event, type RunInfo, type SpawnParams, type StatusResult, Supervisor, type SupervisorOptions, answerPermissionTool, dial, eventsTool, findAvenorBinary, followUpTool, shutdownTool, spawnTool, statusTool };
+export { type Client, type Event, type RunInfo, type SpawnParams, type StatusResult, Supervisor, type SupervisorOptions, answerPermissionTool, dial, eventsTool, findAvenorBinary, followUpTool, getInstallDir, getVersion, installerBinaryPath, shutdownTool, spawnTool, statusTool };

package/dist/index.js

@@ -1,3 +1,4 @@
+import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-C7QXqbJO.js";
 import * as net from "node:net";
 import * as readline from "node:readline";
 import { execSync, spawn } from "node:child_process";
@@ -222,12 +223,20 @@ function findAvenorBinary() {
 		throw new Error(`AVENOR_BIN path not executable: ${envBin}`);
 	}
 	try {
-		const binPath = execSync("which avenor", { encoding: "utf-8" }).trim();
+		const binPath = execSync("which avenor", {
+			encoding: "utf-8",
+			env: process.env
+		}).trim();
 		if (binPath) {
 			fs.accessSync(binPath, fs.constants.X_OK);
 			return binPath;
 		}
 	} catch {}
+	try {
+		const installPath = installerBinaryPath();
+		fs.accessSync(installPath, fs.constants.X_OK);
+		return installPath;
+	} catch {}
 	const homeBin = path.join(os.homedir(), ".botfiles", "bin", "avenor");
 	try {
 		fs.accessSync(homeBin, fs.constants.X_OK);
@@ -443,12 +452,33 @@ function validateSupervisorSocketPath(supervisorId) {
 	return canonical;
 }
 //#endregion
+//#region src/tools/get-supervisor-client.ts
+async function getSupervisorClient(supervisorId) {
+	const id = validateSupervisorSocketPath(supervisorId);
+	if (Supervisor.isCurrentInstance(id)) {
+		const sup = Supervisor.currentInstance();
+		if (!sup) throw new Error(`Supervisor.isCurrentInstance() returned true but currentInstance() is null (id: ${id})`);
+		return {
+			client: sup.getClient(),
+			isSingleton: true,
+			sup,
+			supervisorId: id
+		};
+	}
+	return {
+		client: await dial(id),
+		isSingleton: false,
+		sup: null,
+		supervisorId: id
+	};
+}
+//#endregion
 //#region src/tools/spawn.ts
 async function spawnTool(args) {
 	const runId = crypto.randomUUID();
 	const label = args.label ?? runId;
 	if (args.supervisorId) {
-		const client = await dial(validateSupervisorSocketPath(args.supervisorId));
+		const { client, isSingleton, supervisorId } = await getSupervisorClient(args.supervisorId);
 		const { sentinelPath, eventLogPath } = ensureRunPaths(runId);
 		try {
 			return {
@@ -460,15 +490,17 @@ async function spawnTool(args) {
 					dir: args.dir,
 					timeout: args.timeout !== void 0 ? validateTimeout(args.timeout) : void 0,
 					model: args.model,
+					backend: args.backend,
+					server_url: args.serverUrl,
 					session_id: args.sessionId,
 					sentinel_file: sentinelPath,
 					on_event: eventLogPath
 				})).runtime_id ?? runId,
 				label,
-				supervisor_id: args.supervisorId
+				supervisor_id: supervisorId
 			};
 		} finally {
-			client.close();
+			if (!isSingleton) client.close();
 		}
 	}
 	const sup = await Supervisor.get();
@@ -480,6 +512,8 @@ async function spawnTool(args) {
 		dir: args.dir,
 		timeout: args.timeout !== void 0 ? validateTimeout(args.timeout) : void 0,
 		model: args.model,
+		backend: args.backend,
+		server_url: args.serverUrl,
 		session_id: args.sessionId
 	});
 	return {
@@ -574,7 +608,7 @@ async function buildRunStatus(client, runInfo, liveStatus) {
 }
 async function statusTool(args) {
 	if (args.supervisorId) {
-		const client = await dial(validateSupervisorSocketPath(args.supervisorId));
+		const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
 		try {
 			if (args.runId) {
 				validateRunId(args.runId);
@@ -612,19 +646,46 @@ async function statusTool(args) {
 				session_id: entry.session_id
 			}));
 		} finally {
-			client.close();
+			if (!isSingleton) client.close();
 		}
 	}
 	const sup = await Supervisor.get();
 	const client = sup.getClient();
 	if (args.runId) {
 		const runInfo = findRunByLabel$3(sup, args.runId);
-		if (!runInfo) throw new Error(`run not found: ${args.runId}`);
+		if (runInfo) {
+			let liveStatus = null;
+			if (runInfo.runtimeId) try {
+				liveStatus = await client.status(runInfo.runtimeId);
+			} catch {}
+			return buildRunStatus(client, runInfo, liveStatus);
+		}
+		validateRunId(args.runId);
 		let liveStatus = null;
-		if (runInfo.runtimeId) try {
-			liveStatus = await client.status(runInfo.runtimeId);
+		try {
+			liveStatus = await client.status(args.runId);
 		} catch {}
-		return buildRunStatus(client, runInfo, liveStatus);
+		const sentinelPath = path.join(runsRoot(), args.runId, "sentinel.done");
+		let sentinel = null;
+		if (await sentinelExists(sentinelPath)) sentinel = await parseSentinel$1(sentinelPath);
+		return {
+			run_id: args.runId,
+			label: args.runId,
+			status: translateStatus(liveStatus?.phase ?? liveStatus?.status ?? "running", sentinel),
+			phase: liveStatus?.phase,
+			phase_label: liveStatus?.phase_label,
+			session_id: sentinel?.SESSION ?? liveStatus?.session_id ?? void 0,
+			stop_reason: sentinel?._status ?? void 0,
+			pending_permission: liveStatus?.pending_permission ? {
+				request_id: liveStatus.pending_permission.request_id ?? "",
+				description: liveStatus.pending_permission.description ?? "",
+				options: Array.isArray(liveStatus.pending_permission.options) ? liveStatus.pending_permission.options.map((o) => ({
+					option_id: o.option_id ?? "",
+					label: o.label ?? "",
+					kind: o.kind ?? ""
+				})) : []
+			} : void 0
+		};
 	}
 	const list = await client.list();
 	const results = [];
@@ -659,12 +720,15 @@ async function answerPermissionTool(args) {
 	let client;
 	let sup = null;
 	let requestId = args.requestId;
-	if (args.supervisorId) client = await dial(validateSupervisorSocketPath(args.supervisorId));
+	let supervisorId;
+	let isSingleton = false;
+	if (args.supervisorId) ({client, isSingleton, sup, supervisorId} = await getSupervisorClient(args.supervisorId));
 	else {
 		sup = await Supervisor.get();
 		client = sup.getClient();
 	}
 	try {
+		validateRunId(args.runId);
 		const runtimeId = (sup ? findRunByLabel$2(sup, args.runId) : void 0)?.runtimeId ?? args.runId;
 		if (!requestId) {
 			const pp = (await client.status(runtimeId))?.pending_permission;
@@ -674,7 +738,7 @@ async function answerPermissionTool(args) {
 		await client.answerPermission(runtimeId, requestId, args.optionId);
 		return { ok: true };
 	} finally {
-		if (args.supervisorId) client.close();
+		if (supervisorId && !isSingleton) client.close();
 	}
 }
 //#endregion
@@ -705,7 +769,7 @@ async function parseSentinel(filePath) {
 }
 async function followUpTool(args) {
 	if (args.supervisorId) {
-		const client = await dial(validateSupervisorSocketPath(args.supervisorId));
+		const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
 		try {
 			validateRunId(args.runId);
 			let liveStatus = null;
@@ -731,7 +795,7 @@ async function followUpTool(args) {
 				label: followUpLabel
 			};
 		} finally {
-			client.close();
+			if (!isSingleton) client.close();
 		}
 	}
 	const sup = await Supervisor.get();
@@ -783,7 +847,7 @@ async function eventsTool(args) {
 			await handle.close();
 		}
 	} catch {
-		return [];
+		return { events: [] };
 	}
 	const lines = raw.split("\n").filter((line) => line.trim());
 	let events = [];
@@ -792,7 +856,7 @@ async function eventsTool(args) {
 	} catch {}
 	if (args.types && args.types.length > 0) events = events.filter((e) => args.types.includes(e.type ?? e.event ?? ""));
 	if (events.length > limit) events = events.slice(events.length - limit);
-	return events;
+	return { events };
 }
 //#endregion
 //#region src/tools/shutdown.ts
@@ -851,4 +915,4 @@ async function shutdownTool(args) {
 	};
 }
 //#endregion
-export { Supervisor, answerPermissionTool, dial, eventsTool, findAvenorBinary, followUpTool, shutdownTool, spawnTool, statusTool };
+export { Supervisor, answerPermissionTool, dial, eventsTool, findAvenorBinary, followUpTool, getInstallDir, getVersion, installerBinaryPath, shutdownTool, spawnTool, statusTool };

package/dist/install-path-C7QXqbJO.js

@@ -0,0 +1,30 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+//#region src/install-path.ts
+const SEMVER_RE = /^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?$/;
+function getVersion(packageJsonPath) {
+	const envVer = process.env.AVENOR_VERSION;
+	if (envVer) {
+		if (!SEMVER_RE.test(envVer)) throw new Error(`Invalid AVENOR_VERSION: ${envVer}. Must be a semver string like 1.2.3`);
+		return envVer;
+	}
+	const pkgVer = process.env.npm_package_version;
+	if (pkgVer) {
+		if (!SEMVER_RE.test(pkgVer)) throw new Error(`Invalid npm_package_version: ${pkgVer}. Must be a semver string like 1.2.3`);
+		return pkgVer;
+	}
+	const pkgPath = packageJsonPath ?? new URL("../package.json", import.meta.url);
+	const v = JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+	if (!SEMVER_RE.test(v)) throw new Error(`Invalid package version: ${v}. Must be a semver string like 1.2.3`);
+	return v;
+}
+function getInstallDir(version) {
+	if (process.env.AVENOR_INSTALL_DIR) return process.env.AVENOR_INSTALL_DIR;
+	return path.join(os.homedir(), ".cache", "avenor", "bin", "avenor", version);
+}
+function installerBinaryPath(version = getVersion()) {
+	return path.join(getInstallDir(version), "avenor");
+}
+//#endregion
+export { getVersion as n, installerBinaryPath as r, getInstallDir as t };

package/dist/install-path-DagQIDKB.d.ts

@@ -0,0 +1,6 @@
+//#region src/install-path.d.ts
+declare function getVersion(packageJsonPath?: string): string;
+declare function getInstallDir(version: string): string;
+declare function installerBinaryPath(version?: string): string;
+//#endregion
+export { getVersion as n, installerBinaryPath as r, getInstallDir as t };

package/dist/postinstall.d.ts

@@ -0,0 +1,9 @@
+import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-DagQIDKB.js";
+
+//#region src/postinstall.d.ts
+declare function platformMapping(platform: string, arch: string): string | null;
+declare function verifyChecksum(buffer: Buffer, expectedHash: string): boolean;
+declare function parseChecksums(content: string, assetName: string): string | null;
+declare function postinstall(fetchFn?: typeof globalThis.fetch, platform?: string, arch?: string): Promise<void>;
+//#endregion
+export { getInstallDir, getVersion, installerBinaryPath, parseChecksums, platformMapping, postinstall, verifyChecksum };

package/dist/postinstall.js

@@ -0,0 +1,95 @@
+import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-C7QXqbJO.js";
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as crypto from "node:crypto";
+//#region src/postinstall.ts
+function platformMapping(platform, arch) {
+	return {
+		"darwin/arm64": "avenor_darwin_arm64",
+		"darwin/x64": "avenor_darwin_amd64",
+		"linux/x64": "avenor_linux_amd64",
+		"linux/arm64": "avenor_linux_arm64"
+	}[`${platform}/${arch}`] ?? null;
+}
+function verifyChecksum(buffer, expectedHash) {
+	return crypto.createHash("sha256").update(buffer).digest("hex") === expectedHash;
+}
+function parseChecksums(content, assetName) {
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split(/\s+/);
+		if (parts.length >= 2 && parts[1] === assetName) return parts[0];
+	}
+	return null;
+}
+async function postinstall(fetchFn = globalThis.fetch, platform, arch) {
+	const envBin = process.env.AVENOR_BIN;
+	if (envBin) try {
+		fs.accessSync(envBin, fs.constants.X_OK);
+		return;
+	} catch {}
+	try {
+		const whichBin = execSync("which avenor", {
+			encoding: "utf-8",
+			env: process.env
+		}).trim();
+		if (whichBin) try {
+			fs.accessSync(whichBin, fs.constants.X_OK);
+			return;
+		} catch {}
+	} catch {}
+	if (process.env.AVENOR_SKIP_DOWNLOAD === "1") {
+		console.warn("[avenor-postinstall] AVENOR_SKIP_DOWNLOAD=1, skipping download. Binary may not be available.");
+		return;
+	}
+	const plat = platform ?? process.platform;
+	const a = arch ?? process.arch;
+	const asset = platformMapping(plat, a);
+	if (!asset) {
+		console.warn(`[avenor-postinstall] Unsupported platform: ${plat}/${a}`);
+		return;
+	}
+	const version = getVersion();
+	const installDir = getInstallDir(version);
+	const binaryPath = installerBinaryPath(version);
+	const url = `https://github.com/sdougbrown/avenor/releases/download/v${version}/${asset}`;
+	try {
+		fs.mkdirSync(installDir, {
+			recursive: true,
+			mode: 448
+		});
+		const response = await fetchFn(url);
+		if (!response.ok) {
+			console.warn(`[avenor-postinstall] Download failed: HTTP ${response.status} from ${url}`);
+			return;
+		}
+		const buffer = Buffer.from(await response.arrayBuffer());
+		const checksumsUrl = `https://github.com/sdougbrown/avenor/releases/download/v${version}/checksums.txt`;
+		try {
+			const checksumsResponse = await fetchFn(checksumsUrl);
+			if (checksumsResponse.ok) {
+				const expectedHash = parseChecksums(await checksumsResponse.text(), asset);
+				if (expectedHash) {
+					if (!verifyChecksum(buffer, expectedHash)) {
+						console.warn(`[avenor-postinstall] Checksum mismatch for ${asset}, skipping installation`);
+						return;
+					}
+				} else console.warn(`[avenor-postinstall] Checksums not available for ${asset}, skipping verification`);
+			} else console.warn(`[avenor-postinstall] Checksums not available (HTTP ${checksumsResponse.status}), skipping verification`);
+		} catch {
+			console.warn(`[avenor-postinstall] Checksums not available, skipping verification`);
+		}
+		fs.writeFileSync(binaryPath, buffer);
+		fs.chmodSync(binaryPath, 493);
+	} catch (err) {
+		console.warn(`[avenor-postinstall] Failed to install avenor binary: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+const arg1 = process.argv[1];
+if (!!arg1 && (arg1.endsWith("postinstall.js") || arg1.endsWith("postinstall.ts"))) postinstall().catch((err) => {
+	console.warn(`[avenor-postinstall] Unhandled error: ${err instanceof Error ? err.message : String(err)}`);
+	process.exit(0);
+});
+//#endregion
+export { getInstallDir, getVersion, installerBinaryPath, parseChecksums, platformMapping, postinstall, verifyChecksum };

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@dougbots/avenor-core",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sdougbrown/avenor",
+    "directory": "packages/core"
+  },
   "files": [
     "dist"
   ],
@@ -20,7 +25,8 @@
     "build": "tsdown",
     "test": "bun test",
     "test:e2e": "AVENOR_REAL_INTEGRATION=1 bun test",
-    "dev": "tsdown --watch"
+    "dev": "tsdown --watch",
+    "postinstall": "node -e \"const fs=require('fs');if(fs.existsSync('dist/postinstall.js')){require('./dist/postinstall.js')}\""
   },
   "devDependencies": {
     "@types/bun": "^1.3.12",