@stringsync/splates 0.0.52 → 0.0.53

package/artifact.ts

@@ -0,0 +1,120 @@
+import { basename, resolve } from "node:path";
+import {
+	addArtifact,
+	listArtifacts,
+	removeArtifact,
+} from "@stringsync/splates-server/artifacts";
+import { commaList } from "@stringsync/splates-server/comma-list";
+import { conversationOf } 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 { cli } from "webappwiz/cmd";
+import { z } from "zod";
+import { here } from "./flags";
+
+/** `splates artifact`, which the root cli mounts after `splates attach`. */
+export const splatesArtifact = cli<SplatesDeps>("artifact").description(
+	"files your conversation made as its outputs, such as a screenshot, a recording or an HTML page: kept by name for the life of the conversation, whatever task it was made in, and listed on the `splates server` page beside its thread. A file that shows a question or a demo step is no artifact: `splates attach` it. The conversation is $SPLATES_CONVERSATION, or --conversation <id> from an agent outside `splates server`",
+);
+
+const conversation = [
+	"conversation",
+	z.string(),
+	{
+		default: "",
+		description:
+			"conversation id, when not run by an agent `splates server` started",
+	},
+] as const;
+
+splatesArtifact
+	.command("add")
+	.use(repository({ needs: "own" }))
+	.description(
+		"keep files as artifacts of this conversation, each named for its basename, or by --name when there is one; adding a name the conversation holds makes its next version, earlier ones kept until cleanup takes them. Past the project's limit (artifactProjectCapacity), `splates server` first evicts the oldest bytes the project keeps: removed and replaced versions, then what archived conversations show, then what live ones do. Past the file or conversation limit (artifactFileCapacity, artifactConversationCapacity), or the project's when even that would not make room, it stops with `too_large`, changing nothing for that file",
+	)
+	.arg("files", z.string(), { description: "files to keep, comma separated" })
+	.option("name", z.string(), {
+		default: "",
+		description: "the artifact's name; for one file only",
+	})
+	.option(...conversation)
+	.action(async (opts, ctx) => {
+		const paths = commaList(opts.files);
+		if (paths.length === 0) {
+			fail("usage", "name the files to keep: nothing was changed");
+		}
+		if (opts.name !== "" && paths.length > 1) {
+			fail("usage", "--name names one file: nothing was changed");
+		}
+		const id = await conversationOf(ctx.service, opts.conversation);
+		const files = await Promise.all(
+			paths.map(async (given) => {
+				const path = resolve(ctx.ps.cwd(), given);
+				const bytes = await ctx.fs.readBytes(path).catch(() => null);
+				if (bytes === null) {
+					fail("usage", `cannot read ${path}: nothing was changed`, {
+						file: path,
+					});
+				}
+				return { name: opts.name || basename(path), bytes };
+			}),
+		);
+		const task = await here(ctx);
+		for (const file of files) {
+			await ctx.journal.record(
+				"artifact add",
+				task,
+				() => addArtifact(ctx, id, file),
+				(added) => ({
+					name: file.name,
+					version: added.version,
+					bytes: added.bytes,
+				}),
+			);
+		}
+	});
+
+splatesArtifact
+	.command("remove")
+	.use(repository({ needs: "own" }))
+	.description(
+		"stop listing the artifact of that name, every version kept until cleanup takes them; adding the name again lists it again",
+	)
+	.arg("name", z.string(), { description: "the artifact's name" })
+	.option(...conversation)
+	.action(async (opts, ctx) => {
+		const id = await conversationOf(ctx.service, opts.conversation);
+		await ctx.journal.record(
+			"artifact remove",
+			await here(ctx),
+			() => removeArtifact(ctx, id, opts.name),
+			(version) => ({ name: opts.name, version }),
+		);
+	});
+
+splatesArtifact
+	.command("list")
+	.use(repository({ needs: "own" }))
+	.description(
+		"the artifacts this conversation lists, and their current version",
+	)
+	.option(...conversation)
+	.action(async (opts, ctx) =>
+		listArtifacts(ctx, await conversationOf(ctx.service, opts.conversation)),
+	);
+
+splatesArtifact
+	.command("show")
+	.use(repository({ needs: "own" }))
+	.description("every version of an artifact, and which is current")
+	.arg("name", z.string(), { description: "the artifact's name" })
+	.option(...conversation)
+	.action(async (opts, ctx) =>
+		listArtifacts(
+			ctx,
+			await conversationOf(ctx.service, opts.conversation),
+			opts.name,
+		),
+	);

package/budget.ts

