@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/project-records-CtkmlsHN.mjs

@@ -0,0 +1,233 @@
+import { $r as projectRootOf, Gr as newProjectId, Jr as projectsHome, Kr as placeFiles, R as openStore, Ur as hasInRepoFiles, Wr as inRepoPlace, Xr as shownPath } from "./src-BuF9Lbow.mjs";
+import { c as write, l as writeErr, s as style, v as termOf, y as cut } from "./output-DXZbnFt_.mjs";
+import { r as chip } from "./chips-CP_pgKlj.mjs";
+import { t as refuseExtraArguments } from "./extra-arguments-BxQMXARO.mjs";
+import path from "node:path";
+import { existsSync, mkdirSync, realpathSync, statSync } from "node:fs";
+import { defineCommand } from "citty";
+// src/project/register.ts
+/**
+* @file Registering projects (ADR-035): `ork register` attaches a repository
+*   from outside it, with its workflows, rules and runs in
+*   `~/.ork/projects/<id>/` and nothing written into the repository; `ork init`
+*   records an in-repo project, whose files are its `.ork/`.
+*/
+const ID = /^[a-z0-9][a-z0-9._-]*$/u;
+/** The git root of `target`'s main clone, or why there is none. */
+const cloneOf = (target) => {
+	if (!existsSync(target)) return {
+		ok: false,
+		error: `${target} does not exist`
+	};
+	const root = projectRootOf(realpathSync(target));
+	const dotGit = path.join(root, ".git");
+	if (!existsSync(dotGit)) return {
+		ok: false,
+		error: `${target} is not in a git repository`
+	};
+	if (statSync(dotGit).isFile()) return {
+		ok: false,
+		error: `${root} is a git worktree; register the main clone instead`
+	};
+	return {
+		ok: true,
+		root
+	};
+};
+/**
+* Attaches the repository at `target`: creates `~/.ork/projects/<id>/workflows`
+* and records the project. Registering it again returns the same project.
+*/
+const registerProject = (store, target, options = {}) => {
+	const clone = cloneOf(target);
+	if (!clone.ok) return clone;
+	const { root } = clone;
+	const projects = store.projects();
+	const existing = projects.find((p) => p.root === root);
+	if (existing?.mode === "attached") return {
+		ok: true,
+		project: existing,
+		created: false
+	};
+	if (existing !== void 0 || hasInRepoFiles(root)) return {
+		ok: false,
+		error: `${root} keeps Ork's files in its own .ork/ (in-repo), so it is not attached`
+	};
+	const taken = projects.map((p) => p.id);
+	if (options.id !== void 0) {
+		if (!ID.test(options.id)) return {
+			ok: false,
+			error: `--id \`${options.id}\` must be lowercase letters, digits, ".", "_" or "-"`
+		};
+		if (taken.includes(options.id)) return {
+			ok: false,
+			error: `a project is already registered as ${options.id}`
+		};
+	}
+	const id = options.id ?? newProjectId(root, taken);
+	const project = {
+		id,
+		root,
+		mode: "attached",
+		dir: path.join(projectsHome(options.home), id)
+	};
+	mkdirSync(placeFiles(project).workflows, { recursive: true });
+	return {
+		ok: true,
+		project: store.addProject(project),
+		created: true
+	};
+};
+/**
+* Records the in-repo project at `cwd`'s git root, if it is not registered yet;
+* an attached one stays attached (`ork init` must not take it over).
+*/
+const recordInRepo = (store, cwd) => {
+	const root = projectRootOf(realpathSync(cwd));
+	const projects = store.projects();
+	const existing = projects.find((p) => p.root === root);
+	if (existing?.mode === "attached") return {
+		ok: false,
+		error: `${root} is attached: its workflows are in ${shownPath(existing.dir, root)}, and Ork writes nothing into the repository`
+	};
+	if (existing !== void 0) return {
+		ok: true,
+		project: existing,
+		created: false
+	};
+	const project = {
+		...inRepoPlace(root),
+		id: newProjectId(root, projects.map((p) => p.id))
+	};
+	return {
+		ok: true,
+		project: store.addProject(project),
+		created: true
+	};
+};
+/**
+* Points a registered project at its clone's new place, after the clone was
+* moved or renamed; its runs follow, and an in-repo project's `.ork/` with it.
+*/
+const relocateProject = (store, id, target) => {
+	const projects = store.projects();
+	const project = projects.find((p) => p.id === id);
+	if (project === void 0) return {
+		ok: false,
+		error: `No project is registered as ${id}.`
+	};
+	const clone = cloneOf(target);
+	if (!clone.ok) return clone;
+	const { root } = clone;
+	const other = projects.find((p) => p.root === root && p.id !== id);
+	if (other !== void 0) return {
+		ok: false,
+		error: `${root} is already registered as ${other.id}`
+	};
+	const dir = project.mode === "in-repo" ? inRepoPlace(root).dir : project.dir;
+	store.moveProject(id, {
+		root,
+		mode: project.mode,
+		dir
+	});
+	return {
+		ok: true,
+		project: {
+			...project,
+			root,
+			dir
+		},
+		created: false
+	};
+};
+/**
+* One project's lines for `ork projects`; rich, its mode and a missing clone
+* are chips, its id is padded to `idWidth` and its root is cut to the screen.
+*/
+const formatProject = (project, term = termOf(process.stdout), idWidth = 0) => {
+	const missing = !existsSync(project.root);
+	if (!term.rich) {
+		const gone = missing ? style("yellow", " (missing)") : "";
+		return [`${style("bold", project.id)}  ${style("dim", project.mode)}  ${project.root}${gone}`, style("dim", `  files: ${shownPath(project.dir, project.root)}`)];
+	}
+	const mode = chip(term, project.mode.toUpperCase(), "muted");
+	const gone = missing ? ` ${chip(term, "MISSING", "warn")}` : "";
+	const room = term.width - (idWidth + 2 + project.mode.length + 2 + 2) - (missing ? 10 : 0);
+	return [`${style("bold", project.id.padEnd(idWidth))}  ${mode}  ${cut(project.root, Math.max(8, room))}${gone}`, style("dim", cut(`  files: ${shownPath(project.dir, project.root)}`, term.width))];
+};
+/** Every project's lines, their ids aligned when rich. */
+const formatProjects = (projects, term = termOf(process.stdout)) => {
+	const idWidth = term.rich ? Math.max(0, ...projects.map((p) => p.id.length)) : 0;
+	return projects.flatMap((p) => formatProject(p, term, idWidth));
+};
+/** What `ork register` prints: the project, and where its files go. */
+const formatRegistered = (project, created) => {
+	const files = placeFiles(project);
+	const shown = (file) => shownPath(file, project.root);
+	return [
+		`${style("green", created ? "registered" : "already registered")} ${project.id} → ${project.root}`,
+		`\nWorkflows: ${shown(files.workflows)}/ · rules: ${shown(files.rules)} · runs: ${shown(files.runs)}/`,
+		`Nothing is written into ${project.root}. In it, ${style("bold", "ork run <name>")} finds the workflows above.`
+	];
+};
+// src/commands/project-records.ts
+/**
+* @file `ork projects`' subcommands on one project's record (ADR-035): `forget`
+*   drops it and keeps its files and runs; `move` points it at its clone's new
+*   place after the clone was moved or renamed, and its runs follow.
+*/
+/** Runs `use` with the store open, and closes it. */
+const withStore = (use) => {
+	const store = openStore();
+	try {
+		return use(store);
+	} finally {
+		store.close();
+	}
+};
+const id = {
+	type: "positional",
+	description: "The project's id",
+	required: true
+};
+const forget = defineCommand({
+	meta: {
+		name: "forget",
+		description: "Forget a registered project; its files and runs are kept"
+	},
+	plugins: [refuseExtraArguments],
+	args: { id },
+	run: ({ args }) => {
+		if (withStore((store) => store.forgetProject(args.id))) {
+			write(`${style("green", "forgot")} ${args.id} (its files are kept)`);
+			return;
+		}
+		writeErr(`No project is registered as ${args.id}.`);
+		process.exitCode = 1;
+	}
+});
+const move = defineCommand({
+	meta: {
+		name: "move",
+		description: "Point a registered project at its clone's new place, after moving or renaming it"
+	},
+	plugins: [refuseExtraArguments],
+	args: {
+		id,
+		path: {
+			type: "positional",
+			description: "Where the clone is now",
+			required: true
+		}
+	},
+	run: ({ args }) => {
+		const result = withStore((store) => relocateProject(store, args.id, args.path));
+		if (result.ok) {
+			write(`${style("green", "moved")} ${args.id} → ${result.project.root}`);
+			return;
+		}
+		writeErr(result.error);
+		process.exitCode = 1;
+	}
+});
+export { formatRegistered as a, formatProjects as i, move as n, recordInRepo as o, withStore as r, registerProject as s, forget as t };

