@superblocksteam/vite-plugin-file-sync 2.0.130-next.4 → 2.0.130-next.6

package/dist/ai-service/index.js

@@ -32,7 +32,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";
@@ -55,6 +55,8 @@ 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 { buildServerMigrationLlmConfig } from "./migration-llm-config.js";
 import { policyGateStreamPartToAgentStep } from "./policy-gate-step.js";
 import { ClarkProfiler } from "./profiler/clark-profiler.js";
 import { explainEventHandlerCodePrompt } from "./prompts/explain-code.js";
@@ -62,6 +64,7 @@ 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";
@@ -80,6 +83,7 @@ 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 { createJsonStreamParser } from "./util/json-stream-parser.js";
 import { processLLMConfig } from "./util/llm-config-utils.js";
 import { parseJwt } from "./util/parse-jwt.js";
@@ -359,6 +363,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);
@@ -458,9 +465,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 =====
     /**
@@ -878,7 +892,7 @@ export class AiService extends TracedEventEmitter {
         }
         // Reset stale in_progress items to pending. After a dev-server restart,
         // items left in_progress are not truly running — resetting them allows
-        // the UI polling trigger and backend handler to re-dispatch Clark.
+        // auto-dispatch and the UI polling trigger to re-dispatch Clark.
         const staleInProgressItems = checklist.items.filter((item) => API_MIGRATION_ORIGINS.has(item.origin) && item.status === "in_progress");
         for (const item of staleInProgressItems) {
             await updateChecklistItem({
@@ -920,6 +934,130 @@ 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;
+        }
+        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 {
+            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.
@@ -1256,12 +1394,16 @@ 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);
         // 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.
@@ -1287,8 +1429,10 @@ export class AiService extends TracedEventEmitter {
                 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");
             return { dispatched: false, reason: "checklist-unavailable" };
         }
@@ -1296,6 +1440,7 @@ export class AiService extends TracedEventEmitter {
             (item.status === "pending" || item.status === "in_progress"));
         const pendingSeedApiCount = pendingSeedApiItems.length;
         if (pendingSeedApiCount === 0) {
+            this.migrationTurnTriggered = false;
             return { dispatched: false, reason: "no-pending-items" };
         }
         // Pre-flight quota gate. The migration turn drives LLM inference (which
@@ -1307,10 +1452,10 @@ 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 });
             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({
@@ -1332,6 +1477,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,
@@ -1676,6 +1823,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) {
             throw new Error("Service is unavailable");
         }
@@ -2886,6 +3034,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}`);
@@ -2917,9 +3071,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) {
@@ -2970,6 +3125,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