@superblocksteam/vite-plugin-file-sync 2.0.140 → 2.0.141-next.0

package/dist/ai-service/index.js

@@ -30,7 +30,7 @@ import { AppSkillsManager } from "./app-skills/manager.js";
 import { isUploadedAttachment, toUploadedAttachmentContentPart, } from "./attachments/uploaded-content-part.js";
 import { ChatSessionStore } from "./chat/chat-session-store.js";
 import { normalizeTextAttachmentForModel } from "./chat/utils.js";
-import { API_MIGRATION_ORIGINS, readPersistedChecklist, updateChecklistItem, } from "./checklist/persisted-checklist-store.js";
+import { API_MIGRATION_ORIGINS, isApiMigrationOrigin, readPersistedChecklist, updateChecklistItem, } from "./checklist/persisted-checklist-store.js";
 import { downloadContextFromBucketeer, downloadLatestContextFromBucketeer, restoreContextFromCheckpoint, } from "./context-download.js";
 import { uploadContextToBucketeer } from "./context-upload.js";
 import { AppContextStore } from "./context/app-context.js";
@@ -53,12 +53,17 @@ import { traceLLM } from "./llmobs/helpers.js";
 import { getJwtTraceTags } from "./llmobs/helpers.js";
 import llmobs from "./llmobs/index.js";
 import { PlaywrightMcpServerManager } from "./mcp/playwright-server.js";
+import { evaluateMigrationAutoDispatchReadiness } from "./migration-auto-dispatch-readiness.js";
+import { recordMigrationAutoDispatchOutcome } from "./migration-autodispatch-metrics.js";
+import { buildServerMigrationLlmConfig, isMigrationAutoDispatchEnabled, } from "./migration-llm-config.js";
+import { isMigrationSessionActive } from "./migration-session-active.js";
 import { policyGateStreamPartToAgentStep } from "./policy-gate-step.js";
 import { ClarkProfiler } from "./profiler/clark-profiler.js";
 import { buildSummarizeApiUsagePrompt } from "./prompts/summarize-api-usage.js";
 import { checkAiQuota } from "./quota-client.js";
 import { RecordingManager, createRecordingFetch } from "./recording/index.js";
 import { RequestDeduplicator } from "./request-deduplicator.js";
+import { resolveGenerationStateForUi } from "./resolve-generation-state-for-ui.js";
 import { scanContentForSecrets } from "./security/secret-scanner-service.js";
 import { SecretRedactor } from "./security/secret-scanner.js";
 import { ClarkStateNames, Clark, SERVICE_STARTED_WITH_DRAFT, USER_ACCEPTED_DRAFT, USER_REJECTED_DRAFT, USER_SENT_PROMPT, USER_CANCELED, AGENT_CANCELED, } from "./state-machine/clark-fsm.js";
@@ -78,10 +83,22 @@ import { catchBackgroundPeerDisconnect, StablePeer, } from "./state-machine/help
 import { transitionFrom } from "./state-machine/helpers/transition.js";
 import { isTaskAccessibleTo, registerBackgroundTaskTypes, resyncActiveTaskStatusesToPeer, TaskStore, wireTaskStatusPushToPeer, } from "./tasks/index.js";
 import { TemplateRenderer } from "./template-renderer.js";
+import { describeMigrationInferenceJwt, isUsableMigrationInferenceJwt, } from "./util/inference-jwt.js";
 import { processLLMConfig } from "./util/llm-config-utils.js";
 import { parseJwt } from "./util/parse-jwt.js";
 import { getToolCallSignature } from "./util/tool-signature.js";
 export { AiServiceFeatureFlags } from "./features.js";
+function streamRetryOptionsFromConfig(retryOptions, streamTimeoutBudgets) {
+    if (streamTimeoutBudgets === undefined ||
+        Object.keys(streamTimeoutBudgets).length === 0) {
+        return retryOptions;
+    }
+    return {
+        ...retryOptions,
+        streamTimeoutBudgets,
+        timeoutSource: "feature-flag",
+    };
+}
 export { stripResolvedFromLockfile } from "./app-interface/npm-registry.js";
 export { SnapshotManager } from "./recording/index.js";
 export { isSdkApiTemplate } from "./sdk-api-templates.js";
