mu-harness 0.16.3

package/script/harness/npm/src/deps/jsr.io/@std/yaml/1.1.0/stringify.d.ts

@@ -0,0 +1,99 @@
+import { type SchemaType } from "./_schema.js";
+import type { StyleVariant } from "./_type.js";
+export type { SchemaType, StyleVariant };
+/** Options for {@linkcode stringify}. */
+export type StringifyOptions = {
+    /**
+     * Indentation width to use (in spaces).
+     *
+     * @default {2}
+     */
+    indent?: number;
+    /**
+     * When true, adds an indentation level to array elements.
+     *
+     * @default {true}
+     */
+    arrayIndent?: boolean;
+    /**
+     * Do not throw on invalid types (like function in the safe schema) and skip
+     * pairs and single values with such types.
+     *
+     * @default {false}
+     */
+    skipInvalid?: boolean;
+    /**
+     * Specifies level of nesting, when to switch from block to flow style for
+     * collections. `-1` means block style everywhere.
+     *
+     * @default {-1}
+     */
+    flowLevel?: number;
+    /** Each tag may have own set of styles.	- "tag" => "style" map. */
+    styles?: Record<string, StyleVariant>;
+    /**
+     * Name of the schema to use.
+     *
+     * @default {"default"}
+     */
+    schema?: SchemaType;
+    /**
+     * If true, sort keys when dumping YAML in ascending, ASCII character order.
+     * If a function, use the function to sort the keys.
+     * If a function is specified, the function must return a negative value
+     * if first argument is less than second argument, zero if they're equal
+     * and a positive value otherwise.
+     *
+     * @default {false}
+     */
+    sortKeys?: boolean | ((a: string, b: string, depth: number) => number);
+    /**
+     * Set max line width.
+     *
+     * @default {80}
+     */
+    lineWidth?: number;
+    /**
+     * If false, don't convert duplicate objects into references.
+     *
+     * @default {true}
+     */
+    useAnchors?: boolean;
+    /**
+     * If false don't try to be compatible with older yaml versions.
+     * Currently: don't quote "yes", "no" and so on,
+     * as required for YAML 1.1.
+     *
+     * @default {true}
+     */
+    compatMode?: boolean;
+    /**
+     * If true flow sequences will be condensed, omitting the
+     * space between `key: value` or `a, b`. Eg. `'[a,b]'` or `{a:{b:c}}`.
+     * Can be useful when using yaml for pretty URL query params
+     * as spaces are %-encoded.
+     *
+     * @default {false}
+     */
+    condenseFlow?: boolean;
+};
+/**
+ * Converts a JavaScript object or value to a YAML document string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/yaml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = { id: 1, name: "Alice" };
+ * const yaml = stringify(data);
+ *
+ * assertEquals(yaml, "id: 1\nname: Alice\n");
+ * ```
+ *
+ * @throws {TypeError} If `data` contains invalid types.
+ * @param data The data to serialize.
+ * @param options The options for serialization.
+ * @returns A YAML string.
+ */
+export declare function stringify(data: unknown, options?: StringifyOptions): string;

package/script/harness/npm/src/deps/jsr.io/@std/yaml/1.1.0/stringify.js

@@ -0,0 +1,36 @@
+"use strict";
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = stringify;
+const _dumper_state_js_1 = require("./_dumper_state.js");
+const _schema_js_1 = require("./_schema.js");
+/**
+ * Converts a JavaScript object or value to a YAML document string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/yaml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = { id: 1, name: "Alice" };
+ * const yaml = stringify(data);
+ *
+ * assertEquals(yaml, "id: 1\nname: Alice\n");
+ * ```
+ *
+ * @throws {TypeError} If `data` contains invalid types.
+ * @param data The data to serialize.
+ * @param options The options for serialization.
+ * @returns A YAML string.
+ */
+function stringify(data, options = {}) {
+    const state = new _dumper_state_js_1.DumperState({
+        ...options,
+        schema: _schema_js_1.SCHEMA_MAP.get(options.schema),
+    });
+    return state.stringify(data);
+}

package/script/harness/npm/src/harness/create.d.ts

@@ -0,0 +1,2 @@
+import type { Harness, HarnessOptions } from './types.js';
+export declare const createHarness: (options: HarnessOptions) => Promise<Harness>;

