oh-my-opencode-serverlocal 0.1.0

package/dist/multiplexer/cmux/session-lifecycle.d.ts

@@ -0,0 +1,92 @@
+import type { Multiplexer } from '../types';
+export interface CmuxSessionEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+            directory?: string;
+            sessionID?: string;
+        };
+        part?: {
+            sessionID?: string;
+        };
+        sessionID?: string;
+        status?: {
+            type: string;
+        };
+    };
+}
+interface BackgroundJobs {
+    deferIfRunning(session: string): boolean;
+    clearDeferredClose(session: string): void;
+}
+export interface CmuxSessionLifecycleOptions {
+    now?: () => number;
+    delay?: (milliseconds: number) => Promise<void>;
+    deferredRetryMs?: number;
+    deferredTtlMs?: number;
+    missingGraceMs?: number;
+    closeRetryMs?: number;
+    closeRetryTtlMs?: number;
+    closeRetryMaxAttempts?: number;
+    orphanCooldownMs?: number;
+    shutdownTimeoutMs?: number;
+    isServerRunning?: (url: string) => Promise<boolean>;
+    fetchStatuses?: () => Promise<Record<string, {
+        type: string;
+    }>>;
+}
+export declare class CmuxSessionLifecycle {
+    private readonly owner;
+    private readonly multiplexer;
+    private readonly resolveServerUrl;
+    private readonly defaultDirectory;
+    private readonly backgroundJobs?;
+    private readonly store;
+    private readonly policy;
+    private readonly now;
+    private readonly delay;
+    private readonly injectedDelay;
+    private readonly deferredRetryMs;
+    private readonly deferredTtlMs;
+    private readonly missingGraceMs;
+    private readonly closeRetryMs;
+    private readonly shutdownTimeoutMs;
+    private readonly serverCheck;
+    private readonly fetchStatuses;
+    private pollTimer?;
+    private polling;
+    private cleanupPromise?;
+    private disposed;
+    private spawnGeneration;
+    constructor(owner: string, multiplexer: Multiplexer, resolveServerUrl: () => string | null, defaultDirectory: string, backgroundJobs?: BackgroundJobs | undefined, options?: CmuxSessionLifecycleOptions);
+    onSessionCreated(event: CmuxSessionEvent): Promise<void>;
+    onSessionStatus(event: CmuxSessionEvent): Promise<void>;
+    onSessionDeleted(event: CmuxSessionEvent): Promise<void>;
+    closeSessionFromCoordinator(session: string): Promise<void>;
+    cleanup(): Promise<void>;
+    /** Runs one status pass; exposed for deterministic lifecycle tests. */
+    pollOnce(): Promise<void>;
+    private spawn;
+    private spawnOperation;
+    private deferSpawn;
+    private cancelDeferred;
+    private activity;
+    private requestClose;
+    private attemptClose;
+    private scheduleCooldown;
+    private poll;
+    private startPolling;
+    private updatePolling;
+    private runCleanup;
+    private attemptCloseWithoutTimer;
+    private adoptAndClose;
+    private closeLatePane;
+    private trackStalePane;
+    private eventSession;
+    private timer;
+    private loadStatuses;
+}
+export {};

package/dist/multiplexer/cmux/session-state.d.ts

