@teamscala/service-boot 0.23.349 → 0.23.352

package/src/fn-routers/task-sync-rename.test.ts

@@ -1,53 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit directly
- *
- * Unit tests for the rename back-write leg: renameOutcome (the pure
- * no-task ⇒ not-updated decision) + source-contract assertions that the handler
- * resolves the lane task BY SESSION (never pane) and updates its title. Covers
- * `what-must-have-a-test` for the new procedure + the `lane-identity-is-cli-
- * session-id` invariant it rides on.
- */
-import { describe, it, expect } from "bun:test";
-import { renameOutcome } from "./task-sync-rename.ts";
-
-describe("renameOutcome (no verdict from no data)", () => {
-	it("returns not-updated with a null task_id when no task is bound to the session", () => {
-		// A rename of a tab whose lane has no resolvable task updates nothing —
-		// never an error, never a fake id. updated:false is the signal the caller
-		// treats as best-effort (the window was already renamed; this only missed
-		// the DB echo, which is the rare archived-and-pruned case).
-		expect(renameOutcome(null)).toEqual({ task_id: null, updated: false });
-	});
-
-	it("returns the bound task id + updated:true when a task resolves", () => {
-		expect(renameOutcome({ id: "task-9" })).toEqual({ task_id: "task-9", updated: true });
-	});
-});
-
-describe("renameLaneTask resolves BY SESSION and writes the title (source contract)", () => {
-	const renameSrc = Bun.file(new URL("./task-sync-rename.ts", import.meta.url).pathname);
-
-	it("resolves the lane task by lane_session (the CLI session id), never by pane", async () => {
-		// `lane-identity-is-cli-session-id`: binding is by session because a pane
-		// outlives the session inside it. A pane-keyed rename would let a dead
-		// session's task answer for a live lane.
-		const text = await renameSrc.text();
-		expect(text).toContain("resolveLaneTask(prisma, lane_session)");
-		// No pane matching anywhere in the resolution path.
-		expect(text).not.toContain("lane.pane");
-	});
-
-	it("updates the resolved task's title by id", async () => {
-		const text = await renameSrc.text();
-		expect(text).toContain('where: { id: task.id }');
-		expect(text).toContain("data: { title }");
-	});
-
-	it("requires lane_session + title at the signature (incomplete rename unconstructible)", async () => {
-		const text = await renameSrc.text();
-		expect(text).toContain('lane_session: v.pipe(v.string()');
-		expect(text).toContain('title: v.pipe(v.string()');
-	});
-});

package/src/fn-routers/task-sync-rename.ts