package/script/harness/npm/src/harness/create.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarness = void 0;
+const node_path_1 = require("node:path");
+const node_process_1 = __importDefault(require("node:process"));
+const index_js_1 = require("../agents/index.js");
+const index_js_2 = require("../commands/index.js");
+const index_js_3 = require("../config/index.js");
+const index_js_4 = require("../hooks/index.js");
+const index_js_5 = require("../permissions/index.js");
+const index_js_6 = require("../plugin/index.js");
+const index_js_7 = require("../scheduler/index.js");
+const index_js_8 = require("../session/index.js");
+const index_js_9 = require("../skills/index.js");
+const index_js_10 = require("../subAgents/index.js");
+const models_js_1 = require("./models.js");
+const TITLE_AGENT = {
+    name: 'title',
+    description: 'Generates a concise session title from the first user message.',
+    prompt: 'Generate a concise title (3 to 6 words) for the conversation based on the user message. Reply with ONLY the title — no quotes, no trailing punctuation, no explanation.',
+    tools: [],
+};
+const createHarness = async (options) => {
+    const { hostName, xdg, providers, model, agents: hostAgents = [], skills: hostSkills = [], title, titleModel, scheduler: enableScheduler = false, ...sessionDefaults } = options;
+    const cwd = options.cwd ?? node_process_1.default.cwd();
+    const config = (0, index_js_3.createHarnessConfig)({ hostName, xdg });
+    const models = (0, models_js_1.createModelRegistry)({ providers, default: model });
+    const plugins = (0, index_js_6.createPluginStore)({ dir: (0, node_path_1.join)(config.configDir, 'plugins') });
+    const newId = () => crypto.randomUUID();
+    const pluginAgents = (sessionDefaults.plugins ?? []).flatMap((plugin) => plugin.agents ?? []);
+    const diskAgents = await (0, index_js_1.loadAgents)((0, node_path_1.join)(config.configDir, 'agents'));
+    const agents = (0, index_js_1.createAgentRegistry)([...hostAgents, ...pluginAgents, ...diskAgents]);
+    const skillsDir = (0, node_path_1.join)(config.configDir, 'skills');
+    const cwdSkillsDir = (0, node_path_1.join)(cwd, 'skills');
+    const pluginSkills = (sessionDefaults.plugins ?? []).flatMap((plugin) => plugin.skills ?? []);
+    const cwdSkills = await (0, index_js_9.loadSkills)(cwdSkillsDir);
+    const diskSkills = await (0, index_js_9.loadSkills)(skillsDir);
+    const skills = (0, index_js_9.createSkillRegistry)([...hostSkills, ...pluginSkills, ...cwdSkills, ...diskSkills]);
+    const skillTools = [
+        (0, index_js_9.createSkillTool)(skills),
+        (0, index_js_9.createSkillWriterTool)({ dirs: { local: cwdSkillsDir, config: skillsDir }, registry: skills }),
+    ];
+    const tasks = enableScheduler ? (0, index_js_7.createTaskStore)({ dir: (0, node_path_1.join)(config.configDir, 'tasks') }) : undefined;
+    let schedulerTools = [];
+    const runs = (0, index_js_10.createSubAgentRegistry)();
+    const store = (0, index_js_8.createSessionStore)({ dir: (0, node_path_1.join)(config.dataDir, 'sessions') });
+    const sessionTools = (extra = []) => [...(sessionDefaults.tools ?? []), ...extra, ...skillTools, ...schedulerTools];
+    const persona = (agent, opts) => (0, index_js_8.createAgentSession)({
+        tools: opts.tools,
+        plugins: sessionDefaults.plugins,
+        system: agent.prompt,
+        hooks: opts.hooks ?? (0, index_js_5.allowList)(agent.tools),
+        ...models.resolve(opts.model ?? agent.model),
+        id: newId(),
+    });
+    const spawn = (agent) => (0, index_js_8.persistTo)(store, persona(agent, {
+        tools: sessionTools(),
+        hooks: (0, index_js_4.mergeHooks)([sessionDefaults.hooks, (0, index_js_5.allowList)(agent.tools)]),
+    }));
+    const scheduler = enableScheduler && tasks
+        ? (0, index_js_7.createScheduler)({
+            store: tasks,
+            run: async (task) => {
+                try {
+                    if (!task.agent)
+                        throw new Error('scheduled task is missing an agent');
+                    const output = await (0, index_js_9.runSkill)({ skills, agents, spawn, runs, parentId: task.id }, {
+                        skill: task.skill,
+                        task: task.prompt,
+                        agent: task.agent,
+                    });
+                    return { ok: true, output };
+                }
+                catch (error) {
+                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                }
+            },
+        })
+        : undefined;
+    if (tasks && scheduler) {
+        schedulerTools = [
+            (0, index_js_9.createRunSkillTool)({ skills, agents, spawn, runs }),
+            (0, index_js_7.createScheduleTaskTool)({ store: tasks, skills, onChange: () => scheduler.reload() }),
+        ];
+    }
+    const titleSpawn = (agent) => persona(agent, { model: titleModel });
+    const catalog = (0, index_js_8.createSessionCatalog)({ file: (0, node_path_1.join)(config.dataDir, 'sessions.db') });
+    runs.subscribe((run) => catalog.record(run.runId, { cwd, parentId: run.parentId }));
+    const sessions = (0, index_js_8.createSessionManager)({
+        store,
+        catalog,
+        newId,
+        cwd,
+        title: title === false ? undefined : ({ id, text }) => {
+            void (0, index_js_8.runTitler)({
+                id,
+                text,
+                setTitle: (sid, value) => catalog.setTitle(sid, value),
+                generate: (input) => (0, index_js_10.runSubAgent)(TITLE_AGENT, input, { spawn: titleSpawn }).then((result) => result.text),
+            });
+        },
+        revive: ({ id, model: ref, messages }) => (0, index_js_8.createAgentSession)({
+            ...sessionDefaults,
+            tools: sessionTools([(0, index_js_10.createSubAgentTool)({ registry: agents, spawn, runs, parentId: id })]),
+            ...models.resolve(ref),
+            id,
+            messages,
+        }),
+    });
+    const commands = (0, index_js_2.createCommandRegistry)([
+        (0, index_js_2.createAgentsCommand)(agents),
+        (0, index_js_2.createSkillsCommand)(skills),
+        (0, index_js_2.createSessionsCommand)(sessions),
+        ...(tasks ? [(0, index_js_7.createTasksCommand)(tasks)] : []),
+    ]);
+    commands.register((0, index_js_2.createHelpCommand)(() => commands.list()));
+    if (scheduler)
+        await scheduler.start();
+    return {
+        config,
+        models,
+        plugins,
+        sessions,
+        agents,
+        skills,
+        subAgents: runs,
+        dispatchSubAgent: async (agent, task, parentId) => {
+            const def = agents.get(agent);
+            if (!def)
+                throw new Error(`unknown sub-agent "${agent}"`);
+            return await (0, index_js_10.runSubAgent)(def, task, { spawn, runs, parentId });
+        },
+        scheduler,
+        tasks,
+        commands,
+        cwd,
+        close: () => {
+            scheduler?.stop();
+            catalog.close();
+        },
+    };
+};
+exports.createHarness = createHarness;

