@adhdev/daemon-core 0.9.12 → 0.9.14

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli-adapters/provider-cli-adapter.d.ts

@@ -156,6 +156,8 @@ export declare class ProviderCliAdapter implements CliAdapter {
      * Uses resolveAction script if available, otherwise falls back to standard text.
      */
     resolveAction(data: any): Promise<void>;
+    private writeToPty;
+    private resetPendingSendState;
     sendMessage(text: string): Promise<void>;
     getPartialResponse(): string;
     getRuntimeMetadata(): PtyRuntimeMetadata | null;
@@ -168,7 +170,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     clearHistory(): void;
     isProcessing(): boolean;
     isReady(): boolean;
-    writeRaw(data: string): void;
+    writeRaw(data: string): Promise<void>;
     resolveModal(buttonIndex: number): void;
     resize(cols: number, rows: number): void;
     getDebugState(): Record<string, any>;

package/src/cli-adapters/provider-cli-adapter.ts

@@ -1779,6 +1779,22 @@ export class ProviderCliAdapter implements CliAdapter {
         await this.sendMessage(promptText);
     }
 
+    private async writeToPty(data: string): Promise<void> {
+        if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        await this.ptyProcess.write(data);
+    }
+
+    private resetPendingSendState(reason: string): void {
+        this.isWaitingForResponse = false;
+        this.responseBuffer = '';
+        this.currentTurnScope = null;
+        this.submitPendingUntil = 0;
+        this.clearIdleFinishCandidate(reason);
+        if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
+        if (this.submitRetryTimer) { clearTimeout(this.submitRetryTimer); this.submitRetryTimer = null; }
+        if (this.finishRetryTimer) { clearTimeout(this.finishRetryTimer); this.finishRetryTimer = null; }
+    }
+
     async sendMessage(text: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const allowInputDuringGeneration = this.provider.allowInputDuringGeneration === true;
@@ -1881,20 +1897,30 @@ export class ProviderCliAdapter implements CliAdapter {
                 if (this.isWaitingForResponse) this.finishResponse();
             }, this.timeouts.maxResponse);
         };