@@ -0,0 +1,117 @@
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+import {
+	endBudgetRaise,
+	raiseBudget,
+	setBudget,
+	showBudget,
+} 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",
+};
+
+const JSON_OPTION = { default: false, description: "emit JSON" };
+
+const LIMIT = z.enum(["hour", "day", "month"]);
+
+const LIMIT_ARG = {
+	description:
+		"hour, the rate cap on what made workers running at once cost an hour; day; or month",
+};
+
+/** `splates budget`, which the root cli mounts beside `splates worker`. */
+export const splatesBudget = cli<SplatesDeps>("budget").description(
+	"what the workers a `workerProvider` makes may cost, in dollars: a rate cap per hour on those running at once ($0.25/h by default), and limits on a day ($5) and a month ($75). Past the rate cap, or once a day's or month's limit is spent, no worker is made and the queue says why; reaching the day's or month's stops made workers, whose agents stop at their checkpoint. Each warns at 80%, 90% and 100% by Web Push and on the page's header. Spend is an estimate at each type's list price. Agents' own API spend is not counted here",
+);
+
+splatesBudget
+	.command("show")
+	.description(
+		"show each limit: what made workers spent in its window, of how much, and what is left",
+	)
+	.option("dev", z.string(), DEV)
+	.option("json", z.boolean(), JSON_OPTION)
+	.action((opts, ctx) =>
+		showBudget({
+			dev: opts.dev,
+			json: opts.json,
+			log: ctx.log,
+			fs: ctx.fs,
+			ps: ctx.ps,
+			send: ctx.fetch,
+		}),
+	);
+
+splatesBudget
+	.command("set")
+	.description(
+		"set a limit, in dollars (dollars an hour for hour), then show the budget",
+	)
+	.arg("limit", LIMIT, LIMIT_ARG)
+	.arg("dollars", z.string(), {
+		description: "like 5 or 0.25, or `default` to give it back to its default",
+	})
+	.option("dev", z.string(), DEV)
+	.option("json", z.boolean(), JSON_OPTION)
+	.action((opts, ctx) =>
+		setBudget({
+			limit: opts.limit,
+			dollars: opts.dollars,
+			dev: opts.dev,
+			json: opts.json,
+			log: ctx.log,
+			fs: ctx.fs,
+			ps: ctx.ps,
+			send: ctx.fetch,
+		}),
+	);
+
+splatesBudget
+	.command("raise")
+	.description(
+		"add dollars to a limit for a while, on top of what it is set to, then show the budget",
+	)
+	.arg("limit", LIMIT, LIMIT_ARG)
+	.arg("dollars", z.string(), { description: "how much to add, like 2 or 0.1" })
+	.option("for", z.string(), {
+		default: "1d",
+		description:
+			"how long it lasts, in hours, days or weeks, like 24h, 1d or 2w",
+	})
+	.option("dev", z.string(), DEV)
+	.option("json", z.boolean(), JSON_OPTION)
+	.action((opts, ctx) =>
+		raiseBudget({
+			limit: opts.limit,
+			dollars: opts.dollars,
+			for: opts.for,
+			dev: opts.dev,
+			json: opts.json,
+			log: ctx.log,
+			fs: ctx.fs,
+			ps: ctx.ps,
+			send: ctx.fetch,
+		}),
+	);
+
+splatesBudget
+	.command("end")
+	.description("end a raise now, by the number `show` gives it")
+	.arg("id", z.coerce.number().int(), { description: "the raise's number" })
+	.option("dev", z.string(), DEV)
+	.option("json", z.boolean(), JSON_OPTION)
+	.action((opts, ctx) =>
+		endBudgetRaise({
+			id: opts.id,
+			dev: opts.dev,
+			json: opts.json,
+			log: ctx.log,
+			fs: ctx.fs,
+			ps: ctx.ps,
+			send: ctx.fetch,
+		}),
+	);

package/checkout.ts

@@ -0,0 +1,8 @@
+// What `bin/splates` runs from a checkout: the published program with `dev`
+// mounted, the commands for working on this repository. No `bin` or `exports`
+// entry names this file, so a release bundles none of it.
+import { mountDev } from "./dev";
+import { splates } from "./splates";
+
+mountDev(splates);
+await import("./index");

package/creds.test.ts