package/script/harness/npm/src/harness/index.d.ts

@@ -0,0 +1,3 @@
+export type { Harness, HarnessOptions } from './types.js';
+export { createHarness } from './create.js';
+export { createModelRegistry, type ModelRegistry, type ModelRegistryOptions, type ResolvedModel } from './models.js';

package/script/harness/npm/src/harness/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModelRegistry = exports.createHarness = void 0;
+var create_js_1 = require("./create.js");
+Object.defineProperty(exports, "createHarness", { enumerable: true, get: function () { return create_js_1.createHarness; } });
+var models_js_1 = require("./models.js");
+Object.defineProperty(exports, "createModelRegistry", { enumerable: true, get: function () { return models_js_1.createModelRegistry; } });

package/script/harness/npm/src/harness/models.d.ts

@@ -0,0 +1,16 @@
+import type { Provider } from 'mu-core';
+export interface ModelRegistryOptions {
+    providers: Record<string, Provider>;
+    default: string;
+}
+export interface ResolvedModel {
+    provider: Provider;
+    model: string;
+}
+export interface ModelRegistry {
+    readonly selected: string;
+    readonly providers: string[];
+    select(ref: string): void;
+    resolve(ref?: string): ResolvedModel;
+}
+export declare const createModelRegistry: (options: ModelRegistryOptions) => ModelRegistry;

