@serveryyswys/opm 0.0.0-stage → 0.1.0

package/dist/lib/build.js

@@ -0,0 +1,319 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProject = buildProject;
+/**
+ * opm build：把 Operit 插件工程打成 .toolpkg。
+ *
+ * 流程（与 node.operit 的契约配套）：
+ *   1. 读 manifest.json，取可达种子（main + subpackages[].entry）；
+ *   2. 顺 require 链递归收集被引用文件；
+ *   3. 裸名重写（内建 → node.operit 子路径；npm 包 → 包入口；lodash/uuid/axios 原样）；
+ *   4. 契约拦截：planned / unsupported 直接构建失败，不把问题带到运行期；
+ *   5. 入口注入 process / Buffer 全局（沙盒没有这两个全局）；
+ *   6. 压成 zip，产物放项目根的上一级，名为 <项目目录名>.toolpkg。
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const zip_1 = require("./zip");
+const contract_1 = require("./contract");
+const rewrite_1 = require("./rewrite");
+const typescript_1 = require("./typescript");
+const dependencies_1 = require("./dependencies");
+function toPosix(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+function readManifest(projectDir, errors) {
+    const manifestPath = (0, node_path_1.join)(projectDir, 'manifest.json');
+    if (!(0, node_fs_1.existsSync)(manifestPath)) {
+        errors.push('找不到 ' + manifestPath + '：.toolpkg 必须有 manifest.json（至少要声明 main）');
+        return null;
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        errors.push('manifest.json 不是合法 JSON：' + String(error));
+        return null;
+    }
+}
+/** 可达种子：main 与所有子包入口。 */
+function collectSeeds(manifest, errors) {
+    const seeds = [];
+    if (typeof manifest.main === 'string' && manifest.main.length > 0) {
+        seeds.push(toPosix(manifest.main));
+    }
+    else {
+        errors.push('manifest.json 缺少 main（字符串），没有入口就无从计算可达性');
+    }
+    if (Array.isArray(manifest.subpackages)) {
+        for (const item of manifest.subpackages) {
+            if (item === null || typeof item !== 'object')
+                continue;
+            const entry = item.entry;
+            if (typeof entry === 'string' && entry.length > 0) {
+                seeds.push(toPosix(entry));
+            }
+        }
+    }
+    return seeds;
+}
+function buildProject(options) {
+    const projectDir = (0, node_path_1.resolve)(options.projectDir);
+    const errors = [];
+    const notes = [];
+    const diagnostics = [];
+    const manifest = readManifest(projectDir, errors);
+    if (manifest === null) {
+        return { ok: false, toolpkgPath: '', fileCount: 0, files: [], totalBytes: 0, assets: [], diagnostics, errors, notes };
+    }
+    // 依赖补齐：重写器是在 node_modules 里找包的，依赖没装齐就会以"解析不到"收场，
+    // 那个报错对使用者没有指导性，而一条 npm install 就能解决。所以先补齐再解析。
+    // 不指定 registry —— 包从哪来由使用者自己的 npm 配置决定。
+    const audit = (0, dependencies_1.auditDependencies)(projectDir);
+    if (audit.missing.length > 0) {
+        if (options.install === false) {
+            errors.push('缺少依赖：' + audit.missing.join(', ') + '\n' +
+                '    执行 npm install 补齐后重试（本次带了 --no-install，所以没有自动装）。');
+            return { ok: false, toolpkgPath: '', fileCount: 0, files: [], totalBytes: 0, assets: [], diagnostics, errors, notes };
+        }
+        notes.push('检测到缺少依赖：' + audit.missing.join(', ') + '，正在执行 npm install');
+        const installed = (0, dependencies_1.installDependencies)(projectDir);
+        if (!installed.ok) {
+            errors.push('npm install 失败：\n' + installed.output.trim());
+            return { ok: false, toolpkgPath: '', fileCount: 0, files: [], totalBytes: 0, assets: [], diagnostics, errors, notes };
+        }
+        const afterInstall = (0, dependencies_1.auditDependencies)(projectDir);
+        if (afterInstall.missing.length > 0) {
+            errors.push('npm install 执行完了，但这些依赖仍然不在 node_modules 里：' + afterInstall.missing.join(', ') + '\n' +
+                '    检查 package.json 的拼写，或你的 npm 源里有没有这些包。');
+            return { ok: false, toolpkgPath: '', fileCount: 0, files: [], totalBytes: 0, assets: [], diagnostics, errors, notes };
+        }
+        notes.push('依赖已补齐');
+    }
+    let nodeOperitDir;
+    try {
+        nodeOperitDir = (0, contract_1.findNodeOperitDir)(projectDir);
+    }
+    catch (error) {
+        errors.push(String(error instanceof Error ? error.message : error));
+        return { ok: false, toolpkgPath: '', fileCount: 0, files: [], totalBytes: 0, assets: [], diagnostics, errors, notes };
+    }
+    const contract = (0, contract_1.loadContract)(nodeOperitDir);
+    // TS 模式：先编译，再按 outDir 建立「归档路径 -> 磁盘文件」映射。
+    // 归档内路径始终是 manifest 视角，编译产物落在 outDir 由映射负责对上。
+    const plan = (0, typescript_1.planTypeScript)(projectDir);
+    if (plan.isTypeScript) {
+        notes.push('TS 模式，使用 ' + plan.tsconfigPath);
+        const compiled = (0, typescript_1.compileTypeScript)(projectDir, plan.tsconfigPath);
+        if (!compiled.ok) {
+            errors.push('tsc 编译失败：\n' + compiled.output.trim());
+            return { ok: false, toolpkgPath: '', fileCount: 0, files: [], totalBytes: 0, assets: [], diagnostics, errors, notes };
+        }
+        if (compiled.output.trim().length > 0) {
+            notes.push('tsc 输出：\n    ' + compiled.output.trim().split('\n').join('\n    '));
+        }
+        notes.push('编译产物目录：' + (plan.outDir === null ? '（与源码同目录）' : plan.outDir));
+    }
+    else {
+        notes.push('JS 模式（无 tsconfig.json），以项目根为根打包');
+    }
+    const locate = (0, typescript_1.createLocator)(projectDir, plan.outDir);
+    const env = { locate, contract, nodeOperitArchiveDir: contract_1.NODE_OPERIT_DIR };
+    const seeds = collectSeeds(manifest, errors);
+    const visited = new Set();
+    const rewritten = new Map();
+    const queue = [];
+    for (const seed of seeds) {
+        if (locate(seed) === null) {
+            errors.push('入口不存在：' + seed + '（manifest 里写的是相对项目根的路径）');
+            continue;
+        }
+        if (!visited.has(seed)) {
+            visited.add(seed);
+            queue.push(seed);
+        }
+    }
+    while (queue.length > 0) {
+        const archivePath = queue.shift();
+        const diskPath = locate(archivePath);
+        if (diskPath === null) {
+            errors.push('引用了不存在的文件：' + archivePath);
+            continue;
+        }
+        const source = (0, node_fs_1.readFileSync)(diskPath, 'utf8');
+        const outcome = (0, rewrite_1.rewriteModule)(env, archivePath, source);
+        diagnostics.push(...outcome.diagnostics);
+        errors.push(...outcome.errors);
+        rewritten.set(archivePath, outcome.code);
+        for (const discovered of outcome.discovered) {
+            if (!visited.has(discovered)) {
+                visited.add(discovered);
+                queue.push(discovered);
+            }
+        }
+    }
+    // 入口注入运行时全局
+    const entryPath = typeof manifest.main === 'string' ? toPosix(manifest.main) : '';
+    if (entryPath !== '' && rewritten.has(entryPath)) {
+        const joined = toPosix(joinRelative((0, node_path_1.dirname)(entryPath), contract_1.NODE_OPERIT_DIR));
+        const relative = joined.startsWith('.') ? joined : './' + joined;
+        const prelude = '/* opm: Operit 沙盒没有 process / Buffer 全局，入口先挂上（见 node.operit 的 BUILTINS.json） */\n' +
+            "globalThis.process = require('" + relative + "/dist/process.js');\n" +
+            "globalThis.Buffer = require('" + relative + "/dist/buffer.js').Buffer;\n";
+        rewritten.set(entryPath, prelude + rewritten.get(entryPath));
+        notes.push('已向入口 ' + entryPath + ' 注入 process / Buffer 全局');
+    }
+    // 非 JS 资产原样带上（resources / i18n / modules 等）
+    const reachableDiskPaths = new Set();
+    for (const archivePath of rewritten.keys()) {
+        const disk = locate(archivePath);
+        if (disk !== null) {
+            reachableDiskPaths.add(disk);
+        }
+    }
+    const collected = collectAssets(projectDir, plan.outDir, reachableDiskPaths);
+    errors.push(...collected.errors);
+    if (collected.assets.length > 0) {
+        notes.push('原样带上 ' + collected.assets.length + ' 个非代码资产（resources / i18n / modules 等）');
+    }
+    const outName = options.outName === undefined ? baseName(projectDir) : options.outName;
+    const toolpkgPath = (0, node_path_1.join)((0, node_path_1.dirname)(projectDir), outName + '.toolpkg');
+    if (errors.length > 0) {
+        return { ok: false, toolpkgPath, fileCount: rewritten.size, files: [...rewritten.keys()], totalBytes: 0, assets: collected.assets.map((asset) => asset.path), diagnostics, errors, notes };
+    }
+    if (options.dryRun === true) {
+        notes.push('dry-run：未写产物');
+        return { ok: true, toolpkgPath, fileCount: rewritten.size, files: [...rewritten.keys()], totalBytes: measureBytes(rewritten, collected.assets), assets: collected.assets.map((asset) => asset.path), diagnostics, errors, notes };
+    }
+    const entries = [
+        { path: 'manifest.json', content: (0, node_fs_1.readFileSync)((0, node_path_1.join)(projectDir, 'manifest.json')) }
+    ];
+    for (const [archivePath, code] of rewritten) {
+        entries.push({ path: archivePath, content: Buffer.from(code, 'utf8') });
+    }
+    for (const asset of collected.assets) {
+        entries.push({ path: asset.path, content: (0, node_fs_1.readFileSync)(asset.disk) });
+    }
+    const archiveEntries = entries.slice().sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
+    let totalBytes = 0;
+    for (const entry of archiveEntries) {
+        totalBytes += entry.content.length;
+    }
+    const archive = (0, zip_1.createZip)(entries);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(toolpkgPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(toolpkgPath, archive);
+    return {
+        ok: true,
+        toolpkgPath,
+        fileCount: entries.length,
+        files: archiveEntries.map((entry) => entry.path),
+        totalBytes,
+        assets: collected.assets.map((asset) => asset.path),
+        diagnostics,
+        errors,
+        notes
+    };
+}
+/**
+ * 非 JS 资产的收集。
+ *
+ * 规则：**JS 按可达性裁剪，非 JS 一律原样带上。**
+ *
+ * 为什么：resources / i18n / modules（WASM）这类文件是运行期数据，
+ * 静态追 require 是追不到的 —— 早先只按 require 链收集，会把插件的 logo、
+ * 多语言文件、WASM 模块**静默丢掉**，而且不报错。官方打包脚本本来就是整包 zip，
+ * 使用者按"东西都在包里"预期；这里只裁掉死代码，不再动数据文件。
+ */
+const ASSET_SKIP_DIRS = new Set(['node_modules', '.git']);
+const ASSET_SKIP_FILES = new Set([
+    // manifest 由构建流程显式加入，不能再被资产收集加一遍（否则 zip 里出现重复条目）
+    'manifest.json', 'manifest.hjson',
+    'package.json', 'package-lock.json', 'npm-shrinkwrap.json',
+    'tsconfig.json', '.npmrc', '.gitignore', '.gitattributes'
+]);
+const ARCHIVE_LIKE = /\.(tgz|zip|tar|gz)$/i;
+const SCRIPT_LIKE = /\.(js|cjs|mjs|ts|jsx|tsx|map)$/i;
+/**
+ * 这三个目录**无条件整目录保留**，即使里面的文件是 .js。
+ * 因为 i18n/*.js 是被 i18n 机制加载的**数据**，不是 require 出来的模块 ——
+ * 按"JS 一律按可达性裁剪"会把多语言文件一起丢掉，正是这次要修的坑。
+ */
+const ALWAYS_INCLUDE_DIRS = new Set(['resources', 'i18n', 'modules']);
+function collectAssets(projectDir, outDir, reachableDiskPaths) {
+    const assets = [];
+    const errors = [];
+    const outDirPrefix = outDir === null ? null : outDir.replace(/[\\/]+$/, '') + node_path_1.sep;
+    const walk = (dir, prefix, insideAlways) => {
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            errors.push('读取目录失败：' + dir + ' —— ' + String(error));
+            return;
+        }
+        for (const entry of entries) {
+            const archivePath = prefix === '' ? entry.name : prefix + '/' + entry.name;
+            const disk = (0, node_path_1.join)(dir, entry.name);
+            const nextInsideAlways = insideAlways || (prefix === '' && ALWAYS_INCLUDE_DIRS.has(entry.name));
+            if (entry.isDirectory()) {
+                if (ASSET_SKIP_DIRS.has(entry.name)) {
+                    continue;
+                }
+                if (outDirPrefix !== null && (disk + node_path_1.sep).startsWith(outDirPrefix)) {
+                    continue; // 编译产物目录：它的 JS 由可达性接管
+                }
+                walk(disk, archivePath, nextInsideAlways);
+                continue;
+            }
+            if (prefix === '' && ASSET_SKIP_FILES.has(entry.name)) {
+                continue;
+            }
+            if (!nextInsideAlways && ARCHIVE_LIKE.test(entry.name)) {
+                continue; // 打包产物不该再进包 —— 但 resources/ 里的 zip 是合法资源，规范明确支持
+            }
+            if (reachableDiskPaths.has(disk)) {
+                continue; // 已经是可达 JS，不重复
+            }
+            // 规范目录之外：脚本类文件交给可达性裁剪（不可达的 JS 是死代码），
+            // 其它一律当数据带上。
+            if (!nextInsideAlways && SCRIPT_LIKE.test(entry.name)) {
+                continue;
+            }
+            assets.push({ path: archivePath, disk });
+        }
+    };
+    walk(projectDir, '', false);
+    return { assets, errors };
+}
+/** 归档正文的总字节（未压缩）：重写后的 JS + 原样资产。dry-run 也要能报出来。 */
+function measureBytes(files, assets) {
+    let total = 0;
+    for (const code of files.values()) {
+        total += Buffer.byteLength(code, 'utf8');
+    }
+    for (const asset of assets) {
+        try {
+            total += (0, node_fs_1.statSync)(asset.disk).size;
+        }
+        catch {
+            // 读不到大小就不计它，不影响其余结论
+        }
+    }
+    return total;
+}
+function baseName(value) {
+    const normalized = value.replace(/[\\/]+$/, '');
+    const index = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\'));
+    return index < 0 ? normalized : normalized.slice(index + 1);
+}
+function joinRelative(fromDir, target) {
+    const fromParts = fromDir === '' || fromDir === '.' ? [] : fromDir.split('/');
+    const targetParts = target.split('/');
+    let common = 0;
+    while (common < fromParts.length && common < targetParts.length && fromParts[common] === targetParts[common]) {
+        common += 1;
+    }
+    const up = new Array(fromParts.length - common).fill('..');
+    return up.concat(targetParts.slice(common)).join('/');
+}

