@stringsync/splates 0.0.53 → 0.0.54

package/task.ts

@@ -1,354 +0,0 @@
-import {
-	addedFacts,
-	recordUpdate,
-	taskAdd,
-	taskList,
-	taskRemove,
-	taskShow,
-	tasksNamed,
-	taskUpdate,
-} from "@stringsync/splates-server/board";
-import { commaList } from "@stringsync/splates-server/comma-list";
-import { refuseGroomer } from "@stringsync/splates-server/conversations";
-import { fail } from "@stringsync/splates-server/exit";
-import { repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import {
-	DEFAULT_TIMEOUT,
-	taskWait,
-	untilAfter,
-} from "@stringsync/splates-server/tasks";
-import { cli } from "webappwiz/cmd";
-import { Duration } from "webappwiz/time";
-import { z } from "zod";
-import { assigneeIn, here, laneIn, position, taskIds } from "./flags";
-
-/** `splates task`, the queue, which the root cli mounts after the commands for the task you work on. */
-export const splatesTask = cli<SplatesDeps>("task").description(
-	"the numbered tasks: defer work for later instead of growing the task you are in, and `splates add <slug> --task <n>` starts one; `merge` recommends the next one when a task lands. The person puts tasks in `splates queue`, for workers to start",
-);
-
-/**
- * This project's slug when the command is run from another with `--project`,
- * so what it prints names a task as `webappwiz #12`, which the page links to
- * this project; undefined from this project itself, where `#12` is bare.
- */
-async function projectFrom(ctx: {
-	elsewhere: string | null;
-	git: { root: string };
-	projects: { list(): Promise<{ root: string; slug: string }[]> };
-}): Promise<string | undefined> {
-	if (ctx.elsewhere === null) {
-		return undefined;
-	}
-	return (await ctx.projects.list()).find((each) => each.root === ctx.git.root)
-		?.slug;
-}
-
-/**
- * `splates task add` or `defer`: one writes a task its agent groomed, for
- * ready, the other a rough one, for the backlog and whoever grooms it.
- */
-function adding(name: string, description: string, ready: boolean) {
-	splatesTask
-		.command(name)
-		.use(repository({ needs: "queue" }))
-		.description(description)
-		.arg("subject", z.string(), {
-			description: "what is left to do, in a line",
-		})
-		.arg("text", z.string(), {
-			default: "",
-			description: "whatever more there is to say about it, in markdown",
-		})
-		.option("slug", z.string(), {
-			description:
-				"a short name for the task that takes it (lowercase-with-dashes), naming its branch, worktree and conversation: a few words for what it changes, not the subject cut short",
-		})
-		.option("position", position, {
-			description:
-				"where it goes in the list, 1 at the top, pushing those from there down (default: the bottom)",
-		})
-		.option("file", z.string(), {
-			default: "",
-			description:
-				"files to attach, comma separated: copied under .git/splates/tasks/<n>/",
-		})
-		.option("blocked-by", z.string(), {
-			default: "",
-			description:
-				"numbers of the tasks blocking it, comma separated: each has to merge before this one starts",
-		})
-		.option("lane", z.string(), {
-			default: "",
-			description:
-				"the lane it goes in, at the bottom: a lane's number, `backlog` for the permanent catch-all, or `new` for one of its own (default: none, untriaged)",
-		})
-		.option("agent", z.string(), {
-			default: "",
-			description:
-				"the agent on the roster (`splates agents`) that should work it, which Start on the `splates server` board offers first",
-		})
-		.option("model", z.string(), {
-			default: "",
-			description: "with --agent: the model, by its id or name on the roster",
-		})
-		.option("effort", z.string(), {
-			default: "",
-			description:
-				"with --agent: the thinking level, one the agent offers (default: the agent's own)",
-		})
-		.action(async (opts, ctx) => {
-			if (ctx.elsewhere !== null && opts.lane !== "") {
-				fail(
-					"not_granted",
-					"a task from another project goes in its untriaged lane, for whoever orchestrates it there to place: leave --lane off",
-					{ subject: opts.subject },
-				);
-			}
-			const from = await here(ctx);
-			const assignee = await assigneeIn(
-				ctx,
-				opts.agent,
-				opts.model,
-				opts.effort,
-			);
-			// Run with `--project`, the working directory is in the other project.
-			const origin =
-				ctx.elsewhere === null
-					? undefined
-					: {
-							project: ctx.elsewhere,
-							task:
-								ctx.project === undefined
-									? null
-									: ctx.service.taskFor(
-											await ctx.git.currentBranch(ctx.ps.cwd()),
-										),
-						};
-			const project = await projectFrom(ctx);
-			await ctx.journal.record(
-				"task add",
-				from,
-				() =>
-					taskAdd(ctx, opts.subject, from, {
-						slug: opts.slug,
-						text: opts.text,
-						position: opts.position,
-						files: commaList(opts.file),
-						blockedBy: taskIds(opts["blocked-by"]),
-						lane: laneIn(opts.lane) ?? null,
-						assignee,
-						origin,
-						ready,
-						project,
-					}),
-				addedFacts,
-			);
-		});
-}
-
-adding(
-	"add",
-	"queue a task to do later and move on, groomed, so it goes in ready: you checked no task already asks it, and linked what blocks it; run from a worktree, it records the task it came up in",
-	true,
-);
-
-adding(
-	"defer",
-	"queue a task as it is, rough, in the backlog for whoever grooms it: to check for one that already asks it, link what blocks it, and mark it ready; run from a worktree, it records the task it came up in",
-	false,
-);
-
-splatesTask
-	.command("list")
-	.use(repository({ needs: "read" }))
-	.description(
-		"every queued task, top of the list first, with the task it came from and the started one that took it up",
-	)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.option("open", z.boolean(), {
-		default: false,
-		description:
-			"only tasks no started one has taken up: the ones free to pick up",
-	})
-	.option("ready", z.boolean(), {
-		default: false,
-		description:
-			"only tasks free to start now: none has taken them, and nothing blocking them is still open",
-	})
-	.action(async (opts, ctx) =>
-		taskList(ctx, {
-			json: opts.json,
-			open: opts.open,
-			ready: opts.ready,
-			project: await projectFrom(ctx),
-		}),
-	);
-
-splatesTask
-	.command("show")
-	.use(repository({ needs: "read" }))
-	.description("one task in full: where it stands, its files, and its detail")
-	.arg("id", z.coerce.number().int().positive(), { description: "task number" })
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action(async (opts, ctx) =>
-		taskShow(ctx, opts.id, {
-			json: opts.json,
-			project: await projectFrom(ctx),
-			others: (await ctx.projects.list())
-				.filter((project) => project.root !== ctx.git.root)
-				.map((project) => project.slug),
-		}),
-	);
-
-splatesTask
-	.command("update")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"say what a queued task is in other words, move it up or down the list, or attach and drop files; it keeps its number",
-	)
-	.arg("id", z.coerce.number().int().positive(), { description: "task number" })
-	.arg("text", z.string(), {
-		default: "",
-		description:
-			"whatever more there is to say about it, in markdown; leave out to keep the detail",
-	})
-	.option("subject", z.string(), {
-		default: "",
-		description: "what is left to do, in a line; leave out to keep it",
-	})
-	.option("slug", z.string(), {
-		default: "",
-		description:
-			"a new name for the task that takes it (lowercase-with-dashes); leave out to keep it",
-	})
-	.option("position", position, {
-		description:
-			"where to move it in the list, 1 at the top; the others close up around it",
-	})
-	.option("file", z.string(), {
-		default: "",
-		description: "files to attach, comma separated",
-	})
-	.option("remove-file", z.string(), {
-		default: "",
-		description:
-			"attached files to drop, comma separated, by path or stored name",
-	})
-	.option("blocked-by", z.string(), {
-		default: "",
-		description:
-			"numbers of more tasks blocking it, comma separated: each has to merge before this one starts; refused when that makes a loop",
-	})
-	.option("remove-blocked-by", z.string(), {
-		default: "",
-		description: "numbers of tasks no longer blocking it, comma separated",
-	})
-	.option("lane", z.string(), {
-		default: "",
-		description:
-			"move it to a lane, at the bottom: a lane's number, `backlog` for the permanent catch-all, `new` for one of its own, or `none` for untriaged",
-	})
-	.option("agent", z.string(), {
-		default: "",
-		description:
-			"the agent on the roster (`splates agents`) that should work it, which Start on the `splates server` board offers first, or `none`",
-	})
-	.option("model", z.string(), {
-		default: "",
-		description: "with --agent: the model, by its id or name on the roster",
-	})
-	.option("effort", z.string(), {
-		default: "",
-		description:
-			"with --agent: the thinking level, one the agent offers (default: the agent's own)",
-	})
-	.option("ready", z.boolean(), {
-		default: false,
-		description:
-			"mark it groomed, moving it from the backlog to ready: no task already asks it, and what blocks it is linked",
-	})
-	.option("manual", z.boolean(), {
-		default: false,
-		description:
-			"queue it by hand only: a queued lane passes over it, and it starts once you `splates queue add` it",
-	})
-	.option("auto", z.boolean(), {
-		default: false,
-		description: "let a queued lane queue it again, undoing --manual",
-	})
-	.action(async (opts, ctx) => {
-		if (opts.manual && opts.auto) {
-			fail("usage", "pass --manual or --auto, not both", { number: opts.id });
-		}
-		await refuseGroomer(
-			ctx.service,
-			"task update",
-			await ctx.tasks.find(opts.id),
-		);
-		const assignee = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
-		await recordUpdate(ctx.journal, ctx.tasks, opts.id, () =>
-			taskUpdate(ctx, opts.id, {
-				subject: opts.subject,
-				slug: opts.slug,
-				text: opts.text,
-				position: opts.position,
-				files: commaList(opts.file),
-				removeFiles: commaList(opts["remove-file"]),
-				blockedBy: taskIds(opts["blocked-by"]),
-				removeBlockedBy: taskIds(opts["remove-blocked-by"]),
-				lane: laneIn(opts.lane),
-				assignee,
-				ready: opts.ready,
-				manual: opts.manual ? true : opts.auto ? false : undefined,
-			}),
-		);
-	});
-
-splatesTask
-	.command("remove")
-	.use(repository({ needs: "tasks" }))
-	.description(
-		"drop a queued task that was done some other way or no longer applies",
-	)
-	.arg("id", z.coerce.number().int().positive(), { description: "task number" })
-	.action(async (opts, ctx) => {
-		await refuseGroomer(
-			ctx.service,
-			"task remove",
-			await ctx.tasks.find(opts.id),
-		);
-		await ctx.journal.record(
-			"task remove",
-			null,
-			() => taskRemove(ctx, opts.id),
-			(removed) => ({ tasks: tasksNamed([removed]) }),
-		);
-	});
-
-splatesTask
-	.command("wait")
-	.use(repository({ needs: "read" }))
-	.description(
-		"block until a task leaves the queue, which it does when the task that took it merges: for a task blocked by one another lane is on; ends early when that task waits on a person to answer its questions, and gives up with `timeout`",
-	)
-	.arg("id", z.coerce.number().int().positive(), { description: "task number" })
-	.option("timeout-secs", z.coerce.number(), {
-		default: DEFAULT_TIMEOUT.secs,
-		description: "how long to wait before giving up",
-	})
-	.action(async (opts, ctx) => {
-		const timeout = Duration.secs(opts["timeout-secs"]);
-		const task = (await ctx.tasks.all()).find((each) => each.id === opts.id);
-		await ctx.journal.waiting(
-			"task wait",
-			null,
-			{
-				number: opts.id,
-				subject: task?.subject ?? null,
-				until: untilAfter(timeout),
-			},
-			() => taskWait(ctx, opts.id, { timeout }),
-		);
-	});

