agent-afk 5.1.0 → 5.2.0

package/dist/browser/types.d.ts

@@ -0,0 +1,139 @@
+export interface BrowserObservation {
+    observationId: string;
+    url: string;
+    title: string;
+    textSummary: string;
+    interactive: InteractiveElement[];
+    status: BrowserPageStatus;
+    warnings: string[];
+    screenshotPath: string | null;
+    capturedAt: string;
+}
+export interface BrowserPageStatus {
+    httpStatus: number | null;
+    loadingState: 'idle' | 'loading' | 'navigating';
+    hasDialog: boolean;
+    consoleErrors: number;
+}
+export interface InteractiveElement {
+    id: string;
+    role: string;
+    label: string;
+    kind: string | null;
+    value: string | null;
+    state: InteractiveElementState;
+    bbox: BoundingBox;
+    selector?: string;
+}
+export interface InteractiveElementState {
+    disabled: boolean;
+    checked?: boolean;
+    selected?: boolean;
+    expanded?: boolean;
+}
+export interface BoundingBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export type Target = {
+    kind: 'semantic';
+    text: string;
+    role?: string;
+} | {
+    kind: 'element_id';
+    elementId: string;
+} | {
+    kind: 'selector';
+    selector: string;
+};
+export type WaitForOption = 'load' | 'domcontentloaded' | 'networkidle';
+export type ActAction = 'click' | 'fill' | 'press' | 'select' | 'hover' | 'scroll_to' | 'wait_for';
+export interface OpenInput {
+    sessionId: string;
+    url: string;
+    waitFor?: WaitForOption;
+    screenshot?: boolean;
+    timeoutMs?: number;
+}
+export interface ObserveInput {
+    sessionId: string;
+    screenshot?: boolean;
+    includeHidden?: boolean;
+    maxElements?: number;
+}
+export interface ActInput {
+    sessionId: string;
+    action: ActAction;
+    target: Target;
+    value?: string;
+    timeoutMs?: number;
+    screenshot?: boolean;
+}
+export interface ScreenshotInput {
+    sessionId: string;
+    target?: Target;
+    fullPage?: boolean;
+}
+export interface ExtractInput {
+    sessionId: string;
+    schema: Record<string, unknown>;
+    instruction?: string;
+    scopeSelector?: string;
+}
+export interface CloseInput {
+    sessionId: string;
+}
+export interface RenderInput {
+    url: string;
+    timeoutMs?: number;
+    waitFor?: WaitForOption;
+    signal?: AbortSignal;
+}
+export interface RenderResult {
+    html: string;
+    finalUrl: string;
+    httpStatus: number | null;
+}
+export interface ScreenshotResult {
+    path: string;
+    bytes: number;
+    width: number;
+    height: number;
+    dataBase64: string;
+    mediaType: 'image/png';
+}
+export interface ExtractResult {
+    data: unknown;
+    warnings?: string[];
+}
+export interface AmbiguousTarget {
+    outcome: 'ambiguous_target';
+    query: {
+        text: string;
+        role?: string;
+    };
+    candidates: InteractiveElement[];
+}
+export interface BlockedByPolicy {
+    outcome: 'blocked_by_policy';
+    url: string;
+    reason: string;
+}
+export interface BrowserProviderState {
+    active: boolean;
+    url: string | null;
+    title: string | null;
+    lastAction: string | null;
+    lastActionAt: string | null;
+    openTabs: number;
+}
+export interface BrowserConfig {
+    headless: boolean;
+    allowedDomains: readonly string[];
+    blockedDomains: readonly string[];
+    domSnapshots: boolean;
+    backend: 'playwright';
+    configPath: string | null;
+}

package/dist/browser/witness.d.ts