@@ -357,6 +374,9 @@ export class AiService extends TracedEventEmitter {
         try {
             this.tokenManagerJwt = event.token;
             this.getLogger().info(`[ai-service] token updated via tokenManager`);
+            if (event.token && isUsableMigrationInferenceJwt(event.token)) {
+                this.updateClarkJwt(event.token);
+            }
         }
         catch (err) {
             console.error("[ai-service] tokenUpdated listener threw", err);
@@ -456,9 +476,16 @@ export class AiService extends TracedEventEmitter {
      * Updates the JWT in Clark context
      */
     updateClarkJwt(jwt) {
-        if (jwt) {
-            this.clark.updateContext({ jwt });
+        const jwtDetails = describeMigrationInferenceJwt(jwt);
+        if (!jwt || !jwtDetails.usable) {
+            return;
         }
+        this.clark.updateContext({ jwt });
+        const llmConfig = this.lastMigrationTurnCredentials?.llmConfig ??
+            this.clark.context.llmConfig ??
+            buildServerMigrationLlmConfig(this.config.flagBootstrap);
+        this.storeMigrationTurnCredentials(jwt, llmConfig);
+        this.tryAutoDispatchMigrationTurnIfReady();
     }
     // ===== Recording API =====
     /**
@@ -771,7 +798,7 @@ export class AiService extends TracedEventEmitter {
         this.llmClient = new LLMClient({
             contextManagerV2: this.contextManagerV2,
             appShell: this.appShell,
-            retryOptions: config.retryOptions,
+            retryOptions: streamRetryOptionsFromConfig(config.retryOptions, config.features.streamTimeoutBudgets),
             unifiedProviderEnabled: config.features.unifiedProviderEnabled ?? false,
             organizationId: config.organizationId,
             applicationId: config.applicationId,
@@ -916,6 +943,142 @@ export class AiService extends TracedEventEmitter {
                 },
             });
         }
+        this.tryAutoDispatchMigrationTurnIfReady();
+    }
+    migrationAppArtifactsReady = false;
+    migrationAutoDispatchPending = false;
+    migrationAutoDispatchInFlight = false;
+    lastMigrationTurnCredentials;
+    hasInitialPendingMigrationWork(items) {
+        const pendingItems = items.filter((item) => isApiMigrationOrigin(item.origin) &&
+            (item.status === "pending" || item.status === "in_progress"));
+        if (pendingItems.length === 0) {
+            return false;
+        }
+        return !pendingItems.some((item) => item.lastFailureReason);
+    }
+    resolveMigrationTurnCredentials() {
+        const cachedJwt = this.lastMigrationTurnCredentials?.jwt;
+        const inferenceJwt = this.getInferenceJwt();
+        const jwt = (cachedJwt && isUsableMigrationInferenceJwt(cachedJwt)
+            ? cachedJwt
+            : undefined) ??
+            (inferenceJwt && isUsableMigrationInferenceJwt(inferenceJwt)
+                ? inferenceJwt
+                : undefined);
+        const llmConfig = this.lastMigrationTurnCredentials?.llmConfig ??
+            this.clark.context.llmConfig ??
+            buildServerMigrationLlmConfig(this.config.flagBootstrap);
+        return { jwt, llmConfig };
+    }
+    storeMigrationTurnCredentials(jwt, llmConfig) {
+        const nextJwt = jwt && jwt.length > 0 ? jwt : this.lastMigrationTurnCredentials?.jwt;
+        this.lastMigrationTurnCredentials = {
+            ...(nextJwt ? { jwt: nextJwt } : {}),
+            llmConfig,
+        };
+        if (jwt && jwt.length > 0 && !this.getInferenceJwt()) {
+            this.clark.updateContext({ jwt });
+        }
+    }
+    isRetriableMigrationAutoDispatchFailure(reason) {
+        if (!reason) {
+            return false;
+        }
+        return (reason.startsWith("busy:") ||
+            reason === "pending-tool-permission" ||
+            reason === "awaiting-interactive-response");
+    }
+    /**
+     * Called by dev startup once DBFS download (or upload-first local tree)
+     * has finished so migration scratch/checklist files are on disk.
+     */
+    notifyMigrationAppArtifactsReady() {
+        if (this.migrationAppArtifactsReady) {
+            return;
+        }
+        this.migrationAppArtifactsReady = true;
+        this.tryAutoDispatchMigrationTurnIfReady();
+    }
+    tryAutoDispatchMigrationTurnIfReady() {
+        if (this.migrationAutoDispatchInFlight) {
+            return;
+        }
+        if (!isMigrationAutoDispatchEnabled(this.config.flagBootstrap)) {
+            return;
+        }
+        const { jwt } = this.resolveMigrationTurnCredentials();
+        const readiness = evaluateMigrationAutoDispatchReadiness({
+            appArtifactsReady: this.migrationAppArtifactsReady,
+            hasConnectedPeer: this.hasConnectedPeer(),
+            hasUsableJwt: Boolean(jwt),
+        });
+        if (!readiness.ready) {
+            if (readiness.reason === "jwt-unavailable") {
+                this.migrationAutoDispatchPending = true;
+            }
+            return;
+        }
+        void this.maybeAutoDispatchMigrationTurn().catch((error) => {
+            this.getLogger().error("[ai-service] Migration auto-dispatch failed", getErrorMeta(error));
+        });
+    }
+    /**
+     * Attempts to start the initial post-flip migration turn without UI
+     * involvement. Skips user-initiated focused-debug retries (items with
+     * `lastFailureReason`) and defers when JWT is unavailable.
+     */
+    async maybeAutoDispatchMigrationTurn() {
+        if (this.migrationAutoDispatchInFlight) {
+            return;
+        }
+        this.migrationAutoDispatchInFlight = true;
+        try {
+            // Positive migration-session gate. Only auto-dispatch while a migration
+            // session is genuinely in flight on disk (scratch/migration-state.json).
+            // Completion and abort both remove it, so a stale checklist on a
+            // never-migrated or already-finished app can never arm auto-dispatch
+            // during normal usage — bounding the blast radius to migrations.
+            if (!(await isMigrationSessionActive(this.appRootDirPath))) {
+                this.migrationAutoDispatchPending = false;
+                return;
+            }
+            const checklist = await readPersistedChecklist(this.appRootDirPath);
+            if (!checklist) {
+                this.migrationAutoDispatchPending = false;
+                return;
+            }
+            if (!this.hasInitialPendingMigrationWork(checklist.items)) {
+                this.migrationAutoDispatchPending = false;
+                return;
+            }
+            const { jwt, llmConfig } = this.resolveMigrationTurnCredentials();
+            if (!jwt) {
+                this.migrationAutoDispatchPending = true;
+                return;
+            }
+            const result = await this.handleAiTriggerMigrationTurn({
+                jwt,
+                llmConfig,
+                triggeredBy: "auto-dispatch",
+            });
+            if (result.dispatched) {
+                this.migrationAutoDispatchPending = false;
+                this.getLogger().info("[ai-service] Auto-dispatched post-flip migration turn");
+            }
+            else if (result.reason === "already-triggered") {
+                this.migrationAutoDispatchPending = false;
+            }
+            else if (this.isRetriableMigrationAutoDispatchFailure(result.reason)) {
+                this.migrationAutoDispatchPending = true;
+            }
+            else {
+                this.migrationAutoDispatchPending = false;
+            }
+        }
+        finally {
+            this.migrationAutoDispatchInFlight = false;
+        }
     }
     /**
      * Remove the integration metadata cache for this session.
@@ -1317,12 +1480,22 @@ export class AiService extends TracedEventEmitter {
      * per ai-service lifetime. The disk checklist is the recovery source of
      * truth across process restarts.
      *
-     * Expected caller: the UI issues a dedicated RPC (see
-     * v1.ai.triggerMigrationTurn) once it observes the post-flip state via
-     * /sb-migration-status. jwt + llmConfig come from the UI's normal auth
-     * flow.
+     * Primary auto-trigger: readiness gate (`notifyMigrationAppArtifactsReady`,
+     * `handleUserConnected`, `updateClarkJwt`) →
+     * `tryAutoDispatchMigrationTurnIfReady` → `maybeAutoDispatchMigrationTurn`.
+     * Backup caller: the UI RPC (see v1.ai.triggerMigrationTurn) once it
+     * observes the post-flip state via /sb-migration-status.
+     * User retry after unresolved failures: UI RPC with
+     * `retryMode: "focused-debug"` after /sb-migration-retry-unresolved.
      */
     async handleAiTriggerMigrationTurn(request) {
+        this.storeMigrationTurnCredentials(request.jwt, request.llmConfig);
+        const isAutoDispatch = request.triggeredBy === "auto-dispatch";
+        const recordAutoDispatchOutcome = (reason) => {
+            if (isAutoDispatch) {
+                recordMigrationAutoDispatchOutcome(reason);
+            }
+        };
         // User-initiated "Fix with Clark" retries bypass the one-shot
         // guard. The HTTP route that flips the items has already landed,
         // so if we refused here the user would be stuck.
@@ -1330,33 +1503,44 @@ export class AiService extends TracedEventEmitter {
             this.migrationTurnTriggered = false;
         }
         if (this.migrationTurnTriggered) {
+            recordAutoDispatchOutcome("already-triggered");
             return { dispatched: false, reason: "already-triggered" };
         }
         if (this.clark.state === ClarkStateNames.Dead) {
+            recordAutoDispatchOutcome("dead");
             return { dispatched: false, reason: "dead" };
         }
         if (this.clark.state !== ClarkStateNames.Idle &&
             this.clark.state !== ClarkStateNames.AwaitingUser) {
-            return { dispatched: false, reason: `busy:${this.clark.state}` };
+            const reason = `busy:${this.clark.state}`;
+            recordAutoDispatchOutcome(reason);
+            return { dispatched: false, reason };
         }
         if (this.clark.context.pendingToolPermissionRequest) {
+            recordAutoDispatchOutcome("pending-tool-permission");
             return { dispatched: false, reason: "pending-tool-permission" };
         }
         if (this.clark.state === ClarkStateNames.AwaitingUser) {
             if (this.clark.context.activeInteractiveMessage ||
                 this.clark.context.deferredInteractiveMessage) {
+                recordAutoDispatchOutcome("awaiting-interactive-response");
                 return { dispatched: false, reason: "awaiting-interactive-response" };
             }
         }
+        this.migrationTurnTriggered = true;
         const checklist = await readPersistedChecklist(this.appRootDirPath);
         if (!checklist) {
+            this.migrationTurnTriggered = false;
             this.getLogger().warn("[ai-service] Migration checklist not found or unreadable; skipping translation turn");
+            recordAutoDispatchOutcome("checklist-unavailable");
             return { dispatched: false, reason: "checklist-unavailable" };
         }
         const pendingSeedApiItems = checklist.items.filter((item) => API_MIGRATION_ORIGINS.has(item.origin) &&
             (item.status === "pending" || item.status === "in_progress"));
         const pendingSeedApiCount = pendingSeedApiItems.length;
         if (pendingSeedApiCount === 0) {
+            this.migrationTurnTriggered = false;
+            recordAutoDispatchOutcome("no-pending-items");
             return { dispatched: false, reason: "no-pending-items" };
         }
         // Pre-flight quota gate. The migration turn drives LLM inference (which
@@ -1368,10 +1552,11 @@ export class AiService extends TracedEventEmitter {
         // same pre-flight check handleAiGenerate already runs.
         const quota = await this.checkAiQuota(request.jwt);
         if (!quota.allowed) {
+            this.migrationTurnTriggered = false;
             this.getLogger().warn("[ai-service] Skipping v2→v3 migration turn — AI quota exceeded", { reason: quota.reason });
+            recordAutoDispatchOutcome("quota-exceeded");
             return { dispatched: false, reason: "quota-exceeded" };
         }
-        this.migrationTurnTriggered = true;
         this.appShell.setApiHandlerEnabled(false);
         this.getLogger().info(`[ai-service] Dispatching internal v2→v3 migration turn for ${pendingSeedApiCount} API(s) (API VFS projection disabled, retryMode=${request.retryMode ?? "none"})`);
         const prompt = buildTranslationPrompt({
@@ -1393,6 +1578,8 @@ export class AiService extends TracedEventEmitter {
             origin: "app_migration",
             pendingSeedApiCount,
             retryMode: request.retryMode ?? "none",
+            triggeredBy: request.triggeredBy ??
+                (request.retryMode === "focused-debug" ? "focused-debug" : "ui-rpc"),
         };
         this.clark.updateContext((context) => ({
             ...context,
@@ -1419,6 +1606,7 @@ export class AiService extends TracedEventEmitter {
             this.migrationTurnTriggered = false;
             this.appShell.setApiHandlerEnabled(true);
         });
+        recordAutoDispatchOutcome("dispatched");
         return { dispatched: true };
     }
     getMigrationSafeLlmConfig(llmConfig) {
@@ -1737,6 +1925,7 @@ export class AiService extends TracedEventEmitter {
     }
     async handleAiGenerate(request) {
         this.getLogger().info(`[ai-service] handleAiGenerate: peerId=${this.stablePeer.peerId ?? "unknown"}`);
+        this.storeMigrationTurnCredentials(request.jwt, request.llmConfig);
         if (this.clark.state === ClarkStateNames.Dead) {
             recordPromptEntryRejection({
                 dedupeKey: resolvePromptRequestDedupeKey(request),
@@ -2895,6 +3084,12 @@ export class AiService extends TracedEventEmitter {
         }
         return `Continue with the task using alternative approaches. The tool ${toolName} was denied permission.`;
     }
+    resolveGenerationStateForUi() {
+        return resolveGenerationStateForUi({
+            clarkState: this.clark.state,
+            lastGenerationState: this.clark.context.lastGenerationState,
+        });
+    }
     handleUserConnected(peer, peerId) {
         const existingPeerId = this.stablePeer.peerId;
         this.getLogger().info(`[ai-service] handleUserConnected: peerId=${peerId}`);
@@ -2926,9 +3121,10 @@ export class AiService extends TracedEventEmitter {
             this.authenticatedPeerUserId = undefined;
         }
         // 1. Sync generation state if generation is in progress
-        if (this.clark.context.lastGenerationState) {
-            this.getLogger().info(`[ai-service] Syncing generation state on reconnect: ${this.clark.context.lastGenerationState.state}`);
-            catchBackgroundPeerDisconnect(peer.call.aiSetGenerationState(this.clark.context.lastGenerationState), "generation state reconnect push");
+        const generationState = this.resolveGenerationStateForUi();
+        if (generationState) {
+            this.getLogger().info(`[ai-service] Syncing generation state on reconnect: ${generationState.state}`);
+            catchBackgroundPeerDisconnect(peer.call.aiSetGenerationState(generationState), "generation state reconnect push");
         }
         // 2. Sync tool permission state with the UI
         if (this.clark.context.pendingToolPermissionRequest) {
@@ -2979,6 +3175,7 @@ export class AiService extends TracedEventEmitter {
         if (this.taskStore) {
             this.pendingTaskResyncPeerIds.add(peerId);
         }
+        this.tryAutoDispatchMigrationTurnIfReady();
     }
     /**
      * Per-session set of peer IDs that connected since their last task