package/tunnel.ts

@@ -1,106 +0,0 @@
-import { repository } from "@stringsync/splates-server/records";
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { savedTunnelOf } from "@stringsync/splates-server/server";
-import {
-	API_TOKEN,
-	tunnelRemove,
-	tunnelSetup,
-} from "@stringsync/splates-server/tunnel";
-import { cli } from "webappwiz/cmd";
-import { z } from "zod";
-import { here, slotTunnelsOf } from "./flags";
-
-/** `splates tunnel`, which the root cli mounts after `splates lane`. */
-export const splatesTunnel = cli<SplatesDeps>("tunnel").description(
-	"reach `splates server` from elsewhere: a Cloudflare tunnel with Cloudflare Access in front, set up once per machine",
-);
-
-splatesTunnel
-	.command("setup")
-	.use(repository({ needs: "own" }))
-	.description(
-		`make a Cloudflare tunnel to \`splates server\`, the DNS record routing <host> to it, and an Access application letting in only --email, through the API with the token kept as the cred ${API_TOKEN}, then save them for this machine, so a bare \`splates server\` comes up tunneled; run again, it changes only what is not so already. Without that token it requests it on the Creds page of \`splates server\`, with how to make it, and exits \`requested\`: \`splates creds wait ${API_TOKEN}\`, then run it again`,
-	)
-	.arg("host", z.string(), {
-		description:
-			"the public host name, in a zone of the account, as in splates.example.com",
-	})
-	.option("email", z.string(), {
-		default: "",
-		description: "comma-separated email addresses Access lets in",
-	})
-	.option("name", z.string(), {
-		default: "splates",
-		description:
-			"what the tunnel, the Access application and its policy are called",
-	})
-	.option("team", z.string(), {
-		default: "",
-		description:
-			"the Zero Trust team to make, as in <team>.cloudflareaccess.com, when the account has none yet",
-	})
-	.action(async (opts, ctx) =>
-		ctx.journal.record("tunnel setup", null, async () =>
-			tunnelSetup({
-				...opts,
-				creds: ctx.creds,
-				task: await here(ctx),
-				saved: savedTunnelOf(ctx),
-				log: ctx.log,
-				fetch: ctx.fetch,
-			}),
-		),
-	);
-
-splatesTunnel
-	.command("status")
-	.description(
-		"print the tunnel `splates tunnel setup` saved for this machine, which a bare `splates server` runs, and whether its token is in the system's secret store",
-	)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action(async (opts, ctx) => {
-		const saved = savedTunnelOf(ctx);
-		const record = await saved.read();
-		const token = record === null ? false : (await saved.token()) !== undefined;
-		if (opts.json) {
-			ctx.log.info(
-				JSON.stringify(record === null ? null : { ...record, token }),
-			);
-			return;
-		}
-		if (record === null) {
-			ctx.log.info(
-				"no tunnel saved: `splates tunnel setup <host> --email <you>` makes one",
-			);
-			return;
-		}
-		ctx.log.info(
-			[
-				`host:    https://${record.host}`,
-				`team:    ${record.team}.cloudflareaccess.com`,
-				`aud:     ${record.aud}`,
-				`tunnel:  ${record.tunnel}`,
-				`token:   ${token ? "in the device's store" : "missing: run `splates tunnel setup` again"}`,
-			].join("\n"),
-		);
-	});
-
-splatesTunnel
-	.command("remove")
-	.use(repository({ needs: "own" }))
-	.description(
-		`delete what \`splates tunnel setup\` and \`splates server --slot\` made in Cloudflare by what they saved: each tunnel, the DNS record routing to it, the Access applications and their policy, then forget the saved files and the tunnels' tokens; the API token kept as ${API_TOKEN} stays. Run again after a failure, it finishes what is left`,
-	)
-	.action(async (_opts, ctx) =>
-		ctx.journal.record("tunnel remove", null, async () =>
-			tunnelRemove({
-				saved: savedTunnelOf(ctx),
-				slots: slotTunnelsOf(ctx),
-				creds: ctx.creds,
-				task: await here(ctx),
-				fs: ctx.fs,
-				log: ctx.log,
-				fetch: ctx.fetch,
-			}),
-		),
-	);

