qlogicagent 2.13.3 → 2.13.5

package/dist/cli/permission-approval-bridge.js

@@ -0,0 +1,66 @@
+import { promptOptionsForCategory } from "../runtime/permission-model.js";
+export async function requestPermissionApproval(request, deps) {
+    const acpSession = deps.getAcpPermissionSession();
+    if (acpSession) {
+        try {
+            const options = promptOptionsForCategory(request.category ?? "destructive")
+                .map((o) => ({ optionId: o.optionId, name: o.name, kind: o.kind }));
+            const result = await acpSession.requestPermission({
+                sessionId: acpSession.sessionId,
+                permissionId: request.approvalId,
+                toolCall: {
+                    toolCallId: request.callId,
+                    title: request.toolName,
+                    rawInput: request.arguments ?? {},
+                },
+                message: request.message,
+                category: request.category,
+                options,
+            });
+            return createApprovalResponseFromAcpOption(request, result.optionId);
+        }
+        catch {
+            return { approvalId: request.approvalId, decision: "deny" };
+        }
+    }
+    deps.sendNotification("tool.approval.request", {
+        approvalId: request.approvalId,
+        callId: request.callId,
+        toolName: request.toolName,
+        arguments: request.arguments ? JSON.stringify(request.arguments) : "",
+        message: request.message,
+        category: request.category,
+        reason: request.message,
+        options: promptOptionsForCategory(request.category ?? "destructive"),
+        rememberScope: request.rememberScope,
+    });
+    if (deps.isPetActive()) {
+        const risk = inferApprovalRisk(request.toolName);
+        deps.sendNotification("pet.confirm", {
+            confirmId: request.approvalId,
+            toolName: request.toolName,
+            description: request.message ?? `Allow ${request.toolName}`,
+            risk,
+            timeoutMs: 30_000,
+        });
+    }
+    return new Promise(() => {
+        // PermissionChecker owns pending approval resolution.
+    });
+}
+function inferApprovalRisk(toolName) {
+    if (toolName.match(/exec|bash|shell|terminal|run_command|reset|force|drop/i))
+        return "system";
+    if (toolName.match(/web|http|fetch|mcp|media|image|video|music|tts/i))
+        return "external_egress";
+    if (toolName.match(/write|delete|rm|move|patch|edit|create/i))
+        return "write";
+    return "read";
+}
+export function createApprovalResponseFromAcpOption(request, optionId) {
+    const opt = promptOptionsForCategory(request.category ?? "destructive").find((o) => o.optionId === optionId);
+    if (!opt || opt.kind.startsWith("reject")) {
+        return { approvalId: request.approvalId, decision: "deny" };
+    }
+    return { approvalId: request.approvalId, decision: "allow", scope: opt.scope };
+}

package/dist/cli/permission-approval-bridge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/permission-approval-bridge.test.js

