@flue/cli 0.0.7 → 0.0.9

package/dist/flue.js

@@ -6,6 +6,7 @@ import { pathToFileURL } from "node:url";
 //#region bin/flue.js
 const OPENCODE_URL = "http://localhost:48765";
 let openCodeProcess = null;
+let eventStreamAbort = null;
 function printUsage() {
 	console.error("Usage: flue run <workflowPath> [--args <json>] [--branch <name>] [--model <provider/model>]");
 }
@@ -70,6 +71,122 @@ function parseModel(modelStr) {
 		modelID: modelStr.slice(slashIndex + 1)
 	};
 }
+/**
+* Connect to OpenCode's SSE /event endpoint and log events to stderr.
+* Returns an object with an abort() method to close the connection.
+*/
+function startEventStream(workdir) {
+	const controller = new AbortController();
+	const sessionNames = /* @__PURE__ */ new Map();
+	const textBuffers = /* @__PURE__ */ new Map();
+	_consumeEventStream(controller.signal, workdir, sessionNames, textBuffers).catch((err) => {
+		if (err.name !== "AbortError") console.error(`[opencode] event stream error: ${err.message}`);
+	});
+	return { abort() {
+		for (const [sessionId, text] of textBuffers) if (text) {
+			const name = sessionNames.get(sessionId) ?? sessionId.slice(0, 12);
+			for (const line of text.split("\n")) if (line) console.error(`[opencode] (${name}) > ${line}`);
+		}
+		controller.abort();
+	} };
+}
+async function _consumeEventStream(signal, workdir, sessionNames, textBuffers) {
+	const { transformEvent } = await import("@flue/client");
+	const url = `${OPENCODE_URL}/event?directory=${encodeURIComponent(workdir)}`;
+	const res = await fetch(url, { signal });
+	if (!res.ok || !res.body) {
+		console.error(`[opencode] failed to connect to event stream (HTTP ${res.status})`);
+		return;
+	}
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for await (const chunk of res.body) {
+		if (signal.aborted) break;
+		buffer += decoder.decode(chunk, { stream: true });
+		const parts = buffer.split("\n\n");
+		buffer = parts.pop() ?? "";
+		for (const part of parts) {
+			if (!part.trim()) continue;
+			const dataLines = [];
+			for (const line of part.split("\n")) if (line.startsWith("data: ")) dataLines.push(line.slice(6));
+			else if (line.startsWith("data:")) dataLines.push(line.slice(5));
+			if (dataLines.length === 0) continue;
+			let raw;
+			try {
+				raw = JSON.parse(dataLines.join("\n"));
+			} catch {
+				continue;
+			}
+			if (raw.type === "session.created" || raw.type === "session.updated") {
+				const info = raw.properties?.info;
+				if (info?.id && info?.title) sessionNames.set(info.id, info.title);
+				continue;
+			}
+			const event = transformEvent(raw);
+			if (!event) continue;
+			logEvent(event, sessionNames.get(event.sessionId) ?? event.sessionId.slice(0, 12), textBuffers);
+		}
+	}
+}
+/**
+* Format and log a single FlueEvent to stderr.
+*/
+function logEvent(event, sessionName, textBuffers) {
+	const prefix = `[opencode] (${sessionName})`;
+	switch (event.type) {
+		case "tool.pending":
+			console.error(`${prefix} tool:pending  ${event.tool} — ${event.input}`);
+			break;
+		case "tool.running":
+			flushTextBuffer(textBuffers, event.sessionId, sessionName);
+			console.error(`${prefix} tool:running  ${event.tool} — ${event.input}`);
+			break;
+		case "tool.complete": {
+			const dur = event.duration ? ` (${(event.duration / 1e3).toFixed(1)}s)` : "";
+			console.error(`${prefix} tool:complete ${event.tool}${dur} — ${event.input}`);
+			break;
+		}
+		case "tool.error": {
+			const dur = event.duration ? ` (${(event.duration / 1e3).toFixed(1)}s)` : "";
+			console.error(`${prefix} tool:error    ${event.tool}${dur} — ${event.input} — ${event.error}`);
+			break;
+		}
+		case "text": {
+			const lines = ((textBuffers.get(event.sessionId) ?? "") + event.text).split("\n");
+			textBuffers.set(event.sessionId, lines.pop() ?? "");
+			for (const line of lines) console.error(`${prefix} > ${line}`);
+			break;
+		}
+		case "status":
+			flushTextBuffer(textBuffers, event.sessionId, sessionName);
+			if (event.message) console.error(`${prefix} status:${event.status} — ${event.message}`);
+			else console.error(`${prefix} status:${event.status}`);
+			break;
+		case "step.start":
+			console.error(`${prefix} step:start`);
+			break;
+		case "step.finish": {
+			const tokens = `${event.tokens.input} in / ${event.tokens.output} out`;
+			const cost = event.cost > 0 ? `, $${event.cost.toFixed(4)}` : "";
+			console.error(`${prefix} step:finish — ${tokens}${cost} — ${event.reason}`);
+			break;
+		}
+		case "error":
+			console.error(`${prefix} ERROR: ${event.message}`);
+			break;
+	}
+}
+/**
+* Flush any remaining buffered text for a session.
+*/
+function flushTextBuffer(textBuffers, sessionId, sessionName) {
+	const remaining = textBuffers.get(sessionId);
+	if (remaining) {
+		const prefix = `[opencode] (${sessionName})`;
+		console.error(`${prefix} > ${remaining}`);
+		textBuffers.set(sessionId, "");
+	}
+}
 async function run() {
 	const { workflowPath, argsJson, branch, model: modelStr } = parseArgs(process.argv.slice(2));
 	const workdir = process.cwd();
@@ -98,6 +215,9 @@ async function run() {
 		}
 	}
 	await preflight(workdir, modelStr);