package/wait-journal.test.ts

@@ -1,96 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import type { Event } from "@stringsync/splates-server/records";
-import { Testing } from "@stringsync/splates-server/testing";
-import { Duration, sleep } from "webappwiz/time";
-import { splates } from "./splates";
-
-describe("splates's waits in the journal", () => {
-	let env: Testing;
-	let deps: Parameters<typeof splates.run>[0];
-
-	beforeEach(async () => {
-		env = await Testing.open();
-		env.ps.cd(env.root);
-		deps = {
-			log: env.log,
-			fs: env.fs,
-			ps: env.ps,
-			assets: env.assets,
-			secrets: env.secrets,
-		};
-	});
-
-	afterEach(() => env.disposeAsync());
-
-	it("logs a cred wait as it begins, then as it ends, naming the first", async () => {
-		await splates.run(deps, [
-			"creds",
-			"request",
-			"API_TOKEN",
-			"--purpose",
-			"To test.",
-			"--instructions",
-			"Paste it.",
-		]);
-
-		const waiting = splates.run(deps, ["creds", "wait", "API_TOKEN"]);
-		await sleep(Duration.ms(20));
-		await env.creds.save("API_TOKEN", "secret");
-		await waiting;
-
-		const [began, ended] = (await env.journal.tail(2)) as Extract<
-			Event,
-			{ action: "creds wait" }
-		>[];
-		expect(began).toMatchObject({
-			action: "creds wait",
-			reason: null,
-			name: "API_TOKEN",
-			began: null,
-		});
-		expect(ended).toMatchObject({
-			action: "creds wait",
-			reason: null,
-			name: "API_TOKEN",
-			began: began?.id,
-		});
-		expect(Date.parse(ended?.until ?? "")).toBeGreaterThan(
-			Date.now() + Duration.mins(14).ms,
-		);
-	});
-
-	it("logs a queued task wait with its subject, and how it gave up", async () => {
-		await splates.run(deps, [
-			"task",
-			"add",
-			"Seven",
-			"detail",
-			"--slug",
-			"seven",
-		]);
-		const [queued] = await env.tasks.all();
-
-		await splates.run(deps, [
-			"task",
-			"wait",
-			String(queued?.id),
-			"--timeout-secs",
-			"0",
-		]);
-
-		const [began, ended] = await env.journal.tail(2);
-		expect(began).toMatchObject({
-			action: "task wait",
-			reason: null,
-			number: queued?.id,
-			subject: "Seven",
-			began: null,
-		});
-		expect(ended).toMatchObject({
-			action: "task wait",
-			reason: "timeout",
-			number: queued?.id,
-			began: began?.id,
-		});
-	});
-});