package/script/harness/npm/src/harness/models.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModelRegistry = void 0;
+const createModelRegistry = (options) => {
+    const { providers } = options;
+    let selected = options.default;
+    const resolve = (ref) => {
+        const value = ref ?? selected;
+        const slash = value.indexOf('/');
+        if (slash <= 0 || slash === value.length - 1) {
+            throw new Error(`ModelRegistry: model must be "provider/model", got "${value}"`);
+        }
+        const name = value.slice(0, slash);
+        const provider = providers[name];
+        if (!provider)
+            throw new Error(`ModelRegistry: unknown provider "${name}"`);
+        return { provider, model: value.slice(slash + 1) };
+    };
+    resolve(selected);
+    return {
+        get selected() {
+            return selected;
+        },
+        get providers() {
+            return Object.keys(providers);
+        },
+        select: (ref) => {
+            resolve(ref);
+            selected = ref;
+        },
+        resolve,
+    };
+};
+exports.createModelRegistry = createModelRegistry;

package/script/harness/npm/src/harness/types.d.ts

@@ -0,0 +1,35 @@
+import type { Provider } from 'mu-core';
+import type { Agent, AgentRegistry } from '../agents/index.js';
+import type { CommandRegistry } from '../commands/index.js';
+import type { HarnessConfig, HarnessConfigOptions } from '../config/index.js';
+import type { PluginStore } from '../plugin/index.js';
+import type { Scheduler, TaskStore } from '../scheduler/index.js';
+import type { AgentSessionConfig, SessionManager } from '../session/index.js';
+import type { Skill, SkillRegistry } from '../skills/index.js';
+import type { SubAgentRegistry, SubAgentResult } from '../subAgents/index.js';
+import type { ModelRegistry } from './models.js';
+export type HarnessOptions = HarnessConfigOptions & Omit<AgentSessionConfig, 'provider' | 'model' | 'id' | 'messages'> & {
+    providers: Record<string, Provider>;
+    model: string;
+    agents?: Agent[];
+    skills?: Skill[];
+    title?: boolean;
+    titleModel?: string;
+    cwd?: string;
+    scheduler?: boolean;
+};
+export interface Harness {
+    readonly config: HarnessConfig;
+    readonly models: ModelRegistry;
+    readonly plugins: PluginStore;
+    readonly sessions: SessionManager;
+    readonly agents: AgentRegistry;
+    readonly skills: SkillRegistry;
+    readonly subAgents: SubAgentRegistry;
+    dispatchSubAgent(agent: string, task: string, parentId: string): Promise<SubAgentResult>;
+    readonly commands: CommandRegistry;
+    readonly scheduler?: Scheduler;
+    readonly tasks?: TaskStore;
+    readonly cwd: string;
+    close(): void;
+}

package/script/harness/npm/src/harness/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/harness/npm/src/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export type { AgentSessionHooks, PreparedRequest } from './types.js';
+export { withHooks } from './with-hooks.js';
+export { mergeHooks } from './merge-hooks.js';

package/script/harness/npm/src/hooks/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeHooks = exports.withHooks = void 0;
+var with_hooks_js_1 = require("./with-hooks.js");
+Object.defineProperty(exports, "withHooks", { enumerable: true, get: function () { return with_hooks_js_1.withHooks; } });
+var merge_hooks_js_1 = require("./merge-hooks.js");
+Object.defineProperty(exports, "mergeHooks", { enumerable: true, get: function () { return merge_hooks_js_1.mergeHooks; } });

package/script/harness/npm/src/hooks/merge-hooks.d.ts

@@ -0,0 +1,2 @@
+import type { AgentSessionHooks } from './types.js';
+export declare const mergeHooks: (list: (AgentSessionHooks | undefined)[]) => AgentSessionHooks;

