@yu_robotics/remote-cli 1.6.158 → 1.6.165

package/dist/executor/PiExecutor.js

@@ -37,12 +37,23 @@ exports.PiExecutor = void 0;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
 const ExecutionMetadata_1 = require("./ExecutionMetadata");
 const PiClient_1 = require("./pi/PiClient");
 const contract_1 = require("../delegation/contract");
 const WorkingDirectory_1 = require("../utils/WorkingDirectory");
 const Activity_1 = require("./Activity");
 const PiTypes_1 = require("./pi/PiTypes");
+const MISSING_ADOPTED_ERROR = 'The connected Pi session is no longer available on this computer. Send /session detach to start a fresh conversation, or /resume to connect another session.';
+function sameFilePath(left, right) {
+    const canonical = (value) => { try {
+        return fs.realpathSync.native(value);
+    }
+    catch {
+        return path.resolve(value);
+    } };
+    return canonical(left) === canonical(right);
+}
 const DEFAULT_TURN_TIMEOUT_MS = 10 * 60 * 1000;
 const COMPACT_TIMEOUT_MS = 10 * 60 * 1000;
 /** Grace period to distinguish immediate slash/extension commands from a real agent turn. */
@@ -176,6 +187,15 @@ class PiExecutor {
     unsubscribe = null;
     sessionId = null;
     sessionFile = null;
+    /** Fresh foreground identity, distinct from the stable remote thread. */
+    freshSessionId = (0, crypto_1.randomUUID)();
+    /** Adopted native history is user-owned: never deleted, never renamed. */
+    adopted = false;
+    nativeSessionMutation = false;
+    nativeSessionMutationCancelled = false;
+    nativeSessionMutationDone = null;
+    nativeSessionCleanup = 0;
+    preparingTurn = null;
     activeTurn = null;
     activityTracker = new Activity_1.ActivityTracker();
     pendingUi = null;
@@ -185,7 +205,7 @@ class PiExecutor {
     async configureDelegation(connection) {
         if ((0, contract_1.sameConnection)(this.delegation, connection))
             return;
-        if (this.activeTurn)
+        if (this.isBusy())
             throw new Error('Cannot change delegation while Pi is busy');
         await this.recycleClient();
         this.delegation = connection;
@@ -227,24 +247,42 @@ class PiExecutor {
     async execute(prompt, options = {}) {
         if (this.destroyed)
             throw new Error('Executor has been destroyed');
-        if (this.activeTurn) {
+        if (this.isBusy()) {
             return { success: false, error: 'Pi thread is already running a command' };
         }
         const trimmed = prompt.trim();
         if (trimmed === '/skills' || trimmed === '/skill') {
             return this.listSkills();
         }
-        if (trimmed.startsWith('/')) {
-            const validationError = await this.validateSlashCommand(trimmed);
-            if (validationError)
-                return { success: false, error: validationError };
-        }
+        const preparation = { cancelled: false };
+        this.preparingTurn = preparation;
         try {
+            // Each native Pi process caches a branch. Reload adopted history before
+            // every remote turn; the user must keep other writers idle.
+            if (this.adopted)
+                await this.recycleClient();
+            if (preparation.cancelled || this.destroyed)
+                return { success: false, error: 'Pi command cancelled before startup' };
             await this.ensureClient();
+            if (preparation.cancelled || this.destroyed) {
+                await this.recycleClient();
+                return { success: false, error: 'Pi command cancelled before dispatch' };
+            }
+            if (trimmed.startsWith('/')) {
+                const validationError = await this.validateSlashCommand(trimmed);
+                if (validationError)
+                    return { success: false, error: validationError };
+            }
+            if (preparation.cancelled || this.destroyed)
+                return { success: false, error: 'Pi command cancelled before dispatch' };
         }
         catch (error) {
             return { success: false, error: this.friendlyError(error) };
         }
+        finally {
+            if (this.preparingTurn === preparation)
+                this.preparingTurn = null;
+        }
         return new Promise((resolve) => {
             const active = {
                 options,
@@ -325,7 +363,7 @@ class PiExecutor {
         return this.currentWorkingDirectory;
     }
     isBusy() {
-        return this.activeTurn !== null;
+        return this.activeTurn !== null || this.preparingTurn !== null || this.nativeSessionMutation || this.nativeSessionCleanup > 0;
     }
     async setWorkingDirectory(targetPath) {
         const resolved = this.directoryGuard.resolveWorkingDirectory(targetPath, this.currentWorkingDirectory);
@@ -343,6 +381,10 @@ class PiExecutor {
     resetContext() {
         if (this.destroyed)
             return;
+        if (this.nativeSessionMutation)
+            throw new Error('Cannot clear Pi context while a session connection is changing');
+        if (this.preparingTurn)
+            this.preparingTurn.cancelled = true;
         this.cancelPendingUi(true);
         if (this.activeTurn) {
             this.completeActive({
@@ -355,6 +397,17 @@ class PiExecutor {
         this.replaceClient();
     }
     async abort() {
+        const mutation = this.nativeSessionMutationDone;
+        if (mutation) {
+            this.nativeSessionMutationCancelled = true;
+            await this.stopNativeSessionMutation(mutation);
+            return true;
+        }
+        if (this.preparingTurn) {
+            this.preparingTurn.cancelled = true;
+            await this.recycleClient();
+            return true;
+        }
         if (!this.client.isRunning())
             return false;
         const active = this.activeTurn;
@@ -387,13 +440,36 @@ class PiExecutor {
     }
     async destroy() {
         this.destroyed = true;
+        this.nativeSessionMutationCancelled = true;
+        if (this.preparingTurn)
+            this.preparingTurn.cancelled = true;
         this.cancelPendingUi(true);
         if (this.activeTurn) {
             this.completeActive({ success: false, error: 'Executor destroyed' });
         }
         this.unsubscribe?.();
         this.unsubscribe = null;
-        await this.recycleClient();
+        const mutation = this.nativeSessionMutationDone;
+        if (mutation)
+            await this.stopNativeSessionMutation(mutation);
+        else
+            await this.recycleClient();
+    }
+    /** Abort native context changes without RPC requests that could restart a stopped client. */
+    async stopNativeSessionMutation(mutation) {
+        this.nativeSessionCleanup += 1;
+        try {
+            // Interrupt startup first, then await rollback before the final exit check.
+            try {
+                await this.recycleClient();
+            }
+            catch { /* confirmed cleanup is required below */ }
+            await mutation;
+            await this.recycleClient();
+        }
+        finally {
+            this.nativeSessionCleanup -= 1;
+        }
     }
     /**
      * `recycleClient` waits for the Pi transport's stop operation. Check every
@@ -448,7 +524,7 @@ class PiExecutor {
         return this.compactWhenFull(onStream);
     }
     async compactWhenFull(onStream) {
-        if (this.activeTurn) {
+        if (this.isBusy()) {
             return { success: false, error: 'Cannot compact while a Pi command is running' };
         }
         try {
@@ -655,9 +731,11 @@ class PiExecutor {
     async deleteThreadData(threadId) {
         const pointerPath = path.join(path.dirname(this.sessionFilePath), `${threadId}.json`);
         let sessionFile = this.sessionFile;
+        let adopted = threadId === this.threadId && this.adopted;
         try {
             const stored = JSON.parse(fs.readFileSync(pointerPath, 'utf8'));
             sessionFile = stored.sessionFile ?? sessionFile;
+            adopted = adopted || stored.adopted === true;
         }
         catch {
             // Pointer may already be gone.
@@ -666,7 +744,7 @@ class PiExecutor {
             fs.unlinkSync(pointerPath);
         }
         catch { /* ignore */ }
-        if (sessionFile) {
+        if (sessionFile && !adopted && !this.isForegroundSession(threadId)) {
             try {
                 fs.unlinkSync(sessionFile);
             }
@@ -675,6 +753,7 @@ class PiExecutor {
         if (threadId === this.threadId) {
             this.sessionId = null;
             this.sessionFile = null;
+            this.adopted = false;
         }
     }
     async listSkills() {
@@ -715,6 +794,8 @@ class PiExecutor {
     async ensureClient() {
         if (this.destroyed)
             throw new Error('Executor has been destroyed');
+        if (this.adopted && (!this.sessionFile || !fs.existsSync(this.sessionFile)))
+            throw new Error(MISSING_ADOPTED_ERROR);
         (0, WorkingDirectory_1.assertWorkingDirectoryExists)(this.currentWorkingDirectory);
         if (this.retiredClients.size > 0) {
             await Promise.all([...this.retiredClients].map(client => this.stopRetiredClient(client)));
@@ -727,9 +808,150 @@ class PiExecutor {
             this.reportedEffort = undefined;
             this.client.updateLaunch?.(this.buildLaunch());
             await this.client.start();
-            await this.refreshSessionPointer();
+            if (!this.adopted) {
+                await this.refreshSessionPointer();
+                return;
+            }
+            // Adopted sessions never follow a silently substituted identity after a restart.
+            const mismatch = await this.checkAdoptedIdentity({ sessionId: this.sessionId, sessionFile: this.sessionFile });
+            if (mismatch) {
+                await this.client.stop().catch(() => undefined);
+                throw new Error(`${mismatch} ${MISSING_ADOPTED_ERROR}`);
+            }
         }
     }
+    /**
+     * Connect this thread to an existing native Pi session file. Verification uses
+     * RPC `get_state` only: no prompt is sent. Pi may append ordinary metadata
+     * entries (for example a thinking-level record) but keeps prior history intact.
+     */
+    async adoptNativeSession(target) {
+        const fail = (error) => ({ success: false, error });
+        if (this.destroyed)
+            return fail('Executor has been destroyed.');
+        if (this.isBusy())
+            return fail('Wait for the running Pi task to finish before connecting a session.');
+        if (!fs.existsSync(target.sessionFile))
+            return fail('The selected Pi session is no longer available. No session was changed.');
+        return this.mutateNativeSession(() => this.adoptIdleNativeSession(target));
+    }
+    async mutateNativeSession(operation) {
+        this.nativeSessionMutation = true;
+        this.nativeSessionMutationCancelled = false;
+        let finish;
+        this.nativeSessionMutationDone = new Promise(resolve => { finish = resolve; });
+        try {
+            return await operation();
+        }
+        finally {
+            this.nativeSessionMutation = false;
+            this.nativeSessionMutationDone = null;
+            finish();
+        }
+    }
+    async adoptIdleNativeSession(target) {
+        const fail = (error) => ({ success: false, error });
+        const previous = { sessionId: this.sessionId, sessionFile: this.sessionFile, adopted: this.adopted,
+            reportedModel: this.reportedModel, reportedEffort: this.reportedEffort };
+        try {
+            await this.recycleClient();
+        }
+        catch (error) {
+            return fail(`Could not confirm that the current Pi process stopped (${this.friendlyError(error)}). No session was changed.`);
+        }
+        if (this.destroyed || this.nativeSessionMutationCancelled)
+            return fail('Pi session connection was cancelled. No session was connected.');
+        this.sessionId = target.sessionId;
+        this.sessionFile = target.sessionFile;
+        this.adopted = true;
+        let error;
+        try {
+            (0, WorkingDirectory_1.assertWorkingDirectoryExists)(this.currentWorkingDirectory);
+            this.reportedModel = undefined;
+            this.reportedEffort = undefined;
+            this.client.updateLaunch?.(this.buildLaunch());
+            await this.client.start();
+            // PiClient.request() can start a process; never call it after cancellation.
+            if (!this.destroyed && !this.nativeSessionMutationCancelled)
+                error = await this.checkAdoptedIdentity(target);
+            if (this.destroyed || this.nativeSessionMutationCancelled)
+                error = 'Pi session connection was cancelled.';
+            if (!error && !this.savePointer())
+                error = 'Could not persist the Pi session connection.';
+        }
+        catch (startError) {
+            error = this.friendlyError(startError);
+        }
+        if (!error) {
+            return { success: true };
+        }
+        let stopped = true;
+        try {
+            await this.client.stop();
+        }
+        catch {
+            stopped = false;
+        }
+        Object.assign(this, previous);
+        // An unconfirmed stop is retired and retried before the previous session starts again.
+        if (stopped)
+            this.client.updateLaunch?.(this.buildLaunch());
+        else
+            this.replaceClient();
+        return { success: false, error: `${error} The previous conversation is kept.${stopped ? '' : ' Selected Pi process exit could not be confirmed; the session remains reserved until recovery.'}`,
+            ...(!stopped ? { recoveryRequired: true } : {}) };
+    }
+    /** Forget the adopted session without deleting it; the next turn starts a fresh conversation. */
+    async detachNativeSession() {
+        if (this.destroyed)
+            return { success: false, error: 'Executor has been destroyed.' };
+        if (!this.adopted)
+            return { success: false, error: 'This thread is not connected to a native Pi session.' };
+        if (this.isBusy())
+            return { success: false, error: 'Wait for the running Pi task to finish (or send /abort) before detaching the session.' };
+        return this.mutateNativeSession(() => this.detachIdleNativeSession());
+    }
+    async detachIdleNativeSession() {
+        const previous = { sessionId: this.sessionId, sessionFile: this.sessionFile, adopted: this.adopted };
+        try {
+            await this.recycleClient();
+        }
+        catch (error) {
+            return { success: false, error: `Could not confirm that the Pi process stopped (${this.friendlyError(error)}). The session is still connected; try again.` };
+        }
+        if (this.destroyed || this.nativeSessionMutationCancelled)
+            return { success: false, error: 'Pi session detach was cancelled. The session is still connected.' };
+        this.adopted = false;
+        this.sessionFile = null;
+        this.sessionId = (0, crypto_1.randomUUID)();
+        if (!this.savePointer()) {
+            Object.assign(this, previous);
+            this.client.updateLaunch?.(this.buildLaunch());
+            return { success: false, error: 'Could not persist the Pi session detach. The session is still connected; try again.' };
+        }
+        this.client.updateLaunch?.(this.buildLaunch());
+        return { success: true };
+    }
+    /** Returns an error description when Pi did not load exactly the expected session. */
+    async checkAdoptedIdentity(expected) {
+        const response = await this.client.request({ type: 'get_state' });
+        const data = response.success ? response.data : undefined;
+        if (!data)
+            return 'Pi did not report its session state.';
+        if (data.sessionId !== expected.sessionId || typeof data.sessionFile !== 'string'
+            || !sameFilePath(data.sessionFile, expected.sessionFile)) {
+            return 'Pi opened a different session than the one selected.';
+        }
+        if (data.isStreaming === true)
+            return 'Pi reported that the session is already running a turn.';
+        const model = data.model;
+        if (typeof model?.id === 'string' && model.id.trim()) {
+            this.reportedModel = typeof model.provider === 'string' && model.provider ? `${model.provider}/${model.id}` : model.id;
+        }
+        if (typeof data.thinkingLevel === 'string' && data.thinkingLevel.trim())
+            this.reportedEffort = data.thinkingLevel;
+        return undefined;
+    }
     async recycleClient() {
         await Promise.all([
             this.client.stop(),
@@ -754,10 +976,15 @@ class PiExecutor {
             console.warn('[PiExecutor] Failed to stop previous Pi RPC process', error);
         });
     }
+    isForegroundSession(threadId = this.threadId) {
+        return !this.delegationWorker && !/^(?:remote-cli-)?(?:delegate-lane-|settings-meta-)/.test(threadId ?? '');
+    }
     forgetSession() {
         const sessionFile = this.sessionFile;
+        const preserveHistory = this.adopted || this.isForegroundSession();
         this.clearPointer();
-        if (sessionFile) {
+        // Reset changes the foreground association, never deletes resumable history.
+        if (sessionFile && !preserveHistory) {
             try {
                 fs.unlinkSync(sessionFile);
             }
@@ -766,14 +993,21 @@ class PiExecutor {
     }
     buildLaunch() {
         const pointerFile = this.sessionFile && fs.existsSync(this.sessionFile) ? this.sessionFile : undefined;
+        const sessionId = this.sessionId ?? (this.isForegroundSession() ? this.freshSessionId : this.threadId);
         return {
             command: this.piCommand,
             cwd: this.currentWorkingDirectory,
             approveProject: this.autoApprove,
             sessionDir: this.sessionStoreDir,
-            sessionId: this.sessionId ?? this.threadId,
+            sessionId,
             sessionFile: pointerFile,
-            sessionName: this.threadId ? `remote-cli-${this.threadId}` : undefined,
+            // Name fresh foreground sessions by native identity, not their reusable thread.
+            // Never rename a persisted file on reopen, including locally assigned names.
+            sessionName: this.threadId && !this.adopted
+                ? this.isForegroundSession()
+                    ? !pointerFile ? `remote-cli-${sessionId}` : undefined
+                    : `remote-cli-${this.threadId}`
+                : undefined,
             provider: this.provider,
             model: this.model,
             thinking: this.effort,
@@ -1017,6 +1251,8 @@ class PiExecutor {
                 this.sessionId = stored.id;
             if (stored.sessionFile)
                 this.sessionFile = stored.sessionFile;
+            this.adopted = stored.adopted === true;
+            // Legacy released flags no longer gate adopted sessions.
         }
         catch {
             // First run for this thread.
@@ -1027,11 +1263,13 @@ class PiExecutor {
             id: this.sessionId ?? undefined,
             sessionFile: this.sessionFile ?? undefined,
             cwd: this.currentWorkingDirectory,
+            ...(this.adopted ? { adopted: true } : {}),
         };
         const temporaryPath = `${this.sessionFilePath}.${process.pid}.tmp`;
         try {
             fs.writeFileSync(temporaryPath, JSON.stringify(pointer), { encoding: 'utf8', mode: 0o600 });
             fs.renameSync(temporaryPath, this.sessionFilePath);
+            return true;
         }
         catch (error) {
             try {
@@ -1039,11 +1277,14 @@ class PiExecutor {
             }
             catch { /* ignore */ }
             console.warn('[PiExecutor] Failed to save Pi session pointer', error);
+            return false;
         }
     }
     clearPointer() {
         this.sessionId = null;
         this.sessionFile = null;
+        this.adopted = false;
+        this.freshSessionId = (0, crypto_1.randomUUID)();
         try {
             fs.unlinkSync(this.sessionFilePath);
         }