package/waiting.ts

@@ -1,59 +0,0 @@
-import type { SplatesDeps } from "@stringsync/splates-server/server";
-import { listQueue, moveQueued } from "@stringsync/splates-server/workers";
-import { cli } from "webappwiz/cmd";
-import { z } from "zod";
-
-const DEV = {
-	default: "",
-	description:
-		"the `splates server` to ask, a URL such as http://localhost:4310; by default the one an agent runs under, from SPLATES_DEV",
-};
-
-/** `splates worker queue`, which `splates worker` mounts. */
-export const splatesWaiting = cli<SplatesDeps>("queue").description(
-	"the agents waiting for a slot on a worker of the running `splates server`: each one another agent started (with `splates add --agent`, or a lane's orchestrator handing out tasks), started or resumed while every worker it can run on is full, waits here, first come, first served, and starts once a slot frees, as when an agent left idle 30 minutes stops; none is ever failed for waiting. An agent you start waits only while no worker it can run on is up, as with this machine's own removed or none on the platform its project requires",
-);
-
-splatesWaiting
-	.command("list")
-	.description(
-		"list the agents waiting for a slot, first in line first: position, project, task, conversation, how long each has waited and why (no free slot, no worker up, or a platform no worker runs, as `needs macOS`)",
-	)
-	.option("dev", z.string(), DEV)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action((opts, ctx) =>
-		listQueue({
-			dev: opts.dev,
-			json: opts.json,
-			log: ctx.log,
-			fs: ctx.fs,
-			ps: ctx.ps,
-			send: ctx.fetch,
-		}),
-	);
-
-splatesWaiting
-	.command("move")
-	.description(
-		"move an agent waiting for a slot to another place in line, from 1 for the next to start, then list the queue",
-	)
-	.arg("which", z.string(), {
-		description: "the task it works, or its conversation's id",
-	})
-	.arg("position", z.coerce.number().int(), {
-		description: "where in line to put it, from 1",
-	})
-	.option("dev", z.string(), DEV)
-	.option("json", z.boolean(), { default: false, description: "emit JSON" })
-	.action((opts, ctx) =>
-		moveQueued({
-			which: opts.which,
-			position: opts.position,
-			dev: opts.dev,
-			json: opts.json,
-			log: ctx.log,
-			fs: ctx.fs,
-			ps: ctx.ps,
-			send: ctx.fetch,
-		}),
-	);