@@ -0,0 +1,45 @@
+import type { PaneResult } from '../types';
+import type { CmuxCloseIntent } from './close-policy';
+export type CmuxSpawnState = 'known' | 'spawning' | 'attached' | 'failed';
+export type CmuxLifecycleState = 'active' | 'deleted' | 'orphaned';
+export interface CmuxDeferredSpawn {
+    deadline: number;
+    generation: number;
+    timer?: {
+        cancel(): void;
+    };
+}
+export interface CmuxSessionRecord {
+    session: string;
+    owner: string;
+    parent: string;
+    title: string;
+    directory: string;
+    paneId?: string;
+    spawnState: CmuxSpawnState;
+    lifecycle: CmuxLifecycleState;
+    attachedAt?: number;
+    lastActivityAt: number;
+    activityVersion: number;
+    idleConsecutive: number;
+    statusMissingSince?: number;
+    deferredSpawn?: CmuxDeferredSpawn;
+    closeIntent?: CmuxCloseIntent;
+    closeTimer?: {
+        cancel(): void;
+    };
+    spawnPromise?: Promise<PaneResult>;
+}
+export declare class CmuxSessionStore {
+    claimCreated(record: CmuxSessionRecord): boolean;
+    get(session: string): CmuxSessionRecord | undefined;
+    ownedBy(owner: string): CmuxSessionRecord[];
+    claimOrphans(owner: string, directory: string): CmuxSessionRecord[];
+    markAttached(session: string, paneId: string, now: number): void;
+    markActivity(session: string, now: number): void;
+    markDeleted(session: string): void;
+    markOrphaned(session: string): void;
+    removeAfterConfirmedClose(session: string): boolean;
+    removeWithoutPane(session: string): boolean;
+    resetForTests(): void;
+}

package/dist/multiplexer/factory.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Multiplexer factory - creates the appropriate multiplexer instance
+ */
+import type { MultiplexerConfig } from '../config/schema';
+import type { Multiplexer } from './types';
+/**
+ * Create a multiplexer instance based on config.
+ *
+ * Do not cache instances: tmux/zellij/herdr integrations may depend on
+ * per-process environment like TMUX_PANE/ZELLIJ/HERDR_PANE_ID, which should
+ * be captured fresh for each plugin context.
+ */
+export declare function getMultiplexer(config: MultiplexerConfig): Multiplexer | null;
+/**
+ * Start background availability check for a multiplexer
+ */
+export declare function startAvailabilityCheck(config: MultiplexerConfig): void;

package/dist/multiplexer/herdr/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Herdr multiplexer implementation
+ *
+ * Splits panes for sub-agent sessions in Herdr.
+ *
+ * Herdr is an agent-aware terminal multiplexer (workspaces → tabs → panes).
+ * Pane IDs use the format `w<workspace>:p<pane>`. The CLI outputs
+ * newline-delimited JSON; `pane split` returns a `pane_info` result whose
+ * `pane.pane_id` field is the new pane's ID.
+ *
+ * Environment detection: Herdr injects `HERDR_ENV=1` and `HERDR_PANE_ID`
+ * into every pane it manages.
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class HerdrMultiplexer implements Multiplexer {
+    readonly type: "herdr";
+    private binaryPath;
+    private hasChecked;
+    private readonly parentPaneId;
+    private layout;
+    private paneDirection;
+    private agentAreaPaneId;
+    private spawnMutex;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    private doSpawn;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    private runSplit;
+    private targetPaneArg;
+    private getBinary;
+}

package/dist/multiplexer/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Multiplexer module exports
+ */
+export type { CmuxClient, CommandRunner } from './cmux';
+export { CliCmuxClient, CmuxMultiplexer } from './cmux';
+export { getMultiplexer, startAvailabilityCheck, } from './factory';
+export { HerdrMultiplexer } from './herdr';
+export { MultiplexerSessionManager, TmuxSessionManager, } from './session-manager';
+export { TmuxMultiplexer } from './tmux';
+export type { Multiplexer, PaneResult } from './types';
+export { isServerRunning } from './types';
+export { ZellijMultiplexer } from './zellij';

package/dist/multiplexer/session-manager.d.ts

