@volter/supercode-frontend-vscode 0.1.25 → 0.1.26

package/README.md

@@ -26,8 +26,16 @@ the choice. Neither the extension nor its credentials are bundled or copied.
 
 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` shown before execution. Chat renders native buttons, with
-**Sign in with ChatGPT** for Codex and the reported name for other harnesses.
+the exact `command` revalidated before execution. On a signed-out first open,
+Chat shows its native empty-session welcome: one primary **Sign in with ChatGPT**
+button for the official extension, followed by **Supercode · local agents** and
+each installed agent's own sign-in link, labeled with its reported name. The
+`defaultChatParticipant` proposal supplies `additionalWelcomeMessage`; the pinned
+Code-OSS `ChatViewWelcomePart`, with the editor's native-welcome-button overlay,
+turns the standalone trusted command link into a native button. Stock hosts
+render it as an ordinary command link; product release requires the overlay.
+Setup creates no transcript turns, status sessions or protocol markers, and displays no terminal commands, filesystem paths or runtime banner.
+No installed agents means an explanatory empty state, without invented choices.
 Clicking asks the host's authenticated `/setup` door to revalidate `{ kind,
 harness }` and return the action plus a structured `{ program, arguments, cwd, env? }`
 terminal launch. Absolute executables and an optional host-authored PATH keep
@@ -43,9 +51,10 @@ and reveals that conversation without a reload. Polling only finishes after both
 attachment and the host's native reveal command succeed for that same session
 and runtime URL. A transient attach/reveal failure stays pending and is retried;
 **Check again** retries that handoff even when the host already reports ready.
-Changed setup resources refresh
-Code-OSS's cached status history after an install. Hosts without these optional
-fields keep the existing runtime-attachment behavior.
+Changed inventory updates welcome metadata in place, without opening another
+session or moving focus. Ready connections clear the welcome and reveal the
+actual conversation. Hosts without these optional fields keep the existing
+runtime-attachment commands.
 
 A bundling host can expose a private lifecycle endpoint through
 `SUPERCODE_FRONTEND_HOST_URL` and `SUPERCODE_FRONTEND_HOST_CREDENTIAL_FILE`.
@@ -135,17 +144,11 @@ Three paths, in precedence order.
    an extension may put a bearer token that is better than the runtime's own private 0600 file. The
    base URL it was handed is remembered in `globalState`, so the next activation reconnects.
 
-   A host that could not start a runtime at all says so with the fourth variable,
-   `SUPERCODE_FRONTEND_UNAVAILABLE` (or `connect({unavailable})`): its own sentence, naming its own
-   harness and the command a person must type. Nothing is attached and that sentence is what the
-   Chat view shows. It is shown as a **session** — `chatViewsWelcome` cannot do it, because
-   `ChatViewPane.shouldShowWelcome()` in
-   `src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/chatViewPane.ts` begins
-   `const shouldShow = !hasCoreAgent && …`, so the whole welcome control is suppressed whenever any
-   core agent is registered for the Chat location, which a Code-OSS derivative with an agent host
-   always has; the `when` clause is never consulted. The session's `activeResponseCallback` is the
-   one door that writes into a session nobody has typed into, so the reason is on screen where the
-   eye lands rather than waiting for a prompt.
+   A host that could not start a runtime can supply
+   `SUPERCODE_FRONTEND_UNAVAILABLE` (or `connect({unavailable})`). Without managed
+   setup, its diagnostic appears in the native empty-chat welcome on hosts that
+   grant `defaultChatParticipant`. It is never manufactured into conversation
+   history. Managed setup uses the sign-in welcome described above instead.
 
    An attachment that arrives with HISTORY — a resumed runtime, `claude --resume <id>` — opens its
    own session once, so the panel opens *on* the conversation instead of beside it. A runtime with

package/dist/chat-setup.d.ts

@@ -8,4 +8,8 @@ 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 setupParts(setup: ChatSetupState, chatGPT?: boolean): Array<vscode.ChatResponseMarkdownPart | vscode.ChatResponseCommandButtonPart>;
+/** 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
+ * of the welcome, and the host still revalidates every action on click. */
+export declare function setupWelcome(setup: ChatSetupState, chatGPT?: boolean): vscode.MarkdownString;

package/dist/chat-setup.js

@@ -32,24 +32,33 @@ export async function signInWithChatGPT() {
     // Revealing its sidebar presents its own Sign in with ChatGPT when signed out.
     await vscode.commands.executeCommand('chatgpt.openSidebar');
 }
-export function setupParts(setup, chatGPT = false) {
-    const parts = [];
+/** 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
+ * 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'] };
     if (chatGPT) {
-        parts.push(new vscode.ChatResponseCommandButtonPart({ title: 'Sign in with ChatGPT', command: CHATGPT_SIGN_IN }));
-        parts.push(new vscode.ChatResponseMarkdownPart('Uses the official Codex extension. Installs it from the extension gallery if needed.'));
+        welcome.appendMarkdown(`[Sign in with ChatGPT](command:${CHATGPT_SIGN_IN})\n\n`);
+        welcome.appendMarkdown('Use the official Codex extension.');
+        welcome.appendMarkdown('\n\n');
     }
-    parts.push(new vscode.ChatResponseMarkdownPart(chatGPT
-        ? '**Supercode · use a local agent**\n\nComplete your local agent’s sign-in in the terminal and browser.'
-        : 'Sign in to use Chat. Complete sign-in in the terminal and browser.'));
-    for (const action of setup.actions) {
-        const title = action.kind === 'install' ? `Install ${action.name}`
-            : action.harness === 'codex' ? 'Sign in with ChatGPT' : `Sign in with ${action.name}`;
-        parts.push(new vscode.ChatResponseMarkdownPart(`Runs: \`${action.command.replace(/`/g, '\\`')}\``));
-        parts.push(new vscode.ChatResponseCommandButtonPart({ title, command: 'supercode.frontend.setup', arguments: [action.kind, action.harness] }));
+    welcome.appendMarkdown('**Supercode · local agents**\n\n');
+    const login = setup.actions.filter(action => action.kind === 'login');
+    if (login.length) {
+        for (const action of login) {
+            const title = new vscode.MarkdownString().appendText(`Sign in with ${action.name}`).value;
+            const args = encodeURIComponent(JSON.stringify([action.kind, action.harness]));
+            welcome.appendMarkdown(`- [${title}](command:supercode.frontend.setup?${args})\n`);
+        }
+        welcome.appendMarkdown('\n');
+        welcome.appendMarkdown('Each agent opens its own sign-in.');
     }