@@ -0,0 +1,11 @@
+export declare function browserSidecarDir(sessionId: string): string;
+export declare function screenshotsDir(sessionId: string): string;
+export declare function domSnapshotsDir(sessionId: string): string;
+export declare function writeScreenshotSidecar(sessionId: string, buffer: Buffer, tool: 'browser_open' | 'browser_observe' | 'browser_act' | 'browser_screenshot' | 'browser_extract'): Promise<{
+    path: string;
+    bytes: number;
+}>;
+export declare function writeDomSnapshotSidecar(sessionId: string, html: string): Promise<{
+    path: string;
+    bytes: number;
+}>;

package/dist/changelog.d.ts

@@ -0,0 +1,13 @@
+export interface CommitEntry {
+    hash: string;
+    subject: string;
+    category: string;
+}
+export declare function parseCommits(repoRoot: string): CommitEntry[];
+export declare function formatEntries(commits: CommitEntry[], options?: {
+    includeHash?: boolean;
+}): string;
+export declare function getExistingUnreleased(changelog: string): string;
+export declare function updateAndStampChangelog(repoRoot: string, newEntries: string, version: string, date: string): void;
+export declare function updateChangelog(repoRoot: string, newEntries: string): void;
+export declare function stampRelease(repoRoot: string, version: string, date: string): void;

package/dist/cli/_lib/capture-mode.d.ts

@@ -0,0 +1,8 @@
+export declare function detectCaptureMode(env?: NodeJS.ProcessEnv): boolean;
+export declare function detectBell(env?: NodeJS.ProcessEnv): boolean;
+export declare function detectReducedMotion(env?: NodeJS.ProcessEnv): boolean;
+export declare function detectCaretBlink(env?: NodeJS.ProcessEnv): boolean;
+export declare function ringBellIfEnabled(stream: {
+    write(s: string): unknown;
+    isTTY?: boolean;
+}, env?: NodeJS.ProcessEnv): void;

package/dist/cli/_lib/commit-block.d.ts

@@ -0,0 +1,4 @@
+export interface BlockCommitter {
+    commitAbove(text: string): void;
+}
+export declare function commitBlockAbove(compositor: BlockCommitter, lines: readonly string[]): void;

package/dist/cli/_lib/commit-coordinator.d.ts

@@ -0,0 +1,13 @@
+export type CommitAnchor = 'before-content' | 'after-content' | `after-subagent:${string}`;
+export interface CommitBatch {
+    anchor: CommitAnchor;
+    commits: Array<() => void>;
+}
+export declare class CommitCoordinator {
+    private readonly beforeContent;
+    private readonly afterSubagent;
+    private readonly afterContent;
+    schedule(batch: CommitBatch): void;
+    drainSubagent(id: string): void;
+    flushAll(streamingMarkdownFlush?: () => Promise<void>): Promise<void>;
+}

package/dist/cli/_lib/dedup-line-writer.d.ts

@@ -0,0 +1,5 @@
+import type { Writer } from '../slash/types.js';
+export interface DedupingLineWriter extends Writer {
+    flush(): void;
+}
+export declare function makeDedupingLineWriter(inner: Writer, maxRepeat?: number): DedupingLineWriter;

package/dist/cli/_lib/overlay-composer.d.ts

@@ -0,0 +1,18 @@
+export interface OverlaySlot {
+    readonly key: string;
+    render(): string;
+}
+export interface OverlaySink {
+    setOverlay(text: string): void;
+}
+export declare class OverlayComposer {
+    private readonly sink;
+    private readonly order;
+    private readonly slots;
+    private dirty;
+    constructor(sink: OverlaySink, order: readonly string[]);
+    register(slot: OverlaySlot): void;
+    markDirty(key: string): void;
+    flush(): void;
+    invalidate(): void;
+}

package/dist/cli/_lib/sanitize.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeSchemaString(s: string, maxLen?: number): string;

package/dist/cli/_lib/stream-renderer-contexts.d.ts

