@krapht/ork 0.2.0 → 0.4.0

package/dist/watch-0Qr2UfCQ.mjs

@@ -0,0 +1,394 @@
+import { C as watchingPid, Mn as CheckReportSchema, S as takeWatchLock, Un as timeoutMs, Vn as isToolNode, _ as createWatcher, b as readProjectTriggers, dn as placeFiles, g as triggersReport, ht as stillTheSameProcess, lt as liveStatus, rt as detachRun, v as triggerStanding, y as declaredTriggers } from "./src-CGqMati3.mjs";
+import { n as newRunId } from "./find-DptmbhGd.mjs";
+import { a as write, c as openStore, i as style, o as writeErr, r as plain, t as confirm } from "./output-CXSJO00X.mjs";
+import { i as runLimits, r as limitsRefusal } from "./limits-BDZCmGEu.mjs";
+import { c as toolExecutor, o as spawnTool, s as mcpCallExecutor } from "./src-UWkk1sl9.mjs";
+import { t as acceptRefusal } from "./in-a-run-D1Qc5Mit.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/dist/worktrees-DHl80k96.mjs

@@ -0,0 +1,212 @@
+import { T as inspectProject } from "./src-CGqMati3.mjs";
+import { a as write, c as openStore, i as style, o as writeErr, t as confirm } from "./output-CXSJO00X.mjs";
+import { a as planClean, i as keyOf, o as stepActs, t as applyClean } from "./clean-Dcr807be.mjs";
+import { a as readWorktrees, c as planLine, n as lostWork, o as labelOf, r as planRemove, s as mergeStateOf, t as applyRemove, u as stateParts } from "./remove-AwaMMaHf.mjs";
+import { defineCommand } from "citty";
+import path from "node:path";
+// src/project/worktrees.ts
+/**
+* @file What `ork worktrees` prints: each worktree or branch a run left, with
+*   its state read from git, the plan `ork worktrees clean` or `remove` would
+*   carry out, and what a forced remove would lose. The words are core's
+*   (worktree/words.ts), which the Worktrees panel says too; this only colors
+*   them.
+*/
+/** One line of state: its merge state, then what clean would care about. */
+const worktreeState = (item) => {
+	const merge = mergeStateOf(item);
+	const head = merge === "merged" ? [style("green", "merged")] : merge === "detached" ? ["detached"] : [];
+	const parts = stateParts(item).map((part) => part.risk ? style("yellow", part.text) : part.text);
+	return [...head, ...parts].join(" · ");
+};
+/** A name as the list shows it, saying when it's detached. */
+const nameOf = (item) => mergeStateOf(item) === "detached" ? `${labelOf(item)} (detached)` : labelOf(item);
+const formatWorktrees = (items) => {
+	if (items.length === 0) return ["No Ork worktrees or branches."];
+	const width = Math.max(...items.map((i) => nameOf(i).length));
+	return items.flatMap((item) => [`${style("bold", nameOf(item).padEnd(width))}  ${worktreeState(item)}`, ...item.path === null ? [] : [`  ${style("dim", item.path)}`]]);
+};
+const formatPlan = (steps) => steps.map((step) => {
+	const { text, reason } = planLine(step);
+	return `  ${text}${reason === void 0 ? "" : style("dim", ` (${reason})`)}`;
+});
+/** What a forced remove loses, as git prints it, under a heading each. */
+const formatLost = (lost) => [...lost.changes.length === 0 ? [] : ["Uncommitted changes:", ...lost.changes.map((line) => `  ${line}`)], ...lost.commits.length === 0 ? [] : [lost.commitsOn === "no branch" ? "Commits on no branch:" : "Commits not merged:", ...lost.commits.map((line) => `  ${line}`)]];
+// src/commands/worktrees.ts
+/**
+* @file `ork worktrees` (or `ork wt`): lists the worktrees and branches runs
+*   left behind (those the runs recorded creating, whatever the project's git
+*   rules named them, and any `ork/` branch), with their state read from git;
+*   cleans them up safely after showing the plan and asking; and removes one,
+*   the twin of the Worktrees panel's Remove…. The plans are core's, so the
+*   panel keeps and removes exactly what these do.
+*/
+/** The repo this folder is in, and what Ork created there; null outside one. */
+const here = async () => {
+	const root = (await inspectProject(process.cwd()))?.root ?? null;
+	if (root === null) {
+		writeErr("Not in a git repository with a commit.");
+		process.exitCode = 1;
+		return null;
+	}
+	const store = openStore();
+	try {
+		return {
+			root,
+			...await readWorktrees(store, root)
+		};
+	} finally {
+		store.close();
+	}
+};
+/** Asks before acting, unless `--yes`; without a terminal `--yes` is needed. */
+const goAhead = (yes, verb) => {
+	if (yes) return Promise.resolve(true);
+	if (!process.stdin.isTTY) {
+		writeErr(`Pass --yes to ${verb} without a terminal.`);
+		process.exitCode = 1;
+		return Promise.resolve(false);
+	}
+	return confirm("Go ahead? [y/N] ");
+};
+const done = (lines) => {
+	for (const line of lines) write(`${style("green", "✓")} ${line}`);
+};
+const show = async (json) => {
+	const found = await here();
+	if (found === null) return;
+	if (json) write(JSON.stringify(found.items, void 0, 2));
+	else for (const line of formatWorktrees(found.items)) write(line);
+};
+const list = defineCommand({
+	meta: {
+		name: "list",
+		description: "List Ork's worktrees and branches (the default)"
+	},
+	args: { json: {
+		type: "boolean",
+		description: "Print JSON",
+		default: false
+	} },
+	run: ({ args }) => show(args.json)
+});
+const yes = {
+	type: "boolean",
+	description: "Do not ask",
+	default: false
+};
+const clean = defineCommand({
+	meta: {
+		name: "clean",
+		description: "Remove Ork's worktrees (merged ones by default); never one with uncommitted changes unless --force, nor one whose run is still going"
+	},
+	args: {
+		run: {
+			type: "string",
+			description: "Only this run's worktrees"
+		},
+		all: {
+			type: "boolean",
+			description: "Include worktrees whose branch is not merged",
+			default: false
+		},
+		branches: {
+			type: "boolean",
+			description: "Also delete the branches",
+			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Remove uncommitted changes and unmerged branches too",
+			default: false
+		},
+		yes
+	},
+	run: async ({ args }) => {
+		const found = await here();
+		if (found === null) return;
+		const filter = { merged: !args.all };
+		if (args.run !== void 0) filter.runId = args.run;
+		const steps = planClean(found.items, filter, {
+			branches: args.branches,
+			force: args.force,
+			live: found.live
+		});
+		const acting = steps.filter((s) => stepActs(s));
+		if (acting.length === 0) {
+			for (const line of formatPlan(steps)) write(line);
+			write("Nothing to clean.");
+			return;
+		}
+		write("Plan:");
+		for (const line of formatPlan(steps)) write(line);
+		if (!await goAhead(args.yes, "clean")) return;
+		done(await applyClean(found.root, acting, args.force));
+	}
+});
+const remove = defineCommand({
+	meta: {
+		name: "remove",
+		description: "Remove one of Ork's worktrees, by its branch or its path; --force when that loses work"
+	},
+	args: {
+		target: {
+			type: "positional",
+			description: "The branch, or the worktree's path",
+			required: true
+		},
+		branch: {
+			type: "boolean",
+			description: "Also delete the branch",
+			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Remove even when that loses uncommitted changes or commits",
+			default: false
+		},
+		yes
+	},
+	run: async ({ args }) => {
+		const found = await here();
+		if (found === null) return;
+		const byPath = path.resolve(args.target);
+		const item = found.items.find((i) => keyOf(i) === args.target || i.path === byPath);
+		const planned = planRemove(found, item === void 0 ? args.target : keyOf(item), args.branch);
+		if (!planned.ok) {
+			writeErr(planned.error);
+			process.exitCode = 1;
+			return;
+		}
+		const { plan } = planned;
+		write("Plan:");
+		for (const line of formatPlan([plan.step])) write(line);
+		if (plan.force) {
+			for (const line of formatLost(await lostWork(found.root, plan))) write(line);
+			if (!args.force) {
+				writeErr("That loses work; pass --force to remove it anyway.");
+				process.exitCode = 1;
+				return;
+			}
+		}
+		if (!await goAhead(args.yes, "remove")) return;
+		done(await applyRemove(found.root, plan));
+	}
+});
+const worktrees = defineCommand({
+	meta: {
+		name: "worktrees",
+		description: "Track and clean up the git worktrees Ork creates for runs"
+	},
+	subCommands: {
+		list,
+		clean,
+		remove
+	},
+	run: async ({ rawArgs }) => {
+		const [first] = rawArgs;
+		if (first === "list" || first === "clean" || first === "remove") return;
+		await show(rawArgs.includes("--json"));
+	}
+});
+export { worktrees };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krapht/ork",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Orchestrate Claude agents on your machine: hierarchical, serializable workflows with a CLI and a localhost UI.",
   "keywords": [
     "claude",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.309",
-    "@anthropic-ai/sdk": "1.1.0",
+    "@anthropic-ai/sdk": "1.3.0",
     "@modelcontextprotocol/sdk": "1.32.1",
     "citty": "0.2.2",
     "yaml": "2.9.1",
@@ -51,9 +51,11 @@
     "@krapht/ork-nodes": "0.0.0",
     "@krapht/ork-runtime-claude": "0.0.0",
     "@krapht/ork-schema": "0.0.0",
-    "tsdown": "0.23.1"
+    "@krapht/ork-server": "0.0.0",
+    "@krapht/ork-ui": "0.0.0",
+    "tsdown": "0.23.4"
   },
   "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 && node ../../tools/release/builtin-workflows.ts && tsdown && cp ../../LICENSE ../../THIRD_PARTY_NOTICES.md . && cp -R ../ui/dist dist/ui"
   }
 }