@volter/supercode-frontend-vscode 0.1.33 → 0.1.35

package/README.md

@@ -24,6 +24,25 @@ Gallery detection reads the host's `product.json` through `vscode.workspace.fs`
 at `vscode.env.appRoot`; hosts without an inspectable gallery configuration hide
 the choice. Neither the extension nor its credentials are bundled or copied.
 
+The welcome's primary action uses `supercode.frontend.beginChatGPTSignIn`:
+it starts one retained install/sidebar operation and returns a copied receipt
+with its id, timestamps and current phase. This is a launch receipt, not proof
+that installation, sidebar presentation or authentication succeeded. A second
+begin while that operation is running returns the same id and starts no extra
+installation. `supercode.frontend.chatGPTSignInStatus` reads its current phase
+locally without waiting for host readiness or installation; pass the operation
+id to receive only that operation (a mismatched id returns null).
+Phases name the selected work before its awaited command: `checking-gallery`,
+`installing-extension`, `opening-sidebar`, then `completed` or `failed`.
+Completed means the official command sequence fulfilled, not signed in. Failures
+remain in operation status and the existing native error notification/output.
+Only the current or most recent operation is retained, for this extension-window
+lifetime; reload does not restore or automatically retry it. Runtime status
+inspection also includes this snapshot as `chatGPTSignIn`.
+The existing `supercode.frontend.signInWithChatGPT` still awaits the same work
+with its existing error-notification/fulfillment behavior, and the agent picker
+continues to use it. Ordinary relay budgets and draft guards are unchanged.
+
 The optional host-controls state can include `setup: { ready, actions, reason,
 cwd }`. Each action supplies `kind` (`login` or `install`), `harness`, `name` and
 the exact `command` revalidated before execution. On a signed-out first open,
@@ -373,3 +392,14 @@ routing: stock code broadcasts changes to all input states of a provider. The
 Volter overlay guards this fix with a native regression test. The former legacy
 option-notification queue is no longer required. The narrow reveal/focus bridge
 remains because the native model catalogue and participant identity are provider-wide.
+
+### Native approval cards
+
+A host advertising `volter.chat.inTurnApprovalCapability` version 1 presents
+actual approval requests in its native confirmation card. The original offered
+labels, order and response payloads are preserved. Clicking answers the pending
+request inside the current turn through `supercode.frontend.respondInTurnApproval`;
+it never submits a new chat prompt. The host guards the addressed conversation,
+disables the choices during dispatch and retires them only after an acknowledged
+response or an already-resolved result. Hosts without this capability retain
+stable command buttons. Other request kinds retain their existing presentation.

package/dist/chat-setup.d.ts

@@ -2,12 +2,22 @@
 import * as vscode from 'vscode';
 import type { ChatSetupState } from './host-controls.js';
 export declare const CHATGPT_SIGN_IN = "supercode.frontend.signInWithChatGPT";
+export declare const CHATGPT_SIGN_IN_BEGIN = "supercode.frontend.beginChatGPTSignIn";
+export declare const CHATGPT_SIGN_IN_STATUS = "supercode.frontend.chatGPTSignInStatus";
+export type ChatGPTSignInWorkPhase = 'checking-gallery' | 'installing-extension' | 'opening-sidebar';
+export interface ChatGPTSignInOperation {
+    readonly id: string;
+    readonly phase: ChatGPTSignInWorkPhase | 'completed' | 'failed';
+    readonly startedAt: number;
+    readonly updatedAt: number;
+    readonly finishedAt?: number;
+}
 /** The install command also exists in gallery-less Code-OSS. Fail closed when
  * the host's product configuration cannot be inspected through the VS Code API. */
 export declare function chatGPTAvailable(): Promise<boolean>;
 /** Only called by an explicit click. The gallery and extension own installation
  * and authentication; there is no terminal or provider credential handling here. */
