@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/host/dsh-gateway-feature.js

@@ -0,0 +1,55 @@
+/** 将 Host 已登记的 RPC 命名空间接到 DSH Gateway。 */
+export function createDshRpcGatewayFeature(rpc) {
+    return {
+        channel: 'rpc',
+        operation: 'rpc.request',
+        handleStream: async (context) => {
+            try {
+                const request = readJson(context);
+                if (!isRecord(request) || typeof request.method !== 'string' || request.method.trim() === '') {
+                    throw new DshGatewayRequestError('MESSAGE_INVALID', 'DSH RPC 请求缺少 method');
+                }
+                const target = rpc.resolve(request.method);
+                if (target === null)
+                    throw new DshGatewayRequestError('FEATURE_DISABLED', 'DSH RPC 未启用');
+                const value = await target.handler(target.action, request.payload);
+                context.send('rpc.response', { encoding: 'json' }, encodeJson(value));
+            }
+            catch (error) {
+                // 业务异常可能包含命令行、路径或凭据片段，跨隧道只返回稳定的短描述。
+                const detail = error instanceof DshGatewayRequestError ? error.message : 'DSH RPC 执行失败';
+                const errorCode = error instanceof DshGatewayRequestError ? error.code : 'DSH_RPC_FAILED';
+                context.send('stream.error', { errorCode, detail, retryable: false });
+            }
+            finally {
+                context.close();
+            }
+        },
+    };
+}
+function readJson(context) {
+    const body = context.envelope.body;
+    if (body === undefined || context.envelope.meta.encoding !== 'json')
+        return undefined;
+    try {
+        return JSON.parse(new TextDecoder().decode(body));
+    }
+    catch {
+        throw new DshGatewayRequestError('MESSAGE_INVALID', 'DSH RPC 请求正文不是有效 JSON');
+    }
+}
+function encodeJson(value) {
+    return new TextEncoder().encode(JSON.stringify(value === undefined ? null : value));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+class DshGatewayRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = code;
+    }
+}
+//# sourceMappingURL=dsh-gateway-feature.js.map

package/data/build/dist/host/dsh-runtime-version.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 读取当前 DSH 进程真正加载的 @deepseek-ai/dsh 版本。
+ *
+ * DSH 0.1.6 尚未把启动器版本作为 Cordis 服务暴露给插件，因此不能从
+ * 插件自身的 DSH_VERSION 常量推断宿主版本。优先沿当前 dsh 可执行入口
+ * 向上查找 @deepseek-ai/dsh/package.json，只有开发环境无法提供入口时才
+ * 回退到 PATH 中的 `dsh --version`。
+ */
+export declare function detectRuntimeDshVersion(): string;
+/** Host 启动后供 Web Client 复用的版本注入名称。 */
+export declare const DSH_VERSION_INJECTION_NAME: "__CODINGNS_DSH_VERSION__";
+//# sourceMappingURL=dsh-runtime-version.d.ts.map

package/data/build/dist/host/dsh-runtime-version.js

