@adhdev/daemon-core 0.9.82-rc.24 → 0.9.82-rc.240

package/dist/providers/sdk/v1/types/common/index.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Shared types across provider categories.
+ *
+ * Extracted at build time into the Apache 2.0 npm package
+ * `@adhdev/provider-types`. External provider authors import from there;
+ * daemon-core imports from this file directly.
+ */
+export interface BooleanSettingDef {
+    type: 'boolean';
+    default: boolean;
+    public?: boolean;
+    label?: string;
+    description?: string;
+}
+export interface NumberSettingDef {
+    type: 'number';
+    default: number;
+    public?: boolean;
+    label?: string;
+    description?: string;
+    min?: number;
+    max?: number;
+}
+export interface StringSettingDef {
+    type: 'string';
+    default: string;
+    public?: boolean;
+    label?: string;
+    description?: string;
+}
+export interface SelectSettingDef {
+    type: 'select';
+    default: string;
+    options: ReadonlyArray<string | {
+        value: string;
+        label?: string;
+    }>;
+    public?: boolean;
+    label?: string;
+    description?: string;
+}
+export type SettingDef = BooleanSettingDef | NumberSettingDef | StringSettingDef | SelectSettingDef;
+export type SettingsDef = Readonly<Record<string, SettingDef>>;
+export interface CapabilityInputDef {
+    multipart?: boolean;
+    mediaTypes?: ReadonlyArray<'text' | 'image' | 'audio' | string>;
+    strategies?: ReadonlyArray<{
+        mediaType: string;
+        strategies: ReadonlyArray<string>;
+        native?: boolean;
+        degradation?: ReadonlyArray<string>;
+    }>;
+}
+export interface CapabilityOutputDef {
+    richContent?: boolean;
+    mediaTypes?: ReadonlyArray<string>;
+}
+export interface CapabilityControlsDef {
+    typedResults?: boolean;
+}
+export interface CapabilitiesDef {
+    input?: CapabilityInputDef;
+    output?: CapabilityOutputDef;
+    controls?: CapabilityControlsDef;
+}
+export interface EnvVarAuthDef {
+    type: 'env_var';
+    id: string;
+    name: string;
+    vars: ReadonlyArray<{
+        name: string;
+        description?: string;
+    }>;
+    link?: string;
+}
+export interface CliCommandAuthDef {
+    type: 'cli_command';
+    id: string;
+    name: string;
+    command: string;
+    link?: string;
+}
+export type AuthDef = EnvVarAuthDef | CliCommandAuthDef;
+export interface SpawnDef {
+    command: string;
+    args?: ReadonlyArray<string>;
+    shell?: boolean;
+    env?: Readonly<Record<string, string>>;
+}
+export interface TimeoutsDef {
+    /** Gap between writes before considering a chunk settled (ms). */
+    ptyFlush?: number;
+    /** Delay before sending an approval key (ms). */
+    dialogAccept?: number;
+    /** Window during which a freshly resolved modal is suppressed (ms). */
+    approvalCooldown?: number;
+    /** Fallback "still generating" assumption window (ms). */
+    generatingIdle?: number;
+    /** Grace before declaring generating→idle final (ms). */
+    idleFinish?: number;
+    /** Second-pass confirmation window (ms). */
+    idleFinishConfirm?: number;
+    /** PTY-quiet threshold before marking activity ended (ms). */
+    statusActivityHold?: number;
+    /** Hard upper bound on a single generation (ms). */
+    maxResponse?: number;
+    /** SIGTERM→SIGKILL window (ms). */
+    shutdownGrace?: number;
+    /** Post-write debounce (ms). */
+    outputSettle?: number;
+}
+export type StopStrategy = 'command' | 'ctrl_c' | 'signal';
+export type SessionIdFormat = 'uuid' | 'free' | 'string';
+export interface ResumeDef {
+    supported: boolean;
+    stopStrategy?: StopStrategy;
+    stopCommand?: string;
+    shutdownGraceMs?: number;
+    sessionIdFormat?: SessionIdFormat;
+    /** Args appended to spawn.args when starting a session under a daemon-issued id. `{{id}}` is replaced at launch. */
+    newSessionArgs?: ReadonlyArray<string>;
+    /** Args appended when resuming a specific session id. */
+    resumeSessionArgs?: ReadonlyArray<string>;
+    /** Args appended when "continue most recent" semantics are wanted. */
+    resumeArgs?: ReadonlyArray<string>;
+}
+export interface McpConfigDef {
+    mode: 'manual' | 'auto_import';
+    format?: string;
+    path?: string;
+    configPathCommand?: string;
+    serverName?: string;
+    requiresRestart?: boolean;
+    instructions?: string;
+    /** Template string used by daemon to render the actual config snippet at install time. */
+    template?: string;
+}
+export interface MeshCoordinatorDef {
+    supported: boolean;
+    mcpConfig?: McpConfigDef;
+    systemPromptInjection?: MeshCoordinatorSystemPromptInjectionDef;
+    delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolationDef;
+}
+export type MeshCoordinatorSystemPromptInjectionDef = {
+    mode: 'cli_arg';
+    flag: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    template: string;
+} | {
+    mode: 'context_file';
+    path: string;
+    wrapper?: string;
+} | {
+    mode: 'env_var';
+    name: string;
+};
+export interface MeshCoordinatorDelegatedWorkerIsolationDef {
+    env?: {
+        unset?: ReadonlyArray<string>;
+    };
+    args?: ReadonlyArray<MeshCoordinatorDelegatedWorkerArgRuleDef>;
+}
+export type MeshCoordinatorDelegatedWorkerArgRuleDef = {
+    mode: 'empty_mcp_config';
+    flag: string;
+    strictFlag?: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    key: string;
+    value: string;
+    dedupeKey?: string;
+};
+export interface CompatibilityEntryDef {
+    /** SemVer range against the agent's own version. Optional. */
+    ideVersion?: string;
+    /** Script subdirectory to load when this entry matches. e.g. "scripts/1.0". */
+    scriptDir: string;
+}
+export type ControlType = 'select' | 'action' | 'toggle';
+export interface ControlDef {
+    id: string;
+    type: ControlType;
+    label: string;
+    icon?: string;
+    placement?: string;
+    order?: number;
+    dynamic?: boolean;
+    hidden?: boolean;
+    options?: ReadonlyArray<unknown>;
+    listScript?: string;
+    setScript?: string;
+    invokeScript?: string;
+    readFrom?: string;
+    resultDisplay?: string;
+    defaultValue?: unknown;
+    confirmTitle?: string;
+    confirmMessage?: string;
+    confirmLabel?: string;
+}
+export type ProviderLifecycleStatus = 'Stable' | 'Beta' | 'Experimental' | 'Deprecated';

