@bud.sh/app 0.5.0 → 0.6.0

package/dist/server/assets/run-BJ8r5jSh.js

@@ -0,0 +1,572 @@
+import { rn as parseElementAnchor } from "./events-BH_rAu7O.js";
+//#region app/task-context.ts
+var hash = /^[a-f0-9]{64}$/;
+function object(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function point(value) {
+	let input = object(value);
+	if (!input) return null;
+	let { x, y } = input;
+	return typeof x === "number" && typeof y === "number" && Number.isFinite(x) && Number.isFinite(y) ? {
+		x,
+		y
+	} : null;
+}
+/**
+* Validates a stored task context.
+* @param value - Untrusted stored data.
+* @returns The context, or null when there is none or it can't be read.
+*/
+function parseTaskContext(value) {
+	let input = object(value);
+	if (!input || input.version !== 1 || typeof input.thread !== "string") return null;
+	let page = object(input.page);
+	let code = object(input.code);
+	let element = null;
+	try {
+		element = input.element ? parseElementAnchor(input.element) : null;
+	} catch {}
+	return {
+		version: 1,
+		thread: input.thread.slice(0, 200),
+		page: page && typeof page.id === "string" && typeof page.path === "string" ? {
+			id: page.id,
+			path: page.path,
+			title: typeof page.title === "string" ? page.title : page.path
+		} : null,
+		viewport: typeof input.viewport === "number" ? input.viewport : null,
+		branch: typeof input.branch === "string" ? input.branch : null,
+		point: point(input.point),
+		element,
+		image: typeof input.image === "string" && hash.test(input.image) ? input.image : null,
+		code: code && typeof code.path === "string" && typeof code.startLine === "number" && typeof code.endLine === "number" ? {
+			path: code.path,
+			startLine: code.startLine,
+			endLine: code.endLine,
+			commit: typeof code.commit === "string" ? code.commit : null
+		} : null
+	};
+}
+/**
+* Validates what a browser sends with Make task.
+* @param value - The request's `context`.
+* @returns The screenshot's bytes, the element and the point, each when given and valid.
+*/
+function parseTaskContextInput(value) {
+	let input = object(value);
+	if (!input) return {
+		image: null,
+		element: null,
+		point: null
+	};
+	let image = null;
+	if (typeof input.image === "string" && input.image.length <= 3e6) try {
+		image = Uint8Array.from(atob(input.image), (character) => character.charCodeAt(0));
+	} catch {}
+	let element = null;
+	try {
+		element = input.element ? parseElementAnchor(input.element) : null;
+	} catch {}
+	return {
+		image,
+		element,
+		point: point(input.point)
+	};
+}
+//#endregion
+//#region ../factory/src/lib/run.ts
+/** Every run state, in the order a run passes them. */
+var RUN_STATES = [
+	"provisioning",
+	"working",
+	"review",
+	"needs_context",
+	"changes",
+	"approved",
+	"pushing",
+	"pushed",
+	"merged",
+	"failed",
+	"discarded"
+];
+/** States in which a run waits for people, and its sandbox sleeps after a while. */
+var RUN_WAITING_STATES = [
+	"review",
+	"needs_context",
+	"failed"
+];
+/** The line an agent ends its reply with to ask a person for what it needs. */
+var NEEDS_CONTEXT_MARKER = "NEEDS CONTEXT:";
+/**
+* The question an agent's reply asks a person, from its `NEEDS CONTEXT:` line.
+* @param reply - The agent's last reply.
+* @returns The question, or null when the agent didn't ask one.
+*/
+function askedQuestion(reply) {
+	let lines = reply.split("\n");
+	for (let index = lines.length - 1; index >= 0; index--) {
+		let line = lines[index].trim().replace(/^[*_`>\s]+/, "");
+		if (line.toUpperCase().startsWith("NEEDS CONTEXT:")) {
+			let question = [line.slice(14), ...lines.slice(index + 1)].join("\n").replace(/^[*_`\s]+|[*_`\s]+$/g, "");
+			return question ? question.slice(0, 2e3) : null;
+		}
+	}
+	return null;
+}
+/** States a run can't leave; a new run starts the task again. */
+var ENDED_RUN_STATES = [
+	"pushed",
+	"merged",
+	"discarded"
+];
+/** A step the run's state doesn't allow, such as approving a run that is still working. */
+var RunTransitionError = class extends Error {
+	state;
+	event;
+	constructor(state, event) {
+		super(`A run can't ${event} while it is ${state ?? "not started"}.`);
+		this.state = state;
+		this.event = event;
+		this.name = "RunTransitionError";
+	}
+};
+var MAX_ACTIVITY = 50;
+var MAX_ACTIVITY_TEXT = 500;
+var MAX_PREVIOUS = 10;
+var MAX_SUMMARY = 1e4;
+/**
+* The branch a task's run works on: the prefix, the task id and a short slug of its title.
+* @param prefix - Such as `dev/`.
+* @param taskId - The task's id.
+* @param title - The task's title.
+* @returns Such as `dev/fw-123-make-the-heading-larger`.
+*/
+function runBranch(prefix, taskId, title) {
+	let slug = title.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
+	return `${prefix}${taskId.toLowerCase().replace(/[^a-z0-9._-]+/g, "-")}${slug ? `-${slug}` : ""}`;
+}
+/**
+* Whether a run is still going: started and neither pushed nor discarded.
+* @param run - The task's run, if any.
+* @returns Whether it is active.
+*/
+function runActive(run) {
+	return Boolean(run && !ENDED_RUN_STATES.includes(run.state));
+}
+function withActivity(run, entry, at) {
+	let line = {
+		at,
+		kind: entry.kind,
+		text: entry.text.slice(0, MAX_ACTIVITY_TEXT)
+	};
+	return {
+		...run,
+		activity: [...run.activity, line].slice(-50)
+	};
+}
+function refuse(run, event) {
+	throw new RunTransitionError(run?.state ?? null, event);
+}
+/**
+* Starts a task's run, keeping a short note of the run before it.
+* @param previous - The task's last run, which must have ended or failed.
+* @param start - What the run starts from.
+* @param at - The time.
+* @returns The new run, the task's status and the sandbox to set up.
+*/
+function startRun(previous, start, at) {
+	if (previous && runActive(previous) && previous.state !== "failed") refuse(previous, "start");
+	let earlier = previous ? [{
+		id: previous.id,
+		state: previous.state,
+		endedAt: at
+	}, ...previous.previous] : [];
+	let run = {
+		version: 1,
+		id: start.id,
+		state: "provisioning",
+		failedIn: null,
+		provider: start.provider,
+		sandbox: null,
+		harness: start.harness,
+		model: start.model,
+		session: null,
+		ports: {
+			dev: null,
+			agent: null
+		},
+		asleep: false,
+		branch: runBranch(start.branchPrefix, start.taskId, start.title),
+		base: {
+			branch: start.base,
+			commit: null
+		},
+		head: null,
+		pushed: null,
+		summary: null,
+		question: null,
+		activity: [],
+		error: null,
+		startedBy: start.by,
+		approvedBy: null,
+		createdAt: at,
+		updatedAt: at,
+		previous: earlier.slice(0, MAX_PREVIOUS)
+	};
+	let effects = previous?.state === "failed" ? [{ type: "destroy" }] : [];
+	return {
+		run: withActivity(run, {
+			kind: "status",
+			text: "Started"
+		}, at),
+		status: "inProgress",
+		effects: [...effects, { type: "provision" }]
+	};
+}
+/**
+* The next step of a run: the state machine of the factory.
+* @param run - The run as stored.
+* @param event - What happened.
+* @param at - The time.
+* @returns The run to save, the task status that follows and what Bud does next.
+*/
+function advanceRun(run, event, at) {
+	let next = {
+		...run,
+		updatedAt: at
+	};
+	switch (event.type) {
+		case "ready":
+			if (run.state !== "provisioning") refuse(run, "become ready");
+			return {
+				run: withActivity({
+					...next,
+					state: "working",
+					sandbox: event.sandbox,
+					session: event.session,
+					ports: event.ports,
+					base: {
+						...run.base,
+						commit: event.commit
+					}
+				}, {
+					kind: "status",
+					text: "Agent working"
+				}, at),
+				effects: []
+			};
+		case "created":
+			if (run.state !== "provisioning") refuse(run, "record its sandbox");
+			return {
+				run: {
+					...next,
+					sandbox: event.sandbox
+				},
+				effects: []
+			};
+		case "activity":
+			if (![
+				"provisioning",
+				"working",
+				"changes"
+			].includes(run.state)) refuse(run, "report activity");
+			return {
+				run: withActivity(next, event.entry, at),
+				effects: []
+			};
+		case "idle": {
+			if (run.state !== "working" && run.state !== "changes") refuse(run, "finish");
+			let question = askedQuestion(event.summary);
+			if (question) return {
+				run: withActivity({
+					...next,
+					state: "needs_context",
+					question,
+					summary: event.summary.slice(0, MAX_SUMMARY),
+					head: event.head ?? run.head
+				}, {
+					kind: "status",
+					text: "Needs context"
+				}, at),
+				effects: [{ type: "doze" }]
+			};
+			return {
+				run: withActivity({
+					...next,
+					state: "review",
+					question: null,
+					summary: event.summary.slice(0, MAX_SUMMARY),
+					head: event.head ?? run.head
+				}, {
+					kind: "status",
+					text: "Needs approval"
+				}, at),
+				status: "needsApproval",
+				effects: [{ type: "doze" }]
+			};
+		}
+		case "answer":
+			if (run.state !== "needs_context") refuse(run, "take an answer");
+			return {
+				run: withActivity({
+					...next,
+					state: "changes",
+					question: null
+				}, {
+					kind: "message",
+					text: `${event.by.name}: ${event.message}`
+				}, at),
+				effects: [{
+					type: "send",
+					message: event.message
+				}]
+			};
+		case "changes":
+			if (run.state !== "review") refuse(run, "take changes");
+			return {
+				run: withActivity({
+					...next,
+					state: "changes"
+				}, {
+					kind: "message",
+					text: `${event.by.name}: ${event.message}`
+				}, at),
+				status: "inProgress",
+				effects: [{
+					type: "send",
+					message: event.message
+				}]
+			};
+		case "approve":
+			if (run.state !== "review") refuse(run, "be approved");
+			return {
+				run: withActivity({
+					...next,
+					state: "pushing",
+					approvedBy: event.by
+				}, {
+					kind: "status",
+					text: `Approved by ${event.by.name}`
+				}, at),
+				effects: [{ type: "push" }]
+			};
+		case "pushed":
+			if (run.state !== "pushing" && run.state !== "approved") refuse(run, "be pushed");
+			return {
+				run: withActivity({
+					...next,
+					state: "pushed",
+					pushed: event.commit,
+					error: null,
+					asleep: true
+				}, {
+					kind: "status",
+					text: `Pushed ${run.branch}`
+				}, at),
+				status: "readyToMerge",
+				effects: [{ type: "stop" }]
+			};
+		case "merged":
+			if (run.state !== "pushed") refuse(run, "be merged");
+			return {
+				run: withActivity({
+					...next,
+					state: "merged"
+				}, {
+					kind: "status",
+					text: `Merged ${run.branch}`
+				}, at),
+				status: "merged",
+				effects: [{ type: "destroy" }]
+			};
+		case "discard":
+			if (![
+				"review",
+				"needs_context",
+				"failed",
+				"provisioning",
+				"working",
+				"changes"
+			].includes(run.state)) refuse(run, "be discarded");
+			return {
+				run: withActivity({
+					...next,
+					state: "discarded"
+				}, {
+					kind: "status",
+					text: "Discarded"
+				}, at),
+				status: "open",
+				effects: [{ type: "destroy" }]
+			};
+		case "fail":
+			if (ENDED_RUN_STATES.includes(run.state) || run.state === "failed") refuse(run, "fail");
+			return {
+				run: withActivity({
+					...next,
+					state: "failed",
+					failedIn: run.state,
+					error: {
+						message: event.message.slice(0, MAX_ACTIVITY_TEXT),
+						at,
+						retryable: event.retryable
+					}
+				}, {
+					kind: "error",
+					text: event.message
+				}, at),
+				effects: run.sandbox && !run.asleep ? [{ type: "doze" }] : []
+			};
+		case "sleep":
+			if (run.asleep || !RUN_WAITING_STATES.includes(run.state)) refuse(run, "sleep");
+			return {
+				run: withActivity({
+					...next,
+					asleep: true
+				}, {
+					kind: "status",
+					text: "Sandbox asleep"
+				}, at),
+				effects: [{ type: "stop" }]
+			};
+		case "wake":
+			if (!run.asleep || ENDED_RUN_STATES.includes(run.state)) refuse(run, "wake");
+			return {
+				run: withActivity({
+					...next,
+					asleep: false
+				}, {
+					kind: "status",
+					text: "Sandbox awake"
+				}, at),
+				effects: []
+			};
+		case "retry": {
+			if (run.state !== "failed" || !run.failedIn || !run.error?.retryable) refuse(run, "be retried");
+			let state = run.failedIn;
+			return {
+				run: withActivity({
+					...next,
+					state,
+					failedIn: null,
+					error: null
+				}, {
+					kind: "status",
+					text: "Retrying"
+				}, at),
+				effects: [...state === "provisioning" && run.sandbox ? [{ type: "destroy" }] : [], {
+					type: "resume",
+					state
+				}]
+			};
+		}
+	}
+}
+function isObject(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function text(value, field, max, nullable = false) {
+	if (nullable && value === null) return value;
+	if (typeof value !== "string" || value.length > max) throw new TypeError(`Invalid run ${field}.`);
+	return value;
+}
+function state(value, field) {
+	if (!RUN_STATES.includes(value)) throw new TypeError(`Invalid run ${field}.`);
+	return value;
+}
+function port(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 65535) throw new TypeError("Invalid run port.");
+	return value;
+}
+function ports(value) {
+	if (value === void 0) return {
+		dev: null,
+		agent: null
+	};
+	if (!isObject(value)) throw new TypeError("Invalid run ports.");
+	let terminal = port(value.terminal);
+	let preview = port(value.preview);
+	return {
+		dev: port(value.dev),
+		agent: port(value.agent),
+		...terminal ? { terminal } : {},
+		...preview ? { preview } : {}
+	};
+}
+function person(value, field) {
+	if (!isObject(value)) throw new TypeError(`Invalid run ${field}.`);
+	return {
+		name: text(value.name, field, 1e3),
+		email: text(value.email, field, 1e3)
+	};
+}
+/**
+* Validates a run record read from a task's metadata.
+* @param value - Untrusted stored data.
+* @returns The run.
+*/
+function parseRunRecord(value) {
+	if (!isObject(value) || value.version !== 1) throw new TypeError("Invalid run.");
+	let base = value.base;
+	if (!isObject(base)) throw new TypeError("Invalid run base.");
+	let error = value.error;
+	if (error !== null && !isObject(error)) throw new TypeError("Invalid run error.");
+	if (!Array.isArray(value.activity) || value.activity.length > MAX_ACTIVITY) throw new TypeError("Invalid run activity.");
+	if (!Array.isArray(value.previous) || value.previous.length > MAX_PREVIOUS) throw new TypeError("Invalid earlier runs.");
+	return {
+		version: 1,
+		id: text(value.id, "id", 100),
+		state: state(value.state, "state"),
+		failedIn: value.failedIn === null ? null : state(value.failedIn, "failedIn"),
+		provider: text(value.provider, "provider", 200),
+		sandbox: text(value.sandbox, "sandbox", 500, true),
+		harness: text(value.harness, "harness", 200),
+		model: text(value.model, "model", 200),
+		session: text(value.session, "session", 500, true),
+		ports: ports(value.ports),
+		asleep: value.asleep === true,
+		branch: text(value.branch, "branch", 300),
+		base: {
+			branch: text(base.branch, "base", 300),
+			commit: text(base.commit, "base", 100, true)
+		},
+		head: text(value.head, "head", 100, true),
+		pushed: text(value.pushed, "pushed", 100, true),
+		summary: text(value.summary, "summary", MAX_SUMMARY, true),
+		question: value.question === void 0 ? null : text(value.question, "question", 2e3, true),
+		activity: value.activity.map((entry) => {
+			if (!isObject(entry) || ![
+				"status",
+				"message",
+				"tool",
+				"error"
+			].includes(entry.kind)) throw new TypeError("Invalid run activity.");
+			return {
+				at: text(entry.at, "activity", 64),
+				kind: entry.kind,
+				text: text(entry.text, "activity", MAX_ACTIVITY_TEXT)
+			};
+		}),
+		error: error === null ? null : {
+			message: text(error.message, "error", MAX_ACTIVITY_TEXT),
+			at: text(error.at, "error", 64),
+			retryable: error.retryable === true
+		},
+		startedBy: person(value.startedBy, "startedBy"),
+		approvedBy: value.approvedBy === null ? null : person(value.approvedBy, "approvedBy"),
+		createdAt: text(value.createdAt, "createdAt", 64),
+		updatedAt: text(value.updatedAt, "updatedAt", 64),
+		previous: value.previous.map((entry) => {
+			if (!isObject(entry)) throw new TypeError("Invalid earlier run.");
+			return {
+				id: text(entry.id, "previous", 100),
+				state: state(entry.state, "previous"),
+				endedAt: text(entry.endedAt, "previous", 64)
+			};
+		})
+	};
+}
+//#endregion
+export { parseRunRecord as a, parseTaskContext as c, advanceRun as i, parseTaskContextInput as l, RUN_WAITING_STATES as n, runActive as o, RunTransitionError as r, startRun as s, NEEDS_CONTEXT_MARKER as t };

package/dist/server/assets/{screen-BIQA2mr4.js → screen-CBrHPFug.js}

@@ -1,5 +1,5 @@
-import { F as parseThreadId, P as parseThreadFilter, b as predictThreadReply, i as routes, j as parseThread, v as predictThreadCreate, x as predictThreadStatus, y as predictThreadDelete, z as parseThreadSnapshot } from "./events-iHpLGr3k.js";
-import { En as t, _ as requestComments, a as saveThreads, b as writeOptimistically, bn as toast, g as CommentsRequestError, i as saveThread, l as projectStore, n as unavailableComments, o as threadMatches, x as writeRows, y as plainRow } from "./comment-data-CsjukwAW.js";
+import { N as parseThreadFilter, P as parseThreadId, R as parseThreadSnapshot, b as predictThreadReply, i as routes, j as parseThread, v as predictThreadCreate, x as predictThreadStatus, y as predictThreadDelete } from "./events-BH_rAu7O.js";
+import { Dn as toast, Nn as t, _ as requestComments, a as saveThreads, b as writeOptimistically, g as CommentsRequestError, i as saveThread, l as projectStore, n as unavailableComments, o as threadMatches, x as writeRows, y as plainRow } from "./comment-data-Rg42ToTW.js";
 //#region app/client/project-comments.ts
 var viewers = /* @__PURE__ */ new Map();
 function parseViewer(value) {
@@ -11,6 +11,13 @@ function parseViewer(value) {
 	};
 	throw new TypeError("Invalid viewer.");
 }
+function parseMadeTask(value) {
+	if (!value || typeof value !== "object" || !("item" in value) || !("thread" in value) || !value.item || typeof value.item !== "object" || !("id" in value.item) || typeof value.item.id !== "string" || !value.item.id || value.item.id.length > 256) throw new TypeError("Invalid task.");
+	return {
+		item: { id: value.item.id },
+		thread: parseThread(value.thread)
+	};
+}
 function parseDeletion(value) {
 	if (!value || typeof value !== "object" || !("thread" in value)) throw new TypeError("Invalid deletion.");
 	return { thread: value.thread === null ? null : parseThread(value.thread) };
@@ -234,6 +241,10 @@ function createProjectComments(options) {
 				if (!detailFailures.size) error = "";
 			}
 		} catch (cause) {
+			if (!signal.aborted && turn === generation && cause instanceof CommentsRequestError && cause.code === "not-found") {
+				await forget(id);
+				return;
+			}
 			if (!signal.aborted && turn === generation) {
 				detailFailures.add(id);
 				error = cause instanceof Error ? cause.message : t("app.client.projectComments.couldNotLoadDiscussion");
@@ -382,6 +393,23 @@ function createProjectComments(options) {
 			};
 		},
 		/**
+		* Turns a discussion into a task in the task store, linked to it.
+		* @param threadId - The discussion.
+		* @param context - What the canvas found around the comment: a screenshot and its element.
+		* @returns The new task's id.
+		*/
+		async makeTask(threadId, context) {
+			requireCapability("link");
+			let id = parseThreadId(threadId);
+			let made;
+			await operate(routes.comments.makeTask.href({ id }), context ? { context } : {}, parseMadeTask, (result) => {
+				if (result.thread.id !== id) throw new CommentsRequestError(t("app.client.projectComments.refreshBeforeTryingAgain"), 409, "uncertain");
+				made = result.item;
+				return merge(result.thread);
+			}, t("app.client.projectComments.taskCreated"), id);
+			return made;
+		},
+		/**
 		* Deletes one of the viewer's messages; its first message deletes the whole discussion.
 		* @param threadId - The discussion.
 		* @param messageId - The message to delete.