@emeryld/manager 0.6.0 → 0.6.2

package/dist/create-package/index.js

@@ -80,16 +80,28 @@ async function promptForContractName() {
 }
 async function promptForClientKind(existing) {
     const defaultKind = normalizeClientKind(existing) ?? DEFAULT_CLIENT_KIND;
-    const optionLabels = CLIENT_KIND_OPTIONS.map((opt, idx) => `[${idx + 1}] ${opt.label}`).join(', ');
-    const answer = await askLine(`Client template? ${optionLabels} (${defaultKind}): `);
-    const normalized = normalizeClientKind(answer);
-    if (normalized)
-        return normalized;
-    if (answer === '1')
-        return CLIENT_KIND_OPTIONS[0]?.id ?? defaultKind;
-    if (answer === '2')
-        return CLIENT_KIND_OPTIONS[1]?.id ?? defaultKind;
-    return defaultKind;
+    let selection;
+    const scripts = CLIENT_KIND_OPTIONS.map((opt) => ({
+        name: opt.label,
+        emoji: '💻',
+        description: opt.summary,
+        handler: () => {
+            selection = opt.id;
+        },
+    }));
+    // scripts.push({
+    //   name: `Use default (${defaultKind})`,
+    //   emoji: '✅',
+    //   handler: () => {
+    //     selection = defaultKind
+    //   },
+    // })
+    await runHelperCli({
+        title: 'Select a client template',
+        scripts,
+        argv: [],
+    });
+    return selection ?? defaultKind;
 }
 function resolveVariant(key) {
     if (!key)

package/dist/create-package/shared.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { access, mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { promptYesNoAll } from '../prompts.js';
+import { ModuleResolutionKind } from 'typescript';
 export const workspaceRoot = process.cwd();
 export function isWorkspaceRoot(dir) {
     return path.resolve(dir) === path.resolve(workspaceRoot);
@@ -347,6 +348,12 @@ export async function packageTsConfig(targetDir, options) {
         esModuleInterop: options?.esModuleInterop ?? true,
         allowSyntheticDefaultImports: options?.esModuleInterop ?? true,
         skipLibCheck: options?.skipLibCheck ?? true,
+        target: options?.target,
+        module: options?.module,
+        moduleResolution: options?.ModuleResolutionKind !== undefined
+            ? ModuleResolutionKind[options.ModuleResolutionKind]
+            : undefined,
+        declarationMap: options?.declarationMap,
     });
     const config = stripUndefined({
         extends: extendsPath,

package/dist/create-package/variants/client/client_expo_rn.js

@@ -1,3 +1,4 @@
+import { ModuleResolutionKind } from 'typescript';
 import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, baseScripts, buildReadme, isWorkspaceRoot, packageTsConfig, writeFileIfMissing, } from '../../shared.js';
 const EXPO_CLIENT_SCRIPTS = [
     'dev',
@@ -480,6 +481,9 @@ export async function scaffoldExpoReactNativeClient(ctx) {
         include: ['App.tsx', 'src/**/*.ts', 'src/**/*.tsx'],
         jsx: 'react-native',
         types: ['react', 'react-native'],
+        target: 'ES2022',
+        module: 'ESNext',
+        ModuleResolutionKind: ModuleResolutionKind.Bundler,
         rootDir: '.',
     });
     const files = {

package/dist/create-package/variants/client/client_vite_r.js

@@ -1,3 +1,4 @@
+import { ModuleResolutionKind } from 'typescript';
 import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, baseScripts, buildReadme, isWorkspaceRoot, packageTsConfig, writeFileIfMissing, } from '../../shared.js';
 const VITE_CLIENT_SCRIPTS = [
     'dev',
@@ -525,10 +526,15 @@ function indexHtml() {
 export async function scaffoldViteReactClient(ctx) {
     const includePrepare = isWorkspaceRoot(ctx.targetDir);
     const tsconfig = await packageTsConfig(ctx.targetDir, {
-        include: ['src/**/*', 'vite.config.ts'],
+        include: ['src/**/*.ts', 'src/**/*.tsx'],
         lib: ['ES2022', 'DOM'],
         types: ['vite/client'],
         jsx: 'react-jsx',
+        target: 'ES2022',
+        module: 'ESNext',
+        ModuleResolutionKind: ModuleResolutionKind.Bundler,
+        esModuleInterop: true,
+        skipLibCheck: true,
     });
     const files = {
         'package.json': vitePackageJson(ctx.pkgName, ctx.contractName, includePrepare),

package/dist/create-package/variants/contract.js

@@ -1,3 +1,4 @@
+import { ModuleResolutionKind } from 'typescript';
 import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, isWorkspaceRoot, writeFileIfMissing, } from '../shared.js';
 const CONTRACT_SCRIPTS = [
     'dev',
@@ -16,16 +17,9 @@ const CONTRACT_SCRIPTS = [
  * in some module shapes (CJS export= or default export). To make scaffolds compile reliably,
  * we import as a namespace and then grab from either `default` or the namespace object.
  */
-export const CONTRACT_TS = `import * as rrroutesContract from '@emeryld/rrroutes-contract'
+export const CONTRACT_TS = `import { defineSocketEvents, finalize, resource } from '@emeryld/rrroutes-contract'
 import { z } from 'zod'
 
-const api = (rrroutesContract as any).default ?? rrroutesContract
-const { defineSocketEvents, finalize, resource } = api as {
-  defineSocketEvents: (...args: any[]) => any
-  finalize: (...args: any[]) => any
-  resource: (...args: any[]) => any
-}
-
 const routes = resource('/api')
   .sub(
     resource('health')
@@ -121,6 +115,10 @@ async function contractFiles(pkgName, targetDir) {
     const tsconfig = await packageTsConfig(targetDir, {
         include: ['src/**/*.ts', 'src/**/*.tsx'],
         skipLibCheck: true,
+        "target": "ES2022",
+        "module": "ESNext",
+        "declarationMap": true,
+        ModuleResolutionKind: ModuleResolutionKind.Bundler,
     });
     return {
         'package.json': contractPackageJson(pkgName, { includePrepare }),

package/dist/create-package/variants/docker.js

@@ -18,19 +18,29 @@ const DOCKER_SCRIPTS = [
     'docker:clean',
     'docker:reset',
 ];
+function sanitizeContainerName(name) {
+    const normalized = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]/gi, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'rrr-service';
+    return normalized;
+}
 function dockerPackageJson(name, options) {
+    const image = `${name}:latest`;
+    const container = sanitizeContainerName(name);
+    const portVar = '${PORT:-3000}';
     return basePackageJson({
         name,
         scripts: baseScripts('tsx watch src/index.ts', {
             start: 'node dist/index.js',
-            'docker:cli': 'tsx scripts/docker.ts',
-            'docker:build': 'npm run docker:cli -- build',
-            'docker:up': 'npm run docker:cli -- up',
-            'docker:dev': 'npm run docker:cli -- dev',
-            'docker:logs': 'npm run docker:cli -- logs',
-            'docker:stop': 'npm run docker:cli -- stop',
-            'docker:clean': 'npm run docker:cli -- clean',
-            'docker:reset': 'npm run docker:cli -- reset',
+            'docker:build': `docker build -t ${image} .`,
+            'docker:up': `npm run docker:build && PORT=${portVar} docker run -d --rm -p ${portVar}:${portVar} --name ${container} ${image}`,
+            'docker:dev': `npm run docker:build && PORT=${portVar} docker run -d --rm -p ${portVar}:${portVar} --name ${container} ${image} && docker logs -f ${container}`,
+            'docker:logs': `docker logs -f ${container}`,
+            'docker:stop': `docker stop ${container}`,
+            'docker:clean': `docker stop ${container} || true; docker rm -f ${container} || true`,
+            'docker:reset': `npm run docker:clean && docker rmi -f ${image} || true`,
         }, { includePrepare: options?.includePrepare }),
         dependencies: {
             cors: '^2.8.5',
@@ -41,7 +51,6 @@ function dockerPackageJson(name, options) {
             '@types/cors': '^2.8.5',
             '@types/express': '^5.0.6',
             '@types/node': '^24.10.2',
-            'docker-cli-js': '^2.10.0',
         },
     });
 }
@@ -105,7 +114,6 @@ async function dockerFiles(pkgName, targetDir) {
         'package.json': dockerPackageJson(pkgName, { includePrepare }),
         'tsconfig.json': tsconfig,
         'src/index.ts': dockerIndexTs(),
-        'scripts/docker.ts': dockerCliScript(pkgName),
         '.dockerignore': DOCKER_DOCKERIGNORE,
         ...basePackageFiles(),
         Dockerfile: dockerDockerfile(),
@@ -143,145 +151,16 @@ async function dockerFiles(pkgName, targetDir) {
         }),
     };
 }
-function dockerCliScript(pkgName) {
-    return `#!/usr/bin/env tsx
-import { readFile } from 'node:fs/promises'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { Docker } from 'docker-cli-js'
-import { runHelperCli } from '@emeryld/manager/dist/helper-cli.js'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const pkgRoot = path.join(__dirname, '..')
-const pkgRaw = await readFile(path.join(pkgRoot, 'package.json'), 'utf8')
-const pkg = JSON.parse(pkgRaw) as { name?: string }
-const image = \`\${pkg.name ?? '${pkgName}'}:latest\`
-const container =
-  (pkg.name ?? '${pkgName}')
-    .replace(/[^a-z0-9]/gi, '-')
-    .replace(/^-+|-+$/g, '') || 'rrr-service'
-const port = process.env.PORT ?? '3000'
-const docker = new Docker({ spawnOptions: { stdio: 'inherit' } })
-
-async function safe(run: () => Promise<unknown>) {
-  try {
-    await run()
-  } catch (error: unknown) {
-    console.warn(error instanceof Error ? error.message : String(error))
-  }
-}
-
-function printHelp() {
-  console.log(
-    [
-      'Docker helper commands:',
-      '  build   -> docker build -t ${pkgName}:latest .',
-      '  up      -> build then run in detached mode',
-      '  dev     -> build, run, and tail logs',
-      '  run     -> run existing image detached',
-      '  logs    -> docker logs -f <container>',
-      '  stop    -> docker stop <container>',
-      '  clean   -> docker stop/rm <container>',
-      '  reset   -> clean container and remove image',
-    ].join('\\n'),
-  )
-}
-
-await runHelperCli({
-  title: 'Docker helper',
-  argv: process.argv.slice(2),
-  scripts: [
-    {
-      name: 'build',
-      emoji: '🔨',
-      description: 'docker build -t image .',
-      handler: () => docker.command(\`build -t \${image} .\`),
-    },
-    {
-      name: 'up',
-      emoji: '⬆️',
-      description: 'Build + run detached',
-      handler: async () => {
-        await docker.command(\`build -t \${image} .\`)
-        await docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
-      },
-    },
-    {
-      name: 'dev',
-      emoji: '🛠️',
-      description: 'Build, run, tail logs',
-      handler: async () => {
-        await docker.command(\`build -t \${image} .\`)
-        await docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
-        await docker.command(\`logs -f \${container}\`)
-      },
-    },
-    {
-      name: 'run',
-      emoji: '🏃',
-      description: 'Run existing image detached',
-      handler: () =>
-        docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`),
-    },
-    {
-      name: 'logs',
-      emoji: '📜',
-      description: 'Tail docker logs',
-      handler: () => docker.command(\`logs -f \${container}\`),
-    },
-    {
-      name: 'stop',
-      emoji: '🛑',
-      description: 'Stop container',
-      handler: () => docker.command(\`stop \${container}\`),
-    },
-    {
-      name: 'clean',
-      emoji: '🧹',
-      description: 'Stop + remove container',
-      handler: async () => {
-        await safe(() => docker.command(\`stop \${container}\`))
-        await safe(() => docker.command(\`rm -f \${container}\`))
-      },
-    },
-    {
-      name: 'reset',
-      emoji: '♻️',
-      description: 'Clean container and remove image',
-      handler: async () => {
-        await safe(() => docker.command(\`stop \${container}\`))
-        await safe(() => docker.command(\`rm -f \${container}\`))
-        await safe(() => docker.command(\`rmi -f \${image}\`))
-      },
-    },
-    {
-      name: 'help',
-      emoji: 'ℹ️',
-      description: 'Print commands',
-      handler: () => {
-        printHelp()
-      },
-    },
-  ],
-})
-`;
-}
 export const dockerVariant = {
     id: 'rrr-docker',
     label: 'dockerized service',
     defaultDir: 'packages/rrr-docker',
-    summary: 'Express service plus Dockerfile and a helper CLI for local runs.',
-    keyFiles: [
-        'src/index.ts',
-        'scripts/docker.ts',
-        'Dockerfile',
-        'README.md',
-    ],
+    summary: 'Express service plus Dockerfile and docker scripts for local runs.',
+    keyFiles: ['src/index.ts', 'Dockerfile', 'README.md'],
     scripts: DOCKER_SCRIPTS,
     notes: [
         'Use docker:dev or docker:up to build and run the container quickly.',
-        'scripts/docker.ts wraps common docker commands with consistent naming.',
+        'Manager CLI surfaces Docker helpers automatically when a Dockerfile is present.',
     ],
     async scaffold(ctx) {
         const files = await dockerFiles(ctx.pkgName, ctx.targetDir);

package/dist/create-package/variants/empty.js

@@ -17,6 +17,7 @@ function emptyPackageJson(name, options) {
             includePrepare: options?.includePrepare,
         }),
         devDependencies: {
+            '@types/node': '^24.10.2',
             ...BASE_LINT_DEV_DEPENDENCIES,
         },
     });

package/dist/docker.js

@@ -0,0 +1,128 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { runHelperCli } from './helper-cli.js';
+import { run } from './utils/run.js';
+function sanitizeName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]/gi, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+async function ensureDockerfileExists(dockerfilePath) {
+    try {
+        await access(dockerfilePath);
+    }
+    catch {
+        throw new Error(`Dockerfile not found at ${dockerfilePath}`);
+    }
+}
+async function dockerCommand(args, pkg, options) {
+    try {
+        await run('docker', args, { cwd: pkg.path });
+    }
+    catch (error) {
+        if (!options?.ignoreErrors)
+            throw error;
+        // eslint-disable-next-line no-console
+        console.warn(error instanceof Error ? error.message : String(error));
+    }
+}
+function printHelp(image, container) {
+    console.log([
+        'Docker helper commands:',
+        `  build   -> docker build -t ${image} .`,
+        '  up      -> build then run in detached mode',
+        '  dev     -> build, run, and tail logs',
+        '  run     -> run existing image detached',
+        `  logs    -> docker logs -f ${container}`,
+        `  stop    -> docker stop ${container}`,
+        `  clean   -> docker stop/rm ${container}`,
+        `  reset   -> clean container and remove ${image}`,
+    ].join('\n'));
+}
+export async function openDockerHelper(pkg) {
+    const dockerfilePath = pkg.dockerfilePath ?? path.join(pkg.path, 'Dockerfile');
+    await ensureDockerfileExists(dockerfilePath);
+    const image = `${pkg.name ?? pkg.dirName}:latest`;
+    const container = sanitizeName(pkg.name ?? pkg.dirName) || 'rrr-service';
+    const port = process.env.PORT ?? '3000';
+    const dockerfileLabel = path
+        .relative(process.cwd(), dockerfilePath)
+        .replace(/\\/g, '/');
+    const scripts = [
+        {
+            name: 'build',
+            emoji: '🔨',
+            description: 'docker build -t image .',
+            handler: () => dockerCommand(['build', '-t', image, '.'], pkg),
+        },
+        {
+            name: 'up',
+            emoji: '⬆️',
+            description: 'Build + run detached',
+            handler: async () => {
+                await dockerCommand(['build', '-t', image, '.'], pkg);
+                await dockerCommand(['run', '-d', '--rm', '-p', `${port}:${port}`, '--name', container, image], pkg);
+            },
+        },
+        {
+            name: 'dev',
+            emoji: '🛠️',
+            description: 'Build, run, tail logs',
+            handler: async () => {
+                await dockerCommand(['build', '-t', image, '.'], pkg);
+                await dockerCommand(['run', '-d', '--rm', '-p', `${port}:${port}`, '--name', container, image], pkg);
+                await dockerCommand(['logs', '-f', container], pkg);
+            },
+        },
+        {
+            name: 'run',
+            emoji: '🏃',
+            description: 'Run existing image detached',
+            handler: () => dockerCommand(['run', '-d', '--rm', '-p', `${port}:${port}`, '--name', container, image], pkg),
+        },
+        {
+            name: 'logs',
+            emoji: '📜',
+            description: 'Tail docker logs',
+            handler: () => dockerCommand(['logs', '-f', container], pkg),
+        },
+        {
+            name: 'stop',
+            emoji: '🛑',
+            description: 'Stop container',
+            handler: () => dockerCommand(['stop', container], pkg),
+        },
+        {
+            name: 'clean',
+            emoji: '🧹',
+            description: 'Stop + remove container',
+            handler: async () => {
+                await dockerCommand(['stop', container], pkg, { ignoreErrors: true });
+                await dockerCommand(['rm', '-f', container], pkg, { ignoreErrors: true });
+            },
+        },
+        {
+            name: 'reset',
+            emoji: '♻️',
+            description: 'Clean container and remove image',
+            handler: async () => {
+                await dockerCommand(['stop', container], pkg, { ignoreErrors: true });
+                await dockerCommand(['rm', '-f', container], pkg, { ignoreErrors: true });
+                await dockerCommand(['rmi', '-f', image], pkg, { ignoreErrors: true });
+            },
+        },
+        {
+            name: 'help',
+            emoji: 'ℹ️',
+            description: 'Print commands',
+            handler: () => printHelp(image, container),
+        },
+    ];
+    await runHelperCli({
+        title: `Docker helper for ${pkg.name ?? pkg.dirName} (${dockerfileLabel})`,
+        scripts,
+        argv: [],
+    });
+}

package/dist/menu.js

@@ -1,9 +1,12 @@
+// src/menu.js
+import path from 'node:path';
 import { colors, globalEmoji } from './utils/log.js';
 import { updateDependencies, testAll, testSingle, buildAll, buildSingle, } from './workspace.js';
 import { releaseMultiple, releaseSingle } from './release.js';
 import { getOrderedPackages } from './packages.js';
 import { runHelperCli } from './helper-cli.js';
 import { ensureWorkingTreeCommitted } from './preflight.js';
+import { openDockerHelper } from './docker.js';
 import { run } from './utils/run.js';
 function makeManagerStepEntries(targets, packages, state, options) {
     const includeBack = options?.includeBack ?? true;
@@ -93,6 +96,19 @@ function makeManagerStepEntries(targets, packages, state, options) {
 function makePackageScriptEntries(pkg) {
     const scripts = pkg.json?.scripts ?? {};
     const entries = [];
+    if (pkg.dockerfilePath) {
+        const dockerLabel = path
+            .relative(process.cwd(), pkg.dockerfilePath)
+            .replace(/\\/g, '/');
+        entries.push({
+            name: `Dockerfile (${dockerLabel})`,
+            emoji: '🐳',
+            description: 'manager -> opens the docker cli',
+            handler: async () => {
+                await openDockerHelper(pkg);
+            },
+        });
+    }
     Object.entries(scripts)
         .sort(([a], [b]) => a.localeCompare(b))
         .forEach(([name, command]) => {
@@ -147,9 +163,20 @@ export async function runStepLoop(targets, packages) {
                     emoji: globalEmoji,
                     description: 'update/test/build/publish',
                     handler: async () => {
-                        const managerEntries = makeManagerStepEntries(targets, packages, state, {
-                            includeBack: false,
-                        });
+                        const managerEntries = [
+                            ...makeManagerStepEntries(targets, packages, state, {
+                                includeBack: false,
+                            }),
+                            {
+                                name: 'back',
+                                emoji: '↩️',
+                                description: 'Return to package scripts',
+                                handler: () => {
+                                    // no state change; just exit to the package scripts menu
+                                    state.lastStep = undefined;
+                                },
+                            },
+                        ];
                         await runHelperCli({
                             title: `Manager actions for ${pkg.name}`,
                             scripts: managerEntries,

package/dist/packages.js

@@ -1,7 +1,7 @@
 // src/packages.js
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { readdir, readFile } from 'node:fs/promises';
+import { readdir, readFile, stat } from 'node:fs/promises';
 const rootDir = process.cwd();
 const ignoredDirs = new Set([
     'node_modules',
@@ -181,6 +181,16 @@ export async function loadPackages() {
                 byName.get((pkgName ?? '').toLowerCase());
             const substitute = meta?.substitute ?? deriveSubstitute(pkgName) ?? path.basename(pkgDir);
             const color = meta?.color ?? colorFromSeed(pkgName);
+            let dockerfilePath;
+            try {
+                const candidate = path.join(pkgDir, 'Dockerfile');
+                const stats = await stat(candidate);
+                if (stats.isFile())
+                    dockerfilePath = candidate;
+            }
+            catch {
+                // ignore missing Dockerfile
+            }
             packages.push({
                 dirName: path.basename(pkgDir),
                 relativeDir: relativePath,
@@ -191,6 +201,7 @@ export async function loadPackages() {
                 name: pkgName ?? path.basename(pkgDir),
                 substitute,
                 color,
+                dockerfilePath,
             });
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",