@asterxsk/kiln 0.1.0 → 0.3.0

package/agent.bak.20260905-190020/extensions/shared/test/child-session.test.ts

@@ -0,0 +1,270 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import test from "node:test";
+import {
+  createAgentSession,
+  DefaultResourceLoader,
+  defineTool,
+  ProjectTrustStore,
+  SessionManager,
+  SettingsManager,
+  type SessionShutdownEvent,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import {
+  bindChildSessionExtensions,
+  CHILD_EXCLUDED_TOOL_NAMES,
+  childToolPolicy,
+  createChildResources,
+  resolveStandaloneChildProjectTrust,
+  shutdownAndDisposeChildSession,
+  type DisposableChildSession,
+} from "../child-session.ts";
+
+async function withTempDir(run: (directory: string) => Promise<void>) {
+  const directory = await mkdtemp(path.join(tmpdir(), "pi-child-policy-"));
+  try {
+    await run(directory);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+test("child denylist keeps extension and workflow structured tools available", async () => {
+  await withTempDir(async (directory) => {
+    let starts = 0;
+    let shutdowns = 0;
+    const settingsManager = SettingsManager.inMemory(undefined, {
+      projectTrusted: false,
+    });
+    const inlineLoader = new DefaultResourceLoader({
+      cwd: directory,
+      agentDir: path.join(directory, "inline-agent"),
+      settingsManager,
+      extensionFactories: [
+        (pi) => {
+          pi.on("session_start", () => {
+            starts++;
+          });
+          pi.on("session_shutdown", () => {
+            shutdowns++;
+          });
+          for (const name of [
+            "fixture_extension_tool",
+            ...CHILD_EXCLUDED_TOOL_NAMES,
+          ]) {
+            pi.registerTool({
+              name,
+              label: name,
+              description: name,
+              parameters: Type.Object({}),
+              async execute() {
+                return {
+                  content: [{ type: "text", text: "ok" }],
+                  details: {},
+                };
+              },
+            });
+          }
+        },
+      ],
+    });
+    await inlineLoader.reload();
+
+    const structuredOutput = defineTool({
+      name: "structured_output",
+      label: "Structured Output",
+      description: "fixture structured result",
+      parameters: Type.Object({ value: Type.String() }),
+      async execute(_id, params) {
+        return {
+          content: [{ type: "text", text: params.value }],
+          details: {},
+        };
+      },
+    });
+    const { session } = await createAgentSession({
+      cwd: directory,
+      agentDir: path.join(directory, "inline-agent"),
+      resourceLoader: inlineLoader,
+      settingsManager,
+      sessionManager: SessionManager.inMemory(directory),
+      customTools: [structuredOutput],
+      ...childToolPolicy(),
+    });
+    await bindChildSessionExtensions(session);
+
+    assert.deepEqual(
+      [...CHILD_EXCLUDED_TOOL_NAMES],
+      [
+        "subagent_spawn",
+        "subagent_wait",
+        "subagent_cancel",
+        "subagent_check",
+        "subagent_list",
+        "workflow",
+        "ask_user",
+      ],
+    );
+    const allTools = new Set(session.getAllTools().map((tool) => tool.name));
+    const activeTools = new Set(session.getActiveToolNames());
+    assert.equal(starts, 1);
+    assert.equal(allTools.has("fixture_extension_tool"), true);
+    assert.equal(activeTools.has("fixture_extension_tool"), true);
+    assert.equal(allTools.has("structured_output"), true);
+    assert.equal(activeTools.has("structured_output"), true);
+    for (const denied of CHILD_EXCLUDED_TOOL_NAMES) {
+      assert.equal(allTools.has(denied), false, `${denied} should be denied`);
+      assert.equal(
+        activeTools.has(denied),
+        false,
+        `${denied} should be inactive`,
+      );
+    }
+    for (const builtin of ["read", "bash", "edit", "write"]) {
+      assert.equal(
+        activeTools.has(builtin),
+        true,
+        `${builtin} should stay active`,
+      );
+    }
+
+    await Promise.all([
+      shutdownAndDisposeChildSession(session),
+      shutdownAndDisposeChildSession(session),
+    ]);
+    assert.equal(shutdowns, 1);
+  });
+});
+
+test("resource loading gates project extensions but retains global extensions", async () => {
+  await withTempDir(async (directory) => {
+    const cwd = path.join(directory, "project");
+    const agentDir = path.join(directory, "agent");
+    await mkdir(path.join(cwd, ".pi", "extensions"), { recursive: true });
+    await mkdir(path.join(agentDir, "extensions"), { recursive: true });
+    const extensionSource = (name: string) => `
+      export default function (pi) {
+        pi.registerTool({
+          name: ${JSON.stringify(name)}, label: ${JSON.stringify(name)},
+          description: "fixture", parameters: { type: "object", properties: {} },
+          async execute() { return { content: [{ type: "text", text: "ok" }] }; }
+        });
+      }
+    `;
+    await writeFile(
+      path.join(agentDir, "extensions", "global.ts"),
+      extensionSource("global_fixture"),
+    );
+    await writeFile(
+      path.join(cwd, ".pi", "extensions", "project.ts"),
+      extensionSource("project_fixture"),
+    );
+
+    const untrusted = await createChildResources({
+      cwd,
+      agentDir,
+      projectTrusted: false,
+    });
+    const untrustedTools = untrusted.loader
+      .getExtensions()
+      .extensions.flatMap((extension) => [...extension.tools.keys()]);
+    assert.equal(untrustedTools.includes("global_fixture"), true);
+    assert.equal(untrustedTools.includes("project_fixture"), false);
+
+    const trusted = await createChildResources({
+      cwd,
+      agentDir,
+      projectTrusted: true,
+    });
+    const trustedTools = trusted.loader
+      .getExtensions()
+      .extensions.flatMap((extension) => [...extension.tools.keys()]);
+    assert.equal(trustedTools.includes("global_fixture"), true);
+    assert.equal(trustedTools.includes("project_fixture"), true);
+  });
+});
+
+test("alternate standalone cwd only uses explicit saved trust", async () => {
+  await withTempDir(async (directory) => {
+    const parentCwd = path.join(directory, "parent");
+    const childCwd = path.join(directory, "alternate");
+    const agentDir = path.join(directory, "agent");
+    await mkdir(parentCwd, { recursive: true });
+    await mkdir(childCwd, { recursive: true });
+
+    assert.equal(
+      resolveStandaloneChildProjectTrust({
+        parentCwd,
+        childCwd: parentCwd,
+        parentTrusted: true,
+        agentDir,
+      }),
+      true,
+    );
+    assert.equal(
+      resolveStandaloneChildProjectTrust({
+        parentCwd,
+        childCwd,
+        parentTrusted: true,
+        agentDir,
+      }),
+      false,
+    );
+
+    new ProjectTrustStore(agentDir).set(childCwd, true);
+    assert.equal(
+      resolveStandaloneChildProjectTrust({
+        parentCwd,
+        childCwd,
+        parentTrusted: false,
+        agentDir,
+      }),
+      true,
+    );
+  });
+});
+
+test("shutdown helper balances hooks and disposal despite errors", async () => {
+  let emits = 0;
+  let disposals = 0;
+  const session: DisposableChildSession = {
+    extensionRunner: {
+      hasHandlers: () => true,
+      async emit(event: SessionShutdownEvent) {
+        emits++;
+        assert.deepEqual(event, { type: "session_shutdown", reason: "quit" });
+        throw new Error("fixture shutdown failure");
+      },
+    },
+    dispose() {
+      disposals++;
+    },
+  };
+
+  await Promise.all([
+    shutdownAndDisposeChildSession(session),
+    shutdownAndDisposeChildSession(session),
+    shutdownAndDisposeChildSession(session),
+  ]);
+  assert.equal(emits, 1);
+  assert.equal(disposals, 1);
+});
+
+test("shutdown helper bounds a stuck hook before disposal", async () => {
+  let disposals = 0;
+  const session: DisposableChildSession = {
+    extensionRunner: {
+      hasHandlers: () => true,
+      emit: () => new Promise(() => {}),
+    },
+    dispose() {
+      disposals++;
+    },
+  };
+
+  await shutdownAndDisposeChildSession(session, { timeoutMs: 10 });
+  assert.equal(disposals, 1);
+});

package/agent.bak.20260905-190020/extensions/shared/test/context-utilization.test.ts

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  contextPercent,
+  formatContextUtilization,
+} from "../context-utilization.ts";
+
+test("formats current context occupancy against model capacity", () => {
+  assert.equal(
+    formatContextUtilization({ tokens: 26_040, contextWindow: 372_000 }),
+    "7%/372k",
+  );
+});
+
+test("formats the latest post-compaction usage rather than prior cumulative usage", () => {
+  const latestUsage = { tokens: 18_000, contextWindow: 200_000 };
+  assert.equal(formatContextUtilization(latestUsage), "9%/200k");
+});
+
+test("clamps over-capacity and nonsensical token values", () => {
+  assert.equal(
+    contextPercent({ tokens: 500_000, contextWindow: 200_000 }),
+    100,
+  );
+  assert.equal(
+    formatContextUtilization({
+      tokens: Number.POSITIVE_INFINITY,
+      contextWindow: 200_000,
+    }),
+    "?%/200k",
+  );
+  assert.equal(
+    formatContextUtilization({ tokens: -1, contextWindow: 200_000 }),
+    "?%/200k",
+  );
+});
+
+test("handles missing usage or capacity without NaN or Infinity", () => {
+  assert.equal(
+    formatContextUtilization({ tokens: null, contextWindow: 372_000 }),
+    "?%/372k",
+  );
+  assert.equal(formatContextUtilization({ tokens: 12_000 }), "");
+  assert.equal(
+    formatContextUtilization({ tokens: 12_000, contextWindow: 0 }),
+    "",
+  );
+});

package/agent.bak.20260905-190020/extensions/shared/test/tool-call-timeout.test.ts

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import {
+  createToolCallTimeoutGuard,
+  runWithToolCallTimeout,
+  CHILD_TOOL_CALL_TIMEOUT_MS,
+  ToolCallTimeoutError,
+} from "../tool-call-timeout.ts";
+
+test("the production timeout error names the tool and three-minute limit", () => {
+  assert.equal(
+    new ToolCallTimeoutError("fixture_tool", CHILD_TOOL_CALL_TIMEOUT_MS)
+      .message,
+    'Tool call "fixture_tool" timed out after 3 minutes.',
+  );
+});
+
+test("a hung tool call fails clearly and receives an abort signal", async () => {
+  let executionSignal: AbortSignal | undefined;
+
+  await assert.rejects(
+    runWithToolCallTimeout("hung_fixture", 10, undefined, (signal) => {
+      executionSignal = signal;
+      return new Promise(() => {});
+    }),
+    (error: unknown) => {
+      assert.equal(error instanceof ToolCallTimeoutError, true);
+      assert.equal(
+        error instanceof Error ? error.message : "",
+        'Tool call "hung_fixture" timed out after 10 ms.',
+      );
+      return true;
+    },
+  );
+
+  assert.equal(executionSignal?.aborted, true);
+  assert.equal(executionSignal?.reason instanceof ToolCallTimeoutError, true);
+});
+
+test("parent cancellation still stops the timeout wrapper immediately", async () => {
+  const controller = new AbortController();
+  const reason = new Error("cancelled fixture");
+  const pending = runWithToolCallTimeout(
+    "hung_fixture",
+    60_000,
+    controller.signal,
+    () => new Promise(() => {}),
+  );
+
+  controller.abort(reason);
+
+  await assert.rejects(pending, (error: unknown) => error === reason);
+});
+
+test("the guard wraps each definition once and can discover later tools", () => {
+  const definitions = new Map<string, ToolDefinition>();
+  const createDefinition = (name: string): ToolDefinition => ({
+    name,
+    label: name,
+    description: name,
+    parameters: Type.Object({}),
+    async execute() {
+      return { content: [{ type: "text", text: "done" }], details: {} };
+    },
+  });
+  const first = createDefinition("first");
+  definitions.set(first.name, first);
+  const registry = {
+    getAllTools: () => [...definitions.keys()].map((name) => ({ name })),
+    getToolDefinition: (name: string) => definitions.get(name),
+  };
+  const guard = createToolCallTimeoutGuard(10);
+
+  const firstExecute = first.execute;
+  guard.apply(registry);
+  const firstWrappedExecute = first.execute;
+  assert.notEqual(firstWrappedExecute, firstExecute);
+
+  const second = createDefinition("second");
+  const secondExecute = second.execute;
+  definitions.set(second.name, second);
+  guard.apply(registry);
+
+  assert.equal(first.execute, firstWrappedExecute);
+  assert.notEqual(second.execute, secondExecute);
+});
+
+test("successful and terminating tool results pass through unchanged", async () => {
+  const result = {
+    content: [{ type: "text" as const, text: "recorded" }],
+    details: { value: "fixture" },
+    terminate: true,
+  };
+
+  assert.equal(
+    await runWithToolCallTimeout(
+      "structured_output",
+      10,
+      undefined,
+      async () => result,
+    ),
+    result,
+  );
+});
+
+test("the timeout is fresh for each tool call, not shared across calls", async () => {
+  const execute = () =>
+    runWithToolCallTimeout("slow_fixture", 100, undefined, async () => {
+      await new Promise((resolve) => setTimeout(resolve, 60));
+      return "done";
+    });
+
+  assert.equal(await execute(), "done");
+  assert.equal(await execute(), "done");
+});

package/agent.bak.20260905-190020/extensions/shared/test/widget-order.test.ts

@@ -0,0 +1,167 @@
+/**
+ * widget-order.test.ts — fixed stacking order for the above-editor widgets.
+ *
+ * Each extension loads in an isolated jiti module instance, so this test
+ * imports a DIFFERENT vendored copy of the helper per widget key (mirroring
+ * production) to prove the copies coordinate through the shared globalThis
+ * registry. The fake ui replicates pi core's Map insertion-order semantics:
+ * every setWidget moves the key to the end (closest to the input).
+ *
+ * Run: node --test agent/extensions/shared/widget-order.test.ts
+ */
+
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, test } from "node:test";
+import { fileURLToPath } from "node:url";
+
+// One copy per widget — exactly how the three extensions consume them.
+import {
+	hideOrderedWidget as hideTodos,
+	setOrderedWidget as setTodos,
+	WIDGET_ORDER,
+} from "../../todo/widget-order.ts";
+import {
+	hideOrderedWidget as hideTerms,
+	setOrderedWidget as setTerms,
+} from "../../background-terminals/src/widget-order.ts";
+import {
+	hideOrderedWidget as hideSubs,
+	setOrderedWidget as setSubs,
+} from "../../subagents/src/widget-order.ts";
+
+const TODOS = "rpiv-todos";
+const TERMS = "background-terminals";
+const SUBS = "subagents";
+
+/** Canonical order: todos furthest from the input, subagents closest. */
+const CANONICAL = [TODOS, TERMS, SUBS];
+
+interface FakeUI {
+	setWidget(key: string, content: unknown, options?: unknown): void;
+}
+
+function createFakeUI() {
+	// Map insertion order == pi core's widgetContainerAbove render order.
+	const map = new Map<string, unknown>();
+	const calls: Array<{ key: string; cleared: boolean }> = [];
+	const ui: FakeUI = {
+		setWidget(key: string, content: unknown) {
+			calls.push({ key, cleared: content === undefined });
+			if (content === undefined) map.delete(key);
+			else map.set(key, content);
+		},
+	};
+	return {
+		ui,
+		calls,
+		order: () => [...map.keys()],
+		contentOf: (key: string) => map.get(key),
+	};
+}
+
+const fac = (marker: string) => (_tui: unknown, _theme: unknown) => ({
+	render: () => [marker],
+	invalidate: () => {},
+});
+
+function resetRegistry(ui: FakeUI) {
+	// Hide-all returns every test to a clean slate (registry + fake pi map).
+	hideTodos(ui as never, TODOS as never);
+	hideTerms(ui as never, TERMS as never);
+	hideSubs(ui as never, SUBS as never);
+}
+
+afterEach(() => {
+	// Guard against registry leakage if a test fails mid-sequence.
+	resetRegistry(createFakeUI().ui);
+});
+
+test("canonical order is exported and matches the required stacking", () => {
+	assert.deepEqual([...WIDGET_ORDER], CANONICAL);
+});
+
+test("pins canonical order regardless of registration sequence", () => {
+	const f = createFakeUI();
+	resetRegistry(f.ui);
+	// Worst case: reverse registration order.
+	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
+	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
+	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
+	assert.deepEqual(f.order(), CANONICAL);
+});
+
+test("top widget registering last still lands on top (the reported bug)", () => {
+	const f = createFakeUI();
+	resetRegistry(f.ui);
+	// Terminals + subagents already visible when the todo overlay registers
+	// at agent_start. Naive setWidget would append todos at the bottom.
+	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
+	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
+	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
+	assert.deepEqual(f.order(), CANONICAL);
+});
+
+test("refreshing the middle widget keeps order and stores latest content", () => {
+	const f = createFakeUI();
+	resetRegistry(f.ui);
+	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
+	setTerms(f.ui as never, TERMS as never, fac("bg-1") as never);
+	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
+	// Background count changes 1 -> 2: re-set must not sink it to the bottom.
+	setTerms(f.ui as never, TERMS as never, fac("bg-2") as never);
+	assert.deepEqual(f.order(), CANONICAL);
+	const current = f.contentOf(TERMS) as (_t: unknown, _th: unknown) => { render: () => string[] };
+	assert.deepEqual(current({}, {}).render(), ["bg-2"]);
+});
+
+test("hiding the middle widget preserves survivors; re-show restores slot", () => {
+	const f = createFakeUI();
+	resetRegistry(f.ui);
+	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
+	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
+	setSubs(f.ui as never, SUBS as never, fac("sub") as never);
+	hideTerms(f.ui as never, TERMS as never);
+	assert.deepEqual(f.order(), [TODOS, SUBS]);
+	setTerms(f.ui as never, TERMS as never, fac("bg") as never);
+	assert.deepEqual(f.order(), CANONICAL);
+});
+
+test("setOrderedWidget with undefined content hides", () => {
+	const f = createFakeUI();
+	resetRegistry(f.ui);
+	setTodos(f.ui as never, TODOS as never, fac("todo") as never);
+	assert.deepEqual(f.order(), [TODOS]);
+	setTodos(f.ui as never, TODOS as never, undefined);
+	assert.deepEqual(f.order(), []);
+});
+
+test("hiding an untracked key still clears pi directly", () => {
+	const f = createFakeUI();
+	resetRegistry(f.ui);
+	hideSubs(f.ui as never, SUBS as never);
+	assert.ok(
+		f.calls.some((c) => c.key === SUBS && c.cleared),
+		"expected a direct clear for the untracked key",
+	);
+	assert.deepEqual(f.order(), []);
+});
+
+test("undefined ui is a safe no-op", () => {
+	assert.doesNotThrow(() => {
+		setTodos(undefined as never, TODOS as never, fac("todo") as never);
+		hideTodos(undefined as never, TODOS as never);
+	});
+});
+
+test("vendored helper copies stay byte-identical", () => {
+	const here = path.dirname(fileURLToPath(import.meta.url));
+	const files = [
+		"../todo/widget-order.ts",
+		"../background-terminals/src/widget-order.ts",
+		"../subagents/src/widget-order.ts",
+	].map((rel) => fs.readFileSync(path.resolve(here, rel), "utf8"));
+	assert.equal(files[1], files[0], "background-terminals copy diverged from todo copy");
+	assert.equal(files[2], files[0], "subagents copy diverged from todo copy");
+});

package/agent.bak.20260905-190020/extensions/shared/tool-call-timeout.ts

@@ -0,0 +1,104 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+
+export const CHILD_TOOL_CALL_TIMEOUT_MS = 3 * 60 * 1_000;
+
+interface ToolRegistry {
+  getAllTools(): Array<{ name: string }>;
+  getToolDefinition(name: string): ToolDefinition | undefined;
+}
+
+function formatTimeout(timeoutMs: number) {
+  if (timeoutMs % 60_000 === 0) {
+    const minutes = timeoutMs / 60_000;
+    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+  }
+  if (timeoutMs % 1_000 === 0) {
+    const seconds = timeoutMs / 1_000;
+    return `${seconds} second${seconds === 1 ? "" : "s"}`;
+  }
+  return `${timeoutMs} ms`;
+}
+
+export class ToolCallTimeoutError extends Error {
+  constructor(toolName: string, timeoutMs: number) {
+    super(
+      `Tool call "${toolName}" timed out after ${formatTimeout(timeoutMs)}.`,
+    );
+    this.name = "ToolCallTimeoutError";
+  }
+}
+
+export async function runWithToolCallTimeout<T>(
+  toolName: string,
+  timeoutMs: number,
+  signal: AbortSignal | undefined,
+  execute: (signal: AbortSignal) => Promise<T>,
+) {
+  const timeoutController = new AbortController();
+  const executionSignal = signal
+    ? AbortSignal.any([signal, timeoutController.signal])
+    : timeoutController.signal;
+  const timeoutError = new ToolCallTimeoutError(toolName, timeoutMs);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(timeoutError);
+      timeoutController.abort(timeoutError);
+    }, timeoutMs);
+  });
+
+  let removeAbortListener: (() => void) | undefined;
+  const aborted = new Promise<never>((_resolve, reject) => {
+    if (!signal) return;
+    const onAbort = () => {
+      reject(
+        signal.reason instanceof Error
+          ? signal.reason
+          : new Error(`Tool call "${toolName}" was aborted.`),
+      );
+    };
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+  });
+
+  try {
+    return await Promise.race([execute(executionSignal), timeout, aborted]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    removeAbortListener?.();
+  }
+}
+
+/**
+ * Wrap every currently registered child tool with an independent execution
+ * timeout. Calling apply() again is safe and picks up tools registered later.
+ */
+export function createToolCallTimeoutGuard(
+  timeoutMs = CHILD_TOOL_CALL_TIMEOUT_MS,
+) {
+  const wrapped = new WeakSet<ToolDefinition>();
+
+  const wrap = (definition: ToolDefinition) => {
+    if (wrapped.has(definition)) return;
+    wrapped.add(definition);
+
+    const execute = definition.execute;
+    definition.execute = async (toolCallId, params, signal, onUpdate, ctx) =>
+      runWithToolCallTimeout(definition.name, timeoutMs, signal, (signal) =>
+        execute.call(definition, toolCallId, params, signal, onUpdate, ctx),
+      );
+  };
+
+  return {
+    apply(session: ToolRegistry) {
+      for (const { name } of session.getAllTools()) {
+        const definition = session.getToolDefinition(name);
+        if (definition) wrap(definition);
+      }
+    },
+  };
+}