@@ -0,0 +1,43 @@
+import type { OrchestratorCtx } from './stream-renderer-orchestrator.js';
+import type { SubagentCtx } from './stream-renderer-subagent.js';
+import type { ProgressEvent } from '../../agent/types.js';
+import type { TerminalCompositor } from '../terminal-compositor.js';
+import type { OverlayComposer } from './overlay-composer.js';
+import type { ToolLane } from '../commands/interactive/tool-lane.js';
+import type { ThinkingLane } from '../commands/interactive/thinking-lane.js';
+import type { StreamingMarkdownRenderer } from '../markdown-stream.js';
+import type { Writer } from '../slash/types.js';
+import type { StageTrackerState } from '../commands/interactive/loop-stage.js';
+import type { CommitCoordinator } from './commit-coordinator.js';
+import type { SourceState } from './stream-renderer-source.js';
+export declare function makeOrchestratorCtx(args: {
+    out: Writer;
+    isTTY: boolean;
+    compositor: TerminalCompositor | null;
+    overlayComposer: OverlayComposer | null;
+    toolLane: ToolLane;
+    thinkingLane: ThinkingLane;
+    thinkingMode: 'off' | 'summary' | 'live';
+    streamingMarkdown: {
+        current: StreamingMarkdownRenderer | null;
+    };
+    coordinator: CommitCoordinator;
+    stageTracker?: StageTrackerState;
+    activeSkillName?: string;
+    lastProgressByTask: Map<string, ProgressEvent>;
+}): OrchestratorCtx;
+export declare function makeSubagentCtx(args: {
+    isTTY: boolean;
+    compositor: TerminalCompositor | null;
+    toolLane: ToolLane;
+    out: Writer;
+    streamingMarkdown: Map<string, StreamingMarkdownRenderer>;
+    thinkingMode: 'off' | 'summary' | 'live';
+    orchestratorCtx: OrchestratorCtx;
+}): SubagentCtx;
+export declare function resolveParentSyntheticId(args: {
+    parentId: string | undefined;
+    sources: Map<string, SourceState>;
+    toolLane: ToolLane;
+    sourceId: string;
+}): string | undefined;

package/dist/cli/_lib/stream-renderer-lifecycle.d.ts

@@ -0,0 +1,33 @@
+import type { TerminalCompositor } from '../terminal-compositor.js';
+import { OverlayComposer } from './overlay-composer.js';
+import { createStageTracker } from '../commands/interactive/loop-stage.js';
+import type { SourceState } from './stream-renderer-source.js';
+import type { ToolLane } from '../commands/interactive/tool-lane.js';
+import type { ThinkingLane } from '../commands/interactive/thinking-lane.js';
+import type { StreamingMarkdownRenderer } from '../markdown-stream.js';
+import type { Writer } from '../slash/types.js';
+import type { ProgressEvent } from '../../agent/types.js';
+export interface LifecycleContext {
+    compositor: TerminalCompositor | null;
+    overlayComposer: OverlayComposer | null;
+    stageTracker: ReturnType<typeof createStageTracker>;
+    thinkingLane: ThinkingLane;
+    toolLane: ToolLane;
+    streamingMarkdownRef: {
+        current: StreamingMarkdownRenderer | null;
+    };
+    lastProgressByTask: Map<string, ProgressEvent>;
+    thinkingMode: 'off' | 'summary' | 'live';
+    out: Writer;
+    isTTY: boolean;
+    sources: Map<string, SourceState>;
+    disposed: boolean;
+    pauseTickInterval: ReturnType<typeof setInterval> | null;
+    resizeUnsub: (() => void) | null;
+}
+export declare function registerOverlaySlots(overlayComposer: OverlayComposer, ctx: Readonly<Pick<LifecycleContext, 'stageTracker' | 'thinkingMode' | 'thinkingLane' | 'streamingMarkdownRef' | 'toolLane' | 'lastProgressByTask'>> & {
+    getInterrupting: () => boolean;
+}): void;
+export declare function formatInterruptAffordance(interrupting: boolean): string;
+export declare function subscribeToResize(overlayComposer: OverlayComposer, disposed: boolean): () => void;
+export declare function checkPauseAnnotations(ctx: LifecycleContext): boolean;