@@ -1,111 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Lane RENAME back-write for task-sync: a tab rename EMITS to update the bound
- * work_items task's title in the DB, by CLI session id. This is the DB half of
- * `tab-rename-emits-back-to-task-title`: the operator's tab bar is how they see
- * what is being worked on (`lane-labels-and-task-lists`), so the tmux window
- * name and the task title must never diverge silently. Renaming a tab from
- * `scala-tools session rename` (or the lane renaming itself through the same
- * surface) updates the task title so the project board agrees with the tab bar.
- *
- * THE EMISSION, not a poll (`actions-are-rows-then-emissions`): a caller renames
- * the window (a row/state change) and that change emits the title update — the
- * task-sync owner reacts by updating the row. State lives in the row, never in a
- * return value a caller may never receive.
- *
- * Bound by CLI SESSION ID, never pane id (`lane-identity-is-cli-session-id`): a
- * pane OUTLIVES the session inside it, so matching on a pane would let a dead
- * session's task answer for a live lane. The session is the stable identity a
- * rename resolves to (the daemon resolves the pane's tab → its stored session id
- * and passes that here), so the rename lands on the lane that owns the tab.
- *
- * Split out of task-sync-router.ts for the same reason task-sync-brief/lane/
- * assign exist: the router sits at its 1000-line commit gate, so every cohesive
- * task-sync unit that can live in a sibling does. This owns the rename handler +
- * its pure outcome decision.
- *
- * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
- * candidate. Bound to the work_items schema and to task-sync's own
- * kind_data.lane.session convention; no unrelated app could install this
- * unmodified.
- */
-
-import * as v from "valibot";
-import type { Prisma } from "./task-sync-router.ts";
-import { authed, type Context } from "./auth-router.ts";
-import { resolveLaneTask } from "./task-sync-lane.ts";
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-
-/**
- * renameLaneTask ORPC input. `lane_session` is the lane's CLI-native session id
- * (kind_data.lane.session) — the stable identity a pane rename resolves to.
- * `title` is the new task title (the renamed tab's label). Both required:
- * oRPC rejects a call missing either at the signature
- * (`prevention-over-detection`), so a malformed rename is a 400, never a silent
- * no-op that leaves the title stale.
- */
-export const renameLaneTaskInput = v.object({
-	lane_session: v.pipe(v.string(), v.minLength(1, "lane_session is required")),
-	title: v.pipe(v.string(), v.minLength(1, "title is required")),
-});
-
-/**
- * The rename outcome from a resolved lane task — pure so the "no task bound ⇒
- * not updated, never an error" decision is unit-testable with no DB. A rename
- * whose lane has no task is best-effort (returns updated:false): every spawn
- * now mints a task, so this is the rare case (a tab whose task was archived and
- * pruned), not a path the operator hits. Failing loudly here would refuse a
- * rename of the WINDOW for a DB miss, which couples two surfaces that must not
- * be — the tmux rename already succeeded before this is called.
- */
-export function renameOutcome(task: { id: string } | null): {
-	task_id: string | null;
-	updated: boolean;
-} {
-	if (!task) return { task_id: null, updated: false };
-	return { task_id: task.id, updated: true };
-}
-
-/**
- * renameLaneTask ORPC handler. The session-picker daemon calls this from
- * `/rpc/rename` after it renames the tmux window: it resolves the pane's tab to
- * its session id and posts it here. Same transport as bindLane/readTaskList:
- * page-gate-exempt (fn.taskSync), localhost super-admin. Resolves the lane's
- * task BY SESSION (never pane) and updates its title. Idempotent: renaming to
- * the same title writes the same row.
- *
- * An archived parent is matched too (resolveLaneTask falls back to the archived
- * lane task for the session), so a rename of a tab whose run closed still lands
- * on its task — the title is the title regardless of run state.
- */
-export const renameLaneTaskHandler = authed
-	.input(renameLaneTaskInput)
-	.handler(async ({ input, context }) => {
-		const ctx = context as Context;
-		const prisma = ctx.prisma as Prisma;
-		const { lane_session, title } = input;
-		const task = await resolveLaneTask(prisma, lane_session);
-		const outcome = renameOutcome(task);
-		if (!task) return outcome;
-		try {
-			await prisma.work_items.update({
-				where: { id: task.id },
-				data: { title },
-				select: { id: true },
-			});
-		} catch (err) {
-			// The window was already renamed by the caller; a DB update failure must
-			// not surface as an error that implies the rename failed. Report
-			// not-updated + log, so the two surfaces stay decoupled
-			// (`a-component-may-not-report-a-state-it-has-not-verified`).
-			getAppLogger().warn("[task-sync] renameLaneTask: title update failed", {
-				taskId: task.id,
-				error: err instanceof Error ? err.message : String(err),
-			});
-			return { task_id: task.id, updated: false };
-		}
-		return outcome;
-	});

package/src/fn-routers/tasks-router.ts

