@ai-workbench/connect 0.7.6 → 0.7.9

package/lib/conversation-details.js

@@ -0,0 +1,381 @@
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { lstat, open, readdir, realpath, rename, rm } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { fail, need, NeedError, ok } from "./needs.js";
+import { privateDirectory, readPrivate } from "./private-files.js";
+const queues = new Map();
+const digest = (s) => createHash('sha256').update(s).digest('hex');
+const text = (v) => typeof v === 'string' && v.length > 0 && !/[\x00-\x1f\x7f]/.test(v);
+const integer = (v) => Number.isSafeInteger(v) && Number(v) >= 0;
+const brand = (v) => v === 'claude' || v === 'codex';
+const canonical = (v) => v === null || typeof v !== 'object' ? JSON.stringify(v) : Array.isArray(v) ? '[' + v.map(canonical).join(',') + ']' : '{' + Object.keys(v).sort().map(k => JSON.stringify(k) + ':' + canonical(v[k])).join(',') + '}';
+const sensitiveText = /(?:\bBearer\s+\S+|\bsk-(?:ant-)?[a-zA-Z0-9_-]+|-----BEGIN (?:[A-Z ]*PRIVATE KEY)-----|https?:\/\/[^\s]*[?&](?:code|token|access_token|refresh_token|id_token|client_secret|device_code|user_code|password)=)/i;
+const sensitiveKey = /^(?:headers?|body|cookies?|authorization|proxy-authorization|password|passwd|secret|client_secret|token|access_token|refresh_token|id_token|api[_-]?key|device[_-]?code|user[_-]?code|credentials?|prompt|messages|model[_-]?(?:input|output))$/i;
+function json(v, seen = new Set()) {
+    if (v === null || typeof v === 'boolean')
+        return true;
+    if (typeof v === 'number')
+        return Number.isFinite(v);
+    if (typeof v === 'string')
+        return !sensitiveText.test(v);
+    if (typeof v !== 'object' || seen.has(v) || (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null))
+        return false;
+    seen.add(v);
+    let valid = true;
+    for (const key of Reflect.ownKeys(v)) {
+        if (Array.isArray(v) && key === 'length')
+            continue;
+        if (typeof key !== 'string' || !Object.getOwnPropertyDescriptor(v, key)?.enumerable || !('value' in Object.getOwnPropertyDescriptor(v, key))) {
+            valid = false;
+            break;
+        }
+        if (sensitiveText.test(key) || (sensitiveKey.test(key) && v[key] !== '已脱敏') || !json(v[key], seen)) {
+            valid = false;
+            break;
+        }
+    }
+    if (Array.isArray(v) && Object.keys(v).length !== v.length)
+        valid = false;
+    seen.delete(v);
+    return valid;
+}
+export function validRemoteConversationDetail(v) {
+    if (!v || typeof v !== 'object' || !json(v))
+        return false;
+    const required = ['version', 'eventId', 'instanceId', 'epoch', 'sessionId', 'provider', 'turn', 'step', 'sequence', 'kind', 'severity', 'code', 'summary', 'payload'];
+    if (required.some(k => !Object.hasOwn(v, k)) || Object.keys(v).some(k => !required.includes(k) && k !== 'method'))
+        return false;
+    return v.version === 1 && text(v.eventId) && text(v.instanceId) && integer(v.epoch) && text(v.sessionId) && brand(v.provider) && integer(v.sequence) && [v.turn, v.step].every(x => x === null || text(x) || integer(x)) && text(v.kind) && ['info', 'warning', 'action-required'].includes(v.severity) && text(v.code) && typeof v.summary === 'string' && (v.method === undefined || text(v.method));
+}
+const counts = (items) => ({ total: items.length, unknownCount: items.filter(d => !['extensions', 'commands', 'tools', 'usage', 'action-required'].includes(d.kind)).length, actionRequiredCount: items.filter(d => d.severity === 'action-required' || d.kind === 'action-required').length });
+export function createConversationDetails(options) {
+    const parent = join(options.profileDir, 'ai-workbench-connect'), root = join(parent, 'conversation-details');
+    let disposed = false, uncertain = false, revision = 0, tail = Promise.resolve();
+    let snapshot = { ...connectionIds(), revision, phase: 'unavailable', sessions: [] };
+    const listeners = new Set();
+    function connectionIds() { const c = options.getConnectionState(); return { instanceId: c.instanceId, epoch: c.epoch }; }
+    function check(before) { const c = options.getConnectionState(); if (disposed || c.phase === 'disposed')
+        throw new NeedError(need('DISPOSED')); if (c.phase !== 'connected' || c.instanceId !== before.instanceId || c.epoch !== before.epoch)
+        throw new NeedError(need('CONNECTION_LOST')); }
+    function start() { const c = options.getConnectionState(); check(c); return c; }
+    async function checked(p, before) { const value = await p; check(before); return value; }
+    function publish(phase, sessions = [], code) {
+        snapshot = { ...connectionIds(), revision: ++revision, phase, sessions, ...(code ? { need: need(code) } : {}) };
+        options.onState?.(structuredClone(snapshot));
+        for (const listener of listeners)
+            listener(structuredClone(snapshot));
+    }
+    function error(e) { const code = e instanceof NeedError ? e.need.code : 'REMOTE_DETAIL_STORAGE_FAILED'; if (code === 'REMOTE_DETAIL_STORAGE_FAILED') {
+        uncertain = true;
+        publish('failed', [], code);
+    }
+    else if (code === 'DISPOSED')
+        publish('disposed', [], code);
+    else if (code === 'CONNECTION_LOST' || code === 'REMOTE_DETAIL_SCOPE_INVALID')
+        publish('unavailable', [], code); return fail(code); }
+    function serial(run) {
+        const pending = (queues.get(root) ?? Promise.resolve()).then(async () => { try {
+            return await run();
+        }
+        catch (e) {
+            return error(e);
+        } });
+        const done = pending.then(() => { }, () => { });
+        queues.set(root, done);
+        tail = done;
+        void done.then(() => { if (queues.get(root) === done)
+            queues.delete(root); });
+        return pending;
+    }
+    async function directory(path, before, create) {
+        if (create)
+            await checked(privateDirectory(path), before);
+        let st;
+        try {
+            st = await checked(lstat(path), before);
+        }
+        catch (e) {
+            if (!create && e.code === 'ENOENT')
+                return false;
+            throw e;
+        }
+        if (!st.isDirectory() || st.isSymbolicLink() || st.uid !== process.getuid() || (st.mode & 0o777) !== 0o700 || await checked(realpath(path), before) !== path)
+            throw Error('DETAIL_PATH_INVALID');
+        if (create)
+            await syncDir(join(path, '..'), before);
+        return true;
+    }
+    async function prepare(identity, before, create = false) {
+        if (!/^[a-f0-9]{64}$/.test(identity) || !isAbsolute(options.profileDir) || await checked(realpath(options.profileDir), before) !== options.profileDir)
+            throw Error('DETAIL_PROFILE_INVALID');
+        if (!await directory(parent, before, create) || !await directory(root, before, create))
+            return undefined;
+        const domain = join(root, identity);
+        return await directory(domain, before, create) ? domain : undefined;
+    }
+    async function syncDir(path, before) { const h = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW); try {
+        check(before);
+        const st = await checked(h.stat(), before);
+        if (!st.isDirectory())
+            throw Error('DETAIL_DIRECTORY_INVALID');
+        await checked(h.sync(), before);
+    }
+    finally {
+        await h.close();
+    } }
+    async function durable(file, bytes, before) {
+        const temp = file + '.' + randomUUID() + '.tmp';
+        let handle;
+        try {
+            handle = await open(temp, 'wx', 0o600);
+            check(before);
+            await checked(handle.writeFile(bytes), before);
+            await checked(handle.sync(), before);
+            await handle.close();
+            handle = undefined;
+            check(before);
+            try {
+                const existing = await checked(lstat(file), before);
+                if (existing.isSymbolicLink() || !existing.isFile() || existing.nlink !== 1)
+                    throw Error('DETAIL_PATH_INVALID');
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+            await checked(rename(temp, file), before);
+            await syncDir(join(file, '..'), before);
+        }
+        finally {
+            await handle?.close();
+            await rm(temp, { force: true });
+        }
+    }
+    // A readable record after reopen does not prove the previous rename was durable.
+    // O_RDONLY verification may sync existing inodes, but never creates or rewrites one.
+    async function verifyReceipt(domain, detail, before) {
+        const file = join(domain, digest(detail.eventId) + '.json'), h = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            check(before);
+            const st = await checked(h.stat(), before);
+            if (!st.isFile() || st.uid !== process.getuid() || st.nlink !== 1 || (st.mode & 0o777) !== 0o600)
+                throw Error('DETAIL_RECORD_INVALID');
+            const record = JSON.parse(await checked(h.readFile('utf8'), before));
+            if (record.version !== 1 || !validRemoteConversationDetail(record.detail) || record.digest !== digest(canonical(record.detail)) || canonical(record.detail) !== canonical(detail))
+                throw Error('DETAIL_RECORD_INVALID');
+            await checked(h.sync(), before);
+        }
+        finally {
+            await h.close();
+        }
+        for (const path of [domain, root, parent, options.profileDir])
+            await syncDir(path, before);
+    }
+    async function privateRead(path, before) {
+        const st = await checked(lstat(path), before);
+        if (!st.isFile() || st.isSymbolicLink() || st.nlink !== 1 || (st.mode & 0o777) !== 0o600)
+            throw Error('DETAIL_RECORD_INVALID');
+        return await checked(readPrivate(path), before);
+    }
+    async function key(before, create = false) {
+        const path = join(root, 'cursor-key');
+        try {
+            const value = await privateRead(path, before);
+            if (!/^[a-f0-9]{64}$/.test(value))
+                throw Error('DETAIL_CURSOR_KEY_INVALID');
+            return value;
+        }
+        catch (e) {
+            if (!create || e.code !== 'ENOENT')
+                throw e;
+        }
+        const value = randomBytes(32).toString('hex');
+        await durable(path, value, before);
+        return value;
+    }
+    async function rows(domain, before) {
+        const items = [], ids = new Set(), sequences = new Set();
+        for (const name of await checked(readdir(domain), before)) {
+            if (!/^[a-f0-9]{64}\.json$/.test(name))
+                throw Error('DETAIL_RECORD_INVALID');
+            const raw = JSON.parse(await checked(privateRead(join(domain, name), before), before)), d = raw.detail;
+            if (raw.version !== 1 || !validRemoteConversationDetail(d) || raw.digest !== digest(canonical(d)) || name !== digest(d.eventId) + '.json' || ids.has(d.eventId) || sequences.has(canonical([d.sessionId, d.provider, d.sequence])))
+                throw Error('DETAIL_RECORD_INVALID');
+            ids.add(d.eventId);
+            sequences.add(canonical([d.sessionId, d.provider, d.sequence]));
+            items.push(d);
+        }
+        return items;
+    }
+    async function scope(sessionId, provider, before) {
+        if (!text(sessionId) || !brand(provider))
+            throw new NeedError(need('REMOTE_DETAIL_SCOPE_INVALID'));
+        const result = await checked(options.scope(sessionId, provider), before);
+        if (!result.ok)
+            throw new NeedError(result.error);
+        return result.value.identity;
+    }
+    async function stateRows(items, identity, before) {
+        const sessions = [];
+        let excluded = false;
+        for (const d of items) {
+            if (sessions.some(s => s.sessionId === d.sessionId && s.provider === d.provider))
+                continue;
+            const verified = await checked(options.scope(d.sessionId, d.provider), before);
+            if (!verified.ok || verified.value.identity !== identity) {
+                excluded = true;
+                continue;
+            }
+            sessions.push({ sessionId: d.sessionId, provider: d.provider, ...counts(items.filter(r => r.sessionId === d.sessionId && r.provider === d.provider)) });
+        }
+        check(before);
+        publish('ready', sessions, excluded ? 'REMOTE_DETAIL_SCOPE_INVALID' : undefined);
+    }
+    function cursor(value, secret) { const payload = Buffer.from(canonical(value)).toString('base64url'); return payload + '.' + createHmac('sha256', secret).update(payload).digest('hex'); }
+    function readCursor(value, secret) {
+        if (!/^[A-Za-z0-9_-]+\.[a-f0-9]{64}$/.test(value))
+            throw new NeedError(need('REMOTE_DETAIL_CURSOR_INVALID'));
+        const [payload, mac] = value.split('.'), expected = createHmac('sha256', secret).update(payload).digest();
+        if (!timingSafeEqual(Buffer.from(mac, 'hex'), expected))
+            throw new NeedError(need('REMOTE_DETAIL_CURSOR_INVALID'));
+        try {
+            return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+        }
+        catch {
+            throw new NeedError(need('REMOTE_DETAIL_CURSOR_INVALID'));
+        }
+    }
+    const api = {
+        appendRemoteConversationDetail(input) {
+            let detail;
+            try {
+                if (!validRemoteConversationDetail(input))
+                    return Promise.resolve(fail('REMOTE_DETAIL_INVALID'));
+                detail = structuredClone(input);
+            }
+            catch {
+                return Promise.resolve(fail('REMOTE_DETAIL_INVALID'));
+            }
+            return serial(async () => {
+                const before = start();
+                if (detail.instanceId !== before.instanceId || detail.epoch !== before.epoch)
+                    return fail('REMOTE_DETAIL_SCOPE_INVALID');
+                if (!Number.isSafeInteger(options.maxEventBytes) || options.maxEventBytes < 1)
+                    return fail('SETTINGS_REQUIRED');
+                const identity = await scope(detail.sessionId, detail.provider, before), domain = (await prepare(identity, before, true)), items = await rows(domain, before), existing = items.find(d => d.eventId === detail.eventId);
+                if (existing && canonical(existing) !== canonical(detail))
+                    return fail('REMOTE_DETAIL_CONFLICT');
+                if (!existing && Buffer.byteLength(JSON.stringify(detail), 'utf8') > options.maxEventBytes)
+                    return fail('REMOTE_DETAIL_TOO_LARGE');
+                if (!existing && items.some(d => d.sessionId === detail.sessionId && d.provider === detail.provider && d.sequence >= detail.sequence))
+                    return fail('REMOTE_DETAIL_SEQUENCE_INVALID');
+                // Recheck native ownership after all storage reads and before writing or acknowledging.
+                if (await scope(detail.sessionId, detail.provider, before) !== identity)
+                    return fail('REMOTE_DETAIL_SCOPE_INVALID');
+                const file = join(domain, digest(detail.eventId) + '.json');
+                await key(before, true);
+                if (!existing) {
+                    await durable(file, JSON.stringify({ version: 1, digest: digest(canonical(detail)), detail }) + '\n', before);
+                    items.push(detail);
+                }
+                else {
+                    const h = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+                    try {
+                        check(before);
+                        await checked(h.sync(), before);
+                    }
+                    finally {
+                        await h.close();
+                    }
+                    await syncDir(domain, before);
+                }
+                await stateRows(items, identity, before);
+                if (await scope(detail.sessionId, detail.provider, before) !== identity)
+                    return fail('REMOTE_DETAIL_SCOPE_INVALID');
+                check(before);
+                uncertain = false;
+                return ok({ eventId: detail.eventId, recorded: true });
+            });
+        },
+        getRemoteConversationDetailReceipt(query) {
+            let q;
+            try {
+                q = structuredClone(query);
+            }
+            catch {
+                return Promise.resolve(fail('REMOTE_DETAIL_INVALID'));
+            }
+            return serial(async () => {
+                const before = start();
+                if (!q || !text(q.eventId) || Object.keys(q).sort().join(',') !== 'eventId,provider,sessionId')
+                    return fail('REMOTE_DETAIL_INVALID');
+                const identity = await scope(q.sessionId, q.provider, before), domain = await prepare(identity, before), items = domain ? await rows(domain, before) : [], d = items.find(r => r.eventId === q.eventId);
+                if (d && (d.sessionId !== q.sessionId || d.provider !== q.provider))
+                    return fail('REMOTE_DETAIL_SCOPE_INVALID');
+                if (d)
+                    await verifyReceipt(domain, d, before);
+                else if (uncertain)
+                    return fail('REMOTE_DETAIL_STORAGE_FAILED');
+                if (await scope(q.sessionId, q.provider, before) !== identity)
+                    return fail('REMOTE_DETAIL_SCOPE_INVALID');
+                if (d)
+                    uncertain = false;
+                return ok(d ? { eventId: q.eventId, recorded: true, detail: structuredClone(d) } : { eventId: q.eventId, recorded: false });
+            });
+        },
+        listRemoteConversationDetails(query) {
+            let q;
+            try {
+                q = structuredClone(query);
+            }
+            catch {
+                return Promise.resolve(fail('REMOTE_DETAIL_INVALID'));
+            }
+            return serial(async () => {
+                const before = start();
+                if (uncertain)
+                    return fail('REMOTE_DETAIL_STORAGE_FAILED');
+                if (!q || Object.keys(q).some(k => !['sessionId', 'provider', 'cursor'].includes(k)))
+                    return fail('REMOTE_DETAIL_INVALID');
+                if (!Number.isSafeInteger(options.pageSize) || options.pageSize < 1)
+                    return fail('SETTINGS_REQUIRED');
+                const identity = await scope(q.sessionId, q.provider, before), domain = await prepare(identity, before), items = domain ? await rows(domain, before) : [], all = items.filter(d => d.sessionId === q.sessionId && d.provider === q.provider).sort((a, b) => a.sequence - b.sequence);
+                const secret = all.length ? await key(before) : '';
+                if (q.cursor !== undefined && !all.length)
+                    return fail('REMOTE_DETAIL_CURSOR_INVALID');
+                let upper = all.at(-1)?.sequence ?? -1, after = -1;
+                if (q.cursor !== undefined) {
+                    if (typeof q.cursor !== 'string')
+                        return fail('REMOTE_DETAIL_CURSOR_INVALID');
+                    const c = readCursor(q.cursor, secret);
+                    if (!c || typeof c !== 'object' || Array.isArray(c) || Object.keys(c).sort().join(',') !== 'after,identity,provider,sessionId,upper,version' || c.version !== 1 || c.identity !== identity || c.sessionId !== q.sessionId || c.provider !== q.provider || !integer(c.upper) || !integer(c.after) || c.after > c.upper || !all.some(d => d.sequence === c.upper) || !all.some(d => d.sequence === c.after))
+                        return fail('REMOTE_DETAIL_CURSOR_INVALID');
+                    upper = c.upper;
+                    after = c.after;
+                }
+                const bounded = all.filter(d => d.sequence <= upper), remaining = bounded.filter(d => d.sequence > after), page = remaining.slice(0, options.pageSize);
+                if (await scope(q.sessionId, q.provider, before) !== identity)
+                    return fail('REMOTE_DETAIL_SCOPE_INVALID');
+                await stateRows(items, identity, before);
+                if (await scope(q.sessionId, q.provider, before) !== identity)
+                    return fail('REMOTE_DETAIL_SCOPE_INVALID');
+                const value = { items: structuredClone(page), ...counts(bounded), ...(page.length < remaining.length ? { nextCursor: cursor({ version: 1, identity, sessionId: q.sessionId, provider: q.provider, upper, after: page.at(-1).sequence }, secret) } : {}) };
+                return ok(value);
+            });
+        },
+        getRemoteConversationDetailState() { const c = options.getConnectionState(); if (disposed || c.phase === 'disposed')
+            return { ...connectionIds(), revision, phase: 'disposed', sessions: [], need: need('DISPOSED') }; if (c.phase !== 'connected' || snapshot.instanceId !== c.instanceId || snapshot.epoch !== c.epoch)
+            return { ...connectionIds(), revision, phase: 'unavailable', sessions: [], need: need('CONNECTION_LOST') }; return structuredClone(snapshot); },
+        onRemoteConversationDetailState(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+    };
+    return { ...api, observeConnection(c) { if (disposed)
+            return; if (c.phase !== 'connected') {
+            publish(c.phase === 'disposed' ? 'disposed' : 'unavailable', [], c.phase === 'disposed' ? 'DISPOSED' : 'CONNECTION_LOST');
+            return;
+        } if (uncertain) {
+            publish('failed', [], 'REMOTE_DETAIL_STORAGE_FAILED');
+            return;
+        } publish('loading'); void serial(async () => { const before = start(), context = await checked(options.context(), before); if (!context.ok)
+            throw new NeedError(context.error); const identity = context.value.identity, domain = await prepare(identity, before); await stateRows(domain ? await rows(domain, before) : [], identity, before); return ok(undefined); }); }, async dispose() { disposed = true; await tail; publish('disposed', [], 'DISPOSED'); listeners.clear(); } };
+}