package/dist/refusals-DQQX3AIb.mjs

@@ -0,0 +1,116 @@
+// ../core/src/list-filters/time.ts
+/**
+* @file The times every list's `--since` and `--until` take (specs/usage.md,
+*   RFC-017), and `ork prune --older-than`'s age: an age (`24h`, `30d`, `12w`)
+*   or a day (`2026-11-01`, in the machine's time zone).
+*/
+const UNITS = {
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5
+};
+/** `30d`, `12w`, `24h` before `now`, as an ISO time; `null` when it is not one. */
+const agoTime = (text, now) => {
+	const match = /^(\d+)([hdw])$/u.exec(text);
+	if (match === null) return null;
+	const [, amount = "0", unit = "d"] = match;
+	if (Number(amount) === 0) return null;
+	const date = new Date(now - Number(amount) * (UNITS[unit] ?? 0));
+	return Number.isNaN(date.getTime()) ? null : date.toISOString();
+};
+/** A `YYYY-MM-DD` day's start in the machine's time zone, `after` days on. */
+const dayTime = (text, after) => {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(text);
+	if (match === null) return null;
+	const [, year = "", month = "", day = ""] = match;
+	const start = new Date(Number(year), Number(month) - 1, Number(day));
+	if (start.getMonth() !== Number(month) - 1) return null;
+	if (start.getDate() !== Number(day)) return null;
+	start.setDate(start.getDate() + after);
+	return start.toISOString();
+};
+/** The start of the day `days` whole days ago, counting today as one. */
+const wholeDays = (days, now) => {
+	const today = new Date(now);
+	return new Date(today.getFullYear(), today.getMonth(), today.getDate() - (days - 1)).toISOString();
+};
+/**
+* `--since`: an age or the day it starts from. Days and weeks are whole days,
+* today among them, as the Usage panel counts them; hours are exact.
+*/
+const sinceTime = (text, now) => {
+	const ago = agoTime(text, now);
+	if (ago === null) return dayTime(text, 0);
+	if (text.endsWith("h")) return ago;
+	const amount = Number(text.slice(0, -1));
+	return wholeDays(text.endsWith("w") ? amount * 7 : amount, now);
+};
+/** `--until`: the last day it includes. */
+const untilTime = (text) => dayTime(text, 1);
+// ../core/src/list-filters/parse.ts
+/**
+* @file Reads a list's filter flags against its field table (RFC-017): each
+*   value checked, times turned into ISO times, and `--limit`.
+*/
+const FOR = /^(agent|me|(project|person):\S+)$/u;
+/** The field's value, checked; `null` when the field does not take it. */
+const valueOf = (field, text, now) => {
+	if (text === "all" && field.all === true) return "all";
+	return {
+		enum: () => field.values?.includes(text) === true ? text : null,
+		text: () => text === "" ? null : text,
+		for: () => FOR.test(text) ? text : null,
+		since: () => sinceTime(text, now),
+		until: () => untilTime(text)
+	}[field.type]();
+};
+/** What the field takes, for the error that refuses a value. */
+const takes = (field) => {
+	const all = field.all === true ? ["all"] : [];
+	const or = all.length === 0 ? "" : " or all";
+	return {
+		enum: `one of ${[...field.values ?? [], ...all].join(", ")}`,
+		text: `a value${or}`,
+		for: "agent, me, project:<name> or person:<name>",
+		since: `an age (30d), a day (2026-11-01)${or}`,
+		until: "a day (2026-11-01)"
+	}[field.type];
+};
+/**
+* The filter `given` (a command's parsed flags, by field name) asks for, each
+* value checked against `table`; `now` dates an age. The first value a field
+* does not take is refused, naming the flag and what it takes.
+*/
+const parseFilters = (table, given, now) => {
+	const filter = {};
+	for (const field of table.fields) {
+		const text = given[field.name];
+		if (typeof text !== "string") continue;
+		const value = valueOf(field, text, now);
+		if (value === null) return {
+			ok: false,
+			error: `--${field.name} takes ${takes(field)}, not \`${text}\`.`
+		};
+		filter[field.name] = value;
+	}
+	return {
+		ok: true,
+		filter
+	};
+};
+/** `--limit`: a positive whole number, else `null` (`0`, `-1`, `abc`, `2.5`). */
+const parseLimit = (text) => {
+	if (!/^[1-9]\d*$/u.test(text)) return null;
+	const limit = Number(text);
+	return Number.isSafeInteger(limit) ? limit : null;
+};
+// ../core/src/list-filters/refusals.ts
+/**
+* @file The sentences a list refuses with, shared so `ork` and `ork mcp` say
+*   the same words (the server cannot import the CLI).
+*/
+/** The refusal for a `--limit` that is not a positive whole number in digits. */
+const limitRefusal = (text) => `--limit takes a positive whole number written in digits, not \`${text}\`.`;
+/** The refusal for a `--project` that names no registered project. */
+const unknownProjectRefusal = (key, ids) => `No registered project \`${key}\`; registered: ${ids.length === 0 ? "none" : ids.join(", ")}.`;
+export { agoTime as a, parseLimit as i, unknownProjectRefusal as n, parseFilters as r, limitRefusal as t };