@@ -1,77 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * ORPC procedures for task creation with initial comment.
- * Extracted from @teamscala/orpc/fn-router — primitives tier must not
- * contain application-specific work_items logic.
- */
-
-import { authed, type Context } from "./auth-router.ts";
-
-function toSession(ctx: Context): { userId: string; orgId: string | null } {
-	const user = ctx.user as { id: string; organisationId?: string | null };
-	return {
-		userId: user.id,
-		orgId: ctx.orgId || user.organisationId || null,
-	};
-}
-
-export const tasksRouter = {
-	createWithComment: authed.handler(async ({ input, context }) => {
-		const data = input as {
-			project_id: string;
-			title: string;
-			initial_comment: string;
-			status?: string;
-			assignee_id?: string;
-			due_date?: string;
-			start_date?: string;
-			time_estimate?: number;
-			assignee_type?: string;
-			agent_assignee_id?: string;
-			automation_type?: string;
-			responsible_party?: string;
-			depends_on?: string[];
-		};
-
-		if (!data.project_id) throw new Error("project_id is required");
-		if (!data.title) throw new Error("title is required");
-		if (!data.initial_comment) throw new Error("initial_comment is required");
-
-		const userId = toSession(context).userId;
-		const result = await (context.prisma as any).$transaction(
-			async (tx: any) => {
-				const task = await tx.work_items.create({
-					data: {
-						kind: "task",
-						project_id: data.project_id,
-						title: data.title,
-						status: data.status || "todo",
-						assignee_id: data.assignee_id || null,
-						due_date: data.due_date || null,
-						start_date: data.start_date || null,
-						time_estimate: data.time_estimate || null,
-						assignee_type: data.assignee_type || "user",
-						agent_assignee_id: data.agent_assignee_id || null,
-						automation_type: data.automation_type || "manual",
-						responsible_party: data.responsible_party || "team",
-						depends_on: data.depends_on || [],
-						created_by: userId,
-						updated_by: userId,
-					},
-				});
-				await tx.comments.create({
-					data: {
-						work_item_id: task.id,
-						content: data.initial_comment,
-						user_id: userId,
-					},
-				});
-				return task;
-			},
-		);
-		return { success: true, data: result };
-	}),
-};

package/src/page-server-orpc/portal-diagnostics-router.ts

