@deepseek-harness-tui/dsh-tui 0.8.6 → 0.8.8

package/lib/types/dsh-adapter/subagents.js

@@ -0,0 +1,204 @@
+/** Unified subagent activity domain model used by the adapter and every view. */
+const MAX_OUTPUT_EVENTS = 160;
+const MAX_OUTPUT_LINES = 160;
+export class SubagentActivityStore {
+    states = new Map();
+    sessionToAgent = new Map();
+    listeners = new Set();
+    commitLine(agentId, kind, text) {
+        const state = this.states.get(agentId);
+        if (!state)
+            return;
+        this.pushLine(state, { kind, text, at: Date.now(), settled: true });
+    }
+    pushLine(state, line) {
+        state.outputEvents.push(line);
+        if (state.outputEvents.length > MAX_OUTPUT_EVENTS)
+            state.outputEvents.splice(0, state.outputEvents.length - MAX_OUTPUT_EVENTS);
+        state.output = state.outputEvents.map(entry => entry.text);
+        if (state.output.length > MAX_OUTPUT_LINES)
+            state.output.splice(0, state.output.length - MAX_OUTPUT_LINES);
+    }
+    onSpawned(agentId, provider = 'subagent', model, info = {}) {
+        const existing = this.states.get(agentId);
+        const state = existing ?? {
+            agentId,
+            runId: info.runId ?? agentId,
+            description: info.description ?? 'Subagent task',
+            provider,
+            model: model ?? info.model ?? provider,
+            effort: info.effort,
+            status: 'running',
+            startedAt: info.startedAt ?? Date.now(),
+            local: info.local,
+            parentSessionId: info.parentSessionId,
+            sessionId: info.sessionId,
+            output: [],
+            outputEvents: [],
+            toolCalls: [],
+        };
+        if (existing) {
+            Object.assign(existing, info, { provider, model: model ?? existing.model, status: existing.status === 'completed' ? existing.status : 'running' });
+        }
+        else {
+            this.states.set(agentId, state);
+        }
+        this.notify();
+    }
+    linkSession(agentId, session) {
+        if (session !== undefined && session !== null)
+            this.sessionToAgent.set(session, agentId);
+        const state = this.states.get(agentId);
+        if (state && typeof session === 'string')
+            state.sessionId = session;
+    }
+    getSubagentIdBySession(session) { return this.sessionToAgent.get(session); }
+    appendOutput(agentId, text, kind = 'text') {
+        const state = this.states.get(agentId);
+        if (!state || !text)
+            return;
+        const last = state.outputEvents[state.outputEvents.length - 1];
+        if (last === undefined || last.settled || last.kind !== kind) {
+            if (last !== undefined && !last.settled)
+                last.settled = true;
+            this.pushLine(state, { kind, text, at: Date.now(), settled: false });
+            this.notify();
+            return;
+        }
+        last.text += text;
+        const parts = last.text.split('\n');
+        if (parts.length > 1) {
+            last.text = parts[0];
+            last.settled = true;
+            for (const middle of parts.slice(1, -1)) {
+                this.pushLine(state, { kind, text: middle, at: Date.now(), settled: true });
+            }
+            const tail = parts[parts.length - 1] ?? '';
+            if (tail)
+                this.pushLine(state, { kind, text: tail, at: Date.now(), settled: false });
+        }
+        else {
+            state.output = state.outputEvents.map(entry => entry.text);
+        }
+        this.notify();
+    }
+    /** Mark the streaming tail line complete (run settlement). */
+    flushOutput(agentId) {
+        const state = this.states.get(agentId);
+        const last = state?.outputEvents[state.outputEvents.length - 1];
+        if (last !== undefined && !last.settled) {
+            last.settled = true;
+            this.notify();
+        }
+    }
+    onSessionEvent(agentId, event) {
+        if (!event || typeof event !== 'object')
+            return;
+        const ev = event;
+        const data = ev.data ?? {};
+        switch (ev.type) {
+            case 'assistant/chunk': {
+                const chunk = data.chunk ?? {};
+                if (chunk.type === 'text-delta' && chunk.text)
+                    this.appendOutput(agentId, chunk.text, 'text');
+                else if (chunk.type === 'reasoning-delta' && chunk.text)
+                    this.appendOutput(agentId, chunk.text, 'thinking');
+                else if (chunk.type === 'usage' && chunk.usage)
+                    this.setTokens(agentId, chunk.usage);
+                break;
+            }
+            case 'assistant/message': {
+                if (data.usage)
+                    this.setTokens(agentId, data.usage);
+                break;
+            }
+            case 'tool/call': {
+                this.recordTool(agentId, { id: data.callId, name: data.name, status: 'running', startedAt: Date.now(), argsPreview: data.arguments });
+                break;
+            }
+            case 'tool/result': {
+                const callId = data?.message?.source?.callId;
+                const state = this.states.get(agentId);
+                const tool = callId !== undefined ? state?.toolCalls.find(entry => entry.id === callId) : undefined;
+                if (tool) {
+                    tool.status = data.error !== undefined ? 'failed' : 'completed';
+                    tool.endedAt = Date.now();
+                    if (data.error !== undefined)
+                        tool.error = String(data.error);
+                    else {
+                        const block = data.message?.content?.[0];
+                        tool.resultPreview = block !== undefined && block.type === 'tool-result'
+                            ? this.previewOf(block.content)
+                            : undefined;
+                    }
+                    this.notify();
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    /** Merge partial updates (model discovery, session id) into one subagent. */
+    patch(agentId, partial) {
+        const state = this.states.get(agentId);
+        if (!state)
+            return;
+        Object.assign(state, partial);
+        this.notify();
+    }
+    /** One-line preview of a tool-result content block (text or item list). */
+    previewOf(content) {
+        const text = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content.map(item => (typeof item === 'object' && item !== null && 'text' in item ? String(item.text ?? '') : '')).join(' ')
+                : '';
+        const flat = text.replace(/\s+/g, ' ').trim();
+        return flat ? (flat.length > 80 ? `${flat.slice(0, 80)}…` : flat) : undefined;
+    }
+    recordTool(agentId, input) {
+        const state = this.states.get(agentId);
+        if (!state || !input.name)
+            return;
+        const current = input.id ? state.toolCalls.find(tool => tool.id === input.id) : undefined;
+        if (current)
+            Object.assign(current, input);
+        else
+            state.toolCalls.push({ name: input.name, status: input.status ?? 'completed', startedAt: input.startedAt ?? Date.now(), ...input });
+        this.notify();
+    }
+    setTokens(agentId, usage) {
+        const state = this.states.get(agentId);
+        if (!state)
+            return;
+        const input = usage.input ?? usage.inputTokens;
+        const output = usage.output ?? usage.outputTokens;
+        if (input === undefined && output === undefined && usage.total === undefined)
+            return;
+        state.tokens = { ...state.tokens, input, output, total: usage.total ?? ((input ?? 0) + (output ?? 0) || undefined) };
+        this.notify();
+    }
+    onCompleted(agentId, summary, stopReason = 'completed') { this.finish(agentId, 'completed', stopReason, summary); }
+    onFailed(agentId, error) { this.finish(agentId, 'failed', error, undefined); }
+    onCancelled(agentId, reason = 'cancelled', summary) { this.finish(agentId, 'cancelled', reason, summary); }
+    finish(agentId, status, reason, summary) {
+        const state = this.states.get(agentId);
+        if (!state || (state.status !== 'running' && state.status !== 'starting'))
+            return;
+        state.status = status;
+        state.completedAt = Date.now();
+        state.endedAt = state.completedAt;
+        state.stopReason = reason;
+        if (summary)
+            state.summary = summary;
+        if (status === 'failed')
+            state.error = reason;
+        this.notify();
+    }
+    snapshot() { return Array.from(this.states.values()).map(state => ({ ...state, output: [...state.output], outputEvents: [...state.outputEvents], toolCalls: state.toolCalls.map(tool => ({ ...tool })), tokens: state.tokens ? { ...state.tokens } : undefined })); }
+    get(agentId) { return this.snapshot().find(state => state.agentId === agentId); }
+    subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+    notify() { for (const listener of this.listeners)
+        listener(); }
+}

package/lib/types/herdr.d.ts

@@ -0,0 +1,28 @@
+import { type ExecFileNoThrowResult } from './utils/execFileNoThrow.js';
+interface HerdrChannel {
+    readonly working: boolean;
+    subscribe(listener: () => void): () => void;
+}
+interface BlockingStore {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): unknown | null;
+}
+type RunCommand = (file: string, args: readonly string[]) => Promise<ExecFileNoThrowResult>;
+export interface HerdrIntegration {
+    settled(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface HerdrIntegrationOptions {
+    readonly channel: HerdrChannel;
+    readonly questions: BlockingStore;
+    readonly approvals: BlockingStore;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly run?: RunCommand;
+    readonly reportTimeoutMs?: number;
+    readonly releaseTimeoutMs?: number;
+    readonly retryDelaysMs?: readonly number[];
+}
+/** Report this TUI's lifecycle to the owning Herdr pane when Herdr launches it. */
+export declare function attachHerdrIntegration(options: HerdrIntegrationOptions): HerdrIntegration | undefined;
+export {};
+//# sourceMappingURL=herdr.d.ts.map

package/lib/types/herdr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"herdr.d.ts","sourceRoot":"","sources":["../../src/herdr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAQxF,UAAU,YAAY;IACpB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;CAC5C;AAED,UAAU,aAAa;IACrB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;IAC3C,WAAW,IAAI,OAAO,GAAG,IAAI,CAAA;CAC9B;AAED,KAAK,UAAU,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAE3F,MAAM,WAAW,gBAAgB;IAC/B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC3C;AAkBD,mFAAmF;AACnF,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,GAAG,SAAS,CAgH9B"}

package/lib/types/herdr.js

@@ -0,0 +1,133 @@
+import { execFileNoThrow } from './utils/execFileNoThrow.js';
+const REPORT_TIMEOUT_MS = 2000;
+const RELEASE_TIMEOUT_MS = 500;
+const RETRY_DELAYS_MS = [100, 250, 500, 1000];
+function withTimeout(promise, timeoutMs) {
+    return new Promise(resolve => {
+        const timer = setTimeout(() => resolve(undefined), timeoutMs);
+        void promise.then(value => {
+            clearTimeout(timer);
+            resolve(value);
+        }, () => {
+            clearTimeout(timer);
+            resolve(undefined);
+        });
+    });
+}
+/** Report this TUI's lifecycle to the owning Herdr pane when Herdr launches it. */
+export function attachHerdrIntegration(options) {
+    const env = options.env ?? process.env;
+    const executable = env.HERDR_BIN_PATH?.trim();
+    const paneId = env.HERDR_PANE_ID?.trim();
+    if (env.HERDR_ENV !== '1' || !executable || !paneId)
+        return undefined;
+    const reportTimeoutMs = options.reportTimeoutMs ?? REPORT_TIMEOUT_MS;
+    const releaseTimeoutMs = options.releaseTimeoutMs ?? RELEASE_TIMEOUT_MS;
+    const retryDelays = options.retryDelaysMs ?? RETRY_DELAYS_MS;
+    const run = options.run ?? ((file, args) => execFileNoThrow(file, args, { timeout: reportTimeoutMs }));
+    const runSafely = (args) => {
+        try {
+            return Promise.resolve(run(executable, args));
+        }
+        catch {
+            return Promise.reject(new Error('Herdr command could not be started'));
+        }
+    };
+    let sequence = 0;
+    let lastConfirmedReport = '';
+    let disposed = false;
+    let running = false;
+    let wakeDelay;
+    let settledPromise = Promise.resolve();
+    const computeState = () => {
+        const blocked = options.questions.getSnapshot() !== null || options.approvals.getSnapshot() !== null;
+        return { state: blocked ? 'blocked' : options.channel.working ? 'working' : 'idle', blocked };
+    };
+    const waitForRetry = (delayMs) => new Promise(resolve => {
+        const timer = setTimeout(() => {
+            wakeDelay = undefined;
+            resolve();
+        }, delayMs);
+        wakeDelay = () => {
+            clearTimeout(timer);
+            wakeDelay = undefined;
+            resolve();
+        };
+    });
+    const processQueue = async () => {
+        let failedState = '';
+        let attempts = 0;
+        try {
+            while (!disposed) {
+                const { state, blocked } = computeState();
+                if (state === lastConfirmedReport)
+                    break;
+                if (state !== failedState) {
+                    failedState = state;
+                    attempts = 0;
+                }
+                attempts += 1;
+                const result = await withTimeout(runSafely([
+                    'pane', 'report-agent', paneId,
+                    '--source', 'custom:dsh-tui',
+                    '--agent', 'dsh-tui',
+                    '--state', state,
+                    ...(blocked ? ['--message', 'Waiting for user input'] : []),
+                    '--seq', String(++sequence),
+                ]), reportTimeoutMs);
+                if (disposed)
+                    break;
+                if (result?.code === 0) {
+                    lastConfirmedReport = state;
+                    failedState = '';
+                    attempts = 0;
+                    continue;
+                }
+                if (attempts > retryDelays.length)
+                    break;
+                await waitForRetry(retryDelays[attempts - 1] ?? 0);
+            }
+        }
+        finally {
+            running = false;
+        }
+    };
+    const report = () => {
+        if (disposed)
+            return;
+        if (running) {
+            wakeDelay?.();
+            return;
+        }
+        if (computeState().state === lastConfirmedReport)
+            return;
+        running = true;
+        settledPromise = processQueue();
+    };
+    const unsubscribes = [
+        options.channel.subscribe(report),
+        options.questions.subscribe(report),
+        options.approvals.subscribe(report),
+    ];
+    report();
+    let disposePromise;
+    return {
+        settled: () => settledPromise,
+        dispose: () => {
+            if (disposePromise !== undefined)
+                return disposePromise;
+            disposed = true;
+            wakeDelay?.();
+            for (const unsubscribe of unsubscribes)
+                unsubscribe();
+            const release = runSafely([
+                'pane', 'release-agent', paneId,
+                '--source', 'custom:dsh-tui',
+                '--agent', 'dsh-tui',
+                '--seq', String(++sequence),
+            ]);
+            disposePromise = withTimeout(release, releaseTimeoutMs).then(() => undefined);
+            return disposePromise;
+        },
+    };
+}