@thinkrun/cli 0.1.28 → 0.1.30

package/dist/src/adapters/local.js

@@ -9,9 +9,10 @@ import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { ApiError, SessionError } from '../errors.js';
 import { config } from '../config/store.js';
+import { resolveTabAuditState } from '@thinkrun/shared/audit-state';
 import { readBridgePort, DEFAULT_BRIDGE_PORT, BRIDGE_HEALTH_PROBE_TIMEOUT_MS, BRIDGE_REQUEST_TIMEOUT_MS, unwrapEvaluatePayload, } from '../utils.js';
 import { clearLocalSessionContext, getLocalSessionContext, setLocalSessionContext } from '../session/context.js';
-import { initCliSession, syncBrowserAction, syncScreenshotAction, closeCliSession, readCliSessionId, readCliNetworkCursor, writeCliNetworkCursor, } from '../session/cli-session-sync.js';
+import { initCliSession, syncBrowserAction, syncScreenshotAction, closeCliSession, readCliSessionId, readCliNetworkCursor, readCliAuditScreenshotState, writeCliNetworkCursor, writeCliAuditScreenshotState, unrefAbortSignal, } from '../session/cli-session-sync.js';
 import { acquireLock, getLockedBy, getWorkingLocation, releaseWorkingLocation, setWorkingLocation, updateWorkingLocationControlSession } from '../working-location.js';
 import { resolveAgentId } from '../session/agent-identity.js';
 import { localCommandRequiresTabError } from '../session/errors.js';
@@ -22,12 +23,19 @@ import { captureFingerprint, compareFingerprints } from '../obstacle-recovery/st
 import { classifyElementFailure } from '../obstacle-recovery/obstacle-classifier.js';
 import { getLocalCommandRetryProfileFromPath, } from './local-command-retry.js';
 import { LOCAL_BRIDGE_TYPED_TRANSPORT_RECOVERY_ATTEMPTS, LOCAL_BRIDGE_TYPED_EXTENSION_REVALIDATION_DELAYS_MS, LOCAL_BRIDGE_TYPED_RECENT_DISCONNECT_GRACE_MS, } from '../local-bridge-timing.js';
+import { redactSensitiveResult } from '@thinkrun/shared/sensitive-result-redaction';
 /** Tunable post-action settle delay (ms). React batches setState updates
  *  (~16ms); 50ms gives margin for async DOM mutations to settle. */
 const POST_ACTION_SETTLE_MS = 50;
 const FINGERPRINT_EVALUATE_TIMEOUT_MS = 2500;
 const MAX_NETWORK_REQUESTS_PER_SYNC = 200;
 const FINAL_NETWORK_FLUSH_TIMEOUT_MS = 5_000;