package/dist/cli/_lib/stream-renderer-orchestrator-emit.d.ts

@@ -0,0 +1,10 @@
+import type { SourceState } from './stream-renderer-source.js';
+import type { Writer } from '../slash/types.js';
+import type { CardSpec } from '../render.js';
+import type { OrchestratorCtx } from './stream-renderer-orchestrator.js';
+export declare function emitPanel(spec: CardSpec, source: SourceState, ctx: OrchestratorCtx): void;
+export declare function commitThinkingPhase(source: SourceState, ctx: OrchestratorCtx): void;
+export declare function finalizeOrchestrator(source: SourceState, ctx: OrchestratorCtx): void;
+export declare function emitMarkdown(text: string, out: Writer): void;
+export declare function emitErrorBox(err: Error, out: Writer): void;
+export declare function flushToolLaneToScrollback(ctx: OrchestratorCtx): void;

package/dist/cli/_lib/stream-renderer-orchestrator.d.ts

@@ -0,0 +1,30 @@
+import type { OutputEvent, ProgressEvent } from '../../agent/types.js';
+import type { SourceState } from './stream-renderer-source.js';
+import type { Writer } from '../slash/types.js';
+import type { TerminalCompositor } from '../terminal-compositor.js';
+import type { ToolLane } from '../commands/interactive/tool-lane.js';
+import type { ThinkingLane } from '../commands/interactive/thinking-lane.js';
+import { StreamingMarkdownRenderer } from '../markdown-stream.js';
+import type { CommitCoordinator } from './commit-coordinator.js';
+import type { OverlayComposer } from './overlay-composer.js';
+import { type StageTrackerState } from '../commands/interactive/loop-stage.js';
+export { emitPanel, finalizeOrchestrator, emitMarkdown, emitErrorBox, flushToolLaneToScrollback, } from './stream-renderer-orchestrator-emit.js';
+export interface OrchestratorCtx {
+    out: Writer;
+    isTTY: boolean;
+    compositor: TerminalCompositor | null;
+    overlayComposer?: OverlayComposer | null;
+    toolLane: ToolLane;
+    thinkingLane: ThinkingLane;
+    thinkingMode?: 'off' | 'summary' | 'live';
+    streamingMarkdown: {
+        current: StreamingMarkdownRenderer | null;
+    };
+    stageTracker?: StageTrackerState;
+    activeSkillName?: string;
+    skillBadgeEmitted?: boolean;
+    coordinator?: CommitCoordinator;
+    lastProgressByTask: Map<string, ProgressEvent>;
+}
+export declare function handleOrchestratorEvent(event: OutputEvent, source: SourceState, ctx: OrchestratorCtx): void;
+export declare function setComposedOverlay(ctx: OrchestratorCtx): void;

package/dist/cli/_lib/stream-renderer-source.d.ts

@@ -0,0 +1,27 @@
+import type { ResponseMetadata, ToolResultChunk } from '../../agent/types/message-types.js';
+import { ThinkingLane } from '../commands/interactive/thinking-lane.js';
+declare const ORCHESTRATOR_SOURCE_KEY = "__main__";
+interface SourceState {
+    agentType?: string;
+    syntheticAgentToolUseId?: string;
+    startedAt: number;
+    stats: {
+        tokens: number;
+        toolUses: number;
+        progressReportedToolUses?: number;
+    };
+    contentBuffer: string;
+    currentTextEntryId?: string;
+    done: boolean;
+    responseMetadata?: ResponseMetadata;
+    errored: boolean;
+    lastEventAt: number;
+    pauseAnnotation?: string;
+    stalledTicks: number;
+    thinkingLane?: ThinkingLane;
+    thinkingPhaseStartedAt?: number;
+}
+declare function freshSourceState(agentType: string | undefined): SourceState;
+declare function syntheticResult(content: string, isError: boolean): ToolResultChunk;
+declare function formatDoneSummary(source: SourceState): string;
+export { ORCHESTRATOR_SOURCE_KEY, type SourceState, freshSourceState, syntheticResult, formatDoneSummary, };