@@ -0,0 +1,100 @@
+import { describe, expect, it, vi } from "vitest";
+import { createApprovalResponseFromAcpOption, requestPermissionApproval } from "./permission-approval-bridge.js";
+const req = (over = {}) => ({
+    approvalId: "a1", callId: "c1", toolName: "write", arguments: { path: "/x" }, message: "m", ...over,
+});
+describe("approval bridge options", () => {
+    it("cross_workspace → 3 ACP options incl allow_dir(allow_always), response maps to scope directory", async () => {
+        const calls = [];
+        const deps = {
+            getAcpPermissionSession: () => ({ sessionId: "s", requestPermission: async (p) => { calls.push(p); return { optionId: "allow_dir" }; } }),
+            sendNotification: () => { },
+            isPetActive: () => false,
+        };
+        const resp = await requestPermissionApproval(req({ category: "cross_workspace", rememberScope: { kind: "directory", path: "/x" } }), deps);
+        expect(calls[0].options.map((o) => o.optionId)).toEqual(["allow", "allow_dir", "deny"]);
+        expect(calls[0].options.find((o) => o.optionId === "allow_dir").kind).toBe("allow_always");
+        expect(resp).toMatchObject({ decision: "allow", scope: "directory" });
+    });
+    it("high_risk_delete allow → scope once; deny → deny", () => {
+        expect(createApprovalResponseFromAcpOption(req({ category: "high_risk_delete" }), "allow")).toMatchObject({ decision: "allow", scope: "once" });
+        expect(createApprovalResponseFromAcpOption(req(), "deny")).toMatchObject({ decision: "deny" });
+    });
+    it("unknown/undefined optionId → deny (fail-safe)", () => {
+        expect(createApprovalResponseFromAcpOption(req(), undefined).decision).toBe("deny");
+        expect(createApprovalResponseFromAcpOption(req(), "bogus").decision).toBe("deny");
+    });
+});
+describe("non-ACP path enriched notification", () => {
+    it("non-ACP path enriches the approval notification", () => {
+        const notes = [];
+        const deps = {
+            getAcpPermissionSession: () => undefined,
+            sendNotification: (method, params) => notes.push({ method, params }),
+            isPetActive: () => false,
+        };
+        void requestPermissionApproval(req({ category: "cross_workspace", rememberScope: { kind: "directory", path: "/x" } }), deps);
+        const approval = notes.find((n) => n.method === "tool.approval.request");
+        expect(approval.params.category).toBe("cross_workspace");
+        expect(approval.params.options.some((o) => o.optionId === "allow_dir")).toBe(true);
+    });
+});
+describe("ACP category propagation", () => {
+    it("carries category in ACP request params", async () => {
+        const calls = [];
+        const deps = {
+            getAcpPermissionSession: () => ({ sessionId: "s", requestPermission: async (p) => { calls.push(p); return { optionId: "deny" }; } }),
+            sendNotification: () => { },
+            isPetActive: () => false,
+        };
+        await requestPermissionApproval(req({ category: "cross_workspace" }), deps);
+        expect(calls[0].category).toBe("cross_workspace");
+    });
+});
+describe("requestPermissionApproval ACP standard shape", () => {
+    it("sends standard toolCallId/title/rawInput + options with kind (default/destructive category)", async () => {
+        let captured;
+        const deps = {
+            getAcpPermissionSession: () => ({
+                sessionId: "s1",
+                requestPermission: async (p) => {
+                    captured = p;
+                    return { optionId: "allow" };
+                },
+            }),
+            sendNotification: vi.fn(),
+            isPetActive: () => false,
+        };
+        const res = await requestPermissionApproval({
+            approvalId: "a1",
+            callId: "c1",
+            toolName: "bash",
+            arguments: { cmd: "ls" },
+            message: "run?",
+        }, deps);
+        expect(captured.toolCall).toEqual({ toolCallId: "c1", title: "bash", rawInput: { cmd: "ls" } });
+        expect(captured.toolCall.callId).toBeUndefined();
+        // category defaults to "destructive" → 2 options [allow, deny]
+        expect(captured.options.map((o) => o.optionId)).toEqual(["allow", "deny"]);
+        expect(captured.options[0].kind).toBe("allow_once");
+        expect(captured.options[1].kind).toBe("reject_once");
+        expect(res.decision).toBe("allow");
+    });
+    it("rawInput defaults to {} when arguments absent", async () => {
+        let captured;
+        const deps = {
+            getAcpPermissionSession: () => ({
+                sessionId: "s1",
+                requestPermission: async (p) => {
+                    captured = p;
+                    return { optionId: "deny" };
+                },
+            }),
+            sendNotification: vi.fn(),
+            isPetActive: () => false,
+        };
+        const res = await requestPermissionApproval({ approvalId: "a2", callId: "c2", toolName: "read", message: "?" }, deps);
+        expect(captured.toolCall).toEqual({ toolCallId: "c2", title: "read", rawInput: {} });
+        expect(res.decision).toBe("deny");
+    });
+});

package/dist/cli/permission-bootstrap.d.ts

