@jingyi0605/codingns4dsh 0.1.7-rc.3 → 0.2.0-beta.1

package/data/build/dist/features/registry.d.ts

@@ -66,6 +66,13 @@ export declare class FeatureRegistry<S = unknown, M extends FeatureModule<S> = F
      */
     reconcile(enabledNames: readonly string[]): Promise<void>;
     private reconcileInternal;
+    /**
+     * 执行单个模块的启停，并把失败留给调用方汇总。
+     *
+     * 模块失败（例如必需能力缺失）只影响它自己：同一轮同步里其余模块照常启停，
+     * 失败原因通过模块状态和 trace 暴露，最后只把第一个错误抛给宿主记录。
+     */
+    private step;
     drain(name: string): Promise<void>;
     dispose(name: string): Promise<void>;
     disable(name: string): Promise<void>;

package/data/build/dist/features/registry.js

@@ -169,13 +169,31 @@ export class FeatureRegistry {
             desired: [...desired],
             states: this.list().map((item) => ({ name: item.name, state: item.state, reason: item.reason })),
         });
+        const failures = [];
         for (const name of this.records.keys()) {
             if (desired.has(name))
-                await this.start(name);
+                await this.step(name, () => this.start(name), failures);
         }
         for (const name of this.records.keys()) {
             if (!desired.has(name))
-                await this.disable(name);
+                await this.step(name, () => this.disable(name), failures);
+        }
+        if (failures.length > 0)
+            throw failures[0];
+    }
+    /**
+     * 执行单个模块的启停，并把失败留给调用方汇总。
+     *
+     * 模块失败（例如必需能力缺失）只影响它自己：同一轮同步里其余模块照常启停，
+     * 失败原因通过模块状态和 trace 暴露，最后只把第一个错误抛给宿主记录。
+     */
+    async step(name, operation, failures) {
+        try {
+            await operation();
+        }
+        catch (error) {
+            failures.push(error);
+            traceFeature('reconcile.failed', { feature: name, error: serializeError(error) });
         }
     }
     async drain(name) {

package/data/build/dist/host/cli-adapters/feature.js

@@ -11,6 +11,7 @@ import { CodingNsCliSessionStore } from './session-store.js';
 import { CodingNsDshMessageProjector } from './dsh-message-projector.js';
 import { CommandCodeSubscriptionService } from './command-code-subscription.js';
 import { ProviderSubscriptionService } from './provider-subscription.js';
+import { normalizeSubscriptionUsageSettings } from '../../shared/contracts/config.js';
 export function createCliAdaptersFeature(options = {}) {
     return {
         descriptor: {
@@ -21,8 +22,13 @@ export function createCliAdaptersFeature(options = {}) {
             runtime: 'host',
         },
         start(context) {
-            const commandCodeSubscription = new CommandCodeSubscriptionService();
-            const subscriptions = new ProviderSubscriptionService({ commandCode: commandCodeSubscription });
+            // 用量查询超时对所有适配器统一生效：同一个 timeoutMs 下发给全部网络读取器，
+            // 设置变更时整体重建，避免旧超时继续生效。
+            const buildSubscriptions = (settings) => {
+                const timeoutMs = normalizeSubscriptionUsageSettings(settings?.subscriptionUsage).timeoutSecs * 1000;
+                return new ProviderSubscriptionService({ commandCode: new CommandCodeSubscriptionService({ timeoutMs }), timeoutMs });
+            };
+            let subscriptions = buildSubscriptions(context.services.settings?.get());
             const sessionStore = new CodingNsCliSessionStore(context.services.settings === undefined ? {} : { settings: context.services.settings });
             const nativeSessions = context.services.nativeSessions;
             if (nativeSessions !== undefined) {
@@ -89,6 +95,16 @@ export function createCliAdaptersFeature(options = {}) {
                     case 'session/steer': return registry.steer(readSessionId(payload), readPrompt(payload), false);
                     case 'session/follow-up': return registry.steer(readSessionId(payload), readPrompt(payload), true);
                     case 'session/interrupt': return registry.interrupt(readSessionId(payload));
+                    case 'team/status': return context.services.nativeTeam?.diagnostic() ?? registry.teamDiagnostic();
+                    case 'team/members': return requireTeam(context).invoke('members', payload);
+                    case 'team/tasks': return requireTeam(context).invoke('tasks', payload);
+                    case 'team/task': return requireTeam(context).invoke('task', payload);
+                    case 'team/spawn': return requireTeam(context).invoke('spawn', payload);
+                    case 'team/message': return requireTeam(context).invoke('message', payload);
+                    case 'team/task/create': return requireTeam(context).invoke('task/create', payload);
+                    case 'team/task/update': return requireTeam(context).invoke('task/update', payload);
+                    case 'team/wait': return requireTeam(context).invoke('wait', payload);
+                    case 'team/interrupt': return requireTeam(context).invoke('interrupt', payload);
                     case 'subscription': {
                         const subscription = readSubscriptionRequest(payload);
                         return subscriptions.read(subscription.adapterId, subscription.providerId);
@@ -102,6 +118,7 @@ export function createCliAdaptersFeature(options = {}) {
                     registry.applyEnabledSettings(next.agentAdapters);
                     registry.syncPreferences(next.agentAdapterPreferences);
                     sessionStore.sync(next.cliSessions);
+                    subscriptions = buildSubscriptions(next);
                 }));
             }
             const events = context.services.events;
@@ -217,6 +234,11 @@ export function createCliAdaptersFeature(options = {}) {
         },
     };
 }
+function requireTeam(context) {
+    if (context.services.nativeTeam === undefined)
+        throw new Error('DSH_TEAM_NATIVE_UNAVAILABLE');
+    return context.services.nativeTeam;
+}
 /**
  * DSH 原生 Provider 可能只返回一个 finish(stop)。不能把这个空回合当作成功，
  * 否则 Session 会落下一条空 assistant/message，用户只能看到“一秒结束”。

package/data/build/dist/host/cli-adapters/native-team-proxy.d.ts

@@ -0,0 +1,36 @@
+import type { CodingNsCliTeamDiagnostic } from '../../shared/contracts/cli-adapter.js';
+/** DSH 0.2 原生 Agent Team 的最小结构契约。 */
+export interface CodingNsNativeTeamProxy {
+    diagnostic(): CodingNsCliTeamDiagnostic;
+    invoke(action: string, payload: unknown, signal?: AbortSignal): unknown | Promise<unknown>;
+}
+export interface NativeTeamService {
+    membership?: (agent: unknown) => unknown;
+    listMembers?: (agent: unknown) => unknown;
+    listTasks?: (agent: unknown) => unknown;
+    getTask?: (agent: unknown, id: unknown) => unknown;
+    spawnTeammate?: (agent: unknown, request: Record<string, unknown>) => unknown;
+    sendMessage?: (agent: unknown, request: Record<string, unknown>) => unknown;
+    createTask?: (agent: unknown, request: Record<string, unknown>) => unknown;
+    updateTask?: (agent: unknown, request: Record<string, unknown>) => unknown;
+    waitForChange?: (agent: unknown, timeoutMs: number, signal: AbortSignal) => unknown;
+    interrupt?: (agent: unknown, targetName: string) => unknown;
+}
+export interface AgentRegistry {
+    get?: (id: string) => unknown;
+    list?: () => readonly unknown[];
+}
+/**
+ * 只负责 DSH 原生 TeamService 的调用边界，不把版本判断泄漏到业务模块。
+ * 外部 CLI 没有 Agent 句柄，因此不会经过这个代理伪装成 Team 成员。
+ */
+export declare class DshNativeTeamProxy implements CodingNsNativeTeamProxy {
+    private readonly service;
+    private readonly agents;
+    constructor(service: NativeTeamService | undefined, agents: AgentRegistry | undefined);
+    diagnostic(): CodingNsCliTeamDiagnostic;
+    invoke(action: string, payload: unknown, signal?: AbortSignal): unknown | Promise<unknown>;
+    private findAgent;
+    private findAnyAgent;
+}
+//# sourceMappingURL=native-team-proxy.d.ts.map

package/data/build/dist/host/cli-adapters/native-team-proxy.js

@@ -0,0 +1,108 @@
+/**
+ * 只负责 DSH 原生 TeamService 的调用边界，不把版本判断泄漏到业务模块。
+ * 外部 CLI 没有 Agent 句柄，因此不会经过这个代理伪装成 Team 成员。
+ */
+export class DshNativeTeamProxy {
+    service;
+    agents;
+    constructor(service, agents) {
+        this.service = service;
+        this.agents = agents;
+    }
+    diagnostic() {
+        const supported = this.service !== undefined
+            && typeof this.service.listMembers === 'function'
+            && typeof this.service.spawnTeammate === 'function'
+            && this.findAnyAgent() !== undefined;
+        return supported
+            ? {
+                supported: true,
+                code: 'DSH_TEAM_PROXY_READY',
+                message: 'DSH 0.2 原生 Agent Team 已通过 Codingns4DSH Proxy 暴露。',
+            }
+            : {
+                supported: false,
+                code: 'DSH_TEAM_NATIVE_UNAVAILABLE',
+                message: '当前 DSH 未注入可用的原生 Agent Team 或 Agent 注册表。',
+            };
+    }
+    invoke(action, payload, signal = new AbortController().signal) {
+        const service = this.service;
+        if (service === undefined)
+            throw new Error('DSH_TEAM_NATIVE_UNAVAILABLE');
+        const input = asRecord(payload);
+        const agent = this.findAgent(readString(input, 'sessionId'));
+        if (agent === undefined)
+            throw new Error('DSH_TEAM_AGENT_NOT_FOUND');
+        switch (action) {
+            case 'status':
+                return {
+                    ...this.diagnostic(),
+                    membership: call(service.membership, agent),
+                    members: call(service.listMembers, agent),
+                };
+            case 'members': return requiredCall(service.listMembers, agent);
+            case 'tasks': return requiredCall(service.listTasks, agent);
+            case 'task': return requiredCall(service.getTask, agent, readRequired(input, 'taskId'));
+            case 'spawn': return requiredCall(service.spawnTeammate, agent, withSignal(input, signal));
+            case 'message': return requiredCall(service.sendMessage, agent, withSignal(input, signal));
+            case 'task/create': return requiredCall(service.createTask, agent, input);
+            case 'task/update': return requiredCall(service.updateTask, agent, input);
+            case 'wait': return requiredCall(service.waitForChange, agent, readNumber(input, 'timeoutMs', 30_000), signal);
+            case 'interrupt': return requiredCall(service.interrupt, agent, readRequired(input, 'targetName'));
+            default: throw new Error(`DSH_TEAM_RPC_NOT_FOUND: team/${action}`);
+        }
+    }
+    findAgent(sessionId) {
+        if (this.agents === undefined)
+            return undefined;
+        if (sessionId !== '' && typeof this.agents.get === 'function') {
+            const direct = this.agents.get(sessionId);
+            if (direct !== undefined)
+                return direct;
+        }
+        for (const candidate of this.agents.list?.() ?? []) {
+            const session = readUnknown(candidate, 'session');
+            if (readUnknown(session, 'id') === sessionId || readUnknown(candidate, 'id') === sessionId)
+                return candidate;
+        }
+        return undefined;
+    }
+    findAnyAgent() {
+        return this.agents?.list?.()[0];
+    }
+}
+function call(fn, ...args) {
+    return typeof fn === 'function' ? fn(...args) : undefined;
+}
+function requiredCall(fn, ...args) {
+    if (typeof fn !== 'function')
+        throw new Error('DSH_TEAM_OPERATION_UNAVAILABLE');
+    return fn(...args);
+}
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return {};
+    return { ...value };
+}
+function readUnknown(value, key) {
+    return typeof value === 'object' && value !== null ? Reflect.get(value, key) : undefined;
+}
+function readString(value, key) {
+    const result = value[key];
+    return typeof result === 'string' ? result.trim() : '';
+}
+function readRequired(value, key) {
+    const result = readString(value, key);
+    if (result === '')
+        throw new Error(`DSH_TEAM_INVALID_${key.toUpperCase()}`);
+    return result;
+}
+function readNumber(value, key, fallback) {
+    const result = value[key];
+    return typeof result === 'number' && Number.isSafeInteger(result) && result >= 0 ? result : fallback;
+}
+function withSignal(value, signal) {
+    return { ...value, signal };
+}
+//# sourceMappingURL=native-team-proxy.js.map

package/data/build/dist/host/cli-adapters/provider-subscription.d.ts

@@ -11,6 +11,8 @@ export declare class ProviderSubscriptionService {
     readonly sub2api: Sub2ApiUsageService;
     readonly deepseek: DeepseekSubscriptionService;
     readonly official: OfficialProviderSubscriptionService;
+    readonly kimi: KimiSubscriptionService;
+    readonly grok: GrokSubscriptionService;
     constructor(options?: ProviderSubscriptionOptions);
     read(adapterId: string, providerId?: string): Promise<CliSubscriptionUsage | null>;
     private readDsh;
@@ -24,6 +26,10 @@ export interface ProviderSubscriptionOptions {
     readonly sub2api?: Sub2ApiUsageOptions;
     readonly deepseek?: DeepseekSubscriptionOptions;
     readonly official?: OfficialProviderSubscriptionOptions;
+    readonly kimi?: KimiSubscriptionOptions;
+    readonly grok?: GrokSubscriptionOptions;
+    /** 所有读取器共用的网络超时（毫秒）；单项服务显式给出时优先。 */
+    readonly timeoutMs?: number;
 }
 export interface SubscriptionReader {
     read(): Promise<CliSubscriptionUsage | null>;
@@ -100,5 +106,34 @@ export declare class OpenCodeSubscriptionService implements SubscriptionReader {
     constructor(options?: OpenCodeSubscriptionOptions);
     read(): Promise<CliSubscriptionUsage | null>;
 }
+export interface KimiSubscriptionOptions {
+    readonly fetch?: FetchLike;
+    readonly timeoutMs?: number;
+    readonly credentials?: readonly string[];
+}
+/** 读取 Kimi Code 官方套餐额度；本地 OAuth 凭据只在 Host 内使用，不做刷新只读访问令牌。 */
+export declare class KimiSubscriptionService implements SubscriptionReader {
+    private readonly request;
+    private readonly timeoutMs;
+    private readonly credentialPaths;
+    constructor(options?: KimiSubscriptionOptions);
+    read(): Promise<CliSubscriptionUsage | null>;
+    private readAccessToken;
+    private readUsage;
+}
+export interface GrokSubscriptionOptions {
+    readonly fetch?: FetchLike;
+    readonly timeoutMs?: number;
+    readonly credentials?: readonly string[];
+}
+/** 读取 Grok（xAI）官方 SuperGrok 订阅额度；只读 Grok CLI 的 OAuth 凭据（~/.grok/auth.json），不做刷新，过期令牌也照常尝试以容忍时钟偏差。 */
+export declare class GrokSubscriptionService implements SubscriptionReader {
+    private readonly request;
+    private readonly timeoutMs;
+    private readonly credentialPaths;
+    constructor(options?: GrokSubscriptionOptions);
+    read(): Promise<CliSubscriptionUsage | null>;
+    private readAccessToken;
+}
 export {};
 //# sourceMappingURL=provider-subscription.d.ts.map