@@ -0,0 +1,69 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { MultiplexerConfig } from '../config/schema';
+import type { BackgroundJobStore } from '../utils/background-job-store';
+import { type CmuxSessionLifecycleOptions } from './cmux/session-lifecycle';
+type BackgroundJobReader = Pick<BackgroundJobStore, 'getState' | 'deferIfRunning' | 'clearDeferredClose'>;
+interface SessionEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+            directory?: string;
+            sessionID?: string;
+        };
+        part?: {
+            sessionID?: string;
+        };
+        sessionID?: string;
+        status?: {
+            type: string;
+        };
+    };
+}
+export declare function resetMultiplexerSessionManagerState(): void;
+export type MultiplexerSessionManagerOptions = CmuxSessionLifecycleOptions;
+/**
+ * Tracks child sessions and spawns/closes multiplexer panes for them.
+ *
+ * Uses session.status events for completion detection instead of polling,
+ * with polling kept as a fallback for reliability.
+ */
+export declare class MultiplexerSessionManager {
+    private readonly backgroundJobBoard?;
+    private instanceId;
+    private readonly resolveServerUrl;
+    private directory;
+    private multiplexer;
+    private sessions;
+    private knownSessions;
+    private spawningSessions;
+    private closingSessions;
+    private pollInterval?;
+    private enabled;
+    private cmuxLifecycle?;
+    constructor(ctx: PluginInput, config: MultiplexerConfig, backgroundJobBoard?: BackgroundJobReader | undefined, options?: MultiplexerSessionManagerOptions);
+    onSessionCreated(event: SessionEvent): Promise<void>;
+    onSessionStatus(event: SessionEvent): Promise<void>;
+    onSessionDeleted(event: SessionEvent): Promise<void>;
+    private startPolling;
+    private stopPolling;
+    private pollSessions;
+    private fetchSessionStatuses;
+    private closeSession;
+    private respawnIfKnown;
+    private isTrackedOrSpawning;
+    private updatePolling;
+    private getSessionId;
+    private backgroundJobState;
+    private shouldCloseNow;
+    closeSessionFromCoordinator(sessionId: string): Promise<void>;
+    cleanup(): Promise<void>;
+    cleanupOnInstanceDisposed(): Promise<void>;
+}
+/**
+ * @deprecated Use MultiplexerSessionManager instead
+ */
+export declare const TmuxSessionManager: typeof MultiplexerSessionManager;
+export {};

package/dist/multiplexer/shared.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared multiplexer infrastructure
+ *
+ * Functions used across tmux, zellij, and herdr backend adapters.
+ * Extracted to eliminate copy-paste duplication and prevent drift.
+ */
+export declare function quoteShellArg(value: string): string;
+/** Normalize Windows backslashes to / so sh -lc (MSYS2/Git Bash) doesn't treat them as escape chars. */
+export declare function normalizePathForShell(directory: string): string;
+export declare function buildOpencodeAttachCommand(sessionId: string, serverUrl: string, directory: string, executable?: string): string;
+export declare function resolveHostOpencodeBinary(options?: {
+    override?: string;
+    envOverride?: string;
+    execPath?: string;
+    argv0?: string;
+    pathExists?: (path: string) => boolean;
+}): string | null;
+export declare function findBinary(binaryName: string, options?: {
+    verify?: boolean;
+}): Promise<string | null>;
+export interface GracefulClosePaneOptions {
+    /** Backend-specific Ctrl+C command args (binary prepended by caller). */
+    ctrlC: string[];
+    /** Backend-specific close/kill command args (binary prepended by caller). */
+    close: string[];
+    /** Accept exit code 1 as success (zellij/herdr treat "already closed" as 1). */
+    acceptExitCode1?: boolean;
+    /** Return true for empty/unknown paneId instead of false (zellij/herdr behavior). */
+    emptyPaneReturnsTrue?: boolean;
+}
+export declare function gracefulClosePane(binary: string | null, paneId: string, options: GracefulClosePaneOptions): Promise<boolean>;

package/dist/multiplexer/tmux/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Tmux multiplexer implementation
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class TmuxMultiplexer implements Multiplexer {
+    readonly type: "tmux";
+    private binaryPath;
+    private hasChecked;
+    private storedLayout;
+    private storedMainPaneSize;
+    private targetPane;
+    private layoutTimer?;
+    private layoutGeneration;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(layout: MultiplexerLayout, mainPaneSize: number): Promise<void>;
+    private scheduleLayout;
+    private applyLayoutNow;
+    private runTmux;
+    private getBinary;
+    private targetArgs;
+}

