@jingyi0605/codingns4dsh 0.1.2 → 0.1.7-rc.3

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

@@ -0,0 +1,267 @@
+import { copyFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
+import { CodingNsRpcError } from '../rpc-table.js';
+import { readSessionChangedFiles } from '../session-changes.js';
+const MAX_EDIT_BYTES = 4 * 1024 * 1024;
+/** 文件管理增强的 Host 边界；所有路径先解析到已知工作区，再执行文件操作。 */
+export function createFileManagementFeature() {
+    return {
+        descriptor: {
+            name: 'fileManagement',
+            version: '0.1.0',
+            enabledByDefault: false,
+            dependencies: [],
+            runtime: 'host',
+        },
+        start(context) {
+            context.resources.add(context.services.rpc.register('fileManagement', async (action, payload) => {
+                const input = record(payload);
+                switch (action) {
+                    case 'session-changes': {
+                        const sessionId = requiredString(input.sessionId, 'sessionId');
+                        const workspaceId = typeof input.workspaceId === 'string' ? input.workspaceId.trim() : '';
+                        const root = workspaceId !== ''
+                            ? context.services.resolveWorkspaceRoot?.(workspaceId) ?? findSessionRoot(context.services, sessionId)
+                            : findSessionRoot(context.services, sessionId);
+                        if (root === null || root === undefined || root.trim() === '') {
+                            throw new CodingNsRpcError('FILE_MANAGEMENT_WORKSPACE_UNAVAILABLE', '当前会话没有可用的工作区目录');
+                        }
+                        return readSessionChangedFiles(context.services, sessionId, root);
+                    }
+                    case 'read': {
+                        const target = resolveTarget(context.services, input);
+                        const info = await stat(target.absolute);
+                        if (!info.isFile())
+                            throw new CodingNsRpcError('FILE_MANAGEMENT_NOT_FILE', '目标不是普通文件');
+                        if (typeof info.size === 'number' && info.size > MAX_EDIT_BYTES)
+                            throw new CodingNsRpcError('FILE_MANAGEMENT_TOO_LARGE', '文件超过可编辑大小限制');
+                        return { path: target.absolute, content: await readFile(target.absolute, 'utf8') };
+                    }
+                    case 'download': {
+                        const target = resolveTarget(context.services, input);
+                        const info = await stat(target.absolute);
+                        if (!info.isFile())
+                            throw new CodingNsRpcError('FILE_MANAGEMENT_NOT_FILE', '目标不是普通文件');
+                        const content = await readFile(target.absolute);
+                        return {
+                            path: target.absolute,
+                            fileName: basename(target.absolute),
+                            mimeType: mimeTypeForPath(target.absolute),
+                            contentBase64: Buffer.from(content).toString('base64'),
+                        };
+                    }
+                    case 'write': {
+                        const target = resolveTarget(context.services, input);
+                        const content = requiredString(input.content, 'content', false);
+                        if (Buffer.byteLength(content, 'utf8') > MAX_EDIT_BYTES)
+                            throw new CodingNsRpcError('FILE_MANAGEMENT_TOO_LARGE', '文件超过可编辑大小限制');
+                        const info = await stat(target.absolute);
+                        if (!info.isFile())
+                            throw new CodingNsRpcError('FILE_MANAGEMENT_NOT_FILE', '目标不是普通文件');
+                        await atomicWrite(target.absolute, content);
+                        return { path: target.absolute };
+                    }
+                    case 'create-file': {
+                        const target = resolveTarget(context.services, input);
+                        await mkdir(dirname(target.absolute), { recursive: true });
+                        await writeFile(target.absolute, '', { encoding: 'utf8', flag: 'wx' });
+                        return { path: target.absolute };
+                    }
+                    case 'create-directory': {
+                        const target = resolveTarget(context.services, input);
+                        await mkdir(target.absolute, { recursive: false });
+                        return { path: target.absolute };
+                    }
+                    case 'rename': {
+                        const source = resolveTarget(context.services, input);
+                        const destination = resolveTarget(context.services, { ...input, path: input.destination });
+                        await mkdir(dirname(destination.absolute), { recursive: true });
+                        await rename(source.absolute, destination.absolute);
+                        return { from: source.absolute, path: destination.absolute };
+                    }
+                    case 'copy':
+                        return copyTargets(context.services, input);
+                    case 'move':
+                        return moveTargets(context.services, input);
+                    case 'delete': {
+                        const paths = requiredStringArray(input.paths, 'paths');
+                        for (const path of paths) {
+                            const target = resolveTarget(context.services, { ...input, path });
+                            await rm(target.absolute, { recursive: true, force: false });
+                        }
+                        return { paths };
+                    }
+                    case 'git-ignore':
+                        return addGitIgnore(context.services, input);
+                    default:
+                        throw new CodingNsRpcError('CODINGNS_RPC_NOT_FOUND', `未知文件管理 RPC: fileManagement/${action}`);
+                }
+            }));
+        },
+    };
+}
+async function copyTargets(services, input) {
+    const paths = requiredStringArray(input.paths, 'paths');
+    const destination = resolveTarget(services, { ...input, path: input.destination });
+    const destinationInfo = await stat(destination.absolute);
+    if (!destinationInfo.isDirectory())
+        throw new CodingNsRpcError('FILE_MANAGEMENT_NOT_DIRECTORY', '粘贴目标不是目录');
+    for (const path of paths) {
+        const source = resolveTarget(services, { ...input, path });
+        await copyEntry(source.absolute, join(destination.absolute, basename(source.absolute)));
+    }
+    return { paths };
+}
+async function moveTargets(services, input) {
+    const paths = requiredStringArray(input.paths, 'paths');
+    const destination = resolveTarget(services, { ...input, path: input.destination });
+    const destinationInfo = await stat(destination.absolute);
+    if (!destinationInfo.isDirectory())
+        throw new CodingNsRpcError('FILE_MANAGEMENT_NOT_DIRECTORY', '粘贴目标不是目录');
+    for (const path of paths) {
+        const source = resolveTarget(services, { ...input, path });
+        await rename(source.absolute, join(destination.absolute, basename(source.absolute)));
+    }
+    return { paths };
+}
+async function copyEntry(source, destination) {
+    const info = await stat(source);
+    if (info.isDirectory()) {
+        await mkdir(destination, { recursive: false });
+        for (const entry of await readdir(source, { withFileTypes: true })) {
+            await copyEntry(join(source, entry.name), join(destination, entry.name));
+        }
+        return;
+    }
+    await copyFile(source, destination);
+}
+async function addGitIgnore(services, input) {
+    const paths = requiredStringArray(input.paths, 'paths');
+    const resolved = paths.map((path) => resolveTarget(services, { ...input, path }));
+    const roots = new Set(resolved.map((item) => item.root));
+    if (roots.size !== 1)
+        throw new CodingNsRpcError('FILE_MANAGEMENT_MULTIPLE_ROOTS', '一次只能处理同一个工作区中的文件');
+    const root = resolved[0]?.root;
+    if (root === undefined)
+        throw new TypeError('paths 不能为空');
+    const ignorePath = join(root, '.gitignore');
+    let current = '';
+    try {
+        current = await readFile(ignorePath, 'utf8');
+    }
+    catch { /* .gitignore 不存在时从空文件开始。 */ }
+    const lines = current.split(/\r?\n/u).filter((line) => line.trim() !== '');
+    for (const item of resolved) {
+        const path = relative(root, item.absolute).replaceAll('\\', '/');
+        const info = await stat(item.absolute);
+        const pattern = info.isDirectory() ? `${path}/` : path;
+        if (!lines.includes(pattern))
+            lines.push(pattern);
+    }
+    await atomicWrite(ignorePath, lines.length === 0 ? '' : `${lines.join('\n')}\n`);
+    return { paths };
+}
+function resolveTarget(services, input) {
+    const rawPath = requiredString(input.path, 'path');
+    const sessionId = typeof input.sessionId === 'string' ? input.sessionId.trim() : '';
+    const sessionRoot = sessionId === '' ? undefined : findSessionRoot(services, sessionId);
+    const absolute = isAbsolute(rawPath)
+        ? normalize(rawPath)
+        : sessionRoot === undefined ? resolve(rawPath) : normalize(join(sessionRoot, rawPath));
+    const roots = [...new Set([...(services.listWorkspaceRoots?.() ?? []), ...(sessionRoot === undefined ? [] : [sessionRoot])])]
+        .map((root) => normalize(root))
+        .filter((root) => root !== '')
+        .sort((left, right) => right.length - left.length);
+    const root = roots.find((candidate) => isInside(candidate, absolute));
+    if (root === undefined)
+        throw new CodingNsRpcError('FILE_MANAGEMENT_OUTSIDE_WORKSPACE', '路径不在已知工作区内');
+    return { absolute, root };
+}
+function findSessionRoot(services, sessionId) {
+    const session = services.nativeSessions?.get(sessionId);
+    return findCwd(session, 0);
+}
+function findCwd(value, depth) {
+    if (depth > 5 || value === null || typeof value !== 'object')
+        return undefined;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findCwd(item, depth + 1);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    const record = value;
+    for (const key of ['cwd', 'workingDirectory']) {
+        if (typeof record[key] === 'string' && record[key].trim() !== '')
+            return record[key].trim();
+    }
+    for (const key of ['header', 'request', 'context', 'data', 'meta', 'session']) {
+        const found = findCwd(record[key], depth + 1);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function isInside(root, target) {
+    const escaped = relative(root, target);
+    return escaped === '' || (!escaped.startsWith('..') && !isAbsolute(escaped));
+}
+async function atomicWrite(path, content) {
+    const temporary = `${path}.codingns-tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    let mode = 0o600;
+    try {
+        const current = await stat(path);
+        mode = current.mode === undefined ? mode : current.mode & 0o777;
+    }
+    catch {
+        // 新建 .gitignore 时使用受限默认权限。
+    }
+    await writeFile(temporary, content, { encoding: 'utf8', mode });
+    try {
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function requiredString(value, field, trim = true) {
+    if (typeof value !== 'string' || (trim && value.trim() === ''))
+        throw new TypeError(`${field} 必须是非空字符串`);
+    return trim ? value.trim() : value;
+}
+function requiredStringArray(value, field) {
+    if (!Array.isArray(value) || value.length === 0 || value.some((item) => typeof item !== 'string' || item.trim() === ''))
+        throw new TypeError(`${field} 必须是非空字符串数组`);
+    return value.map((item) => item.trim());
+}
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new TypeError('文件管理 RPC 参数必须是对象');
+    return value;
+}
+function mimeTypeForPath(path) {
+    const extension = path.toLowerCase().match(/\.([a-z0-9]+)$/u)?.[1] ?? '';
+    return {
+        css: 'text/css',
+        csv: 'text/csv',
+        gif: 'image/gif',
+        html: 'text/html',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        js: 'text/javascript',
+        json: 'application/json',
+        md: 'text/markdown',
+        pdf: 'application/pdf',
+        png: 'image/png',
+        svg: 'image/svg+xml',
+        txt: 'text/plain',
+        xml: 'application/xml',
+        yaml: 'application/yaml',
+        yml: 'application/yaml',
+        zip: 'application/zip',
+    }[extension] ?? 'application/octet-stream';
+}
+//# sourceMappingURL=file-management.js.map

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

@@ -105,6 +105,17 @@ async function readDiff(workspaceId, root, target, staged) {
     const path = safeTarget(root, target);
     try {
         const result = await runGit(root, [...(staged ? ['diff', '--cached'] : ['diff']), '--binary', '--', path]);
+        if (!staged && result.stdout === '' && await isUntracked(root, path)) {
+            try {
+                await runGit(root, ['diff', '--no-index', '--binary', '--', process.platform === 'win32' ? 'NUL' : '/dev/null', path]);
+            }
+            catch (error) {
+                if (error instanceof GitCommandError && error.stdout !== '') {
+                    const content = error.stdout.slice(0, MAX_DIFF_BYTES);
+                    return { workspaceId, path: normalizeGitPath(target), staged, binary: /Binary files /u.test(error.stdout), truncated: error.stdout.length > content.length, content };
+                }
+            }
+        }
         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 };
     }
@@ -114,6 +125,15 @@ async function readDiff(workspaceId, root, target, staged) {
         return { workspaceId, path: normalizeGitPath(target), staged, binary: false, truncated: false, content: '' };
     }
 }
+async function isUntracked(root, path) {
+    try {
+        await runGit(root, ['ls-files', '--error-unmatch', '--', path]);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
 async function mutateTargets(workspaceId, root, rawTargets, action) {
     const targets = safeTargets(root, rawTargets);
     if (targets.length > 0)
@@ -239,16 +259,18 @@ async function runGit(cwd, args) {
     }
     catch (error) {
         const detail = error;
-        throw new GitCommandError(`git ${args.join(' ')} 执行失败`, detail.stderr ?? detail.stdout ?? String(error), detail.code);
+        throw new GitCommandError(`git ${args.join(' ')} 执行失败`, detail.stderr ?? detail.stdout ?? String(error), detail.code, detail.stdout ?? '');
     }
 }
 class GitCommandError extends Error {
     stderr;
     commandCode;
-    constructor(message, stderr, commandCode) {
+    stdout;
+    constructor(message, stderr, commandCode, stdout = '') {
         super(message);
         this.stderr = stderr;
         this.commandCode = commandCode;
+        this.stdout = stdout;
     }
 }
 function safeTargets(root, value) {

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

@@ -16,5 +16,7 @@ export { createTerminalProcessFeature } from './terminal-process.js';
 export { createDebugFeature } from './debug.js';
 export { createHostStatusFeature } from './host-status.js';
 export { createGitManagementFeature } from './git-management.js';
+export { createFileManagementFeature } from './file-management.js';
+export { createPeerHostFeature, toPeerHostClientRecord } from './peer-host.js';
 export type { CodingNsHostServices } from './types.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -6,6 +6,8 @@ import { createTerminalProcessFeature } from './terminal-process.js';
 import { createDebugFeature } from './debug.js';
 import { createHostStatusFeature } from './host-status.js';
 import { createGitManagementFeature } from './git-management.js';
+import { createFileManagementFeature } from './file-management.js';
+import { createPeerHostFeature } from './peer-host.js';
 /** 生产启动可把实际 controller 模式注入状态模块，避免向设置页报告默认占位值。 */
 export function createHostFeatures(options = {}) {
     return [
@@ -17,6 +19,8 @@ export function createHostFeatures(options = {}) {
         createDebugFeature(),
         createHostStatusFeature(),
         createGitManagementFeature(),
+        createFileManagementFeature(),
+        createPeerHostFeature(),
     ];
 }
 /** Host 侧功能模块清单：新增模块在这里登记一行，不需要改动入口或 RPC 分发。 */
@@ -29,4 +33,6 @@ export { createTerminalProcessFeature } from './terminal-process.js';
 export { createDebugFeature } from './debug.js';
 export { createHostStatusFeature } from './host-status.js';
 export { createGitManagementFeature } from './git-management.js';
+export { createFileManagementFeature } from './file-management.js';
+export { createPeerHostFeature, toPeerHostClientRecord } from './peer-host.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,22 @@
+import type { FeatureModule } from '../../shared/contracts/feature.js';
+import type { CodingNsHostServices } from './types.js';
+import type { PeerHostRecord, PeerHostClientRecord } from '../../shared/contracts/peer-host.js';
+import type { AggregateHostSource } from '../modules/peer-host/peer-host-aggregate-service.js';
+import { type PeerHostRemoteConnector } from '../modules/peer-host/host-ws-proxy-service.js';
+import { type PeerHostRelayTransportFactory } from '../modules/peer-host/peer-host-relay.js';
+export interface PeerHostFeatureOptions {
+    readonly stateDirectory?: string;
+    readonly ownerUserId?: string;
+    readonly encryptionKey?: Uint8Array;
+    readonly fetchImpl?: typeof fetch;
+    /** 测试或已验证的 Host-to-Host WebSocket connector；未注入时保持不可用。 */
+    readonly connectRemote?: PeerHostRemoteConnector;
+    /** 仅允许复用已验证的 Host 侧 Relay Transport；缺省时中转保持不可用。 */
+    readonly relayTransport?: PeerHostRelayTransportFactory;
+    /** 当前 Host/已验证 PeerHost 的摘要源；未注入时必须保持明确降级。 */
+    readonly aggregateSources?: () => Promise<readonly AggregateHostSource[]>;
+}
+/** PeerHost Host 模块；配置、握手和目标登录态只在 Host 进程内装配。 */
+export declare function createPeerHostFeature(options?: PeerHostFeatureOptions): FeatureModule<CodingNsHostServices>;
+export declare function toPeerHostClientRecord(record: PeerHostRecord): PeerHostClientRecord;
+//# sourceMappingURL=peer-host.d.ts.map