+const AUDIT_SCREENSHOT_TIMEOUT_MS = 8_000;
+const AUDIT_SCREENSHOT_SESSION_CEILING = 500;
+const AUDIT_SCREENSHOT_RECENT_KEY_LIMIT = 64;
+// Leave 1KB headroom under the backend's 10KB result cap so metadata wrapping
+// and transport encoding cannot push an otherwise-valid payload over the limit.
+const MAX_SYNC_RESULT_JSON_LENGTH = 9_000;
 /**
  * Actionable hints keyed by native host error codes.
  * These are surfaced in structured error output (--json mode) and TTY tips.
@@ -58,11 +66,89 @@ export function getNativeCodeHint(code) {
         return undefined;
     return NATIVE_CODE_HINTS[code];
 }
+function sanitizeAndTruncateSyncResult(value) {
+    return truncateSyncResult(redactSensitiveResult(value));
+}
+function truncateSyncResult(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string') {
+        if (JSON.stringify(value).length <= MAX_SYNC_RESULT_JSON_LENGTH)
+            return value;
+        const suffix = '... [truncated]';
+        let low = 0;
+        let high = value.length;
+        let best = suffix;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const candidate = `${value.slice(0, mid)}${suffix}`;
+            if (JSON.stringify(candidate).length <= MAX_SYNC_RESULT_JSON_LENGTH) {
+                best = candidate;
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        return best;
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized.length <= MAX_SYNC_RESULT_JSON_LENGTH)
+            return value;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const next = {};
+            for (const [key, entry] of Object.entries(value)) {
+                next[key] = truncateSyncResult(entry);
+                if (JSON.stringify(next).length > MAX_SYNC_RESULT_JSON_LENGTH) {
+                    next[key] = '[truncated]';
+                    if (JSON.stringify(next).length > MAX_SYNC_RESULT_JSON_LENGTH) {
+                        delete next[key];
+                        break;
+                    }
+                }
+            }
+            while (Object.keys(next).length > 0 && JSON.stringify(next).length > MAX_SYNC_RESULT_JSON_LENGTH) {
+                const lastKey = Object.keys(next).pop();
+                if (!lastKey)
+                    break;
+                delete next[lastKey];
+            }
+            if (JSON.stringify(next).length <= MAX_SYNC_RESULT_JSON_LENGTH)
+                return next;
+            return truncateSyncResult(serialized);
+        }
+        if (Array.isArray(value)) {
+            const next = [];
+            for (const entry of value) {
+                next.push(truncateSyncResult(entry));
+                if (JSON.stringify(next).length > MAX_SYNC_RESULT_JSON_LENGTH) {
+                    next[next.length - 1] = '[truncated]';
+                    if (JSON.stringify(next).length > MAX_SYNC_RESULT_JSON_LENGTH) {
+                        next.pop();
+                        break;
+                    }
+                }
+            }
+            while (next.length > 0 && JSON.stringify(next).length > MAX_SYNC_RESULT_JSON_LENGTH) {
+                next.pop();
+            }
+            if (JSON.stringify(next).length <= MAX_SYNC_RESULT_JSON_LENGTH)
+                return next;
+            return truncateSyncResult(serialized);
+        }
+        return '[truncated]';
+    }
+    catch {
+        return '[unserializable result omitted]';
+    }
+}
 export class LocalAdapter {
     baseUrl;
     defaultTimeout = 60000;
     validatedTabCache = new Map();
     syncedNetworkRequestMarkers = new Map();
+    auditScreenshotChains = new Map();
     TAB_CACHE_TTL_MS = 60_000;
     /** Injected fetch function — allows unit tests to intercept all HTTP calls. */
     fetchFn;
@@ -117,6 +203,102 @@ export class LocalAdapter {
             ? request.id
             : undefined;
     }