package/dist/lib/contract.d.ts

@@ -0,0 +1,23 @@
+export declare const NODE_OPERIT_PACKAGE = "@serveryyswys/node.operit";
+export declare const NODE_OPERIT_DIR = "node_modules/@serveryyswys/node.operit";
+/** 运行时已内建、重写时必须保持原样的裸名。 */
+export declare const RUNTIME_BUILTINS: string[];
+export type BuiltinStatus = 'ready' | 'partial' | 'planned' | 'unsupported';
+export interface BuiltinEntry {
+    subpath: string;
+    status: BuiltinStatus;
+    note?: string;
+}
+export interface Contract {
+    package: string;
+    distDir: string;
+    subpathTemplate: string;
+    installDir: string;
+    builtins: Record<string, BuiltinEntry>;
+}
+export declare class ContractError extends Error {
+    constructor(message: string);
+}
+/** 找到项目里安装的 node.operit 包目录；找不到就给出可操作的提示。 */
+export declare function findNodeOperitDir(projectDir: string): string;
+export declare function loadContract(nodeOperitDir: string): Contract;

package/dist/lib/contract.js

@@ -0,0 +1,60 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractError = exports.RUNTIME_BUILTINS = exports.NODE_OPERIT_DIR = exports.NODE_OPERIT_PACKAGE = void 0;
+exports.findNodeOperitDir = findNodeOperitDir;
+exports.loadContract = loadContract;
+/**
+ * BUILTINS.json 契约表 —— 重写规则的唯一真源。
+ *
+ * 表在 node.operit 包里（node_modules/@serveryyswys/node.operit/BUILTINS.json），
+ * 不是本包自带的副本：那份副本一定会过期，而过期的契约会把构建带偏。
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.NODE_OPERIT_PACKAGE = '@serveryyswys/node.operit';
+exports.NODE_OPERIT_DIR = 'node_modules/@serveryyswys/node.operit';
+/** 运行时已内建、重写时必须保持原样的裸名。 */
+exports.RUNTIME_BUILTINS = ['lodash', 'uuid', 'axios'];
+class ContractError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ContractError';
+    }
+}
+exports.ContractError = ContractError;
+/** 找到项目里安装的 node.operit 包目录；找不到就给出可操作的提示。 */
+function findNodeOperitDir(projectDir) {
+    const candidates = [
+        (0, node_path_1.join)(projectDir, exports.NODE_OPERIT_DIR),
+        // pnpm / 提升安装时可能落在更上层
+        (0, node_path_1.join)(projectDir, '..', exports.NODE_OPERIT_DIR)
+    ];
+    for (const candidate of candidates) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(candidate, 'BUILTINS.json'))) {
+            return candidate;
+        }
+    }
+    throw new ContractError('找不到 ' + exports.NODE_OPERIT_PACKAGE + '（在 ' + projectDir + ' 下找过 ' + exports.NODE_OPERIT_DIR + '）。\n' +
+        '它是重写规则的来源，必须先安装：npm install -D ' + exports.NODE_OPERIT_PACKAGE);
+}
+function loadContract(nodeOperitDir) {
+    const contractPath = (0, node_path_1.join)(nodeOperitDir, 'BUILTINS.json');
+    let raw;
+    try {
+        raw = JSON.parse((0, node_fs_1.readFileSync)(contractPath, 'utf8'));
+    }
+    catch (error) {
+        throw new ContractError('读取契约表失败：' + contractPath + '\n' + String(error));
+    }
+    const record = raw;
+    if (record.builtins === undefined || typeof record.builtins !== 'object') {
+        throw new ContractError('契约表缺少 builtins 段：' + contractPath);
+    }
+    return {
+        package: record.package === undefined ? exports.NODE_OPERIT_PACKAGE : record.package,
+        distDir: record.distDir === undefined ? 'dist' : record.distDir,
+        subpathTemplate: record.subpathTemplate === undefined ? '<distDir>/<subpath>.js' : record.subpathTemplate,
+        installDir: record.installDir === undefined ? exports.NODE_OPERIT_DIR : record.installDir,
+        builtins: record.builtins
+    };
+}

