@yu_robotics/remote-cli 1.6.149 → 1.6.152

package/dist/executor/ClaudePersistentExecutor.js

@@ -10,6 +10,7 @@ const Activity_1 = require("./Activity");
 const ClaudeSandbox_1 = require("./claude/ClaudeSandbox");
 const ClaudeFilePolicy_1 = require("./claude/ClaudeFilePolicy");
 const ExecutionMetadata_1 = require("./ExecutionMetadata");
+const ClaudeSettings_1 = require("./claude/ClaudeSettings");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
@@ -38,7 +39,13 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
     threadId;
     /** Model to pass via --model on process start. Updated by setModel() for future restarts. */
     model;
+    effort;
     reportedModel;
+    // Native control catalog cache & control request state
+    cachedModelCatalog = null;
+    cachedRawEntries = null;
+    catalogInitPromise;
+    pendingControlRequests = new Map();
     // Persistent process
     claudeProcess = null;
     isStarting = false;
@@ -97,12 +104,13 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
     static FILE_POLICY_SCRIPT = path_1.default.join(__dirname, 'claude', 'filePolicyHook.js');
     // Activity tracking for timeout extension (optional, can be disabled)
     activityTrackingEnabled = false;
-    constructor(directoryGuard, initialWorkingDirectory, threadId, model, sandbox, claudeCommand, lifecycleHooks = true, delegationWorker = false) {
+    constructor(directoryGuard, initialWorkingDirectory, threadId, model, sandbox, claudeCommand, lifecycleHooks = true, delegationWorker = false, effort) {
         super();
         this.lifecycleHooks = lifecycleHooks;
         this.delegationWorker = delegationWorker;
         this.directoryGuard = directoryGuard;
         this.model = model;
+        this.effort = effort === 'auto' ? undefined : effort;
         this.sandbox = new ClaudeSandbox_1.ClaudeSandbox(directoryGuard, sandbox, threadId);
         this.claudeCommand = claudeCommand ?? 'claude';
         // Use provided working directory or fall back to process.cwd()
@@ -213,8 +221,20 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
         return this.currentWorkingDirectory;
     }
     getExecutionMetadata() {
-        const data = (0, ExecutionMetadata_1.configuredExecutionMetadata)(this.model);
-        data.effortSource = 'unknown';
+        let effectiveEffort = this.effort;
+        if (this.effort && this.cachedRawEntries) {
+            const activeModel = this.reportedModel || this.model;
+            const entry = activeModel
+                ? this.cachedRawEntries.find(e => e.value === activeModel || (e.resolvedModel !== undefined && e.resolvedModel === activeModel))
+                : this.cachedRawEntries.find(e => e.value === 'default');
+            if (entry && (!entry.supportsEffort || !entry.supportedEffortLevels?.includes(this.effort))) {
+                effectiveEffort = undefined;
+            }
+        }
+        const data = (0, ExecutionMetadata_1.configuredExecutionMetadata)(this.model, effectiveEffort);
+        if (!effectiveEffort) {
+            data.effortSource = 'unknown';
+        }
         if (this.isProcessRunning() && this.reportedModel) {
             data.model = this.reportedModel;
             data.modelSource = 'reported';
@@ -259,6 +279,8 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
      * Start the persistent Claude process
      */
     async startProcess() {
+        if (this.isDestroyed || (this.isStopping && this.claudeProcess))
+            throw new Error('Claude process is unavailable or its exit is unconfirmed');
         if (this.claudeProcess || this.isStarting) {
             return;
         }
@@ -321,6 +343,9 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
             if (this.model) {
                 args.push('--model', this.model);
             }
+            if (this.effort) {
+                args.push('--effort', this.effort);
+            }
             if (this.sessionId) {
                 args.push('--resume', this.sessionId);
                 console.log(`[ClaudePersistent] Resuming session: ${this.sessionId}`);
@@ -410,8 +435,12 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
             // Use 'close' event (fires after all I/O streams are closed, i.e. after all stdout
             // data events have been processed) instead of 'exit' for command completion logic.
             child.on('close', (code, signal) => {
+                if (this.claudeProcess !== child)
+                    return;
                 flushStderr();
                 this.clearApprovals('Claude process exited');
+                this.rejectPendingControlRequests('Claude process exited before control response');
+                this.clearCatalogCache();
                 this.claudeProcess = null;
                 // Check if this was an intentional stop (abort/reset)
                 const wasIntentionalStop = this.isStopping;
@@ -530,32 +559,33 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
         this.filePolicyRoots = [];
         this.filePolicyStarted = false;
         this.clearApprovals('Claude process stopped');
+        this.rejectPendingControlRequests('Claude process stopped before control response');
+        this.clearCatalogCache();
         if (!this.claudeProcess) {
             return;
         }
         console.log('[ClaudePersistent] Stopping process...');
         this.isStopping = true;
-        // Send EOF to stdin to gracefully close
-        this.claudeProcess.stdin?.end();
-        // Kill after timeout
-        const killTimeout = setTimeout(() => {
-            if (this.claudeProcess) {
-                console.log('[ClaudePersistent] Force killing process...');
-                this.claudeProcess.kill('SIGTERM');
+        const child = this.claudeProcess;
+        // A signal is not evidence of exit. Bound the wait and retain the child on
+        // failure so the caller cannot silently launch a replacement over it.
+        await new Promise((resolve, reject) => {
+            const term = setTimeout(() => child.kill('SIGTERM'), 5_000);
+            const kill = setTimeout(() => child.kill('SIGKILL'), 8_000);
+            const deadline = setTimeout(() => { cleanup(); reject(new Error('Claude process exit could not be confirmed')); }, 9_000);
+            const cleanup = () => { clearTimeout(term); clearTimeout(kill); clearTimeout(deadline); child.removeListener('close', closed); };
+            const closed = () => { cleanup(); resolve(); };
+            child.once('close', closed);
+            try {
+                child.stdin?.end();
             }
-        }, 5000);
-        // Wait for process to exit
-        await new Promise(resolve => {
-            if (!this.claudeProcess) {
-                resolve();
-                return;
+            catch {
+                child.kill('SIGTERM');
             }
-            this.claudeProcess.on('close', () => {
-                clearTimeout(killTimeout);
-                resolve();
-            });
         });
-        this.claudeProcess = null;
+        if (this.claudeProcess === child)
+            this.claudeProcess = null;
+        this.isStopping = false;
         console.log('[ClaudePersistent] Process stopped');
     }
     // ── Sandbox approval channel ─────────────────────────────────────────────
@@ -885,6 +915,41 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
         }
         return text;
     }
+    handleControlMessage(message) {
+        if (message.type !== 'control_response' || !message.response) {
+            return;
+        }
+        const { subtype, request_id, response, error } = message.response;
+        if (!request_id)
+            return;
+        const pending = this.pendingControlRequests.get(request_id);
+        if (!pending)
+            return;
+        this.pendingControlRequests.delete(request_id);
+        clearTimeout(pending.timer);
+        if (subtype === 'success') {
+            if (Buffer.byteLength(JSON.stringify(response ?? {}), 'utf8') > 1024 * 1024) {
+                pending.reject(new Error('Claude control response exceeds the supported size'));
+                return;
+            }
+            pending.resolve(response ?? {});
+        }
+        else {
+            pending.reject(new Error(error || `Claude control request failed with status: ${subtype}`));
+        }
+    }
+    rejectPendingControlRequests(reason) {
+        for (const [id, pending] of this.pendingControlRequests.entries()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(reason));
+        }
+        this.pendingControlRequests.clear();
+    }
+    clearCatalogCache() {
+        this.cachedModelCatalog = null;
+        this.cachedRawEntries = null;
+        this.catalogInitPromise = undefined;
+    }
     /**
      * Handle a line of JSON output from Claude
      */
@@ -892,6 +957,12 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
         try {
             // Parse message first to check type
             const parsedMessage = JSON.parse(line);
+            // Handle native Claude Control response packets (models catalog, etc.).
+            // These bypass raw stdout logging to prevent any potential account/credential leakage.
+            if (parsedMessage.type === 'control_response' || parsedMessage.type === 'control_request') {
+                this.handleControlMessage(parsedMessage);
+                return;
+            }
             // Skip logging for stream_event messages to avoid console spam
             // Token deltas are handled below without logging every fragment.
             if (parsedMessage.type !== 'stream_event') {
@@ -1625,29 +1696,226 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
         this.stopProcess().catch((err) => console.error('[ClaudePersistent] Failed to stop process on reset:', err));
     }
     /**
-     * Send /model slash command to the running Claude process to switch models.
-     * Also stores the model so future process restarts start with --model already set,
-     * since a live /model change does not survive a process respawn on its own.
+     * Switch the model for future commands.
+     * Restarts the process if running, preserving the session via --resume.
+     * Rejects known incompatible effort rather than silently changing a second preference.
+     * Retains a deliberate text-argument full-model path if not found in catalog.
      */
-    setModel(model, onStream) {
-        console.log(`[ClaudePersistent] Sending /model ${model} slash command`);
+    async setModel(model, _onStream) {
+        if (this.isDestroyed) {
+            return { success: false, error: 'Executor has been destroyed' };
+        }
+        if (this.isBusy()) {
+            return { success: false, error: 'Cannot change model while Claude is busy' };
+        }
+        if (this.effort && !this.cachedRawEntries) {
+            try {
+                await this.listModels();
+            }
+            catch {
+                return { success: false, error: 'Cannot validate the saved reasoning effort. Reset /effort auto before changing models.' };
+            }
+        }
+        let matchedEntry;
+        if (this.cachedRawEntries) {
+            matchedEntry = this.cachedRawEntries.find(e => e.value === model || (e.resolvedModel !== undefined && e.resolvedModel === model));
+        }
+        if (this.effort && matchedEntry) {
+            if (!matchedEntry.supportsEffort || !matchedEntry.supportedEffortLevels?.includes(this.effort)) {
+                return { success: false, error: 'The saved reasoning effort is incompatible with this model. Reset /effort auto before changing models.' };
+            }
+        }
+        await this.stopProcess();
         this.model = model;
+        this.reportedModel = undefined;
+        return {
+            success: true,
+            output: `Model set to ${this.model}.`,
+        };
+    }
+    async clearModel() {
+        if (this.isDestroyed)
+            return;
+        if (this.isBusy()) {
+            throw new Error('Cannot clear model while Claude is busy');
+        }
+        this.model = undefined;
+        this.reportedModel = undefined;
+        await this.stopProcess();
+    }
+    /**
+     * Query models available to the authenticated Claude backend using native control initialization.
+     * Bounded by 10s timeout, cached per process instance, and rejects without injecting user prompts.
+     */
+    async listModels() {
+        if (this.isDestroyed) {
+            throw new Error('Executor has been destroyed');
+        }
+        if (this.cachedModelCatalog) {
+            return (0, ClaudeSettings_1.parseClaudeModelsCatalog)(this.cachedRawEntries, this.reportedModel || this.model).models;
+        }
+        if (this.catalogInitPromise) {
+            return this.catalogInitPromise;
+        }
+        const pending = this.performControlInitialization().finally(() => {
+            if (this.catalogInitPromise === pending)
+                this.catalogInitPromise = undefined;
+        });
+        this.catalogInitPromise = pending;
+        return pending;
+    }
+    async performControlInitialization() {
+        await this.startProcess();
+        const child = this.claudeProcess;
+        if (!child || !child.stdin || child.killed) {
+            throw new Error('Claude process is not available for control initialization');
+        }
+        const stdin = child.stdin;
+        const requestId = `catalog-${(0, crypto_1.randomUUID)()}`;
+        const requestPacket = {
+            type: 'control_request',
+            request_id: requestId,
+            request: {
+                subtype: 'initialize',
+            },
+        };
         return new Promise((resolve, reject) => {
-            this.reportedModel = undefined;
-            if (this.isDestroyed) {
-                resolve({ success: false, error: 'Executor has been destroyed' });
-                return;
-            }
-            this.commandQueue.push({
-                prompt: `/model ${model}`,
-                options: { onStream },
-                resolve,
-                reject,
-                isSlashCommand: true,
+            let timer;
+            const cleanup = () => {
+                if (timer)
+                    clearTimeout(timer);
+                this.pendingControlRequests.delete(requestId);
+            };
+            timer = setTimeout(() => {
+                cleanup();
+                reject(new Error('Claude control initialization timed out after 10000ms'));
+            }, 10_000);
+            this.pendingControlRequests.set(requestId, {
+                resolve: (response) => {
+                    cleanup();
+                    if (this.claudeProcess !== child || this.isDestroyed || this.isStopping) {
+                        reject(new Error('Claude catalog process is no longer active'));
+                        return;
+                    }
+                    try {
+                        const rawResponse = response || {};
+                        const { models, rawEntries } = (0, ClaudeSettings_1.parseClaudeModelsCatalog)(rawResponse.models, this.reportedModel || this.model);
+                        this.cachedRawEntries = rawEntries;
+                        this.cachedModelCatalog = models;
+                        resolve(models);
+                    }
+                    catch (err) {
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                },
+                reject: (err) => {
+                    cleanup();
+                    reject(err);
+                },
+                timer,
             });
-            this.processQueue();
+            try {
+                stdin.write(JSON.stringify(requestPacket) + '\n', (err) => {
+                    if (err) {
+                        cleanup();
+                        reject(new Error(`Failed to write control request to Claude stdin: ${err.message}`));
+                    }
+                });
+            }
+            catch (err) {
+                cleanup();
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
         });
     }
+    /**
+     * Query reasoning effort levels supported for the current model.
+     */
+    async listEfforts() {
+        if (this.isDestroyed) {
+            return {
+                choices: [],
+                current: this.effort,
+                default: undefined,
+                supportsReset: true,
+                unavailableReason: 'Executor has been destroyed',
+            };
+        }
+        try {
+            await this.listModels();
+        }
+        catch (err) {
+            return {
+                choices: [],
+                current: this.effort,
+                default: undefined,
+                supportsReset: true,
+                unavailableReason: err instanceof Error ? err.message : 'Claude model catalog unavailable',
+            };
+        }
+        if (!this.cachedRawEntries) {
+            return {
+                choices: [],
+                current: this.effort,
+                default: undefined,
+                supportsReset: true,
+                unavailableReason: 'Reasoning effort is not supported for Claude Code.',
+            };
+        }
+        const activeModel = this.reportedModel || this.model;
+        return (0, ClaudeSettings_1.resolveClaudeEfforts)(this.cachedRawEntries, activeModel, this.effort);
+    }
+    /**
+     * Set reasoning effort level for future commands.
+     * 'auto' clears the override. Non-auto values validate against native supported levels.
+     * Preserves the session while recycling the idle process and passing --effort to the next spawn.
+     */
+    async setEffort(effort) {
+        if (this.isDestroyed) {
+            return { success: false, error: 'Executor has been destroyed' };
+        }
+        if (this.isBusy()) {
+            return { success: false, error: 'Cannot change reasoning effort while Claude is busy' };
+        }
+        const normalized = effort.trim().toLowerCase();
+        if (normalized === 'auto' || normalized === '') {
+            await this.stopProcess();
+            this.effort = undefined;
+            return {
+                success: true,
+                output: 'Reasoning effort restored to default.',
+            };
+        }
+        let effortInfo;
+        try {
+            effortInfo = await this.listEfforts();
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : 'Failed to query available reasoning efforts',
+            };
+        }
+        if (effortInfo.unavailableReason || !effortInfo.choices.length) {
+            return {
+                success: false,
+                error: effortInfo.unavailableReason || 'Reasoning effort is not supported for the current model.',
+            };
+        }
+        const match = effortInfo.choices.find(c => c.value.toLowerCase() === normalized);
+        if (!match) {
+            return {
+                success: false,
+                error: `Unsupported reasoning effort: ${effort}. Supported values: auto, ${effortInfo.choices.map(c => c.value).join(', ')}.`,
+            };
+        }
+        await this.stopProcess();
+        this.effort = match.value;
+        return {
+            success: true,
+            output: `Reasoning effort set to ${match.value}.`,
+        };
+    }
     /**
      * Send /compact slash command to the running Claude process to compress conversation history.
      * This asks Claude CLI to summarize the conversation and reduce context size.
@@ -1756,6 +2024,8 @@ class ClaudePersistentExecutor extends events_1.EventEmitter {
         }
         this.commandQueue = [];
         this.clearApprovals('Executor destroyed');
+        this.rejectPendingControlRequests('Executor has been destroyed');
+        this.clearCatalogCache();
         if (this.approvalServer) {
             const server = this.approvalServer;
             this.approvalServer = null;