@cerebriline/core 4.100.240

package/dist/extensions/tools/types.d.ts

@@ -0,0 +1,410 @@
+/**
+ * Types for Default Tools
+ *
+ * Type definitions for executors, configuration, and results.
+ */
+import type { AgentToolContext, ImageContent, ITelemetryService, TextContent } from "@cerebriline/shared";
+import type { SedFileOutcome } from "./executors/sed";
+import type { QaCredential } from "./qa-credentials";
+import type { ApplyPatchInput, AwkToolInput, EditFileInput, ExtractDocumentInput, GrepToolInput, ReadFileRequest, SedToolInput, StructuredCommandInput } from "./schemas";
+import type { TaskProgressTracker } from "./task-progress";
+/**
+ * Result from a single tool operation
+ */
+export interface ToolOperationResult {
+    /** The query/input that was executed */
+    query: string;
+    /** The result content (if successful) */
+    result: unknown;
+    /** Error message (if failed) */
+    error?: string;
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Duration in MS */
+    duration?: number;
+}
+export type FileReadResultContent = string | Array<TextContent | ImageContent>;
+/**
+ * Executor for reading files
+ *
+ * @param request - File path and optional inclusive line range to read
+ * @param context - Tool execution context
+ * @returns The file content as a string
+ */
+export type FileReadExecutor = (request: ReadFileRequest, context: AgentToolContext) => Promise<FileReadResultContent>;
+/**
+ * Executor for searching the codebase
+ *
+ * @param query - Regex pattern to search for
+ * @param cwd - Current working directory for the search
+ * @param context - Tool execution context
+ * @returns Search results as a formatted string
+ */
+/** Per-call overrides for one search, on top of the executor's defaults. */
+export interface SearchQueryOptions {
+    /** Lines shown either side of a match. */
+    contextLines?: number;
+    /**
+     * Matches reported per file. One by default, which answers "which files
+     * mention this" and cannot answer "how many times, and where".
+     */
+    maxPerFile?: number;
+}
+export type SearchExecutor = (query: string, cwd: string, context: AgentToolContext, options?: SearchQueryOptions) => Promise<string>;
+/**
+ * Per-call execution options for a shell executor.
+ */
+export interface ShellExecutionOptions {
+    /**
+     * Environment for this command and no other.
+     *
+     * Separate from the executor's own `env` because it carries QA credentials,
+     * which are scoped to the single command that asked for them. An executor
+     * that cannot honour per-command environment -- a persistent terminal, where
+     * anything exported outlives the command -- must not silently ignore this;
+     * see the VS Code `run_commands` tool, which routes such a command to a
+     * child process instead.
+     */
+    env?: Record<string, string>;
+    /**
+     * Names to strip from the inherited environment before `env` is applied.
+     *
+     * Without this the gate is decorative wherever the host itself holds the
+     * secret: the CLI is started with `QA_PASSWORD` exported, `spawn` inherits
+     * the parent environment, and every command in the run sees it whether it
+     * asked or not. Withholding the declared names and re-adding only the ones a
+     * command asked for gives that host the same guarantee as one with a secret
+     * store.
+     */
+    withhold?: readonly string[];
+}
+/**
+ * Executor for running shell commands
+ *
+ * @param command - Shell command to execute
+ * @param cwd - Current working directory for execution
+ * @param context - Tool execution context
+ * @param options - Per-call options, currently the command's own environment
+ * @returns Command output (stdout)
+ */
+export type ShellExecutor = (command: string | StructuredCommandInput, cwd: string, context: AgentToolContext, options?: ShellExecutionOptions) => Promise<string>;
+/**
+ * Executor for fetching web content
+ *
+ * @param url - URL to fetch
+ * @param prompt - Analysis prompt for the content
+ * @param context - Tool execution context
+ * @returns Analyzed/extracted content
+ */
+export type WebFetchExecutor = (url: string, prompt: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for editing files
+ *
+ * @param input - Editor command input
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type EditorExecutor = (input: EditFileInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for the in-process `grep`.
+ *
+ * Read-only, so there is no write guard to satisfy — but it does record what it
+ * read, which is why it belongs to the same executor set as the editor rather
+ * than being constructed wherever it is called.
+ *
+ * @param input - grep command input
+ * @param cwd - Current working directory; paths are resolved against it
+ * @param context - Tool execution context
+ */
+export type GrepExecutor = (input: GrepToolInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for the in-process `sed`.
+ *
+ * `in_place: true` writes, so it takes the same read receipt the editor takes:
+ * a file the model has not read is not a file it may rewrite.
+ *
+ * @param input - sed command input
+ * @param cwd - Current working directory; paths are resolved against it
+ * @param context - Tool execution context
+ */
+export type SedExecutor = (input: SedToolInput, cwd: string, context: AgentToolContext) => Promise<SedFileOutcome[]>;
+/**
+ * Executor for the in-process `awk`.
+ *
+ * Read-only by construction — output redirection, pipes and `getline` are all
+ * refused — so, like grep, it records reads and guards no writes.
+ *
+ * @param input - awk command input
+ * @param cwd - Current working directory; paths are resolved against it
+ * @param context - Tool execution context
+ */
+export type AwkExecutor = (input: AwkToolInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for `extract_document`: a document to markdown or text, its
+ * pictures written as files. Returns image parts too when `images: "inline"`.
+ */
+export type ExtractDocumentExecutor = (input: ExtractDocumentInput, cwd: string, context: AgentToolContext) => Promise<FileReadResultContent>;
+/**
+ * Executor for apply_patch operations
+ *
+ * @param input - apply_patch command payload
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type ApplyPatchExecutor = (input: ApplyPatchInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for invoking configured skills
+ *
+ * @param skill - Skill name to invoke
+ * @param args - Optional arguments for the skill
+ * @param context - Tool execution context
+ * @returns Skill loading/invocation result
+ */
+export type SkillsExecutor = (skill: string, args: string | undefined, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for asking a single follow-up question with selectable options
+ *
+ * @param question - Single clarifying question for the user
+ * @param options - 2-5 selectable answer options
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type AskQuestionExecutor = (question: string, options: string[], context: AgentToolContext) => Promise<string>;
+/**
+ * Skill metadata exposed by SkillsExecutor for clients/UI
+ */
+export interface SkillsExecutorSkillMetadata {
+    /** Normalized skill id (usually lowercased name) */
+    id: string;
+    /** Display name for the skill */
+    name: string;
+    /** Optional short description */
+    description?: string;
+    /** True when configured but intentionally disabled */
+    disabled: boolean;
+}
+/**
+ * A callable executor that can also expose configured skill metadata.
+ */
+export interface SkillsExecutorWithMetadata {
+    (skill: string, args: string | undefined, context: AgentToolContext): Promise<string>;
+    configuredSkills?: SkillsExecutorSkillMetadata[];
+}
+/**
+ * Executor for verifying a user's response to a question
+ *
+ * @param summary - Summary of the solution ans steps taken
+ * @param verified - Boolean indicating if the solution has been verified
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type VerifySubmitExecutor = (summary: string, verified: boolean, context: AgentToolContext) => Promise<string>;
+/**
+ * Collection of all tool executors
+ */
+export interface ToolExecutors {
+    /** File reading implementation */
+    readFile?: FileReadExecutor;
+    /** Codebase search implementation */
+    search?: SearchExecutor;
+    /** Shell command execution implementation */
+    bash?: ShellExecutor;
+    /** Web content fetching implementation */
+    webFetch?: WebFetchExecutor;
+    /** Filesystem editor implementation */
+    editor?: EditorExecutor;
+    /** In-process grep implementation */
+    grep?: GrepExecutor;
+    /** In-process sed implementation */
+    sed?: SedExecutor;
+    /** In-process awk implementation */
+    awk?: AwkExecutor;
+    /** Document to text/markdown, pictures to files */
+    extractDocument?: ExtractDocumentExecutor;
+    /** Apply patch implementation */
+    applyPatch?: ApplyPatchExecutor;
+    /** Skill invocation implementation */
+    skills?: SkillsExecutorWithMetadata;
+    /** Follow-up question implementation */
+    askQuestion?: AskQuestionExecutor;
+    /** Final submission implementation */
+    submit?: VerifySubmitExecutor;
+}
+/**
+ * Names of available default tools
+ */
+export type DefaultToolName = "read_files" | "search_codebase" | "run_commands" | "fetch_web_content" | "apply_patch" | "editor" | "grep" | "sed" | "awk" | "extract_document" | "skills" | "ask_question" | "submit_and_exit";
+/**
+ * Configuration for enabling/disabling default tools
+ */
+export interface DefaultToolsConfig {
+    /**
+     * QA credentials available to `run_commands`, from the host's secret store.
+     * A function when the set can change while a session runs.
+     */
+    qaCredentials?: readonly QaCredential[] | (() => readonly QaCredential[]);
+    /**
+     * Host telemetry service, injected at tool construction time. Tools that
+     * emit operational telemetry (e.g. run_commands timeouts) close over this
+     * service. It is a live host object and must never travel on the per-call
+     * AgentToolContext, which crosses process boundaries over JSON IPC.
+     */
+    telemetry?: ITelemetryService;
+    /**
+     * Enable the read_files tool
+     * @default true
+     */
+    enableReadFiles?: boolean;
+    /**
+     * Enable the search_codebase tool
+     * @default true
+     */
+    enableSearch?: boolean;
+    /**
+     * Enable the run_commands tool
+     * @default true
+     */
+    enableBash?: boolean;
+    /**
+     * Enable the fetch_web_content tool
+     * @default true
+     */
+    enableWebFetch?: boolean;
+    /**
+     * Enable the apply_patch tool
+     * @default true
+     */
+    enableApplyPatch?: boolean;
+    /**
+     * Enable the editor tool
+     * @default true
+     */
+    enableEditor?: boolean;
+    /**
+     * Enable the grep tool
+     * @default true
+     */
+    enableGrep?: boolean;
+    /**
+     * Enable the sed tool
+     * @default true
+     */
+    enableSed?: boolean;
+    /**
+     * Enable the awk tool
+     * @default true
+     */
+    enableAwk?: boolean;
+    /**
+     * Enable the extract_document tool. Off unless asked for: it is a niche
+     * reader, and a session pays for its schema on every request.
+     * @default false
+     */
+    enableExtractDocument?: boolean;
+    /**
+     * Enable the skills tool
+     * @default true
+     */
+    enableSkills?: boolean;
+    /**
+     * Enable the ask_followup_question tool
+     * @default true
+     */
+    enableAskQuestion?: boolean;
+    /**
+     * Enable the submit_and_exit tool
+     * @default false
+     */
+    enableSubmitAndExit?: boolean;
+    /**
+     * Current working directory for tools that need it
+     */
+    cwd?: string;
+    /**
+     * Shell executable (name or full path) the run_commands executor will use.
+     * The tool description tells the model which shell syntax to write, so this
+     * must match the shell configured on the executor.
+     * @default getDefaultShell(process.platform) — "/bin/bash" on Unix, "powershell" on Windows
+     */
+    shell?: string;
+    /**
+     * Timeout for file read operations in milliseconds
+     * @default 10000
+     */
+    fileReadTimeoutMs?: number;
+    /**
+     * Timeout for bash command execution in milliseconds
+     * @default 30000
+     */
+    bashTimeoutMs?: number;
+    /**
+     * Timeout for web fetch operations in milliseconds
+     * @default 30000
+     */
+    webFetchTimeoutMs?: number;
+    /**
+     * Timeout for search operations in milliseconds
+     * @default 30000
+     */
+    searchTimeoutMs?: number;
+    /**
+     * Timeout for apply_patch operations in milliseconds
+     * @default 30000
+     */
+    applyPatchTimeoutMs?: number;
+    /**
+     * Timeout for editor operations in milliseconds
+     * @default 30000
+     */
+    editorTimeoutMs?: number;
+    /**
+     * Timeout for the grep / sed / awk tools, in milliseconds.
+     *
+     * One value for all three: they are the same kind of work — a pattern over
+     * a set of local files — and splitting it into three knobs would invite a
+     * host to set one and leave the others at a default it did not choose.
+     *
+     * @default 30000
+     */
+    textToolsTimeoutMs?: number;
+    /**
+     * Timeout for extract_document, in milliseconds. Long, because a
+     * several-hundred-page PDF with pictures is minutes of work, and each
+     * scanned page read by a vision model is a request.
+     *
+     * @default 600000
+     */
+    extractDocumentTimeoutMs?: number;
+    /**
+     * Timeout for skills operations in milliseconds
+     * @default 15000
+     */
+    skillsTimeoutMs?: number;
+    /**
+     * Timeout for submit_and_exit operations in milliseconds
+     * @default 15000
+     */
+    submitTimeoutMs?: number;
+}
+/**
+ * Options for creating default tools
+ */
+export interface CreateDefaultToolsOptions extends DefaultToolsConfig {
+    /**
+     * Executor implementations for the tools
+     * Only tools with provided executors will be available
+     */
+    executors: ToolExecutors;
+    /**
+     * Session-scoped checklist tracker. When provided, every tool gains the
+     * optional `task_progress` parameter, and results carry the checklist back
+     * to the model periodically.
+     *
+     * Absent by default: the tracker holds per-session state, so a shared or
+     * missing one is the difference between a checklist and a leak between
+     * tasks. Hosts opt in by constructing one per session.
+     */
+    taskProgress?: TaskProgressTracker;
+}

package/dist/extensions/tools/video-generation.d.ts

@@ -0,0 +1,94 @@
+/**
+ * A tool that makes a short video clip.
+ *
+ * The fourth media tool, and the one that is not a single request. An image
+ * takes seconds and comes back in the response; a clip takes from most of a
+ * minute to many, so the OpenAI videos API is a job: `POST {endpoint}/videos`
+ * answers at once with an id, `GET {endpoint}/videos/{id}` says how far it
+ * is, and `GET {endpoint}/videos/{id}/content` hands over the bytes when it is
+ * done. opencoti serves exactly that (its M7.5), and keeps a finished clip for
+ * ten minutes by default, so the content is fetched the moment the job
+ * completes.
+ *
+ * A job outlives the request that made it. So a call that is stopped -- by
+ * the user, or by this tool's own limit -- deletes its job, or the engine
+ * would go on rendering a clip nobody is waiting for while the next request
+ * queues behind it.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+export declare const GENERATE_VIDEO_TOOL_NAME = "generate_video";
+export declare const GENERATE_VIDEO_TOOL_DESCRIPTION = "Generate a short video clip from a text description and save it as a file in the workspace. Use it for a few seconds of footage you would otherwise have to ask the user to make elsewhere: a background loop, a product shot, a placeholder for a scene, an animated version of an image you already have.\n\nThe clip is written to a file and its path is returned. You cannot watch it, so tell the user where it is and let them judge it.\n\nArguments:\n- `prompt` \u2014 what the clip shows: the subject, what moves and how, the camera, the style. One scene; these models do not follow a storyboard.\n- `image` \u2014 optional workspace path of an image to start from. The clip animates it. Only some video models take one; the backend says so if it does not.\n- `path` \u2014 where to save the clip, relative to the workspace. Optional; defaults to a file under `.cline/generated-videos/`.\n- `size` \u2014 `WxH` in pixels, e.g. `832x480`. Optional; the backend has a default and supports only a few shapes.\n- `seconds` \u2014 the length of the clip. Optional; a few seconds is what these models make, and longer costs more than proportionally.\n- `seed` \u2014 optional integer. The same request with the same seed gives the same clip.\n\nThis is slow: a clip takes from most of a minute to many minutes, and on a hosted backend it costs money. Generate one only when the task needs it, and do not retry to \"improve\" a clip you have not been told is wrong.";
+export declare const GENERATE_VIDEO_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: "What the clip shows: the subject, what moves and how, the camera, the style.";
+        };
+        readonly image: {
+            readonly type: "string";
+            readonly description: "Workspace path of an image to start from. Optional; only some video models take one.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Where to save the clip, relative to the workspace. Optional; defaults to a file under .cline/generated-videos/.";
+        };
+        readonly size: {
+            readonly type: "string";
+            readonly description: "Pixel size as \"WIDTHxHEIGHT\", e.g. \"832x480\". Optional.";
+        };
+        readonly seconds: {
+            readonly type: "number";
+            readonly description: "The length of the clip in seconds. Optional.";
+        };
+        readonly seed: {
+            readonly type: "integer";
+            readonly description: "Optional. The same request with the same seed gives the same clip.";
+        };
+    };
+    readonly required: readonly ["prompt"];
+};
+export interface VideoGenerationEndpoint {
+    /** Base URL, with or without a trailing `/v1`. */
+    baseUrl: string;
+    model: string;
+    apiKey?: string;
+    /** Default for calls that name no size. */
+    size?: string;
+    /** Default for calls that name no length. */
+    seconds?: number;
+    /** The container to ask for, e.g. `mp4`. The engine's own when unset. */
+    format?: string;
+}
+export interface GenerateVideoToolOptions {
+    cwd: string;
+    getEndpoint: () => VideoGenerationEndpoint | undefined | Promise<VideoGenerationEndpoint | undefined>;
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    fetchImpl?: typeof fetch;
+    /**
+     * Milliseconds one clip may take from the request to the bytes, queueing
+     * included. Defaults to 60 minutes.
+     */
+    timeoutMs?: number;
+    /** Milliseconds between two looks at the job. Defaults to 5 seconds. */
+    pollMs?: number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    onError?: (message: string, error: unknown) => void;
+}
+/**
+ * What the bytes are, according to the bytes, as a file extension.
+ *
+ * The engine decides the container: opencoti answers mp4 with its codec
+ * sidecar loaded and AVI without it, whatever the file was going to be called.
+ */
+export declare function sniffVideoExtension(data: Buffer): string | undefined;
+/** A filename that says what the clip shows. */
+export declare function defaultVideoPath(prompt: string, now: number): string;
+/**
+ * Create the `generate_video` tool.
+ *
+ * Like the other media tools, the host leaves it out when nothing is
+ * configured, and `getEndpoint` returning nothing is handled anyway.
+ */
+export declare function createGenerateVideoTool(options: GenerateVideoToolOptions): AgentTool;

package/dist/hooks/checkpoint-hooks.d.ts

@@ -0,0 +1,39 @@
+import type { AgentHooks, BasicLogger } from "@cerebriline/shared";
+export declare function isCheckpointStashMessage(message: string): boolean;
+export interface CheckpointEntry {
+    ref: string;
+    createdAt: number;
+    runCount: number;
+    kind?: "stash" | "commit";
+}
+export interface CheckpointMetadata {
+    latest: CheckpointEntry;
+    history: CheckpointEntry[];
+}
+type CreateCheckpointHooksOptions = {
+    cwd: string;
+    sessionId: string;
+    logger?: BasicLogger;
+    readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+    writeSessionMetadata: (metadata: Record<string, unknown>) => Promise<void> | void;
+    /**
+     * Optional custom checkpoint implementation. When provided, the built-in
+     * git stash/ref logic is skipped entirely and this function is called
+     * instead. Return `undefined` to skip writing a checkpoint for that run.
+     */
+    createCheckpoint?: (context: {
+        cwd: string;
+        sessionId: string;
+        runCount: number;
+    }) => Promise<CheckpointEntry | undefined> | CheckpointEntry | undefined;
+};
+/**
+ * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that
+ * were created by the checkpoint system to keep stash objects reachable.
+ * Errors are swallowed - if the cwd is not a git repo or the refs don't exist,
+ * the delete is a no-op.
+ */
+export declare function deleteCheckpointRefs(cwd: string | null | undefined, sessionId: string): Promise<void>;
+export declare function retainCheckpointRefs(cwd: string | null | undefined, sessionId: string, checkpoints: readonly CheckpointEntry[]): Promise<void>;
+export declare function createCheckpointHooks(options: CreateCheckpointHooksOptions): AgentHooks;
+export {};

package/dist/hooks/hook-extension.d.ts

@@ -0,0 +1,2 @@
+import type { AgentExtension, AgentHooks } from "@cerebriline/shared";
+export declare function createAgentHooksExtension(name: string, hooks: AgentHooks | undefined): AgentExtension | undefined;

package/dist/hooks/hook-file-config.d.ts

@@ -0,0 +1,24 @@
+import { HOOKS_CONFIG_DIRECTORY_NAME } from "@cerebriline/shared/storage";
+import type { HookEventName } from "./subprocess";
+export { HOOKS_CONFIG_DIRECTORY_NAME };
+export declare function resolveHooksConfigSearchPaths(workspacePath?: string): string[];
+export declare enum HookConfigFileName {
+    TaskStart = "TaskStart",
+    TaskResume = "TaskResume",
+    TaskCancel = "TaskCancel",
+    TaskComplete = "TaskComplete",
+    TaskError = "TaskError",
+    PreToolUse = "PreToolUse",
+    PostToolUse = "PostToolUse",
+    UserPromptSubmit = "UserPromptSubmit",
+    PreCompact = "PreCompact",
+    SessionShutdown = "SessionShutdown"
+}
+export declare const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<Record<HookConfigFileName, HookEventName | undefined>>;
+export declare function toHookConfigFileName(fileName: string): HookConfigFileName | undefined;
+export interface HookConfigFileEntry {
+    fileName: HookConfigFileName;
+    hookEventName?: HookEventName;
+    path: string;
+}
+export declare function listHookConfigFiles(workspacePath?: string): HookConfigFileEntry[];

package/dist/hooks/hook-file-hooks.d.ts

@@ -0,0 +1,22 @@
+import type { AgentExtension, AgentHooks, BasicLogger, WorkspaceInfo } from "@cerebriline/shared";
+type HookRuntimeOptions = {
+    cwd: string;
+    workspacePath: string;
+    rootSessionId?: string;
+    logger?: BasicLogger;
+    toolCallTimeoutMs?: number;
+    /** Keep asynchronous hooks attached until exit. Intended for deterministic tests. */
+    detachAsyncHooks?: boolean;
+    /** Structured git + path metadata forwarded into every hook payload. */
+    workspaceInfo?: WorkspaceInfo;
+};
+export declare function getWindowsPythonFallbackCommand(command: string[], platform?: NodeJS.Platform, error?: unknown): string[] | undefined;
+export declare function createHookAuditHooks(options: {
+    rootSessionId?: string;
+    workspacePath: string;
+    workspaceInfo?: WorkspaceInfo;
+}): AgentHooks;
+export declare function createHookConfigFileHooks(options: HookRuntimeOptions): AgentHooks | undefined;
+export declare function createHookConfigFileExtension(options: HookRuntimeOptions): AgentExtension | undefined;
+export declare function mergeAgentHooks(layers: Array<AgentHooks | undefined>): AgentHooks | undefined;
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { createAgentHooksExtension } from "./hook-extension";
+export { HOOK_CONFIG_FILE_EVENT_MAP, HOOKS_CONFIG_DIRECTORY_NAME, type HookConfigFileEntry, HookConfigFileName, listHookConfigFiles, resolveHooksConfigSearchPaths, toHookConfigFileName, } from "./hook-file-config";
+export { createHookAuditHooks, createHookConfigFileExtension, createHookConfigFileHooks, mergeAgentHooks, } from "./hook-file-hooks";
+export { createSubprocessHooks, type HookEventName, HookEventNameSchema, type HookEventPayload, HookEventPayloadSchema, parseHookEventPayload, type RunHookOptions, type RunHookResult, runHook, type SubprocessHookControl, type SubprocessHooksOptions, } from "./subprocess";
+export { type RunSubprocessEventOptions, type RunSubprocessEventResult, runSubprocessEvent, } from "./subprocess-runner";

package/dist/hooks/subprocess-runner.d.ts

@@ -0,0 +1,21 @@
+export interface RunSubprocessEventOptions {
+    command: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    detached?: boolean;
+    timeoutMs?: number;
+    onSpawn?: (event: {
+        command: string[];
+        pid?: number;
+        detached: boolean;
+    }) => void;
+}
+export interface RunSubprocessEventResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    parsedJson?: unknown;
+    parseError?: string;
+    timedOut?: boolean;
+}
+export declare function runSubprocessEvent(payload: unknown, options: RunSubprocessEventOptions): Promise<RunSubprocessEventResult | undefined>;