dsh-lark-agent 0.4.0 → 0.5.0

package/dist/onboarding/lark-platform.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { BOT_MENU_EVENT } from '../bot-menu.js';
-import { DOCUMENT_SCOPES, STREAMING_SCOPE, defaultScopesReady } from '../rich-scopes.js';
+import { DOCUMENT_SCOPES, STREAMING_SCOPE } from '../rich-scopes.js';
+import { mediaScopes } from '../media-scopes.js';
 export class LarkPlatformError extends Error {
     code;
     constructor(code) {
@@ -244,16 +245,26 @@ export class LarkPlatform {
     }
     /** Incremental, owner-confirmed authorization; returned credentials never leave this method. */
     async enableDocuments(profile, onQRCode, signal) {
+        return this.authorizeScopes(profile, [...DOCUMENT_SCOPES, STREAMING_SCOPE], onQRCode, signal);
+    }
+    async enableInput(profile, kind, onQRCode, signal, expectedAppId) {
+        if ((kind !== 'images' && kind !== 'voice') || !validId(expectedAppId, 'cli'))
+            fail('INVALID_INPUT');
+        return this.authorizeScopes(profile, mediaScopes(kind), onQRCode, signal, expectedAppId);
+    }
+    async authorizeScopes(profile, scopes, onQRCode, signal, expectedAppId) {
         const selected = await this.profile(profile, signal);
+        if (expectedAppId !== undefined && selected.appId !== expectedAppId)
+            fail('APP_MISMATCH');
         try {
             const current = await this.inspect(profile, signal);
             if (current.appId !== selected.appId)
                 fail('APP_MISMATCH');
             // Another host may already have completed the upgrade; never ask for another scan just to refresh UI state.
-            if (current.scopeStatus === 'verified' && defaultScopesReady(current.grantedScopes))
+            if (current.scopeStatus === 'verified' && scopes.every(scope => current.grantedScopes.includes(scope)))
                 return;
             const result = await this.registrar({ source: 'dsh-larkbot', appId: selected.appId, signal,
-                addons: { preset: false, scopes: { tenant: [...DOCUMENT_SCOPES, STREAMING_SCOPE] } },
+                addons: { preset: false, scopes: { tenant: [...scopes] } },
                 onQRCodeReady: info => {
                     checkSignal(signal);
                     let url;
@@ -274,7 +285,7 @@ export class LarkPlatform {
             if (result.client_id !== selected.appId || (result.user_info?.tenant_brand && result.user_info.tenant_brand !== selected.brand))
                 fail('APP_MISMATCH');
             const inspection = await this.inspect(profile, signal);
-            if (inspection.appId !== selected.appId || inspection.scopeStatus !== 'verified' || !defaultScopesReady(inspection.grantedScopes))
+            if (inspection.appId !== selected.appId || inspection.scopeStatus !== 'verified' || !scopes.every(scope => inspection.grantedScopes.includes(scope)))
                 fail('MISSING_SCOPE');
         }
         catch (error) {

package/dist/onboarding/manager.d.ts

@@ -0,0 +1,32 @@
+import { type OnboardingDependencies } from './controller.js';
+import { ConnectionStore } from './store.js';
+import type { AgentCatalog, ConnectionEndpoint, ConnectionList, ConnectionSnapshot } from './protocol.js';
+export declare const MAX_CONNECTIONS = 10;
+export declare const validConnectionId: (id: unknown) => id is string;
+/** Owns independent controllers; the legacy controller and its native logs never move. */
+export declare class ConnectionManager {
+    private readonly directory;
+    private readonly dependencies;
+    private readonly readCatalog;
+    private readonly controllers;
+    private readonly registry;
+    private readonly claims;
+    private tail;
+    private closed;
+    constructor(directory: string, dependencies: (store: ConnectionStore) => Omit<OnboardingDependencies, 'store'>, readCatalog: () => Promise<AgentCatalog>);
+    private make;
+    initialize(): Promise<void>;
+    private get;
+    snapshot(id?: string): ConnectionSnapshot;
+    list(): ConnectionList;
+    catalog(): Promise<AgentCatalog>;
+    profiles(signal?: AbortSignal, id?: string): Promise<import("./protocol.js").ConnectionProfile[]>;
+    command(endpoint: Exclude<ConnectionEndpoint, 'profiles' | 'status'>, payload: unknown, id?: string): Promise<ConnectionSnapshot>;
+    add(): Promise<ConnectionList & {
+        selectedId: string;
+    }>;
+    remove(id: string): Promise<ConnectionList & {
+        selectedId: string;
+    }>;
+    dispose(): Promise<boolean>;
+}

package/dist/onboarding/manager.js

@@ -0,0 +1,129 @@
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { ConnectionController, SetupError } from './controller.js';
+import { ConnectionStore } from './store.js';
+import { SettingsStore } from './settings-store.js';
+export const MAX_CONNECTIONS = 10;
+export const validConnectionId = (id) => typeof id === 'string' && (id === 'default' || /^[a-f0-9]{32}$/.test(id));
+function ids(raw) {
+    const value = raw;
+    if (value?.version !== 1 || !Array.isArray(value.ids) || !value.ids.length || value.ids.length > MAX_CONNECTIONS
+        || value.ids[0] !== 'default' || !value.ids.every(validConnectionId) || new Set(value.ids).size !== value.ids.length)
+        throw new Error('Invalid connection registry');
+    return { version: 1, ids: [...value.ids] };
+}
+/** Owns independent controllers; the legacy controller and its native logs never move. */
+export class ConnectionManager {
+    directory;
+    dependencies;
+    readCatalog;
+    controllers = new Map();
+    registry;
+    claims = new Map();
+    tail = Promise.resolve();
+    closed = false;
+    constructor(directory, dependencies, readCatalog) {
+        this.directory = directory;
+        this.dependencies = dependencies;
+        this.readCatalog = readCatalog;
+        this.registry = new SettingsStore(directory, 'connections.json', ids);
+    }
+    make(id) {
+        const directory = id === 'default' ? this.directory : join(this.directory, 'connections', id);
+        const store = new ConnectionStore(directory);
+        return new ConnectionController({ ...this.dependencies(store), store, reserveApp: appId => {
+                const owner = this.claims.get(appId);
+                if (owner && owner !== id)
+                    throw new SetupError('这个机器人已在列表中，请直接打开对应的机器人。', false);
+                this.claims.set(appId, id);
+            }, commitApp: appId => {
+                for (const [reserved, owner] of this.claims)
+                    if (owner === id && reserved !== appId)
+                        this.claims.delete(reserved);
+            } });
+    }
+    async initialize() {
+        const registry = await this.registry.read() ?? { version: 1, ids: ['default'] };
+        // Reserve all saved identities before any enabled controller starts receiving.
+        for (const id of registry.ids) {
+            const store = new ConnectionStore(id === 'default' ? this.directory : join(this.directory, 'connections', id));
+            const record = await store.read();
+            if (record) {
+                if (this.claims.has(record.appId))
+                    throw new SetupError('机器人列表有重复身份，请检查本地连接状态。', false);
+                this.claims.set(record.appId, id);
+            }
+            this.controllers.set(id, this.make(id));
+        }
+        for (const controller of this.controllers.values())
+            await controller.initialize();
+    }
+    get(id = 'default') {
+        if (this.closed || !validConnectionId(id))
+            throw new SetupError('机器人入口不可用，请刷新列表。');
+        const controller = this.controllers.get(id);
+        if (!controller)
+            throw new SetupError('没有找到这个机器人，请刷新列表。');
+        return controller;
+    }
+    snapshot(id) { return this.get(id).snapshot(); }
+    list() {
+        return { limit: MAX_CONNECTIONS, connections: [...this.controllers].map(([id, controller], index) => {
+                const snapshot = controller.snapshot();
+                return { id, label: snapshot.agent?.label || snapshot.bot?.name || `飞书助手 ${index + 1}`,
+                    phase: snapshot.phase, busy: snapshot.busy, agentPreset: snapshot.agent?.agentPreset ?? '' };
+            }) };
+    }
+    catalog() { return this.readCatalog(); }
+    profiles(signal, id) { return this.get(id).profiles(signal); }
+    command(endpoint, payload, id) {
+        // Serialize roster changes with command admission, before a controller can acquire a service.
+        const result = this.tail.then(() => this.get(id).command(endpoint, payload));
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+    add() {
+        const result = this.tail.then(async () => {
+            if (this.closed)
+                throw new SetupError('连接设置已关闭。');
+            if (this.controllers.size >= MAX_CONNECTIONS)
+                throw new SetupError(`最多管理 ${MAX_CONNECTIONS} 个机器人。`);
+            const id = randomUUID().replaceAll('-', '');
+            const controller = this.make(id);
+            await controller.initialize();
+            // Publish the new controller only after its roster entry is durable.
+            await this.registry.write({ version: 1, ids: [...this.controllers.keys(), id] });
+            this.controllers.set(id, controller);
+            return { ...this.list(), selectedId: id };
+        });
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+    remove(id) {
+        const result = this.tail.then(async () => {
+            const controller = this.get(id), snapshot = controller.snapshot();
+            if (id === 'default')
+                throw new SetupError('首个机器人入口会保留，可以断开后复用。');
+            if (!snapshot.agent?.editable || snapshot.documentSetup || snapshot.inputSetup)
+                throw new SetupError('请先暂停或取消这个机器人的连接和授权，再从列表移除。');
+            if (!await controller.dispose())
+                throw new SetupError('连接尚未安全停止，机器人入口已保留。');
+            await this.registry.write({ version: 1, ids: [...this.controllers.keys()].filter(key => key !== id) });
+            this.controllers.delete(id);
+            for (const [appId, owner] of this.claims)
+                if (owner === id)
+                    this.claims.delete(appId);
+            // Its durable folder and CLI credentials are retained for manual recovery.
+            return { ...this.list(), selectedId: 'default' };
+        });
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+    async dispose() {
+        this.closed = true;
+        await this.tail;
+        const results = await Promise.allSettled([...this.controllers.values()].map(controller => controller.dispose()));
+        return results.every(result => result.status === 'fulfilled' && result.value);
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/onboarding/protocol.d.ts

@@ -1,3 +1,4 @@
+import type { MediaInputKind } from '../media-scopes.js';
 /** Owner-only UI contract. Credentials and raw platform errors never belong here. */
 export type ConnectionPhase = 'idle' | 'creating' | 'waiting_scan' | 'configuring' | 'action_required' | 'pairing' | 'confirming_owner' | 'starting' | 'connected' | 'paused' | 'error';
 export interface ConnectionSnapshot {
@@ -30,6 +31,8 @@ export interface ConnectionSnapshot {
         cards: boolean;
         loading: boolean;
         documents?: boolean;
+        images?: boolean;
+        voice?: boolean;
     };
     documentSetup?: {
         phase: 'preparing' | 'scanning' | 'error';
@@ -40,6 +43,16 @@ export interface ConnectionSnapshot {
             expiresAt: number;
         };
     };
+    inputSetup?: {
+        kind: MediaInputKind;
+        phase: 'preparing' | 'scanning' | 'error';
+        message: string;
+        qr?: {
+            url: string;
+            image: string;
+            expiresAt: number;
+        };
+    };
     /** Bottom-menu entries the published app lacks, and where its owner adds them. */
     menu?: {
         missing: Array<{
@@ -54,13 +67,50 @@ export interface ConnectionSnapshot {
         current: string;
         latest: string;
     };
+    agent?: AgentSettings & {
+        workspaceDisplay: string;
+        editable: boolean;
+    };
+}
+/** Per-robot choices. Empty preset/workspace follows the host/default workspace. */
+export interface AgentSettings {
+    label: string;
+    agentPreset: string;
+    workspace: string;
+    imageInput: boolean;
+    voiceInput: boolean;
+}
+export interface AgentCatalog {
+    presets: Array<{
+        id: string;
+        name: string;
+        description?: string;
+        available: boolean;
+    }>;
+    presetsAvailable: boolean;
+    defaultPreset?: string;
+    model: string;
+    imagesAvailable: boolean;
+    voiceAvailable: boolean;
+    modelImages?: 'supported' | 'unsupported' | 'unknown';
+}
+export interface ConnectionList {
+    connections: Array<{
+        id: string;
+        label: string;
+        phase: ConnectionPhase;
+        busy: boolean;
+        agentPreset: string;
+    }>;
+    limit: number;
 }
+export type ManagerEndpoint = 'connections' | 'add-connection' | 'remove-connection' | 'agent-catalog';
 export interface ConnectionProfile {
     name: string;
     appId: string;
     label: string;
 }
-export type ConnectionEndpoint = 'status' | 'profiles' | 'create' | 'use-profile' | 'recheck' | 'cancel' | 'renew-pairing' | 'confirm-owner' | 'pause' | 'resume' | 'disconnect' | 'enable-documents' | 'cancel-documents';
+export type ConnectionEndpoint = 'status' | 'profiles' | 'create' | 'use-profile' | 'recheck' | 'cancel' | 'renew-pairing' | 'confirm-owner' | 'pause' | 'resume' | 'disconnect' | 'enable-documents' | 'cancel-documents' | 'enable-input' | 'cancel-input' | 'update-agent';
 export type ConnectionResult<T> = {
     ok: true;
     value: T;

package/dist/onboarding/settings-store.d.ts

@@ -0,0 +1,11 @@
+/** A failed publication poisons this writer until the owner reloads from disk. */
+export declare class SettingsStore<T> {
+    private readonly directory;
+    private readonly filename;
+    private readonly parse;
+    private unavailable;
+    private tail;
+    constructor(directory: string, filename: string, parse: (raw: unknown) => T);
+    read(): Promise<T | undefined>;
+    write(value: T): Promise<void>;
+}

package/dist/onboarding/settings-store.js

@@ -0,0 +1,67 @@
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+/** A failed publication poisons this writer until the owner reloads from disk. */
+export class SettingsStore {
+    directory;
+    filename;
+    parse;
+    unavailable = false;
+    tail = Promise.resolve();
+    constructor(directory, filename, parse) {
+        this.directory = directory;
+        this.filename = filename;
+        this.parse = parse;
+    }
+    async read() {
+        await this.tail;
+        if (this.unavailable)
+            throw new Error('Settings publication is uncertain');
+        try {
+            return this.parse(JSON.parse(await readFile(join(this.directory, this.filename), 'utf8')));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+    }
+    write(value) {
+        const safe = this.parse(value);
+        const job = this.tail.then(async () => {
+            if (this.unavailable)
+                throw new Error('Settings publication is uncertain');
+            await mkdir(this.directory, { recursive: true, mode: 0o700 });
+            const temp = join(this.directory, `${this.filename}.${randomUUID()}.tmp`);
+            let publishing = false;
+            try {
+                const file = await open(temp, 'wx', 0o600);
+                try {
+                    await file.writeFile(JSON.stringify(safe) + '\n');
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+                publishing = true;
+                await rename(temp, join(this.directory, this.filename));
+                const directory = await open(this.directory, 'r');
+                try {
+                    await directory.sync();
+                }
+                finally {
+                    await directory.close();
+                }
+            }
+            catch (error) {
+                if (publishing)
+                    this.unavailable = true;
+                await unlink(temp).catch(() => undefined);
+                throw error;
+            }
+        });
+        this.tail = job.catch(() => undefined);
+        return job;
+    }
+}
+//# sourceMappingURL=settings-store.js.map

package/dist/session-store.d.ts

@@ -10,6 +10,8 @@ export interface SavedSession {
     title: string;
     createdAt: number;
     updatedAt: number;
+    /** Workspace captured when this native session was created. */
+    cwd?: string;
 }
 export type SessionStoreErrorCode = 'INVALID_INPUT' | 'NOT_FOUND' | 'NO_CURRENT' | 'CONFLICT' | 'CAPACITY' | 'CORRUPT' | 'WRITE_FAILED' | 'UNAVAILABLE';
 /** Messages contain no titles, user identifiers, native session IDs, or filesystem details. */
@@ -35,7 +37,9 @@ export declare class SessionStore {
     private mutate;
     current(context: SessionContext): Promise<SavedSession | undefined>;
     list(context: SessionContext): Promise<SavedSession[]>;
-    add(context: SessionContext, nativeId: string, title?: string): Promise<SavedSession>;
+    add(context: SessionContext, nativeId: string, title?: string, cwd?: string): Promise<SavedSession>;
+    /** Under the bot's state lock, capture legacy rows before its workspace changes. */
+    pinWorkspace(cwd: string): Promise<void>;
     activate(context: SessionContext, id: string): Promise<SavedSession>;
     /** Replace only a confirmed native binding, preserving the user's stable topic. */
     rebindNative(context: SessionContext, id: string, expectedNativeId: string, newNativeId: string): Promise<SavedSession>;

package/dist/session-store.js

@@ -1,6 +1,6 @@
 import { randomBytes, randomUUID } from 'node:crypto';
 import { chmod, mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, isAbsolute } from 'node:path';
 /** Messages contain no titles, user identifiers, native session IDs, or filesystem details. */
 export class SessionStoreError extends Error {
     code;
@@ -80,11 +80,14 @@ function parseDocument(value) {
                     || session.updatedAt < session.createdAt)
                     throw new Error();
                 const title = titleText(session.title);
+                if (session.cwd !== undefined && (typeof session.cwd !== 'string' || !isAbsolute(session.cwd) || CONTROLS.test(session.cwd)))
+                    throw new Error();
                 if (title !== session.title || sessionIds.has(session.id) || nativeIds.has(session.nativeId.toLowerCase()))
                     throw new Error();
                 sessionIds.add(session.id);
                 nativeIds.add(session.nativeId.toLowerCase());
-                return { id: session.id, nativeId: session.nativeId, title, createdAt: session.createdAt, updatedAt: session.updatedAt };
+                return { id: session.id, nativeId: session.nativeId, title, createdAt: session.createdAt, updatedAt: session.updatedAt,
+                    ...(session.cwd === undefined ? {} : { cwd: session.cwd }) };
             });
             if (entry.activeId !== null && (typeof entry.activeId !== 'string' || !sessions.some(session => session.id === entry.activeId)))
                 throw new Error();
@@ -210,13 +213,15 @@ export class SessionStore {
         return (this.locate(this.document, identity)?.sessions ?? [])
             .map(session => ({ ...session })).sort((left, right) => right.updatedAt - left.updatedAt || left.id.localeCompare(right.id));
     }
-    add(context, nativeId, title = '新会话') {
+    add(context, nativeId, title = '新会话', cwd) {
         const identity = { ...context };
         return this.mutate(identity, draft => {
             if (identity.sessionId !== undefined)
                 throw new SessionStoreError('INVALID_INPUT');
             if (!NATIVE_ID.test(nativeId))
                 throw new SessionStoreError('INVALID_INPUT');
+            if (cwd !== undefined && (!isAbsolute(cwd) || CONTROLS.test(cwd)))
+                throw new SessionStoreError('INVALID_INPUT');
             const safeTitle = titleText(title);
             let entry = this.locate(draft, identity);
             const owned = draft.contexts.filter(candidate => candidate.ownerKey === identity.ownerKey);
@@ -231,7 +236,7 @@ export class SessionStore {
                 id = randomBytes(6).toString('hex');
             } while (usedIds.has(id));
             const time = this.nextTimestamp(draft);
-            const session = { id, nativeId, title: safeTitle, createdAt: time, updatedAt: time };
+            const session = { id, nativeId, title: safeTitle, createdAt: time, updatedAt: time, ...(cwd === undefined ? {} : { cwd }) };
             if (!entry) {
                 entry = { ownerKey: identity.ownerKey, conversationKey: identity.conversationKey, activeId: null, sessions: [] };
                 draft.contexts.push(entry);
@@ -241,6 +246,29 @@ export class SessionStore {
             return { value: session, changed: true };
         });
     }
+    /** Under the bot's state lock, capture legacy rows before its workspace changes. */
+    pinWorkspace(cwd) {
+        const job = this.tail.then(async () => {
+            this.assertAvailable();
+            if (!isAbsolute(cwd) || CONTROLS.test(cwd))
+                throw new SessionStoreError('INVALID_INPUT');
+            const draft = structuredClone(this.document);
+            let changed = false;
+            for (const context of draft.contexts)
+                for (const session of context.sessions) {
+                    if (session.cwd === undefined) {
+                        session.cwd = cwd;
+                        changed = true;
+                    }
+                }
+            if (changed) {
+                await this.persist(draft);
+                this.document = draft;
+            }
+        });
+        this.tail = job.catch(() => undefined);
+        return job;
+    }
     activate(context, id) {
         const identity = { ...context };
         return this.mutate(identity, draft => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lark-agent",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Reach your DeepSeek Harness assistant from Feishu / Lark: a dsh plugin built on the official Lark CLI",
   "keywords": [
     "deepseek",