-    if (!setup.actions.length) {
-        parts.push(new vscode.ChatResponseMarkdownPart(setup.reason || 'No sign-in action is available.'));
+    else {
+        welcome.appendMarkdown('No local agents are ready. Install an agent on this machine to use it with Supercode.');
     }
-    parts.push(new vscode.ChatResponseCommandButtonPart({ title: 'Check again', command: 'supercode.frontend.refreshSetup' }));
-    return parts;
+    // Inline so it remains a secondary link, not another primary button.
+    welcome.appendMarkdown('\n\nAlready signed in? [Check again](command:supercode.frontend.refreshSetup).');
+    return welcome;
 }

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, setupParts, signInWithChatGPT } from './chat-setup.js';
+import { CHATGPT_SIGN_IN, chatGPTAvailable, setupWelcome, signInWithChatGPT } from './chat-setup.js';
 import * as vscode from 'vscode';
 import { createFrontendClient } from './client.js';
 import { readCredentialFile } from './credential.js';
@@ -15,8 +15,6 @@ const PARTICIPANT_ID = 'supercode.chat';
 const DEFAULT_PARTICIPANT_ID = 'supercode.chat.default';
 /** `package.json` gates the `isDefault` participant on this key. */
 const DEFAULT_PARTICIPANT_CONTEXT_KEY = 'supercodeChatDefaultParticipant';
