vyriy 0.3.5 → 0.3.9

package/README.md

@@ -34,8 +34,13 @@ vyriy new my-app
 vyriy .
 vyriy init
 vyriy doctor
+vyriy publish
 vyriy --dry-run
 vyriy --yes
+vyriy --no-install
+vyriy --no-verify
+vyriy --install-only
+vyriy --verify
 vyriy --overwrite
 vyriy --skip-existing
 vyriy --help
@@ -48,7 +53,7 @@ Runs the same flow as `vyriy new`.
 
 ### `vyriy new [name]`
 
-Starts the project planning wizard, prints the project summary and file plan, then writes generated files when no unresolved conflicts exist.
+Starts the project planning wizard, prints the project summary and file plan, writes generated files when no unresolved conflicts exist, installs dependencies, and runs generated project checks.
 
 If `name` is provided, it is used as the default project name and target directory.
 
@@ -75,15 +80,37 @@ Current checks:
 
 Node.js is fatal when unsupported. Yarn and Git are warnings so generation can continue without silently installing tools or initializing Git.
 
+### `vyriy publish`
+
+Prepares compiled `dist` package metadata for publishing without running `npm publish`.
+
+Use it after TypeScript emits package files into `dist`, for example from a `build:dist` script.
+
 ## Flags
 
 ### `--dry-run`
 
-Prints the doctor report, project summary, and file plan without writing files or running fix commands.
+Prints the doctor report, project summary, and file plan without writing files, installing dependencies, or running checks.
+
+### `--no-install`
+
+Writes generated files but skips `yarn install` and `yarn check`.
+
+### `--no-verify`
+
+Writes generated files and runs `yarn install`, but skips `yarn check`.
+
+### `--install-only`
+
+Alias for `--no-verify`.
+
+### `--verify`
+
+Explicitly enables `yarn check`. This is already the default unless `--no-install`, `--no-verify`, or `--install-only` is passed.
 
 ### `--yes`
 
-Uses default wizard answers and avoids prompts where possible. It does not overwrite existing files unless `--overwrite` is also passed.
+Uses default wizard answers and avoids prompts where possible. In non-interactive mode, the default preset is `empty` with no CI/CD provider. It does not overwrite existing files unless `--overwrite` is also passed.
 
 ### `--overwrite`
 
@@ -106,10 +133,10 @@ The wizard collects:
 - project preset
 - API style for API-capable presets
 - CI/CD provider
-- optional infrastructure choices
+- infrastructure provider
 - confirmation
 
-After confirmation, the CLI prints the project plan, creates generated files in memory, builds a conflict-aware file plan, and writes the accepted file plan.
+After confirmation, the CLI prints the project plan, creates generated files in memory, builds a conflict-aware file plan, writes the accepted file plan, runs `yarn install`, and runs `yarn check`.
 
 Presets do not write to disk directly.
 
@@ -119,28 +146,28 @@ Generated projects always include `AGENTS.md` based on the shared Vyriy package
 
 Supported presets:
 
+- `empty`
 - `library`
 - `api`
-- `react-csr`
-- `react-ssr`
-- `react-ssg`
-- `mfe`
-- `openmfe`
-- `mfe-bff`
-- `openmfe-bff`
+- `ssr`
+- `ssg`
+- `csr`
 - `fullstack`
-- `aws-serverless`
-- `empty`
+- `mfe`
+
+The preset is the concrete future generated setup. The project kind is the broader architecture category. The infrastructure choice is selected separately: Docker is the default local/container shape, while AWS selects CDK plus Lambda/API Gateway for API-capable presets.
+
+The `mfe` preset uses OpenMFE as the default MFE contract shape. There is no separate `openmfe` preset unless a future use case proves that split is useful.
 
-The preset is the concrete future generated setup. The project kind is the broader architecture category.
+Workspace kinds describe deployment intent: `ui` is universal UI output, `api` is Docker-oriented, `lambda` is the AWS API runtime, `fargate` is an AWS container runtime, and `stack` contains AWS infrastructure.
 
 Examples:
 
-- `react-csr` -> `csr`
-- `react-ssr` -> `ssr`
-- `react-ssg` -> `ssg`
-- `openmfe-bff` -> `mfe`
-- `aws-serverless` -> `aws-serverless`
+- `csr` -> `csr`
+- `ssr` -> `ssr`
+- `ssg` -> `ssg`
+- `mfe` -> `mfe`
+- `fullstack` -> `fullstack`
 
 ## Public API
 