package/dist/providers/sdk/v1/validators/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validators — public surface.
+ */
+export { analyzeOverrideTaint, formatTaintResult, type TaintLevel, type TaintCategory, type TaintFinding, type TaintResult, } from './taint.js';
+export { validateCliProviderManifest, formatManifestValidationIssues, type ManifestValidationIssue, type ManifestValidationResult, } from './manifest.js';

package/dist/providers/sdk/v1/validators/manifest.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Manifest validators — runtime JSON Schema check for v1 provider manifests.
+ *
+ * The schemas live under `schemas/{category}/provider.schema.json` and are
+ * the authoritative contract for what a v1 manifest may contain. Daemon
+ * code that loads a manifest at install or boot time runs it through
+ * `validateCliProviderManifest()` first; failures are reported back to
+ * the caller with structured paths so manifest authors can locate the
+ * offending field without guessing.
+ *
+ * Validation lives in the SDK layer (not in provider-loader) so dashboards,
+ * registry workers, and the provider publish flow can all reuse the
+ * same code path and produce identical error messages.
+ */
+export interface ManifestValidationIssue {
+    /** JSON Pointer-style path into the manifest. Empty string for the root. */
+    path: string;
+    /** Schema-keyword that failed. */
+    keyword: string;
+    /** Human-readable explanation. */
+    message: string;
+    /** Allowed values when the failure is an `enum` / `const` / `additionalProperties`. */
+    allowed?: unknown;
+}
+export interface ManifestValidationResult {
+    ok: boolean;
+    issues: ManifestValidationIssue[];
+}
+/**
+ * Validate a CLI provider.v1.json manifest. Returns `{ ok: true, issues: [] }`
+ * on success and `{ ok: false, issues: [...] }` on failure with each issue
+ * pointing at the offending field. Never throws — manifest parse errors
+ * should be caught by the caller before this is called.
+ */
+export declare function validateCliProviderManifest(manifest: unknown): ManifestValidationResult;
+/**
+ * Render a list of validation issues as a single multi-line string,
+ * suitable for log lines or daemon command error fields.
+ */
+export declare function formatManifestValidationIssues(issues: ManifestValidationIssue[]): string;