package/dist/multiplexer/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Multiplexer abstraction layer
+ *
+ * Provides a unified interface for terminal multiplexers (tmux, zellij,
+ * herdr, etc.) to spawn and manage panes for child agent sessions.
+ */
+import type { MultiplexerConfig, MultiplexerLayout } from '../config/schema';
+export interface PaneResult {
+    success: boolean;
+    paneId?: string;
+    orphanPaneId?: string;
+    error?: 'unavailable' | 'not_found' | 'invalid_state' | 'hard';
+}
+/**
+ * Core multiplexer interface
+ * Implementations: TmuxMultiplexer, ZellijMultiplexer, HerdrMultiplexer,
+ * CmuxMultiplexer
+ */
+export interface Multiplexer {
+    readonly type: 'tmux' | 'zellij' | 'herdr' | 'cmux';
+    /**
+     * Check if the multiplexer binary is available on the system
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Check if currently running inside a multiplexer session
+     */
+    isInsideSession(): boolean;
+    /**
+     * Spawn a new pane running the given command
+     * @param sessionId - The OpenCode session ID to attach to
+     * @param description - Human-readable description for the pane
+     * @param serverUrl - The OpenCode server URL to attach to
+     * @param directory - The project directory to attach from
+     */
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    /**
+     * Close a pane by its ID
+     * @param paneId - The pane ID returned by spawnPane
+     * @returns true if successfully closed
+     */
+    closePane(paneId: string): Promise<boolean>;
+    /**
+     * Apply layout to rebalance panes
+     * @param layout - The layout type to apply
+     * @param mainPaneSize - Percentage for main pane (for main-* layouts)
+     */
+    applyLayout(layout: MultiplexerLayout, mainPaneSize: number): Promise<void>;
+}
+/**
+ * Factory function type for creating multiplexer instances
+ */
+export type MultiplexerFactory = (config: MultiplexerConfig) => Multiplexer;
+/**
+ * Server health check utility (shared across implementations)
+ */
+export declare function isServerRunning(serverUrl: string, timeoutMs?: number, maxAttempts?: number): Promise<boolean>;

package/dist/multiplexer/zellij/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Zellij multiplexer implementation
+ *
+ * Creates panes for sub-agent sessions in Zellij.
+ *
+ * The default mode creates a dedicated "opencode-agents" tab:
+ * - First sub-agent uses the default pane from new-tab
+ * - Subsequent sub-agents create new panes
+ * - User stays in their original tab
+ *
+ * The optional "current-tab" mode creates panes in the tab containing the
+ * parent OpenCode pane instead.
+ */
+import type { MultiplexerLayout, ZellijPaneMode } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class ZellijMultiplexer implements Multiplexer {
+    private readonly paneMode;
+    readonly type: "zellij";
+    private binaryPath;
+    private hasChecked;
+    private agentTabId;
+    private firstPaneId;
+    private firstPaneUsed;
+    private parentTabId;
+    private readonly parentPaneId;
+    private readonly paneDirection;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number, paneMode?: ZellijPaneMode);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    private createPaneInCurrentTab;
+    private createPaneInAgentTab;
+    private runInPane;
+    private ensureAgentTab;
+    private listPanesJson;
+    private getFirstPaneInTab;
+    private findTabByName;
+    private findTabByNameText;
+    private getCurrentTabId;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(_layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    private directionArgs;
+    private tabIdArgs;
+    private getParentTabId;
+    private findTabIdForPane;
+    private getBinary;
+}

package/dist/tools/acp-run.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+import { type AcpAgentsConfig } from '../config';
+export declare function createAcpRunTool(agents?: AcpAgentsConfig): ToolDefinition;

package/dist/tools/ast-grep/cli.d.ts

@@ -0,0 +1,15 @@
+import type { CliLanguage, SgResult } from './types';
+export interface RunOptions {
+    pattern: string;
+    lang: CliLanguage;
+    paths?: string[];
+    globs?: string[];
+    rewrite?: string;
+    context?: number;
+    updateAll?: boolean;
+}
+export declare function getAstGrepPath(): Promise<string | null>;
+export declare function startBackgroundInit(): void;
+export declare function runSg(options: RunOptions): Promise<SgResult>;
+export declare function isCliAvailable(): boolean;
+export declare function ensureCliAvailable(): Promise<boolean>;

