@jingyi0605/codingns4dsh 0.1.0 → 0.1.2

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

@@ -1,5 +1,6 @@
-import { homedir } from 'node:os';
+import { homedir, hostname } from 'node:os';
 import { join } from 'node:path';
+import { DSH_VERSION } from '../shared/contracts/version.js';
 import { FileDshDeviceCredentialStore, } from './credential-store.js';
 import { ensureHostDtlsIdentity, FileHostDtlsIdentityStore, startHostRelayRuntime, } from './relay-tunnel-runtime.js';
 /**
@@ -15,20 +16,26 @@ export async function startDshHostDeviceRuntime(options) {
             throw new Error('DSH Host accessToken 已失效');
         return token;
     };
+    const withAccessToken = (operation) => options.withAccessToken === undefined ? operation(getAccessToken()) : options.withAccessToken(operation);
     const credentialStore = options.credentialStore ?? new FileDshDeviceCredentialStore(defaultDshCredentialPath());
     const dtlsStore = options.dtlsStore ?? new FileHostDtlsIdentityStore(defaultDtlsPath());
     const identity = await ensureHostDtlsIdentity(dtlsStore);
+    const dshVersion = options.dshVersion?.trim() || DSH_VERSION;
+    const computerName = options.computerName?.trim() || hostname().trim() || 'unknown';
+    const heartbeatDetails = { dshVersion, computerName };
     let credential = await credentialStore.read();
     let device;
     if (credential === null || credential.dtlsFingerprint !== identity.fingerprint) {
         const request = {
             displayName: options.displayName?.trim() || 'DSH Host',
+            dshVersion,
+            computerName,
             devicePublicKey: identity.certPem,
             dtlsFingerprint: identity.fingerprint,
             protocolVersion: options.protocolVersion ?? 'dsh-envelope-v1',
             capabilities: [...(options.capabilities ?? ['rpc', 'pty', 'file', 'web'])],
         };
-        const registered = await options.controlClient.registerDshDevice(getAccessToken(), request);
+        const registered = await withAccessToken((accessToken) => options.controlClient.registerDshDevice(accessToken, request));
         credential = {
             deviceId: registered.device.dshDeviceId ?? registered.device.deviceId ?? (() => { throw new Error('DSH 注册响应缺少设备标识'); })(),
             deviceCredential: registered.deviceCredential,
@@ -36,17 +43,21 @@ export async function startDshHostDeviceRuntime(options) {
             dtlsFingerprint: identity.fingerprint,
             tunnelDomain: registered.device.tunnelDomain ?? null,
             displayName: registered.device.displayName,
+            dshVersion: registered.device.dshVersion ?? dshVersion,
+            computerName: registered.device.computerName ?? computerName,
             savedAt: new Date().toISOString(),
         };
         await credentialStore.write(credential);
         device = registered.device;
     }
     else {
-        const listed = await options.controlClient.listDshDevices(getAccessToken());
+        const listed = await withAccessToken((accessToken) => options.controlClient.listDshDevices(accessToken));
         device = listed.devices.find((candidate) => (candidate.dshDeviceId ?? candidate.deviceId) === credential.deviceId) ?? {
             dshDeviceId: credential.deviceId,
             deviceId: credential.deviceId,
             displayName: credential.displayName,
+            dshVersion: credential.dshVersion ?? dshVersion,
+            computerName: credential.computerName ?? computerName,
             protocolVersion: options.protocolVersion ?? 'dsh-envelope-v1',
             capabilities: [...(options.capabilities ?? [])],
             dtlsFingerprint: credential.dtlsFingerprint,
@@ -61,10 +72,10 @@ export async function startDshHostDeviceRuntime(options) {
     if (credential === null)
         throw new Error('DSH 设备凭据初始化失败');
     const savedCredential = credential;
-    await options.controlClient.heartbeatDshDevice(getAccessToken(), savedCredential.deviceId, savedCredential.deviceCredential);
+    await withAccessToken((accessToken) => options.controlClient.heartbeatDshDevice(accessToken, savedCredential.deviceId, savedCredential.deviceCredential, heartbeatDetails));
     const runtimeOptions = {
         controlClient: { createSignalingTicket: async () => { throw new Error('DSH runtime 必须使用 DSH ticket'); } },
-        createTicket: ({ identity: material, credentialVersion }) => requestDshTicket(options.controlClient, getAccessToken(), savedCredential, material.fingerprint, credentialVersion),
+        createTicket: ({ identity: material, credentialVersion }) => requestDshTicket(withAccessToken, options.controlClient, savedCredential, material.fingerprint, credentialVersion),
         accessToken: options.accessToken,
         bindingId: savedCredential.deviceId,
         credentialVersion: savedCredential.credentialVersion,
@@ -83,7 +94,7 @@ export async function startDshHostDeviceRuntime(options) {
         if (stopped)
             return;
         void Promise.resolve()
-            .then(() => options.controlClient.heartbeatDshDevice(getAccessToken(), savedCredential.deviceId, savedCredential.deviceCredential))
+            .then(() => withAccessToken((accessToken) => options.controlClient.heartbeatDshDevice(accessToken, savedCredential.deviceId, savedCredential.deviceCredential, heartbeatDetails)))
             .catch(() => undefined);
     }, options.heartbeatIntervalMs ?? 30_000);
     const stop = async () => {
@@ -98,14 +109,14 @@ export async function startDshHostDeviceRuntime(options) {
     await options.onRuntime?.(runtime);
     return { credential: savedCredential, device, runtime, stop };
 }
-async function requestDshTicket(client, accessToken, credential, fingerprint, credentialVersion) {
-    const response = await client.createDshRelayTicket(accessToken, {
+async function requestDshTicket(withAccessToken, client, credential, fingerprint, credentialVersion) {
+    const response = await withAccessToken((accessToken) => client.createDshRelayTicket(accessToken, {
         dshDeviceId: credential.deviceId,
         deviceCredential: credential.deviceCredential,
         hostDtlsFingerprint: fingerprint,
         credentialVersion: credentialVersion ?? credential.credentialVersion,
         role: 'host',
-    });
+    }));
     return {
         ...response,
         bindingId: response.dshDeviceId,

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

@@ -29,7 +29,7 @@ export function createAuthFeature() {
     return {
         descriptor: {
             name: 'auth',
-            version: '0.1.0',
+            version: '0.1.1',
             enabledByDefault: true,
             dependencies: [],
             runtime: 'host',
@@ -89,6 +89,7 @@ export function createAuthFeature() {
                             accessToken,
                             credentialStore: dshCredentials,
                             accessTokenProvider: () => target.getAccessToken(),
+                            withAccessToken: (operation) => target.withAccessToken(operation),
                             ...(context.services.dshVersion === undefined ? {} : { dshVersion: context.services.dshVersion }),
                             resources: context.resources,
                             gatewayFeatures,
@@ -131,7 +132,10 @@ export function createAuthFeature() {
                 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/list': () => {
+                    const target = requireSession();
+                    return target.withAccessToken((accessToken) => target.getControlClient().listDshDevices(accessToken));
+                },
                 '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 },
@@ -148,8 +152,7 @@ export function createAuthFeature() {
                     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)
+                    if (!target.getAccessToken())
                         throw new CodingNsRpcError('CODINGNS_RPC_UNAUTHENTICATED', 'Codingns4DSH 尚未登录');
                     const request = {
                         dshDeviceId: dshRuntime.credential.deviceId,
@@ -158,7 +161,7 @@ export function createAuthFeature() {
                         credentialVersion: dshRuntime.credential.credentialVersion,
                         role: 'client',
                     };
-                    return target.getControlClient().createDshRelayTicket(accessToken, request);
+                    return target.withAccessToken((accessToken) => target.getControlClient().createDshRelayTicket(accessToken, request));
                 },
             };
             context.resources.add(context.services.rpc.register('auth', (action, payload) => {

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

@@ -4,7 +4,7 @@ export function createDebugFeature() {
     return {
         descriptor: {
             name: 'debug',
-            version: '0.1.0',
+            version: '0.1.1',
             enabledByDefault: true,
             dependencies: ['terminalProcess'],
             runtime: 'host',

package/data/build/dist/host/features/git-management.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import type { CodingNsHostServices } from './types.js';
+/** Host 侧 Git 工作区服务；所有路径都由 resolveWorkspaceRoot 权威解析。 */
+export declare function createGitManagementFeature(): FeatureModule<CodingNsHostServices>;
+//# sourceMappingURL=git-management.d.ts.map