-export declare function signInWithChatGPT(): Promise<void>;
+export declare function signInWithChatGPT(report?: (phase: ChatGPTSignInWorkPhase) => void): Promise<void>;
 /** Empty-chat welcome content, rendered by Code-OSS's ChatViewWelcomePart.
  * Only the official extension gets the primary button; native local sign-in
  * actions remain ordinary links. Commands and host diagnostic paths stay out

package/dist/chat-setup.js

@@ -1,6 +1,8 @@
 /** Native Chat presentation; the host supplies inventory and terminal actions. */
 import * as vscode from 'vscode';
 export const CHATGPT_SIGN_IN = 'supercode.frontend.signInWithChatGPT';
+export const CHATGPT_SIGN_IN_BEGIN = 'supercode.frontend.beginChatGPTSignIn';
+export const CHATGPT_SIGN_IN_STATUS = 'supercode.frontend.chatGPTSignInStatus';
 const CODEX_EXTENSION = 'openai.chatgpt';
 const INSTALL_EXTENSION = 'workbench.extensions.installExtension';
 /** The install command also exists in gallery-less Code-OSS. Fail closed when
@@ -20,16 +22,19 @@ export async function chatGPTAvailable() {
 }
 /** Only called by an explicit click. The gallery and extension own installation
  * and authentication; there is no terminal or provider credential handling here. */