package/dist/tools/ast-grep/constants.d.ts

@@ -0,0 +1,25 @@
+import { CLI_LANGUAGES } from './types';
+export declare function findSgCliPathSync(): string | null;
+export declare function getSgCliPath(): string;
+export declare function setSgCliPath(path: string): void;
+export { CLI_LANGUAGES };
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+export declare const DEFAULT_MAX_MATCHES = 500;
+export declare const LANG_EXTENSIONS: Record<string, string[]>;
+export interface EnvironmentCheckResult {
+    cli: {
+        available: boolean;
+        path: string;
+        error?: string;
+    };
+}
+/**
+ * Check if ast-grep CLI is available.
+ * Call this at startup to provide early feedback about missing dependencies.
+ */
+export declare function checkEnvironment(): EnvironmentCheckResult;
+/**
+ * Format environment check result as user-friendly message.
+ */
+export declare function formatEnvironmentCheck(result: EnvironmentCheckResult): string;

package/dist/tools/ast-grep/downloader.d.ts

@@ -0,0 +1,5 @@
+export declare function getCacheDir(): string;
+export declare function getBinaryName(): string;
+export declare function getCachedBinaryPath(): string | null;
+export declare function downloadAstGrep(version?: string): Promise<string | null>;
+export declare function ensureAstGrepBinary(): Promise<string | null>;

package/dist/tools/ast-grep/index.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+import { ast_grep_replace, ast_grep_search } from './tools';
+export declare const builtinTools: Record<string, ToolDefinition>;
+export { ensureCliAvailable, getAstGrepPath, isCliAvailable, startBackgroundInit, } from './cli';
+export type { EnvironmentCheckResult } from './constants';
+export { checkEnvironment, formatEnvironmentCheck } from './constants';
+export { ensureAstGrepBinary, getCacheDir, getCachedBinaryPath, } from './downloader';
+export type { CliLanguage, CliMatch, SgResult } from './types';
+export { CLI_LANGUAGES } from './types';
+export { ast_grep_replace, ast_grep_search };

package/dist/tools/ast-grep/tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+export declare const ast_grep_search: ToolDefinition;
+export declare const ast_grep_replace: ToolDefinition;

package/dist/tools/ast-grep/types.d.ts

