@dungle-scrubs/tallow 0.8.21 → 0.8.23

package/extensions/_shared/bordered-box.ts

@@ -0,0 +1,102 @@
+/**
+ * Lightweight bordered-box renderer for bundled extensions.
+ *
+ * This avoids depending on fork-only `@mariozechner/pi-tui` exports in the
+ * published package while preserving the same visual style where needed.
+ */
+
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+interface BorderStyle {
+	readonly bottomLeft: string;
+	readonly bottomRight: string;
+	readonly horizontal: string;
+	readonly topLeft: string;
+	readonly topRight: string;
+	readonly vertical: string;
+}
+
+export interface RenderBorderedBoxOptions {
+	readonly borderColorFn?: (str: string) => string;
+	readonly paddingX?: number;
+	readonly style?: "rounded" | "sharp";
+	readonly title?: string;
+	readonly titleColorFn?: (str: string) => string;
+}
+
+const BORDER_STYLES = {
+	rounded: {
+		bottomLeft: "╰",
+		bottomRight: "╯",
+		horizontal: "─",
+		topLeft: "╭",
+		topRight: "╮",
+		vertical: "│",
+	},
+	sharp: {
+		bottomLeft: "└",
+		bottomRight: "┘",
+		horizontal: "─",
+		topLeft: "┌",
+		topRight: "┐",
+		vertical: "│",
+	},
+} as const satisfies Record<NonNullable<RenderBorderedBoxOptions["style"]>, BorderStyle>;
+
+/**
+ * Render content lines inside a bordered box.
+ *
+ * @param contentLines - Pre-rendered content to wrap
+ * @param width - Available render width
+ * @param options - Title, padding, border style, and color callbacks
+ * @returns Rendered border and body lines
+ */
+export function renderBorderedBox(
+	contentLines: readonly string[],
+	width: number,
+	options: RenderBorderedBoxOptions = {}
+): string[] {
+	const style = BORDER_STYLES[options.style ?? "sharp"];
+	const padX = options.paddingX ?? 1;
+	const colorBorder = options.borderColorFn ?? ((str: string) => str);
+	const colorTitle = options.titleColorFn ?? ((str: string) => str);
+	const innerWidth = width - 2 - padX * 2;
+	if (innerWidth < 1) return [...contentLines];
+
+	const pad = " ".repeat(padX);
+	let topBar: string;
+	if (options.title) {
+		const title = ` ${colorTitle(options.title)} `;
+		const rightFill = Math.max(0, width - 3 - visibleWidth(title));
+		topBar =
+			colorBorder(style.topLeft) +
+			colorBorder(style.horizontal) +
+			title +
+			colorBorder(style.horizontal.repeat(rightFill)) +
+			colorBorder(style.topRight);
+	} else {
+		topBar =
+			colorBorder(style.topLeft) +
+			colorBorder(style.horizontal.repeat(width - 2)) +
+			colorBorder(style.topRight);
+	}
+
+	const bodyLines = contentLines.map((line) => {
+		const clamped = visibleWidth(line) > innerWidth ? truncateToWidth(line, innerWidth) : line;
+		const fill = Math.max(0, innerWidth - visibleWidth(clamped));
+		return (
+			colorBorder(style.vertical) +
+			pad +
+			clamped +
+			" ".repeat(fill) +
+			pad +
+			colorBorder(style.vertical)
+		);
+	});
+
+	const bottomBar =
+		colorBorder(style.bottomLeft) +
+		colorBorder(style.horizontal.repeat(width - 2)) +
+		colorBorder(style.bottomRight);
+	return [topBar, ...bodyLines, bottomBar];
+}

package/extensions/_shared/interop-events.ts