package/script/harness/npm/src/hooks/merge-hooks.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeHooks = void 0;
+const mergeHooks = (list) => {
+    const hooks = list.filter((h) => h !== undefined);
+    const merged = {};
+    if (hooks.some((h) => h.sessionStart)) {
+        merged.sessionStart = async () => {
+            for (const h of hooks)
+                await h.sessionStart?.();
+        };
+    }
+    if (hooks.some((h) => h.prepareRequest)) {
+        merged.prepareRequest = async (req) => {
+            let current = req;
+            for (const h of hooks) {
+                const next = await h.prepareRequest?.(current);
+                if (next)
+                    current = { system: next.system ?? current.system, tools: next.tools ?? current.tools };
+            }
+            return current;
+        };
+    }
+    if (hooks.some((h) => h.beforeToolCall)) {
+        merged.beforeToolCall = async (call) => {
+            for (const h of hooks) {
+                const blocked = await h.beforeToolCall?.(call);
+                if (blocked)
+                    return blocked;
+            }
+        };
+    }
+    if (hooks.some((h) => h.afterToolCall)) {
+        merged.afterToolCall = async (call) => {
+            let result = call.result;
+            for (const h of hooks) {
+                const next = await h.afterToolCall?.({ name: call.name, result });
+                if (next)
+                    result = next;
+            }
+            return result;
+        };
+    }
+    return merged;
+};
+exports.mergeHooks = mergeHooks;

package/script/harness/npm/src/hooks/types.d.ts

@@ -0,0 +1,20 @@
+import type { ContentPart, Tool } from 'mu-core';
+export interface PreparedRequest {
+    system?: string;
+    tools?: Tool[];
+}
+export interface AgentSessionHooks {
+    sessionStart?(): void | Promise<void>;
+    prepareRequest?(req: {
+        system: string;
+        tools: Tool[];
+    }): PreparedRequest | void | Promise<PreparedRequest | void>;
+    beforeToolCall?(call: {
+        name: string;
+        input: unknown;
+    }): void | ContentPart[] | Promise<void | ContentPart[]>;
+    afterToolCall?(call: {
+        name: string;
+        result: ContentPart[];
+    }): void | ContentPart[] | Promise<void | ContentPart[]>;
+}

package/script/harness/npm/src/hooks/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/harness/npm/src/hooks/with-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from 'mu-core';
+import type { AgentSessionHooks } from './types.js';
+export declare const withHooks: (tool: Tool, hooks: AgentSessionHooks) => Tool;

package/script/harness/npm/src/hooks/with-hooks.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withHooks = void 0;
+const withHooks = (tool, hooks) => {
+    if (!hooks.beforeToolCall && !hooks.afterToolCall)
+        return tool;
+    const run = async (input, ctx) => {
+        const blocked = await hooks.beforeToolCall?.({ name: tool.name, input });
+        if (blocked)
+            return blocked;
+        const result = await tool.run(input, ctx);
+        return (await hooks.afterToolCall?.({ name: tool.name, result })) ?? result;
+    };
+    return Object.assign(Object.create(tool), { run });
+};
+exports.withHooks = withHooks;

package/script/harness/npm/src/index.d.ts

@@ -0,0 +1,15 @@
+import "./_dnt.polyfills.js";
+export * from './agents/index.js';
+export * from './channels/index.js';
+export * from './commands/index.js';
+export * from './common/index.js';
+export * from './config/index.js';
+export * from './harness/index.js';
+export * from './hooks/index.js';
+export * from './permissions/index.js';
+export * from './plugin/index.js';
+export * from './scheduler/index.js';
+export * from './session/index.js';
+export * from './skills/index.js';
+export * from './subAgents/index.js';
+export * from './tui/index.js';

package/script/harness/npm/src/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./_dnt.polyfills.js");
+__exportStar(require("./agents/index.js"), exports);
+__exportStar(require("./channels/index.js"), exports);
+__exportStar(require("./commands/index.js"), exports);
+__exportStar(require("./common/index.js"), exports);
+__exportStar(require("./config/index.js"), exports);
+__exportStar(require("./harness/index.js"), exports);
+__exportStar(require("./hooks/index.js"), exports);
+__exportStar(require("./permissions/index.js"), exports);
+__exportStar(require("./plugin/index.js"), exports);
+__exportStar(require("./scheduler/index.js"), exports);
+__exportStar(require("./session/index.js"), exports);
+__exportStar(require("./skills/index.js"), exports);
+__exportStar(require("./subAgents/index.js"), exports);
+__exportStar(require("./tui/index.js"), exports);