package/dist/{relay-0SD0erwf.mjs → relay-CiP77vga.mjs}

@@ -1,5 +1,5 @@
-import { B as linkNodes, L as addressOf, U as unlinkNodes } from "./src-Dujmvv4s.mjs";
-import { a as write, c as openStore, i as style, o as writeErr } from "./output-BLQWD6MJ.mjs";
+import { En as addressOf, On as linkNodes, R as openStore, kn as unlinkNodes } from "./src-BuF9Lbow.mjs";
+import { c as write, l as writeErr, s as style } from "./output-DXZbnFt_.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts
 /**

package/dist/run-CtuNY3mE.mjs

@@ -0,0 +1,234 @@
+import { in as gitOk, rn as git } from "./src-BuF9Lbow.mjs";
+import path from "node:path";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+// ../core/src/once/key.ts
+/**
+* @file The key of a check run once (`ork once`, `verify: { once: true }`): the
+*   working tree's files as a git tree (tracked and untracked, not ignored),
+*   written through a temporary index so the real one is untouched, with `HEAD`
+*   and the repository's common git folder, where passes are kept for every
+*   worktree. The key is the files, not the commit: a commit or a no-op rebase
+*   keeps it. With pathspecs (`--on`), only the files they match count.
+*/
+/**
+* Git rejected the pathspecs, or they match no file: a usage error, never a
+* silent hit.
+*/
+var OncePathspecError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OncePathspecError";
+	}
+};
+/** The part of the key a pass is matched on: the files, else the tree. */
+const filesOf = (key) => key.files ?? key.tree;
+/**
+* The key of the files in the worktree at `cwd`. Rejects outside a git
+* repository, and with `OncePathspecError` when git rejects `on` or it matches
+* no file. Starts from a copy of the real index, so git hashes only the files
+* whose stat changed.
+*/
+const treeKeyOf = async (cwd, { on = [] } = {}) => {
+	const [commonDir = "", index = ""] = (await gitOk(cwd, [
+		"rev-parse",
+		"--git-common-dir",
+		"--git-path",
+		"index"
+	])).split("\n").map((line) => path.resolve(cwd, line.trim()));
+	const scratch = mkdtempSync(path.join(tmpdir(), "ork-once-"));
+	const env = { GIT_INDEX_FILE: path.join(scratch, "index") };
+	try {
+		if (existsSync(index)) copyFileSync(index, env.GIT_INDEX_FILE);
+		await gitOk(cwd, ["add", "-A"], env);
+		const tree = (await gitOk(cwd, ["write-tree"], env)).trim();
+		const head = await git(cwd, [
+			"rev-parse",
+			"--verify",
+			"-q",
+			"HEAD"
+		]);
+		const key = {
+			tree,
+			head: head.code === 0 ? head.stdout.trim() : null,
+			commonDir
+		};
+		if (on.length === 0) return key;
+		const listed = await git(cwd, [
+			"ls-files",
+			"-s",
+			"-z",
+			"--full-name",
+			"--",
+			...on
+		], env);
+		if (listed.code !== 0) throw new OncePathspecError(`git rejected the pathspecs ${on.join(" ")}: ${listed.stderr.trim()}`);
+		if (listed.stdout === "") throw new OncePathspecError(`the pathspecs ${on.join(" ")} match no file: check them, or drop --on to key every file`);
+		const files = createHash("sha256").update(listed.stdout).digest("hex");
+		return {
+			...key,
+			files,
+			on: [...on]
+		};
+	} finally {
+		rmSync(scratch, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+// ../core/src/once/store.ts
+/**
+* @file The passes of checks run once, kept in `<git-common-dir>/ork-once/`,
+*   outside every worktree and shared by all of them. A pass is one JSON file
+*   per check name, files and Node version; it holds the tree, `HEAD`, the time
+*   and who ran it, nothing else. Only a passing run writes one (Ork's process
+*   or the check's own, never an agent's edit). Pruned past 7 days or 500
+*   entries.
+*/
+const ONCE_MAX_AGE_MS = 6048e5;
+/** The folder of passes for a repository's common git folder. */
+const onceDirOf = (commonDir) => path.join(commonDir, "ork-once");
+/** Without pathspecs the name key is unchanged, so earlier passes still hit. */
+const fileOf = (dir, name, key, node) => path.join(dir, `${createHash("sha256").update(JSON.stringify(key.on === void 0 || key.on.length === 0 ? [
+	name,
+	key.tree,
+	node
+] : [
+	name,
+	filesOf(key),
+	node,
+	key.on
+])).digest("hex")}.json`);
+const read = (file) => {
+	try {
+		const value = JSON.parse(readFileSync(file, "utf8"));
+		if (typeof value !== "object" || value === null || !("name" in value && "tree" in value && "head" in value && "node" in value && "at" in value && "who" in value)) return null;
+		const { name, tree, head, node, at, who } = value;
+		return typeof name === "string" && typeof tree === "string" && (typeof head === "string" || head === null) && typeof node === "string" && typeof at === "string" && typeof who === "string" ? {
+			name,
+			tree,
+			head,
+			node,
+			at,
+			who
+		} : null;
+	} catch {
+		return null;
+	}
+};
+/** The pass of `name` on these files, or `null`. */
+const findPass = ({ key, name, withHead = false, node = process.version }) => {
+	const pass = read(fileOf(onceDirOf(key.commonDir), name, key, node));
+	if (pass === null || pass.tree !== filesOf(key) || pass.node !== node) return null;
+	return withHead && pass.head !== key.head ? null : pass;
+};
+/** Records a pass under `name` and each covered name, then prunes. */
+const recordPass = ({ key, name, covers = [], who, node = process.version, at = /* @__PURE__ */ new Date() }) => {
+	const dir = onceDirOf(key.commonDir);
+	mkdirSync(dir, { recursive: true });
+	const pass = {
+		name,
+		tree: filesOf(key),
+		head: key.head,
+		node,
+		at: at.toISOString(),
+		who
+	};
+	for (const each of [name, ...covers]) {
+		const temp = path.join(dir, `.${randomUUID()}.tmp`);
+		writeFileSync(temp, `${JSON.stringify({
+			...pass,
+			name: each
+		})}\n`);
+		renameSync(temp, fileOf(dir, each, key, node));
+	}
+	prunePasses(key.commonDir, { now: at });
+	return pass;
+};
+/**
+* Removes passes older than `maxAgeMs` or past the newest `maxEntries`, and
+* files that don't read as a pass. Returns how many it removed.
+*/
+const prunePasses = (commonDir, { now = /* @__PURE__ */ new Date(), maxAgeMs = ONCE_MAX_AGE_MS, maxEntries = 500 } = {}) => {
+	const dir = onceDirOf(commonDir);
+	let names;
+	try {
+		names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+	} catch {
+		return 0;
+	}
+	const kept = [];
+	const stale = [];
+	for (const name of names) {
+		const file = path.join(dir, name);
+		const at = Date.parse(read(file)?.at ?? "");
+		if (Number.isNaN(at) || now.getTime() - at > maxAgeMs) stale.push(file);
+		else kept.push({
+			file,
+			at
+		});
+	}
+	kept.sort((a, b) => b.at - a.at);
+	stale.push(...kept.slice(maxEntries).map((entry) => entry.file));
+	for (const file of stale) rmSync(file, { force: true });
+	return stale.length;
+};
+// ../core/src/once/run.ts
+/**
+* @file Runs a check once per set of files, for `ork once` and for
+*   `verify:`/tool commands with `once: true`: skip it when the same check
+*   already passed on identical files, else run it and record a pass when it
+*   exits 0 and the files didn't change while it ran. `force` and
+*   `ORK_ONCE=off` run it anyway; outside a git repository it always runs.
+*/
+/**
+* `null` outside a git repository: nothing to key the files by. Rejected
+* pathspecs reject, so a bad `--on` is an error, never a run without a key.
+*/
+const keyOf = (cwd, on) => treeKeyOf(cwd, { on }).catch((error) => {
+	if (error instanceof OncePathspecError) throw error;
+	return null;
+});
+/** Runs `run` unless the check already passed on these files. */
+const runOnce = async ({ cwd, name, covers = [], withHead = false, on = [], force = false, who = "you", run, env = process.env, node = process.version }) => {
+	if (env["ORK_ONCE"] === "off") return {
+		skipped: false,
+		code: await run()
+	};
+	const before = await keyOf(cwd, on);
+	const earlier = before === null || force ? null : findPass({
+		key: before,
+		name,
+		withHead,
+		node
+	});
+	if (earlier !== null) return {
+		skipped: true,
+		pass: earlier,
+		code: 0
+	};
+	const code = await run();
+	if (code !== 0 || before === null) return {
+		skipped: false,
+		code
+	};
+	const after = await keyOf(cwd, on).catch(() => null);
+	if (after === null || filesOf(after) !== filesOf(before) || after.head !== before.head) return {
+		skipped: false,
+		code
+	};
+	return {
+		skipped: false,
+		pass: recordPass({
+			key: before,
+			name,
+			covers,
+			who,
+			node
+		}),
+		code
+	};
+};
+export { OncePathspecError as n, runOnce as t };

package/dist/send-DRYGks8K.mjs

@@ -0,0 +1,104 @@
+import { R as openStore, et as TOO_LONG, nt as sendFromScript, tt as scriptRefusal } from "./src-BuF9Lbow.mjs";
+import { u as inheritedScrubber } from "./src-k0A_QpST.mjs";
+import { l as writeErr } from "./output-DXZbnFt_.mjs";
+import { defineCommand } from "citty";
+// src/commands/send.ts
+/**
+* @file `ork send` (RFC-005): a program in a tool node writes to a session on
+*   its run's bus. It prints nothing when it works, as what a program prints is
+*   its node's output, and says why on stderr, with exit 1, when it is refused:
+*   before reading a message it could not send, and for anything wrong with the
+*   command itself, which would otherwise go to stdout as usage.
+*/
+const refuse = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
+/** Stdin, up to the limit: past it, the rest is not worth holding. */
+const readBounded = async () => {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of process.stdin) {
+		const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+		size += part.length;
+		if (size > 65536) return null;
+		chunks.push(part);
+	}
+	return Buffer.concat(chunks);
+};
+/** The message, or why it can't go. */
+const bodyOf = async (given) => {
+	if (given !== void 0) return { body: given };
+	const read = await readBounded();
+	if (read === null) return { refused: TOO_LONG };
+	try {
+		return { body: new TextDecoder("utf-8", { fatal: true }).decode(read) };
+	} catch {
+		return { refused: "The message is not UTF-8 text." };
+	}
+};
+const deliver = async (store, to, given) => {
+	const sender = {
+		run: process.env["ORK_RUN"],
+		node: process.env["ORK_NODE"],
+		to
+	};
+	const refused = scriptRefusal(store, sender);
+	if (refused !== null) {
+		refuse(refused);
+		return;
+	}
+	const message = await bodyOf(given);
+	if ("refused" in message) {
+		refuse(message.refused);
+		return;
+	}
+	if (message.body.replaceAll(/[\p{Cc}\s]/gu, "") === "") {
+		refuse("The message is empty.");
+		return;
+	}
+	const sent = await sendFromScript(store, {
+		...sender,
+		body: inheritedScrubber(process.env)(message.body)
+	});
+	if (!sent.ok) refuse(sent.error);
+};
+const send = defineCommand({
+	meta: {
+		name: "send",
+		description: "From a tool node's program: write to a session in its run"
+	},
+	args: {
+		to: {
+			type: "positional",
+			description: "The node to write to: the owner, or a channel",
+			required: false
+		},
+		message: {
+			type: "string",
+			description: "The message"
+		},
+		stdin: {
+			type: "boolean",
+			description: "Read the message from stdin",
+			default: false
+		}
+	},
+	run: async ({ args }) => {
+		if (args.to === void 0 || args._.length !== 1) {
+			refuse("Give one node to write to: ork send <to> -m <body>.");
+			return;
+		}
+		if (args.message === void 0 === !args.stdin) {
+			refuse("Give the message with -m or --stdin, one of them.");
+			return;
+		}
+		const store = openStore();
+		try {
+			await deliver(store, args.to, args.message);
+		} finally {
+			store.close();
+		}
+	}
+});
+export { send };

package/dist/short-flags-DkJLWVqh.mjs

@@ -0,0 +1 @@
+export { a as withShortFlags } from "./short-flags-Qf21as0E.mjs";