-        await new Promise<void>((resolve) => {
+        await new Promise<void>((resolve, reject) => {
             let resolved = false;
             const resolveOnce = () => {
                 if (resolved) return;
                 resolved = true;
                 resolve();
             };
+            const rejectOnce = (error: unknown) => {
+                if (resolved) return;
+                this.resetPendingSendState('send_write_failed');
+                resolved = true;
+                reject(error);
+            };
+            const writeRetryKey = (mode: string) => {
+                void this.writeToPty(this.sendKey).catch((error) => {
+                    LOG.warn('CLI', `[${this.cliType}] ${mode} write failed: ${error?.message || error}`);
+                });
+            };
 
             const submit = () => {
                 if (!this.ptyProcess) {
                     resolveOnce();
                     return;
                 }
-                commitUserTurn();
                 this.submitPendingUntil = 0;
                 const screenText = this.terminalScreen.getText();
                 this.recordTrace('submit_write', {
@@ -1902,7 +1928,6 @@ export class ProviderCliAdapter implements CliAdapter {
                     sendKey: this.sendKey,
                     screenText: summarizeCliTraceText(screenText, 500),
                 });
-                this.ptyProcess!.write(this.sendKey);
                 const retrySubmitIfStuck = (attempt: number) => {
                     this.submitRetryTimer = null;
                     if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
@@ -1922,20 +1947,22 @@ export class ProviderCliAdapter implements CliAdapter {
                         sendKey: this.sendKey,
                         screenText: summarizeCliTraceText(screenText, 500),
                     });
-                    this.ptyProcess.write(this.sendKey);
+                    writeRetryKey('submit_retry');
                     if (attempt >= 3) {
                         this.submitRetryUsed = true;
                         return;
                     }
                     this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(attempt + 1), retryDelayMs);
                 };
-                this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
-                startResponseTimeout();
-                resolveOnce();
+                void this.writeToPty(this.sendKey).then(() => {
+                    commitUserTurn();
+                    this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
+                    startResponseTimeout();
+                    resolveOnce();
+                }, rejectOnce);
             };
 
             if (this.submitStrategy === 'immediate') {
-                commitUserTurn();
                 this.submitPendingUntil = 0;
                 this.recordTrace('submit_write', {
                     mode: 'immediate',
@@ -1943,38 +1970,39 @@ export class ProviderCliAdapter implements CliAdapter {
                     sendKey: this.sendKey,
                     screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500),
                 });
-                this.ptyProcess!.write(text + this.sendKey);
-                this.submitRetryTimer = setTimeout(() => {
-                    this.submitRetryTimer = null;
-                    if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
-                    if (this.currentStatus === 'waiting_approval') return;
-                    if (this.hasMeaningfulResponseBuffer(normalizedPromptSnippet)) return;
-                    const screenText = this.terminalScreen.getText();
-                    if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
-                    const liveApproval = this.runParseApproval(screenText) || this.runParseApproval(this.recentOutputBuffer);
-                    if (liveApproval) return;
-                    const liveStatus = this.runDetectStatus(screenText) || this.runDetectStatus(this.recentOutputBuffer);
-                    if (liveStatus === 'generating' || liveStatus === 'waiting_approval') return;
-                    LOG.info('CLI', `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
-                    this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
-                    this.recordTrace('submit_write', {
-                        mode: 'immediate_retry',
-                        attempt: 1,
-                        sendKey: this.sendKey,
-                        screenText: summarizeCliTraceText(screenText, 500),
-                    });
-                    this.ptyProcess.write(this.sendKey);
-                    this.submitRetryUsed = true;
-                }, retryDelayMs);
-                startResponseTimeout();
-                resolveOnce();
+                void this.writeToPty(text + this.sendKey).then(() => {
+                    commitUserTurn();
+                    this.submitRetryTimer = setTimeout(() => {
+                        this.submitRetryTimer = null;
+                        if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+                        if (this.currentStatus === 'waiting_approval') return;
+                        if (this.hasMeaningfulResponseBuffer(normalizedPromptSnippet)) return;
+                        const screenText = this.terminalScreen.getText();
+                        if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
+                        const liveApproval = this.runParseApproval(screenText) || this.runParseApproval(this.recentOutputBuffer);
+                        if (liveApproval) return;
+                        const liveStatus = this.runDetectStatus(screenText) || this.runDetectStatus(this.recentOutputBuffer);
+                        if (liveStatus === 'generating' || liveStatus === 'waiting_approval') return;
+                        LOG.info('CLI', `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
+                        this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+                        this.recordTrace('submit_write', {
+                            mode: 'immediate_retry',
+                            attempt: 1,
+                            sendKey: this.sendKey,
+                            screenText: summarizeCliTraceText(screenText, 500),
+                        });
+                        writeRetryKey('immediate_retry');
+                        this.submitRetryUsed = true;
+                    }, retryDelayMs);
+                    startResponseTimeout();
+                    resolveOnce();
+                }, rejectOnce);
                 return;
             }
 
             if (submitDelayMs > 0) {
                 this.submitPendingUntil = Date.now() + submitDelayMs;
             }
-            this.ptyProcess!.write(text);
             this.recordTrace('submit_write', {
                 mode: 'type_then_submit',
                 text: summarizeCliTraceText(text, 500),
@@ -2014,7 +2042,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
                 setTimeout(waitForEchoAndSubmit, 50);
             };
-            waitForEchoAndSubmit();
+            void this.writeToPty(text).then(() => waitForEchoAndSubmit(), rejectOnce);
         });
     }
 