@@ -0,0 +1,40 @@
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { AcpPermissionRequestParams } from "../protocol/wire/index.js";
+import type { ToolCatalog } from "../runtime/ports/index.js";
+import { type RuntimePermissionChecker, type RuntimePermissionRuleEngine } from "./permission-runtime-service.js";
+export { createApprovalResponseFromAcpOption } from "./permission-approval-bridge.js";
+export interface PermissionBootstrapDeps {
+    config: Record<string, unknown>;
+    toolCatalog: ToolCatalog;
+    hooks: HookRegistry;
+    log: {
+        info(message: string): void;
+        warn(message: string): void;
+    };
+    sessionId: string;
+    getTurnId(): string;
+    getActiveProjectRoot(): string;
+    /**
+     * The live active tool workdir (where file/exec relative paths resolve). The
+     * cross-workspace classifier compares tool target paths against THIS, not
+     * getActiveProjectRoot — the latter is a (possibly snapshotted) project root
+     * used for memory/sessions and does not track the per-turn tool workdir.
+     */
+    getActiveWorkdir(): string;
+    getAcpPermissionSession(): {
+        sessionId: string;
+        requestPermission(params: AcpPermissionRequestParams): Promise<{
+            optionId?: string;
+        }>;
+    } | undefined;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+    isPetActive(): boolean;
+    currentUnregister?: (() => void) | null;
+}
+export interface PermissionBootstrapResult {
+    permissionChecker: RuntimePermissionChecker;
+    permissionUnregister: () => void;
+    ruleEngine: RuntimePermissionRuleEngine;
+}
+export declare function configurePermissionBootstrap(deps: PermissionBootstrapDeps): PermissionBootstrapResult;

package/dist/cli/permission-bootstrap.js

@@ -0,0 +1,58 @@
+import { createDefaultCommunityTelemetryRecorder } from "../runtime/community/community-telemetry-recorder.js";
+import { DenialAuditLogger } from "../skills/permissions/denial-audit-log.js";
+import { getGroupSecurityRules } from "../skills/permissions/group-security-policy.js";
+import { isActiveProjectGroup } from "./project-context.js";
+import { setGroupSecurityMode, setSandboxPermissionSource } from "./tool-bootstrap.js";
+import { requestPermissionApproval } from "./permission-approval-bridge.js";
+import { createRuntimePermissionChecker, createRuntimePermissionRuleEngine, parseRuntimePermissionConfig, } from "./permission-runtime-service.js";
+export { createApprovalResponseFromAcpOption } from "./permission-approval-bridge.js";
+export function configurePermissionBootstrap(deps) {
+    const permConfig = parseRuntimePermissionConfig(deps.config.permissions);
+    const ruleEngine = createRuntimePermissionRuleEngine(permConfig);
+    // Cross-workspace / full_access access is owned by the permission pipeline
+    // (the `tool.before_invoke` hook); the tool layer no longer bypasses a
+    // workspace boundary, so no tool-level toggle is needed here.
+    if (isActiveProjectGroup()) {
+        const groupRules = getGroupSecurityRules();
+        for (const rule of groupRules) {
+            ruleEngine.addRule(rule);
+        }
+        setGroupSecurityMode(true);
+        deps.log.info(`[permissions] group security mode active: ${groupRules.length} rules injected`);
+    }
+    else {
+        setGroupSecurityMode(false);
+    }
+    deps.currentUnregister?.();
+    const permissionChecker = createRuntimePermissionChecker({
+        ruleEngine,
+        hookRegistry: deps.hooks,
+        // Cross-workspace classification must compare against the dir the tools
+        // actually operate in (active workdir), NOT the project root. The audit
+        // logger keeps using getActiveProjectRoot (memory/sessions location).
+        getWorkspaceRoot: deps.getActiveWorkdir,
+        auditLogger: new DenialAuditLogger(deps.getActiveProjectRoot()),
+        sessionId: deps.sessionId,
+        getTurnId: deps.getTurnId,
+        communityTelemetryRecorder: createDefaultCommunityTelemetryRecorder() ?? undefined,
+        onRequestApproval: (request) => requestPermissionApproval(request, deps),
+        onDenied: (toolName, message) => {
+            deps.log.warn(`[permissions] blocked "${toolName}": ${message}`);
+        },
+    });
+    permissionChecker.setToolMeta(deps.toolCatalog.getToolManifest());
+    // cut7c: expose the live permission single-source to the OS-sandbox builder
+    // (exec tool's resolveSandbox). Same rule engine + active workdir the prompt
+    // pipeline uses; mode/allowedDirs are read live per exec.
+    setSandboxPermissionSource(() => ({
+        mode: ruleEngine.getMode(),
+        workdir: deps.getActiveWorkdir(),
+        allowedDirs: ruleEngine.getAllowedWriteDirectories(),
+        communityTurn: permissionChecker.isCommunitySandboxTurn(),
+    }));
+    return {
+        permissionChecker,
+        permissionUnregister: permissionChecker.register(),
+        ruleEngine,
+    };
+}