@@ -0,0 +1,69 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { assertSupportedDshVersion, CODINGNS_DSH_VERSION_GLOBAL, CODINGNS_DSH_ERROR_CODES, CodingNsDshError, } from '../shared/index.js';
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u;
+/**
+ * 读取当前 DSH 进程真正加载的 @deepseek-ai/dsh 版本。
+ *
+ * DSH 0.1.6 尚未把启动器版本作为 Cordis 服务暴露给插件，因此不能从
+ * 插件自身的 DSH_VERSION 常量推断宿主版本。优先沿当前 dsh 可执行入口
+ * 向上查找 @deepseek-ai/dsh/package.json，只有开发环境无法提供入口时才
+ * 回退到 PATH 中的 `dsh --version`。
+ */
+export function detectRuntimeDshVersion() {
+    const candidates = [
+        process.env.DSH_RUNTIME_VERSION,
+        process.env.DSH_VERSION,
+        readDshPackageVersion(process.argv[1]),
+        readDshPackageVersion(fileURLToPath(import.meta.url)),
+        readDshVersionFromCommand(),
+    ];
+    const version = candidates.find((candidate) => candidate !== undefined && VERSION_PATTERN.test(candidate));
+    if (version === undefined) {
+        throw new CodingNsDshError(CODINGNS_DSH_ERROR_CODES.DSH_VERSION_UNSUPPORTED, '无法读取当前 DSH 版本；为避免 API 不兼容，已拒绝启用 codingns4dsh');
+    }
+    assertSupportedDshVersion(version);
+    return version;
+}
+/** Host 启动后供 Web Client 复用的版本注入名称。 */
+export const DSH_VERSION_INJECTION_NAME = CODINGNS_DSH_VERSION_GLOBAL;
+function readDshPackageVersion(entryPath) {
+    if (entryPath === undefined || entryPath.trim() === '')
+        return undefined;
+    let current = dirname(entryPath);
+    for (let depth = 0; depth < 10; depth += 1) {
+        const manifestPath = join(current, 'package.json');
+        try {
+            const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            if (manifest.name === '@deepseek-ai/dsh' && typeof manifest.version === 'string')
+                return manifest.version;
+        }
+        catch {
+            // 当前目录不是 DSH 包时继续向上查找；读取失败不应掩盖后续探测路径。
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+function readDshVersionFromCommand() {
+    try {
+        const result = spawnSync(process.platform === 'win32' ? 'dsh.cmd' : 'dsh', ['--version'], {
+            encoding: 'utf8',
+            timeout: 2_000,
+            windowsHide: true,
+        });
+        if (result.status !== 0)
+            return undefined;
+        const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
+        return output.match(VERSION_PATTERN)?.[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=dsh-runtime-version.js.map

package/data/build/dist/host/features/auth.d.ts

@@ -0,0 +1,11 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import type { CodingNsHostServices } from './types.js';
+/**
+ * 认证模块：登录、凭据、设备查询和 Host 绑定。
+ *
+ * 它是唯一持有 CodingNsAuthSession 和凭据存储的地方，并以 `auth/*` 命名空间
+ * 暴露 RPC。refresh token 只存在于这里，所有响应都不包含它。模块没有界面：
+ * 这些设置由「中转访问服务」卡片承载。
+ */
+export declare function createAuthFeature(): FeatureModule<CodingNsHostServices>;
+//# sourceMappingURL=auth.d.ts.map

package/data/build/dist/host/features/auth.js

@@ -0,0 +1,273 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { CodingNsAuthSession } from '../auth-session.js';
+import { HttpCodingNsControlApiClient } from '../control-api-client.js';
+import { FileCodingNsCredentialStore, FileDshDeviceCredentialStore } from '../credential-store.js';
+import { startDshHostDeviceRuntime } from '../dsh-device-runtime.js';
+import { CodingNsRpcError } from '../rpc-table.js';
+import { createDshRpcGatewayFeature } from '../dsh-gateway-feature.js';
+import { createLocalDshWebRuntimeProvider, createRemoteWebRuntimeFeature } from '../remote-web-runtime.js';
+import { DSH_VERSION } from '../../shared/contracts/version.js';
+import { FileLanAccessDshLoginStore, verifyLoginProtectionSession } from '../lan-access-dsh.js';
+/** 未登录时的稳定快照；Client 首次读取 `auth/snapshot` 会拿到它。 */
+const LOGGED_OUT_SNAPSHOT = {
+    status: 'logged_out',
+    account: null,
+    currentDevice: null,
+    binding: null,
+    expiresAt: null,
+    errorCode: null,
+};
+/**
+ * 认证模块：登录、凭据、设备查询和 Host 绑定。
+ *
+ * 它是唯一持有 CodingNsAuthSession 和凭据存储的地方，并以 `auth/*` 命名空间
+ * 暴露 RPC。refresh token 只存在于这里，所有响应都不包含它。模块没有界面：
+ * 这些设置由「中转访问服务」卡片承载。
+ */
+export function createAuthFeature() {
+    return {
+        descriptor: {
+            name: 'auth',
+            version: '0.1.0',
+            enabledByDefault: true,
+            dependencies: [],
+            runtime: 'host',
+        },
+        start(context) {
+            const stateDirectory = process.env.CODINGNS4DSH_STATE_DIR?.trim() || join(homedir(), '.config', 'codingns4dsh');
+            const credentials = new FileCodingNsCredentialStore(join(stateDirectory, 'codingns-credentials.json'));
+            const dshCredentials = new FileDshDeviceCredentialStore(join(stateDirectory, 'device-credential.json'));
+            const loginProtectionStore = new FileLanAccessDshLoginStore(join(stateDirectory, 'lan-access-login.json'));
+            let session = null;
+            let sessionBaseUrl = null;
+            let dshRuntime = null;
+            let dshStartPromise = null;
+            let keepAliveTimer;
+            let keepAlivePromise = null;
+            let disposed = false;
+            const ensureSession = async (controlBaseUrl) => {
+                if (session && sessionBaseUrl === controlBaseUrl)
+                    return session;
+                if (session)
+                    await session.logout();
+                session = new CodingNsAuthSession(new HttpCodingNsControlApiClient({ controlBaseUrl }), credentials, controlBaseUrl);
+                sessionBaseUrl = controlBaseUrl;
+                return session;
+            };
+            const requireSession = () => {
+                if (!session)
+                    throw new CodingNsRpcError('CODINGNS_RPC_UNAUTHENTICATED', 'Codingns4DSH 尚未登录');
+                return session;
+            };
+            const startDsh = async (target) => {
+                if (disposed || context.resources.disposed)
+                    return;
+                if (dshRuntime !== null)
+                    return;
+                if (dshStartPromise !== null)
+                    return dshStartPromise;
+                const accessToken = target.getAccessToken();
+                if (!accessToken)
+                    return;
+                dshStartPromise = (async () => {
+                    try {
+                        const gatewayFeatures = [createDshRpcGatewayFeature(context.services.rpc)];
+                        if (context.services.dshWebPort !== undefined) {
+                            gatewayFeatures.push(createRemoteWebRuntimeFeature({
+                                provider: createLocalDshWebRuntimeProvider({
+                                    port: context.services.dshWebPort,
+                                    dshVersion: context.services.dshVersion ?? DSH_VERSION,
+                                    ...(context.services.dshWebAuthenticatedUrl === undefined ? {} : { authenticatedUrl: context.services.dshWebAuthenticatedUrl }),
+                                }),
+                            }));
+                        }
+                        if (disposed || context.resources.disposed)
+                            return;
+                        const runtime = await startDshHostDeviceRuntime({
+                            controlClient: target.getControlClient(),
+                            accessToken,
+                            credentialStore: dshCredentials,
+                            accessTokenProvider: () => target.getAccessToken(),
+                            ...(context.services.dshVersion === undefined ? {} : { dshVersion: context.services.dshVersion }),
+                            resources: context.resources,
+                            gatewayFeatures,
+                        });
+                        if (disposed || context.resources.disposed) {
+                            await runtime.stop();
+                            return;
+                        }
+                        dshRuntime = runtime;
+                    }
+                    catch (error) {
+                        // DSH 设备服务不可用时不应破坏已有 Codingns4DSH 登录；下次登录/显式 start 会重试。
+                        console.error('codingns4dsh: DSH Host runtime 启动失败', error);
+                    }
+                    finally {
+                        dshStartPromise = null;
+                    }
+                })();
+                return dshStartPromise;
+            };
+            const actions = {
+                snapshot: () => session?.snapshot() ?? LOGGED_OUT_SNAPSHOT,
+                login: async (payload) => {
+                    const input = parseLogin(payload);
+                    const target = await ensureSession(input.controlBaseUrl);
+                    await target.login({ email: input.email, password: input.password });
+                    await startDsh(target);
+                    return target.snapshot();
+                },
+                logout: async () => {
+                    // DSH 设备注册凭据独立保存在 device-credential.json；注销中继站
+                    // 登录只停止当前运行时并清理 Codingns4DSH refresh token，不得清除设备注册。
+                    await dshRuntime?.stop();
+                    dshRuntime = null;
+                    if (session)
+                        await session.logout();
+                    return { status: 'logged_out' };
+                },
+                devices: () => requireSession().getDevices(),
+                bind: (payload) => requireSession().bindHost(parseHostBind(payload)),
+                unbind: (payload) => requireSession().unbindHost(parseStringField(payload, 'bindingId')),
+                signalingTicket: (payload) => requireSession().createClientSignalingTicket(parseOptionalStringField(payload, 'tunnelDomain')),
+                'dsh/device/list': () => requireSession().getControlClient().listDshDevices(requireSession().getAccessToken() ?? ''),
+                'dsh/device/start': async () => { await startDsh(requireSession()); return dshRuntime?.device ?? null; },
+                'dsh/device/stop': async () => { await dshRuntime?.stop(); dshRuntime = null; return { stopped: true }; },
+                'dsh/device/status': () => dshRuntime ? { device: dshRuntime.device, online: true } : { device: null, online: false },
+                'dsh/relayTicket': async (payload) => {
+                    const loginProtectionToken = isRecord(payload) && typeof payload.loginProtectionToken === 'string' ? payload.loginProtectionToken : undefined;
+                    if (!await verifyLoginProtectionSession(loginProtectionStore, loginProtectionToken, 'relay')) {
+                        throw new CodingNsRpcError('CODINGNS_RPC_UNAUTHENTICATED', '需要先完成登录保护验证');
+                    }
+                    const target = requireSession();
+                    if (!dshRuntime)
+                        await startDsh(target);
+                    if (!dshRuntime)
+                        throw new CodingNsRpcError('DSH_DEVICE_OFFLINE', 'DSH Host 尚未上线');
+                    const input = isRecord(payload) && typeof payload.dshDeviceId === 'string' ? payload.dshDeviceId.trim() : '';
+                    if (!input || input !== dshRuntime.credential.deviceId)
+                        throw new CodingNsRpcError('DSH_DEVICE_NOT_FOUND', '请求的 DSH 设备不是当前 Host');
+                    const accessToken = target.getAccessToken();
+                    if (!accessToken)
+                        throw new CodingNsRpcError('CODINGNS_RPC_UNAUTHENTICATED', 'Codingns4DSH 尚未登录');
+                    const request = {
+                        dshDeviceId: dshRuntime.credential.deviceId,
+                        deviceCredential: dshRuntime.credential.deviceCredential,
+                        hostDtlsFingerprint: dshRuntime.runtime.identity.fingerprint,
+                        credentialVersion: dshRuntime.credential.credentialVersion,
+                        role: 'client',
+                    };
+                    return target.getControlClient().createDshRelayTicket(accessToken, request);
+                },
+            };
+            context.resources.add(context.services.rpc.register('auth', (action, payload) => {
+                const handler = actions[action];
+                if (handler === undefined) {
+                    throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', `未知 Codingns4DSH RPC: auth/${action}`);
+                }
+                return handler(payload);
+            }));
+            // 设备心跳维持在线状态；认证 token 临近过期时提前续期，运行时通过
+            // accessTokenProvider 自动使用新 token，不需要重建隧道。
+            const keepAlive = async () => {
+                if (disposed || keepAlivePromise !== null || session === null)
+                    return;
+                const target = session;
+                if (target.getAccessToken() === null)
+                    return;
+                keepAlivePromise = (async () => {
+                    const expiresAt = Date.parse(target.snapshot().expiresAt ?? '');
+                    if (!Number.isFinite(expiresAt) || expiresAt - Date.now() <= 120_000) {
+                        try {
+                            await target.refresh();
+                        }
+                        catch (error) {
+                            console.error('codingns4dsh: 后台刷新 Codingns4DSH 会话失败', error);
+                        }
+                    }
+                    if (dshRuntime === null)
+                        await startDsh(target);
+                })().finally(() => { keepAlivePromise = null; });
+                await keepAlivePromise;
+            };
+            keepAliveTimer = setInterval(() => { void keepAlive(); }, 30_000);
+            context.resources.add(() => {
+                if (keepAliveTimer !== undefined)
+                    clearInterval(keepAliveTimer);
+                keepAliveTimer = undefined;
+            });
+            // Host 重启后优先恢复 refresh token，并尝试把已注册的 DSH 设备重新上线。
+            void (async () => {
+                try {
+                    const saved = await credentials.read();
+                    if (!saved)
+                        return;
+                    const target = await ensureSession(saved.controlBaseUrl);
+                    await target.restore();
+                    await startDsh(target);
+                }
+                catch (error) {
+                    console.error('codingns4dsh: 恢复 DSH Host 会话失败', error);
+                }
+            })();
+            context.resources.add(async () => {
+                disposed = true;
+                await dshRuntime?.stop();
+                dshRuntime = null;
+                await session?.logout();
+                session = null;
+                sessionBaseUrl = null;
+            });
+        },
+    };
+}
+function parseLogin(value) {
+    if (!isRecord(value))
+        throw new TypeError('登录参数必须是对象');
+    return {
+        controlBaseUrl: requireUrl(value.controlBaseUrl),
+        email: requireString(value.email, 'email'),
+        password: requireString(value.password, 'password'),
+    };
+}
+function parseHostBind(value) {
+    if (!isRecord(value))
+        throw new TypeError('Host 绑定参数必须是对象');
+    return {
+        hostLabel: requireString(value.hostLabel, 'hostLabel'),
+        hostPublicKey: requireString(value.hostPublicKey, 'hostPublicKey'),
+        hostFingerprint: requireString(value.hostFingerprint, 'hostFingerprint'),
+    };
+}
+function parseStringField(value, field) {
+    if (!isRecord(value))
+        throw new TypeError(`${field} 参数必须是对象`);
+    return requireString(value[field], field);
+}
+function parseOptionalStringField(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isRecord(value))
+        throw new TypeError(`${field} 参数必须是对象`);
+    const raw = value[field];
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    return requireString(raw, field);
+}
+function requireString(value, field) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new TypeError(`${field} 不能为空`);
+    return value.trim();
+}
+function requireUrl(value) {
+    const raw = requireString(value, 'controlBaseUrl');
+    const parsed = new URL(raw);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        throw new TypeError('controlBaseUrl 必须使用 HTTP(S)');
+    return parsed.toString().replace(/\/$/u, '');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=auth.js.map

package/data/build/dist/host/features/debug.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import type { CodingNsHostServices } from './types.js';
+/** Spec003 Host 模块：配置、PTY、端口检查和插件内部代理。 */
+export declare function createDebugFeature(): FeatureModule<CodingNsHostServices>;
+//# sourceMappingURL=debug.d.ts.map

package/data/build/dist/host/features/debug.js

@@ -0,0 +1,90 @@
+import { CodingNsRpcError } from '../rpc-table.js';
+/** Spec003 Host 模块：配置、PTY、端口检查和插件内部代理。 */
+export function createDebugFeature() {
+    return {
+        descriptor: {
+            name: 'debug',
+            version: '0.1.0',
+            enabledByDefault: true,
+            dependencies: ['terminalProcess'],
+            runtime: 'host',
+        },
+        start(context) {
+            const service = context.services.debug;
+            if (service === undefined)
+                throw new CodingNsRpcError('CODINGNS_DEBUG_UNAVAILABLE', 'Spec003 调试服务未装配');
+            context.resources.add(context.services.rpc.register('debug', async (action, payload) => {
+                const input = objectFields(payload);
+                const workspaceId = requiredString(input.workspaceId, 'workspaceId');
+                requiredString(input.sessionId, 'sessionId');
+                generation(input.generation);
+                switch (action) {
+                    case 'config/get':
+                        return service.getConfig(workspaceId);
+                    case 'config/save':
+                        return service.saveConfig(workspaceId, input.config);
+                    case 'config/update':
+                        return service.updateProfile(workspaceId, requiredString(input.profileId, 'profileId'), input.profile);
+                    case 'config/delete':
+                        return service.deleteProfile(workspaceId, requiredString(input.profileId, 'profileId'));
+                    case 'profile/list':
+                        return (await service.getConfig(workspaceId)).profiles;
+                    case 'profile/launch':
+                        return service.launch({ workspaceId, profileId: requiredString(input.profileId, 'profileId'), ...(input.dshSessionId === undefined ? {} : { dshSessionId: requiredString(input.dshSessionId, 'dshSessionId') }), cols: integer(input.cols, 'cols'), rows: integer(input.rows, 'rows') });
+                    case 'runtime/get':
+                        return scopedInstance(service.getInstance(requiredString(input.instanceId, 'instanceId')), workspaceId);
+                    case 'runtime/list':
+                        return service.listInstances(workspaceId);
+                    case 'runtime/stop':
+                        scopedInstance(service.getInstance(requiredString(input.instanceId, 'instanceId')), workspaceId);
+                        return service.stop(requiredString(input.instanceId, 'instanceId'));
+                    case 'port/check':
+                        return service.checkPort(workspaceId, requiredString(input.profileId, 'profileId'));
+                    case 'port/terminate':
+                        return service.terminatePort(workspaceId, requiredString(input.checkId, 'checkId'));
+                    case 'port/kill':
+                        return service.killPortProcess(workspaceId, requiredString(input.checkId, 'checkId'));
+                    case 'proxy/get':
+                        return service.getProxy(requiredString(input.bindingId, 'bindingId'));
+                    case 'proxy/enable':
+                        return service.enableProxy(workspaceId, requiredString(input.profileId, 'profileId'), requiredString(input.instanceId, 'instanceId'));
+                    case 'proxy/disable':
+                        return service.disableProxy(workspaceId, requiredString(input.bindingId, 'bindingId'));
+                    default:
+                        throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', `未知 Spec003 RPC: debug/${action}`);
+                }
+            }));
+            const registerProxyRoute = context.services.registerDebugProxyRoute;
+            if (registerProxyRoute !== undefined)
+                context.resources.add(registerProxyRoute((request) => service.handleProxyRequest(request)));
+        },
+    };
+}
+function objectFields(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new TypeError('Spec003 RPC 参数必须是对象');
+    return value;
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new TypeError(`${field} 必须是非空字符串`);
+    return value.trim();
+}
+function integer(value, field) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0)
+        throw new TypeError(`${field} 必须是正整数`);
+    return value;
+}
+function generation(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        throw new TypeError('generation 必须是非负整数');
+    return value;
+}
+function scopedInstance(instance, workspaceId) {
+    if (instance === undefined)
+        return null;
+    if (instance.workspaceId !== workspaceId)
+        throw new Error('运行实例不属于当前 Workspace');
+    return instance;
+}
+//# sourceMappingURL=debug.js.map

package/data/build/dist/host/features/host-status.d.ts

@@ -0,0 +1,12 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import type { CodingNsHostServices } from './types.js';
+/** 暴露 Host 资源采样；状态保留在模块内，不写入设置和磁盘。 */
+export declare function createHostStatusFeature(): FeatureModule<CodingNsHostServices>;
+interface CpuSample {
+    idle: number;
+    total: number;
+}
+declare function readCpuSample(): CpuSample;
+declare function cpuUsage(previous: CpuSample, current: CpuSample): number;
+export { cpuUsage, readCpuSample };
+//# sourceMappingURL=host-status.d.ts.map

package/data/build/dist/host/features/host-status.js

@@ -0,0 +1,54 @@
+import { cpus, freemem, totalmem } from 'node:os';
+/** 暴露 Host 资源采样；状态保留在模块内，不写入设置和磁盘。 */
+export function createHostStatusFeature() {
+    let previous;
+    return {
+        descriptor: {
+            name: 'hostStatus',
+            version: '0.1.0',
+            enabledByDefault: true,
+            dependencies: [],
+            runtime: 'host',
+        },
+        start(context) {
+            context.resources.add(context.services.rpc.register('host', async (action) => {
+                if (action !== 'status')
+                    throw new Error(`未知 Host RPC: host/${action}`);
+                const current = readCpuSample();
+                const cpuPercent = previous === undefined ? 0 : cpuUsage(previous, current);
+                previous = current;
+                const memoryTotalBytes = totalmem();
+                const memoryUsedBytes = Math.max(0, memoryTotalBytes - freemem());
+                const value = {
+                    cpuPercent,
+                    memoryPercent: memoryTotalBytes > 0 ? (memoryUsedBytes / memoryTotalBytes) * 100 : 0,
+                    memoryUsedBytes,
+                    memoryTotalBytes,
+                    sampledAt: Date.now(),
+                };
+                return value;
+            }));
+        },
+    };
+}
+function readCpuSample() {
+    let idle = 0;
+    let total = 0;
+    for (const cpu of cpus()) {
+        idle += cpu.times.idle;
+        total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+    }
+    return { idle, total };
+}
+function cpuUsage(previous, current) {
+    const idleDelta = Math.max(0, current.idle - previous.idle);
+    const totalDelta = Math.max(0, current.total - previous.total);
+    if (totalDelta === 0)
+        return 0;
+    return clamp((1 - idleDelta / totalDelta) * 100);
+}
+function clamp(value) {
+    return Math.min(100, Math.max(0, Number.isFinite(value) ? value : 0));
+}
+export { cpuUsage, readCpuSample };
+//# sourceMappingURL=host-status.js.map

package/data/build/dist/host/features/index.d.ts

@@ -0,0 +1,19 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import { createTerminalStatusFeature } from './terminal-status.js';
+import type { CodingNsHostServices } from './types.js';
+export interface HostFeatureOptions {
+    readonly terminalStatus?: Parameters<typeof createTerminalStatusFeature>[0];
+}
+/** 生产启动可把实际 controller 模式注入状态模块，避免向设置页报告默认占位值。 */
+export declare function createHostFeatures(options?: HostFeatureOptions): readonly FeatureModule<CodingNsHostServices>[];
+/** Host 侧功能模块清单：新增模块在这里登记一行，不需要改动入口或 RPC 分发。 */
+export declare const HOST_FEATURES: readonly FeatureModule<CodingNsHostServices>[];
+export { createAuthFeature } from './auth.js';
+export { createLanAccessDshFeature } from './lan-access-dsh.js';
+export { createTerminalStatusFeature } from './terminal-status.js';
+export { createCliAdaptersFeature } from '../cli-adapters/feature.js';
+export { createTerminalProcessFeature } from './terminal-process.js';
+export { createDebugFeature } from './debug.js';
+export { createHostStatusFeature } from './host-status.js';
+export type { CodingNsHostServices } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/data/build/dist/host/features/index.js

@@ -0,0 +1,29 @@
+import { createAuthFeature } from './auth.js';
+import { createLanAccessDshFeature } from './lan-access-dsh.js';
+import { createTerminalStatusFeature } from './terminal-status.js';
+import { createCliAdaptersFeature } from '../cli-adapters/feature.js';
+import { createTerminalProcessFeature } from './terminal-process.js';
+import { createDebugFeature } from './debug.js';
+import { createHostStatusFeature } from './host-status.js';
+/** 生产启动可把实际 controller 模式注入状态模块，避免向设置页报告默认占位值。 */
+export function createHostFeatures(options = {}) {
+    return [
+        createAuthFeature(),
+        createLanAccessDshFeature(),
+        createTerminalStatusFeature(options.terminalStatus),
+        createCliAdaptersFeature(),
+        createTerminalProcessFeature(),
+        createDebugFeature(),
+        createHostStatusFeature(),
+    ];
+}
+/** Host 侧功能模块清单：新增模块在这里登记一行，不需要改动入口或 RPC 分发。 */
+export const HOST_FEATURES = createHostFeatures();
+export { createAuthFeature } from './auth.js';
+export { createLanAccessDshFeature } from './lan-access-dsh.js';
+export { createTerminalStatusFeature } from './terminal-status.js';
+export { createCliAdaptersFeature } from '../cli-adapters/feature.js';
+export { createTerminalProcessFeature } from './terminal-process.js';
+export { createDebugFeature } from './debug.js';
+export { createHostStatusFeature } from './host-status.js';
+//# sourceMappingURL=index.js.map

package/data/build/dist/host/features/lan-access-dsh.d.ts

@@ -0,0 +1,8 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import { type LanAccessDshRuntime } from '../lan-access-dsh.js';
+import type { CodingNsHostServices } from './types.js';
+/** Host 侧“局域网访问 DSH”模块，只管理一条 DSH Web 监听映射。 */
+export declare function createLanAccessDshFeature(options?: {
+    runtime?: LanAccessDshRuntime;
+}): FeatureModule<CodingNsHostServices>;
+//# sourceMappingURL=lan-access-dsh.d.ts.map