@krapht/ork 0.3.0 → 1.0.0-alpha.0

package/dist/ui/index.html

@@ -1,7 +1,6 @@
 <!doctype html>
 <html
   lang="en"
-  data-theme="dark"
   data-contrast="standard"
 >
   <head>
@@ -20,9 +19,9 @@
       href="/favicon.svg"
       type="image/svg+xml"
     />
-    <script type="module" crossorigin src="/assets/index-BoG6O-Lp.js"></script>
+    <script type="module" crossorigin src="/assets/index-D83F2OKZ.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/theme-3xH5jxKs.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-BiO54L90.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BPIbqRRb.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/ui-CY4xxJUu.mjs

@@ -0,0 +1,472 @@
+import { n as ORK_VERSION, t as ORK_NAME } from "./__build_info__-DdTVd2p5.mjs";
+import { a as write, i as style, o as writeErr } from "./output-B1V6ZJSx.mjs";
+import { i as uiFilePath, l as newToken, n as startServer, r as runningServer, t as DEFAULT_PORT } from "./src-BJTegEzY.mjs";
+import { a as mayShowSignIn } from "./in-a-run-BPXX09Bs.mjs";
+import path from "node:path";
+import { constants } from "node:os";
+import { spawn } from "node:child_process";
+import { defineCommand } from "citty";
+import { fileURLToPath } from "node:url";
+// src/browser/open.ts
+/**
+* @file Opening a link in the user's browser, for `ork ui`. Each way is an
+*   opener in a registry, tried in order when it applies to this platform:
+*   `open` on macOS, `wslview` then `xdg-open` under WSL, `xdg-open` on Linux.
+*   Adding a platform is one more entry. When none starts, the caller prints
+*   the link instead.
+*/
+const wsl = (env) => env["WSL_DISTRO_NAME"] !== void 0;
+const OPENERS = [
+	{
+		id: "macos",
+		applies: (platform) => platform === "darwin",
+		program: "open"
+	},
+	{
+		id: "wslview",
+		applies: (platform, env) => platform === "linux" && wsl(env),
+		program: "wslview"
+	},
+	{
+		id: "xdg-open",
+		applies: (platform) => platform === "linux" || platform === "freebsd",
+		program: "xdg-open"
+	}
+];
+/** Starts one program with the link; false when it cannot be started. */
+const start = (program, url) => new Promise((resolve) => {
+	const child = spawn(program, [url], {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.once("error", () => {
+		resolve(false);
+	});
+	child.once("spawn", () => {
+		child.unref();
+		resolve(true);
+	});
+});
+/** Opens `url` with the first opener that starts; false when none did. */
+const openInBrowser = async (url, options = {}) => {
+	const platform = options.platform ?? process.platform;
+	const env = options.env ?? process.env;
+	for (const opener of options.openers ?? OPENERS) {
+		if (!opener.applies(platform, env)) continue;
+		if (await start(opener.program, url)) return true;
+	}
+	return false;
+};
+// src/browser/folder.ts
+/**
+* @file Where `ork ui` finds the built UI: `dist/ui` beside the published
+*   bundle, or, run from source, `packages/ui/dist` once it is built (`pnpm
+*   --filter @krapht/ork-ui build`). The CLI takes the UI's built files, never
+*   its source; without them the server shows its placeholder page.
+*/
+/** The UI package's built folder in the workspace, or null outside it. */
+const workspaceUi = () => {
+	try {
+		const manifest = fileURLToPath(import.meta.resolve("@krapht/ork-ui/package.json"));
+		return path.join(path.dirname(manifest), "dist");
+	} catch {
+		return null;
+	}
+};
+/** The folders that may hold the built UI, in the order they are tried. */
+const uiFolders = () => {
+	const workspace = workspaceUi();
+	return [path.join(import.meta.dirname, "ui"), ...workspace === null ? [] : [workspace]];
+};
+// src/browser/ui-protocol.ts
+const isRecord = (value) => typeof value === "object" && value !== null;
+const TYPES = /* @__PURE__ */ new Set([
+	"ork-ui-hello",
+	"ork-ui-ready",
+	"ork-ui-failed",
+	"ork-ui-restart"
+]);
+/** A message from the child, or `null` for anything else. */
+const childMessage = (value) => {
+	if (!isRecord(value) || !TYPES.has(value["type"])) return null;
+	const { type, port, version, error } = value;
+	if (type === "ork-ui-ready") return typeof port === "number" && typeof version === "string" ? {
+		type,
+		port,
+		version
+	} : null;
+	if (type === "ork-ui-failed") return {
+		type,
+		error: typeof error === "string" ? error : "It failed."
+	};
+	return type === "ork-ui-hello" ? { type } : { type: "ork-ui-restart" };
+};
+/** The supervisor's `start`, or `null` for anything else. */
+const startMessage = (value) => isRecord(value) && value["type"] === "ork-ui-start" && typeof value["port"] === "number" && typeof value["token"] === "string" ? {
+	type: "ork-ui-start",
+	port: value["port"],
+	token: value["token"]
+} : null;
+// src/browser/serve.ts
+/**
+* @file The server's side of `ork ui` (ADR-060): `ork ui --serve`, which only
+*   `ork ui` starts. It says hello over its IPC channel, takes the port and the
+*   token from the supervisor, serves, and says it's ready. A restart asked by
+*   the page tells the supervisor, then closes and exits, so the supervisor
+*   starts the installed `ork` in its place. Ctrl-C, SIGTERM, or losing the
+*   supervisor closes it too, so no server is left behind; an upgrade still
+*   running is waited for first.
+*/
+const NOT_SUPERVISED = "`ork ui --serve` is how `ork ui` starts its server; run `ork ui`.";
+const send = (message) => new Promise((resolve) => {
+	if (!process.connected || process.send === void 0) {
+		resolve();
+		return;
+	}
+	process.send(message, void 0, {}, () => {
+		resolve();
+	});
+});
+/** The supervisor's `start`, after saying hello. */
+const started = () => new Promise((resolve) => {
+	const listen = (raw) => {
+		const message = startMessage(raw);
+		if (message === null) return;
+		process.off("message", listen);
+		resolve(message);
+	};
+	process.on("message", listen);
+	send({ type: "ork-ui-hello" });
+});
+const ignore = () => {};
+/** What the terminal says while an upgrade holds the stop up. */
+const WAITING_FOR_UPGRADE = "Waiting for the upgrade to finish… Press Ctrl-C again to stop now.";
+/**
+* Ends on Ctrl-C, SIGTERM, the supervisor's channel closing, or `end`. Each
+* Ctrl-C reaches the child twice (from the terminal, and passed on by the
+* supervisor), so while the supervisor is there, forcing a stop is its job: it
+* kills the child on the second. Without it, a signal after the first stop
+* exits at once.
+*/
+const stopper = () => {
+	let end = ignore;
+	let stopped = false;
+	const promise = new Promise((resolve) => {
+		end = () => {
+			stopped = true;
+			resolve();
+		};
+	});
+	const onSignal = (signal) => {
+		if (stopped && !process.connected) process.exit(128 + constants.signals[signal]);
+		end();
+	};
+	process.on("SIGINT", onSignal);
+	process.on("SIGTERM", onSignal);
+	process.once("disconnect", () => {
+		end();
+	});
+	return {
+		promise,
+		end: () => {
+			end();
+		}
+	};
+};
+/**
+* Waits for an upgrade still running before the server closes, saying so on the
+* terminal: exiting mid-install could leave `ork` half-installed. The
+* installer's output is read to its end meanwhile.
+*/
+const upgradeFinished = async (server, say) => {
+	const running = server.upgrading();
+	if (running === null) return;
+	say(WAITING_FOR_UPGRADE);
+	await running.catch(ignore);
+};
+const serve = async (start, end) => {
+	try {
+		return await startServer({
+			version: ORK_VERSION,
+			port: start.port,
+			token: start.token,
+			ui: uiFolders(),
+			update: { name: ORK_NAME },
+			restart: () => {
+				send({ type: "ork-ui-restart" }).then(end);
+			}
+		});
+	} catch (error) {
+		await send({
+			type: "ork-ui-failed",
+			error: error instanceof Error ? error.message : String(error)
+		});
+		return null;
+	}
+};
+/** `ork ui --serve`: serves until stopped; exits when it closes. */
+const serveForSupervisor = async () => {
+	if (process.send === void 0) {
+		writeErr(NOT_SUPERVISED);
+		process.exitCode = 1;
+		return;
+	}
+	const stop = stopper();
+	const start = await Promise.race([started(), stop.promise.then(() => null)]);
+	const server = start === null ? null : await serve(start, stop.end);
+	if (server !== null) {
+		await send({
+			type: "ork-ui-ready",
+			port: server.port,
+			version: ORK_VERSION
+		});
+		await stop.promise;
+		await upgradeFinished(server, writeErr);
+		await server.close();
+	}
+	process.exit(server === null ? 1 : 0);
+};
+// src/browser/supervise.ts
+/**
+* @file `ork ui`'s process model (ADR-060): the command in the terminal only
+*   supervises; its server runs in a child, the launcher the user ran
+*   (`process.argv[1]` as given, so after an upgrade it is the new install's)
+*   with `ui --serve`. The port and the token go over the child's IPC channel.
+*   When the page asks for a restart, the child says so and exits, and the
+*   supervisor starts the launcher again on the same port with the same token,
+*   so the open tab stays signed in. There is only ever one child; Ctrl-C (or
+*   SIGTERM) stops it and then the supervisor, which exits with its code. The
+*   child may wait for an upgrade to finish first; a second Ctrl-C (or SIGTERM)
+*   kills it and exits at once.
+*/
+/**
+* How long an exited child's channel may take to close before the supervisor
+* decides without it; a child's channel closes with it, so this is only a
+* backstop.
+*/
+const CHANNEL_CLOSE_MS = 2e3;
+/** A shell's exit code for a process a signal stopped. */
+const signalled = (signal) => 128 + constants.signals[signal];
+/** Supervises the server until it stops; resolves the exit code. */
+const supervise = (options) => new Promise((resolve) => {
+	const { token, say, sayErr } = options;
+	let port = options.port;
+	let stopping = false;
+	let ended = false;
+	let restarts = 0;
+	let current = null;
+	const end = (code) => {
+		if (ended) return;
+		ended = true;
+		resolve(code);
+	};
+	const start = () => {
+		let restarting = false;
+		let ready = false;
+		let exited = null;
+		let disconnected = false;
+		let backstop;
+		const child = options.spawnServer();
+		current = child;
+		const decide = () => {
+			clearTimeout(backstop);
+			if (exited === null || ended || current !== child) return;
+			const { code } = exited;
+			if (restarting && !stopping) {
+				restarts += 1;
+				say("Restarting Ork's UI from the installed `ork`…");
+				start();
+				return;
+			}
+			if (!ready && restarts > 0) sayErr(`Ork's UI did not start again (exit ${String(code)}). Start it with: ork ui --port ${String(port)}`);
+			else if (ready && code !== 0 && !stopping) sayErr(`Ork's UI stopped: its server exited with ${String(code)}.`);
+			if (ready) say("Ork's UI stopped.");
+			end(code ?? (stopping ? 0 : 1));
+		};
+		child.onMessage((raw) => {
+			const message = childMessage(raw);
+			if (message?.type === "ork-ui-hello") child.send({
+				type: "ork-ui-start",
+				port,
+				token
+			});
+			else if (message?.type === "ork-ui-ready") {
+				ready = true;
+				({port} = message);
+				options.onReady({
+					port,
+					version: message.version,
+					restarted: restarts > 0
+				});
+			} else if (message?.type === "ork-ui-failed") sayErr(message.error);
+			else if (message?.type === "ork-ui-restart") restarting = true;
+		});
+		child.onExit((code) => {
+			exited = { code };
+			if (disconnected) decide();
+			else backstop = setTimeout(decide, CHANNEL_CLOSE_MS);
+		});
+		child.onDisconnect(() => {
+			disconnected = true;
+			decide();
+		});
+	};
+	options.onStop((signal) => {
+		if (!stopping) {
+			stopping = true;
+			current?.kill(signal);
+			return;
+		}
+		current?.kill("SIGKILL");
+		say("Ork's UI stopped.");
+		end(signalled(signal));
+	});
+	start();
+});
+/**
+* Starts `launcher ui --serve` with the same Node, on this terminal, with an
+* IPC channel for the port and the token.
+*/
+const spawnServerFrom = (launcher) => () => {
+	const child = spawn(process.execPath, [
+		...process.execArgv,
+		launcher,
+		"ui",
+		"--serve"
+	], { stdio: [
+		"inherit",
+		"inherit",
+		"inherit",
+		"ipc"
+	] });
+	return {
+		send: (message) => {
+			if (child.connected) child.send(message);
+		},
+		kill: (signal) => {
+			child.kill(signal);
+		},
+		onMessage: (listener) => {
+			child.on("message", listener);
+		},
+		onExit: (listener) => {
+			let told = false;
+			const once = (code) => {
+				if (told) return;
+				told = true;
+				listener(code);
+			};
+			child.on("error", () => {
+				if (child.pid === void 0) once(1);
+			});
+			child.on("exit", once);
+		},
+		onDisconnect: (listener) => {
+			let told = false;
+			const once = () => {
+				if (told) return;
+				told = true;
+				listener();
+			};
+			child.on("error", () => {
+				if (child.pid === void 0) once();
+			});
+			child.on("disconnect", once);
+		}
+	};
+};
+/** Ctrl-C and SIGTERM, for {@link SuperviseOptions.onStop}. */
+const onStopSignals = (stop) => {
+	for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
+		stop(signal);
+	});
+};
+// src/commands/ui.ts
+/**
+* @file `ork ui`: starts the local server (ADR-039) on loopback and opens it in
+*   the browser, signed in with the server's token; or, when one is already
+*   running (`~/.ork/ui.json`), opens that one. The command supervises the
+*   server in a child process, so the page can restart it onto a newly
+*   installed `ork` (ADR-060). The server runs nothing: runs it starts keep
+*   running when it stops, and the CLI works without it.
+*/
+/** The link that signs the browser in; the server swaps it for a cookie. */
+const signInLink = (port, token) => `http://127.0.0.1:${String(port)}/?token=${token}`;
+/** `--port`: 0 to 65535 (0 picks a free port); `null` when invalid. */
+const portArg = (value) => {
+	if (value === void 0) return DEFAULT_PORT;
+	const port = Number(value);
+	return Number.isInteger(port) && port >= 0 && port <= 65535 ? port : null;
+};
+/** Opens the link, or prints it when there is no browser to open. */
+const show = async (link, open) => {
+	if (!mayShowSignIn()) {
+		writeErr("A program or an agent in a run does not get the sign-in link, which acts as you. Run `ork ui` in your own terminal.");
+		return;
+	}
+	if (!(open && process.stdout.isTTY && await openInBrowser(link))) write(`Open it with this link, which signs you in: ${link}`);
+};
+/** What `ork ui` says once its server serves, the first time or again. */
+const ready = async ({ port, version, restarted }, token, open) => {
+	const url = `http://127.0.0.1:${String(port)}`;
+	if (restarted) {
+		write(`Ork's UI restarted: Ork ${version} at ${url}`);
+		return;
+	}
+	write(`Ork's UI is at ${url}`);
+	write(style("dim", "Runs keep running when it stops, and every ork command works without it. Ctrl-C stops it."));
+	await show(signInLink(port, token), open);
+};
+const ui = defineCommand({
+	meta: {
+		name: "ui",
+		description: "Start Ork's local UI and open it, or open the running one"
+	},
+	args: {
+		port: {
+			type: "string",
+			description: `The port to serve on (default ${String(DEFAULT_PORT)})`
+		},
+		open: {
+			type: "boolean",
+			description: "Open the browser (--no-open only prints the address)",
+			default: true
+		},
+		serve: {
+			type: "boolean",
+			description: "Only for `ork ui` itself: be the server it supervises",
+			default: false
+		}
+	},
+	run: async ({ args }) => {
+		const port = portArg(args.port);
+		if (port === null) {
+			writeErr(`--port must be a number from 0 to 65535, not \`${args.port ?? ""}\`.`);
+			process.exitCode = 1;
+			return;
+		}
+		if (args.serve) {
+			await serveForSupervisor();
+			return;
+		}
+		const running = runningServer(uiFilePath());
+		if (running !== null) {
+			write(`Ork's UI is already running at http://127.0.0.1:${String(running.port)} (process ${String(running.pid)}).`);
+			await show(signInLink(running.port, running.token), args.open);
+			return;
+		}
+		const token = newToken();
+		process.exitCode = await supervise({
+			port,
+			token,
+			spawnServer: spawnServerFrom(process.argv[1] ?? ""),
+			onReady: (answer) => ready(answer, token, args.open),
+			onStop: onStopSignals,
+			say: (line) => {
+				write(style("dim", line));
+			},
+			sayErr: writeErr
+		});
+	}
+});
+export { ui };