package/dist/cli/permission-bootstrap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/permission-bootstrap.test.js

@@ -0,0 +1,129 @@
+import path from "node:path";
+import os from "node:os";
+import { describe, expect, it, vi } from "vitest";
+import { configurePermissionBootstrap, createApprovalResponseFromAcpOption } from "./permission-bootstrap.js";
+class MemoryHookRegistry {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handlers = new Map();
+    register(registration) {
+        const list = this.handlers.get(registration.point) ?? [];
+        list.push(registration.handler);
+        this.handlers.set(registration.point, list);
+        return () => {
+            this.handlers.set(registration.point, list.filter(h => h !== registration.handler));
+        };
+    }
+    async invoke(point, context) {
+        for (const handler of this.handlers.get(point) ?? []) {
+            const result = await handler(point, context);
+            if (result?.action === "abort")
+                return result;
+        }
+        return { action: "continue" };
+    }
+}
+function approvalRequest(toolName = "write") {
+    return {
+        approvalId: "approval-1",
+        callId: "call-1",
+        toolName,
+        message: `Allow ${toolName}`,
+    };
+}
+describe("createApprovalResponseFromAcpOption", () => {
+    it("uses allow as the only approving ACP decision", () => {
+        expect(createApprovalResponseFromAcpOption(approvalRequest(), "allow")).toMatchObject({
+            approvalId: "approval-1",
+            decision: "allow",
+        });
+    });
+    it("denies unknown or missing ACP decisions", () => {
+        expect(createApprovalResponseFromAcpOption(approvalRequest(), "deny")).toMatchObject({
+            decision: "deny",
+        });
+        expect(createApprovalResponseFromAcpOption(approvalRequest(), undefined)).toMatchObject({
+            decision: "deny",
+        });
+        expect(createApprovalResponseFromAcpOption(approvalRequest(), "allow" + "Always")).toMatchObject({
+            decision: "deny",
+        });
+    });
+});
+describe("configurePermissionBootstrap workspace root wiring", () => {
+    function makeDeps(over) {
+        return {
+            config: {},
+            toolCatalog: {
+                // write tool meta: not read-only so cross-workspace gating applies.
+                getToolManifest: () => [
+                    {
+                        type: "function",
+                        function: { name: "write", description: "writes", parameters: { type: "object", properties: {} } },
+                        meta: { isReadOnly: false },
+                    },
+                ],
+            },
+            hooks: over.hooks,
+            log: { info: () => { }, warn: () => { } },
+            sessionId: "session-1",
+            getTurnId: () => "turn-1",
+            getActiveProjectRoot: over.getActiveProjectRoot,
+            getActiveWorkdir: over.getActiveWorkdir,
+            getAcpPermissionSession: () => ({
+                sessionId: "session-1",
+                requestPermission: over.onRequestApproval,
+            }),
+            sendNotification: () => { },
+            isPetActive: () => false,
+        };
+    }
+    it("classifies cross-workspace against the active workdir, not the project root", async () => {
+        // Project root and active workdir DIVERGE (the exact bug shape): a write that
+        // is INSIDE the project root but OUTSIDE the tool workdir must be treated as
+        // cross-workspace (prompt), proving getWorkspaceRoot == active workdir.
+        const projectRoot = path.join(os.tmpdir(), "qla-perm-wiring-project");
+        const activeWorkdir = path.join(projectRoot, "workspaces", "default");
+        const targetInsideProjectButOutsideWorkdir = path.join(projectRoot, "outside-the-workdir.txt");
+        const registry = new MemoryHookRegistry();
+        const approval = vi.fn(async (_params) => ({ optionId: "allow" }));
+        configurePermissionBootstrap(makeDeps({
+            hooks: registry,
+            getActiveProjectRoot: () => projectRoot,
+            getActiveWorkdir: () => activeWorkdir,
+            onRequestApproval: approval,
+        }));
+        const result = await registry.invoke("tool.before_invoke", {
+            sessionId: "session-1",
+            turnId: "turn-1",
+            callId: "call-1",
+            toolName: "write",
+            arguments: { path: targetInsideProjectButOutsideWorkdir, content: "x" },
+        });
+        // Cross-workspace ⇒ default mode prompts; approval was requested.
+        expect(approval).toHaveBeenCalledTimes(1);
+        expect(approval.mock.calls[0]?.[0].category).toBe("cross_workspace");
+        expect(result.action).toBe("continue");
+    });
+    it("does not prompt for a write inside the active workdir", async () => {
+        const projectRoot = path.join(os.tmpdir(), "qla-perm-wiring-project2");
+        const activeWorkdir = path.join(projectRoot, "workspaces", "default");
+        const insideWorkdir = path.join(activeWorkdir, "src", "app.ts");
+        const registry = new MemoryHookRegistry();
+        const approval = vi.fn(async (_params) => ({ optionId: "allow" }));
+        configurePermissionBootstrap(makeDeps({
+            hooks: registry,
+            getActiveProjectRoot: () => projectRoot,
+            getActiveWorkdir: () => activeWorkdir,
+            onRequestApproval: approval,
+        }));
+        const result = await registry.invoke("tool.before_invoke", {
+            sessionId: "session-1",
+            turnId: "turn-1",
+            callId: "call-2",
+            toolName: "write",
+            arguments: { path: insideWorkdir, content: "x" },
+        });
+        expect(approval).not.toHaveBeenCalled();
+        expect(result.action).toBe("continue");
+    });
+});

