@volter/supercode-frontend-vscode 0.1.60 → 0.1.61

package/dist/extension.js

@@ -1,6 +1,7 @@
 import { resolveSessionBinding } from './bindings.js';
 import { withTextContext } from './context.js';
 import { randomUUID } from 'node:crypto';
+import { WorkbenchTools } from './workbench-tools.js';
 import { ChatHostControls, runtimeIdentity, harnessDisplayName, turnPermission } from './host-controls.js';
 import { SETUP_BEGIN, SETUP_CANCEL, SETUP_STATE, setupAgents, setupPresentation, setupWelcome } from './chat-setup.js';
 import { ChatSetupFlow } from './setup-flow.js';
@@ -360,6 +361,16 @@ export async function activate(context) {
     const controls = await ChatHostControls.fromEnvironment();
     const controlsChanged = new vscode.EventEmitter();
     context.subscriptions.push(controlsChanged);
+    // The workbench's tools for the host's runtimes, on the endpoint the host names (ADR 0255).
+    if (controls) {
+        const workbenchTools = new WorkbenchTools();
+        context.subscriptions.push(workbenchTools);
+        const serveTools = (state) => {
+            workbenchTools.serve(state.workbenchTools).catch(error => log.warn(`Workbench tools unavailable: ${String(error)}`));
+        };
+        context.subscriptions.push({ dispose: controls.onState(serveTools) });
+        serveTools(controls.state);
+    }
     // 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', []));

package/dist/host-controls.d.ts

@@ -79,15 +79,26 @@ export interface HostState {
     /** Project policy for the next start/resume; an existing runtime uses its recorded session policy. */
     newChatRuntimePolicy?: 'default' | 'yolo' | null;
     runtimePolicyError?: string | null;
+    /** The workbench tools this host's runtimes reach (ADR 0255): the tag they carry, and the socket and token the host
+     *  named, where their relay (`supercode mcp workbench`) calls them. Absent, they reach none. */
+    workbenchTools?: WorkbenchToolsEndpoint;
+}
+export interface WorkbenchToolsEndpoint {
+    tag: string;
+    socket: string;
+    token: string;
 }
 export interface HostSelectionResult extends HostState {
     connection: Record<string, string>;
 }
 export declare class ChatHostControls {
+    #private;
     readonly baseUrl: string;
     private readonly credential;
     state: HostState;
     private updating;
+    /** Call `listener` with each state the host replies with; returns the unsubscribe. */
+    onState(listener: (state: HostState) => void): () => void;
     private constructor();
     static fromEnvironment(env?: NodeJS.ProcessEnv): Promise<ChatHostControls | undefined>;
     refresh(): Promise<void>;

package/dist/host-controls.js

@@ -4,6 +4,12 @@ export class ChatHostControls {
     credential;
     state;
     updating = Promise.resolve();
+    #stateListeners = new Set();
+    /** Call `listener` with each state the host replies with; returns the unsubscribe. */
+    onState(listener) {
+        this.#stateListeners.add(listener);
+        return () => this.#stateListeners.delete(listener);
+    }
     constructor(baseUrl, credential, state) {
         this.baseUrl = baseUrl;
         this.credential = credential;
@@ -37,6 +43,8 @@ export class ChatHostControls {
         const pending = this.updating.then(async () => {
             const result = await this.request(path, selection);
             this.state = result;
+            for (const listener of this.#stateListeners)
+                listener(result);
             return result;
         });
         this.updating = pending.then(() => undefined, () => undefined);

package/dist/workbench-tools.d.ts

@@ -0,0 +1,13 @@
+import * as vscode from 'vscode';
+import type { WorkbenchToolsEndpoint } from './host-controls.js';
+export declare class WorkbenchTools implements vscode.Disposable {
+    #private;
+    /** Serve on the endpoint the host names, or nothing when it names none. A changed endpoint replaces the server.
+     *  Calls apply in order, so two quick state replies cannot race a close against a listen. */
+    serve(endpoint: WorkbenchToolsEndpoint | undefined): Promise<void>;
+    private apply;
+    private answer;
+    private handle;
+    private close;
+    dispose(): void;
+}

package/dist/workbench-tools.js

@@ -0,0 +1,81 @@
+/**
+ * The workbench's tools, for the harness agents in its Chat (ADR 0255).
+ *
+ * The host names the tools and where they run (`HostState.workbenchTools`: a tag, a socket and a token), and lists
+ * them to its runtimes itself, through `supercode mcp workbench`. That relay calls them here: this serves, in the
+ * extension host where `vscode.lm` exists, one call of a tool `vscode.lm.tools` lists with the tag, through
+ * Code-OSS's own tool service. With no endpoint it serves nothing.
+ *
+ * The wire is one JSON line each way per connection: `{token, name, input}` → `{text, isError}`.
+ */
+import { rmSync } from 'node:fs';
+import { createServer } from 'node:net';
+import * as vscode from 'vscode';
+export class WorkbenchTools {
+    #served;
+    #applying = Promise.resolve();
+    /** Serve on the endpoint the host names, or nothing when it names none. A changed endpoint replaces the server.
+     *  Calls apply in order, so two quick state replies cannot race a close against a listen. */
+    serve(endpoint) {
+        const applying = this.#applying.then(() => this.apply(endpoint));
+        this.#applying = applying.catch(() => undefined);
+        return applying;
+    }
+    async apply(endpoint) {
+        const current = this.#served?.endpoint;
+        if (current?.tag === endpoint?.tag && current?.socket === endpoint?.socket && current?.token === endpoint?.token)
+            return;
+        this.close();
+        if (!endpoint)
+            return;
+        // A socket left by an earlier extension host of this window is this window's own.
+        if (process.platform !== 'win32')
+            rmSync(endpoint.socket, { force: true });
+        const server = createServer(socket => this.answer(socket, endpoint));
+        await new Promise((resolve, reject) => { server.once('error', reject); server.listen(endpoint.socket, resolve); });
+        this.#served = { endpoint, server };
+    }
+    answer(socket, endpoint) {
+        let buffer = '';
+        socket.setEncoding('utf8');
+        socket.on('data', chunk => {
+            buffer += chunk;
+            const end = buffer.indexOf('\n');
+            if (end < 0)
+                return;
+            const line = buffer.slice(0, end);
+            buffer = '';
+            void this.handle(line, endpoint).then(reply => socket.end(`${JSON.stringify(reply)}\n`));
+        });
+        socket.on('error', () => socket.destroy());
+    }
+    async handle(line, { tag, token }) {
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            return { text: 'The call was not JSON.', isError: true };
+        }
+        if (request.token !== token)
+            return { text: 'The call was refused.', isError: true };
+        const name = request.name;
+        if (typeof name !== 'string' || !vscode.lm.tools.some(tool => tool.name === name && tool.tags.includes(tag))) {
+            return { text: `The workbench has no tool ${String(name)}.`, isError: true };
+        }
+        try {
+            const input = request.input && typeof request.input === 'object' ? request.input : {};
+            const result = await vscode.lm.invokeTool(name, { input, toolInvocationToken: undefined });
+            return { text: result.content.map(part => part instanceof vscode.LanguageModelTextPart ? part.value : '').join(''), isError: false };
+        }
+        catch (error) {
+            return { text: error instanceof Error ? error.message : String(error), isError: true };
+        }
+    }
+    close() {
+        const served = this.#served;
+        this.#served = undefined;
+        served?.server.close();
+    }
+    dispose() { this.close(); }
+}

package/package.json

@@ -1,14 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
-  "devEngines": {
-    "packageManager": {
-      "name": "pnpm",
-      "version": ">=12.15.0",
-      "onFail": "error"
-    }
-  },
   "displayName": "Volter Harness",
-  "version": "0.1.60",
+  "version": "0.1.61",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "repository": {
@@ -34,6 +27,11 @@
     "NOTICE.md",
     "media"
   ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', {recursive:true, force:true})\" && node scripts/sync-sdk.mjs && node scripts/fetch-icon.mjs && node scripts/sync-marks.mjs && tsc -p tsconfig.build.json",
+    "extension": "npm run build && node scripts/pack-extension.mjs",
+    "prepack": "npm run build"
+  },
   "engines": {
     "node": ">=20",
     "vscode": "^1.138.0"
@@ -214,9 +212,5 @@
     "version": "0.2.12",
     "mode": "generated-artifact"
   },
-  "license": "MIT OR Apache-2.0",
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist', {recursive:true, force:true})\" && node scripts/sync-sdk.mjs && node scripts/fetch-icon.mjs && node scripts/sync-marks.mjs && tsc -p tsconfig.build.json",
-    "extension": "pnpm run build && node scripts/pack-extension.mjs"
-  }
-}
+  "license": "MIT OR Apache-2.0"
+}

package/vendor/supercode-frontend/package.json

@@ -1,6 +1,5 @@
 {
   "name": "@volter/supercode-frontend",
-  "devEngines": { "packageManager": { "name": "pnpm", "version": ">=12.15.0", "onFail": "error" } },
   "version": "0.2.12",
   "type": "module",
   "description": "Generated language-neutral attachment client for Volter Harness SDK runtimes",