package/script/harness/npm/src/permissions/allow-list.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from 'mu-core';
+import type { AgentSessionHooks } from '../hooks/index.js';
+export declare const filterTools: (pool: Tool[], allow: string[] | undefined) => Tool[];
+export declare const allowList: (names: string[] | undefined) => AgentSessionHooks;

package/script/harness/npm/src/permissions/allow-list.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowList = exports.filterTools = void 0;
+const glob_js_1 = require("./glob.js");
+const filterTools = (pool, allow) => {
+    const patterns = allow ?? [];
+    return pool.filter((tool) => (0, glob_js_1.matchesAnyGlob)(tool.name, patterns));
+};
+exports.filterTools = filterTools;
+const allowList = (names) => ({
+    prepareRequest: ({ tools }) => ({ tools: (0, exports.filterTools)(tools, names) }),
+});
+exports.allowList = allowList;

package/script/harness/npm/src/permissions/approval.d.ts

@@ -0,0 +1,17 @@
+import type { ContentPart } from 'mu-core';
+import type { AgentSessionHooks } from '../hooks/index.js';
+export interface ApprovalCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+export interface RequireApprovalOptions {
+    needsApproval(call: {
+        name: string;
+        input: unknown;
+    }): boolean;
+    prompt(call: ApprovalCall): boolean | Promise<boolean>;
+    onDeny?(call: ApprovalCall): ContentPart[];
+    newId?(): string;
+}
+export declare const requireApproval: (options: RequireApprovalOptions) => AgentSessionHooks;

package/script/harness/npm/src/permissions/approval.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireApproval = void 0;
+const requireApproval = (options) => {
+    const newId = options.newId ?? (() => crypto.randomUUID());
+    return {
+        beforeToolCall: async ({ name, input }) => {
+            if (!options.needsApproval({ name, input }))
+                return;
+            const call = { id: newId(), name, input };
+            if (await options.prompt(call))
+                return;
+            return options.onDeny?.(call) ?? [{ type: 'text', text: `Denied: ${call.name}` }];
+        },
+    };
+};
+exports.requireApproval = requireApproval;

package/script/harness/npm/src/permissions/glob.d.ts

@@ -0,0 +1 @@
+export declare const matchesAnyGlob: (value: string, patterns: string[]) => boolean;

package/script/harness/npm/src/permissions/glob.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesAnyGlob = void 0;
+const node_path_1 = require("node:path");
+const matchesAnyGlob = (value, patterns) => patterns.some((pattern) => (0, node_path_1.matchesGlob)(value, pattern));
+exports.matchesAnyGlob = matchesAnyGlob;

package/script/harness/npm/src/permissions/index.d.ts

@@ -0,0 +1,3 @@
+export { allowList, filterTools } from './allow-list.js';
+export { type ApprovalCall, requireApproval, type RequireApprovalOptions } from './approval.js';
+export { matchesAnyGlob } from './glob.js';

package/script/harness/npm/src/permissions/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesAnyGlob = exports.requireApproval = exports.filterTools = exports.allowList = void 0;
+var allow_list_js_1 = require("./allow-list.js");
+Object.defineProperty(exports, "allowList", { enumerable: true, get: function () { return allow_list_js_1.allowList; } });
+Object.defineProperty(exports, "filterTools", { enumerable: true, get: function () { return allow_list_js_1.filterTools; } });
+var approval_js_1 = require("./approval.js");
+Object.defineProperty(exports, "requireApproval", { enumerable: true, get: function () { return approval_js_1.requireApproval; } });
+var glob_js_1 = require("./glob.js");
+Object.defineProperty(exports, "matchesAnyGlob", { enumerable: true, get: function () { return glob_js_1.matchesAnyGlob; } });

package/script/harness/npm/src/plugin/define.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from './types.js';
+export declare const definePlugin: (plugin: Plugin) => Plugin;

package/script/harness/npm/src/plugin/define.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definePlugin = void 0;
+const definePlugin = (plugin) => plugin;
+exports.definePlugin = definePlugin;

package/script/harness/npm/src/plugin/import-ts.d.ts

@@ -0,0 +1 @@
+export declare const importModule: (spec: string) => Promise<Record<string, unknown>>;