@meetopenbot/openbot 0.1.1

package/dist/runtime.js

@@ -0,0 +1,401 @@
+import { generateText } from 'ai';
+import { eventsToModelMessages } from './history.js';
+import { buildContext } from './context.js';
+import { OPENBOT_SYSTEM_PROMPT } from './system-prompt.js';
+import { resolveModel } from './model.js';
+async function buildSystemPrompt(state, storage) {
+    const context = await buildContext(state, storage);
+    const sections = [OPENBOT_SYSTEM_PROMPT, '', context];
+    // Hardcoded naming hint logic
+    const threadState = state.threadDetails?.state;
+    if (!threadState?.isSmartNamed) {
+        sections.push('', '## SYSTEM HINT', 'This thread is unnamed. Please use the `patch_thread_details` tool to set a concise, descriptive, and regular `name` (e.g., "Project Brainstorming" instead of "project-brainstorm") in the thread state and set `isSmartNamed: true` in the same patch. Only do this once.');
+    }
+    return sections.join('\n');
+}
+/**
+ * Tracks tool-call IDs from one LLM turn until matching `:result` events arrive.
+ *
+ * Melony runs yielded `action:*` events depth-first, so parallel tool calls from
+ * a single `generateText` response execute one-by-one. We must wait for every ID
+ * in the batch before calling the LLM again — not after the first result.
+ */
+function createToolBatchTracker(state, storage, channelId, threadId) {
+    const save = async (ids) => {
+        if (!storage || !channelId || !threadId)
+            return;
+        try {
+            await storage.patchThreadState({
+                channelId,
+                threadId,
+                state: { pendingToolCallIds: ids },
+            });
+        }
+        catch (error) {
+            console.error('[openbot] Failed to persist pendingToolCallIds:', error);
+        }
+    };
+    return {
+        async startBatch(toolCallIds) {
+            state.pendingToolCallIds = [...toolCallIds];
+            await save(state.pendingToolCallIds);
+        },
+        async clear() {
+            state.pendingToolCallIds = undefined;
+            await save(undefined);
+        },
+        /** Returns true when this result completes the batch (time to call the LLM again). */
+        async recordResult(toolCallId) {
+            if (!state.pendingToolCallIds?.includes(toolCallId))
+                return false;
+            state.pendingToolCallIds = state.pendingToolCallIds.filter((id) => id !== toolCallId);
+            const done = state.pendingToolCallIds.length === 0;
+            if (done) {
+                state.pendingToolCallIds = undefined;
+            }
+            await save(state.pendingToolCallIds);
+            return done;
+        },
+    };
+}
+/**
+ * OpenBot agent runtime.
+ *
+ * - One `generateText` call per `runLLM` (tools have no `execute`; SDK stops at 1 step).
+ * - Tool calls become `action:*` events; plugins emit `:result` when done.
+ * - When a full batch of results is in, `runLLM` runs again with updated history.
+ */
+export const openbotRuntime = (options) => (builder) => {
+    const { model: modelString = 'openai/gpt-4o-mini', authMode = 'byok', agentId, storage, toolDefinitions = {}, abortSignal, host, } = options;
+    let currentModelString = modelString;
+    let model = resolveModel(currentModelString, agentId);
+    const isCreditsCloudAgent = (id) => host.isCloudSystemAgent(id ?? '') && authMode === 'credits';
+    const runLLM = async function* (context, threadId, trigger) {
+        if (!storage)
+            return;
+        if (abortSignal?.aborted)
+            return;
+        const toolBatch = createToolBatchTracker(context.state, storage, context.state.channelId, threadId || context.state.threadId);
+        // Capture parent metadata for event enrichment
+        const triggerEvent = trigger || context.state.triggerEvent;
+        const parentAgentId = triggerEvent?.meta?.parentAgentId;
+        const parentToolCallId = triggerEvent?.meta?.parentToolCallId;
+        const state = context.state;
+        state.model = currentModelString;
+        const systemPrompt = await buildSystemPrompt(context.state, storage);
+        const events = await storage.getEvents({
+            channelId: context.state.channelId,
+            threadId: context.state.threadId,
+        });
+        const messages = eventsToModelMessages(events);
+        // console.log('systemPrompt:::::::\n', systemPrompt);
+        // console.log('messages:::::::\n', JSON.stringify(messages));
+        // console.log('toolDefinitions:::::::\n', JSON.stringify(toolDefinitions));
+        try {
+            // Single LLM request — tool execution happens externally via action:* handlers.
+            const result = await generateText({
+                model,
+                system: systemPrompt,
+                messages,
+                tools: toolDefinitions,
+                stopWhen: ({ steps }) => steps.length === 1,
+                allowSystemInMessages: true,
+                abortSignal,
+            });
+            const toolCalls = result.toolCalls ?? [];
+            // if (result.usage) {
+            //   const usage = result.usage;
+            //   yield {
+            //     type: 'agent:usage',
+            //     data: {
+            //       usage: {
+            //         promptTokens: usage.inputTokens,
+            //         completionTokens: usage.outputTokens,
+            //         totalTokens: usage.totalTokens,
+            //         currentContextTokens: usage.inputTokens,
+            //         contextBudget: getContextBudgetForModel(currentModelString),
+            //       },
+            //       model: currentModelString,
+            //     },
+            //     meta: {
+            //       agentId: context.state.agentId,
+            //       threadId,
+            //       runId: context.state.runId,
+            //     },
+            //   } as OpenBotEvent;
+            // }
+            const outputMeta = {
+                agentId: context.state.agentId,
+                threadId,
+                parentAgentId,
+                parentToolCallId,
+            };
+            // Text before actions so history/UI show the model's intent first.
+            if (result.text) {
+                yield {
+                    type: 'agent:output',
+                    data: { content: result.text },
+                    meta: outputMeta,
+                };
+            }
+            if (toolCalls.length > 0) {
+                // when multiple tool calls are made, Melony runtime handles them one by one, thats why we need to start a new batch
+                await toolBatch.startBatch(toolCalls.map((tc) => tc.toolCallId));
+                for (const toolCall of toolCalls) {
+                    yield {
+                        type: `action:${toolCall.toolName}`,
+                        data: toolCall.input,
+                        meta: {
+                            toolCallId: toolCall.toolCallId,
+                            ...outputMeta,
+                        },
+                    };
+                }
+            }
+            else {
+                // clear the tool batch if there are no tool calls
+                await toolBatch.clear();
+            }
+        }
+        catch (error) {
+            // Run was stopped — unwind quietly without surfacing an error.
+            if (abortSignal?.aborted)
+                return;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isApiKeyError = errorMessage.includes('API key') ||
+                errorMessage.includes('401') ||
+                errorMessage.includes('Unauthorized') ||
+                errorMessage.includes('authentication');
+            if (isApiKeyError && !isCreditsCloudAgent(context.state.agentId)) {
+                const registry = await host.resolveModelRegistry();
+                const providerActions = host.listApiKeyProvidersFromRegistry(registry).map((provider) => ({
+                    id: provider.id,
+                    label: provider.label,
+                    variant: 'primary',
+                }));
+                yield {
+                    type: 'client:ui:widget',
+                    data: {
+                        kind: 'choice',
+                        widgetId: `api_provider_selection_${Date.now()}`,
+                        title: `Setup AI Provider`,
+                        description: `Select a provider to continue.`,
+                        actions: providerActions.length > 0
+                            ? providerActions
+                            : [
+                                { id: 'openai', label: 'OpenAI', variant: 'primary' },
+                                { id: 'anthropic', label: 'Anthropic', variant: 'primary' },
+                                { id: 'google', label: 'Google', variant: 'primary' },
+                            ],
+                        metadata: {
+                            type: 'api_provider_selection',
+                        },
+                    },
+                    meta: { agentId: context.state.agentId, threadId },
+                };
+                return;
+            }
+            throw error;
+        }
+    };
+    builder.on('agent:invoke', async function* (event, context) {
+        const routedTo = event.data?.agentId;
+        if (typeof routedTo === 'string' && routedTo && routedTo !== context.state.agentId) {
+            return;
+        }
+        // Capture user info from meta if available
+        if (event.meta?.userName) {
+            context.state.currentUser = {
+                userName: event.meta.userName,
+            };
+        }
+        const threadId = event.meta?.threadId || context.state.threadId;
+        // clear the tool batch if the agent is invoked
+        // this is to prevent the tool batch from being used for a new agent invocation
+        await createToolBatchTracker(context.state, storage, context.state.channelId, threadId).clear();
+        yield* runLLM(context, threadId, event);
+    });
+    // this is to handle the tool results from the tool calls
+    // because Melony runtime handles them one by one, thats why we need to record the result
+    builder.on('*', async function* (event, context) {
+        if (!event.type.endsWith(':result'))
+            return;
+        if (event.meta?.agentId !== context.state.agentId)
+            return;
+        const toolCallId = event.meta?.toolCallId;
+        // record the result of the tool call
+        if (!toolCallId ||
+            !(await createToolBatchTracker(context.state, storage, context.state.channelId, event.meta?.threadId || context.state.threadId).recordResult(toolCallId)))
+            return;
+        const threadId = event.meta?.threadId || context.state.threadId;
+        yield* runLLM(context, threadId);
+    });
+    builder.on('client:ui:widget:response', async function* (event, context) {
+        const { metadata, values, actionId } = event.data;
+        const threadId = event.meta?.threadId || context.state.threadId;
+        if (isCreditsCloudAgent(context.state.agentId))
+            return;
+        if (metadata?.type === 'api_provider_selection') {
+            const provider = actionId;
+            const [_, ...rest] = currentModelString.split('/');
+            const currentModelId = rest.join('/');
+            const registry = await host.resolveModelRegistry();
+            const providerData = registry.providers?.[provider];
+            const providerLinks = {
+                openai: 'https://platform.openai.com/api-keys',
+                anthropic: 'https://console.anthropic.com/settings/keys',
+                google: 'https://aistudio.google.com/app/apikey',
+            };
+            const label = providerData?.label || provider;
+            const link = providerLinks[provider] || '';
+            const modelOptions = providerData?.models.map((m) => ({
+                label: m.label,
+                value: m.id,
+            }));
+            if (!modelOptions || modelOptions.length === 0) {
+                yield {
+                    type: 'agent:output',
+                    data: {
+                        content: `No models are listed for **${label}** in the marketplace registry.`,
+                    },
+                    meta: { agentId: context.state.agentId },
+                };
+                return;
+            }
+            const defaultModel = modelOptions[0].value;
+            const defaultValue = modelOptions.find((m) => m.value === currentModelId)?.value || defaultModel;
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    widgetId: event.data.widgetId,
+                    kind: 'message',
+                    title: 'Provider Selected',
+                    body: `${label} provider was selected.`,
+                    state: 'submitted',
+                    display: 'collapsed',
+                    disabled: true,
+                    actions: [],
+                },
+                meta: { agentId: context.state.agentId, threadId },
+            };
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    kind: 'form',
+                    widgetId: `api_key_request_${Date.now()}`,
+                    title: `${label} Setup`,
+                    description: `Enter your API key and select a model.`,
+                    fields: [
+                        {
+                            id: 'model',
+                            label: 'Model',
+                            type: 'select',
+                            options: modelOptions,
+                            required: true,
+                            defaultValue,
+                        },
+                        {
+                            id: 'apiKey',
+                            label: 'API Key',
+                            type: 'password',
+                            description: `Get your key here: [${link}](${link})`,
+                            placeholder: `sk-...`,
+                            required: true,
+                        },
+                    ],
+                    submitLabel: 'Save & Continue',
+                    metadata: {
+                        type: 'api_key_request',
+                        provider,
+                    },
+                },
+                meta: { agentId: context.state.agentId, threadId },
+            };
+            return;
+        }
+        if (metadata?.type !== 'api_key_request')
+            return;
+        if (!values?.apiKey || !values?.model)
+            return;
+        const provider = String(values.provider || metadata.provider);
+        const modelId = String(values.model).trim();
+        const apiKey = String(values.apiKey);
+        if (provider !== 'openai' && provider !== 'anthropic' && provider !== 'google') {
+            yield {
+                type: 'agent:output',
+                data: { content: `Unsupported provider: ${provider}` },
+                meta: { agentId: context.state.agentId },
+            };
+            return;
+        }
+        const envVar = provider === 'openai'
+            ? 'OPENAI_API_KEY'
+            : provider === 'anthropic'
+                ? 'ANTHROPIC_API_KEY'
+                : 'GOOGLE_GENERATIVE_AI_API_KEY';
+        const newModelString = `${provider}/${modelId}`;
+        if (!storage)
+            return;
+        try {
+            await storage.createVariable({ key: envVar, value: apiKey, secret: true });
+            process.env[envVar] = apiKey;
+            currentModelString = newModelString;
+            model = resolveModel(currentModelString, agentId);
+            try {
+                host.saveConfig({ model: currentModelString });
+                const details = await storage.getAgentDetails({ agentId: context.state.agentId });
+                const updatedPlugins = details.pluginRefs.map((ref) => {
+                    if (ref.id === host.openbotPluginId) {
+                        return {
+                            ...ref,
+                            config: {
+                                ...ref.config,
+                                model: currentModelString,
+                                ...(host.isCloudSystemAgent(context.state.agentId) ? { authMode: 'byok' } : {}),
+                            },
+                        };
+                    }
+                    return ref;
+                });
+                await storage.updateAgent({
+                    agentId: context.state.agentId,
+                    plugins: updatedPlugins,
+                });
+            }
+            catch {
+                // best-effort: config persistence failure shouldn't block the conversation
+            }
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `Saved ${provider} API key and set model to \`${newModelString}\`.`,
+                },
+                meta: { agentId: context.state.agentId },
+            };
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    widgetId: event.data.widgetId,
+                    kind: 'message',
+                    title: 'API Key Saved',
+                    body: `Successfully saved ${provider} API key and selected model \`${newModelString}\`. You can now continue your conversation.`,
+                    state: 'submitted',
+                    display: 'collapsed',
+                    disabled: true,
+                    actions: [],
+                },
+                meta: { agentId: context.state.agentId },
+            };
+            yield* runLLM(context, threadId);
+        }
+        catch (error) {
+            yield {
+                type: 'agent:output',
+                data: {
+                    content: `Failed to save API key: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+                meta: { agentId: context.state.agentId },
+            };
+        }
+    });
+};

package/dist/system-prompt.d.ts

@@ -0,0 +1 @@
+export declare const OPENBOT_SYSTEM_PROMPT: string;

package/dist/system-prompt.js

@@ -0,0 +1,57 @@
+export const OPENBOT_SYSTEM_PROMPT = [
+    '# ROLE',
+    'You are an OpenBot, the main coordinator and router agent. Your primary role is to orchestrate specialized agents and manage tasks methodically to help the human achieve their goals.',
+    '',
+    '# SECURITY POLICY',
+    '- **CRITICAL**: Never request API keys, passwords, or sensitive credentials via text or UI widgets; these are managed deterministically via secure forms and must never enter your context.',
+    '- **Credential Guidance**: If an agent or tool requires credentials, inform the user they can be managed under "Settings > Variables".',
+    '',
+    '# CORE MISSION',
+    'You act as a high-level manager, ensuring the right specialized agent is working on the right task. However, when orchestrating or when specialized agents are not available, you are capable of executing complex steps yourself using a highly structured, stateful, and disciplined approach.',
+    '',
+    '# THE AGENT LOOP',
+    'You operate in an iterative agent loop to complete user-assigned tasks step-by-step:',
+    '1. **Analyze Events**: Understand user needs and the current state through the chronological event stream (focusing on latest user messages and execution/observation results).',
+    '2. **Select Tools**: Choose the next tool call based on current state, todos, and environment constraints. To maximize precision, choose only one tool call per iteration for complex tasks, or parallel calls if they are independent.',
+    '3. **Wait for Execution**: Let the system execute the tool action and add observations/results back into the event stream.',
+    '4. **Iterate**: Patiently repeat the above steps, analyzing results at each turn, until all steps of the task are completed.',
+    '5. **Submit Results**: Message the human with clear, polished, and detailed outcomes, attaching any relevant files or deliverables.',
+    '6. **Enter Standby**: Enter an idle state and wait for new tasks.',
+    '',
+    '# TASK TRACKING (TODOS)',
+    '- For any complex multi-step task (3+ steps), you **MUST** maintain a todo list with `todo_write`.',
+    '- Write the full intended list at task start. Each call replaces the previous list (not a partial patch).',
+    '- Keep exactly one item `in_progress` while working. Mark items `completed` immediately after finishing them.',
+    '- Use `cancelled` for steps that are no longer needed. When the overall task is done, mark all items `completed` and leave the list intact (do not clear with empty `items`).',
+    '- The current list is injected into context each turn as `## TODOS`; call `todo_read` only if you need an explicit refresh.',
+    '- Do not stop with open `pending` or `in_progress` items unless you are blocked and have told the user why.',
+    '',
+    '# OPERATIONAL GUIDELINES',
+    '- **Channel and Threads**: The main way to communicate and act is through channels and threads. There might be a channel called "uncategorized" for general purpose communication.',
+    '- **Delegation**: You can delegate tasks to any specialized agent in the `INSTALLED AGENTS` list using the `delegate` tool.',
+    '- **Durable Memory**: Use the `remember` tool to store important facts, preferences, or project details that should persist across sessions.',
+    '- **Hub-and-Spoke**: Specialized agents cannot communicate directly; as coordinator, you must pass relevant data from one agent to another.',
+    '',
+    '# SHELL & FILE EXECUTION RULES',
+    '- **Stateful Sessions**: Use `shell_exec` with a session `id` (e.g. `default`, `server`). Reuse the same id to keep shell state (cwd, env) across commands.',
+    '- **Working Directory**: Always pass an absolute `exec_dir` (use the channel workspace path from ENVIRONMENT).',
+    '- **Command Discipline**: Avoid interactive prompts when possible; use `-y`, `-f`, or non-interactive flags. For prompts, use `shell_write_to_process`.',
+    '- **Long-Running Processes**: Start dev servers with `shell_exec` using `&` at the end (e.g. `pnpm dev &`). If you forget `&`, `shell_exec` returns after ~15s with partial logs — the server may still be running.',
+    '- **Polling dev servers**: After starting (or after a timeout), poll with `shell_wait` (2–5s) then `shell_view` until logs show ready (URL/port). Do not start a duplicate server; reuse the same session id.',
+    '- **Stop dev servers**: Use `shell_kill_process` before restarting or when finished.',
+    '- **Preview URLs**: After a dev server is ready, use `expose_port` with its port to generate a public preview URL (stored on channel details as `previewUrl`). Expose tunnels are temporary; close with `unexpose_port`.',
+    '- **Calculations**: Use `bc` or Python for math. Do not calculate complex math mentally.',
+    '- **Chaining**: Chain related commands with `&&` in a single `shell_exec` when they must run sequentially.',
+    '',
+    '# COMMUNICATION & WRITING STYLE',
+    '- Be concise, professional, proactive, and polite.',
+    '- Confirm receipt of user messages quickly and outline your high-level strategy brief before executing a long series of steps.',
+    '- Inform the user via messages when you change methods or find strategic issues.',
+    '- Write in clean, continuous prose. Avoid excessive bullet points or lists in final responses unless explicitly requested.',
+    '- All major deliverables and documents must be highly detailed and complete; do not summarize or truncate final outputs unless specified.',
+    '',
+    '# ERROR HANDLING',
+    '- Tool failures are provided as events. When an error occurs, do not panic or immediately ask the user for help.',
+    '- Carefully analyze the stderr or failure logs, verify tool/argument names, and attempt alternative approaches or parameter fixes.',
+    '- Only report failure reasons and ask the human for help after multiple alternative approaches have failed.',
+].join('\n');

package/dist/tools/approval.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types.js';
+export declare const approvalPlugin: Plugin;
+export default approvalPlugin;

package/dist/tools/approval.js

@@ -0,0 +1,130 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * `approval` — gates protected tool calls behind a UI confirmation widget.
+ *
+ * This is a simplified version that intercepts specified actions (default: bash)
+ * and requires user approval before they are allowed to proceed.
+ */
+// In-memory tracking for pending approval IDs with TTL (shared across plugin instances)
+const pendingApprovals = new Map();
+const TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+export const approvalPlugin = {
+    id: 'approval',
+    name: 'Approval',
+    description: 'Gate protected tool calls behind a UI confirmation widget.',
+    factory: ({ config, storage }) => (builder) => {
+        // Actions that require approval. Defaults to bash.
+        const actionsToApprove = config.actions || ['action:shell_exec'];
+        for (const action of actionsToApprove) {
+            builder.intercept(action, (event, context) => {
+                // If already approved in this flow, let it pass to the actual handler
+                if (event.meta?.approvalStatus === 'approved')
+                    return event;
+                // Otherwise, intercept and ask for approval via a UI widget
+                const displayData = JSON.stringify(event?.data) || '';
+                const widgetId = randomUUID();
+                pendingApprovals.set(widgetId, Date.now());
+                return {
+                    type: 'client:ui:widget',
+                    data: {
+                        widgetId,
+                        kind: 'message',
+                        title: `The agent wants to perform \`${action}\``,
+                        body: displayData,
+                        metadata: {
+                            type: 'approval:request',
+                            originalEvent: event,
+                        },
+                        actions: [
+                            { id: 'approve', label: 'Approve', variant: 'primary' },
+                            { id: 'deny', label: 'Deny', variant: 'danger' },
+                        ],
+                    },
+                    meta: { agentId: context.state.agentId, threadId: context.state.threadId },
+                };
+            });
+        }
+        // Handle the user's response from the UI widget
+        builder.on('client:ui:widget:response', async function* (event, context) {
+            const { widgetId, actionId } = event.data;
+            const metadata = event.data?.metadata;
+            if (metadata?.type !== 'approval:request')
+                return;
+            // Verify the widget is still pending and hasn't expired
+            if (!widgetId || !pendingApprovals.has(widgetId)) {
+                console.warn(`[approval] Received response for unknown or already handled widget: ${widgetId}`);
+                return;
+            }
+            const timestamp = pendingApprovals.get(widgetId);
+            if (Date.now() - timestamp > TTL_MS) {
+                pendingApprovals.delete(widgetId);
+                console.warn(`[approval] Received response for expired widget: ${widgetId}`);
+                return;
+            }
+            // Mark as handled
+            pendingApprovals.delete(widgetId);
+            const originalEvent = metadata.originalEvent;
+            const approved = actionId === 'approve';
+            const displayData = JSON.stringify(event?.data) || '';
+            // Yield a "responded" widget update to the UI
+            yield {
+                type: 'client:ui:widget',
+                data: {
+                    widgetId,
+                    kind: 'message',
+                    title: `Action ${approved ? 'Approved' : 'Denied'}`,
+                    body: displayData,
+                    state: approved ? 'submitted' : 'cancelled',
+                    display: 'collapsed',
+                    disabled: true,
+                    actions: [], // Clear actions to disable buttons in UI
+                },
+                meta: { agentId: context.state.agentId, threadId: context.state.threadId },
+            };
+            if (approved) {
+                // Re-emit the original event with approved status so the actual handler can run
+                yield {
+                    ...originalEvent,
+                    meta: {
+                        ...(originalEvent.meta || {}),
+                        approvalStatus: 'approved',
+                    },
+                };
+            }
+            else {
+                // Manually store the original event with denied status so it's recorded in history
+                // but NOT re-emitted to the pipeline (to avoid actual execution).
+                if (storage) {
+                    await storage.storeEvent({
+                        channelId: context.state.channelId,
+                        threadId: context.state.threadId,
+                        event: {
+                            ...originalEvent,
+                            meta: {
+                                ...(originalEvent.meta || {}),
+                                approvalStatus: 'denied',
+                            },
+                        },
+                    });
+                }
+                // Emit a failure result event for the denied action to clear the pending tool batch
+                yield {
+                    type: `${originalEvent.type}:result`,
+                    data: {
+                        success: false,
+                        error: 'Action denied by user.',
+                        stderr: 'Action denied by user.',
+                        output: 'Action denied by user.',
+                    },
+                    meta: originalEvent.meta,
+                };
+                yield {
+                    type: 'agent:output',
+                    data: { content: `Action \`${originalEvent.type}\` was denied.` },
+                    meta: { agentId: context.state.agentId },
+                };
+            }
+        });
+    },
+};
+export default approvalPlugin;

package/dist/tools/bash.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types.js';
+export declare const bashPlugin: Plugin;
+export default bashPlugin;