@volter/supercode-frontend-vscode 0.1.34 → 0.1.36

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,
@@ -123,8 +142,17 @@ the same cached conversation. Managed resources then notify
 owns no processes.
 
 The permission group offers **Ask for approval** and, on an answerable interactive attachment,
-**Auto approve**. Policies are scoped by conversation and captured for each turn; automatic
-approval does not bypass harness sandbox rules. Unsupported modes are refused. Unanswerable
+**Auto approve**. Policies are scoped by conversation and read throughout the turn: switching to
+**Auto approve** while a turn runs answers the approvals already waiting and every later one.
+A lifecycle host may declare `defaultPermission: "autoApprove"` for conversations no one has
+picked a mode for (Model Editor does); it applies to Claude Code and Codex where the runtime answers approvals
+through Chat, every other harness keeps its own prompts, and a person's explicit pick always
+wins. Only a pick that differs from the default (or replaces an earlier pick) is saved, so the
+default is never stored as a choice (a pick equal to the default follows the default if it later
+changes), and an Auto approve is never stored for a conversation that cannot answer. Conversations opened before 0.1.36 saved their picker's
+**Ask** when opened and keep it. Auto approve approves the requests the harness would ask you about, including requests to run
+outside its sandbox (Codex's approval requests are its sandbox escalations); the harness's deny
+rules still apply. Each request it answers is noted in the turn ("auto-approved: …"). Unsupported modes are refused. Unanswerable
 harnesses show **Harness permissions**. Previously answered requests cannot affect another
 connection. Native command-button fallback limitations are documented below.
 

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';
@@ -324,20 +324,77 @@ export async function activate(context) {
     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';
+    // A person's explicit picker choice: per conversation once it is bound, and for the new chat before then.
+    let permission;
     const permissions = new Map(context.workspaceState.get('supercode.sessionPermissions', []));
     const savePermission = (id, value) => {
         permissions.set(id, value);
         void Promise.resolve(context.workspaceState.update('supercode.sessionPermissions', [...permissions])).catch(error => log.error(`Could not persist conversation permissions: ${String(error)}`));
+        for (const sweep of runningTurns.get(id) ?? [])
+            sweep();
+    };
+    // The approval sweeps of each conversation's running turns, so a picker change reaches a turn already running.
+    const runningTurns = new Map();
+    // The host's default for a conversation no one has chosen for (Model Editor declares Auto approve).
+    const hostDefault = () => controls?.state.defaultPermission === 'autoApprove' ? 'autoApprove' : 'ask';
+    const canAnswer = (connection) => Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve'));
+    // The host's default for one conversation: Auto approve only for a conversation the host manages and only
+    // where this Chat can answer the runtime's approvals, read from its live connection, or, while it is not
+    // connected, from the harness the host records for it (hosted Claude Code and Codex answer through Chat).
+    // A runtime attached by address and every other harness keep their own prompts.
+    const defaultFor = (id) => {
+        if (hostDefault() !== 'autoApprove' || attachedIds.has(id))
+            return 'ask';
+        const connection = frontends.get(id);
+        const harness = controls?.state.sessions.find(session => session.id === id)?.selection.harness ?? '';
+        // Only the harnesses whose approvals this default was decided for; a runtime that answers through another
+        // protocol (an ACP agent) keeps asking until a host names it.
+        return ['claude-code', 'codex'].includes(harness) && (!connection || canAnswer(connection)) ? 'autoApprove' : 'ask';
+    };
+    // What governs a conversation's approvals: the person's choice, else the host's default.
+    const approvalFor = (id) => permissions.get(id) ?? defaultFor(id);
+    // A picker value becomes the person's choice only when it is one: it differs from the default the picker showed
+    // (`shown`; null when the person already picked it), or replaces an earlier choice. Echoes of the displayed default
+    // (the picker re-applied when a conversation opens) are not saved, and neither is an Auto approve the conversation
+    // cannot answer: the picker offers it only where it can, so there it is a default shown before the harness was known.
+    const choosePermission = (id, value, shown = defaultFor(id)) => {
+        const connection = frontends.get(id);
+        if (value === 'autoApprove' && connection && !canAnswer(connection))
+            return;
+        if (permissions.has(id) || value !== shown)
+            savePermission(id, value);
     };
     const resourceBindings = new Map(context.workspaceState.get('supercode.sessionBindings', []));
     const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
@@ -429,7 +486,7 @@ export async function activate(context) {
     }
     const currentOptions = (resource) => {
         const id = resource ? boundId(resource) : controls?.state.activeSession;
-        return { permissions: id ? permissions.get(id) ?? 'ask' : permission };
+        return { permissions: id ? approvalFor(id) : permission ?? hostDefault() };
     };
     const savedConnections = new Map();
     const saveManagedHistory = async (connection) => {
@@ -726,8 +783,8 @@ export async function activate(context) {
             const active = resource ? (id ? frontends.get(id) : undefined) : managed();
             const canApprove = active?.session.descriptor?.actions.respond && active.session.permissions.has('approve');
             const permissionItems = [{ id: 'ask', name: canApprove ? 'Ask for approval' : 'Harness permissions', description: canApprove ? 'Show each approval requested by the harness.' : 'Approval controls are unavailable for this harness.' },
-                ...((canApprove || (!active && resource && currentOptions(resource).permissions === 'autoApprove')) ? [{ id: 'autoApprove', name: 'Auto approve', description: 'Allow tool approval requests for this chat. Harness sandbox rules still apply.' }] : [])];
-            const groups = [{ id: 'permissions', name: 'Permissions', kind: 'permissions', items: permissionItems, selected: permissionItems.find(i => i.id === (resource ? currentOptions(resource).permissions : 'ask')) }];
+                ...((canApprove || (!active && resource && currentOptions(resource).permissions === 'autoApprove')) ? [{ id: 'autoApprove', name: 'Auto approve', description: 'Approve the requests the harness would ask you about, including requests to run outside its sandbox. Its deny rules still apply.' }] : [])];
+            const groups = [{ id: 'permissions', name: 'Permissions', kind: 'permissions', items: permissionItems, selected: permissionItems.find(i => i.id === currentOptions(resource).permissions) }];
             const selected = controls?.state.sessions.find(session => session.id === id);
             if (selected && ['claude-code', 'codex'].includes(selected.selection.harness)) {
                 // Native session-option commands remain reachable for nondelegating providers,
@@ -745,7 +802,7 @@ export async function activate(context) {
             if (controls && !id)
                 throw new Error('This conversation has no session binding.');
             if (id)
-                savePermission(id, turnPermission(value));
+                choosePermission(id, turnPermission(value));
             else
                 permission = turnPermission(value);
         },
@@ -771,7 +828,10 @@ export async function activate(context) {
             const pending = applying.then(() => applySelection(selection));
             applying = pending.then(() => undefined, () => undefined);
             const connection = await pending;
-            savePermission(connection.id, turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id));
+            // The picker shows the host's default until someone changes it; only a change is the person's choice.
+            const picked = turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id);
+            choosePermission(connection.id, picked, permission !== undefined ? null : hostDefault());
+            permission = undefined;
             if (pendingDraft === draft) {
                 pendingDraft = undefined;
                 controlsChanged.fire();
@@ -802,7 +862,7 @@ export async function activate(context) {
         if (supplied?.permissions) {
             const id = controls?.state.activeSession;
             if (id)
-                savePermission(id, turnPermission(supplied.permissions));
+                choosePermission(id, turnPermission(supplied.permissions));
             else
                 permission = turnPermission(supplied.permissions);
             controlsChanged.fire();
@@ -886,7 +946,7 @@ export async function activate(context) {
     }));
     context.subscriptions.push({ dispose: () => frontends.dispose() });
     const runTurnInto = async (connection, prompt, stream, token, approval) => {
-        if (approval === 'autoApprove' && (!connection.session.descriptor?.actions.respond || !connection.session.permissions.has('approve'))) {
+        if (approval() === 'autoApprove' && !canAnswer(connection)) {
             throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
         }
         const answered = new Set();
@@ -902,25 +962,40 @@ export async function activate(context) {
                 // this view reports.
             });
         });
+        // Read at every event and on every picker change, so switching to Auto approve mid-turn
+        // answers the approvals already waiting and the ones after them.
+        const sweep = () => {
+            if (approval() !== 'autoApprove' || token.isCancellationRequested || !canAnswer(connection))
+                return;
+            for (const pending of connection.session.pendingRequests.values()) {
+                if (pending.kind !== 'approval' || answered.has(pending.id))
+                    continue;
+                const decisions = acceptedDecisions(pending);
+                if (decisions && !decisions.includes('allow'))
+                    continue;
+                answered.add(pending.id);
+                // Its card is already in the stream (the event that raised it was written first), so say it was answered.
+                const payload = pending.payload && typeof pending.payload === 'object' && !Array.isArray(pending.payload) ? pending.payload : {};
+                const named = [payload.title, payload.tool, payload.tool_name].find((value) => typeof value === 'string');
+                void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).then(() => {
+                    stream.markdown(`\n_auto-approved: ${opaqueText(named ?? `request #${pending.id}`, 200)}_\n`);
+                }, error => {
+                    stream.markdown(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
+                });
+            }
+        };
+        const sweeps = runningTurns.get(connection.id) ?? new Set();
+        runningTurns.set(connection.id, sweeps.add(sweep));
         try {
             await connection.session.runTurn(prompt, (event) => {
                 writeProjected(stream, projectEvent(event, projection), granted, state);
-                if (approval === 'autoApprove' && !token.isCancellationRequested) {
-                    for (const pending of connection.session.pendingRequests.values()) {
-                        if (pending.kind !== 'approval' || answered.has(pending.id))
-                            continue;
-                        const decisions = acceptedDecisions(pending);
-                        if (decisions && !decisions.includes('allow'))
-                            continue;
-                        answered.add(pending.id);
-                        void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).catch(error => {
-                            stream.markdown(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
-                        });
-                    }
-                }
+                sweep();
             });
         }
         finally {
+            sweeps.delete(sweep);
+            if (!sweeps.size && runningTurns.get(connection.id) === sweeps)
+                runningTurns.delete(connection.id);
             cancellation.dispose();
             if (controls && !attachedIds.has(connection.id)) {
                 if (connection.session.descriptor?.session_id)
@@ -970,7 +1045,8 @@ export async function activate(context) {
             stream.markdown('_nothing to submit_');
             return {};
         }
-        const approval = turnPermission(controls ? permissions.get(connection.id) ?? 'ask' : request.permissionLevel);
+        const native = controls ? undefined : turnPermission(request.permissionLevel);
+        const approval = () => native ?? approvalFor(connection.id);
         const attached = [];
         for (const reference of request.references) {
             const value = reference.value;
@@ -1160,6 +1236,7 @@ export async function activate(context) {
             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/host-controls.d.ts

@@ -49,6 +49,9 @@ export interface HostState {
     actualModel?: string | null;
     configurable: boolean;
     setup?: ChatSetupState;
+    /** The approval mode of a conversation no one has picked one for. `autoApprove` takes effect only
+     *  where the runtime can answer approvals through Chat; absent, every conversation asks. */
+    defaultPermission?: 'ask' | 'autoApprove';
 }
 export interface HostSelectionResult extends HostState {
     connection: Record<string, string>;
@@ -75,7 +78,7 @@ export declare class ChatHostControls {
     private update;
     private request;
 }
-/** Approval policy is captured for one turn, never inferred from connection privileges. */
+/** A picked approval mode, never inferred from connection privileges (those only keep a host default at ask). */
 export declare function turnPermission(value: string | undefined): 'ask' | 'autoApprove';
 export declare function harnessDisplayName(harness: string | null | undefined): string;
 export declare function runtimeIdentity(harness: string | null | undefined, model: string | null | undefined): {

package/dist/host-controls.js

@@ -53,7 +53,7 @@ export class ChatHostControls {
         return value;
     }
 }
-/** Approval policy is captured for one turn, never inferred from connection privileges. */
+/** A picked approval mode, never inferred from connection privileges (those only keep a host default at ask). */
 export function turnPermission(value) {
     if (!value || value === 'default' || value === 'ask')
         return 'ask';

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/package.json

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