package/data/build/dist/host/features/git-management.js

@@ -0,0 +1,290 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { promisify } from 'node:util';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { CodingNsRpcError } from '../rpc-table.js';
+const execFile = promisify(execFileCallback);
+const MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+const MAX_DIFF_BYTES = 60_000;
+/** Host 侧 Git 工作区服务；所有路径都由 resolveWorkspaceRoot 权威解析。 */
+export function createGitManagementFeature() {
+    return {
+        descriptor: {
+            name: 'gitManagement',
+            version: '0.1.0',
+            enabledByDefault: true,
+            dependencies: [],
+            runtime: 'host',
+        },
+        start(context) {
+            context.resources.add(context.services.rpc.register('git', async (action, payload) => {
+                const input = record(payload);
+                const workspaceId = requiredString(input.workspaceId, 'workspaceId');
+                const root = context.services.resolveWorkspaceRoot?.(workspaceId);
+                if (root === null || root === undefined)
+                    throw new CodingNsRpcError('GIT_WORKSPACE_UNAVAILABLE', '当前 Workspace 没有可用的本地目录');
+                switch (action) {
+                    case 'status': return readStatus(workspaceId, root);
+                    case 'init': return runGit(root, ['init']).then(() => readStatus(workspaceId, root));
+                    case 'diff': return readDiff(workspaceId, root, requiredString(input.path, 'path'), input.staged === true);
+                    case 'stage': return mutateTargets(workspaceId, root, input.targets, 'add');
+                    case 'unstage': return mutateTargets(workspaceId, root, input.targets, 'reset');
+                    case 'discard': return discardTargets(workspaceId, root, input.targets);
+                    case 'commit': return commit(workspaceId, root, requiredString(input.subject, 'subject'));
+                    case 'commit-diff': return readCommitDiff(root, requiredString(input.commitHash, 'commitHash'));
+                    case 'history': return readHistory(workspaceId, root, input.limit, input.offset);
+                    case 'branches': return readBranches(root);
+                    case 'switch': return switchBranch(root, requiredString(input.branchName, 'branchName'), input.create === true);
+                    case 'fetch': return syncRemote(workspaceId, root, ['fetch', '--all', '--prune']);
+                    case 'pull': return syncRemote(workspaceId, root, ['pull', '--ff-only']);
+                    case 'push': return syncRemote(workspaceId, root, ['push']);
+                    case 'undo': return undoLastCommit(workspaceId, root);
+                    default: throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', `未知 Git RPC: git/${action}`);
+                }
+            }));
+        },
+    };
+}
+async function readStatus(workspaceId, root) {
+    let result;
+    try {
+        result = await runGit(root, ['status', '--porcelain=v1', '-z', '--branch']);
+    }
+    catch (error) {
+        if (!isNotGitRepositoryError(error))
+            throw error;
+        return {
+            snapshot: { workspaceId, repoRoot: root, enabled: false, branch: 'HEAD', ahead: 0, behind: 0, hasRemote: false, isDirty: false, lastFetchedAt: null },
+            changes: [],
+        };
+    }
+    const tokens = result.stdout.split('\0');
+    const changes = [];
+    let branch = 'HEAD';
+    let ahead = 0;
+    let behind = 0;
+    let hasRemote = false;
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token)
+            continue;
+        if (token.startsWith('## ')) {
+            const tracking = parseBranchLine(token.slice(3));
+            branch = tracking.branch;
+            ahead = tracking.ahead;
+            behind = tracking.behind;
+            hasRemote = tracking.hasRemote;
+            continue;
+        }
+        if (token.length < 3)
+            continue;
+        const stagedStatus = token[0] === ' ' || token[0] === '?' || token[0] === '!' ? null : token[0] ?? null;
+        const worktreeStatus = token[1] === ' ' || token[1] === '?' || token[1] === '!' ? null : token[1] ?? null;
+        const status = `${token[0] ?? ' '}${token[1] ?? ' '}`.trim() || '?';
+        const path = normalizeGitPath(token.slice(3));
+        let oldPath = null;
+        if ((token[0] === 'R' || token[0] === 'C' || token[1] === 'R' || token[1] === 'C') && tokens[index + 1]) {
+            oldPath = normalizeGitPath(tokens[index + 1] ?? '');
+            index += 1;
+        }
+        changes.push({ path, status, staged: stagedStatus !== null, oldPath, binary: false, stagedStatus, worktreeStatus });
+    }
+    return {
+        snapshot: { workspaceId, repoRoot: root, enabled: true, branch, ahead, behind, hasRemote, isDirty: changes.length > 0, lastFetchedAt: null },
+        changes,
+    };
+}
+function parseBranchLine(value) {
+    const [rawBranch, rawTracking] = value.split('...');
+    const branch = (rawBranch ?? 'HEAD').replace(/^No commits yet on /u, '').trim() || 'HEAD';
+    const tracking = rawTracking ?? '';
+    const ahead = Number(/\[ahead (\d+)/u.exec(tracking)?.[1] ?? 0);
+    const behind = Number(/\[behind (\d+)/u.exec(tracking)?.[1] ?? 0);
+    return { branch, ahead, behind, hasRemote: rawTracking !== undefined };
+}
+async function readDiff(workspaceId, root, target, staged) {
+    const path = safeTarget(root, target);
+    try {
+        const result = await runGit(root, [...(staged ? ['diff', '--cached'] : ['diff']), '--binary', '--', path]);
+        const content = result.stdout.slice(0, MAX_DIFF_BYTES);
+        return { workspaceId, path: normalizeGitPath(target), staged, binary: /Binary files /u.test(result.stdout), truncated: result.stdout.length > content.length, content };
+    }
+    catch (error) {
+        if (error instanceof GitCommandError && error.stderr.includes('unknown revision'))
+            throw error;
+        return { workspaceId, path: normalizeGitPath(target), staged, binary: false, truncated: false, content: '' };
+    }
+}
+async function mutateTargets(workspaceId, root, rawTargets, action) {
+    const targets = safeTargets(root, rawTargets);
+    if (targets.length > 0)
+        await runGit(root, action === 'add' ? ['add', '--', ...targets] : ['reset', '--', ...targets]);
+    return readStatus(workspaceId, root);
+}
+async function discardTargets(workspaceId, root, rawTargets) {
+    const targets = safeTargets(root, rawTargets);
+    if (targets.length > 0) {
+        await runGit(root, ['restore', '--worktree', '--staged', '--', ...targets]).catch(() => undefined);
+        await runGit(root, ['clean', '-f', '--', ...targets]).catch(() => undefined);
+    }
+    return readStatus(workspaceId, root);
+}
+async function commit(workspaceId, root, subject) {
+    if (subject.length > 200)
+        throw new TypeError('subject 不能超过 200 个字符');
+    const result = await runGit(root, ['commit', '-m', subject]);
+    const hash = (await runGit(root, ['rev-parse', 'HEAD'])).stdout.trim();
+    return { commitHash: hash, summary: result.stdout.trim() || `已提交 ${hash.slice(0, 8)}`, status: await readStatus(workspaceId, root) };
+}
+async function readCommitDiff(root, rawCommitHash) {
+    const commitHash = rawCommitHash.trim();
+    if (!/^[0-9a-f]{7,40}$/iu.test(commitHash))
+        throw new TypeError('commitHash 无效');
+    const [result, filesResult] = await Promise.all([
+        runGit(root, ['-c', 'core.quotePath=false', 'show', '--format=', '--binary', '--no-ext-diff', '-M', commitHash, '--']),
+        runGit(root, ['-c', 'core.quotePath=false', 'show', '--format=', '--name-status', '-M', commitHash, '--']),
+    ]);
+    const content = result.stdout.slice(0, MAX_DIFF_BYTES);
+    return { commitHash, files: parseCommitChangedFiles(filesResult.stdout, result.stdout), content, truncated: result.stdout.length > content.length };
+}
+function parseCommitChangedFiles(value, diffContent) {
+    const binaryPaths = new Set();
+    for (const line of diffContent.split(/\r?\n/u)) {
+        const match = /^Binary files .* and .* differ$/u.exec(line);
+        if (match !== null) {
+            const paths = line.match(/(?:a|b)\/([^\s]+?)(?: differ)?$/u);
+            if (paths?.[1] !== undefined)
+                binaryPaths.add(paths[1]);
+        }
+    }
+    return value.split(/\r?\n/u).flatMap((line) => {
+        const fields = line.split('\t');
+        const statusToken = fields[0]?.trim() ?? '';
+        if (statusToken === '' || fields.length < 2)
+            return [];
+        const status = statusToken[0] ?? '?';
+        const renamed = status === 'R' || status === 'C';
+        const oldPath = renamed ? fields[1] ?? null : null;
+        const path = (renamed ? fields[2] : fields[1])?.trim() ?? '';
+        if (path === '')
+            return [];
+        return [{ path, oldPath, status, binary: binaryPaths.has(path) }];
+    });
+}
+async function syncRemote(workspaceId, root, args) {
+    await runGit(root, args);
+    return readStatus(workspaceId, root);
+}
+async function undoLastCommit(workspaceId, root) {
+    await runGit(root, ['rev-parse', '--verify', 'HEAD']);
+    await runGit(root, ['reset', '--soft', 'HEAD~1']);
+    return readStatus(workspaceId, root);
+}
+async function readHistory(_workspaceId, root, rawLimit, rawOffset) {
+    const limit = Math.max(1, Math.min(100, Number.isSafeInteger(rawLimit) ? Number(rawLimit) : 50));
+    const offset = Math.max(0, Math.min(1_000_000, Number.isSafeInteger(rawOffset) ? Number(rawOffset) : 0));
+    let result;
+    try {
+        result = await runGit(root, ['log', `--skip=${String(offset)}`, `--max-count=${String(limit)}`, '--format=%H%x1f%an%x1f%aI%x1f%s%x1f%b%x1e']);
+    }
+    catch (error) {
+        if (isEmptyRepositoryError(error))
+            return { items: [], cursor: String(offset), nextCursor: null, totalCount: 0 };
+        throw error;
+    }
+    const items = [];
+    for (const record of result.stdout.split('\x1e')) {
+        const fields = record.trim().split('\x1f');
+        if (fields.length < 5 || !fields[0])
+            continue;
+        items.push({ commitHash: fields[0], authorName: fields[1] ?? '', authoredAt: fields[2] ?? '', subject: fields[3] ?? '', body: fields[4] ?? '', refs: [] });
+    }
+    let total = 0;
+    try {
+        total = Number((await runGit(root, ['rev-list', '--count', 'HEAD'])).stdout.trim() || 0);
+    }
+    catch (error) {
+        if (!isEmptyRepositoryError(error))
+            throw error;
+    }
+    return { items, cursor: String(offset), nextCursor: offset + items.length < total ? String(offset + items.length) : null, totalCount: total };
+}
+async function readBranches(root) {
+    const currentBranch = (await runGit(root, ['branch', '--show-current'])).stdout.trim() || 'HEAD';
+    // for-each-ref 不展开 %xNN；使用 Git 原生支持的 NUL 字段分隔符，避免分支名被污染。
+    const result = await runGit(root, ['for-each-ref', '--format=%(refname)%00%(refname:short)%00%(HEAD)%00%(upstream:short)', 'refs/heads', 'refs/remotes']);
+    const local = [];
+    const remote = [];
+    const fields = result.stdout.replace(/\r?\n$/u, '').split('\0');
+    for (let index = 0; index + 3 < fields.length; index += 4) {
+        const fullName = fields[index] ?? '';
+        const name = fields[index + 1] ?? '';
+        const head = fields[index + 2] ?? '';
+        const upstream = fields[index + 3] ?? '';
+        if (!name)
+            continue;
+        const item = { name, current: head === '*', upstream: upstream || null, remote: fullName.startsWith('refs/remotes/') };
+        (item.remote ? remote : local).push(item);
+    }
+    return { currentBranch, local, remote };
+}
+async function switchBranch(root, branchName, create) {
+    if (!/^[A-Za-z0-9._/-]+$/u.test(branchName) || branchName.startsWith('-'))
+        throw new TypeError('branchName 无效');
+    await runGit(root, create ? ['switch', '-c', branchName] : ['switch', branchName]);
+    return readBranches(root);
+}
+async function runGit(cwd, args) {
+    try {
+        return await execFile('git', [...args], { cwd, encoding: 'utf8', maxBuffer: MAX_OUTPUT_BYTES, timeout: 30_000 });
+    }
+    catch (error) {
+        const detail = error;
+        throw new GitCommandError(`git ${args.join(' ')} 执行失败`, detail.stderr ?? detail.stdout ?? String(error), detail.code);
+    }
+}
+class GitCommandError extends Error {
+    stderr;
+    commandCode;
+    constructor(message, stderr, commandCode) {
+        super(message);
+        this.stderr = stderr;
+        this.commandCode = commandCode;
+    }
+}
+function safeTargets(root, value) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string'))
+        throw new TypeError('targets 必须是字符串数组');
+    return value.map((item) => safeTarget(root, item)).filter((item, index, list) => list.indexOf(item) === index);
+}
+function safeTarget(root, value) {
+    const target = normalizeGitPath(value);
+    if (!target || target.includes('\0') || isAbsolute(target) || target === '.' || target.split('/').includes('..'))
+        throw new TypeError('Git 路径无效');
+    const absolute = resolve(root, target);
+    const escaped = relative(root, absolute);
+    if (escaped.startsWith('..') || isAbsolute(escaped))
+        throw new TypeError('Git 路径超出 Workspace');
+    return target;
+}
+function normalizeGitPath(value) { return value.replaceAll('\\', '/').replace(/^\.\//u, '').trim(); }
+function isNotGitRepositoryError(error) {
+    if (!(error instanceof GitCommandError))
+        return false;
+    return error.commandCode === 128 && /not a git repository|not a git repository/u.test(error.stderr);
+}
+function isEmptyRepositoryError(error) {
+    if (!(error instanceof GitCommandError))
+        return false;
+    return error.commandCode === 128 && /does not have any commits yet|your current branch/u.test(error.stderr);
+}
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new TypeError('Git RPC 参数必须是对象');
+    return value;
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new TypeError(`${field} 必须是非空字符串`);
+    return value.trim();
+}
+//# sourceMappingURL=git-management.js.map

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

@@ -5,7 +5,7 @@ export function createHostStatusFeature() {
     return {
         descriptor: {
             name: 'hostStatus',
-            version: '0.1.0',
+            version: '0.1.1',
             enabledByDefault: true,
             dependencies: [],
             runtime: 'host',

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

@@ -15,5 +15,6 @@ 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 { createGitManagementFeature } from './git-management.js';
 export type { CodingNsHostServices } from './types.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -5,6 +5,7 @@ import { createCliAdaptersFeature } from '../cli-adapters/feature.js';
 import { createTerminalProcessFeature } from './terminal-process.js';
 import { createDebugFeature } from './debug.js';
 import { createHostStatusFeature } from './host-status.js';
+import { createGitManagementFeature } from './git-management.js';
 /** 生产启动可把实际 controller 模式注入状态模块，避免向设置页报告默认占位值。 */
 export function createHostFeatures(options = {}) {
     return [
@@ -15,6 +16,7 @@ export function createHostFeatures(options = {}) {
         createTerminalProcessFeature(),
         createDebugFeature(),
         createHostStatusFeature(),
+        createGitManagementFeature(),
     ];
 }
 /** Host 侧功能模块清单：新增模块在这里登记一行，不需要改动入口或 RPC 分发。 */
@@ -26,4 +28,5 @@ 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 { createGitManagementFeature } from './git-management.js';
 //# sourceMappingURL=index.js.map

package/data/build/dist/host/features/terminal-process.js

@@ -4,7 +4,7 @@ export function createTerminalProcessFeature() {
     return {
         descriptor: {
             name: 'terminalProcess',
-            version: '0.1.0',
+            version: '0.1.1',
             enabledByDefault: true,
             dependencies: [],
             runtime: 'host',

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

@@ -1,11 +1,13 @@
 import type { FeatureModule } from '../../shared/contracts/feature.js';
-import type { CodingNsTerminalStatus } from '../../shared/contracts/terminal.js';
+import type { CodingNsTerminalRuntimeType, CodingNsTerminalStatus } from '../../shared/contracts/terminal.js';
 import { type DetectedTerminalShell } from '../terminal/shell-detection.js';
 import type { CodingNsHostServices } from './types.js';
 export interface TerminalStatusFeatureOptions {
     readonly platform?: string;
     readonly controllerMode?: CodingNsTerminalStatus['controllerMode'];
     readonly effectiveEnabled?: boolean;
+    readonly runtimeTypes?: readonly CodingNsTerminalRuntimeType[];
+    readonly runtimeWarning?: string;
     readonly detectShells?: () => readonly DetectedTerminalShell[];
 }
 /**

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

@@ -14,7 +14,7 @@ export function createTerminalStatusFeature(options = {}) {
     return {
         descriptor: {
             name: 'terminalStatus',
-            version: '0.1.0',
+            version: '0.1.1',
             enabledByDefault: true,
             dependencies: [],
             runtime: 'host',
@@ -38,6 +38,8 @@ export function createTerminalStatusFeature(options = {}) {
                     platform: normalizePlatform(platform),
                     controllerMode,
                     effectiveEnabled,
+                    ...(options.runtimeTypes === undefined ? {} : { runtimeTypes: options.runtimeTypes }),
+                    ...(options.runtimeWarning === undefined ? {} : { runtimeWarning: options.runtimeWarning }),
                     profiles: available.map((shell) => ({
                         profileId: shell.profileId,
                         name: shell.displayName,

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

@@ -7,17 +7,21 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 export declare function apply(ctx?: Context): void;
-export { HOST_FEATURES, createAuthFeature, createLanAccessDshFeature, createTerminalStatusFeature, createHostFeatures, createCliAdaptersFeature, createTerminalProcessFeature, } from './features/index.js';
+export { HOST_FEATURES, createAuthFeature, createLanAccessDshFeature, createTerminalStatusFeature, createHostFeatures, createCliAdaptersFeature, createTerminalProcessFeature, createGitManagementFeature, } from './features/index.js';
 export type { CodingNsHostServices } from './features/index.js';
 export { CodingNsSettingsSchema, registerCodingNsSettings } from './settings.js';
 export { createCodingNsRpcHandler, createCodingNsSettingsRpcHandler, registerCodingNsRpc } from './rpc.js';
 export { DebugWorkspaceService, NodeDebugPortInspector, type DebugPortCheck, type DebugPortInspector, type DebugPortProcess, type DebugProxyBinding, } from './debug.js';
 export { CodingNsRpcError, CodingNsRpcTable, type CodingNsRpcHandler, type CodingNsRpcTarget, } from './rpc-table.js';
 export { CodingNsAuthSession } from './auth-session.js';
-export { createCodingNsNativeSessionBridge, type CodingNsNativeSessionBridge, type CodingNsNativeSessionController, type CodingNsNativeSessionStore, type CodingNsNativeWorkspaceController, type CodingNsNativeRequestContext, } from './native-session-bridge.js';
+export { createCodingNsNativeSessionBridge, type CodingNsNativeSessionBridge, type CodingNsNativeSessionController, type CodingNsNativeSessionStore, type CodingNsNativeWorkspaceController, type CodingNsNativeRequestContext, type CodingNsNativeUsageSample, } from './native-session-bridge.js';
+export { repairLegacySessionLog, repairLegacySessionLogs, type LegacySessionRepairOptions, type LegacySessionRepairReport, } from './session-migration-repair.js';
+export { defaultLegacySettingsPath, parseLegacyImportedSessionRecords, readLegacyImportedSessionRecords, } from './cli-adapters/legacy-session-settings.js';
 export { CommandCodeDriver } from './cli-adapters/command-code-driver.js';
 export { CommandCodeSubscriptionService, readCommandCodeApiKey } from './cli-adapters/command-code-subscription.js';
-export { ProviderSubscriptionService, CodexSubscriptionService, ClaudeCodeSubscriptionService, Sub2ApiUsageService, OpenCodeSubscriptionService, type Sub2ApiSource, type Sub2ApiUsageOptions, } from './cli-adapters/provider-subscription.js';
+export { ProviderSubscriptionService, CodexSubscriptionService, ClaudeCodeSubscriptionService, DeepseekSubscriptionService, Sub2ApiUsageService, OpenCodeSubscriptionService, type DeepseekSubscriptionOptions, type Sub2ApiSource, type Sub2ApiUsageOptions, } from './cli-adapters/provider-subscription.js';
+export { OfficialProviderSubscriptionService, type OfficialProviderSubscriptionOptions } from './cli-adapters/official-provider-subscription.js';
+export { MODEL_PROVIDER_DEFINITIONS, identifyModelProvider, normalizeProviderBaseUrl, normalizeProviderName, thirdPartyProvider, type ProviderDefinition, type ProviderIdentity, type ProviderSubscriptionCapability, type ProviderSubscriptionReader, } from './cli-adapters/provider-registry.js';
 export { ClaudeCodeDriver } from './cli-adapters/claude-driver.js';
 export { KimiCliDriver } from './cli-adapters/kimi-driver.js';
 export { GeminiCliDriver } from './cli-adapters/gemini-driver.js';