package/dist/cli/_lib/stream-renderer-subagent-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { SourceState } from './stream-renderer-source.js';
+import type { SubagentCtx } from './stream-renderer-subagent.js';
+export declare function extractLatestThinkingClause(buffer: string, maxChars: number): string;
+export declare function emitSubagentTextLines(text: string, ctx: SubagentCtx): void;
+export declare function formatSubagentTextLines(text: string): string[];
+export declare function synthesizeAgentEntry(sourceId: string, source: SourceState, ctx: SubagentCtx, agentContext?: string): void;

package/dist/cli/_lib/stream-renderer-subagent.d.ts

@@ -0,0 +1,22 @@
+import type { OutputEvent } from '../../agent/types.js';
+import type { SourceState } from './stream-renderer-source.js';
+import type { TerminalCompositor } from '../terminal-compositor.js';
+import type { ToolLane } from '../commands/interactive/tool-lane.js';
+import type { Writer } from '../slash/types.js';
+import type { CardSpec } from '../render.js';
+import { StreamingMarkdownRenderer } from '../markdown-stream.js';
+import type { OrchestratorCtx } from './stream-renderer-orchestrator.js';
+import { extractLatestThinkingClause, synthesizeAgentEntry } from './stream-renderer-subagent-helpers.js';
+export interface SubagentCtx {
+    isTTY: boolean;
+    compositor: TerminalCompositor | null;
+    toolLane: ToolLane;
+    out: Writer;
+    streamingMarkdown: Map<string, StreamingMarkdownRenderer>;
+    thinkingMode: 'off' | 'summary' | 'live';
+    orchestratorCtx?: OrchestratorCtx;
+}
+export declare function handleSubagentEvent(event: OutputEvent, sourceId: string, source: SourceState, ctx: SubagentCtx): void;
+export declare function emitSubagentPanel(spec: CardSpec, _sourceId: string, source: SourceState, ctx: SubagentCtx): void;
+export declare function finalizeSubagent(_sourceId: string, source: SourceState, ctx: SubagentCtx): void;
+export { extractLatestThinkingClause, synthesizeAgentEntry };

package/dist/cli/_lib/stream-renderer.d.ts

