@adhdev/daemon-core 0.9.82-rc.21 → 0.9.82-rc.210

package/src/commands/cli-manager.ts

@@ -18,13 +18,14 @@ import { loadConfig } from '../config/config.js';
 import { loadState, saveState } from '../config/state-store.js';
 import { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
 import { appendRecentActivity } from '../config/recent-activity.js';
+import { unregisterMeshCoordinator } from '../mesh/coordinator-registry.js';
 import { upsertSavedProviderSession } from '../config/saved-sessions.js';
 import { buildLegacyModelModeSummaryMetadata, normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
 import { CliProviderInstance } from '../providers/cli-provider-instance.js';
 import { AcpProviderInstance } from '../providers/acp-provider-instance.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
-import { normalizeInputEnvelope, type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
+import { normalizeInputEnvelope, type MeshCoordinatorDelegatedWorkerIsolation, type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
 import { assertProviderSupportsDeclaredInput, assertTextOnlyInput } from '../providers/provider-input-support.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
@@ -80,6 +81,114 @@ export interface CliManagerDeps {
 
 type CommandResult = { success: boolean;[key: string]: unknown };
 
+const BUSY_AGENT_STATUSES = new Set(['generating', 'running', 'streaming', 'starting', 'busy', 'waiting', 'waiting_approval', 'long_generating']);
+const ZERO_MESSAGE_STARTING_SEND_WAIT_MS = 2_000;
+
+function normalizeAgentStatus(value: unknown): string {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+function hasNonEmptyModalButtons(activeModal: unknown): boolean {
+    const buttons = (activeModal as any)?.buttons;
+    return Array.isArray(buttons) && buttons.some((button) => String(button || '').trim().length > 0);
+}
+
+function hasAdapterPendingResponse(adapter: any): boolean {
+    if (adapter?.isWaitingForResponse === true) return true;
+    if (adapter?.currentTurnScope) return true;
+    try {
+        if (typeof adapter?.isProcessing === 'function' && adapter.isProcessing()) return true;
+    } catch { /* defensive: send guard should not fail on diagnostics */ }
+    try {
+        const partial = typeof adapter?.getPartialResponse === 'function' ? adapter.getPartialResponse() : '';
+        if (typeof partial === 'string' && partial.trim()) return true;
+    } catch { /* defensive: missing partial means no pending evidence */ }
+    return false;
+}
+
+function countMessages(value: unknown): number {
+    return Array.isArray(value) ? value.length : 0;
+}
+
+function hasFinalAssistantMessage(value: unknown): boolean {
+    const messages = Array.isArray(value) ? value : [];
+    const last = messages[messages.length - 1] as any;
+    if (!last || last.role !== 'assistant') return false;
+    if (last.bubbleState === 'streaming') return false;
+    if (last.meta?.streaming === true) return false;
+    return typeof last.content === 'string' && last.content.trim().length > 0;
+}
+
+function hasZeroMessageStartingLaunch(adapter: any): boolean {
+    const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+    const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
+        ? adapter.getScriptParsedStatus()
+        : {};
+    const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (adapterRawStatus !== 'starting') return false;
+    if (parsedRawStatus && parsedRawStatus !== 'starting' && parsedRawStatus !== 'generating') return false;
+    if (hasNonEmptyModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    if (countMessages(adapterStatus?.messages) > 0 || countMessages(parsedStatus?.messages) > 0) return false;
+    return !hasAdapterPendingResponse(adapter);
+}
+
+function hasCompletedStartingLaunch(adapter: any): boolean {
+    const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+    const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+    if (adapterRawStatus !== 'starting') return false;
+    if (hasAdapterPendingResponse(adapter)) return false;
+
+    const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
+        ? adapter.getScriptParsedStatus()
+        : {};
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (parsedRawStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return hasFinalAssistantMessage(parsedStatus?.messages);
+}
+
+function shouldSuppressStaleParsedBusyStatus(adapterStatus: string, parsedStatus: any, adapter: any): boolean {
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
+    if (adapterStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return !hasAdapterPendingResponse(adapter);
+}
+
+function getEffectiveAgentSendStatus(adapter: any): string {
+    const adapterStatus = normalizeAgentStatus(adapter?.getStatus?.({ allowParse: false })?.status ?? adapter?.getStatus?.()?.status);
+    if (adapterStatus === 'starting' && hasCompletedStartingLaunch(adapter)) return 'idle';
+    if (adapterStatus && adapterStatus !== 'idle') return adapterStatus;
+    if (adapterStatus !== 'idle') return adapterStatus;
+
+    if (typeof adapter?.getScriptParsedStatus !== 'function') return adapterStatus;
+    try {
+        const parsedStatus = adapter.getScriptParsedStatus();
+        const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+        if (BUSY_AGENT_STATUSES.has(parsedRawStatus) && !shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapter)) {
+            return parsedRawStatus;
+        }
+    } catch {
+        return adapterStatus;
+    }
+    return adapterStatus;
+}
+
+async function waitForZeroMessageStartingLaunch(adapter: any): Promise<boolean> {
+    try {
+        if (!hasZeroMessageStartingLaunch(adapter)) return false;
+    } catch {
+        return false;
+    }
+    await new Promise(resolve => setTimeout(resolve, ZERO_MESSAGE_STARTING_SEND_WAIT_MS));
+    try {
+        return hasZeroMessageStartingLaunch(adapter);
+    } catch {
+        return false;
+    }
+}
+
 export interface CliTransportFactoryParams {
     runtimeId: string;
     providerType: string;
@@ -138,18 +247,19 @@ type CliStartOptions = {
     extraEnv?: Record<string, string>;
 };
 
-const COORDINATOR_DELEGATED_ENV_UNSETS: Record<string, string> = {
-    ADHDEV_INLINE_MESH: '',
-    ADHDEV_MCP_TRANSPORT: '',
-    ADHDEV_MESH_ID: '',
-    HERMES_EPHEMERAL_SYSTEM_PROMPT: '',
-};
+const DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS = [
+    'ADHDEV_INLINE_MESH',
+    'ADHDEV_MCP_TRANSPORT',
+    'ADHDEV_MESH_ID',
+    'HERMES_EPHEMERAL_SYSTEM_PROMPT',
+] as const;
 
 export interface CoordinatorDelegatedCliLaunchOptionsInput {
     cliType: string;
     workspace: string;
     cliArgs?: string[];
     env?: Record<string, string>;
+    isolation?: MeshCoordinatorDelegatedWorkerIsolation;
 }
 
 export interface CoordinatorDelegatedCliLaunchOptions {
@@ -161,6 +271,21 @@ function hasCliArg(args: string[], flag: string): boolean {
     return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
 
+function hasConfigOverride(args: string[], key: string): boolean {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const next = args[index + 1];
+        if ((arg === '-c' || arg === '--config') && typeof next === 'string') {
+            if (next === key || next.startsWith(`${key}=`) || next.startsWith(`${key}.`)) return true;
+        }
+        if (arg.startsWith('--config=')) {
+            const value = arg.slice('--config='.length);
+            if (value === key || value.startsWith(`${key}=`) || value.startsWith(`${key}.`)) return true;
+        }
+    }
+    return false;
+}
+
 function ensureEmptyDelegatedMcpConfig(workspace: string): string {
     const baseDir = path.join(os.tmpdir(), 'adhdev-delegated-agent-empty-mcp');
     mkdirSync(baseDir, { recursive: true });
@@ -173,12 +298,31 @@ function ensureEmptyDelegatedMcpConfig(workspace: string): string {
 export function buildCoordinatorDelegatedCliLaunchOptions(
     input: CoordinatorDelegatedCliLaunchOptionsInput,
 ): CoordinatorDelegatedCliLaunchOptions {
-    const cliType = String(input.cliType || '').trim();
     const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
-    const env: Record<string, string> = { ...(input.env || {}), ...COORDINATOR_DELEGATED_ENV_UNSETS };
+    const env: Record<string, string> = { ...(input.env || {}) };
+    const envUnsets = new Set<string>(DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS);
+    for (const key of input.isolation?.env?.unset || []) {
+        if (typeof key === 'string' && key.trim()) envUnsets.add(key.trim());
+    }
+    for (const key of envUnsets) env[key] = '';
 
-    if (cliType === 'claude-cli' && !hasCliArg(cliArgs, '--mcp-config')) {
-        cliArgs.unshift('--mcp-config', ensureEmptyDelegatedMcpConfig(input.workspace));
+    for (const rule of input.isolation?.args || []) {
+        if (!rule || typeof rule !== 'object') continue;
+        if (rule.mode === 'empty_mcp_config') {
+            if (rule.flag && !hasCliArg(cliArgs, rule.flag)) {
+                cliArgs.unshift(rule.flag, ensureEmptyDelegatedMcpConfig(input.workspace));
+            }
+            if (rule.strictFlag && !hasCliArg(cliArgs, rule.strictFlag)) {
+                cliArgs.unshift(rule.strictFlag);
+            }
+            continue;
+        }
+        if (rule.mode === 'config_override') {
+            const key = String(rule.dedupeKey || rule.key || '').trim();
+            const flag = String(rule.flag || '').trim();
+            if (!key || !flag || hasConfigOverride(cliArgs, key)) continue;
+            cliArgs.unshift(flag, `${rule.key}=${rule.value}`);
+        }
     }
 
     return { cliArgs, env };
@@ -255,10 +399,14 @@ function detectExplicitProviderSessionId(
 
     const subcommands = resume?.sessionIdFromSubcommand;
     if (Array.isArray(subcommands) && subcommands.length > 0) {
+        const hasResumeSubcommand = args.some((arg) => subcommands.includes(arg));
         const subcommandSessionId = readSubcommandSessionId(args, subcommands);
         if (subcommandSessionId) {
             return { providerSessionId: subcommandSessionId, launchMode: 'resume' };
         }
+        if (hasResumeSubcommand) {
+            return { launchMode: 'resume' };
+        }
     }
 
     return { launchMode: 'manual' };
@@ -292,6 +440,12 @@ export function resolveCliSessionBinding(
             launchMode: explicit.launchMode,
         };
     }
+    if (explicit.launchMode === 'resume') {
+        return {
+            cliArgs: baseArgs,
+            launchMode: 'resume',
+        };
+    }
     if (explicit.launchMode === 'manual' && hasArg(baseArgs || [], ['--session-id'])) {
         return {
             cliArgs: baseArgs,
@@ -435,7 +589,9 @@ export class DaemonCliManager {
                 providerSessionId,
                 attachExisting,
             );
-            return new ProviderCliAdapter(resolvedProvider as CliProviderModule, workingDir, cliArgs, extraEnv || {}, transportFactory);
+            const adapter = new ProviderCliAdapter(resolvedProvider as CliProviderModule, workingDir, cliArgs, extraEnv || {}, transportFactory);
+            if (providerSessionId) adapter.updateRuntimeMeta({ providerSessionId });
+            return adapter;
         }
 
         throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
@@ -457,6 +613,7 @@ export class DaemonCliManager {
                             this.deps.removeAgentTracking(key);
                             sessionRegistry?.unregisterByInstanceKey(key);
                             instanceManager?.removeInstance(key);
+                            unregisterMeshCoordinator(key);
                             LOG.info('CLI', `🧹 Auto-cleaned ${status.status} CLI: ${cliType}`);
                             this.deps.onStatusChange();
                         }
@@ -516,6 +673,17 @@ export class DaemonCliManager {
                 transport: 'pty',
                 adapterKey: key,
                 instanceKey: key,
+                // attachExisting === true means we're restoring an already-spawned
+                // hosted runtime after a daemon restart, not starting a fresh PTY.
+                // The real spawn time is in the past and we don't have it on the
+                // restored descriptor; pinning spawnedAtMs to Date.now() in that
+                // case would push the native-history session-floor cutoff past
+                // every existing transcript file, so the agy/hermes/claude reader
+                // would return null even though the transcript on disk is fresh.
+                // 0 disables the floor for this session — recent_window_ms in the
+                // spec still bounds how far back we look. Fresh launches still
+                // get a proper floor so prior-session leak protection holds.
+                spawnedAtMs: attachExisting ? 0 : Date.now(),
             });
         } catch (spawnErr: any) {
             LOG.error('CLI', `[${cliType}] Spawn failed: ${spawnErr?.message}`);
@@ -783,6 +951,7 @@ export class DaemonCliManager {
             this.deps.removeAgentTracking(key);
             this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
             this.deps.getInstanceManager()?.removeInstance(key);
+            unregisterMeshCoordinator(key);
             LOG.info('CLI', `🛑 Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
             this.deps.onStatusChange();
         } else {
@@ -792,6 +961,7 @@ export class DaemonCliManager {
                 this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
                 im.removeInstance(key);
                 this.deps.removeAgentTracking(key);
+                unregisterMeshCoordinator(key);
                 LOG.warn('CLI', `🧹 Force-removed orphan entry: ${key}`);
                 this.deps.onStatusChange();
             }
@@ -955,6 +1125,8 @@ export class DaemonCliManager {
                 const launchSource = resolved.source;
                 if (!cliType) throw new Error('cliType required');
 
+                const providerType = this.providerLoader.resolveAlias(cliType);
+                const provLookup = this.providerLoader.getMeta(providerType) as ProviderModule | undefined;
                 const settingsOverride = args?.settings && typeof args.settings === 'object' ? args.settings : undefined;
                 const delegatedLaunch = settingsOverride?.launchedByCoordinator === true
                     ? buildCoordinatorDelegatedCliLaunchOptions({
@@ -962,8 +1134,28 @@ export class DaemonCliManager {
                         workspace: dir,
                         cliArgs: args?.cliArgs,
                         env: args?.env,
+                        isolation: provLookup?.meshCoordinator?.delegatedWorkerIsolation,
                     })
                     : null;
+                // Untrusted-provider gate: an external source that ships JS
+                // hooks needs explicit user confirmation before its first
+                // launch. Dashboards add `confirmExternalUntrusted: true` to
+                // the launch args after showing the trust modal. Without
+                // that ack we refuse to spawn and tell the caller why.
+                const provMeta = provLookup as any;
+                const provTrust = provMeta?._sourceTrust;
+                if (provTrust === 'external-untrusted' && args?.confirmExternalUntrusted !== true) {
+                    return {
+                        success: false,
+                        error: 'untrusted_external_provider',
+                        provider: {
+                            type: provLookup?.type ?? cliType,
+                            sourceName: provMeta?._sourceName ?? null,
+                            trust: provTrust,
+                        },
+                        hint: 'Resend launch_cli with confirmExternalUntrusted=true after the user explicitly approves running JavaScript from this 3rd-party source.',
+                    };
+                }
                 const started = await this.startSession(
                     cliType,
                     dir,
@@ -1030,6 +1222,45 @@ export class DaemonCliManager {
                 this.deps.onStatusChange();
                 return { success: true, id: found.key, mode };
             }
+            case 'record_provider_pty': {
+                const cliType = args?.type || args?.cliType;
+                if (!cliType) {
+                    return { success: false, error: '`type` (provider type) is required', code: 'MISSING_TYPE' };
+                }
+                const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId : '';
+                const dir = args?.dir || '';
+                const found = (targetSessionId ? this.findAdapterBySessionId(targetSessionId) : null)
+                    || this.findAdapter(cliType, { instanceKey: targetSessionId, dir });
+                if (!found) {
+                    return {
+                        success: false,
+                        error: `No running ${cliType} session. Launch one first (adhdev launch ${cliType}) or pass --target-session-id.`,
+                        code: 'NO_RUNNING_SESSION',
+                    };
+                }
+                const instance = this.deps.getInstanceManager()?.getInstance(found.key);
+                if (!(instance instanceof CliProviderInstance)) {
+                    return { success: false, error: 'CLI instance not available', code: 'CLI_INSTANCE_NOT_FOUND' };
+                }
+                const adapter = instance.getAdapter();
+                if (!adapter || typeof (adapter as any).getAccumulatedRawBuffer !== 'function') {
+                    return { success: false, error: 'Adapter does not expose PTY buffer', code: 'ADAPTER_NOT_RECORDABLE' };
+                }
+                const buffer = (adapter as any).getAccumulatedRawBuffer() as { text: string; droppedChars: number };
+                const maxBytes = Number(args?.maxBytes) > 0 ? Number(args.maxBytes) : 262144;
+                const truncated = buffer.text.length > maxBytes;
+                const ptyBytes = truncated ? buffer.text.slice(-maxBytes) : buffer.text;
+                return {
+                    success: true,
+                    cliType,
+                    sessionId: found.key,
+                    ptyBytes,
+                    bytes: ptyBytes.length,
+                    truncated,
+                    droppedChars: buffer.droppedChars,
+                    capturedAt: Date.now(),
+                };
+            }
             case 'restart_session': {
                 const cliType = args?.cliType || args?.agentType || args?.ideType;
                 const cfg = loadConfig();
@@ -1073,6 +1304,28 @@ export class DaemonCliManager {
                 const { adapter, key } = found;
 
                 if (action === 'send_chat') {
+                    let currentStatus = getEffectiveAgentSendStatus(adapter);
+                    if (currentStatus === 'starting' && await waitForZeroMessageStartingLaunch(adapter)) {
+                        currentStatus = 'idle';
+                    } else if (currentStatus === 'starting') {
+                        currentStatus = getEffectiveAgentSendStatus(adapter);
+                    }
+                    // Stamp mesh direct-dispatch assignment on the target
+                    // instance BEFORE sending the prompt so the completion
+                    // event has a routing marker by the time it fires.
+                    // mesh_send_task --direct ships meshContext for plain CLI
+                    // sessions that were never launched as mesh delegates.
+                    const meshContext = (args as any)?.meshContext;
+                    if (meshContext && typeof meshContext === 'object' && typeof meshContext.meshId === 'string' && meshContext.meshId) {
+                        const targetInstanceId = key;
+                        try {
+                            this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
+                                meshId: meshContext.meshId,
+                                ...(typeof meshContext.nodeId === 'string' && meshContext.nodeId ? { nodeId: meshContext.nodeId } : {}),
+                                ...(typeof meshContext.taskId === 'string' && meshContext.taskId ? { taskId: meshContext.taskId } : {}),
+                            });
+                        } catch { /* best-effort */ }
+                    }
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
                     const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);
                     if (provider?.category === 'acp') {
@@ -1082,8 +1335,24 @@ export class DaemonCliManager {
                     }
                     const message = input.textFallback;
                     if (!message) throw new Error('message required for send_chat');
-                    await adapter.sendMessage(message);
-                    return { success: true, status: 'generating' };
+                    const forceSend = args?.force === true || args?.forceSend === true;
+                    if (forceSend && typeof (adapter as any).forceSendMessage === 'function') {
+                        await (adapter as any).forceSendMessage(message);
+                    } else if (forceSend) {
+                        await adapter.sendMessage(message, { force: true });
+                    } else {
+                        await adapter.sendMessage(message);
+                    }
+                    const targetInstance = this.deps.getInstanceManager()?.getInstance(key) as
+                        | { recordAcknowledgedUserInput?: (input: unknown) => void }
+                        | undefined;
+                    targetInstance?.recordAcknowledgedUserInput?.(input);
+                    return {
+                        success: true,
+                        status: BUSY_AGENT_STATUSES.has(currentStatus) ? currentStatus : 'generating',
+                        ...(BUSY_AGENT_STATUSES.has(currentStatus) ? { queued: true, queuedReason: 'agent_runtime_busy' } : {}),
+                        ...(forceSend ? { forceSent: true, queued: false } : {}),
+                    };
                 } else if (action === 'clear_history') {
                     if (typeof adapter.clearHistory === 'function') adapter.clearHistory();
                     return { success: true, cleared: true };