@@ -178,7 +205,7 @@ It includes:
 - architecture: `preset`, `projectKind`
 - selected features
 - CI/CD planning: enabled state, providers, and validation pipelines
-- API planning for API-capable presets: REST, GraphQL, or mixed API style
+- API planning for API-capable presets: REST or GraphQL API style
 - future package plans
 - future workspace plans
 

package/cli/args/args.js

@@ -6,6 +6,8 @@ export const parseArgs = (args) => {
         return { type: 'version' };
     }
     const dryRun = args.includes('--dry-run');
+    const install = !args.includes('--no-install');
+    const verify = install && (args.includes('--verify') || (!args.includes('--no-verify') && !args.includes('--install-only')));
     const yes = args.includes('--yes') || args.includes('-y');
     const overwrite = args.includes('--overwrite');
     const skipExisting = args.includes('--skip-existing');
@@ -13,8 +15,10 @@ export const parseArgs = (args) => {
     const [command, projectName] = positionalArgs;
     const options = {
         dryRun,
+        install,
         yes,
         overwrite,
+        verify,
         skipExisting,
     };
     if (!command) {
@@ -28,6 +32,8 @@ export const parseArgs = (args) => {
             return { type: 'init', ...options };
         case 'doctor':
             return { type: 'doctor' };
+        case 'publish':
+            return { type: 'publish' };
         default:
             return { type: 'unknown', command };
     }

package/cli/args/types.d.ts

@@ -2,17 +2,21 @@ export type VyriyCliCommand = {
     readonly type: 'new';
     readonly projectName?: string;
     readonly dryRun: boolean;
+    readonly install: boolean;
     readonly yes: boolean;
     readonly overwrite: boolean;
+    readonly verify: boolean;
     readonly skipExisting: boolean;
 } | {
     readonly type: 'init';
     readonly dryRun: boolean;
+    readonly install: boolean;
     readonly yes: boolean;
     readonly overwrite: boolean;
+    readonly verify: boolean;
     readonly skipExisting: boolean;
 } | {
-    readonly type: 'doctor' | 'help' | 'version';
+    readonly type: 'doctor' | 'help' | 'publish' | 'version';
 } | {
     readonly type: 'unknown';
     readonly command: string;

package/cli/cli.js

@@ -1,6 +1,7 @@
 import { runDoctorCommand } from '../commands/doctor/index.js';
 import { runInitCommand } from '../commands/init/index.js';
 import { runNewCommand } from '../commands/new/index.js';
+import { runPublishCommand } from '../commands/publish/index.js';
 import packageJson from '../package.json' with { type: 'json' };
 import { parseArgs } from './args/index.js';
 const helpText = `Vyriy Project Master
@@ -10,9 +11,17 @@ Usage:
   vyriy init             Initialize the current directory
   vyriy .                Initialize the current directory
   vyriy doctor           Check local environment
+  vyriy publish          Prepare dist package metadata without publishing to npm
+  vyriy --yes, -y        Use defaults where possible (empty preset)
   vyriy --dry-run        Print checks and file plan without writing
-  vyriy --help           Show help
-  vyriy --version        Show version
+  vyriy --overwrite      Overwrite existing generated paths
+  vyriy --skip-existing  Leave existing generated paths untouched
+  vyriy --no-install     Create files without installing dependencies
+  vyriy --no-verify      Install dependencies without running checks
+  vyriy --install-only   Alias for --no-verify
+  vyriy --verify         Explicitly enable generated project checks
+  vyriy --help, -h       Show help
+  vyriy --version, -v    Show version
 
 Examples:
   vyriy new my-app
@@ -25,19 +34,23 @@ export const runVyriyCli = async (args = [], { output = console } = {}) => {
         case 'new':
             code = await runNewCommand({
                 dryRun: command.dryRun,
+                install: command.install,
                 output,
                 overwrite: command.overwrite,
                 projectName: command.projectName,
                 skipExisting: command.skipExisting,
+                verify: command.verify,
                 yes: command.yes,
             });
             break;
         case 'init':
             code = await runInitCommand({
                 dryRun: command.dryRun,
+                install: command.install,
                 output,
                 overwrite: command.overwrite,
                 skipExisting: command.skipExisting,
+                verify: command.verify,
                 yes: command.yes,
             });
             break;
@@ -46,6 +59,9 @@ export const runVyriyCli = async (args = [], { output = console } = {}) => {
             code = result.code;
             break;
         }
+        case 'publish':
+            code = await runPublishCommand();
+            break;
         case 'help':
             output.log(helpText);
             break;

package/commands/new/new.js

@@ -5,6 +5,8 @@ import { createFilePlan, printFilePlan, writeFilePlan } from '../../file-plan/in
 import { createProjectFiles } from '../../presets/index.js';
 import { askProjectPlan as askProjectPlanDefault } from '../../prompts/project-plan/index.js';
 import { createProjectPlanFromPreset, printProjectPlan } from '../../project-plan/index.js';
+import { runCommand } from '../../shared/index.js';
+const defaultYesPreset = 'empty';
 const getConflicts = (filePlan) => filePlan.filter((item) => item.status === 'conflict');
 const logConflicts = (output, conflicts, method) => {
     output[method]('\nExisting files found:\n');
@@ -28,6 +30,70 @@ const createResolvedFilePlan = async (plan, projectFiles, resolution) => createF
     overwrite: resolution === 'overwrite',
     skipExisting: resolution === 'skip',
 });
+const formatCommand = (command, args) => [command, ...args].join(' ');
+const printFailedPostGenerationCommand = ({ args, command, intro, output, projectDirectory, }) => {
+    const commandText = formatCommand(command, args);
+    output.error(`\n${intro}\n`);
+    output.error(`Failed command:\n  ${commandText}\n`);
+    output.error(`Project directory:\n  ${projectDirectory}\n`);
+    output.error(`You can inspect it and run manually:\n  cd ${projectDirectory}\n  ${commandText}`);
+};
+const runPostGenerationCommands = async ({ install, output, projectDirectory, verify, }) => {
+    if (!install) {
+        output.log('Installing dependencies... SKIPPED');
+        output.log('Running checks... SKIPPED');
+        output.log('\nProject files were created.');
+        return 0;
+    }
+    try {
+        await runCommand({
+            args: ['install'],
+            command: 'yarn',
+            cwd: projectDirectory,
+        });
+    }
+    catch {
+        printFailedPostGenerationCommand({
+            args: ['install'],
+            command: 'yarn',
+            intro: 'Project files were created, but dependency installation failed.',
+            output,
+            projectDirectory,
+        });
+        return 1;
+    }
+    output.log('Installing dependencies... OK');
+    if (!verify) {
+        output.log('Running checks... SKIPPED');
+        output.log('\nProject files were created and dependencies were installed.');
+        return 0;
+    }
+    try {
+        await runCommand({
+            args: ['fix'],
+            command: 'yarn',
+            cwd: projectDirectory,
+        });
+        await runCommand({
+            args: ['check'],
+            command: 'yarn',
+            cwd: projectDirectory,
+        });
+    }
+    catch {
+        printFailedPostGenerationCommand({
+            args: ['check'],
+            command: 'yarn',
+            intro: 'Project files were created and dependencies were installed, but verification failed.',
+            output,
+            projectDirectory,
+        });
+        return 1;
+    }
+    output.log('Running checks... OK');
+    output.log('\nProject is ready.');
+    return 0;
+};
 const resolveInteractiveConflicts = async (plan, projectFiles, output, conflicts, askConflictResolution) => {
     logConflicts(output, conflicts, 'log');
     printConflictPrompt(output);
@@ -46,7 +112,7 @@ const resolveInteractiveConflicts = async (plan, projectFiles, output, conflicts
 export const askConflictResolutionDefault = async () => {
     const readline = createInterface({ input: stdin, output: stdout });
     try {
-        const answer = (await readline.question('What should Vyriy do? 1. overwrite existing files, 2. skip existing files, 3. abort (abort): '))
+        const answer = (await readline.question('What should Vyriy do?\n\n 1. overwrite existing files,\n\n 2. skip existing files,\n\n 3. abort (abort): '))
             .trim()
             .toLowerCase();
         if (answer === '1' || answer === 'overwrite') {
@@ -61,7 +127,7 @@ export const askConflictResolutionDefault = async () => {
         readline.close();
     }
 };
-export const runNewCommand = async ({ askConflictResolution = askConflictResolutionDefault, askProjectPlan = askProjectPlanDefault, dryRun = false, output = console, overwrite = false, projectName = 'my-app', skipExisting = false, yes = false, } = {}) => {
+export const runNewCommand = async ({ askConflictResolution = askConflictResolutionDefault, askProjectPlan = askProjectPlanDefault, dryRun = false, install = true, output = console, overwrite = false, projectName = 'my-app', skipExisting = false, verify = true, yes = false, } = {}) => {
     if (overwrite && skipExisting) {
         output.error('Cannot use --overwrite and --skip-existing together.');
         return 1;
@@ -72,13 +138,13 @@ export const runNewCommand = async ({ askConflictResolution = askConflictResolut
         output.error('\nPlease install Node.js 24+ and run the command again.');
         return 1;
     }
-    const plan = dryRun || yes
+    const plan = yes
         ? createProjectPlanFromPreset({
             apiStyle: 'rest',
             ciProvider: 'none',
             description: 'Calm cloud-ready application.',
             packageScope: `@${projectName}`,
-            preset: 'react-ssr',
+            preset: defaultYesPreset,
             projectName,
             targetDirectory: projectName,
         })
@@ -113,6 +179,11 @@ export const runNewCommand = async ({ askConflictResolution = askConflictResolut
         output.log(`\n${printFilePlan(resolved.filePlan)}`);
     }
     await writeFilePlan(plan.targetDirectory, filePlan);
-    output.log('\nProject files written.');
-    return 0;
+    output.log('\nCreating project files... OK');
+    return runPostGenerationCommands({
+        install,
+        output,
+        projectDirectory: plan.targetDirectory,
+        verify: install && verify,
+    });
 };

package/commands/new/types.d.ts

@@ -6,8 +6,10 @@ export type RunNewCommandOptions = {
     readonly askConflictResolution?: () => Promise<ConflictResolution>;
     readonly output?: Pick<typeof console, 'log' | 'error'>;
     readonly dryRun?: boolean;
+    readonly install?: boolean;
     readonly yes?: boolean;
     readonly overwrite?: boolean;
+    readonly verify?: boolean;
     readonly skipExisting?: boolean;
 };
 export type RunNewCommand = (options?: RunNewCommandOptions) => Promise<number>;

package/commands/publish/index.d.ts

@@ -0,0 +1,2 @@
+export * from './publish.js';
+export type * from './types.js';

package/commands/publish/index.js

@@ -0,0 +1 @@
+export * from './publish.js';

package/commands/publish/publish.d.ts

@@ -0,0 +1,2 @@
+import type { RunPublishCommand } from './types.js';
+export declare const runPublishCommand: RunPublishCommand;

package/commands/publish/publish.js

@@ -0,0 +1,274 @@
+import { chmod, copyFile, readdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const DIST_DIR = 'dist';
+const AGENTS_FILE = 'AGENTS.md';
+const LICENSE_FILE = 'LICENSE';
+const PACKAGE_JSON_FILE = 'package.json';
+const PACKAGES_DIR = 'packages';
+const README_FILE = 'README.md';
+const toPosixPath = (value) => value.split(path.sep).join('/');
+const toPackagePath = (value) => {
+    const normalizedValue = toPosixPath(value);
+    return `./${normalizedValue.replace(/^\.\//, '')}`;
+};
+const hasFile = async (filePath) => {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const readJson = async (filePath) => {
+    const content = await readFile(filePath, 'utf8');
+    return JSON.parse(content);
+};
+const writeJson = async (filePath, value) => {
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+};
+const isEmptyJavaScriptContent = (content) => {
+    const normalizedContent = content.trim();
+    return normalizedContent.length === 0 || normalizedContent === 'export {};';
+};
+const exportTargetPattern = /^\s*export(?:\s+\*|\s+\{[^}]*\})\s+from\s+['"](\..+\.js)['"];?\s*$/;
+const getMissingExportTarget = async (file, line) => {
+    const exportTarget = exportTargetPattern.exec(line)?.[1];
+    if (!exportTarget) {
+        return undefined;
+    }
+    const exportTargetPath = path.resolve(path.dirname(file), exportTarget);
+    return (await hasFile(exportTargetPath)) ? undefined : exportTargetPath;
+};
+const readFiles = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return readFiles(entryPath);
+        }
+        return entry.isFile() ? [entryPath] : [];
+    }));
+    return files.flat();
+};
+const getPackageMain = async (packageDirectory, packageJson, javaScriptFiles) => {
+    if (packageJson.main?.endsWith('.js')) {
+        const mainPath = packageJson.main.replace(/^\.\//, '');
+        if (await hasFile(path.join(packageDirectory, mainPath))) {
+            return toPosixPath(mainPath);
+        }
+    }
+    if (javaScriptFiles.includes('index.js')) {
+        return 'index.js';
+    }
+    return javaScriptFiles[0];
+};
+const createExportTarget = (javaScriptFile) => {
+    const packagePath = toPackagePath(javaScriptFile);
+    return {
+        types: packagePath.replace(/\.js$/, '.d.ts'),
+        import: packagePath,
+        default: packagePath,
+    };
+};
+const createExports = (mainFile, javaScriptFiles) => {
+    const exports = {
+        '.': createExportTarget(mainFile),
+    };
+    for (const javaScriptFile of javaScriptFiles) {
+        const packagePath = toPackagePath(javaScriptFile);
+        const extensionlessPackagePath = packagePath.replace(/\.js$/, '');
+        const target = createExportTarget(javaScriptFile);
+        exports[extensionlessPackagePath] = target;
+        exports[packagePath] = target;
+    }
+    return exports;
+};
+const createPackageRepository = (rootPackageJson, packageDirectory) => {
+    const rootRepository = rootPackageJson.repository;
+    if (!rootRepository) {
+        return undefined;
+    }
+    return {
+        ...rootRepository,
+        directory: toPosixPath(path.join(PACKAGES_DIR, path.basename(packageDirectory))),
+    };
+};
+const getJavaScriptFiles = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    const javaScriptFiles = [];
+    for (const file of files) {
+        const relativeFile = toPosixPath(path.relative(packageDirectory, file));
+        const declarationFile = path.join(packageDirectory, relativeFile.replace(/\.js$/, '.d.ts'));
+        if (relativeFile.endsWith('.js') && !relativeFile.endsWith('.test.js') && (await hasFile(declarationFile))) {
+            javaScriptFiles.push(relativeFile);
+        }
+    }
+    return javaScriptFiles.sort((left, right) => left.localeCompare(right));
+};
+const removeEmptyJavaScriptFiles = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    for (const file of files) {
+        if (file.endsWith('.js') && isEmptyJavaScriptContent(await readFile(file, 'utf8'))) {
+            await unlink(file);
+        }
+    }
+};
+const removeMissingJavaScriptExports = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    for (const file of files) {
+        if (!file.endsWith('.js')) {
+            continue;
+        }
+        const content = await readFile(file, 'utf8');
+        const lines = content.split('\n');
+        const retainedLines = [];
+        for (const line of lines) {
+            if (!(await getMissingExportTarget(file, line))) {
+                retainedLines.push(line);
+            }
+        }
+        if (retainedLines.length !== lines.length) {
+            await writeFile(file, retainedLines.join('\n'));
+        }
+    }
+};
+const copyReadme = async (packageDirectory) => {
+    const packageName = path.basename(packageDirectory);
+    const sourceReadmePath = path.join(PACKAGES_DIR, packageName, README_FILE);
+    if (await hasFile(sourceReadmePath)) {
+        await copyFile(sourceReadmePath, path.join(packageDirectory, README_FILE));
+    }
+};
+const resolveSourceAgentsPath = async (packageAgentsPath, sharedAgentsPath, rootAgentsPath) => {
+    if (await hasFile(packageAgentsPath)) {
+        return packageAgentsPath;
+    }
+    if (await hasFile(sharedAgentsPath)) {
+        return sharedAgentsPath;
+    }
+    return rootAgentsPath;
+};
+const copyAgents = async (packageDirectory, rootPackageJson) => {
+    const packageName = path.basename(packageDirectory);
+    const packageAgentsPath = path.join(PACKAGES_DIR, packageName, AGENTS_FILE);
+    const sharedAgentsPath = path.join(PACKAGES_DIR, AGENTS_FILE);
+    const rootAgentsPath = typeof rootPackageJson.agents === 'string' ? rootPackageJson.agents.replace(/^\.\//, '') : '';
+    const sourceAgentsPath = await resolveSourceAgentsPath(packageAgentsPath, sharedAgentsPath, rootAgentsPath);
+    if (await hasFile(sourceAgentsPath)) {
+        await copyFile(sourceAgentsPath, path.join(packageDirectory, AGENTS_FILE));
+        return true;
+    }
+    return false;
+};
+const copyLicense = async (packageDirectory) => {
+    if (await hasFile(LICENSE_FILE)) {
+        await copyFile(LICENSE_FILE, path.join(packageDirectory, LICENSE_FILE));
+    }
+};
+const getPackageBinFiles = (packageJson) => {
+    if (typeof packageJson.bin === 'string') {
+        return [packageJson.bin];
+    }
+    if (packageJson.bin && typeof packageJson.bin === 'object') {
+        return Object.values(packageJson.bin);
+    }
+    return [];
+};
+const makePackageBinsExecutable = async (packageDirectory, packageJson) => {
+    for (const binFile of getPackageBinFiles(packageJson)) {
+        const binFilePath = path.join(packageDirectory, binFile.replace(/^\.\//, ''));
+        if (await hasFile(binFilePath)) {
+            await chmod(binFilePath, 0o755);
+        }
+    }
+};
+const copyRootFile = async (fileName) => {
+    if (await hasFile(fileName)) {
+        await copyFile(fileName, path.join(DIST_DIR, fileName));
+    }
+};
+const publishRootPackageJson = async () => {
+    const packageJson = await readJson(PACKAGE_JSON_FILE);
+    delete packageJson.agents;
+    delete packageJson.dependencies;
+    delete packageJson.packageManager;
+    delete packageJson.scripts;
+    delete packageJson.devDependencies;
+    await writeJson(path.join(DIST_DIR, PACKAGE_JSON_FILE), packageJson);
+};
+const publishRoot = async () => {
+    await copyRootFile(README_FILE);
+    await copyRootFile(LICENSE_FILE);
+    await publishRootPackageJson();
+};
+const syncPackageRuntimeMetadata = (packageJson, rootPackageJson) => {
+    if (packageJson.name !== 'vyriy') {
+        return;
+    }
+    packageJson.packageManager = rootPackageJson.packageManager;
+    packageJson.engines = rootPackageJson.engines;
+};
+const publishPackage = async (packageJsonPath, rootPackageJson) => {
+    const packageDirectory = path.dirname(packageJsonPath);
+    const packageJson = await readJson(packageJsonPath);
+    await removeEmptyJavaScriptFiles(packageDirectory);
+    await removeMissingJavaScriptExports(packageDirectory);
+    await removeEmptyJavaScriptFiles(packageDirectory);
+    const javaScriptFiles = await getJavaScriptFiles(packageDirectory);
+    await copyLicense(packageDirectory);
+    await copyReadme(packageDirectory);
+    const hasAgents = await copyAgents(packageDirectory, rootPackageJson);
+    delete packageJson.private;
+    if (hasAgents && rootPackageJson.agents) {
+        packageJson.agents = toPackagePath(AGENTS_FILE);
+    }
+    else {
+        delete packageJson.agents;
+    }
+    if (rootPackageJson.license) {
+        packageJson.license = rootPackageJson.license;
+    }
+    else {
+        delete packageJson.license;
+    }
+    const repository = createPackageRepository(rootPackageJson, packageDirectory);
+    if (repository) {
+        packageJson.repository = repository;
+    }
+    else {
+        delete packageJson.repository;
+    }
+    syncPackageRuntimeMetadata(packageJson, rootPackageJson);
+    if (javaScriptFiles.length > 0) {
+        const mainFile = await getPackageMain(packageDirectory, packageJson, javaScriptFiles);
+        if (mainFile) {
+            packageJson.main = toPackagePath(mainFile);
+            packageJson.types = toPackagePath(mainFile).replace(/\.js$/, '.d.ts');
+            packageJson.exports = createExports(mainFile, javaScriptFiles);
+        }
+    }
+    await makePackageBinsExecutable(packageDirectory, packageJson);
+    await writeJson(packageJsonPath, packageJson);
+};
+export const runPublishCommand = async ({ cwd = process.cwd() } = {}) => {
+    const previousCwd = process.cwd();
+    try {
+        process.chdir(cwd);
+        const rootPackageJson = await readJson(PACKAGE_JSON_FILE);
+        await publishRoot();
+        const entries = await readdir(DIST_DIR, { withFileTypes: true });
+        const packageJsonPaths = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(DIST_DIR, entry.name, 'package.json'))
+            .sort((left, right) => left.localeCompare(right));
+        for (const packageJsonPath of packageJsonPaths) {
+            if (await hasFile(packageJsonPath)) {
+                await publishPackage(packageJsonPath, rootPackageJson);
+            }
+        }
+        return 0;
+    }
+    finally {
+        process.chdir(previousCwd);
+    }
+};