@@ -0,0 +1,68 @@
+import type { OutputEvent, SubagentProgressMeta } from '../../agent/types.js';
+import type { Message } from '../../agent/types/message-types.js';
+import type { Writer } from '../slash/types.js';
+import { TerminalCompositor } from '../terminal-compositor.js';
+import type { IHistoryRing } from '../input/types.js';
+import type { AutocompleteState } from '../input/autocomplete-state.js';
+export interface StreamRendererOptions {
+    out: Writer;
+    thinkingMode?: 'off' | 'summary' | 'live';
+    verbose?: boolean;
+    onCancel?: () => void;
+    onBackground?: () => void;
+    forceNonTty?: boolean;
+    activeSkillName?: string;
+    history?: IHistoryRing;
+    autocompleteState?: AutocompleteState;
+    promptText?: string;
+    scrollRegion?: {
+        withFullScrollRegion<T>(fn: () => T): T;
+        getExtraRows(): number;
+    };
+    captureMode?: boolean;
+    reducedMotion?: boolean;
+    compositor?: TerminalCompositor;
+    onStageChange?: (stage: import('../commands/interactive/loop-stage.js').LoopStage) => void;
+}
+export declare class StreamRenderer {
+    private readonly out;
+    private readonly thinkingMode;
+    private readonly isTTY;
+    private readonly captureMode;
+    private readonly reducedMotion;
+    private readonly onCancel;
+    private readonly onBackground;
+    private readonly activeSkillName;
+    private readonly history;
+    private readonly autocompleteState;
+    private readonly promptText;
+    private readonly scrollRegion;
+    private readonly onStageChange;
+    private ownsCompositor;
+    private borrowedCompositor;
+    private priorOnCancel;
+    private interrupting;
+    private readonly coordinator;
+    private compositor;
+    private overlayComposer;
+    private streamingMarkdownRef;
+    private toolLane;
+    private thinkingLane;
+    private stageTracker;
+    private sources;
+    private subagentMarkdown;
+    private lastProgressByTask;
+    private disposed;
+    private pauseTickInterval;
+    private resizeUnsub;
+    readonly sink: (event: OutputEvent, meta?: SubagentProgressMeta) => void;
+    constructor(opts: StreamRendererOptions);
+    arm(): Promise<void>;
+    getCompositor(): TerminalCompositor | null;
+    setInterrupting(active: boolean): void;
+    private buildOrchestratorCtx;
+    process(event: OutputEvent, meta?: SubagentProgressMeta): void;
+    dispose(): Promise<void>;
+    private checkPauseAnnotations;
+}
+export type { Message };

package/dist/cli/_lib/testing/virtual-screen.d.ts

@@ -0,0 +1,54 @@
+export declare class VirtualScreen {
+    readonly cols: number;
+    readonly rows: number;
+    private grid;
+    private cursorRow;
+    private cursorCol;
+    private pendingWrap;
+    private scrollTop;
+    private scrollBottom;
+    private cursorHidden;
+    private bellCount;
+    private oscSequences;
+    private scrollback;
+    private parserState;
+    private csiParams;
+    private csiPrivatePrefix;
+    private oscBuffer;
+    private utf8Accum;
+    constructor(cols?: number, rows?: number);
+    private makeGrid;
+    private clampRow;
+    private clampCol;
+    write(data: string | Uint8Array): void;
+    private processByte;
+    private processGroundByte;
+    private processEscByte;
+    private processCsiByte;
+    private dispatchCsi;
+    private normalizeCsiParams;
+    private processOscByte;
+    private processUtf8Byte;
+    private putChar;
+    private lineFeed;
+    private scrollRegionUp;
+    private eraseCursorToEndOfLine;
+    private eraseStartOfLineToCursor;
+    private eraseEntireLine;
+    private eraseCursorToEndOfScreen;
+    private eraseStartOfScreenToCursor;
+    private eraseEntireScreen;
+    visibleLines(): string[];
+    lineAt(row: number): string;
+    scrollbackLines(): string[];
+    screenText(): string;
+    get cursor(): {
+        row: number;
+        col: number;
+    };
+    isCursorHidden(): boolean;
+    getBellCount(): number;
+    getOscSequences(): string[];
+    getPendingWrap(): boolean;
+    reset(): void;
+}

package/dist/cli/afk-mode-toggle.d.ts

@@ -0,0 +1,2 @@
+import type { SlashContext } from './slash/types.js';
+export declare function toggleAfkMode(ctx: SlashContext, desired?: boolean): Promise<void>;

package/dist/cli/auth-wizard.d.ts

@@ -0,0 +1,4 @@
+import { upsertEnvVar } from '../utils/envFile.js';
+export { upsertEnvVar };
+export declare function promptToken(): Promise<string>;
+export declare function runAuthWizard(token?: string): Promise<void>;

package/dist/cli/background/types.d.ts

@@ -0,0 +1,8 @@
+import type { BackgroundJob } from '../../agent/background-registry.js';
+export type BackgroundItem = {
+    kind: 'subagent';
+    job: BackgroundJob;
+};
+export declare function itemId(item: BackgroundItem): string;
+export declare function itemStartedAt(item: BackgroundItem): number;
+export declare function itemIsRunning(item: BackgroundItem): boolean;