package/dist/{usage-BIjf9Xdt.mjs → usage-CJnytoe4.mjs}

@@ -1,10 +1,11 @@
-import { Qt as placeFor, c as usd, en as runDirOf, rt as liveStatus } from "./src-Cz1yOUTg.mjs";
-import { a as write, c as openStore, i as style, n as cost, o as writeErr, t as confirm } from "./output-Q2EdeVUt.mjs";
-import { c as createdWorktrees, l as listOrkWorktrees } from "./format-DqpObyMl.mjs";
+import { Cn as runDirOf, c as usd, ht as liveStatus, xn as placeFor } from "./src-DHvWU4tX.mjs";
+import { a as write, c as openStore, i as style, n as cost, o as writeErr, t as confirm } from "./output-B1V6ZJSx.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-C7UEgmtd.mjs";
 import { n as usageReport, t as USAGE_DIMENSIONS } from "./report-DK4LGqwF.mjs";
-import { n as limitsHere } from "./limits-BKYAmqCR.mjs";
-import { defineCommand } from "citty";
+import "./format-CmTlTOjT.mjs";
+import { n as limitsHere } from "./limits-JCve2QpI.mjs";
 import { existsSync, rmSync } from "node:fs";
+import { defineCommand } from "citty";
 // ../core/src/store/prune.ts
 /**
 * @file `ork prune` (ADR-046): which runs may lose their transcript, and doing

package/dist/{watch-B8o4Szd_.mjs → watch-BJB82ZJ7.mjs}

@@ -1,13 +1,13 @@
-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 { $n as timeoutMs, S as readProjectTriggers, T as watchingPid, Wn as CheckReportSchema, Xn as isToolNode, b as triggerStanding, bn as placeFiles, ht as liveStatus, ot as detachRun, v as triggersReport, w as takeWatchLock, x as declaredTriggers, xt as stillTheSameProcess, y as createWatcher } from "./src-DHvWU4tX.mjs";
+import { n as newRunId } from "./find-BKW-uGey.mjs";
+import { a as write, c as openStore, i as style, o as writeErr, r as plain, t as confirm } from "./output-B1V6ZJSx.mjs";
+import { i as runLimits, r as limitsRefusal } from "./limits-JCve2QpI.mjs";
+import { c as toolExecutor, o as spawnTool, s as mcpCallExecutor } from "./src-C38BPzit.mjs";
+import { t as acceptRefusal } from "./in-a-run-BPXX09Bs.mjs";
 import path from "node:path";
 import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
+import { defineCommand } from "citty";
 const NO_HUMAN = {
 	permit: () => Promise.resolve({
 		allow: false,

package/dist/workflows-CiM7S3l0.mjs

@@ -0,0 +1,88 @@
+import { Cn as runDirOf, En as inside, bn as placeFiles, xn as placeFor } from "./src-DHvWU4tX.mjs";
+import { i as builtinWorkflowFile, r as builtinProblem, s as isBuiltinArg } from "./decide-B81wCZQg.mjs";
+import { c as openStore, l as storePath, o as writeErr } from "./output-B1V6ZJSx.mjs";
+import path from "node:path";
+import { existsSync, readdirSync, statSync } from "node:fs";
+// src/project/place.ts
+/**
+* @file Which project a folder belongs to, from the projects the store has
+*   registered (ADR-035): an attached project's files are in
+*   `~/.ork/projects/<id>/`, an in-repo one's in its `.ork/`.
+*/
+/** The registered projects; none before Ork has a store (never creates one). */
+const registeredProjects = (home) => {
+	const file = storePath(home);
+	if (!existsSync(file)) return [];
+	const store = openStore(file);
+	try {
+		return store.projects();
+	} finally {
+		store.close();
+	}
+};
+/** The project `dir` is in: registered, or the in-repo one at its git root. */
+const projectAt = (dir, home) => placeFor(dir, registeredProjects(home));
+/** A path to show: relative to `cwd` when inside it, else as it is. */
+const fromCwd = (target, cwd) => inside(cwd, target) ? path.relative(cwd, target) || "." : target;
+// src/workflows.ts
+/**
+* @file Finding workflow files: the project's workflows folder by default
+*   (`.ork/workflows/`, or an attached project's), directories expanded, a
+*   workflow given by name, and one of Ork's own by its `ork:` name, written
+*   into the project's run folder.
+*/
+const WORKFLOW_DIR = path.join(".ork", "workflows");
+const WORKFLOW_SUFFIX = ".ork.yaml";
+/**
+* Expands the given paths to workflow files: a directory contributes its
+* `*.ork.yaml` files, and a name one in the project's workflows folder
+* (`workflows`, default `.ork/workflows/` under `cwd`). With no paths, uses
+* that folder.
+*/
+const findWorkflowFiles = (paths, cwd, workflows = path.join(cwd, WORKFLOW_DIR)) => {
+	return (paths.length > 0 ? paths : [fromCwd(workflows, cwd)]).flatMap((target) => {
+		const absolute = path.resolve(cwd, target);
+		if (existsSync(absolute) && statSync(absolute).isDirectory()) return readdirSync(absolute).filter((name) => name.endsWith(WORKFLOW_SUFFIX)).toSorted().map((name) => path.join(target, name));
+		return [resolveWorkflowArg(target, cwd, workflows)];
+	});
+};
+/**
+* A workflow given by path, by name for one in the project's workflows folder
+* (`hello` is `.ork/workflows/hello.ork.yaml` when no file `hello` exists), or
+* by its `ork:` name for one of Ork's own. An unknown `ork:` name comes back as
+* it is: commands refuse it first (`unknownBuiltin`).
+*/
+const resolveWorkflowArg = (arg, cwd, workflows = path.join(cwd, WORKFLOW_DIR)) => {
+	if (isBuiltinArg(arg)) {
+		const file = builtinWorkflowFile(projectAt(cwd), arg);
+		return file === void 0 ? arg : fromCwd(file, cwd);
+	}
+	if (existsSync(path.resolve(cwd, arg)) || arg.endsWith(".ork.yaml")) return arg;
+	const named = path.join(workflows, `${arg}${WORKFLOW_SUFFIX}`);
+	return existsSync(named) ? fromCwd(named, cwd) : arg;
+};
+/**
+* Refuses an `ork:` name that isn't one of Ork's workflows, saying which are,
+* or whose file's place in the project is a link; true when it did, so the
+* command stops.
+*/
+const refusedBuiltin = (args, cwd) => {
+	const problems = args.filter((arg) => isBuiltinArg(arg)).flatMap((arg) => builtinProblem(projectAt(cwd), arg) ?? []);
+	for (const problem of problems) writeErr(problem);
+	if (problems.length > 0) process.exitCode = 1;
+	return problems.length > 0;
+};
+/**
+* A command's workflow argument, by path or by name in the project `cwd` is in,
+* with the project the file belongs to and a run's folder there.
+*/
+const workflowArg = (arg, cwd) => {
+	const file = resolveWorkflowArg(arg, cwd, placeFiles(projectAt(cwd)).workflows);
+	const place = projectAt(path.dirname(path.resolve(cwd, file)));
+	return {
+		file,
+		place,
+		runDir: (runId) => runDirOf(place, runId)
+	};
+};
+export { resolveWorkflowArg as a, registeredProjects as c, refusedBuiltin as i, WORKFLOW_SUFFIX as n, workflowArg as o, findWorkflowFiles as r, projectAt as s, WORKFLOW_DIR as t };