@ai-workbench/connect 0.7.7 → 0.7.11

package/lib/startup.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { fail, need, ok } from "./needs.js";
+import { authFailure } from "./auth-diagnostics.js";
 export function employeeMessage(code) {
     if (code === 'ENROLLMENT_RESULT_UNKNOWN' || code === 'ENROLLMENT_REJECTED')
         return need(code).message;
@@ -19,19 +20,76 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
     let disposed = false, revision = 0, serial = 0, generation = 0, checkSerial = 0, connectionPhase = 'unavailable', observedConnected = false;
     let flight, authorization, authorizationId;
     const pending = new Set(), listeners = new Set(), deferred = new Set();
-    let state = { instanceId, revision: 0, phase: 'checking', message: '正在连接远程主机…', logins: {}, checkingProviders: [], providerNeeds: {}, technicalDetails: {} };
+    const providerSerial = new Map();
+    const resultTickets = new WeakMap();
+    let connectionEpoch, connectionInstance;
+    let state = { instanceId, revision: 0, phase: 'checking', message: '正在连接远程主机…', logins: {}, queuedProviders: [...providers], checkingProviders: [], providerNeeds: {}, technicalDetails: {} };
     const publish = (next) => { state = { ...next, instanceId, revision: ++revision }; emit(structuredClone(state)); for (const listener of listeners)
         listener(structuredClone(state)); };
     const track = (p) => { pending.add(p); void p.then(() => pending.delete(p), () => pending.delete(p)); return p; };
-    const close = (outcome, code) => { if (state.requestId && state.provider)
-        result({ requestId: state.requestId, provider: state.provider, outcome, ...(code ? { need: need(code) } : {}) }); };
-    const blocked = (code) => { close('invalidated', code); publish({ phase: 'blocked', message: employeeMessage(code), logins: {}, checkingProviders: [], providerNeeds: {}, technicalDetails: { ...state.technicalDetails, code } }); };
+    const close = (outcome, code) => { if (state.requestId && state.provider) {
+        const terminal = { requestId: state.requestId, provider: state.provider, outcome, ...(code ? { need: need(code) } : {}) };
+        publish({ ...state, requestId: undefined, provider: undefined });
+        result(terminal);
+    } };
+    const blocked = (code) => { const mine = generation; close('invalidated', code); if (disposed || mine !== generation)
+        return; publish({ phase: 'blocked', message: employeeMessage(code), logins: {}, queuedProviders: [], checkingProviders: [], providerNeeds: {}, technicalDetails: { ...state.technicalDetails, code } }); };
     const snapshot = () => state.phase === 'disposed' ? fail('DISPOSED') : state.phase === 'blocked' ? fail(state.technicalDetails.code ?? 'AUTH_STATUS_INVALID') : ok(structuredClone(state));
     const ask = () => {
+        if (disposed || state.phase === 'blocked' || state.phase === 'disposed')
+            return;
+        if (state.checkingProviders.length) {
+            publish({ ...state, ...(!state.requestId ? { phase: 'checking', message: '正在检查登录状态…' } : {}) });
+            return;
+        }
         const provider = state.requestId && state.provider && state.logins[state.provider] === false && !deferred.has(state.provider) ? state.provider : providers.find(p => state.logins[p] === false && !deferred.has(p));
         const same = provider && state.provider === provider && state.requestId && state.phase === 'login-required';
         publish({ ...state, phase: provider ? 'login-required' : 'idle', provider, requestId: provider ? (same ? state.requestId : 'login-' + instanceId + '-' + (++serial)) : undefined, message: provider ? '需要登录，请到设置 → 远程主机连接 点登录' : Object.keys(state.providerNeeds).length ? Object.keys(state.providerNeeds).map(p => p === 'claude' ? 'Claude' : 'Codex').join('、') + ' 登录状态无法确认，请联系管理员。' : '远程主机连接检查完成。' });
     };
+    const beginCheck = (provider) => {
+        const serial = (providerSerial.get(provider) ?? 0) + 1;
+        providerSerial.set(provider, serial);
+        publish({ ...state, ...(!authorization && !state.requestId ? { phase: 'checking', message: '正在检查登录状态…' } : {}), queuedProviders: (state.queuedProviders ?? []).filter(p => p !== provider), checkingProviders: [...new Set([...state.checkingProviders, provider])] });
+        return { provider, generation, serial };
+    };
+    const currentTicket = (ticket) => !disposed && ticket.generation === generation && (providerSerial.get(ticket.provider) ?? 0) === ticket.serial;
+    const finishCheck = (ticket, status) => {
+        const provider = ticket.provider;
+        if (!currentTicket(ticket))
+            return false;
+        const logins = { ...state.logins }, providerNeeds = { ...state.providerNeeds };
+        if (status.ok) {
+            logins[provider] = status.value.loggedIn;
+            delete providerNeeds[provider];
+        }
+        else {
+            delete logins[provider];
+            providerNeeds[provider] = structuredClone(status.error);
+        }
+        const clearTicket = !authorization && state.requestId && state.provider === provider && logins[provider] !== false;
+        const terminal = clearTicket ? { requestId: state.requestId, provider, outcome: logins[provider] === true ? 'logged-in' : 'invalidated', ...(providerNeeds[provider] ? { need: structuredClone(providerNeeds[provider]) } : {}) } : undefined;
+        publish({ ...state, ...(clearTicket ? { requestId: undefined, provider: undefined } : {}), logins, providerNeeds, checkingProviders: state.checkingProviders.filter(p => p !== provider) });
+        if (terminal)
+            result(currentTicket(ticket) ? terminal : { ...terminal, outcome: 'invalidated', need: need(disposed ? 'DISPOSED' : 'CONNECTION_LOST') });
+        if (!currentTicket(ticket))
+            return false;
+        if (!flight && !authorization)
+            ask();
+        if (!currentTicket(ticket))
+            return false;
+        resultTickets.set(status, ticket);
+        return true;
+    };
+    const observeCheck = async (provider, operation) => {
+        const ticket = beginCheck(provider);
+        if (!currentTicket(ticket))
+            return { status: fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST'), current: false };
+        const status = await operation();
+        if (currentTicket(ticket))
+            finishCheck(ticket, status);
+        const observed = resultTickets.get(status);
+        return { status, current: !!observed && currentTicket(observed) };
+    };
     const check = () => {
         if (disposed)
             return Promise.resolve();
@@ -43,7 +101,8 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
         const run = async () => {
             try {
                 // Preserve an existing question while gathering fresh evidence, so duplicate requests keep its ticket.
-                publish({ ...state, ...(!state.requestId ? { phase: 'checking', message: '正在检查登录状态…' } : {}), checkingProviders: [] });
+                const planned = new Map(providers.map(p => [p, providerSerial.get(p) ?? 0]));
+                publish({ ...state, ...(!state.requestId ? { phase: 'checking', message: '正在检查登录状态…' } : {}), queuedProviders: providers.filter(p => !state.checkingProviders.includes(p)) });
                 const connected = await api.connect();
                 if (disposed || mine !== generation || checkMine !== checkSerial)
                     return;
@@ -51,35 +110,33 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
                     blocked(connected.error.code);
                     return;
                 }
-                const logins = { ...state.logins }, providerNeeds = { ...state.providerNeeds };
                 for (const provider of providers) {
-                    publish({ ...state, checkingProviders: [provider] });
+                    const pendingProvider = state.checkingProviders.includes(provider);
+                    if (pendingProvider)
+                        await new Promise(resolve => { const done = () => { if (disposed || mine !== generation || !state.checkingProviders.includes(provider)) {
+                            listeners.delete(done);
+                            resolve();
+                        } }; listeners.add(done); done(); });
+                    if (disposed || mine !== generation || checkMine !== checkSerial)
+                        return;
+                    if (pendingProvider || (providerSerial.get(provider) ?? 0) !== planned.get(provider)) {
+                        publish({ ...state, queuedProviders: (state.queuedProviders ?? []).filter(p => p !== provider) });
+                        continue;
+                    }
+                    const ticket = beginCheck(provider);
                     const status = await api.checkLogin(provider);
                     if (disposed || mine !== generation || checkMine !== checkSerial)
                         return;
+                    // createConnect publishes its own newer ticket; standalone coordinators use this one.
+                    finishCheck(ticket, status);
                     if (!status.ok) {
                         if (status.error.layer !== 'auth' && !['AUTH_STATUS_INVALID', 'LOGIN_FAILED', 'POLICY_DENIED'].includes(status.error.code)) {
                             blocked(status.error.code);
                             return;
                         }
-                        delete logins[provider];
-                        providerNeeds[provider] = status.error;
-                    }
-                    else {
-                        logins[provider] = status.value.loggedIn;
-                        delete providerNeeds[provider];
                     }
-                    if (state.requestId && state.provider === provider && logins[provider] !== false) {
-                        close(logins[provider] === true ? 'logged-in' : 'invalidated', providerNeeds[provider]?.code);
-                        publish({ ...state, requestId: undefined, provider: undefined, phase: 'checking', message: '正在检查登录状态…' });
-                    }
-                    publish({ ...state, logins: { ...logins }, providerNeeds: { ...providerNeeds }, checkingProviders: state.checkingProviders.filter(p => p !== provider) });
-                }
-                if (state.requestId && state.provider && logins[state.provider] === true) {
-                    close('logged-in');
-                    publish({ ...state, requestId: undefined, provider: undefined, phase: 'checking', message: '正在检查登录状态…' });
                 }
-                publish({ ...state, logins, providerNeeds, checkingProviders: [], technicalDetails: connected.value.hostContext ? { hostContext: structuredClone(connected.value.hostContext) } : {} });
+                publish({ ...state, queuedProviders: [], technicalDetails: connected.value.hostContext ? { hostContext: structuredClone(connected.value.hostContext) } : {} });
                 ask();
             }
             catch {
@@ -96,7 +153,7 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
     const providerFailed = (provider, code, sourceNeed = need(code)) => {
         const logins = { ...state.logins };
         delete logins[provider];
-        publish({ ...state, phase: 'idle', requestId: undefined, provider: undefined, logins, checkingProviders: [], providerNeeds: { ...state.providerNeeds, [provider]: structuredClone(sourceNeed) } });
+        publish({ ...state, phase: 'idle', requestId: undefined, provider: undefined, logins, checkingProviders: state.checkingProviders.filter(p => p !== provider), providerNeeds: { ...state.providerNeeds, [provider]: structuredClone(sourceNeed) } });
         ask();
     };
     const respond = (requestId, action) => {
@@ -108,7 +165,10 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
             return Promise.resolve(fail('LOGIN_PROMPT_INVALID'));
         const provider = state.provider;
         if (action === 'defer') {
+            const mine = generation;
             close('deferred');
+            if (disposed || mine !== generation)
+                return Promise.resolve(fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST'));
             deferred.add(provider);
             publish({ ...state, requestId: undefined, provider: undefined });
             ask();
@@ -119,29 +179,44 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
         const mine = generation;
         checkSerial++;
         authorizationId = requestId;
-        publish({ ...state, phase: 'authorizing', checkingProviders: [provider], message: '请在授权窗口完成本人登录。' });
+        publish({ ...state, phase: 'authorizing', queuedProviders: [], checkingProviders: [...new Set([...state.checkingProviders, provider])], message: '请在授权窗口完成本人登录。' });
+        const superseded = () => { const failure = authFailure('connect-check-login', 'STATUS_SUPERSEDED'); if (state.requestId === requestId)
+            publish({ ...state, phase: 'idle', requestId: undefined, provider: undefined }); result({ requestId, provider, outcome: 'invalidated', need: failure.error }); ask(); return failure; };
         const run = async () => {
             try {
                 await flight;
                 if (disposed || mine !== generation)
                     return fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST');
-                const current = await api.checkLogin(provider);
+                const observation = await observeCheck(provider, () => api.checkLogin(provider));
                 if (disposed || mine !== generation)
                     return fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST');
-                const verified = current.ok && current.value.loggedIn ? current : current.ok ? await api.login(provider) : current;
+                if (!observation.current)
+                    return superseded();
+                const current = observation.status;
+                const login = current.ok && !current.value.loggedIn ? await observeCheck(provider, () => api.login(provider)) : observation;
+                const verified = login.status;
                 if (disposed || mine !== generation)
                     return fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST');
+                const finalTicket = resultTickets.get(verified);
+                if (!login.current || !finalTicket || !currentTicket(finalTicket))
+                    return superseded();
                 if (!verified.ok || !verified.value.loggedIn) {
                     const code = verified.ok ? 'LOGIN_FAILED' : verified.error.code;
-                    result({ requestId, provider, outcome: 'failed', need: need(code) });
                     providerFailed(provider, code, verified.ok ? need(code) : verified.error);
-                    return verified.ok ? fail(code) : verified;
+                    result({ requestId, provider, outcome: 'failed', need: verified.ok ? need(code) : verified.error });
+                    return disposed || mine !== generation ? fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST') : verified.ok ? fail(code) : verified;
                 }
-                result({ requestId, provider, outcome: 'logged-in' });
                 deferred.delete(provider);
                 const providerNeeds = { ...state.providerNeeds };
                 delete providerNeeds[provider];
-                publish({ ...state, requestId: undefined, provider: undefined, logins: { ...state.logins, [provider]: true }, providerNeeds, checkingProviders: [], phase: 'idle' });
+                publish({ ...state, requestId: undefined, provider: undefined, logins: { ...state.logins, [provider]: true }, providerNeeds, checkingProviders: state.checkingProviders.filter(p => p !== provider), phase: 'idle' });
+                if (disposed || mine !== generation) {
+                    result({ requestId, provider, outcome: 'invalidated', need: need(disposed ? 'DISPOSED' : 'CONNECTION_LOST') });
+                    return fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST');
+                }
+                result({ requestId, provider, outcome: 'logged-in' });
+                if (disposed || mine !== generation)
+                    return fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST');
                 ask();
                 return snapshot();
             }
@@ -161,7 +236,9 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
         } });
         return promise;
     };
-    return { getState: () => structuredClone(state), check,
+    return { getState: () => structuredClone(state), check, beginCheck, finishCheck, currentTicket, captureCheck: (provider) => ({ provider, generation, serial: providerSerial.get(provider) ?? 0 }),
+        inheritCheck(source, derived) { const ticket = resultTickets.get(source); if (ticket && currentTicket(ticket))
+            resultTickets.set(derived, ticket); },
         subscribe(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
         async request(provider, intent) {
             if (!providers.includes(provider) || !['automatic', 'user'].includes(intent))
@@ -176,6 +253,8 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
                 return fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST');
             if (intent === 'user' && !authorization && state.logins[provider] === false && !state.providerNeeds[provider] && !state.checkingProviders.includes(provider) && state.phase !== 'blocked' && state.phase !== 'disposed' && state.provider !== provider) {
                 close('invalidated', 'LOGIN_PROMPT_INVALID');
+                if (disposed || mine !== generation)
+                    return fail(disposed ? 'DISPOSED' : 'CONNECTION_LOST');
                 publish({ ...state, phase: 'login-required', provider, requestId: 'login-' + instanceId + '-' + (++serial), message: '需要登录，请到设置 → 远程主机连接 点登录' });
             }
             return state.providerNeeds[provider] ? { ok: false, error: structuredClone(state.providerNeeds[provider]) } : snapshot();
@@ -190,6 +269,18 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
                 return;
             const prior = connectionPhase;
             connectionPhase = next.phase;
+            const changed = connectionEpoch !== undefined && (connectionEpoch !== next.epoch || connectionInstance !== next.instanceId);
+            connectionEpoch = next.epoch;
+            connectionInstance = next.instanceId;
+            if (changed) {
+                generation++;
+                flight = undefined;
+                const mine = generation;
+                close('invalidated', 'CONNECTION_LOST');
+                if (disposed || mine !== generation)
+                    return;
+                publish({ phase: 'checking', message: '正在连接远程主机…', logins: {}, queuedProviders: [], checkingProviders: [], providerNeeds: {}, technicalDetails: {} });
+            }
             if (next.phase === 'unavailable' || next.phase === 'disposed') {
                 generation++;
                 flight = undefined;
@@ -206,6 +297,6 @@ export function createStartup(api, providers, emit = () => { }, result = () => {
             }
         },
         stop() { if (disposed)
-            return; disposed = true; generation++; close('invalidated', 'DISPOSED'); publish({ phase: 'disposed', message: '远程主机连接已关闭。', logins: {}, checkingProviders: [], providerNeeds: {}, technicalDetails: { code: 'DISPOSED' } }); listeners.clear(); },
+            return; disposed = true; generation++; close('invalidated', 'DISPOSED'); publish({ phase: 'disposed', message: '远程主机连接已关闭。', logins: {}, queuedProviders: [], checkingProviders: [], providerNeeds: {}, technicalDetails: { code: 'DISPOSED' } }); listeners.clear(); },
         async dispose() { this.stop(); await Promise.allSettled([...pending]); }, };
 }

package/lib/workspace-bindings.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectApi, SessionProjectTarget, Result, ConnectionState, WorkspaceBindingState, WorkspaceNoticeReceipt, WorkspaceUse } from './api.ts';
+import type { ConnectApi, SessionProjectTarget, Result, ConnectionState, WorkspaceBindingState, WorkspaceNoticeReceipt, WorkspaceUse, Provider, SshTarget } from './api.ts';
 export interface NativeWorkspace {
     id: string;
     path: string;
@@ -25,6 +25,9 @@ export interface WorkspaceBindingOptions {
 export declare function createWorkspaceBindings(options: WorkspaceBindingOptions): {
     observeConnection(state: ConnectionState): void;
     dispose(): Promise<unknown>;
+    verifyRemoteConversationScope: (sessionId: string, provider: Provider, target: SshTarget) => Promise<Result<{
+        identity: string;
+    }>>;
     getWorkspaceBindingState: () => WorkspaceBindingState;
     onWorkspaceBindingState(listener: (state: WorkspaceBindingState) => void): () => void;
     acknowledgeWorkspaceNotice: (receipt: WorkspaceNoticeReceipt) => Promise<Result<void>>;

package/lib/workspace-bindings.js

@@ -8,7 +8,7 @@ import { ok, fail, NeedError, need } from "./needs.js";
 const queues = new Map();
 const hash = (v) => createHash('sha256').update(JSON.stringify(v)).digest('hex');
 const token = (v) => typeof v === 'string' && v.length > 0 && !/[\x00-\x1f\x7f]/.test(v);
-const integrity = (r) => hash([r.identity, r.workspaceId, r.localPath, r.localDev, r.localIno, r.project, r.bindingId, r.noticeId, r.sessionIds]);
+const integrity = (r) => hash([r.identity, r.workspaceId, r.localPath, r.localDev, r.localIno, r.project, r.bindingId, r.noticeId, r.sessionIds, ...(r.accepted === undefined ? [] : [r.accepted])]);
 export function createWorkspaceBindings(options) {
     const root = join(options.profileDir, 'ai-workbench-connect'), file = join(root, 'workspaces.json'), owner = randomUUID();
     let revision = 0, disposed = false, tail = Promise.resolve(), snapshot = { instanceId: options.api.getConnectionState().instanceId, revision: 0, items: [] };
@@ -52,6 +52,8 @@ export function createWorkspaceBindings(options) {
                 throw Error('BINDING_INVALID');
             if (r.provider === 'pending' ? r.claim !== undefined : (!r.claim || !token(r.claim.id) || !token(r.claim.sessionId) || !['claude', 'codex'].includes(r.claim.provider) || !token(r.claim.owner) || (r.provider === 'delivered' && !token(r.claim.deliveryId))))
                 throw Error('BINDING_CLAIM_INVALID');
+            if (r.accepted !== undefined && (!Array.isArray(r.accepted) || r.accepted.some(a => !r.sessionIds.includes(a.sessionId) || !['claude', 'codex'].includes(a.provider)) || new Set(r.accepted.map(a => a.sessionId + '\0' + a.provider)).size !== r.accepted.length))
+                throw Error('BINDING_ACCEPTANCE_INVALID');
             ids.add(r.workspaceId);
             paths.add(r.identity + '\0' + r.project.path);
             notices.add(r.noticeId);
@@ -249,6 +251,12 @@ export function createWorkspaceBindings(options) {
                 return stale();
             if (!sameNative(current, await native(sessionId)))
                 throw new NeedError(need('PROJECT_BINDING_INVALID'));
+            if (!same(before))
+                return stale();
+            binding.accepted ??= [];
+            if (!binding.accepted.some(a => a.sessionId === sessionId && a.provider === use.provider))
+                binding.accepted.push({ sessionId, provider: use.provider });
+            await save(stored);
             if (!same(before))
                 return stale();
             publish(stored);
@@ -306,6 +314,47 @@ export function createWorkspaceBindings(options) {
             return fail('PROJECT_BINDING_INVALID');
         }
     }
+    // Pure verification: never resolves a project, checks login, creates or claims a notice.
+    async function verifyRemoteConversationScope(sessionId, provider, target) {
+        const before = options.api.getConnectionState();
+        if (!same(before))
+            return stale();
+        if (!token(sessionId) || !['claude', 'codex'].includes(provider))
+            return fail('REMOTE_DETAIL_SCOPE_INVALID');
+        try {
+            if (!isAbsolute(options.profileDir) || await realpath(options.profileDir) !== options.profileDir)
+                return fail('REMOTE_DETAIL_SCOPE_INVALID');
+            if (!same(before))
+                return stale();
+            const directory = await lstat(root);
+            if (!same(before))
+                return stale();
+            if (!directory.isDirectory() || directory.isSymbolicLink() || await realpath(root) !== root)
+                return fail('REMOTE_DETAIL_SCOPE_INVALID');
+            if (!same(before))
+                return stale();
+            const stored = await records();
+            if (!same(before))
+                return stale();
+            const binding = stored.find(r => r.sessionIds.includes(sessionId));
+            if (!binding || binding.phase !== 'bound' || statuses.get(binding.bindingId) === 'invalid' || !binding.accepted?.some(a => a.sessionId === sessionId && a.provider === provider))
+                return fail('REMOTE_DETAIL_SCOPE_INVALID');
+            const trust = await readPrivate(target.knownHostsFile, options.metadataMaxBytes);
+            if (!same(before))
+                return stale();
+            if (binding.identity !== hash([target.host, target.username, target.port, target.projectRoot, target.session, trust]))
+                return fail('REMOTE_DETAIL_SCOPE_INVALID');
+            const current = await native(sessionId);
+            if (!same(before))
+                return stale();
+            if (binding.workspaceId !== current.workspaceId || binding.localPath !== current.localPath || binding.localDev !== current.localDev || binding.localIno !== current.localIno || binding.project.name !== current.name || binding.project.path !== target.projectRoot + '/' + current.name)
+                return fail('REMOTE_DETAIL_SCOPE_INVALID');
+            return ok({ identity: hash([target.host, target.username, target.port, trust]) });
+        }
+        catch {
+            return same(before) ? fail('REMOTE_DETAIL_SCOPE_INVALID') : stale();
+        }
+    }
     // Loading metadata never resolves a remote project or creates either a local or remote directory.
     void serialized(async () => { try {
         await prepare();
@@ -320,6 +369,7 @@ export function createWorkspaceBindings(options) {
             if (status === 'ready')
                 statuses.set(id, 'unavailable'); publish(latest); },
         dispose() { disposed = true; listeners.clear(); return tail; },
+        verifyRemoteConversationScope: (sessionId, provider, target) => serialized(() => verifyRemoteConversationScope(sessionId, provider, target)),
         getWorkspaceBindingState: () => structuredClone(snapshot),
         onWorkspaceBindingState(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
         acknowledgeWorkspaceNotice: (receipt) => serialized(() => acknowledge(receipt)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/connect",
-  "version": "0.7.7",
+  "version": "0.7.11",
   "type": "module",
   "engines": {
     "node": ">=24.13.1"