package/dist/cli/permission-runtime-service.d.ts

@@ -0,0 +1,9 @@
+import { PermissionChecker } from "../skills/permissions/hook-runner.js";
+import { PermissionRuleEngine } from "../skills/permissions/rule-engine.js";
+import type { PermissionEngineConfig } from "../runtime/ports/index.js";
+import type { PermissionCheckerDeps } from "../skills/permissions/hook-runner.js";
+export type RuntimePermissionChecker = PermissionChecker;
+export type RuntimePermissionRuleEngine = PermissionRuleEngine;
+export declare function parseRuntimePermissionConfig(raw: unknown): PermissionEngineConfig;
+export declare function createRuntimePermissionRuleEngine(raw: unknown): PermissionRuleEngine;
+export declare function createRuntimePermissionChecker(deps: PermissionCheckerDeps): PermissionChecker;

package/dist/cli/permission-runtime-service.js

@@ -0,0 +1,11 @@
+import { PermissionChecker } from "../skills/permissions/hook-runner.js";
+import { parsePermissionConfig, PermissionRuleEngine } from "../skills/permissions/rule-engine.js";
+export function parseRuntimePermissionConfig(raw) {
+    return parsePermissionConfig(raw);
+}
+export function createRuntimePermissionRuleEngine(raw) {
+    return new PermissionRuleEngine(parseRuntimePermissionConfig(raw));
+}
+export function createRuntimePermissionChecker(deps) {
+    return new PermissionChecker(deps);
+}

package/dist/cli/permission-settings-store.d.ts

