@markjaquith/agency 3.2.0 → 3.2.2

package/src/usage-log.test.ts

@@ -24,6 +24,13 @@ describe("usage logging", () => {
 					durationMs: 12.4,
 					outcome: "success",
 					exitStatus: 0,
+					...(commandPath === "context"
+						? {
+								vcs: "git" as const,
+								terminalStage: "publish",
+								category: "success",
+							}
+						: {}),
 				},
 				"1.2.3",
 				env,
@@ -35,7 +42,7 @@ describe("usage logging", () => {
 		)
 		expect(await exportUsageEvents(env)).toEqual([
 			expect.objectContaining({
-				version: 1,
+				version: 2,
 				sessionId: "session-1",
 				sessionSequence: 1,
 				agencyVersion: "1.2.3",
@@ -48,6 +55,9 @@ describe("usage logging", () => {
 			expect.objectContaining({
 				sessionSequence: 2,
 				commandPath: "context",
+				vcs: "git",
+				terminalStage: "publish",
+				category: "success",
 			}),
 		])
 	})

package/src/usage-log.ts

@@ -2,7 +2,7 @@ import { Database } from "bun:sqlite"
 import { mkdir } from "node:fs/promises"
 import { dirname, join } from "node:path"
 
-const USAGE_EVENT_VERSION = 1 as const
+const USAGE_EVENT_VERSION = 2 as const
 const DEFAULT_RETENTION_DAYS = 90
 
 export interface UsageEvent {
@@ -11,6 +11,9 @@ export interface UsageEvent {
 	readonly durationMs: number
 	readonly exitStatus: number
 	readonly outcome: "success" | "failure"
+	readonly vcs?: "git"
+	readonly terminalStage?: string
+	readonly category?: string
 }
 
 const stateDirectory = (env: NodeJS.ProcessEnv) =>
@@ -50,6 +53,13 @@ const openDatabase = async (env: NodeJS.ProcessEnv) => {
 			exit_status INTEGER NOT NULL
 		)
 	`)
+	for (const column of ["vcs", "terminal_stage", "category"]) {
+		try {
+			database.run(`ALTER TABLE usage_events ADD COLUMN ${column} TEXT`)
+		} catch {
+			// Existing databases already have migrated columns.
+		}
+	}
 	database.run(
 		"CREATE INDEX IF NOT EXISTS usage_events_session ON usage_events(session_id, session_sequence)",
 	)
@@ -74,11 +84,11 @@ export async function recordUsageEvent(
 					INSERT INTO usage_events (
 						event_version, session_id, session_sequence, occurred_at,
 						agency_version, command_path, flag_names, duration_ms,
-						outcome, exit_status
+						outcome, exit_status, vcs, terminal_stage, category
 					) VALUES (
 						?, ?,
 						(SELECT COALESCE(MAX(session_sequence), 0) + 1 FROM usage_events WHERE session_id = ?),
-						?, ?, ?, ?, ?, ?, ?
+						?, ?, ?, ?, ?, ?, ?, ?, ?, ?
 					)
 				`)
 			.run(
@@ -92,6 +102,9 @@ export async function recordUsageEvent(
 				Math.max(0, Math.round(event.durationMs)),
 				event.outcome,
 				event.exitStatus,
+				event.vcs ?? null,
+				event.terminalStage ?? null,
+				event.category ?? null,
 			)
 		if (Math.random() < 0.01) {
 			const days = retentionDays(env)
@@ -119,7 +132,7 @@ export async function exportUsageEvents(
 			.query(`
 				SELECT event_version, session_id, session_sequence, occurred_at,
 					agency_version, command_path, flag_names, duration_ms,
-					outcome, exit_status
+					outcome, exit_status, vcs, terminal_stage, category
 				FROM usage_events ORDER BY occurred_at, id
 			`)
 			.all() as Record<string, string | number>[]
@@ -134,6 +147,11 @@ export async function exportUsageEvents(
 			durationMs: row.duration_ms,
 			outcome: row.outcome,
 			exitStatus: row.exit_status,
+			...(row.vcs == null ? {} : { vcs: row.vcs }),
+			...(row.terminal_stage == null
+				? {}
+				: { terminalStage: row.terminal_stage }),
+			...(row.category == null ? {} : { category: row.category }),
 		}))
 	} catch {
 		return []

package/src/utils/process.test.ts

@@ -64,4 +64,14 @@ describe("spawnProcess", () => {
 		expect(result.stderr).toContain("err:0:")
 		expect(result.stderr).toContain(`err:${lineCount - 1}:`)
 	})
+
+	test("terminates timed-out process groups", async () => {
+		const startedAt = performance.now()
+		await expect(
+			Effect.runPromise(
+				spawnProcess(["sh", "-c", "sleep 30 & wait"], { timeoutMs: 25 }),
+			),
+		).rejects.toThrow("Process timed out")
+		expect(performance.now() - startedAt).toBeLessThan(1_000)
+	})
 })

package/src/utils/process.ts

@@ -18,6 +18,7 @@ interface SpawnOptions {
 	readonly stdout?: "pipe" | "inherit" | "tee"
 	readonly stderr?: "pipe" | "inherit" | "tee"
 	readonly env?: Record<string, string>
+	readonly timeoutMs?: number
 }
 
 const readOutput = async (
@@ -45,8 +46,14 @@ class ProcessError extends Data.TaggedError("ProcessError")<{
 	command: string
 	exitCode: number
 	stderr: string
+	timedOut?: boolean
+	timeoutMs?: number
+	elapsedMs?: number
 }> {
 	override get message(): string {
+		if (this.timedOut) {
+			return `Process timed out after ${this.elapsedMs ?? this.timeoutMs} ms: ${this.command}${this.stderr ? `\n${this.stderr}` : ""}`
+		}
 		return (
 			this.stderr ||
 			`Process failed with exit code ${this.exitCode}: ${this.command}`
@@ -65,12 +72,14 @@ export const spawnProcess = (
 ): Effect.Effect<ProcessResult, ProcessError> =>
 	Effect.tryPromise({
 		try: async () => {
+			const startedAt = performance.now()
 			const proc = Bun.spawn([...args], {
 				cwd: options?.cwd ?? process.cwd(),
 				stdin: options?.stdin ?? "pipe",
 				stdout: options?.stdout === "inherit" ? "inherit" : "pipe",
 				stderr: options?.stderr === "inherit" ? "inherit" : "pipe",
 				env: options?.env ? { ...process.env, ...options.env } : process.env,
+				detached: options?.timeoutMs !== undefined,
 			})
 			// Start draining stdout/stderr immediately so verbose subprocesses
 			// cannot block on filled pipe buffers before they exit.
@@ -89,11 +98,53 @@ export const spawnProcess = (
 							options?.stderr === "tee" ? process.stderr : undefined,
 						)
 
+			let timedOut = false
+			let timer: ReturnType<typeof setTimeout> | undefined
+			const exited =
+				options?.timeoutMs === undefined
+					? proc.exited
+					: Promise.race([
+							proc.exited,
+							new Promise<number>((resolve) => {
+								timer = setTimeout(async () => {
+									timedOut = true
+									try {
+										process.kill(-proc.pid, "SIGTERM")
+									} catch {
+										proc.kill("SIGTERM")
+									}
+									const stopped = await Promise.race([
+										proc.exited.then(() => true),
+										Bun.sleep(250).then(() => false),
+									])
+									if (!stopped) {
+										try {
+											process.kill(-proc.pid, "SIGKILL")
+										} catch {
+											proc.kill("SIGKILL")
+										}
+									}
+									resolve(await proc.exited)
+								}, options.timeoutMs)
+							}),
+						])
 			const [exitCode, stdout, stderr] = await Promise.all([
-				proc.exited,
+				exited,
 				stdoutPromise,
 				stderrPromise,
 			])
+			if (timer) clearTimeout(timer)
+			if (timedOut) {
+				throw new ProcessError({
+					command: args.join(" "),
+					exitCode:
+						typeof exitCode === "number" ? exitCode : (proc.exitCode ?? -1),
+					stderr: stderr.trim(),
+					timedOut: true,
+					timeoutMs: options?.timeoutMs,
+					elapsedMs: Math.round(performance.now() - startedAt),
+				})
+			}
 
 			return {
 				stdout: stdout.trim(),
@@ -103,9 +154,11 @@ export const spawnProcess = (
 			}
 		},
 		catch: (error) =>
-			new ProcessError({
-				command: args.join(" "),
-				exitCode: -1,
-				stderr: error instanceof Error ? error.message : String(error),
-			}),
+			error instanceof ProcessError
+				? error
+				: new ProcessError({
+						command: args.join(" "),
+						exitCode: -1,
+						stderr: error instanceof Error ? error.message : String(error),
+					}),
 	})