package/dist/lib/dependencies.d.ts

@@ -0,0 +1,24 @@
+export interface DependencyAudit {
+    /** package.json 里声明了、但 node_modules 里没有的包 */
+    missing: string[];
+    /** 是否连 package.json 都没有 */
+    hasManifest: boolean;
+}
+/**
+ * 审计依赖。
+ *
+ * 只查 dependencies，不查 devDependencies —— 进包的是运行期依赖，
+ * 开发依赖被 require 到属于打包错误，应当让重写器如实报错，而不是默默装进来。
+ * 例外是 node.operit：它是**构建期**的契约来源，无论写在哪一段都必须存在。
+ */
+export declare function auditDependencies(projectDir: string): DependencyAudit;
+/**
+ * 跑 npm install。
+ *
+ * 输出重定向到临时文件而不是管道：与调 tsc 同一个理由（受限环境不允许管道，
+ * 而这里必须拿到 npm 的日志才能报错）。
+ */
+export declare function installDependencies(projectDir: string): {
+    ok: boolean;
+    output: string;
+};

package/dist/lib/dependencies.js

@@ -0,0 +1,105 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditDependencies = auditDependencies;
+exports.installDependencies = installDependencies;
+/**
+ * 依赖补齐。
+ *
+ * 为什么 build 要管这件事：重写器是在 node_modules 里找包的，依赖没装齐就会直接
+ * "既不是 Node 内建、也不在 node_modules 里" —— 那个报错对使用者没有指导性，
+ * 而且明明一条 npm install 就能解决。所以 build 先补齐再解析。
+ *
+ * **不指定 registry**：包从哪来由使用者自己的 npm 配置决定（私有源的用户自然走私源）。
+ */
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const contract_1 = require("./contract");
+function readManifest(projectDir) {
+    const manifestPath = (0, node_path_1.join)(projectDir, 'package.json');
+    if (!(0, node_fs_1.existsSync)(manifestPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 判断一个包在不在 node_modules 里（看它自己的 package.json）。 */
+function isInstalled(projectDir, name) {
+    return (0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, 'node_modules', name, 'package.json'));
+}
+/**
+ * 审计依赖。
+ *
+ * 只查 dependencies，不查 devDependencies —— 进包的是运行期依赖，
+ * 开发依赖被 require 到属于打包错误，应当让重写器如实报错，而不是默默装进来。
+ * 例外是 node.operit：它是**构建期**的契约来源，无论写在哪一段都必须存在。
+ */
+function auditDependencies(projectDir) {
+    const manifest = readManifest(projectDir);
+    if (manifest === null) {
+        // 没有 package.json 也可能是合法的 toolpkg 工程（纯 Operit 工程），
+        // 所以这里仍然要如实检查 node.operit 装没装，不能一律判缺。
+        return {
+            missing: isInstalled(projectDir, contract_1.NODE_OPERIT_PACKAGE) ? [] : [contract_1.NODE_OPERIT_PACKAGE],
+            hasManifest: false
+        };
+    }
+    const names = new Set([contract_1.NODE_OPERIT_PACKAGE]);
+    const dependencies = manifest.dependencies;
+    if (dependencies !== null && typeof dependencies === 'object') {
+        for (const name of Object.keys(dependencies)) {
+            names.add(name);
+        }
+    }
+    const missing = [];
+    for (const name of names) {
+        if (!isInstalled(projectDir, name)) {
+            missing.push(name);
+        }
+    }
+    missing.sort();
+    return { missing, hasManifest: true };
+}
+/**
+ * 跑 npm install。
+ *
+ * 输出重定向到临时文件而不是管道：与调 tsc 同一个理由（受限环境不允许管道，
+ * 而这里必须拿到 npm 的日志才能报错）。
+ */
+function installDependencies(projectDir) {
+    const logPath = (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'opm-npm-' + process.pid + '-' + Date.now() + '.log');
+    const logFd = (0, node_fs_1.openSync)(logPath, 'w');
+    let result;
+    try {
+        result = (0, node_child_process_1.spawnSync)('npm', ['install'], {
+            cwd: projectDir,
+            shell: true,
+            stdio: ['ignore', logFd, logFd]
+        });
+    }
+    finally {
+        (0, node_fs_1.closeSync)(logFd);
+    }
+    let output = '';
+    try {
+        output = (0, node_fs_1.readFileSync)(logPath, 'utf8');
+    }
+    catch {
+        output = '';
+    }
+    try {
+        (0, node_fs_1.unlinkSync)(logPath);
+    }
+    catch {
+        // 清不掉临时日志不影响结论
+    }
+    if (result.error !== undefined && result.error !== null) {
+        return { ok: false, output: output + '\n无法启动 npm：' + result.error.message };
+    }
+    return { ok: result.status === 0, output };
+}

package/dist/lib/init.d.ts

@@ -0,0 +1,19 @@
+export declare const OPM_PACKAGE = "@serveryyswys/opm";
+export interface InitOptions {
+    projectDir: string;
+    /** 是否跑 npm install（默认 true） */
+    install?: boolean;
+    /** 覆盖已存在的 package.json 字段（默认 false：只补不改） */
+    overwrite?: boolean;
+}
+export interface InitResult {
+    ok: boolean;
+    created: string[];
+    updated: string[];
+    unchanged: string[];
+    notes: string[];
+    errors: string[];
+    /** 建议使用者接着执行的命令 */
+    nextSteps: string[];
+}
+export declare function initProject(options: InitOptions): InitResult;