@astrofoundry/pi-astro 0.6.5 → 0.6.7

package/extensions/security-guard/config.ts

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DEFAULT_RULES } from "./defaults.ts";
+import type { RuleAction, SecurityRule, SecurityRules } from "./types.ts";
+
+export interface ConfigLoadResult {
+    rules: SecurityRules;
+    configPath: string;
+    configExists: boolean;
+    errors: string[];
+}
+
+function configPath(): string {
+    const dir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+    return join(dir, "security-guard.json");
+}
+
+function examplePath(): string {
+    return `${configPath()}.example`;
+}
+
+const VALID_ACTIONS: readonly RuleAction[] = ["prompt", "block", "allow"];
+
+function validateRule(raw: unknown, errors: string[], where: string): SecurityRule | null {
+    if (typeof raw !== "object" || raw === null) {
+        errors.push(`${where}: rule is not an object`);
+        return null;
+    }
+    const r = raw as Record<string, unknown>;
+    if (typeof r.pattern !== "string" || r.pattern.length === 0) {
+        errors.push(`${where}: missing or empty 'pattern' string`);
+        return null;
+    }
+    if (typeof r.action !== "string" || !(VALID_ACTIONS as readonly string[]).includes(r.action)) {
+        errors.push(`${where}: action must be one of ${VALID_ACTIONS.join(", ")}`);
+        return null;
+    }
+    return { pattern: r.pattern, action: r.action as RuleAction };
+}
+
+function validateRules(raw: unknown, errors: string[]): SecurityRules {
+    const out: SecurityRules = { operations: [], writes: [], reads: [] };
+    if (typeof raw !== "object" || raw === null) {
+        errors.push("config root is not an object");
+        return out;
+    }
+    const r = raw as Record<string, unknown>;
+    for (const section of ["operations", "writes", "reads"] as const) {
+        const list = r[section];
+        if (list === undefined) continue;
+        if (!Array.isArray(list)) {
+            errors.push(`${section}: expected array, got ${typeof list}`);
+            continue;
+        }
+        for (let i = 0; i < list.length; i++) {
+            const rule = validateRule(list[i], errors, `${section}[${i}]`);
+            if (rule) out[section].push(rule);
+        }
+    }
+    return out;
+}
+
+export function loadConfig(): ConfigLoadResult {
+    const path = configPath();
+    const errors: string[] = [];
+    if (!existsSync(path)) {
+        return { rules: DEFAULT_RULES, configPath: path, configExists: false, errors };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+        const rules = validateRules(parsed, errors);
+        const merged: SecurityRules = {
+            operations: rules.operations.length > 0 ? rules.operations : DEFAULT_RULES.operations,
+            writes: rules.writes.length > 0 ? rules.writes : DEFAULT_RULES.writes,
+            reads: rules.reads.length > 0 ? rules.reads : DEFAULT_RULES.reads,
+        };
+        return { rules: merged, configPath: path, configExists: true, errors };
+    } catch (err) {
+        errors.push(`invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+        return { rules: DEFAULT_RULES, configPath: path, configExists: true, errors };
+    }
+}
+
+const EXAMPLE_CONTENT = `{
+  "_comment": "Copy this file to security-guard.json to activate. Patterns support globs: * matches one path segment, ** matches any number, ? matches one char. ~/ expands to your home directory. Longest matching pattern wins, so narrow 'allow' rules override broader 'block' rules.",
+  "operations": [
+    { "pattern": "rm -rf /", "action": "block" },
+    { "pattern": "mkfs", "action": "block" },
+    { "pattern": "dd if=", "action": "block" },
+    { "pattern": "> /dev/", "action": "block" },
+    { "pattern": "> /dev/null", "action": "allow" },
+    { "pattern": "rm -rf", "action": "prompt" },
+    { "pattern": "sudo", "action": "prompt" }
+  ],
+  "writes": [
+    { "pattern": "**/.env", "action": "block" },
+    { "pattern": "**/.env.*", "action": "block" },
+    { "pattern": "~/.ssh/**", "action": "block" },
+    { "pattern": "~/.aws/**", "action": "block" },
+    { "pattern": "/etc/**", "action": "prompt" }
+  ],
+  "reads": [
+    { "pattern": "~/.ssh/**", "action": "block" },
+    { "pattern": "~/.aws/credentials", "action": "block" },
+    { "pattern": "**/.env", "action": "prompt" }
+  ]
+}
+`;
+
+export function ensureExampleConfig(): void {
+    const path = examplePath();
+    if (existsSync(path)) return;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, EXAMPLE_CONTENT, "utf-8");
+}
+
+export function isDryRun(): boolean {
+    return process.env.PI_SECURITY_GUARD_DRY_RUN === "1";
+}

package/extensions/security-guard/defaults.ts

@@ -0,0 +1,38 @@
+import type { SecurityRules } from "./types.ts";
+
+/**
+ * Conservative baseline rules. Users override via ~/.pi/agent/security-guard.json.
+ * Patterns support globs (`*`, `**`, `?`) and `~` expansion.
+ */
+export const DEFAULT_RULES: SecurityRules = {
+    operations: [
+        { pattern: "rm -rf /", action: "block" },
+        { pattern: ":(){ :|:&", action: "block" }, // fork bomb fragment
+        { pattern: "mkfs", action: "block" },
+        { pattern: "dd if=", action: "block" },
+        { pattern: "> /dev/sd", action: "block" },
+        { pattern: "> /dev/null", action: "allow" },
+        { pattern: "> /dev/", action: "block" },
+        { pattern: "rm -rf", action: "prompt" },
+        { pattern: "sudo", action: "prompt" },
+        { pattern: "chmod -R 777", action: "prompt" },
+    ],
+    writes: [
+        { pattern: "**/.env", action: "block" },
+        { pattern: "**/.env.*", action: "block" },
+        { pattern: "~/.ssh/**", action: "block" },
+        { pattern: "~/.aws/**", action: "block" },
+        { pattern: "~/.gnupg/**", action: "block" },
+        { pattern: "/etc/**", action: "prompt" },
+        { pattern: "~/.bash_history", action: "prompt" },
+        { pattern: "~/.zsh_history", action: "prompt" },
+    ],
+    reads: [
+        { pattern: "~/.ssh/**", action: "block" },
+        { pattern: "~/.aws/credentials", action: "block" },
+        { pattern: "~/.aws/**", action: "prompt" },
+        { pattern: "~/.gnupg/**", action: "block" },
+        { pattern: "**/.env", action: "prompt" },
+        { pattern: "**/.env.*", action: "prompt" },
+    ],
+};

package/extensions/security-guard/index.test.ts

@@ -0,0 +1,296 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+type Handler = (event: Record<string, unknown>, ctx: unknown) => Promise<unknown>;
+type CommandHandler = (args: string, ctx: unknown) => Promise<void> | void;
+
+interface CapturedPi {
+    commands: Map<string, { description?: string; handler: CommandHandler }>;
+    handlers: Record<string, Handler>;
+    registerCommand: (name: string, opts: { description?: string; handler: CommandHandler }) => void;
+    on: (event: string, handler: Handler) => void;
+}
+
+function makePi(): CapturedPi {
+    const commands = new Map();
+    const handlers: Record<string, Handler> = {};
+    return {
+        commands,
+        handlers,
+        registerCommand: (name, opts) => {
+            commands.set(name, opts);
+        },
+        on: (event, handler) => {
+            handlers[event] = handler;
+        },
+    };
+}
+
+interface Ctx {
+    cwd: string;
+    hasUI: boolean;
+    ui: {
+        notify: ReturnType<typeof vi.fn>;
+        confirm: ReturnType<typeof vi.fn>;
+    };
+}
+
+function makeCtx(opts: { cwd?: string; hasUI?: boolean; allow?: boolean } = {}): Ctx {
+    return {
+        cwd: opts.cwd ?? "/tmp/cwd",
+        hasUI: opts.hasUI ?? true,
+        ui: {
+            notify: vi.fn(),
+            confirm: vi.fn().mockResolvedValue(opts.allow ?? true),
+        },
+    };
+}
+
+describe("security-guard tool_call hook", () => {
+    let root: string;
+    const originalDir = process.env.PI_CODING_AGENT_DIR;
+    const originalDryRun = process.env.PI_SECURITY_GUARD_DRY_RUN;
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "sg-ext-"));
+        process.env.PI_CODING_AGENT_DIR = root;
+        delete process.env.PI_SECURITY_GUARD_DRY_RUN;
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+        process.env.PI_CODING_AGENT_DIR = originalDir;
+        if (originalDryRun === undefined) delete process.env.PI_SECURITY_GUARD_DRY_RUN;
+        else process.env.PI_SECURITY_GUARD_DRY_RUN = originalDryRun;
+    });
+
+    async function load(rules?: Record<string, unknown>): Promise<{ pi: CapturedPi }> {
+        if (rules) {
+            mkdirSync(root, { recursive: true });
+            writeFileSync(join(root, "security-guard.json"), JSON.stringify(rules), "utf-8");
+        }
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        return { pi };
+    }
+
+    it("registers tool_call handler + /security-guard command", async () => {
+        const { pi } = await load();
+        expect(pi.handlers.tool_call).toBeDefined();
+        expect(pi.commands.has("security-guard")).toBe(true);
+    });
+
+    it("blocks bash command matching 'rm -rf /' (default block rule)", async () => {
+        const { pi } = await load();
+        const ctx = makeCtx();
+        const result = (await pi.handlers.tool_call(
+            { toolName: "bash", input: { command: "rm -rf / && echo done" } },
+            ctx,
+        )) as { block?: boolean; reason?: string } | undefined;
+        expect(result?.block).toBe(true);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/Blocked/), "warning");
+    });
+
+    it("allows benign bash commands (no rule match)", async () => {
+        const { pi } = await load();
+        const ctx = makeCtx();
+        const result = await pi.handlers.tool_call(
+            { toolName: "bash", input: { command: "ls -la" } },
+            ctx,
+        );
+        expect(result).toBeUndefined();
+    });
+
+    it("'> /dev/null' allow rule overrides broader '> /dev/' block rule", async () => {
+        const { pi } = await load();
+        const ctx = makeCtx();
+        const result = await pi.handlers.tool_call(
+            { toolName: "bash", input: { command: "echo hi > /dev/null" } },
+            ctx,
+        );
+        expect(result).toBeUndefined();
+    });
+
+    it("prompt rule: user confirms → allowed", async () => {
+        const { pi } = await load({
+            operations: [{ pattern: "testcmd", action: "prompt" }],
+        });
+        const ctx = makeCtx({ allow: true });
+        const result = await pi.handlers.tool_call(
+            { toolName: "bash", input: { command: "testcmd now" } },
+            ctx,
+        );
+        expect(result).toBeUndefined();
+        expect(ctx.ui.confirm).toHaveBeenCalled();
+    });
+
+    it("prompt rule: user denies → blocked", async () => {
+        const { pi } = await load({
+            operations: [{ pattern: "testcmd", action: "prompt" }],
+        });
+        const ctx = makeCtx({ allow: false });
+        const result = (await pi.handlers.tool_call(
+            { toolName: "bash", input: { command: "testcmd now" } },
+            ctx,
+        )) as { block?: boolean; reason?: string };
+        expect(result?.block).toBe(true);
+    });
+
+    it("prompt rule without UI → blocked with reason", async () => {
+        const { pi } = await load({
+            operations: [{ pattern: "testcmd", action: "prompt" }],
+        });
+        const ctx = makeCtx({ hasUI: false });
+        const result = (await pi.handlers.tool_call(
+            { toolName: "bash", input: { command: "testcmd" } },
+            ctx,
+        )) as { block?: boolean };
+        expect(result?.block).toBe(true);
+    });
+
+    it("write to .env is blocked", async () => {
+        const { pi } = await load();
+        const ctx = makeCtx({ cwd: "/repo" });
+        const result = (await pi.handlers.tool_call(
+            { toolName: "write", input: { path: ".env" } },
+            ctx,
+        )) as { block?: boolean };
+        expect(result?.block).toBe(true);
+    });
+
+    it("edit batch: one entry hits a protected path → whole edit blocked", async () => {
+        const { pi } = await load({
+            writes: [{ pattern: "**/protected.ts", action: "block" }],
+        });
+        const ctx = makeCtx({ cwd: "/repo" });
+        const result = (await pi.handlers.tool_call(
+            {
+                toolName: "edit",
+                input: {
+                    multi: [
+                        { path: "safe.ts", oldText: "a", newText: "b" },
+                        { path: "sub/protected.ts", oldText: "x", newText: "y" },
+                    ],
+                },
+            },
+            ctx,
+        )) as { block?: boolean };
+        expect(result?.block).toBe(true);
+    });
+
+    it("edit patch mode: extracts paths from '*** Add/Update/Delete File:' headers", async () => {
+        const { pi } = await load({
+            writes: [{ pattern: "**/secret.ts", action: "block" }],
+        });
+        const ctx = makeCtx({ cwd: "/repo" });
+        const patch = "*** Begin Patch\n*** Add File: src/secret.ts\n+x\n*** End Patch";
+        const result = (await pi.handlers.tool_call(
+            { toolName: "edit", input: { patch } },
+            ctx,
+        )) as { block?: boolean };
+        expect(result?.block).toBe(true);
+    });
+
+    it("read of ~/.ssh/id_rsa is blocked", async () => {
+        const { pi } = await load();
+        const ctx = makeCtx();
+        const result = (await pi.handlers.tool_call(
+            { toolName: "read", input: { path: "~/.ssh/id_rsa" } },
+            ctx,
+        )) as { block?: boolean };
+        expect(result?.block).toBe(true);
+    });
+
+    it("other tool names pass through untouched", async () => {
+        const { pi } = await load();
+        const ctx = makeCtx();
+        const result = await pi.handlers.tool_call(
+            { toolName: "grep", input: { pattern: "foo" } },
+            ctx,
+        );
+        expect(result).toBeUndefined();
+    });
+
+    it("DRY-RUN mode: would-be-blocked passes through with notify prefix", async () => {
+        process.env.PI_SECURITY_GUARD_DRY_RUN = "1";
+        const { pi } = await load();
+        const ctx = makeCtx();
+        const result = await pi.handlers.tool_call(
+            { toolName: "bash", input: { command: "rm -rf /" } },
+            ctx,
+        );
+        expect(result).toBeUndefined(); // NOT blocked
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/DRY-RUN/), "warning");
+    });
+});
+
+describe("security-guard command", () => {
+    let root: string;
+    const originalDir = process.env.PI_CODING_AGENT_DIR;
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "sg-cmd-"));
+        process.env.PI_CODING_AGENT_DIR = root;
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+        process.env.PI_CODING_AGENT_DIR = originalDir;
+    });
+
+    it("status sub-command prints rule counts", async () => {
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("security-guard")!.handler("status", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/operations=/), "info");
+    });
+
+    it("reload re-reads config + notifies", async () => {
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        mkdirSync(root, { recursive: true });
+        writeFileSync(
+            join(root, "security-guard.json"),
+            JSON.stringify({ operations: [{ pattern: "new-one", action: "block" }] }),
+            "utf-8",
+        );
+        const ctx = makeCtx();
+        await pi.commands.get("security-guard")!.handler("reload", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/reloaded/), "info");
+    });
+
+    it("test sub-command reports match", async () => {
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("security-guard")!.handler("test bash rm -rf /", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/block/), "info");
+    });
+
+    it("test with unknown kind warns", async () => {
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("security-guard")!.handler("test foo bar", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/usage/), "warning");
+    });
+
+    it("test reports no match as 'would be allowed'", async () => {
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await pi.commands.get("security-guard")!.handler("test bash ls -la", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/no match/), "info");
+    });
+});

package/extensions/security-guard/index.ts

@@ -0,0 +1,173 @@
+import type { ExtensionAPI, ExtensionContext, ToolCallEvent } from "@mariozechner/pi-coding-agent";
+import { ensureExampleConfig, isDryRun, loadConfig } from "./config.ts";
+import { findMatchingRule, normalizePath } from "./rules.ts";
+import type { SecurityRule, SecurityRules } from "./types.ts";
+
+interface Decision {
+    block: boolean;
+    reason?: string;
+}
+
+async function evaluate(
+    label: string,
+    target: string,
+    rules: readonly SecurityRule[],
+    ctx: ExtensionContext,
+): Promise<Decision> {
+    const rule = findMatchingRule(target, rules);
+    if (!rule || rule.action === "allow") return { block: false };
+
+    const dryRun = isDryRun();
+    const prefix = dryRun ? "[security-guard DRY-RUN] " : "";
+
+    if (rule.action === "block") {
+        ctx.ui.notify(
+            `${prefix}Blocked ${label}: matched pattern "${rule.pattern}"`,
+            "warning",
+        );
+        if (dryRun) return { block: false };
+        return {
+            block: true,
+            reason: `Blocked by security-guard: pattern "${rule.pattern}"`,
+        };
+    }
+
+    // prompt
+    if (!ctx.hasUI) {
+        if (dryRun) return { block: false };
+        return {
+            block: true,
+            reason: "security-guard: confirmation required but no UI available",
+        };
+    }
+    const confirmed = await ctx.ui.confirm(
+        `Security check — ${label}`,
+        `Matched pattern "${rule.pattern}"\n\nTarget: ${target}\n\nAllow this operation?`,
+    );
+    if (confirmed) return { block: false };
+    ctx.ui.notify(`${prefix}Denied ${label}`, "warning");
+    if (dryRun) return { block: false };
+    return { block: true, reason: "Denied by user via security-guard" };
+}
+
+function extractEditPaths(input: Record<string, unknown>): string[] {
+    const paths: string[] = [];
+    if (typeof input.path === "string") paths.push(input.path);
+    const multi = input.multi;
+    if (Array.isArray(multi)) {
+        for (const item of multi) {
+            if (item && typeof item === "object" && typeof (item as { path?: unknown }).path === "string") {
+                paths.push((item as { path: string }).path);
+            }
+        }
+    }
+    const patch = input.patch;
+    if (typeof patch === "string") {
+        const re = /^\*\*\* (?:Add File|Update File|Delete File):\s+(.+)$/gm;
+        let m: RegExpExecArray | null;
+        while ((m = re.exec(patch)) !== null) {
+            paths.push(m[1].trim());
+        }
+    }
+    return paths;
+}
+
+async function handleToolCall(
+    event: ToolCallEvent,
+    ctx: ExtensionContext,
+    rules: SecurityRules,
+): Promise<{ block?: boolean; reason?: string } | undefined> {
+    switch (event.toolName) {
+        case "bash": {
+            const command = (event.input as { command?: string }).command ?? "";
+            const decision = await evaluate("bash command", command, rules.operations, ctx);
+            if (decision.block) return { block: true, reason: decision.reason };
+            return undefined;
+        }
+        case "write": {
+            const target = normalizePath(String((event.input as { path?: string }).path ?? ""), ctx.cwd);
+            const decision = await evaluate(`write to ${target}`, target, rules.writes, ctx);
+            if (decision.block) return { block: true, reason: decision.reason };
+            return undefined;
+        }
+        case "edit": {
+            const paths = extractEditPaths(event.input as Record<string, unknown>);
+            for (const raw of paths) {
+                const target = normalizePath(raw, ctx.cwd);
+                const decision = await evaluate(`edit of ${target}`, target, rules.writes, ctx);
+                if (decision.block) return { block: true, reason: decision.reason };
+            }
+            return undefined;
+        }
+        case "read": {
+            const target = normalizePath(String((event.input as { path?: string }).path ?? ""), ctx.cwd);
+            const decision = await evaluate(`read of ${target}`, target, rules.reads, ctx);
+            if (decision.block) return { block: true, reason: decision.reason };
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+
+export default function securityGuardExtension(pi: ExtensionAPI): void {
+    ensureExampleConfig();
+    let loaded = loadConfig();
+
+    pi.registerCommand("security-guard", {
+        description: "Security guard status / reload / test. Usage: /security-guard [status|reload|test <bash|write|read> <input>]",
+        handler: async (args, ctx) => {
+            const parts = args.trim().split(/\s+/).filter(Boolean);
+            const sub = parts[0] ?? "status";
+
+            if (sub === "reload") {
+                loaded = loadConfig();
+                const n =
+                    loaded.rules.operations.length +
+                    loaded.rules.writes.length +
+                    loaded.rules.reads.length;
+                ctx.ui.notify(
+                    `security-guard reloaded: ${n} rules${loaded.errors.length > 0 ? `; ${loaded.errors.length} errors` : ""}`,
+                    loaded.errors.length > 0 ? "warning" : "info",
+                );
+                return;
+            }
+
+            if (sub === "test") {
+                const kind = parts[1];
+                const input = parts.slice(2).join(" ");
+                if (!kind || !input || !["bash", "write", "read"].includes(kind)) {
+                    ctx.ui.notify("usage: /security-guard test <bash|write|read> <input>", "warning");
+                    return;
+                }
+                const rules =
+                    kind === "bash"
+                        ? loaded.rules.operations
+                        : kind === "write"
+                        ? loaded.rules.writes
+                        : loaded.rules.reads;
+                const target = kind === "bash" ? input : normalizePath(input, ctx.cwd);
+                const rule = findMatchingRule(target, rules);
+                ctx.ui.notify(
+                    rule
+                        ? `match: pattern "${rule.pattern}" -> ${rule.action}`
+                        : `no match (would be allowed)`,
+                    "info",
+                );
+                return;
+            }
+
+            // status (default)
+            const { rules, configPath, configExists, errors } = loaded;
+            const lines = [
+                `config: ${configPath}${configExists ? "" : " (not found — using defaults)"}`,
+                `operations=${rules.operations.length} writes=${rules.writes.length} reads=${rules.reads.length}`,
+                isDryRun() ? "dry-run: ON (PI_SECURITY_GUARD_DRY_RUN=1)" : "dry-run: off",
+            ];
+            if (errors.length > 0) lines.push(`errors: ${errors.join("; ")}`);
+            ctx.ui.notify(lines.join(" | "), "info");
+        },
+    });
+
+    pi.on("tool_call", async (event, ctx) => handleToolCall(event, ctx, loaded.rules));
+}