package/dist/cli/background-status-bar.d.ts

@@ -0,0 +1,37 @@
+import type { BackgroundAgentRegistry, BackgroundJob } from '../agent/background-registry.js';
+export interface BackgroundStatusBarOptions {
+    stream?: NodeJS.WriteStream;
+    throttleMs?: number;
+    getAdjacentRows?: () => number;
+}
+export declare class BackgroundStatusBar {
+    private readonly stream;
+    private readonly registry;
+    private readonly throttleMs;
+    private started;
+    private lastRepaint;
+    private spinnerIndex;
+    private spinnerInterval;
+    private resizeUnsub;
+    private resizeImmediateUnsub;
+    private registryStartedHandler;
+    private registrySettledHandler;
+    private rowCount;
+    private lastPaintStartRow;
+    private preResizeStartRow;
+    private preResizeRowCount;
+    private onRowCountChange?;
+    private readonly getAdjacentRows;
+    constructor(registry?: BackgroundAgentRegistry, opts?: BackgroundStatusBarOptions);
+    setRowCountChangeHandler(handler: (rows: number) => void): void;
+    start(): void;
+    stop(): void;
+    private resetGeometry;
+    private scheduleRepaint;
+    redraw(): void;
+    private repaint;
+    private clearRows;
+    private clearPreResizeRows;
+    private formatItemLine;
+    formatJobLine(job: BackgroundJob): string;
+}

package/dist/cli/clipboard.d.ts

@@ -0,0 +1,7 @@
+interface ClipboardTool {
+    cmd: string;
+    args: string[];
+}
+export declare function clipboardToolsFor(platform: NodeJS.Platform): ClipboardTool[];
+export declare function copyToClipboard(text: string, platform?: NodeJS.Platform): boolean;
+export {};

package/dist/cli/color-config.d.ts

@@ -0,0 +1 @@
+export declare function configureColor(): void;

package/dist/cli/commands/bg.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerBgCommand(program: Command): void;

package/dist/cli/commands/browser.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import { type McpConfigFile } from '../../agent/mcp/config-loader.js';
+import type { McpServerConfig } from '../../agent/mcp/types.js';
+export declare const CHROME_DEVTOOLS_SERVER_NAME = "chrome-devtools";
+declare const VALID_CHANNELS: readonly ["stable", "beta", "canary", "dev"];
+type ChromeChannel = (typeof VALID_CHANNELS)[number];
+export declare function buildChromeDevtoolsEntry(channel?: ChromeChannel): McpServerConfig;
+export declare function readMcpConfigFile(path: string): McpConfigFile;
+export declare function writeMcpConfigFileAtomic(path: string, cfg: McpConfigFile): void;
+export declare function registerBrowserCommand(program: Command): void;
+export {};

package/dist/cli/commands/chat.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerChatCommand(program: Command): void;

package/dist/cli/commands/completion.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerCompletionCommand(program: Command): void;

package/dist/cli/commands/config-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerConfigCommand(program: Command): void;

package/dist/cli/commands/daemon.d.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import type { TaskCompletionDetails, TelemetryRecord } from '../../agent/daemon/scheduler.js';
+import type { AgentConfig, AgentModelInput } from '../../agent/types.js';
+import { AgentSession } from '../../agent/session.js';
+export interface BuildDaemonSessionFactoryOpts {
+    model: AgentModelInput;
+    apiKey?: string;
+    baseUrl?: string;
+    openaiBaseUrl?: string;
+    cwd?: string;
+}
+export declare function buildDaemonSessionFactory(opts: BuildDaemonSessionFactoryOpts): (config: AgentConfig) => AgentSession;
+export declare function formatTaskCompletion(record: TelemetryRecord, details?: TaskCompletionDetails): string;
+export declare function registerDaemonCommand(program: Command): void;