@@ -0,0 +1,30 @@
+export declare const CLI_LANGUAGES: readonly ["bash", "c", "cpp", "csharp", "css", "elixir", "go", "haskell", "html", "java", "javascript", "json", "kotlin", "lua", "nix", "php", "python", "ruby", "rust", "scala", "solidity", "swift", "typescript", "tsx", "yaml"];
+export type CliLanguage = (typeof CLI_LANGUAGES)[number];
+export interface CliMatch {
+    file: string;
+    range: {
+        byteOffset: {
+            start: number;
+            end: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+    lines: string;
+    text: string;
+    replacement?: string;
+    language: string;
+}
+export interface SgResult {
+    matches: CliMatch[];
+    totalMatches: number;
+    truncated: boolean;
+    truncatedReason?: 'timeout' | 'max_output_bytes' | 'max_matches';
+    error?: string;
+}

package/dist/tools/ast-grep/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CliLanguage, SgResult } from './types';
+export declare function formatSearchResult(result: SgResult): string;
+export declare function formatReplaceResult(result: SgResult, isDryRun: boolean): string;
+export declare function getEmptyResultHint(pattern: string, lang: CliLanguage): string | null;

package/dist/tools/cancel-task.d.ts

@@ -0,0 +1,16 @@
+import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
+import type { BackgroundJobStore } from '../utils/background-job-store';
+interface CancelTaskToolOptions {
+    client: PluginInput['client'];
+    backgroundJobBoard: BackgroundJobStore;
+    shouldManageSession: (sessionID: string) => boolean;
+    abortTimeoutMs?: number;
+    verifyAbortMs?: number;
+    abortRetryIntervalMs?: number;
+    stableStoppedMs?: number;
+    deleteTimeoutMs?: number;
+    deleteVerifyMs?: number;
+    deleteStableStoppedMs?: number;
+}
+export declare function createCancelTaskTool(options: CancelTaskToolOptions): Record<string, ToolDefinition>;
+export {};

package/dist/tools/council.d.ts

@@ -0,0 +1,10 @@
+import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
+import type { CouncilManager } from '../council/council-manager';
+/**
+ * Creates the council_session tool for multi-LLM orchestration.
+ *
+ * This tool triggers a full council session: parallel councillors →
+ * formatted results returned to the council agent for synthesis.
+ * Available to the council agent.
+ */
+export declare function createCouncilTool(_ctx: PluginInput, councilManager: CouncilManager): Record<string, ToolDefinition>;

package/dist/tools/index.d.ts

@@ -0,0 +1,7 @@
+export { createAcpRunTool } from './acp-run';
+export { ast_grep_replace, ast_grep_search } from './ast-grep';
+export { createCancelTaskTool } from './cancel-task';
+export { createCouncilTool } from './council';
+export type { PresetManager } from './preset-manager';
+export { createPresetManager } from './preset-manager';
+export { createWebfetchTool } from './smartfetch';

package/dist/tools/preset-manager.d.ts

@@ -0,0 +1,26 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+/**
+ * Creates a preset manager for the /preset slash command.
+ *
+ * Stores the requested runtime preset in plugin memory and updates the
+ * plugin-facing TUI snapshot. It deliberately does not call OpenCode's
+ * client.config.update() or instance.dispose() from command hooks because
+ * OpenCode continues the same command into the prompt loop after
+ * command.execute.before, which can break the active conversation while
+ * the agent registry is changing.
+ */
+export declare function createPresetManager(ctx: PluginInput, config: PluginConfig): {
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    registerCommand: (opencodeConfig: Record<string, unknown>) => void;
+};
+export type PresetManager = ReturnType<typeof createPresetManager>;

package/dist/tools/smartfetch/binary.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryFetch } from './types';
+export declare function buildBinaryResultMessage(fetchResult: BinaryFetch, savedPath?: string): string;
+export declare function saveBinary(binaryDir: string, data: Uint8Array, contentType: string, filename?: string): Promise<string>;

package/dist/tools/smartfetch/cache.d.ts

@@ -0,0 +1,6 @@
+import { LRUCache } from 'lru-cache';
+import type { FetchResult } from './types';
+export declare const CACHE: LRUCache<string, FetchResult, unknown>;
+export declare function buildCacheKey(url: string, extractMain: boolean, preferLlmsTxt: 'auto' | 'always' | 'never', saveBinary: boolean): string;
+export declare function cacheFetchResult(fetchResult: FetchResult, extractMain: boolean, preferLlmsTxt: 'auto' | 'always' | 'never', saveBinary: boolean): void;
+export declare function isInvalidLlmsResult(fetchResult: FetchResult | undefined): boolean;

package/dist/tools/smartfetch/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const DOCS_HOST_SUFFIXES: string[];
+export declare const DOCS_HOST_PREFIXES: string[];
+export declare const MAX_REDIRECTS = 10;
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const MAX_BINARY_DOWNLOAD_BYTES: number;
+export declare const DEFAULT_TIMEOUT_SECONDS = 30;
+export declare const MAX_TIMEOUT_SECONDS = 120;
+export declare const MAX_LLMS_PROBE_TIMEOUT_MS = 8000;
+export declare const MAX_MODEL_CONTENT_CHARS = 100000;
+export declare const DEFAULT_ACCEPT_LANGUAGE = "en;q=0.8,*;q=0.5";
+export declare const BINARY_PREFIXES: string[];
+export declare const WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";

package/dist/tools/smartfetch/index.d.ts

@@ -0,0 +1,3 @@
+export { WEBFETCH_DESCRIPTION } from './constants';
+export { createWebfetchTool } from './tool';
+export type { BinaryFetch, CachedFetch, FetchResult, SmartfetchOptions, } from './types';