-/** `chatViewsWelcome` shows the empty state until this is true. */
-const ATTACHED_CONTEXT_KEY = 'supercodeAttached';
 const PERMISSIONS = ['observe', 'interact', 'approve', 'terminate'];
 /** The environment a runtime uses to hand this frontend a live connection. */
 const ENV = Object.freeze({
@@ -46,16 +44,6 @@ function normalizePermissions(value, fallback) {
         permissions.unshift('observe');
     return value === undefined || value === null ? fallback : permissions;
 }
-/** The one session item that stands for "there is no runtime, and here is why". */
-const UNAVAILABLE_PATH = '/unavailable';
-/**
- * The prompt of the turn that carries a status this frontend is reporting.
- * It names itself; nothing here is presented as a person's words.
- */
-const STATUS_MARKER_PROMPT = '⟨supercode⟩';
-function unavailableResource() {
-    return vscode.Uri.from({ scheme: SESSION_SCHEME, authority: 'supercode', path: UNAVAILABLE_PATH });
-}
 function sessionResource(connection) {
     const sessionId = 'conversation';
     return vscode.Uri.from({ scheme: SESSION_SCHEME, authority: connection.id, path: `/${encodeURIComponent(sessionId)}` });
@@ -367,6 +355,8 @@ export async function activate(context) {
         context.subscriptions.push(vscode.lm.registerLanguageModelChatProvider('supercode-runtime', {
             onDidChangeLanguageModelChatInformation: controlsChanged.event,
             provideLanguageModelChatInformation: () => {
+                if (controls.state.setup && !controls.state.setup.ready)
+                    return [];
                 const { selection, models } = controls.state;
                 // A running harness does not advertise hot model changes. Configuration
                 // belongs to the explicit new-conversation flow.
@@ -437,22 +427,14 @@ export async function activate(context) {
         // Host readiness alone is not completion: the native reveal must succeed too.
         setupHandoff = { id, baseUrl: connection.baseUrl };
     };
-    let setupFingerprint = '';
+    let setupRevealed = false;
     const revealSetup = async () => {
-        if (!controls?.state.setup || controls.state.setup.ready || !controls.state.openSessionCommand)
-            return;
-        const fingerprint = JSON.stringify(controls.state.setup);
-        if (setupFingerprint === fingerprint)
+        if (!granted.has('chatSessionsProvider') || !controls?.state.setup || controls.state.setup.ready || setupRevealed)
             return;
-        setupFingerprint = fingerprint;
-        // A changed resource avoids Code-OSS reusing cached status history after an install.
-        try {
-            await vscode.commands.executeCommand(controls.state.openSessionCommand, vscode.Uri.from({ scheme: SESSION_SCHEME, path: UNAVAILABLE_PATH, query: encodeURIComponent(fingerprint) }).toString());
-        }
-        catch (error) {
-            setupFingerprint = '';
-            throw error;
-        }
+        // A real empty session uses the widget's native welcome, never transcript
+        // history. Inventory changes update participant metadata in place.
+        await vscode.commands.executeCommand(`workbench.action.chat.openNewChatSessionInPlace.${SESSION_SCHEME}`, 'sidebar');
+        setupRevealed = true;
     };
     let refreshingSetup;
     const refreshSetup = () => {
@@ -461,6 +443,7 @@ export async function activate(context) {
                 return;
             await controls.refresh();
             if (controls.state.setup?.ready) {
+                setupRevealed = false;
                 await connectManaged();
                 controlsChanged.fire();
                 if (!setupHandoffComplete())
@@ -566,6 +549,8 @@ export async function activate(context) {
         changed: controlsChanged.event,
         currentOptions,
         options: (resource) => {
+            if (controls?.state.setup && !controls.state.setup.ready)
+                return [];
             const id = resource ? boundId(resource) : undefined;
             const active = resource ? (id ? frontends.get(id) : undefined) : managed();
             const canApprove = active?.session.descriptor?.actions.respond && active.session.permissions.has('approve');
@@ -605,8 +590,6 @@ export async function activate(context) {
         attached: (connection) => attachedIds.has(connection.id),
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
-        setup: () => controls?.state.setup,
-        offerChatGPT,
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.openSession', async (id) => {
@@ -698,12 +681,6 @@ export async function activate(context) {
         await enqueueSelection(selection);
     }));
     context.subscriptions.push({ dispose: () => frontends.dispose() });
-    context.subscriptions.push(frontends.onDidChange(() => {
-        void vscode.commands.executeCommand('setContext', ATTACHED_CONTEXT_KEY, frontends.all.length > 0);
-    }));
-    // From the connections, not `false`: one made earlier in activation (the editor host
-    // attaches before this line) already fired its change, and `false` here outlived it.
-    await vscode.commands.executeCommand('setContext', ATTACHED_CONTEXT_KEY, frontends.all.length > 0);
     const runTurnInto = async (connection, prompt, stream, token, approval) => {
         if (approval === 'autoApprove' && (!connection.session.descriptor?.actions.respond || !connection.session.permissions.has('approve'))) {
             throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
@@ -753,8 +730,7 @@ export async function activate(context) {
         await applying;
         const requestedResource = chatContext.chatSessionContext?.chatSessionItem?.resource;
         if (controls?.state.setup && !controls.state.setup.ready) {
-            for (const part of setupParts(controls.state.setup, offerChatGPT))
-                stream.push(part);
+            stream.markdown('Sign in before sending a message. Use **New Chat: Choose Agent** to get started.');
             return {};
         }
         const connection = requestedResource
@@ -817,6 +793,22 @@ export async function activate(context) {
             log.warn(`Volter Harness chat participant ${id} was not registered: ${String(error?.message ?? error)}`);
         }
     }
+    let welcomeValue;
+    const updateWelcome = () => {
+        if (!granted.has('defaultChatParticipant'))
+            return;
+        const setup = controls?.state.setup;
+        const welcome = setup && !setup.ready ? setupWelcome(setup, offerChatGPT)
+            : !controls && frontends.all.length === 0 ? new vscode.MarkdownString(unavailableMarkdown(frontends.unavailable))
+                : undefined;
+        if (welcomeValue === welcome?.value)
+            return;
+        welcomeValue = welcome?.value;
+        for (const participant of participants)
+            participant.additionalWelcomeMessage = welcome;
+    };
+    updateWelcome();
+    context.subscriptions.push(controlsChanged.event(updateWelcome), frontends.onDidChange(updateWelcome));
     // The runtime's sessions in the Chat view's own picker. Without the
     // `chatSessionsProvider` grant the participant alone still works.
     if (granted.has('chatSessionsProvider')) {
@@ -1216,27 +1208,7 @@ function applyTiming(item, connection) {
 }
 function registerSessions(context, frontends, participant, granted, handler, controls) {
     const turns = vscode;
-    /**
-     * The session list is the door that actually SHOWS a reason on screen.
-     * `chatViewsWelcome` cannot: `ChatViewPane.shouldShowWelcome()` in
-     * `src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/chatViewPane.ts`
-     * begins `const shouldShow = !hasCoreAgent && …`, so the whole welcome
-     * control is suppressed whenever ANY core agent is registered for the Chat
-     * location — which a Code-OSS derivative with an agent host always has. The
-     * `when` clause is never even consulted there.
-     */
-    const unavailableItem = () => {
-        if (!frontends.unavailable || frontends.all.length > 0)
-            return undefined;
-        const item = controller.createChatSessionItem(unavailableResource(), controls?.setup() ? 'Sign in to Chat' : 'Volter Harness · no runtime');
-        item.description = frontends.unavailable.split('\n')[0];
-        item.status = vscode.ChatSessionStatus.Failed;
-        return item;
-    };
     const items = () => {
-        const unavailable = unavailableItem();
-        if (unavailable)
-            return [unavailable];
         return (controls?.catalogue() ?? []).filter(entry => !frontends.get(entry.id)).map(entry => {
             const item = controller.createChatSessionItem(vscode.Uri.from({ scheme: SESSION_SCHEME, authority: entry.id, path: '/conversation' }), entry.title);
             item.description = runtimeIdentity(entry.selection.harness, entry.selection.model).name;
@@ -1290,21 +1262,6 @@ function registerSessions(context, frontends, participant, granted, handler, con
     context.subscriptions.push(vscode.chat.registerChatSessionContentProvider(SESSION_SCHEME, {
         provideChatSessionContent: async (resource, _token, { inputState }) => {
             const boundHandler = (request, chatContext, stream, token) => handler(request, { ...chatContext, chatSessionContext: { chatSessionItem: { resource, label: 'Conversation' } } }, stream, token);
-            if (resource.path === UNAVAILABLE_PATH) {
-                // As HISTORY, not `activeResponseCallback`: the editor only invokes
-                // that callback for a session it believes is mid-response, and this
-                // one is not running anything. A history turn renders the moment
-                // the session opens, with no request behind it and nothing to wait
-                // for — which is the whole point, since the person has not typed.
-                return {
-                    title: controls?.setup() ? 'Sign in to Chat' : 'Volter Harness · no runtime',
-                    history: [
-                        new turns.ChatRequestTurn(STATUS_MARKER_PROMPT, undefined, [], participant.id, []),
-                        new turns.ChatResponseTurn(controls?.setup() ? setupParts(controls.setup(), controls.offerChatGPT) : [new vscode.ChatResponseMarkdownPart(unavailableMarkdown(frontends.unavailable))], {}, participant.id),
-                    ],
-                    requestHandler: boundHandler,
-                };
-            }
             // Only a native untitled resource can create a conversation. Existing
             // resources must resolve their exact saved binding; there is no fallback.
             const connection = controls ? (resource.path.startsWith('/untitled-') && !controls.bindings(resource) ? undefined : await controls.resolve(resource)) : frontends.get(resource.authority);

package/dist/host-controls.d.ts

@@ -18,7 +18,7 @@ export interface ManagedChatSession {
     title: string;
     created: number;
 }
-/** Host-owned operations. The frontend displays commands before the person runs them. */
+/** Host-owned operations. The host revalidates commands before native terminal execution. */
 export interface ChatSetupAction {
     kind: 'login' | 'install';
     harness: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",
@@ -80,11 +80,11 @@
       {
         "type": "supercode",
         "name": "supercode-runtime",
-        "displayName": "Harness",
+        "displayName": "Supercode",
         "description": "Conversations with your AI assistant",
         "icon": "$(server-process)",
         "welcomeTitle": "Chat",
-        "welcomeMessage": "Write a message to your coding agent.",
+        "welcomeMessage": "Work with your coding agent.",
         "inputPlaceholder": "Ask a question or describe a task",
         "order": 1,
         "capabilities": {
@@ -97,14 +97,6 @@
         "requiresCustomModels": true
       }
     ],
-    "chatViewsWelcome": [
-      {
-        "icon": "$(server-process)",
-        "title": "Volter Harness",
-        "content": "Volter Harness is not attached to a runtime.\n[Set runtime token](command:supercode.frontend.setToken)\n[Attach](command:supercode.frontend.connect)",
-        "when": "!supercodeAttached"
-      }
-    ],
     "commands": [
       {
         "command": "supercode.frontend.setToken",