@@ -2168,12 +2196,12 @@ export class ProviderCliAdapter implements CliAdapter {
     isProcessing(): boolean { return this.isWaitingForResponse; }
     isReady(): boolean { return this.ready; }
 
-    writeRaw(data: string): void {
+    async writeRaw(data: string): Promise<void> {
         this.recordTrace('write_raw', {
             keys: JSON.stringify(data),
             length: data.length,
         });
-        this.ptyProcess?.write(data);
+        await this.writeToPty(data);
     }
 
     resolveModal(buttonIndex: number): void {

package/src/cli-adapters/pty-transport.d.ts

@@ -28,7 +28,7 @@ export interface PtyRuntimeTransport {
     readonly pid: number;
     readonly ready: Promise<void>;
     readonly terminalQueriesHandled?: boolean;
-    write(data: string): void;
+    write(data: string): void | Promise<void>;
     resize(cols: number, rows: number): void;
     kill(): void;
     clearBuffer?(): void;

package/src/cli-adapters/pty-transport.ts

@@ -53,7 +53,7 @@ export interface PtyRuntimeTransport {
   readonly pid: number;
   readonly ready: Promise<void>;
   readonly terminalQueriesHandled?: boolean;
-  write(data: string): void;
+  write(data: string): void | Promise<void>;
   resize(cols: number, rows: number): void;
   kill(): void;
   clearBuffer?(): void;

package/src/cli-adapters/session-host-transport.ts

@@ -82,8 +82,8 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
         this.exitCallbacks.add(callback);
     }
 
-    write(data: string): void {
-        this.enqueue(async () => {
+    write(data: string): Promise<void> {
+        return this.enqueue(async () => {
             let response = await this.client.request({
                 type: 'send_input',
                 payload: {
@@ -404,13 +404,14 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
         };
     }
 
-    private enqueue(action: () => Promise<void>): void {
-        this.operationChain = this.operationChain
+    private enqueue(action: () => Promise<void>): Promise<void> {
+        const operation = this.operationChain
             .then(() => this.ready)
             .then(action)
-            .catch((error) => {
-                LOG.warn('CLI', `[session-host:${this.options.runtimeId}] ${error?.message || error}`);
-            });
+        this.operationChain = operation.catch((error) => {
+            LOG.warn('CLI', `[session-host:${this.options.runtimeId}] ${error?.message || error}`);
+        });
+        return operation;
     }
 
     private async closeClient(destroy = false): Promise<void> {

package/src/commands/router.ts

@@ -818,10 +818,16 @@ export class DaemonCommandRouter {
                         // ignore ls failures; upgrade can still proceed
                     }
 
-                    if (currentInstalled === latest) {
+                    const runningVersion = typeof this.deps.statusVersion === 'string'
+                        ? this.deps.statusVersion.trim().replace(/^v/, '')
+                        : null;
+                    if (currentInstalled === latest && runningVersion === latest) {
                         LOG.info('Upgrade', `Already on latest version v${latest}; skipping install`);
                         return { success: true, upgraded: false, alreadyLatest: true, version: latest };
                     }
+                    if (currentInstalled === latest && runningVersion && runningVersion !== latest) {
+                        LOG.info('Upgrade', `Installed package is v${latest}, but running daemon is v${runningVersion}; scheduling restart`);
+                    }
 
                     spawnDetachedDaemonUpgradeHelper({
                         packageName: pkgName,

package/src/commands/stream-commands.d.ts

@@ -5,7 +5,7 @@
 import type { CommandResult, CommandHelpers } from './handler.js';
 export declare function handleSelectSession(h: CommandHelpers, args: any): Promise<CommandResult>;
 export declare function handleOpenPanel(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handlePtyInput(h: CommandHelpers, args: any): CommandResult;
+export declare function handlePtyInput(h: CommandHelpers, args: any): Promise<CommandResult>;
 export declare function handlePtyResize(h: CommandHelpers, args: any): CommandResult;
 export declare function handleGetProviderSettings(h: CommandHelpers, args: any): CommandResult;
 export declare function handleSetProviderSetting(h: CommandHelpers, args: any): Promise<CommandResult>;

package/src/commands/stream-commands.ts

@@ -110,14 +110,14 @@ export async function handleOpenPanel(h: CommandHelpers, args: any): Promise<Com
 
 // ─── PTY Raw I/O ──────────────────────────────────
 
-export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {
+export async function handlePtyInput(h: CommandHelpers, args: any): Promise<CommandResult> {
     const { cliType, data, targetSessionId } = args || {};
     if (!data) return { success: false, error: 'data required' };
     const adapter = h.getCliAdapter(targetSessionId || cliType);
     if (!adapter || typeof adapter.writeRaw !== 'function') {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };
     }
-    adapter.writeRaw(data);
+    await adapter.writeRaw(data);
     return { success: true };
 }
 
@@ -343,7 +343,7 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
             if (cliCommand?.type === 'send_message' && cliCommand.text) {
                 await adapter.sendMessage(cliCommand.text);
             } else if (cliCommand?.type === 'pty_write' && cliCommand.text && adapter.writeRaw) {
-                adapter.writeRaw(cliCommand.text + '\r');
+                await adapter.writeRaw(cliCommand.text + '\r');
             }
             applyProviderPatch(h, args, parsed.payload);
             return {

package/src/daemon/dev-cli-debug.ts

@@ -1195,7 +1195,7 @@ export async function handleCliRaw(ctx: DevServerContext, req: http.IncomingMess
 
   try {
     if (typeof adapter.writeRaw === 'function') {
-      adapter.writeRaw(keys);
+      await adapter.writeRaw(keys);
       ctx.json(res, 200, { sent: true, type: target.type, instanceId: target.instanceId, keysLength: keys.length });
     } else {
       ctx.json(res, 400, { error: 'writeRaw not available on this adapter' });

package/src/providers/cli-provider-instance.ts

@@ -526,7 +526,7 @@ export class CliProviderInstance implements ProviderInstance {
         if (cliCommand?.type === 'send_message' && cliCommand.text) {
             await this.adapter.sendMessage(cliCommand.text);
         } else if (cliCommand?.type === 'pty_write' && cliCommand.text) {
-            this.adapter.writeRaw(cliCommand.text + '\r');
+            await this.adapter.writeRaw(cliCommand.text + '\r');
         }
 
         this.applyProviderResponse(parsed.payload, { phase: 'immediate' });