-export async function signInWithChatGPT() {
+export async function signInWithChatGPT(report) {
+    report?.('checking-gallery');
     if (!await chatGPTAvailable())
         throw new Error('This host does not provide an extension gallery.');
     if (!vscode.extensions.getExtension(CODEX_EXTENSION)) {
         // enable makes the workbench await the running extension registry, not
         // just the installed inventory, before we dispatch the contributed command.
+        report?.('installing-extension');
         await vscode.commands.executeCommand(INSTALL_EXTENSION, CODEX_EXTENSION, { enable: true });
     }
     // openai.chatgpt contributes this command, not a public sign-in command.
     // Revealing its sidebar presents its own Sign in with ChatGPT when signed out.
+    report?.('opening-sidebar');
     await vscode.commands.executeCommand('chatgpt.openSidebar');
 }
 /** Empty-chat welcome content, rendered by Code-OSS's ChatViewWelcomePart.
@@ -38,9 +43,9 @@ export async function signInWithChatGPT() {
  * of the welcome, and the host still revalidates every action on click. */
 export function setupWelcome(setup, chatGPT = false) {
     const welcome = new vscode.MarkdownString();
-    welcome.isTrusted = { enabledCommands: [CHATGPT_SIGN_IN, 'supercode.frontend.setup', 'supercode.frontend.refreshSetup'] };
+    welcome.isTrusted = { enabledCommands: [CHATGPT_SIGN_IN_BEGIN, 'supercode.frontend.setup', 'supercode.frontend.refreshSetup'] };
     if (chatGPT) {
-        welcome.appendMarkdown(`[Sign in with ChatGPT](command:${CHATGPT_SIGN_IN})\n\n`);
+        welcome.appendMarkdown(`[Sign in with ChatGPT](command:${CHATGPT_SIGN_IN_BEGIN})\n\n`);
         welcome.appendMarkdown('Use the official Codex extension.');
         welcome.appendMarkdown('\n\n');
     }

package/dist/extension.js

@@ -2,7 +2,7 @@ import { resolveSessionBinding } from './bindings.js';
 import { withTextContext } from './context.js';
 import { randomUUID } from 'node:crypto';
 import { ChatHostControls, runtimeIdentity, harnessDisplayName, turnPermission } from './host-controls.js';
-import { CHATGPT_SIGN_IN, chatGPTAvailable, setupWelcome, signInWithChatGPT } from './chat-setup.js';
+import { CHATGPT_SIGN_IN, CHATGPT_SIGN_IN_BEGIN, CHATGPT_SIGN_IN_STATUS, chatGPTAvailable, setupWelcome, signInWithChatGPT } from './chat-setup.js';
 import * as vscode from 'vscode';
 import { createFrontendClient } from './client.js';
 import { readCredentialFile } from './credential.js';
@@ -184,6 +184,7 @@ class SupercodeFrontends {
         this.#changed.dispose();
     }
 }
+let nativeInTurnApprovalCards = false;
 function writeProjected(stream, projected, granted, state) {
     for (const candidate of projected) {
         const parts = resolveParts([candidate], granted);
@@ -235,6 +236,12 @@ function writePart(stream, part, state) {
             return;
         }
         case 'answers':
+            if (part.approval && nativeInTurnApprovalCards && part.answers.length > 0) {
+                stream.confirmation(part.title, part.message, {
+                    kind: 'supercode.inTurnApproval', version: 1, answers: part.answers,
+                }, part.answers.map(answer => answer.label));
+                return;
+            }
             // Stable API on purpose: a command button runs INSIDE the live turn,
             // which is when a supercode approval is raised. See `view.ts`.
             stream.markdown(`\n\n**${part.title}**\n\n${part.message}\n\n`);
@@ -300,16 +307,53 @@ export async function activate(context) {
     // description, so this is the grant, not the request.
     const granted = grantedProposals(context.extension.packageJSON);
     log.info(`Volter Harness: proposals requested ${REQUESTED_PROPOSALS.join(', ')}; granted ${granted.size ? [...granted].join(', ') : 'none (stable chat parts only)'}`);
+    // Explicit workbench support is required: stock confirmation clicks send
+    // a new prompt. A missing capability keeps the stable in-turn buttons.
+    if (granted.has('chatParticipantAdditions')) {
+        try {
+            const commands = await vscode.commands.getCommands(true);
+            if (commands.includes('volter.chat.inTurnApprovalCapability')) {
+                const capability = await vscode.commands.executeCommand('volter.chat.inTurnApprovalCapability');
+                nativeInTurnApprovalCards = capability?.version === 1;
+            }
+        }
+        catch (error) {
+            log.warn(`Native in-turn approval cards unavailable: ${String(error)}`);
+        }
+    }
     const controls = await ChatHostControls.fromEnvironment();
     const offerChatGPT = await chatGPTAvailable();
     let signingInWithChatGPT;
-    context.subscriptions.push(vscode.commands.registerCommand(CHATGPT_SIGN_IN, () => {
-        signingInWithChatGPT ??= signInWithChatGPT().catch(error => {
+    let chatGPTSignInOperation;
+    const signInSnapshot = () => chatGPTSignInOperation ? { ...chatGPTSignInOperation } : null;
+    const startChatGPTSignIn = () => {
+        if (signingInWithChatGPT)
+            return signingInWithChatGPT;
+        const startedAt = Date.now();
+        const operation = { id: randomUUID(), startedAt };
+        const update = (phase) => {
+            const updatedAt = Date.now();
+            chatGPTSignInOperation = { ...operation, phase, updatedAt,
+                ...(phase === 'completed' || phase === 'failed' ? { finishedAt: updatedAt } : {}) };
+        };
+        signingInWithChatGPT = signInWithChatGPT(phase => update(phase)).then(() => {
+            // Fulfilled install/sidebar commands do not establish authentication.
+            update('completed');
+        }).catch(error => {
+            update('failed');
             log.error(`Could not open ChatGPT sign-in: ${String(error)}`);
             void vscode.window.showErrorMessage(`Could not open ChatGPT sign-in: ${error instanceof Error ? error.message : String(error)}`);
         }).finally(() => { signingInWithChatGPT = undefined; });
         return signingInWithChatGPT;
-    }));
+    };
+    context.subscriptions.push(
+    // Preserve the completion-awaiting command used by the agent picker.
+    vscode.commands.registerCommand(CHATGPT_SIGN_IN, startChatGPTSignIn), 
+    // A click starts one retained task. Its receipt is not install/login success.
+    vscode.commands.registerCommand(CHATGPT_SIGN_IN_BEGIN, () => {
+        void startChatGPTSignIn();
+        return signInSnapshot();
+    }), vscode.commands.registerCommand(CHATGPT_SIGN_IN_STATUS, (operationId) => operationId === undefined || operationId === chatGPTSignInOperation?.id ? signInSnapshot() : null));
     const controlsChanged = new vscode.EventEmitter();
     context.subscriptions.push(controlsChanged);
     let permission = 'ask';
@@ -1059,34 +1103,36 @@ export async function activate(context) {
      */
     async function answerRequest(answer) {
         if (!answer || typeof answer.requestId !== 'number')
-            return;
+            return { status: 'unavailable' };
         const connection = frontends.get(answer.connectionId);
         if (!connection) {
             void vscode.window.showWarningMessage('Volter Harness is no longer attached to that runtime.');
-            return;
+            return { status: 'unavailable' };
         }
         const request = connection.session.pendingRequests.get(answer.requestId);
         if (!request) {
             void vscode.window.showInformationMessage(`Volter Harness: request #${answer.requestId} is already resolved.`);
-            return;
+            return { status: 'resolved' };
         }
         let response = answer.response;
         try {
             if (answer.promptForContent) {
                 const content = await requestContent(request);
                 if (content === undefined)
-                    return;
+                    return { status: 'cancelled' };
                 response = { ...response, content };
             }
             await connection.session.respond(response);
             void vscode.window.setStatusBarMessage(`Volter Harness: ${resolutionSentence(response, request, answer.requestId)}`, 4000);
+            return { status: 'responded' };
         }
         catch (error) {
             if (error instanceof RequestNotPendingError) {
                 void vscode.window.showInformationMessage(`Volter Harness: request #${answer.requestId} is already resolved.`);
-                return;
+                return { status: 'resolved' };
             }
             void vscode.window.showErrorMessage(`Volter Harness could not answer request #${answer.requestId}: ${String(error?.message ?? error)}`);
+            return { status: 'failed' };
         }
     }
     const secretKey = (baseUrl) => `supercode.frontend.token:${baseUrl}`;
@@ -1132,11 +1178,12 @@ export async function activate(context) {
     // The one door an answer button uses. It answers the runtime's pending
     // request through `frontend.v2.respond` and narrates itself, because a
     // click whose effect is invisible is a click nobody can trust.
-    vscode.commands.registerCommand('supercode.frontend.respond', (answer) => answerRequest(answer)), vscode.commands.registerCommand('supercode.frontend.status', async (inspect) => {
+    vscode.commands.registerCommand('supercode.frontend.respond', async (answer) => { await answerRequest(answer); }), vscode.commands.registerCommand('supercode.frontend.respondInTurnApproval', (answer) => answerRequest(answer)), vscode.commands.registerCommand('supercode.frontend.status', async (inspect) => {
         if (controls)
             await controls.refresh();
         if (inspect === true)
             return {
+                chatGPTSignIn: signInSnapshot(),
                 connections: frontends.all.map(c => ({ ...frontends.info(c), permissions: [...c.session.permissions],
                     pendingRequests: [...c.session.pendingRequests.values()] })),
                 selection: controls?.state.selection, activeSession: controls?.state.activeSession,

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { createFrontendClient, type FrontendPermission, type VscodeFrontendConnection } from './client.js';
 export { readCredentialFile } from './credential.js';
+export type { ChatGPTSignInWorkPhase, ChatGPTSignInOperation } from './chat-setup.js';
 export { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS, type ProposalName, } from './proposals.js';
 export { EventSequenceGapError, LEASE_ERROR_NAMES, RequestNotPendingError, TURN_TERMINAL_KINDS, VscodeFrontendSession, type VscodeFrontendActions, type VscodeRuntimeClient, } from './session.js';
 export { HISTORY_MARKER_PROMPT, VSCODE_CHAT_LIMITS, acceptedDecisions, diffPaths, fence, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, requestAnswers, requestNeedsTypedReply, requestSubject, requestSummary, resolutionSentence, resolveParts, toolSubject, typedAnswer, type ChatAnswer, type ChatPart, type ProjectedPart, type ProjectedTurn, type ProjectionContext, } from './view.js';

package/dist/view.d.ts

@@ -15,15 +15,10 @@ export declare const VSCODE_CHAT_LIMITS: Readonly<{
 /**
  * What one answer button sends back to the runtime.
  *
- * MEASURED: `ChatResponseConfirmationPart` is the wrong mechanism here. The
- * editor answers a confirmation by sending a NEW chat request carrying the
- * part's data (`chatConfirmationContentPart`), and a supercode approval is
- * raised WHILE the turn is still running — `decide_approval` in
- * crates/harness/src/server.rs blocks the agent loop until it is answered — so
- * the editor refuses that second request and the click does nothing. An
- * answer is therefore a COMMAND button: it runs inside the live turn, it is
- * stable API (no proposal), and each button carries its own answer instead of
- * the one payload a confirmation splits across accepted/rejected.
+ * Stock confirmations send a new chat request and cannot answer a running
+ * harness turn. Hosts advertising the versioned in-turn approval capability
+ * reuse their native confirmation card while dispatching this exact answer.
+ * Other hosts retain stable command buttons inside the running turn.
  */
 export interface ChatAnswer {
     connectionId: string;
@@ -67,6 +62,7 @@ export type ChatPart = {
     resultText?: string;
 } | {
     part: 'answers';
+    approval: boolean;
     title: string;
     message: string;
     answers: ChatAnswer[];

package/dist/view.js

@@ -389,25 +389,9 @@ export function projectEvent(event, context) {
             const title = request.kind === 'approval'
                 ? 'Approval required'
                 : subject ? `Approve ${subject}` : `Assistant request #${request.id}`;
-            // Command buttons, and MEASURED rather than assumed. Two richer
-            // mechanisms were tried against a live runtime in the editor's own Chat
-            // view and both failed, so neither ships:
-            //   `ChatResponseConfirmationPart` retires its own buttons on click, but
-            //     the click answers by sending a NEW chat request, and a supercode
-            //     approval is raised while the turn still runs (`decide_approval`
-            //     blocks the agent loop) — the editor refuses that request, so the
-            //     click does nothing and the runtime waits forever.
-            //   `stream.questionCarousel` resolves inside the running turn and the
-            //     widget retires itself — the right shape on paper. Observed: the
-            //     widget renders with its options, Submit retires it, and the
-            //     promise never delivers an answer this frontend can read, so the
-            //     runtime is left blocked. A preferred path that silently swallows
-            //     the answer is worse than a plain one that works.
-            // A command button runs inside the live turn and carries its own answer,
-            // so the runtime's offered answers remain usable. It cannot be withdrawn
-            // once pushed (`chatCommandContentPart` enables on `!isStale` and has no
-            // used-state), so `supercode.frontend.respond` refuses a request that is
-            // no longer pending and SAYS so instead of sending a stale answer.
+            // The host capability decides whether these original answers can use
+            // a native in-turn confirmation card. Stock confirmation clicks start a
+            // new chat request, so stable command buttons remain the fallback.
             if (context.canRespond === false || (request.payload && typeof request.payload === 'object' && !Array.isArray(request.payload) && request.payload.observe_only === true)) {
                 return [stable({
                         part: 'markdown',
@@ -416,6 +400,7 @@ export function projectEvent(event, context) {
             }
             return [stable({
                     part: 'answers',
+                    approval: request.kind === 'approval',
                     title: clamp(title, VSCODE_CHAT_LIMITS.titleCharacters),
                     message: summary,
                     answers,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",