package/dist/providers/sdk/v1/validators/taint.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Static taint analyzer for extended-tier override JS.
+ *
+ * Goal: classify the override JS shipped with an extended-tier provider into
+ * one of three risk tiers, so the dashboard + daemon trust prompt can
+ * surface accurate language to the operator instead of a single generic
+ * "this provider contains JS" warning.
+ *
+ *   - clean    : no flagged APIs at all. The override looks like pure string
+ *                manipulation. Still extended-tier, but the warning copy is
+ *                "this provider contains JS; nothing dangerous was detected".
+ *   - elevated : touches process / dynamic codegen / dynamic require / eval
+ *                / Function constructor / child_process. The warning copy is
+ *                explicit ("this provider can run shell commands / dynamically
+ *                load code").
+ *   - hostile  : combines elevated APIs with network egress, AND uses obvious
+ *                obfuscation (base64-decoded strings fed into Function / eval).
+ *                The publish endpoint should reject these.
+ *
+ * Implementation note: this is a *static* analyzer — string + light AST scan
+ * via Node's built-in parser. It is intentionally fail-loud: anything that
+ * looks suspicious is flagged. False positives are fine; this exists to gate
+ * the trust prompt, not to be a real sandbox. The real sandbox lives in
+ * Phase 5 (isolated-vm).
+ *
+ * Used by:
+ *   - `adhdev provider validate` (CLI tier classification)
+ *   - registry publish endpoint static-check
+ *   - daemon at provider-load time, to size the warning
+ */
+export type TaintLevel = 'clean' | 'elevated' | 'hostile';
+export interface TaintFinding {
+    /** What was found, e.g. "child_process.exec". */
+    api: string;
+    /** Coarse category. */
+    category: TaintCategory;
+    /** File the finding came from. */
+    file: string;
+    /** Line number (1-indexed) of the first character of the matched token. */
+    line: number;
+    /** The surrounding source excerpt, trimmed. */
+    excerpt: string;
+}
+export type TaintCategory = 'process-control' | 'shell-exec' | 'fs-write' | 'fs-read' | 'network' | 'dynamic-codegen' | 'dynamic-require' | 'obfuscation' | 'global-mutation';
+export interface TaintResult {
+    level: TaintLevel;
+    findings: TaintFinding[];
+    files: string[];
+}
+export declare function analyzeOverrideTaint(manifestPath: string): TaintResult;
+/** Format a result as a single CLI-friendly block. */
+export declare function formatTaintResult(result: TaintResult): string;

package/dist/providers/spec/adapter.d.ts

@@ -0,0 +1,52 @@
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+export type { PtyTransportFactory };
+export interface TerminalAdapterOpts {
+    binary: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    /** Coalesce screen snapshots: emit on_screen_changed at most this often. */
+    screenChangeDebounceMs?: number;
+    tickIntervalMs?: number;
+    transportFactory?: PtyTransportFactory;
+}
+export interface TerminalAdapterHandlers {
+    init?(info: {
+        pid: number;
+    }): void;
+    on_pty_data?(chunk: string): void;
+    on_screen_changed?(snapshot: string): void;
+    on_exit?(info: {
+        exitCode: number;
+    }): void;
+    tick?(): void;
+}
+export declare class TerminalAdapter {
+    private readonly opts;
+    private readonly handlers;
+    private rows;
+    private cols;
+    private readonly screenDebounceMs;
+    private readonly tickIntervalMs;
+    private readonly factory;
+    private screen;
+    private pty;
+    private screenTimer;
+    private tickTimer;
+    private lastScreen;
+    constructor(opts: TerminalAdapterOpts, handlers: TerminalAdapterHandlers);
+    start(): void;
+    resize(cols: number, rows: number): void;
+    snapshot(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
+    send_keys(text: string): void;
+    kill(): void;
+    private onChunk;
+    private computeScreen;
+    private stopTimers;
+}

package/dist/providers/spec/cli-adapter.d.ts

@@ -0,0 +1,102 @@
+import type { CliAdapter, CliAdapterStatus } from '../../cli-adapter-types.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import { type InteractivePromptResponse } from '../types/interactive-prompt.js';
+export declare class SpecCliAdapter implements CliAdapter {
+    readonly cliType: string;
+    readonly cliName: string;
+    readonly workingDir: string;
+    /**
+     * Marker the daemon's finalization gate checks: `getStatus()` returns
+     * `messages: []` by design here (chat history lives in the daemon's
+     * native-history pipeline, not the adapter). Without this flag,
+     * cli-provider-instance's `missing_final_assistant` gate would stall
+     * every turn until the 30s safety timeout because it expects the
+     * adapter to surface the final assistant message.
+     */
+    readonly chatMessagesOwnedExternally: true;
+    private driver;
+    /** Common spec fields the adapter reads, present in both v3 and v4. */
+    private spec;
+    private lastEvent;
+    private latestState;
+    private latestModal;
+    private statusCallback;
+    private ptyDataCallback;
+    private partialResponse;
+    private activeInteractivePrompt;
+    private interactivePromptTransport;
+    private claudeTuiPromptCaptureInFlight;
+    private jsonLineTail;
+    private exited;
+    private spawned;
+    private providerSessionId;
+    /** Wall clock at the moment spawn() ran. Used as the cutoff for
+     *  native-history file selection so a prior session's transcript
+     *  can't leak into this session before the agent has written its
+     *  own records. */
+    private spawnedAtMs;
+    /** Env vars the daemon set on the spawned child. Mesh coordinator
+     *  points hermes at a per-coordinator HERMES_HOME so the dashboard's
+     *  native-history reader needs that override to find the right
+     *  state.db; without it the reader sees ~/.hermes/state.db which
+     *  the coordinator-launched hermes never writes to. The choice to
+     *  redirect HERMES_HOME is a workaround for an unresolved hermes
+     *  upstream feature gap (see hermes-agent#23130 — runtime-supplied
+     *  MCP config), so this routing keeps the dashboard honest until
+     *  hermes ships a runtime MCP override. */
+    private spawnedEnv;
+    constructor(specPath: string, workingDir: string, cliArgs: string[], extraEnv: Record<string, string>, transportFactory?: PtyTransportFactory);
+    spawn(): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getStatus(): CliAdapterStatus;
+    private maybeRefreshNativeHistory;
+    getScriptParsedStatus(): unknown;
+    getPartialResponse(): string;
+    shutdown(): void;
+    cancel(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    setOnStatusChange(cb: () => void): void;
+    setOnPtyData(cb: (data: string) => void): void;
+    writeRaw(data: string): void;
+    resize(cols: number, rows: number): void;
+    resolveModal(buttonIndex: number): void;
+    resolveAction(data: unknown): Promise<void>;
+    setInteractivePromptResponse(response: InteractivePromptResponse): Promise<void>;
+    isApprovalRecentlyResolved(): boolean;
+    clearHistory(): void;
+    updateRuntimeSettings(): void;
+    setServerConn(): void;
+    /**
+     * Map an invokeScript(name, args) call onto a control_bar entry.
+     *
+     * scriptName is matched against control.id. The control's action.type
+     * drives the dispatch:
+     *
+     *   send_keys     → click_control                   (e.g. stop)
+     *   open_picker   → click_control then resolve when extract_choices
+     *                   surface; choice index comes from args.choiceIndex
+     *                   or args.choice (string label match), defaulting to 0
+     *   attach_image  → attach_image dispatch; expects args.blob (data url
+     *                   or base64) and args.mime
+     *
+     * Callers that pass an unknown control id get a { not_found } response.
+     * No control matched, no driver call — keeps the surface honest.
+     */
+    invokeScript(scriptName: string, args?: Record<string, unknown>): Promise<unknown>;
+    getDebugSnapshot(): unknown;
+    getRuntimeMetadata(): unknown;
+    updateRuntimeMeta(meta?: Record<string, unknown>): void;
+    refreshProviderDefinition(): void;
+    private handleEvent;
+    private detectInteractivePromptFromPtyChunk;
+    private readCurrentScreenSections;
+    private extractProviderSessionIdFromScreen;
+    private readClaudeScreenAssistantMessages;
+    private maybeCaptureClaudeTuiPrompt;
+    private readClaudeTuiHeaders;
+    private captureClaudeTuiPrompt;
+    getDebugState(): Record<string, any>;
+    getTraceState(limit?: number): Record<string, any>;
+    getProviderResolutionMeta(): Record<string, any>;
+}

package/dist/providers/spec/evaluator.d.ts

@@ -0,0 +1,23 @@
+import type { SectionDef, Condition, ExtractTitle, ExtractButtons } from './types.js';
+export interface ResolvedSection {
+    id: string;
+    fromLine: number;
+    toLine: number;
+    text: string;
+}
+export interface TraceEntry {
+    kind: 'section' | 'state_match' | 'state_skip' | 'modal' | 'control' | 'notification' | 'delegate';
+    text: string;
+}
+export declare function resolveSections(sectionsObj: Record<string, SectionDef>, lines: string[]): ResolvedSection[];
+export declare function sectionText(sections: ResolvedSection[], sectionId: string | undefined, fullScreen: string): string;
+export declare function evaluateCondition(cond: Condition, sections: ResolvedSection[], fullScreen: string, cursor: {
+    row: number;
+    col: number;
+} | undefined, prevLines: string[] | undefined, trace: TraceEntry[], stateId: string): boolean;
+export declare function extractTitle(rule: ExtractTitle, sections: ResolvedSection[], fullScreen: string): string | null;
+export declare function extractButtonsFromRule(rule: ExtractButtons, hay: string): {
+    index: number;
+    label: string;
+    key: string;
+}[];