@@ -1,170 +0,0 @@
-/**
- * @system page-server
- * @status handwritten
- * @edit edit directly
- *
- * ORPC procedures for portal diagnostics. These replace direct Prisma calls
- * in the portal diagnostic section files with proper ORPC procedures that
- * receive context.prisma from the router.
- */
-
-import { os } from "@orpc/server";
-import { BlockSchemaConfigSchema } from "@teamscala/db-validation/registry-schemas/block-schema";
-import { loadRegistryConfigsByType } from "@teamscala/db/registry/load-config";
-import * as v from "valibot";
-
-const procedure = os;
-
-const PortalWebsiteSchema = v.object({
-	id: v.string(),
-	name: v.string(),
-	organisation_id: v.nullable(v.string()),
-});
-
-const MemberSchema = v.object({
-	user_id: v.string(),
-});
-
-const PageRowSchema = v.object({
-	id: v.string(),
-	path: v.nullable(v.string()),
-	name: v.string(),
-	puck_data: v.unknown(),
-	updated_at: v.string(),
-});
-
-const BlockSchemaSlugSchema = v.object({
-	slug: v.string(),
-});
-
-export const portalDiagRouter = {
-	findPortalWebsite: procedure
-		.input(v.object({}))
-		.output(v.nullable(PortalWebsiteSchema))
-		.handler(async ({ context }) => {
-			const db = (context as { prisma?: unknown }).prisma;
-			if (!db)
-				throw new Error("portalDiag.findPortalWebsite requires context.prisma");
-
-			return (await (
-				db as {
-					builda_websites: { findFirst: (args: unknown) => Promise<unknown> };
-				}
-			).builda_websites.findFirst({
-				where: { website_type: "portal" },
-				select: { id: true, name: true, organisation_id: true },
-				orderBy: { updated_at: "desc" },
-			})) as {
-				id: string;
-				name: string;
-				organisation_id: string | null;
-			} | null;
-		}),
-
-	findMember: procedure
-		.input(v.object({ organisationId: v.string() }))
-		.output(v.nullable(MemberSchema))
-		.handler(async ({ input, context }) => {
-			const db = (context as { prisma?: unknown }).prisma;
-			if (!db) throw new Error("portalDiag.findMember requires context.prisma");
-
-			return (await (
-				db as {
-					better_auth_member: {
-						findFirst: (args: unknown) => Promise<unknown>;
-					};
-				}
-			).better_auth_member.findFirst({
-				where: { organization_id: input.organisationId },
-				select: { user_id: true },
-			})) as { user_id: string } | null;
-		}),
-
-	countPages: procedure
-		.input(v.object({ websiteId: v.string() }))
-		.output(v.number())
-		.handler(async ({ input, context }) => {
-			const db = (context as { prisma?: unknown }).prisma;
-			if (!db) throw new Error("portalDiag.countPages requires context.prisma");
-
-			return await (
-				db as { builda_pages: { count: (args: unknown) => Promise<number> } }
-			).builda_pages.count({
-				where: { website_id: input.websiteId },
-			});
-		}),
-
-	findPages: procedure
-		.input(
-			v.object({
-				websiteId: v.string(),
-				path: v.optional(v.string()),
-				take: v.optional(v.number()),
-				orderBy: v.optional(v.string()),
-			}),
-		)
-		.output(v.array(PageRowSchema))
-		.handler(async ({ input, context }) => {
-			const db = (context as { prisma?: unknown }).prisma;
-			if (!db) throw new Error("portalDiag.findPages requires context.prisma");
-
-			const where: Record<string, unknown> = { website_id: input.websiteId };
-			if (input.path) where.path = input.path;
-
-			return (await (
-				db as {
-					builda_pages: { findMany: (args: unknown) => Promise<unknown[]> };
-				}
-			).builda_pages.findMany({
-				where,
-				select: {
-					id: true,
-					path: true,
-					name: true,
-					puck_data: true,
-					updated_at: true,
-				},
-				take: input.take,
-				orderBy: input.orderBy ? { [input.orderBy]: "desc" } : undefined,
-			})) as Array<{
-				id: string;
-				path: string | null;
-				name: string;
-				puck_data: unknown;
-				updated_at: string;
-			}>;
-		}),
-
-	findBlockSchemas: procedure
-		.input(v.object({ slugs: v.array(v.string()) }))
-		.output(v.array(BlockSchemaSlugSchema))
-		.handler(async ({ input }) => {
-			const all = await loadRegistryConfigsByType(
-				"block_schema",
-				BlockSchemaConfigSchema,
-			);
-			return all
-				.filter((r) => input.slugs.includes(r.slug))
-				.map((r) => ({ slug: r.slug }));
-		}),
-
-	findWebsites: procedure
-		.input(v.object({ take: v.optional(v.number()) }))
-		.output(v.array(v.object({ id: v.string(), name: v.string() })))
-		.handler(async ({ input, context }) => {
-			const db = (context as { prisma?: unknown }).prisma;
-			if (!db)
-				throw new Error("portalDiag.findWebsites requires context.prisma");
-
-			return (await (
-				db as {
-					builda_websites: { findMany: (args: unknown) => Promise<unknown[]> };
-				}
-			).builda_websites.findMany({
-				select: { id: true, name: true },
-				take: input.take ?? 10,
-			})) as Array<{ id: string; name: string }>;
-		}),
-};
-
-export type PortalDiagRouter = typeof portalDiagRouter;

package/src/page-server-orpc/templates-router.ts