+	await setPermissions(workdir);
+	const eventStream = startEventStream(workdir);
+	eventStreamAbort = eventStream;
 	const model = modelStr ? parseModel(modelStr) : void 0;
 	const flue = new Flue({
 		workdir,
@@ -117,6 +237,8 @@ async function run() {
 		console.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	} finally {
+		eventStream.abort();
+		eventStreamAbort = null;
 		await flue.close();
 		if (startedOpenCode) stopOpenCodeServer(startedOpenCode);
 		openCodeProcess = null;
@@ -144,6 +266,32 @@ async function preflight(workdir, modelOverride) {
 		process.exit(1);
 	}
 }
+/**
+* Configure OpenCode to auto-approve all tool operations.
+* In headless/CI mode there's no human to respond to permission prompts,
+* so we must allow everything upfront. This mirrors what the Cloudflare
+* runner does via `'*': 'allow'` in its config.
+*
+* NOTE: We set each permission field explicitly here. The OpenCode config
+* also supports a wildcard `'*': 'allow'` key (used by the Cloudflare
+* runner with @ts-expect-error), but the typed Config schema doesn't
+* expose it. We should try wildcard support at some point to future-proof
+* against new permission types being added.
+*/
+async function setPermissions(workdir) {
+	const res = await fetch(`${OPENCODE_URL}/config?directory=${encodeURIComponent(workdir)}`, {
+		method: "PUT",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ permission: {
+			edit: "allow",
+			bash: "allow",
+			webfetch: "allow",
+			doom_loop: "allow",
+			external_directory: "allow"
+		} })
+	});
+	if (!res.ok) console.error(`[flue] warning: failed to set permissions (HTTP ${res.status})`);
+}
 async function isOpenCodeRunning() {
 	try {
 		const controller = new AbortController();
@@ -179,10 +327,12 @@ function stopOpenCodeServer(child) {
 	child.kill("SIGTERM");
 }
 process.on("SIGINT", () => {
+	if (eventStreamAbort) eventStreamAbort.abort();
 	if (openCodeProcess) stopOpenCodeServer(openCodeProcess);
 	process.exit(130);
 });
 process.on("SIGTERM", () => {
+	if (eventStreamAbort) eventStreamAbort.abort();
 	if (openCodeProcess) stopOpenCodeServer(openCodeProcess);
 	process.exit(143);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@flue/cli",
-	"version": "0.0.7",
+	"version": "0.0.9",
 	"type": "module",
 	"bin": {
 		"flue": "dist/flue.js"
@@ -13,7 +13,7 @@
 		"check:types": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@flue/client": "^0.0.5"
+		"@flue/client": "^0.0.6"
 	},
 	"devDependencies": {
 		"tsdown": "^0.20.3"