+    getScreenshotMimeType(format) {
+        return format === 'jpeg' ? 'image/jpeg'
+            : format === 'webp' ? 'image/webp'
+                : 'image/png';
+    }
+    buildAuditScreenshotCaption(type, details) {
+        const subject = typeof details['selector'] === 'string' ? details['selector']
+            : typeof details['url'] === 'string' ? details['url']
+                : typeof details['key'] === 'string' ? details['key']
+                    : 'page state';
+        return `Audit after ${type}: ${subject}`.slice(0, 240);
+    }
+    async runSerializedAuditScreenshotCapture(key, task) {
+        const prior = this.auditScreenshotChains.get(key) ?? Promise.resolve();
+        const current = prior.catch(() => { }).then(task);
+        this.auditScreenshotChains.set(key, current);
+        try {
+            await current;
+        }
+        finally {
+            if (this.auditScreenshotChains.get(key) === current) {
+                this.auditScreenshotChains.delete(key);
+            }
+        }
+    }
+    async captureAuditScreenshot(tabId, type, details) {
+        const auditState = resolveTabAuditState({ tabId });
+        if (!auditState.enabled)
+            return;
+        const persistedSessionId = readCliSessionId(tabId);
+        if (!persistedSessionId)
+            return;
+        const captureKey = `${tabId}:${persistedSessionId}`;
+        await this.runSerializedAuditScreenshotCapture(captureKey, async () => {
+            const dedupKey = typeof details['__auditActionId'] === 'string'
+                ? `${type}:${details['__auditActionId']}`
+                : undefined;
+            const persistedAuditState = readCliAuditScreenshotState(tabId, persistedSessionId) ?? { count: 0, recentKeys: [] };
+            if (dedupKey && persistedAuditState.recentKeys.includes(dedupKey))
+                return;
+            if (persistedAuditState.count >= AUDIT_SCREENSHOT_SESSION_CEILING) {
+                console.warn(`[thinkrun] audit screenshot ceiling reached for session ${persistedSessionId}; dropping additional audit frames`);
+                return;
+            }
+            const sessionId = this.tabOverride ? undefined : this.getAgentSessionId();
+            const headers = { 'Content-Type': 'application/json' };
+            if (sessionId)
+                headers['x-session-id'] = sessionId;
+            try {
+                const response = await this.fetchFn(`${this.baseUrl}/sessions/${tabId}/screenshot`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ type: 'png' }),
+                    signal: unrefAbortSignal(AUDIT_SCREENSHOT_TIMEOUT_MS),
+                });
+                const json = await response.json();
+                if (!response.ok || json?.success === false)
+                    return;
+                const screenshot = json?.data && typeof json.data === 'object'
+                    ? json.data.screenshot
+                    : json?.data;
+                if (typeof screenshot !== 'string' || screenshot.length === 0)
+                    return;
+                const delivered = await syncScreenshotAction(persistedSessionId, screenshot, this.getScreenshotMimeType('png'), this.buildAuditScreenshotCaption(type, details), typeof details['__auditTimestamp'] === 'string' ? details['__auditTimestamp'] : undefined, this.fetchFn);
+                if (!delivered)
+                    return;
+                writeCliAuditScreenshotState(tabId, persistedSessionId, {
+                    count: persistedAuditState.count + 1,
+                    recentKeys: dedupKey
+                        ? [...persistedAuditState.recentKeys, dedupKey].slice(-AUDIT_SCREENSHOT_RECENT_KEY_LIMIT)
+                        : persistedAuditState.recentKeys,
+                });
+            }
+            catch {
+                // Fire-and-forget audit capture must never break the primary action path.
+            }
+        });
+    }
+    triggerAuditScreenshot(tabId, type, details) {
+        this.captureAuditScreenshot(tabId, type, details).catch(() => {
+            // Explicit swallow so callers never observe audit capture failures.
+        });
+    }
+    createAuditActionId(type) {
+        return `${type}:${randomUUID()}`;
+    }
+    buildAuditCaptureDetails(type, actionId, details) {
+        const captureDetails = {
+            ...details,
+            // Post-action capture timestamp used to order deferred audit screenshots.
+            __auditTimestamp: new Date().toISOString(),
+        };
+        if (!actionId)
+            return captureDetails;
+        return { ...captureDetails, __auditActionId: actionId };
+    }
     getNetworkRequestMarker(request) {
         const method = typeof request.method === 'string' ? request.method : undefined;
         const url = typeof request.url === 'string' ? request.url : undefined;
@@ -711,7 +893,7 @@ export class LocalAdapter {
                         apiErr.retryHint = json.retryHint;
                     throw apiErr;
                 }
-                return json;
+                return { ...json, __thinkrunRequestId: requestId };
             }
             catch (error) {
                 this.logDiagnostics('bridge_request_error', {
@@ -823,6 +1005,7 @@ export class LocalAdapter {
     // --- Navigation ---
     async navigate(url, options = {}) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('navigate');
         try {
             const response = await this.request(`/sessions/${tabId}/navigate`, {
                 method: 'POST',
@@ -837,7 +1020,9 @@ export class LocalAdapter {
                 const syncedUrl = typeof response.data?.url === 'string' && response.data.url.length > 0
                     ? response.data.url
                     : url;
-                this.syncAction(tabId, 'navigate', { url: syncedUrl });
+                const syncDetails = { url: syncedUrl };
+                this.syncAction(tabId, 'navigate', syncDetails);
+                this.triggerAuditScreenshot(tabId, 'navigate', this.buildAuditCaptureDetails('navigate', auditActionId, syncDetails));
             }
             return { success: response.success, data: response.data };
         }
@@ -860,16 +1045,24 @@ export class LocalAdapter {
     }
     async goBack() {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('go-back');
         const response = await this.request(`/sessions/${tabId}/go-back`, { method: 'POST' });
-        if (response.success)
-            this.syncAction(tabId, 'go-back', {});
+        if (response.success) {
+            const syncDetails = {};
+            this.syncAction(tabId, 'go-back', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'go-back', this.buildAuditCaptureDetails('go-back', auditActionId, syncDetails));
+        }
         return { success: response.success, data: response.data };
     }
     async goForward() {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('go-forward');
         const response = await this.request(`/sessions/${tabId}/go-forward`, { method: 'POST' });
-        if (response.success)
-            this.syncAction(tabId, 'go-forward', {});
+        if (response.success) {
+            const syncDetails = {};
+            this.syncAction(tabId, 'go-forward', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'go-forward', this.buildAuditCaptureDetails('go-forward', auditActionId, syncDetails));
+        }
         return { success: response.success, data: response.data };
     }
     // --- Fingerprint + obstacle helpers ─────────────────────────────────────
@@ -924,6 +1117,7 @@ export class LocalAdapter {
     // --- Interaction ---
     async click(selector, options = {}) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('click');
         // Capture pre-action fingerprint (best-effort)
         const pre = await this.tryCaptureFP(selector);
         let response;
@@ -966,12 +1160,16 @@ export class LocalAdapter {
             }
             catch { /* fingerprint failure — do not break normal flow */ }
         }
-        if (response.success)
-            this.syncAction(tabId, 'click', { selector });
+        if (response.success) {
+            const syncDetails = { selector };
+            this.syncAction(tabId, 'click', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'click', this.buildAuditCaptureDetails('click', auditActionId, syncDetails));
+        }
         return { success: response.success };
     }
     async clickAt(x, y, options = {}) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('click_at');
         // Coordinate clicks are an escape hatch when semantic targeting has already
         // failed, so there is no stable selector to fingerprint pre/post here.
         const response = await this.request(`/sessions/${tabId}/click-at`, {
@@ -984,12 +1182,16 @@ export class LocalAdapter {
                 timeout: options.timeout ?? 15000,
             }),
         });
-        if (response.success)
-            this.syncAction(tabId, 'click_at', { x, y, coordinateSpace: 'viewport' });
+        if (response.success) {
+            const syncDetails = { x, y, coordinateSpace: 'viewport' };
+            this.syncAction(tabId, 'click_at', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'click_at', this.buildAuditCaptureDetails('click_at', auditActionId, syncDetails));
+        }
         return { success: response.success, data: response.data };
     }
     async type(selector, text, options = {}) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('type');
         const pre = await this.tryCaptureFP(selector);
         let response;
         try {
@@ -1023,12 +1225,16 @@ export class LocalAdapter {
             }
             catch { /* fingerprint failure — do not break normal flow */ }
         }
-        if (response.success)
-            this.syncAction(tabId, 'type', { selector });
+        if (response.success) {
+            const syncDetails = { selector };
+            this.syncAction(tabId, 'type', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'type', this.buildAuditCaptureDetails('type', auditActionId, syncDetails));
+        }
         return { success: response.success };
     }
     async fill(selector, value) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('fill');
         const pre = await this.tryCaptureFP(selector);
         let response;
         try {
@@ -1062,18 +1268,25 @@ export class LocalAdapter {
             }
             catch { /* fingerprint failure — do not break normal flow */ }
         }
-        if (response.success)
-            this.syncAction(tabId, 'fill', { selector });
+        if (response.success) {
+            const syncDetails = { selector };
+            this.syncAction(tabId, 'fill', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'fill', this.buildAuditCaptureDetails('fill', auditActionId, syncDetails));
+        }
         return { success: response.success };
     }
     async press(key) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('press');
         const response = await this.request(`/sessions/${tabId}/press`, {
             method: 'POST',
             body: JSON.stringify({ key }),
         });
-        if (response.success)
-            this.syncAction(tabId, 'press', { key });
+        if (response.success) {
+            const syncDetails = { key };
+            this.syncAction(tabId, 'press', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'press', this.buildAuditCaptureDetails('press', auditActionId, syncDetails));
+        }
         return { success: response.success };
     }
     async scroll(options) {
@@ -1081,6 +1294,7 @@ export class LocalAdapter {
         // Selector-based: scroll element into view via evaluate, but sync as 'scroll'
         // (not 'evaluate') so the activity feed shows the user-facing action type.
         if (options.selector) {
+            const auditActionId = this.createAuditActionId('scroll');
             const resp = await this.request(`/sessions/${tabId}/evaluate`, {
                 method: 'POST',
                 body: JSON.stringify({
@@ -1088,8 +1302,11 @@ export class LocalAdapter {
                     args: [],
                 }),
             });
-            if (resp.success)
-                this.syncAction(tabId, 'scroll', { selector: options.selector });
+            if (resp.success) {
+                const syncDetails = { selector: options.selector };
+                this.syncAction(tabId, 'scroll', syncDetails);
+                this.triggerAuditScreenshot(tabId, 'scroll', this.buildAuditCaptureDetails('scroll', auditActionId, syncDetails));
+            }
             return { success: resp.success, data: resp.data };
         }
         // Horizontal scroll is not supported by the native host's handleScroll (which only
@@ -1101,23 +1318,31 @@ export class LocalAdapter {
         // Translate y offset → {direction, amount} as expected by native host handleScroll
         const direction = (options.y !== undefined && options.y < 0) ? 'up' : 'down';
         const amount = options.y !== undefined ? Math.abs(options.y) : 500;
+        const auditActionId = this.createAuditActionId('scroll');
         const response = await this.request(`/sessions/${tabId}/scroll`, {
             method: 'POST',
             body: JSON.stringify({ direction, amount }),
         });
-        if (response.success)
-            this.syncAction(tabId, 'scroll', { direction, amount });
+        if (response.success) {
+            const syncDetails = { direction, amount };
+            this.syncAction(tabId, 'scroll', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'scroll', this.buildAuditCaptureDetails('scroll', auditActionId, syncDetails));
+        }
         return { success: response.success };
     }
     async hover(selector) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('hover');
         try {
             const response = await this.request(`/sessions/${tabId}/hover`, {
                 method: 'POST',
                 body: JSON.stringify({ selector }),
             });
-            if (response.success)
-                this.syncAction(tabId, 'hover', { selector });
+            if (response.success) {
+                const syncDetails = { selector };
+                this.syncAction(tabId, 'hover', syncDetails);
+                this.triggerAuditScreenshot(tabId, 'hover', this.buildAuditCaptureDetails('hover', auditActionId, syncDetails));
+            }
             return { success: response.success };
         }
         catch (err) {
@@ -1129,6 +1354,7 @@ export class LocalAdapter {
     }
     async select(selector, value) {
         const tabId = await this.getActiveTabId();
+        const auditActionId = this.createAuditActionId('select');
         const pre = await this.tryCaptureFP(selector);
         let response;
         try {
@@ -1181,8 +1407,11 @@ export class LocalAdapter {
             }
             catch { /* fingerprint failure — do not break normal flow */ }
         }
-        if (response.success)
-            this.syncAction(tabId, 'select', { selector });
+        if (response.success) {
+            const syncDetails = { selector };
+            this.syncAction(tabId, 'select', syncDetails);
+            this.triggerAuditScreenshot(tabId, 'select', this.buildAuditCaptureDetails('select', auditActionId, syncDetails));
+        }
         return { success: response.success };
     }
     // --- Waiting ---
@@ -1245,9 +1474,7 @@ export class LocalAdapter {
             const tempPath = join(tmpdir(), `thinkrun-${ts}-${randomUUID().slice(0, 8)}.png`);
             writeFileSync(tempPath, Buffer.from(b64, 'base64'));
             // Derive MIME type once — used for both the artifact upload and the sync action.
-            const mimeType = options.format === 'jpeg' ? 'image/jpeg'
-                : options.format === 'webp' ? 'image/webp'
-                    : 'image/png';
+            const mimeType = this.getScreenshotMimeType(options.format);
             // If this local tab has a registered cloud session (from startSession()), sync
             // the screenshot as an action in the activity feed.  Fire-and-forget — never
             // blocks the caller.
@@ -1263,7 +1490,7 @@ export class LocalAdapter {
                     if (!caption) {
                         throw new Error('Local screenshots synced to ThinkRun require --caption <text>');
                     }
-                    syncScreenshotAction(persistedSessionId, b64, mimeType, caption, this.fetchFn);
+                    syncScreenshotAction(persistedSessionId, b64, mimeType, caption, undefined, this.fetchFn);
                 }
             }
             // If API key is configured, upload to cloud artifact storage so the screenshot
@@ -1323,8 +1550,9 @@ export class LocalAdapter {
                 multiple: options.all,
             }),
         });
-        if (response.success)
-            this.syncAction(tabId, 'extract', { selector: selector || 'page' });
+        if (response.success) {
+            this.syncAction(tabId, 'extract', { selector: selector || 'page' }, { result: sanitizeAndTruncateSyncResult(response.data) });
+        }
         return { success: response.success, data: response.data };
     }
     async evaluate(script, args = [], evalOpts) {
@@ -1336,7 +1564,7 @@ export class LocalAdapter {
             timeoutMs: Math.min(timeoutMs + 15_000, 615_000),
         });
         if (response.success)
-            this.syncAction(tabId, 'evaluate', {}, { result: response.data });
+            this.syncAction(tabId, 'evaluate', {}, { result: sanitizeAndTruncateSyncResult(response.data) });
         return { success: response.success, data: response.data };
     }
     async getUrl() {