@@ -0,0 +1 @@
+export declare function persistPermissionUpdateToSettings(_update: unknown, _settingsPath?: string): void;

package/dist/cli/permission-settings-store.js

@@ -0,0 +1,3 @@
+export function persistPermissionUpdateToSettings(_update, _settingsPath) {
+    return;
+}

package/dist/cli/permission-settings-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/permission-settings-store.test.js

@@ -0,0 +1,65 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { persistPermissionUpdateToSettings } from "./permission-settings-store.js";
+const tempDirs = [];
+function createSettingsFile(initial) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qlogicagent-permissions-"));
+    tempDirs.push(dir);
+    const file = path.join(dir, "settings.json");
+    fs.writeFileSync(file, JSON.stringify(initial, null, 2), "utf-8");
+    return file;
+}
+function readSettings(file) {
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+}
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("persistPermissionUpdateToSettings", () => {
+    it("does not persist per-tool permission updates", () => {
+        const settingsPath = createSettingsFile({
+            permissions: {
+                mode: "auto",
+                rules: [
+                    { pattern: "execute_command", behavior: "ask", source: "config" },
+                    { pattern: "read", behavior: "allow", source: "config" },
+                ],
+            },
+        });
+        persistPermissionUpdateToSettings({
+            pattern: "execute_command",
+            behavior: "allow",
+            scope: "persistent",
+            description: "Always allow execute_command",
+        }, settingsPath);
+        expect(readSettings(settingsPath).permissions).toEqual({
+            mode: "auto",
+            rules: [
+                { pattern: "execute_command", behavior: "ask", source: "config" },
+                { pattern: "read", behavior: "allow", source: "config" },
+            ],
+        });
+    });
+    it("does not persist session-scoped permission updates", () => {
+        const settingsPath = createSettingsFile({
+            permissions: {
+                mode: "default",
+                rules: [],
+            },
+        });
+        persistPermissionUpdateToSettings({
+            pattern: "write",
+            behavior: "allow",
+            scope: "session",
+            description: "Allow write for this session",
+        }, settingsPath);
+        expect(readSettings(settingsPath).permissions).toEqual({
+            mode: "default",
+            rules: [],
+        });
+    });
+});

package/dist/cli/pet-confirm-coordinator.d.ts

@@ -0,0 +1,20 @@
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { ApprovalResponse, PermissionRiskLevel } from "../runtime/ports/index.js";
+export interface PetConfirmPermissionResolver {
+    resolveApproval(response: ApprovalResponse): void;
+}
+export interface PetConfirmCoordinatorDeps {
+    getPermissionResolver(): PetConfirmPermissionResolver | null | undefined;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+}
+export interface PetConfirmResponse {
+    confirmId: string;
+    approved: boolean;
+}
+export declare class PetConfirmCoordinator {
+    private readonly deps;
+    private readonly pendingConfirms;
+    constructor(deps: PetConfirmCoordinatorDeps);
+    requestConfirm(toolName: string, description: string, risk: PermissionRiskLevel, timeoutMs?: number): Promise<boolean>;
+    handleResponse({ confirmId, approved }: PetConfirmResponse): void;
+}

package/dist/cli/pet-confirm-coordinator.js