@@ -7,6 +7,7 @@ export const INTEROP_EVENT_SCHEMA_VERSION = 1 as const;
 
 /** Event channels used for typed cross-extension state synchronization. */
 export const INTEROP_EVENT_NAMES = {
+	backgroundTasksPresenterState: "interop.v1.background-tasks.presenter-state",
 	backgroundTasksSnapshot: "interop.v1.background-tasks.snapshot",
 	stateRequest: "interop.v1.state.request",
 	subagentsSnapshot: "interop.v1.subagents.snapshot",
@@ -117,6 +118,10 @@ const InteropTeamViewSchema = Type.Object({
 });
 
 const InteropEventSchemas = {
+	[INTEROP_EVENT_NAMES.backgroundTasksPresenterState]: Type.Object({
+		active: Type.Boolean(),
+		schemaVersion: Type.Literal(INTEROP_EVENT_SCHEMA_VERSION),
+	}),
 	[INTEROP_EVENT_NAMES.backgroundTasksSnapshot]: Type.Object({
 		schemaVersion: Type.Literal(INTEROP_EVENT_SCHEMA_VERSION),
 		tasks: Type.Array(InteropBackgroundTaskViewSchema),

package/extensions/_shared/pid-registry.ts

@@ -15,7 +15,7 @@ import { dirname, join } from "node:path";
 import {
 	createRuntimePathProvider,
 	type RuntimePathProvider,
-} from "../../src/runtime-path-provider.js";
+} from "../../runtime/runtime-path-provider.js";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { acquireFileLock } from "./file-lock.js";
 

package/extensions/agent-commands-tool/index.ts

@@ -11,7 +11,10 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { DEFAULT_AGENT_RUNNER_ENV, spawnWithResolvedAgentRunner } from "../../src/agent-runner.js";
+import {
+	DEFAULT_AGENT_RUNNER_ENV,
+	spawnWithResolvedAgentRunner,
+} from "../../runtime/agent-runner.js";
 import { isProjectTrusted } from "../_shared/project-trust.js";
 import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 

package/extensions/background-task-tool/__tests__/lifecycle.test.ts

@@ -196,54 +196,70 @@ describe("Background task tool registration", () => {
 	});
 });
 
-// ── bg_bash streaming mode ───────────────────────────────────────────────────
+// ── bg_bash always-async mode ─────────────────────────────────────────────────
 
-describe("bg_bash streaming mode", () => {
-	it("runs a simple command and captures output", async () => {
+describe("bg_bash always-async mode", () => {
+	it("returns immediately with task ID", async () => {
 		const bgBash = getTool(harness, "bg_bash");
 		const result = await execTool(bgBash, { command: "echo hello world" });
 
-		expect(firstText(result)).toContain("hello world");
-		const details = result.details as { status?: string; exitCode?: number };
-		expect(details.status).toBe("completed");
-		expect(details.exitCode).toBe(0);
+		const details = result.details as { taskId?: string };
+		expect(details.taskId).toBeDefined();
+		expect(details.taskId).toMatch(/^bg_/);
+		expect(firstText(result)).toContain("Task ID:");
 	});
 
-	it("captures exit code from failing commands", async () => {
+	it("captures output retrievable via task_output", async () => {
 		const bgBash = getTool(harness, "bg_bash");
-		const result = await execTool(bgBash, { command: "exit 42" });
+		const taskOutput = getTool(harness, "task_output");
 
-		const details = result.details as { status?: string; exitCode?: number };
-		expect(details.status).toBe("failed");
-		expect(details.exitCode).toBe(42);
+		const run = await execTool(bgBash, { command: "echo hello world" });
+		const taskId = (run.details as { taskId: string }).taskId;
+
+		// Wait for process to complete
+		await new Promise((resolve) => setTimeout(resolve, 100));
+
+		const output = await execTool(taskOutput, { taskId });
+		expect(firstText(output)).toContain("hello world");
 	});
 
-	it("reports duration in result details", async () => {
+	it("captures exit code from failing commands", async () => {
 		const bgBash = getTool(harness, "bg_bash");
-		const result = await execTool(bgBash, { command: "echo fast" });
+		const taskStatus = getTool(harness, "task_status");
 
-		const details = result.details as { duration?: string };
-		expect(details.duration).toBeDefined();
-		expect(details.duration).toContain("s");
+		const run = await execTool(bgBash, { command: "exit 42" });
+		const taskId = (run.details as { taskId: string }).taskId;
+
+		await new Promise((resolve) => setTimeout(resolve, 100));
+
+		const status = await execTool(taskStatus, { taskId });
+		const details = status.details as { status?: string; exitCode?: number };
+		expect(details.status).toBe("failed");
+		expect(details.exitCode).toBe(42);
 	});
 
 	it("captures stderr in output", async () => {
 		const bgBash = getTool(harness, "bg_bash");
-		const result = await execTool(bgBash, { command: "echo error >&2" });
+		const taskOutput = getTool(harness, "task_output");
+
+		const run = await execTool(bgBash, { command: "echo error >&2" });
+		const taskId = (run.details as { taskId: string }).taskId;
+
+		await new Promise((resolve) => setTimeout(resolve, 100));
 
-		expect(firstText(result)).toContain("error");
+		const output = await execTool(taskOutput, { taskId });
+		expect(firstText(output)).toContain("error");
 	});
 });
 
 // ── bg_bash fire-and-forget mode ─────────────────────────────────────────────
 
-describe("bg_bash fire-and-forget mode", () => {
-	it("returns immediately with task ID", async () => {
+describe("bg_bash background flag (deprecated, always async)", () => {
+	it("background=true still returns immediately with task ID", async () => {
 		const bgBash = getTool(harness, "bg_bash");
 		const result = await execTool(bgBash, { command: "sleep 0.1", background: true });
 
-		const details = result.details as { taskId?: string; fireAndForget?: boolean };
-		expect(details.fireAndForget).toBe(true);
+		const details = result.details as { taskId?: string };
 		expect(details.taskId).toBeDefined();
 		expect(details.taskId).toMatch(/^bg_/);
 		expect(firstText(result)).toContain("Task ID:");
@@ -255,7 +271,7 @@ describe("bg_bash fire-and-forget mode", () => {
 		const taskStatus = getTool(harness, "task_status");
 		const taskOutput = getTool(harness, "task_output");
 
-		const run = await execTool(bgBash, { command: "echo ignored", background: true });
+		const run = await execTool(bgBash, { command: "echo ignored" });
 		const taskId = (run.details as { taskId: string }).taskId;
 
 		await new Promise((resolve) => setTimeout(resolve, 5));
@@ -271,7 +287,7 @@ describe("bg_bash fire-and-forget mode", () => {
 		const bgBash = getTool(harness, "bg_bash");
 		const taskStatus = getTool(harness, "task_status");
 
-		const result = await execTool(bgBash, { command: "sleep 0.05", background: true });
+		const result = await execTool(bgBash, { command: "sleep 0.05" });
 		const taskId = (result.details as { taskId: string }).taskId;
 
 		const status = await execTool(taskStatus, { taskId });
@@ -291,6 +307,8 @@ describe("task_output", () => {
 		const run = await execTool(bgBash, { command: "echo line1; echo line2" });
 		const taskId = (run.details as { taskId: string }).taskId;
 
+		await new Promise((resolve) => setTimeout(resolve, 100));
+
 		const output = await execTool(taskOutput, { taskId });
 		expect(firstText(output)).toContain("line1");
 		expect(firstText(output)).toContain("line2");
@@ -312,6 +330,8 @@ describe("task_output", () => {
 		});
 		const taskId = (run.details as { taskId: string }).taskId;
 
+		await new Promise((resolve) => setTimeout(resolve, 100));
+
 		const output = await execTool(taskOutput, { taskId, tail: 3 });
 		const text = firstText(output);
 		expect(text).toContain("line10");
@@ -329,6 +349,8 @@ describe("task_status", () => {
 		const run = await execTool(bgBash, { command: "echo done" });
 		const taskId = (run.details as { taskId: string }).taskId;
 
+		await new Promise((resolve) => setTimeout(resolve, 100));
+
 		const status = await execTool(taskStatus, { taskId });
 		const details = status.details as { status?: string; exitCode?: number };
 		expect(details.status).toBe("completed");
@@ -360,6 +382,9 @@ describe("task_kill", () => {
 		const run = await execTool(bgBash, { command: "echo done" });
 		const taskId = (run.details as { taskId: string }).taskId;
 
+		// Wait for the async process to complete
+		await new Promise((resolve) => setTimeout(resolve, 100));
+
 		const result = await execTool(taskKill, { taskId });
 		expect(firstText(result)).toContain("not running");
 	});