package/lib/cordis.d.ts

@@ -1,9 +1,10 @@
-import type { ConnectApi, ConnectState, ConnectionState, LoginPromptState, LoginPromptResult, EnrollmentState, WorkspaceBindingState } from './api.ts';
+import type { ConnectApi, ConnectState, ConnectionState, LoginPromptState, LoginPromptResult, EnrollmentState, WorkspaceBindingState, RemoteConversationDetailState } from './api.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         aiWorkbenchConnect: ConnectApi;
     }
     interface Events {
+        'ai-workbench/remote-conversation-detail-state': (state: RemoteConversationDetailState) => void;
         'ai-workbench/enrollment-state': (state: EnrollmentState) => void;
         'ai-workbench/workspace-binding-state': (state: WorkspaceBindingState) => void;
         'ai-workbench/workspace-diagnostic': (error: unknown) => void;

package/lib/defaults.d.ts

@@ -28,3 +28,7 @@ export declare const NETWORK_DEFAULTS: Readonly<{
     controlResponseMaxBytes: 65536;
     downloadMaxRedirects: 3;
 }>;
+export declare const CONVERSATION_DETAIL_DEFAULTS: Readonly<{
+    maxEventBytes: 1048576;
+    pageSize: 100;
+}>;

package/lib/defaults.js

@@ -2,3 +2,4 @@
 export const L_DEFAULTS = Object.freeze({ enrollmentMetadataMaxBytes: 1048576, commandOutputMaxBytes: 1048576, remoteKillGraceMs: 1000, componentDownloadMaxRedirects: 3, componentObservationIntervalMs: 1000, maxDownloadBytes: 200000000, maxExtractedBytes: 600000000, loginOutputMaxBytes: 1048576, ipcMaxBytes: 1048576 });
 export const ELECTRON_PIN = Object.freeze({ source: 'https://github.com/electron/electron/releases/download/v44.0.0/electron-v44.0.0-darwin-arm64.zip', sha256: '076d79742986e1b100b69ebecc691cb07368045e54c9087cef631b8622b76a80', executable: 'Electron.app/Contents/MacOS/Electron' });
 export const NETWORK_DEFAULTS = Object.freeze({ proxyListen: '127.0.0.1:0', logUpload: false, statusRefreshIntervalSeconds: 2, dialTimeoutSeconds: 20, headerTimeoutSeconds: 10, enrollmentObservationSeconds: 30, httpMaxHeaderBytes: 1048576, httpMaxResponseHeaderBytes: 1048576, startupObservationSeconds: 35, shutdownObservationSeconds: 10, controlResponseMaxBytes: 65536, downloadMaxRedirects: 3 });
+export const CONVERSATION_DETAIL_DEFAULTS = Object.freeze({ maxEventBytes: 1048576, pageSize: 100 });

package/lib/index.d.ts

@@ -12,6 +12,10 @@ export { sshArgs } from './ssh.ts';
 export declare const name = "ai-workbench-connect";
 export declare const inject: string[];
 export interface Config {
+    conversationDetails?: {
+        maxEventBytes?: number;
+        pageSize?: number;
+    };
     inventory?: ComponentInventory;
     enrollmentMetadataMaxBytes?: number;
     enrollmentPackageDir?: string;
@@ -35,7 +39,7 @@ export interface Config {
     };
 }
 export declare const Config: z<Config>;
-export declare function register(ctx: Context, ports: Ports, inventory?: ComponentInventory, extend?: (api: import('./api.ts').ConnectApi) => void): void;
+export declare function register(ctx: Context, ports: Ports, _inventory?: ComponentInventory, extend?: (api: import('./api.ts').ConnectApi) => void): void;
 export declare function apply(ctx: Context, config?: Config): void;
 export { createProfileEnrollment } from './profile-enrollment.ts';
 export { createWorkspaceBindings } from './workspace-bindings.ts';

package/lib/index.js

@@ -1,11 +1,12 @@
 import z from '@deepseek-ai/schemastery';
+import { createConversationDetailSettings } from "./conversation-detail-settings.js";
 import { createConnect } from "./connect.js";
 import { configuredPorts } from "./integration.js";
 import { attachProfileRuntime } from "./profile-runtime.js";
 import { profileSettings } from "./profile-settings.js";
 import { createComponentSources, DEFAULT_SOURCE_REASON } from "./component-source.js";
 import { createComponentProgress } from "./component-download.js";
-import { L_DEFAULTS, NETWORK_DEFAULTS } from "./defaults.js";
+import { L_DEFAULTS, NETWORK_DEFAULTS, CONVERSATION_DETAIL_DEFAULTS } from "./defaults.js";
 import { registerComponents } from "./components.js";
 export { writeNetworkConfig, createNetworkClient } from "./network.js";
 export { createConnect } from "./connect.js";
@@ -17,25 +18,30 @@ const positive = () => z.number().step(1).min(1);
 // aiWorkbenchNetwork itself is a required Cordis injection; missing N holds this module from loading.
 // Own technical defaults use the approved settings record; no global DSH policy is changed.
 export const Config = z.object({
-    enrollmentMetadataMaxBytes: positive().max(2147483647).default(L_DEFAULTS.enrollmentMetadataMaxBytes).description('开通元数据与工作区关联文件字节上限；默认1MiB，可由管理员修改；不读取key内容'),
-    inventory: z.object({ network: z.string(), connect: z.string(), claude: z.string(), codex: z.string() }).description('由bundle真实包版本自动生成，只读交付事实，不是策略默认'),
-    enrollmentPackageDir: z.string().description('开通包目录：由安装交付，员工不手填；owner已定稿，交付显式配置'),
-    trustDir: z.string().description('主机信任缓存目录；owner已定稿，交付显式配置'),
-    commandOutputMaxBytes: positive().default(L_DEFAULTS.commandOutputMaxBytes).description('CLI检查输出内存上限（字节）；owner已定1048576，管理员可改'),
-    network: z.object({ executable: z.string(), runtimeDir: z.string(), stateDir: z.string(), configFile: z.string(), helperLogFile: z.string(), nodeName: z.string(), startupObservationSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.startupObservationSeconds), shutdownObservationSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.shutdownObservationSeconds), controlResponseMaxBytes: positive().default(NETWORK_DEFAULTS.controlResponseMaxBytes), downloadMaxRedirects: z.number().step(1).min(0).default(NETWORK_DEFAULTS.downloadMaxRedirects), proxyListen: z.string().default(NETWORK_DEFAULTS.proxyListen), logUpload: z.boolean().default(NETWORK_DEFAULTS.logUpload), statusRefreshIntervalSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.statusRefreshIntervalSeconds), dialTimeoutSeconds: z.number().min(1e-9).default(NETWORK_DEFAULTS.dialTimeoutSeconds), headerTimeoutSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.headerTimeoutSeconds), enrollmentObservationSeconds: z.number().min(1e-9).default(NETWORK_DEFAULTS.enrollmentObservationSeconds), httpMaxHeaderBytes: positive().default(NETWORK_DEFAULTS.httpMaxHeaderBytes), httpMaxResponseHeaderBytes: positive().default(NETWORK_DEFAULTS.httpMaxResponseHeaderBytes), controlMaxBytes: positive() }).description('N v1 交接设置；沿owner已定技术值自动装配，管理员可改；路径由当前用户/profile派生，员工不填'),
+    conversationDetails: z.object({
+        maxEventBytes: positive().max(Number.MAX_SAFE_INTEGER).default(CONVERSATION_DETAIL_DEFAULTS.maxEventBytes).description('conversationDetails.maxEventBytes：完整UTF-8 JSON事件的字节上限；默认1048576，范围1至9007199254740991整数。改大增加单事件存储与内存；改小会拒收超过新值的新事件，不裁剪或删除旧记录。'),
+        pageSize: positive().max(Number.MAX_SAFE_INTEGER).default(CONVERSATION_DETAIL_DEFAULTS.pageSize).description('conversationDetails.pageSize：每页条数；默认100，范围1至9007199254740991整数。改大增加一次读取与界面负担，改小增加继续加载次数，不减少完整快照总数。'),
+    }).description('管理员诊断记录设置：不自动过期、不按条数淘汰、没有隐藏总条数上限，本版没有清除入口。'),
+    enrollmentMetadataMaxBytes: positive().max(2147483647).default(L_DEFAULTS.enrollmentMetadataMaxBytes).description('开通元数据、工作区关联文件、诊断设置文件及设置提交JSON的字节上限；默认1048576，可由管理员修改；改小可能拒绝设置读取/提交，不读取key内容'),
+    inventory: z.object({ network: z.string(), connect: z.string(), claude: z.string(), codex: z.string() }).description('由已安装组件的实际版本自动生成，只读信息，不作为功能开关'),
+    enrollmentPackageDir: z.string().description('连接资料目录：由管理员安装时配置，员工无需手填'),
+    trustDir: z.string().description('主机信任缓存目录：由管理员安装时配置'),
+    commandOutputMaxBytes: positive().default(L_DEFAULTS.commandOutputMaxBytes).description('远程命令输出内存上限（字节），默认1048576，管理员可修改'),
+    network: z.object({ executable: z.string(), runtimeDir: z.string(), stateDir: z.string(), configFile: z.string(), helperLogFile: z.string(), nodeName: z.string(), startupObservationSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.startupObservationSeconds), shutdownObservationSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.shutdownObservationSeconds), controlResponseMaxBytes: positive().default(NETWORK_DEFAULTS.controlResponseMaxBytes), downloadMaxRedirects: z.number().step(1).min(0).default(NETWORK_DEFAULTS.downloadMaxRedirects), proxyListen: z.string().default(NETWORK_DEFAULTS.proxyListen), logUpload: z.boolean().default(NETWORK_DEFAULTS.logUpload), statusRefreshIntervalSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.statusRefreshIntervalSeconds), dialTimeoutSeconds: z.number().min(1e-9).default(NETWORK_DEFAULTS.dialTimeoutSeconds), headerTimeoutSeconds: z.number().min(0.001).max(2147483.647).default(NETWORK_DEFAULTS.headerTimeoutSeconds), enrollmentObservationSeconds: z.number().min(1e-9).default(NETWORK_DEFAULTS.enrollmentObservationSeconds), httpMaxHeaderBytes: positive().default(NETWORK_DEFAULTS.httpMaxHeaderBytes), httpMaxResponseHeaderBytes: positive().default(NETWORK_DEFAULTS.httpMaxResponseHeaderBytes), controlMaxBytes: positive() }).description('远程网络连接设置：使用默认技术参数，管理员可修改；路径根据当前用户和应用配置目录生成，员工无需填写'),
     helper: z.object({
-        componentDownloadSource: z.union([z.const('github'), z.const('npmmirror')]).description('未保存设置节选择时的初始下载源；未设且无旧source时默认npmmirror（编排leo实测可达），可选github；不自动测速/换源，版本与SHA固定'),
+        componentDownloadSource: z.union([z.const('github'), z.const('npmmirror')]).description('未保存设置节选择时的初始下载源；未设且无旧source时默认npmmirror（已验证可达的中国镜像），可选github；不自动测速/换源，版本与SHA固定'),
         componentObservationIntervalMs: z.number().step(1).min(1).max(2147483647).default(L_DEFAULTS.componentObservationIntervalMs).description('无进展观察刷新间隔毫秒，默认1000；只刷新秒数，不超时/重试/换源'),
-        componentDownloadMaxRedirects: z.number().step(1).min(0).default(L_DEFAULTS.componentDownloadMaxRedirects).description('组件直接HTTPS下载的重定向次数上限；默认3，0拒绝重定向；管理员可改，不影响OAuth主机出口'),
-        remoteKillGraceMs: z.number().step(1).min(0).max(2147483647).default(L_DEFAULTS.remoteKillGraceMs).description('远端本轮登录进程组结束宽限毫秒；owner已定1000，0立即KILL，管理员可改'),
-        maxRedirects: z.number().step(1).min(0).description('兼容旧配置；0.5默认路径改由N插件downloadMaxRedirects控制，此项不再生效'),
-        source: z.string().description('兼容初始管理员显式URL；无已保存的设置节选择且未设componentDownloadSource时生效；无隐式换源'), sha256: z.string().description('darwin-arm64默认已定44.0.0下载SHA256；管理员可改，必须校验'),
-        cacheDir: z.string().description('默认从当前profile自动派生ai-workbench-connect/login-component-cache；管理员可改，员工不填路径'), maxDownloadBytes: positive().default(L_DEFAULTS.maxDownloadBytes).description('下载字节上限；owner已定200000000，管理员可改'), maxExtractedBytes: positive().default(L_DEFAULTS.maxExtractedBytes).description('解压字节上限；owner已定600000000，管理员可改'),
-        executable: z.string().description('darwin-arm64默认Electron.app/Contents/MacOS/Electron；其他平台无默认，管理员可改'), loginOutputMaxBytes: positive().default(L_DEFAULTS.loginOutputMaxBytes).description('登录进程输出字节上限；owner已定1048576，管理员可改'), ipcMaxBytes: positive().default(L_DEFAULTS.ipcMaxBytes).description('私有IPC字节上限；owner已定1048576，管理员可改'),
+        componentDownloadMaxRedirects: z.number().step(1).min(0).default(L_DEFAULTS.componentDownloadMaxRedirects).description('组件直接HTTPS下载的重定向次数上限；默认3，0拒绝重定向；管理员可改，不改变网页登录网络'),
+        remoteKillGraceMs: z.number().step(1).min(0).max(2147483647).default(L_DEFAULTS.remoteKillGraceMs).description('远端本轮登录进程组结束宽限毫秒；默认1000，0立即KILL，管理员可改'),
+        maxRedirects: z.number().step(1).min(0).description('兼容旧配置；当前由网络连接组件的downloadMaxRedirects设置控制，此项不再生效'),
+        source: z.string().description('兼容初始管理员显式URL；无已保存的设置节选择且未设componentDownloadSource时生效；无隐式换源'), sha256: z.string().description('darwin-arm64默认使用Electron 44.0.0对应的下载SHA256；管理员可改，必须校验'),
+        cacheDir: z.string().description('默认从当前profile自动派生ai-workbench-connect/login-component-cache；管理员可改，员工不填路径'), maxDownloadBytes: positive().default(L_DEFAULTS.maxDownloadBytes).description('下载字节上限；默认200000000，管理员可改'), maxExtractedBytes: positive().default(L_DEFAULTS.maxExtractedBytes).description('解压字节上限；默认600000000，管理员可改'),
+        executable: z.string().description('darwin-arm64默认Electron.app/Contents/MacOS/Electron；其他平台无默认，管理员可改'), loginOutputMaxBytes: positive().default(L_DEFAULTS.loginOutputMaxBytes).description('登录进程输出字节上限；默认1048576，管理员可改'), ipcMaxBytes: positive().default(L_DEFAULTS.ipcMaxBytes).description('私有IPC字节上限；默认1048576，管理员可改'),
     }),
 });