@@ -0,0 +1,336 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { Testing } from "@stringsync/splates-server/testing";
+import { Duration, sleep } from "webappwiz/time";
+import { splates } from "./splates";
+
+const WHY = "To read the build logs through the dashboard's API.";
+const HOW = "Open the dashboard, create a token, and paste it here.";
+
+/** Long enough that a test only reaches it when waiting is genuinely stuck. */
+const PATIENT = { timeout: Duration.secs(5), poll: Duration.ms(5) };
+
+describe("creds", () => {
+	let deps: Testing;
+
+	beforeEach(async () => {
+		deps = await Testing.open();
+	});
+
+	afterEach(() => deps.disposeAsync());
+
+	it("records a request, with what for and how to get it, for the page to show", async () => {
+		await deps.creds.request("API_TOKEN", {
+			scope: "device",
+			purpose: WHY,
+			instructions: HOW,
+			task: "alpha",
+		});
+
+		expect(await deps.creds.requests()).toMatchObject([
+			{
+				name: "API_TOKEN",
+				scope: "device",
+				purpose: WHY,
+				instructions: HOW,
+				task: "alpha",
+				status: "open",
+			},
+		]);
+	});
+
+	it("asks nothing for a cred already kept, unless told the kept one fails", async () => {
+		await deps.projectStore.set("API_TOKEN", "old");
+		const ask = {
+			scope: "project" as const,
+			purpose: WHY,
+			instructions: HOW,
+			task: null,
+		};
+
+		expect(await deps.creds.request("API_TOKEN", ask)).toBeNull();
+		expect(
+			await deps.creds.request("API_TOKEN", { ...ask, replace: true }),
+		).toMatchObject({ status: "open" });
+	});
+
+	it("replaces with the last request's purpose and instructions when left off", async () => {
+		const ask = {
+			scope: "project" as const,
+			purpose: WHY,
+			instructions: HOW,
+			task: null,
+		};
+		await deps.creds.request("API_TOKEN", ask);
+		await deps.projectStore.set("API_TOKEN", "old");
+
+		expect(
+			await deps.creds.request("API_TOKEN", {
+				scope: "project",
+				purpose: "",
+				instructions: "",
+				task: null,
+				replace: true,
+			}),
+		).toMatchObject({ purpose: WHY, instructions: HOW, status: "open" });
+	});
+
+	it("refuses a request that says nothing of what it is for", async () => {
+		await expect(
+			deps.creds.request("API_TOKEN", {
+				scope: "project",
+				purpose: " ",
+				instructions: HOW,
+				task: null,
+			}),
+		).toBail("usage");
+	});
+
+	it("refuses a request that says nothing of how to get it", async () => {
+		await expect(
+			deps.creds.request("API_TOKEN", {
+				scope: "project",
+				purpose: WHY,
+				instructions: " ",
+				task: null,
+			}),
+		).toBail("usage");
+	});
+
+	it("refuses a name no environment variable could have", async () => {
+		await expect(
+			deps.creds.request("api-token", {
+				scope: "project",
+				purpose: WHY,
+				instructions: HOW,
+				task: null,
+			}),
+		).toBail("usage");
+	});
+
+	it("keeps a value in the store its request asked for, and fills it", async () => {
+		await deps.creds.request("API_TOKEN", {
+			scope: "device",
+			purpose: WHY,
+			instructions: HOW,
+			task: null,
+		});
+
+		expect(await deps.creds.save("API_TOKEN", " secret \n")).toBe("device");
+
+		expect(await deps.deviceStore.get("API_TOKEN")).toBe("secret");
+		expect(await deps.projectStore.get("API_TOKEN")).toBeUndefined();
+		expect((await deps.creds.requests())[0]?.status).toBe("saved");
+		expect(await deps.creds.credentials.require("API_TOKEN")).toBe("secret");
+	});
+
+	it("never writes a value into its record", async () => {
+		await deps.creds.request("API_TOKEN", {
+			scope: "project",
+			purpose: WHY,
+			instructions: HOW,
+			task: null,
+		});
+		await deps.creds.save("API_TOKEN", "hunter2", { by: "a tool" });
+
+		expect(await deps.fs.read(`${deps.splatesDir}/creds.json`)).not.toContain(
+			"hunter2",
+		);
+	});
+
+	it("ends a wait once the value is saved", async () => {
+		await deps.creds.request("API_TOKEN", {
+			scope: "project",
+			purpose: WHY,
+			instructions: HOW,
+			task: null,
+		});
+
+		const waiting = deps.creds.wait("API_TOKEN", PATIENT);
+		await sleep(Duration.ms(20));
+		await deps.creds.save("API_TOKEN", "secret");
+
+		expect(await waiting).toBe("saved");
+	});
+
+	it("ends a wait once the request is dismissed", async () => {
+		await deps.creds.request("API_TOKEN", {
+			scope: "project",
+			purpose: WHY,
+			instructions: HOW,
+			task: null,
+		});
+		await deps.creds.dismiss("API_TOKEN");
+
+		expect(await deps.creds.wait("API_TOKEN", PATIENT)).toBe("dismissed");
+	});
+
+	it("gives up waiting on a request nobody fills", async () => {
+		await deps.creds.request("API_TOKEN", {
+			scope: "project",
+			purpose: WHY,
+			instructions: HOW,
+			task: null,
+		});
+
+		await expect(
+			deps.creds.wait("API_TOKEN", {
+				timeout: Duration.ms(20),
+				poll: Duration.ms(5),
+			}),
+		).toBail("timeout");
+	});
+
+	it("refuses to wait on a cred nothing requested", async () => {
+		await expect(deps.creds.wait("API_TOKEN", PATIENT)).toBail("not_found");
+	});
+
+	it("lists what each store keeps, and what a tool saved itself", async () => {
+		await deps.projectStore.set("DATABASE_URL", "x");
+		await deps.creds.save("TUNNEL_TOKEN", "y", {
+			scope: "device",
+			by: "splates tunnel setup",
+		});
+
+		expect(await deps.creds.kept()).toEqual([
+			{
+				name: "DATABASE_URL",
+				scope: "project",
+				provider: "system",
+				savedBy: null,
+			},
+			{
+				name: "TUNNEL_TOKEN",
+				scope: "device",
+				provider: "system",
+				savedBy: "splates tunnel setup",
+			},
+		]);
+	});
+
+	it("removes a kept cred from its store", async () => {
+		await deps.creds.save("TUNNEL_TOKEN", "y", { scope: "device", by: "t" });
+
+		expect(await deps.creds.remove("TUNNEL_TOKEN", "device")).toBe(true);
+		expect(await deps.creds.kept()).toEqual([]);
+	});
+
+	it("says the system keeps no secrets when its store cannot be reached", async () => {
+		deps.projectStore.names = () => Promise.reject(new Error("no daemon"));
+
+		await expect(deps.creds.kept()).toBail("no_secret_store", {
+			message: "secret service",
+		});
+	});
+});
+
+// scry-ignore simple-test-setup: one describe per command, as the file groups the CLI's cases
+describe("splates creds", () => {
+	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("requests a cred, then waits until a person saves it", async () => {
+		await splates.run(deps, [
+			"creds",
+			"request",
+			"API_TOKEN",
+			"--purpose",
+			WHY,
+			"--instructions",
+			HOW,
+			"--device",
+		]);
+		expect(env.out()).toContain(`requested API_TOKEN  ${WHY}`);
+
+		const waiting = splates.run(deps, ["creds", "wait", "API_TOKEN"]);
+		await sleep(Duration.ms(20));
+		await env.creds.save("API_TOKEN", "secret");
+		await waiting;
+
+		expect(env.out()).toContain("saved API_TOKEN");
+		expect(await env.deviceStore.get("API_TOKEN")).toBe("secret");
+	});
+
+	it("exits dismissed when the person turns the request down", async () => {
+		await splates.run(deps, [
+			"creds",
+			"request",
+			"API_TOKEN",
+			"--purpose",
+			WHY,
+			"--instructions",
+			HOW,
+		]);
+		await env.creds.dismiss("API_TOKEN");
+
+		await splates.run(deps, ["creds", "wait", "API_TOKEN"]);
+
+		expect(env.proc.exits).toEqual([22]);
+	});
+
+	it("lists requests and kept creds by name, never a value", async () => {
+		await env.projectStore.set("DATABASE_URL", "postgres://secret");
+		await splates.run(deps, [
+			"creds",
+			"request",
+			"API_TOKEN",
+			"--purpose",
+			WHY,
+			"--instructions",
+			HOW,
+		]);
+
+		await splates.run(deps, ["creds", "list", "--json"]);
+
+		const listed = String(env.log.entries.at(-1)?.message);
+		expect(JSON.parse(listed)).toMatchObject({
+			requested: [{ name: "API_TOKEN", status: "open" }],
+			kept: [{ name: "DATABASE_URL", scope: "project" }],
+		});
+		expect(listed).not.toContain("postgres://secret");
+	});
+});
+
+// scry-ignore simple-test-setup: copyLegacy reads a store the other commands never touch
+describe("copyLegacy", () => {
+	let deps: Testing;
+
+	beforeEach(async () => {
+		deps = await Testing.open();
+	});
+
+	afterEach(() => deps.disposeAsync());
+
+	it("keeps each of arbor's creds under splates's name too, in the same store", async () => {
+		await deps.deviceStore.set("ARBOR_CLOUDFLARE_API_TOKEN", "secret");
+
+		await deps.creds.copyLegacy();
+
+		expect(await deps.deviceStore.names()).toEqual([
+			"ARBOR_CLOUDFLARE_API_TOKEN",
+			"SPLATES_CLOUDFLARE_API_TOKEN",
+		]);
+	});
+
+	it("leaves a cred splates already keeps", async () => {
+		await deps.deviceStore.set("ARBOR_TUNNEL_TOKEN", "old");
+		await deps.deviceStore.set("SPLATES_TUNNEL_TOKEN", "new");
+
+		await deps.creds.copyLegacy();
+
+		expect(await deps.deviceStore.get("SPLATES_TUNNEL_TOKEN")).toBe("new");
+	});
+});