@@ -0,0 +1,32 @@
+export class PetConfirmCoordinator {
+    deps;
+    pendingConfirms = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    requestConfirm(toolName, description, risk, timeoutMs = 30_000) {
+        const confirmId = `confirm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        this.deps.sendNotification("pet.confirm", { confirmId, toolName, description, risk, timeoutMs });
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pendingConfirms.delete(confirmId);
+                resolve(false);
+            }, timeoutMs + 2_000);
+            this.pendingConfirms.set(confirmId, (approved) => {
+                clearTimeout(timer);
+                resolve(approved);
+            });
+        });
+    }
+    handleResponse({ confirmId, approved }) {
+        this.deps.getPermissionResolver()?.resolveApproval({
+            approvalId: confirmId,
+            decision: approved ? "allow" : "deny",
+        });
+        const resolve = this.pendingConfirms.get(confirmId);
+        if (resolve) {
+            this.pendingConfirms.delete(confirmId);
+            resolve(!!approved);
+        }
+    }
+}

package/dist/cli/pet-confirm-coordinator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/pet-confirm-coordinator.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+import { PetConfirmCoordinator } from "./pet-confirm-coordinator.js";
+describe("PetConfirmCoordinator", () => {
+    it("routes confirm responses to permission approval and pending requester", async () => {
+        const notifications = [];
+        const approvals = [];
+        const coordinator = new PetConfirmCoordinator({
+            getPermissionResolver: () => ({
+                resolveApproval: (response) => approvals.push(response),
+            }),
+            sendNotification: (method, params) => notifications.push({ method, params }),
+        });
+        const pending = coordinator.requestConfirm("write", "Allow write?", "write", 10);
+        const confirmId = (notifications[0]?.params).confirmId;
+        coordinator.handleResponse({ confirmId, approved: true });
+        await expect(pending).resolves.toBe(true);
+        expect(notifications[0]).toMatchObject({
+            method: "pet.confirm",
+            params: { toolName: "write", description: "Allow write?", risk: "write", timeoutMs: 10 },
+        });
+        expect(approvals).toEqual([{ approvalId: confirmId, decision: "allow" }]);
+    });
+    it("denies stale confirmations after timeout", async () => {
+        vi.useFakeTimers();
+        const coordinator = new PetConfirmCoordinator({
+            getPermissionResolver: () => null,
+            sendNotification: () => { },
+        });
+        const pending = coordinator.requestConfirm("delete", "Allow delete?", "system", 10);
+        await vi.advanceTimersByTimeAsync(2_010);
+        await expect(pending).resolves.toBe(false);
+        vi.useRealTimers();
+    });
+});

package/dist/cli/pet-runtime.d.ts

@@ -0,0 +1,55 @@
+import type { ChatMessage } from "../agent/types.js";
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import { type PetStats, type PetdexPetAsset, type PetdexValidationReport } from "../runtime/pet/index.js";
+import { type PetdexProductionRun } from "../runtime/pet/petdex-forge-service.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export type PetSoulGenerator = (rarity: string, stats: PetStats) => Promise<{
+    name: string;
+    personality: string;
+    catchphrase: string;
+}>;
+export type SmallLlmCall = (prompt: string, maxTokens: number) => Promise<string | null>;
+export interface PetdexForgeInput {
+    id?: string;
+    name: string;
+    description: string;
+    prompt?: string | null;
+    referenceImageUrl?: string;
+    referenceMode?: "identity" | "refine";
+    baseSpritesheet?: Buffer;
+}
+export interface PetdexForgeOutput {
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+    productionRun?: PetdexProductionRun;
+    mediaUsage?: {
+        provider: string;
+        model: string;
+        billingUnit: string;
+        billingQuantity: number;
+    };
+}
+export interface PetLlmClient {
+    transport: LLMTransport;
+    apiKey: string;
+    model: string;
+}
+export interface PetRuntime {
+    createPetSoulGenerator(): PetSoulGenerator | undefined;
+    createSmallLLMCall(): SmallLlmCall | undefined;
+    forgeAnalyzeImage(imageBase64: string, hint?: string): Promise<string>;
+    isImageGenerationAvailable(): boolean;
+    isPetdexForgeAvailable(): boolean;
+    forgeGeneratePetdexAtlas(input: PetdexForgeInput): Promise<PetdexForgeOutput>;
+    awardXp(event: string): Promise<void>;
+    reactAfterTurn(messages: ChatMessage[]): Promise<void>;
+    isActive(): boolean;
+}
+export interface PetRuntimeDeps {
+    getActiveProjectRoot(): string;
+    resolveOwnerUserId?: () => string;
+    resolveClientForPurpose(purpose: ModelPurpose): PetLlmClient | null;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+}
+export declare function createPetRuntime(deps: PetRuntimeDeps): PetRuntime;