@krapht/ork 0.1.0 → 0.3.0

package/dist/watch-B8o4Szd_.mjs

@@ -0,0 +1,394 @@
+import { Dn as timeoutMs, T as stillTheSameProcess, Tn as isToolNode, Zt as placeFiles, _ as takeWatchLock, d as triggersReport, f as createWatcher, gn as CheckReportSchema, h as readProjectTriggers, m as declaredTriggers, p as triggerStanding, rt as liveStatus, tt as detachRun, v as watchingPid } from "./src-Cz1yOUTg.mjs";
+import { n as newRunId } from "./find-BcvhT6UN.mjs";
+import { a as write, c as openStore, i as style, o as writeErr, r as plain, t as confirm } from "./output-Q2EdeVUt.mjs";
+import { i as runLimits, r as limitsRefusal } from "./limits-BKYAmqCR.mjs";
+import { c as toolExecutor, o as spawnTool, s as mcpCallExecutor } from "./src-DtN1k-B3.mjs";
+import { t as acceptRefusal } from "./in-a-run-BbLhZOFW.mjs";
+import { defineCommand } from "citty";
+import path from "node:path";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+const NO_HUMAN = {
+	permit: () => Promise.resolve({
+		allow: false,
+		message: "no one is watching a check"
+	}),
+	ask: () => Promise.resolve("no one is watching a check")
+};
+/** A tool's result has to be read as JSON; an MCP call's already is. */
+const asNode = (check) => isToolNode(check) ? {
+	...check,
+	output: { format: "json" }
+} : check;
+const resultOf = (json) => {
+	const report = CheckReportSchema.safeParse(json);
+	return report.success ? {
+		ok: true,
+		events: report.data.events
+	} : {
+		ok: false,
+		error: "the check must report { \"events\": [{ \"key\": \"...\", \"inputs\": { ... } }] }"
+	};
+};
+const lookAt = async (options) => {
+	const { place, id, signal } = options;
+	const node = asNode(options.check);
+	const workflow = {
+		schemaVersion: 1,
+		name: `trigger ${id}`,
+		nodes: { check: node }
+	};
+	const runDir = path.join(placeFiles(place).runs, ".triggers", id);
+	mkdirSync(runDir, { recursive: true });
+	const executor = node.type === "mcp.call" ? mcpCallExecutor() : toolExecutor(spawnTool);
+	const limit = AbortSignal.timeout(timeoutMs(node.timeout ?? "5m") ?? 0);
+	const result = await executor({
+		runId: `trigger-${id}`,
+		id: "check",
+		node,
+		workflow,
+		inputs: {},
+		outputs: {},
+		input: void 0,
+		round: 1,
+		cwd: place.root,
+		runDir,
+		workflowDir: place.dir,
+		projectRoot: place.root,
+		orkDir: place.dir,
+		budgetLeftUsd: void 0,
+		human: NO_HUMAN,
+		emit: () => {},
+		signal: AbortSignal.any([signal, limit])
+	});
+	return result.ok ? resultOf(result.output["json"]) : {
+		ok: false,
+		error: result.error ?? "the check failed"
+	};
+};
+// src/watch/report.ts
+const STANDING = {
+	live: "live",
+	new: "off: new, not accepted",
+	changed: "off: changed since it was accepted",
+	invalid: "off: has an error"
+};
+const brokenLines = (broken) => broken.map(({ file, message }) => `${style("red", "✗")} ${plain(file)}: ${plain(message)}`);
+const statusLines = (report) => {
+	const head = report.pid === void 0 ? "ork watch isn't running. Start it with `ork watch`, or `ork watch --detach`." : `ork watch is running (process ${String(report.pid)}).`;
+	const broken = brokenLines(report.broken);
+	if (report.triggers.length === 0) return [
+		head,
+		...broken,
+		"No triggers in any registered project."
+	];
+	return [
+		head,
+		...broken,
+		...report.triggers.flatMap((status) => [
+			`${style("bold", plain(status.trigger))} ${style("dim", plain(`${status.project} → ${status.run}, every ${status.every}`))}`,
+			`  ${STANDING[status.standing] ?? status.standing}${status.lookedAt === void 0 ? "" : `, last looked ${status.lookedAt}`}`,
+			...status.error === void 0 ? [] : [`  last look: ${plain(status.error)}`],
+			...status.held === void 0 ? [] : [`  waiting: ${plain(status.held)}`],
+			...status.problems.map((problem) => `  ${style("red", "✗")} ${plain(problem)}`)
+		])
+	];
+};
+const asJson = (value) => plain(JSON.stringify(value));
+/** What a check runs with, past its command. */
+const checkSettings = ({ trigger }) => {
+	const { check } = trigger;
+	if (check === void 0) return [];
+	return [
+		..."cwd" in check && check.cwd !== void 0 ? [`    in: ${plain(check.cwd)}`] : [],
+		...check.env === void 0 ? [] : [`    env: ${asJson(check.env)}`],
+		..."arguments" in check && check.arguments !== void 0 ? [`    arguments: ${asJson(check.arguments)}`] : []
+	];
+};
+/** What a trigger runs, in as many words as it takes to judge it. */
+const checkLines = (item) => {
+	const { check } = item.trigger;
+	if (check === void 0) return ["  no check: starts a run every time"];
+	if (check.type === "mcp.call") return [`  looks with: ${plain(check.server)}.${plain(check.tool)}, from the project's .mcp.json`, ...checkSettings(item)];
+	return [
+		`  looks with: ${plain(check.type)} ${plain(check.command ?? "")}`.trimEnd(),
+		...check.script === void 0 ? [] : check.script.trimEnd().split("\n").map((line) => `    ${plain(line)}`),
+		...checkSettings(item)
+	];
+};
+/** What the run does, since a changed workflow looks the same from outside. */
+const workflowLines = ({ workflow, workflowFile }) => {
+	if (workflow === null) return [];
+	const budget = workflow.limits?.budgetUsd;
+	return [`  workflow: ${plain(workflowFile)}${budget === void 0 ? "" : `, up to $${String(budget)} a run`}`, ...Object.entries(workflow.nodes).map(([id, node]) => `    ${plain(id)}: ${plain(node.type)}`)];
+};
+const STANDS = {
+	new: "new",
+	changed: "changed since you accepted it, here or in the workflow it starts"
+};
+const acceptLines = (item, standing) => [
+	`${style("bold", plain(item.id))} ${style("dim", plain(item.place.root))}`,
+	`  ${STANDS[standing] ?? standing}`,
+	...checkLines(item),
+	`  starts: ${plain(item.trigger.run)}, looking every ${item.trigger.every}, with up to ${String(item.trigger.maxRunsPerDay ?? 10)} runs a day`,
+	...workflowLines(item),
+	...item.diagnostics.filter(({ severity }) => severity === "warning").map(({ message }) => `  ${style("yellow", "!")} ${plain(message)}`)
+];
+/** The triggers `--accept` can't offer, so they aren't silently left out. */
+const unacceptableLines = (item) => [`${style("bold", plain(item.id))} ${style("dim", plain(item.place.root))}`, ...item.diagnostics.filter(({ severity }) => severity === "error").map(({ message }) => `  ${style("red", "✗")} ${plain(message)}`)];
+// src/watch/start.ts
+/**
+* @file Starting a trigger's run (RFC-011): an ordinary run in the background,
+*   so everything else works on it. It runs the file that was accepted, by its
+*   whole path and only if its text is still what was accepted, so nothing a
+*   branch adds or a pull changes runs in its place. What a check reported
+*   can't become extra arguments: each value is joined to its flag, and its
+*   name must be an input the workflow declares.
+*/
+/** What a run gets, and which of it came from what the check reported. */
+const inputsFor = (trigger, event) => {
+	const reported = Object.fromEntries(Object.entries(event.inputs ?? {}).map(([name, value]) => [name, String(value)]));
+	const own = trigger.inputs ?? {};
+	return {
+		inputs: {
+			...reported,
+			...own
+		},
+		untrusted: Object.keys(reported).filter((name) => !Object.hasOwn(own, name))
+	};
+};
+/** How the run is started, with each value joined to its flag. */
+const triggerRunArgs = (options) => [
+	"run",
+	options.workflowFile,
+	`--expect-workflow=${options.workflowHash}`,
+	...Object.entries(options.inputs).map(([name, value]) => `--input=${name}=${value}`),
+	`--trigger=${options.id}`,
+	...options.untrusted.map((name) => `--untrusted=${name}`),
+	`--run-id=${options.runId}`
+];
+const startTriggerRun = async (options) => {
+	const { store, place, id, trigger, workflow, event, runId } = options;
+	const { workflowFile, workflowHash } = options;
+	const { inputs, untrusted } = inputsFor(trigger, event);
+	const unknown = Object.keys(inputs).find((name) => !Object.hasOwn(workflow.inputs ?? {}, name));
+	if (unknown !== void 0) return {
+		ok: false,
+		error: `the check reported input \`${unknown}\`, which ${trigger.run} doesn't declare`
+	};
+	const detached = await detachRun({
+		store,
+		runId,
+		cwd: place.root,
+		runDir: path.join(placeFiles(place).runs, runId),
+		args: triggerRunArgs({
+			id,
+			workflowFile,
+			workflowHash,
+			inputs,
+			untrusted,
+			runId
+		})
+	});
+	return detached.ok ? { ok: true } : {
+		ok: false,
+		error: detached.error
+	};
+};
+// src/commands/watch.ts
+/**
+* @file `ork watch` (RFC-011): looks at what each registered project's triggers
+*   declare, and starts a run for each new thing they report. One per machine,
+*   in the foreground or with `--detach`; Ork installs nothing to keep it
+*   alive. It runs only what was accepted here, and accepting takes a terminal,
+*   so a browser tab can't approve code to run with nobody there, nor a program
+*   by accident.
+*/
+/** How often it sees what's due. A trigger looks once a minute at most. */
+const TICK_MS = 1e4;
+const watchLoop = async (store) => {
+	const lock = takeWatchLock(store);
+	if (!lock.ok) {
+		writeErr(`ork watch is already running (process ${String(lock.pid)}).`);
+		return 1;
+	}
+	const stopping = new AbortController();
+	const watcher = createWatcher({
+		store,
+		declared: () => declaredTriggers(store.projects()),
+		look: ({ place, id, trigger }) => trigger.check === void 0 ? Promise.resolve({
+			ok: true,
+			events: []
+		}) : lookAt({
+			place,
+			id,
+			check: trigger.check,
+			signal: stopping.signal
+		}),
+		start: ({ place, id, trigger, workflow, workflowFile, workflowHash }, event, runId) => startTriggerRun({
+			store,
+			place,
+			id,
+			trigger,
+			workflow,
+			workflowFile,
+			workflowHash,
+			event,
+			runId
+		}),
+		newRunId: () => newRunId(store),
+		isRunning: (runId) => {
+			const [run] = store.lookup(runId);
+			if (run === void 0 || liveStatus(run) !== "running") return false;
+			const last = store.events(run.id).at(-1)?.at ?? run.startedAt;
+			return stillTheSameProcess(run.pid, last);
+		},
+		blocked: ({ place, workflow }) => limitsRefusal(runLimits(store, place), workflow)[0],
+		note: (line) => {
+			write(`${style("dim", (/* @__PURE__ */ new Date()).toISOString())} ${plain(line)}`);
+		}
+	});
+	const { promise: stopped, resolve: stop } = Promise.withResolvers();
+	const onSignal = () => {
+		stop();
+	};
+	process.once("SIGINT", onSignal);
+	process.once("SIGTERM", onSignal);
+	write("▸ watching. `ork watch --status` says what's live.");
+	watcher.tick();
+	const timer = setInterval(() => {
+		watcher.tick();
+	}, TICK_MS);
+	await stopped;
+	clearInterval(timer);
+	stopping.abort();
+	await watcher.settled();
+	lock.release();
+	return 0;
+};
+const detach = async (store) => {
+	const running = watchingPid(store);
+	if (running !== void 0) {
+		writeErr(`ork watch is already running (process ${String(running)}).`);
+		return 1;
+	}
+	const started = await detachRun({
+		store,
+		runId: "watch",
+		cwd: homedir(),
+		runDir: path.join(homedir(), ".ork", "watch"),
+		args: ["watch"],
+		started: (pid) => pid !== void 0 && watchingPid(store) === pid
+	});
+	if (!started.ok) {
+		writeErr(started.error);
+		return 1;
+	}
+	write(`▸ watching in the background; its output is in ${started.log}`);
+	return 0;
+};
+const stopWatching = (store) => {
+	const pid = watchingPid(store);
+	if (pid === void 0) {
+		write("ork watch isn't running.");
+		return 0;
+	}
+	process.kill(pid, "SIGTERM");
+	write(`Told ork watch (process ${String(pid)}) to stop.`);
+	return 0;
+};
+const hasError = ({ diagnostics }) => diagnostics.some(({ severity }) => severity === "error");
+/** Asks about each trigger that's new or changed, in this terminal. */
+const accept = async (store) => {
+	const refused = acceptRefusal();
+	if (refused !== null) {
+		writeErr(refused);
+		return 1;
+	}
+	if (!process.stdin.isTTY) {
+		writeErr("`ork watch --accept` asks in a terminal: it approves code to run with nobody there.");
+		return 1;
+	}
+	const projects = store.projects();
+	const read = projects.map((place) => ({
+		place,
+		found: readProjectTriggers(place, void 0, projects)
+	}));
+	for (const { place, found } of read) {
+		const broken = found.diagnostics.map(({ message }) => ({
+			project: place.id ?? "",
+			file: found.file,
+			message
+		}));
+		for (const line of brokenLines(broken)) write(line);
+		for (const item of found.triggers.filter(hasError)) for (const line of unacceptableLines(item)) write(line);
+	}
+	const waiting = read.flatMap(({ place, found }) => {
+		const records = store.triggerRecords(place.id);
+		return found.triggers.flatMap((item) => {
+			const standing = triggerStanding(item, records.find(({ trigger }) => trigger === item.id));
+			return hasError(item) || standing === "live" ? [] : [{
+				item,
+				standing
+			}];
+		});
+	});
+	if (waiting.length === 0) {
+		write("No new or changed triggers to accept.");
+		return 0;
+	}
+	for (const { item, standing } of waiting) {
+		for (const line of acceptLines(item, standing)) write(line);
+		if (await confirm("Accept this trigger, to run with nobody there? [y/N] ")) {
+			const project = item.place.id;
+			if (project !== void 0) {
+				store.acceptTrigger(project, item.id, item.hash);
+				write(`Accepted ${plain(item.id)}; its first look starts nothing.`);
+			}
+		}
+	}
+	return 0;
+};
+const watch = defineCommand({
+	meta: {
+		name: "watch",
+		description: "Look at each project's triggers, and start a run for each new thing they report"
+	},
+	args: {
+		detach: {
+			type: "boolean",
+			description: "Watch in the background",
+			default: false
+		},
+		status: {
+			type: "boolean",
+			description: "Say what's live, and when each trigger last looked",
+			default: false
+		},
+		accept: {
+			type: "boolean",
+			description: "Accept new or changed triggers, in a terminal",
+			default: false
+		},
+		stop: {
+			type: "boolean",
+			description: "Stop the ork watch that's running",
+			default: false
+		}
+	},
+	run: async ({ args }) => {
+		const store = openStore();
+		try {
+			if (args.status) {
+				const report = triggersReport(store, store.projects());
+				for (const line of statusLines(report)) write(line);
+			} else if (args.stop) process.exitCode = stopWatching(store);
+			else if (args.accept) process.exitCode = await accept(store);
+			else if (args.detach) process.exitCode = await detach(store);
+			else process.exitCode = await watchLoop(store);
+		} finally {
+			store.close();
+		}
+	}
+});
+export { watch };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krapht/ork",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Orchestrate Claude agents on your machine: hierarchical, serializable workflows with a CLI and a localhost UI.",
   "keywords": [
     "claude",
@@ -51,9 +51,11 @@
     "@krapht/ork-nodes": "0.0.0",
     "@krapht/ork-runtime-claude": "0.0.0",
     "@krapht/ork-schema": "0.0.0",
+    "@krapht/ork-server": "0.0.0",
+    "@krapht/ork-ui": "0.0.0",
     "tsdown": "0.23.1"
   },
   "scripts": {
-    "build": "node ../../tools/release/build-info.ts && tsdown && cp ../../LICENSE ../../THIRD_PARTY_NOTICES.md ."
+    "build": "pnpm --filter @krapht/ork-ui build && node ../../tools/release/build-info.ts && node ../../tools/release/plugin-skills.ts && tsdown && cp ../../LICENSE ../../THIRD_PARTY_NOTICES.md . && cp -R ../ui/dist dist/ui"
   }
 }