-export function register(ctx, ports, inventory, extend) {
-    const api = createConnect(ports, state => ctx.emit('ai-workbench/connect-state', state), { providers: inventory && !inventory.codex ? ['claude'] : ['codex', 'claude'], onConnectionState: state => ctx.emit('ai-workbench/connection-state', state), onPromptState: state => ctx.emit('ai-workbench/login-prompt-state', state), onPromptResult: result => ctx.emit('ai-workbench/login-prompt-result', result) });
+export function register(ctx, ports, _inventory, extend) {
+    // 当前独立插件始终检查两品牌；保留旧inventory参数兼容调用，但不以交付清单开关能力。
+    const api = createConnect(ports, state => ctx.emit('ai-workbench/connect-state', state), { onConnectionState: state => ctx.emit('ai-workbench/connection-state', state), onPromptState: state => ctx.emit('ai-workbench/login-prompt-state', state), onPromptResult: result => ctx.emit('ai-workbench/login-prompt-result', result) });
     extend?.(api);
     ctx.provide('aiWorkbenchConnect', api);
     ctx.effect(() => { void api.refreshLoginPrompts(); return () => api.dispose(); });
@@ -43,12 +49,15 @@ export function register(ctx, ports, inventory, extend) {
 export function apply(ctx, config = {}) {
     const sourceReason = config.helper?.componentDownloadSource !== undefined ? '管理员通过 helper.componentDownloadSource 指定此下载源。' : config.helper?.source !== undefined ? '管理员通过 helper.source 指定此下载源。' : DEFAULT_SOURCE_REASON;
     config = profileSettings(config, ctx.get('profileContext')?.dir);
+    const detailSettings = createConversationDetailSettings({ profileDir: ctx.get('profileContext')?.dir, initial: config.conversationDetails, metadataMaxBytes: config.enrollmentMetadataMaxBytes });
+    ctx.provide('aiWorkbenchConversationDetailSettings', detailSettings);
+    ctx.effect(() => () => detailSettings.dispose());
     const network = ctx.get('aiWorkbenchNetwork'), component = createComponentProgress();
     const sources = createComponentSources({ profileDir: ctx.get('profileContext')?.dir, metadataMaxBytes: config.enrollmentMetadataMaxBytes ?? L_DEFAULTS.enrollmentMetadataMaxBytes, source: config.helper?.source, sha256: config.helper?.sha256, reason: sourceReason, busy: () => ['downloading', 'verifying', 'unpacking'].includes(component.getState().phase) || ctx.get('aiWorkbenchConnect')?.getLoginPromptState().phase === 'authorizing' });
     ctx.effect(() => () => sources.dispose());
     const ports = configuredPorts(config, network, component, sources);
     register(ctx, ports, config.inventory, api => attachProfileRuntime(ctx, api, ports, config, network));
-    registerComponents(ctx, config.inventory, config.helper?.cacheDir, component, sources, config.helper?.componentObservationIntervalMs);
+    registerComponents(ctx, config.inventory, config.helper?.cacheDir, component, sources, config.helper?.componentObservationIntervalMs, config.enrollmentMetadataMaxBytes ?? L_DEFAULTS.enrollmentMetadataMaxBytes);
 }
 export { createProfileEnrollment } from "./profile-enrollment.js";
 export { createWorkspaceBindings } from "./workspace-bindings.js";

package/lib/integration.js

@@ -9,7 +9,8 @@ import { remoteLoginCommand } from "./remote-login.js";
 import { runLogin } from "./login.js";
 import { ensureHelper } from "./cache.js";
 import { launchElectron } from "./electron.js";
-import { need, fail } from "./needs.js";
+import { parseLoginStatus } from "./auth-status.js";
+import { need, fail, ok } from "./needs.js";
 import { createComponentProgress, downloadComponent } from "./component-download.js";
 export function configuredPorts(config, provider, component = createComponentProgress(), sources) {
     const ports = {};
@@ -45,6 +46,24 @@ export function configuredPorts(config, provider, component = createComponentPro
                     return result;
                 if (signal.aborted)
                     return fail('LOGIN_FAILED');
+                // Component preparation may outlive another device's completed login. Recheck immediately before any destructive CLI authorization.
+                if (!ports.ssh)
+                    return fail('AUTH_STATUS_INVALID');
+                try {
+                    const raw = await ports.ssh.status(target, provider, signal);
+                    if (signal.aborted)
+                        return fail('CONNECTION_LOST');
+                    if (!raw.ok)
+                        return raw;
+                    const current = parseLoginStatus(provider, raw.value);
+                    if (!current.ok)
+                        return current;
+                    if (current.value.loggedIn)
+                        return ok(undefined);
+                }
+                catch {
+                    return fail('AUTH_STATUS_INVALID');
+                }
                 return runLogin(target, provider, {
                     start: (t, p, s) => createRemoteLogin('ssh', [...sshArgs(t), remoteLoginCommand(p, h.remoteKillGraceMs)], p, h.loginOutputMaxBytes, s, 'remote-control'),
                     acquireProxy: (_t, s) => network.acquireProxy(s),

package/lib/login.d.ts

@@ -6,11 +6,14 @@ export interface ProxyLease {
     closed?: Promise<void>;
     release(): Promise<void>;
 }
-export interface LoginBoot {
-    provider: Provider;
+export type LoginBoot = {
+    provider: 'claude';
     url: string;
-    proxy: Pick<ProxyLease, 'url' | 'username' | 'password'>;
-}
+} | {
+    provider: 'codex';
+    url: string;
+    deviceCode: string;
+};
 export interface RemoteLogin {
     ownership?: Promise<{
         pid: number;
@@ -18,6 +21,7 @@ export interface RemoteLogin {
         provider: string;
     }>;
     url: Promise<Result<string>>;
+    deviceCode?: Promise<Result<string>>;
     completion: Promise<Result<void>>;
     writeCode(code: string): Promise<void>;
     close(): Promise<void>;