@@ -1,116 +0,0 @@
-/**
- * @system page-server
- * @status handwritten
- * @edit edit directly
- *
- * ORPC procedure: templates.getSettings(slug). Reads the registry_entries row
- * of type='template_settings' for the requested slug, validates against the
- * matching Valibot schema from db-validation, returns typed settings.
- *
- * Per data-access.md: every data read goes through ORPC. The Template
- * components do not call Prisma or registry directly — they receive the
- * typed result of this procedure as a prop.
- *
- * Server-side (SSR) calls land here in-process via createRouterClient.
- * Client-side calls would land here over HTTP via createORPCClient.
- */
-
-import { os } from "@orpc/server";
-import { TemplateSettingsPortalsConfigSchema } from "@teamscala/db-validation/registry-schemas/template-settings-portals";
-import { TemplateSettingsPublicConfigSchema } from "@teamscala/db-validation/registry-schemas/template-settings-public";
-import { getEntry } from "@teamscala/db/registry/accessors";
-import * as v from "valibot";
-
-const SCHEMA_BY_SLUG: Record<
-	string,
-	v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>
-> = {
-	"portals-template": TemplateSettingsPortalsConfigSchema,
-	"public-template": TemplateSettingsPublicConfigSchema,
-};
-
-const procedure = os;
-
-export const templatesRouter = {
-	getSettings: procedure
-		.input(v.object({ slug: v.string() }))
-		.handler(async ({ input }) => {
-			const schema = SCHEMA_BY_SLUG[input.slug];
-			if (!schema) {
-				throw new Error(
-					`templates.getSettings: unknown template slug "${input.slug}"`,
-				);
-			}
-			const entry = getEntry("template_settings" as never, input.slug);
-			if (!entry) {
-				throw new Error(
-					`templates.getSettings: row missing for slug "${input.slug}"`,
-				);
-			}
-			const config =
-				typeof entry.config === "string"
-					? JSON.parse(entry.config)
-					: entry.config;
-			return v.parse(schema, config);
-		}),
-
-	/**
-	 * Patch a template's settings row. The patch is a deep partial applied
-	 * over the existing config; the merged result is validated against the
-	 * matching Valibot schema before write. Used by chrome layout (pane
-	 * widths, toolbar height, etc.) so resizes persist server-side and the
-	 * next SSR render picks them up directly — no localStorage, no flash.
-	 */
-	updateSettings: procedure
-		.input(
-			v.object({ slug: v.string(), patch: v.record(v.string(), v.unknown()) }),
-		)
-		.handler(async ({ input }) => {
-			const schema = SCHEMA_BY_SLUG[input.slug];
-			if (!schema) {
-				throw new Error(
-					`templates.updateSettings: unknown template slug "${input.slug}"`,
-				);
-			}
-			const entry = getEntry("template_settings" as never, input.slug);
-			if (!entry) {
-				throw new Error(
-					`templates.updateSettings: row missing for slug "${input.slug}"`,
-				);
-			}
-			const current =
-				typeof entry.config === "string"
-					? JSON.parse(entry.config)
-					: entry.config;
-			const merged = deepMerge(current as Record<string, unknown>, input.patch);
-			const validated = v.parse(schema, merged);
-			return validated;
-		}),
-};
-
-function deepMerge(
-	target: Record<string, unknown>,
-	patch: Record<string, unknown>,
-): Record<string, unknown> {
-	const out: Record<string, unknown> = { ...target };
-	for (const [key, value] of Object.entries(patch)) {
-		if (
-			value &&
-			typeof value === "object" &&
-			!Array.isArray(value) &&
-			target[key] &&
-			typeof target[key] === "object" &&
-			!Array.isArray(target[key])
-		) {
-			out[key] = deepMerge(
-				target[key] as Record<string, unknown>,
-				value as Record<string, unknown>,
-			);
-		} else {
-			out[key] = value;
-		}
-	}
-	return out;
-}
-
-export type TemplatesRouter = typeof templatesRouter;

package/src/serve/serve-ws.test.ts

@@ -1,135 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * Unit test for serve.ts WebSocket upgrade path. Spins up a real
- * Hono + createBunWebSocket + Bun.serve, registers a WS route, connects
- * a client, and asserts message round-trip.
- *
- * Catches the class of bugs where fetchWithPeerPort clones the Request
- * on WS upgrade (commit 43bb02b8e fixed this). If any future change to
- * serve.ts breaks upgrade identity, this test fails.
- */
-
-import { afterEach, expect, test } from "bun:test";
-import { Hono } from "hono";
-import { createBunWebSocket } from "hono/bun";
-import type { ServeHandle } from "./serve.ts";
-import { serveStart } from "./serve.ts";
-
-const TEST_PORT = 49152;
-const WS_PATH = "/ws-test";
-
-let handle: ServeHandle | null = null;
-
-function setupTestServer(): ServeHandle {
-	const app = new Hono();
-	const { upgradeWebSocket } = createBunWebSocket();
-
-	app.get(
-		WS_PATH,
-		upgradeWebSocket(() => ({
-			onOpen(_evt, ws) {
-				const raw = ws.raw as { send: (data: string) => void } | undefined;
-				if (raw) {
-					raw.send("hello-from-server");
-				}
-			},
-			onMessage(evt, ws) {
-				const raw = ws.raw as { send: (data: string) => void } | undefined;
-				if (raw && typeof evt.data === "string") {
-					raw.send(`echo:${evt.data}`);
-				}
-			},
-		})),
-	);
-
-	const h = serveStart(app, {
-		port: TEST_PORT,
-		serviceSlug: "ws-test",
-		logger: { info: () => {}, warn: () => {} },
-	});
-	handle = h;
-	return h;
-}
-
-afterEach(() => {
-	if (handle) {
-		handle.stop();
-		handle = null;
-	}
-});
-
-test("WS upgrade succeeds and messages round-trip", async () => {
-	setupTestServer();
-
-	const ws = new WebSocket(`ws://127.0.0.1:${TEST_PORT}${WS_PATH}`);
-
-	const openPromise = new Promise<void>((resolve, reject) => {
-		const timer = setTimeout(
-			() => reject(new Error("WS connection timed out")),
-			5000,
-		);
-		ws.addEventListener("open", () => {
-			clearTimeout(timer);
-			resolve();
-		});
-		ws.addEventListener("error", (evt) => {
-			clearTimeout(timer);
-			reject(new Error(`WS error: ${String(evt)}`));
-		});
-	});
-
-	await openPromise;
-
-	const greeting = await new Promise<string>((resolve, reject) => {
-		const timer = setTimeout(
-			() => reject(new Error("greeting message timed out")),
-			5000,
-		);
-		ws.addEventListener("message", (evt) => {
-			clearTimeout(timer);
-			resolve(String(evt.data));
-		});
-	});
-	expect(greeting).toBe("hello-from-server");
-
-	const echoPromise = new Promise<string>((resolve, reject) => {
-		const timer = setTimeout(
-			() => reject(new Error("echo message timed out")),
-			5000,
-		);
-		ws.addEventListener("message", (evt) => {
-			clearTimeout(timer);
-			resolve(String(evt.data));
-		});
-	});
-	ws.send("ping");
-	const echo = await echoPromise;
-	expect(echo).toBe("echo:ping");
-
-	ws.close();
-});
-
-test("WS upgrade rejects on unknown path", async () => {
-	setupTestServer();
-
-	const ws = new WebSocket(`ws://127.0.0.1:${TEST_PORT}/nonexistent`);
-
-	const result = await new Promise<{ ok: boolean; code?: number }>(
-		(resolve) => {
-			const timer = setTimeout(() => resolve({ ok: true }), 5000);
-			ws.addEventListener("error", () => {
-				clearTimeout(timer);
-				resolve({ ok: false });
-			});
-			ws.addEventListener("close", (evt) => {
-				clearTimeout(timer);
-				resolve({ ok: false, code: evt.code });
-			});
-		},
-	);
-
-	expect(result.ok).toBe(false);
-});