@emeryld/manager 0.2.3 → 0.3.0

package/bin/manager-cli.js

@@ -1,28 +1,46 @@
 #!/usr/bin/env node
 import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
 import path from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import { fileURLToPath } from 'node:url'
 import { createRequire } from 'node:module'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 const packageRoot = path.resolve(__dirname, '..')
 const tsconfigPath = path.join(packageRoot, 'tsconfig.base.json')
-const entryPoint = path.join(packageRoot, 'src', 'publish.ts')
+const compiledEntry = path.join(packageRoot, 'dist', 'publish.js')
+const sourceEntry = path.join(packageRoot, 'src', 'publish.ts')
+const args = process.argv.slice(2)
 
-const require = createRequire(import.meta.url)
-const tsNodeLoader = require.resolve('ts-node/esm.mjs')
-const registerCode = [
-  'import { register } from "node:module";',
-  'import { pathToFileURL } from "node:url";',
-   `register(${JSON.stringify(tsNodeLoader)}, pathToFileURL(${JSON.stringify(packageRoot + path.sep)}));`,
-].join(' ')
-const registerImport = `data:text/javascript,${encodeURIComponent(registerCode)}`
+const hasCompiledEntry = existsSync(compiledEntry)
+const hasSourceEntry = existsSync(sourceEntry)
 
-const nodeArgs = ['--import', registerImport, entryPoint, ...process.argv.slice(2)]
-const execOptions = {
-  env: { ...process.env, TS_NODE_PROJECT: tsconfigPath },
-  stdio: 'inherit',
+let nodeArgs
+let execOptions
+
+if (hasCompiledEntry) {
+  nodeArgs = [compiledEntry, ...args]
+  execOptions = { env: process.env, stdio: 'inherit' }
+} else if (hasSourceEntry) {
+  const require = createRequire(import.meta.url)
+  const tsNodeLoader = require.resolve('ts-node/esm.mjs')
+  const registerCode = [
+    'import { register } from "node:module";',
+    'import { pathToFileURL } from "node:url";',
+    `register(${JSON.stringify(tsNodeLoader)}, pathToFileURL(${JSON.stringify(packageRoot + path.sep)}));`,
+  ].join(' ')
+  const registerImport = `data:text/javascript,${encodeURIComponent(registerCode)}`
+  nodeArgs = ['--import', registerImport, sourceEntry, ...args]
+  execOptions = {
+    env: { ...process.env, TS_NODE_PROJECT: tsconfigPath },
+    stdio: 'inherit',
+  }
+} else {
+  console.error(
+    `manager-cli could not find a publish entry point (checked ${compiledEntry} and ${sourceEntry}).`,
+  )
+  process.exit(1)
 }
 
 const child = spawnSync(process.execPath, nodeArgs, execOptions)

package/dist/create-package.js

@@ -0,0 +1,388 @@
+import { access, mkdir, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { askLine, promptSingleKey } from './prompts.js';
+import { colors, logGlobal } from './utils/log.js';
+const VARIANTS = [
+    { id: 'rrr-contract', label: 'rrr contract', defaultDir: 'packages/rrr-contract' },
+    { id: 'rrr-server', label: 'rrr server', defaultDir: 'packages/rrr-server' },
+    { id: 'rrr-client', label: 'rrr client', defaultDir: 'packages/rrr-client' },
+];
+const workspaceRoot = process.cwd();
+function derivePackageName(targetDir) {
+    const base = path.basename(targetDir) || 'rrr-package';
+    return base;
+}
+async function ensureTargetDir(targetDir) {
+    try {
+        const stats = await stat(targetDir);
+        if (!stats.isDirectory()) {
+            throw new Error(`Target "${targetDir}" exists and is not a directory.`);
+        }
+        const entries = await readdir(targetDir);
+        if (entries.length > 0) {
+            logGlobal(`Target ${path.relative(workspaceRoot, targetDir)} is not empty; existing files will be preserved.`, colors.yellow);
+        }
+    }
+    catch (error) {
+        if (error &&
+            typeof error === 'object' &&
+            error.code === 'ENOENT') {
+            await mkdir(targetDir, { recursive: true });
+            return;
+        }
+        throw error;
+    }
+}
+async function writeFileIfMissing(baseDir, relative, contents) {
+    const fullPath = path.join(baseDir, relative);
+    await mkdir(path.dirname(fullPath), { recursive: true });
+    try {
+        await access(fullPath);
+        const rel = path.relative(workspaceRoot, fullPath);
+        console.log(`  skipped ${rel} (already exists)`);
+        return 'skipped';
+    }
+    catch (error) {
+        if (error &&
+            typeof error === 'object' &&
+            error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await writeFile(fullPath, contents, 'utf8');
+    const rel = path.relative(workspaceRoot, fullPath);
+    console.log(`  created ${rel}`);
+    return 'created';
+}
+function contractIndexTs() {
+    return `import { defineSocketEvents, finalize, resource } from '@emeryld/rrroutes-contract'
+import { z } from 'zod'
+
+const routes = resource('/api')
+  .sub(
+    resource('health')
+      .get({
+        outputSchema: z.object({
+          status: z.literal('ok'),
+          html: z.string().optional(),
+        }),
+        description: 'Basic GET health probe for uptime + docs.',
+      })
+      .post({
+        bodySchema: z.object({
+          echo: z.string().optional(),
+        }),
+        outputSchema: z.object({
+          status: z.literal('ok'),
+          received: z.string().optional(),
+        }),
+        description: 'POST health probe that echoes a payload.',
+      })
+      .done(),
+  )
+  .done()
+
+export const registry = finalize(routes)
+
+const sockets = defineSocketEvents(
+  {
+    joinMetaMessage: z.object({ room: z.string().optional() }),
+    leaveMetaMessage: z.object({ room: z.string().optional() }),
+    pingPayload: z.object({
+      note: z.string().default('ping'),
+      sentAt: z.string(),
+    }),
+    pongPayload: z.object({
+      ok: z.boolean(),
+      receivedAt: z.string(),
+      echo: z.string().optional(),
+    }),
+  },
+  {
+    'health:connected': {
+      message: z.object({
+        socketId: z.string(),
+        at: z.string(),
+        message: z.string(),
+      }),
+    },
+    'health:ping': {
+      message: z.object({
+        note: z.string().default('ping'),
+      }),
+    },
+    'health:pong': {
+      message: z.object({
+        ok: z.literal(true),
+        at: z.string(),
+        echo: z.string().optional(),
+      }),
+    },
+  },
+)
+
+export const socketConfig = sockets.config
+export const socketEvents = sockets.events
+export type AppRegistry = typeof registry
+`;
+}
+function serverIndexTs(contractImport) {
+    return `import 'dotenv/config'
+import http from 'node:http'
+import express from 'express'
+import cors from 'cors'
+import { createRRRoute } from '@emeryld/rrroutes-server'
+import { registry } from '${contractImport}'
+
+const app = express()
+app.use(cors({ origin: '*', credentials: true }))
+app.use(express.json())
+
+app.get('/', (_req, res) => {
+  res.send('<h1>rrr server ready</h1>')
+})
+
+const routes = createRRRoute(app, {
+  buildCtx: async () => ({
+    requestId: Math.random().toString(36).slice(2),
+  }),
+  debug:
+    process.env.NODE_ENV === 'development'
+      ? { request: true, handler: true }
+      : undefined,
+})
+
+routes.registerControllers(registry, {
+  'GET /api/health': {
+    handler: async ({ ctx }) => ({
+      out: {
+        status: 'ok',
+        requestId: ctx.requestId,
+        at: new Date().toISOString(),
+      },
+    }),
+  },
+})
+
+const PORT = Number.parseInt(process.env.PORT ?? '4000', 10)
+const server = http.createServer(app)
+
+server.listen(PORT, () => {
+  console.log(\`rrr server listening on http://localhost:\${PORT}\`)
+})
+`;
+}
+function clientIndexTs(contractImport) {
+    return `import { QueryClient } from '@tanstack/react-query'
+import { createRouteClient } from '@emeryld/rrroutes-client'
+import { registry } from '${contractImport}'
+
+const baseUrl = process.env.RRR_API_URL ?? 'http://localhost:4000'
+export const queryClient = new QueryClient()
+
+export const routeClient = createRouteClient({
+  baseUrl,
+  queryClient,
+  environment: process.env.NODE_ENV === 'production' ? 'production' : 'development',
+})
+
+export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
+export const healthPost = routeClient.build(registry.byKey['POST /api/health'])
+`;
+}
+function baseTsConfig(options) {
+    return `${JSON.stringify({
+        compilerOptions: {
+            target: 'ES2020',
+            module: 'NodeNext',
+            moduleResolution: 'NodeNext',
+            outDir: 'dist',
+            rootDir: 'src',
+            declaration: true,
+            sourceMap: true,
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            lib: options?.lib,
+            types: options?.types,
+        },
+        include: ['src/**/*'],
+    }, null, 2)}\n`;
+}
+function contractPackageJson(name) {
+    return `${JSON.stringify({
+        name,
+        version: '0.1.0',
+        private: false,
+        type: 'module',
+        main: 'dist/index.js',
+        types: 'dist/index.d.ts',
+        exports: {
+            '.': {
+                types: './dist/index.d.ts',
+                import: './dist/index.js',
+            },
+        },
+        files: ['dist'],
+        scripts: {
+            build: 'tsc -p tsconfig.json',
+            typecheck: 'tsc -p tsconfig.json --noEmit',
+        },
+        dependencies: {
+            '@emeryld/rrroutes-contract': '^2.5.2',
+            zod: '^4.2.1',
+        },
+        devDependencies: {
+            typescript: '^5.9.3',
+        },
+    }, null, 2)}\n`;
+}
+function serverPackageJson(name) {
+    return `${JSON.stringify({
+        name,
+        version: '0.1.0',
+        private: false,
+        type: 'module',
+        main: 'dist/index.js',
+        types: 'dist/index.d.ts',
+        files: ['dist'],
+        scripts: {
+            dev: 'node --loader ts-node/esm src/index.ts',
+            build: 'tsc -p tsconfig.json',
+            typecheck: 'tsc -p tsconfig.json --noEmit',
+            start: 'node dist/index.js',
+        },
+        dependencies: {
+            '@emeryld/rrroutes-contract': '^2.5.2',
+            '@emeryld/rrroutes-server': '^2.4.1',
+            cors: '^2.8.5',
+            dotenv: '^16.4.5',
+            express: '^5.1.0',
+            zod: '^4.2.1',
+        },
+        devDependencies: {
+            '@types/cors': '^2.8.5',
+            '@types/express': '^5.0.6',
+            '@types/node': '^24.10.2',
+            'ts-node': '^10.9.2',
+            typescript: '^5.9.3',
+        },
+    }, null, 2)}\n`;
+}
+function clientPackageJson(name) {
+    return `${JSON.stringify({
+        name,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        main: 'dist/index.js',
+        types: 'dist/index.d.ts',
+        files: ['dist'],
+        scripts: {
+            build: 'tsc -p tsconfig.json',
+            typecheck: 'tsc -p tsconfig.json --noEmit',
+        },
+        dependencies: {
+            '@emeryld/rrroutes-client': '^2.5.3',
+            '@emeryld/rrroutes-contract': '^2.5.2',
+            '@tanstack/react-query': '^5.90.12',
+            'socket.io-client': '^4.8.3',
+        },
+        devDependencies: {
+            '@types/node': '^24.10.2',
+            typescript: '^5.9.3',
+        },
+    }, null, 2)}\n`;
+}
+function contractFiles(pkgName) {
+    return {
+        'package.json': contractPackageJson(pkgName),
+        'tsconfig.json': baseTsConfig(),
+        'src/index.ts': contractIndexTs(),
+        'README.md': `# ${pkgName}
+
+Contract package scaffolded by manager-cli.
+- edit src/index.ts to add routes and socket events
+- build with \`npm run build\`
+- import the registry in your server/client packages
+`,
+    };
+}
+function serverFiles(pkgName, contractImport) {
+    return {
+        'package.json': serverPackageJson(pkgName),
+        'tsconfig.json': baseTsConfig({ types: ['node'] }),
+        'src/index.ts': serverIndexTs(contractImport),
+        '.env.example': 'PORT=4000\n',
+        'README.md': `# ${pkgName}
+
+Starter RRRoutes server scaffold.
+- update the contract import in src/index.ts if needed (${contractImport})
+- run \`npm install\` then \`npm run dev\` to start the API
+`,
+    };
+}
+function clientFiles(pkgName, contractImport) {
+    return {
+        'package.json': clientPackageJson(pkgName),
+        'tsconfig.json': baseTsConfig({ lib: ['ES2020', 'DOM'], types: ['node'] }),
+        'src/index.ts': clientIndexTs(contractImport),
+        'README.md': `# ${pkgName}
+
+Starter RRRoutes client scaffold.
+- update the contract import in src/index.ts if needed (${contractImport})
+- the generated QueryClient is exported from src/index.ts
+`,
+    };
+}
+function resolveContractImport(variant) {
+    if (variant === 'rrr-contract')
+        return '';
+    return '@your-scope/contract';
+}
+async function scaffoldVariant(variant, targetDir, pkgName) {
+    const contractImport = resolveContractImport(variant);
+    let files;
+    if (variant === 'rrr-contract')
+        files = contractFiles(pkgName);
+    else if (variant === 'rrr-server')
+        files = serverFiles(pkgName, contractImport);
+    else
+        files = clientFiles(pkgName, contractImport);
+    for (const [relative, contents] of Object.entries(files)) {
+        // eslint-disable-next-line no-await-in-loop
+        await writeFileIfMissing(targetDir, relative, contents);
+    }
+}
+async function promptForVariant() {
+    const messageLines = [
+        'Pick a package template:',
+        VARIANTS.map((opt, idx) => `  [${idx + 1}] ${opt.label}`).join('\n'),
+        'Enter 1, 2, or 3: ',
+    ];
+    const message = `${messageLines.join('\n')}`;
+    const variant = await promptSingleKey(message, (key) => {
+        if (key === '1')
+            return VARIANTS[0];
+        if (key === '2')
+            return VARIANTS[1];
+        if (key === '3')
+            return VARIANTS[2];
+        return undefined;
+    });
+    return variant;
+}
+async function promptForTargetDir(fallback) {
+    const answer = await askLine(`Path for the new package? (${fallback}): `);
+    const normalized = answer || fallback;
+    return path.resolve(workspaceRoot, normalized);
+}
+export async function createRrrPackage() {
+    const variant = await promptForVariant();
+    const targetDir = await promptForTargetDir(variant.defaultDir);
+    await ensureTargetDir(targetDir);
+    const pkgName = derivePackageName(targetDir);
+    logGlobal(`Creating ${variant.label} in ${path.relative(workspaceRoot, targetDir) || '.'}`, colors.green);
+    await scaffoldVariant(variant.id, targetDir, pkgName);
+    logGlobal('Scaffold complete. Install deps and start building!', colors.green);
+}

package/dist/manager-cli.js

@@ -1,28 +1,46 @@
 #!/usr/bin/env node
 import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
 import path from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import { fileURLToPath } from 'node:url'
 import { createRequire } from 'node:module'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 const packageRoot = path.resolve(__dirname, '..')
 const tsconfigPath = path.join(packageRoot, 'tsconfig.base.json')
-const entryPoint = path.join(packageRoot, 'src', 'publish.ts')
+const compiledEntry = path.join(packageRoot, 'dist', 'publish.js')
+const sourceEntry = path.join(packageRoot, 'src', 'publish.ts')
+const args = process.argv.slice(2)
 
-const require = createRequire(import.meta.url)
-const tsNodeLoader = require.resolve('ts-node/esm.mjs')
-const registerCode = [
-  'import { register } from "node:module";',
-  'import { pathToFileURL } from "node:url";',
-   `register(${JSON.stringify(tsNodeLoader)}, pathToFileURL(${JSON.stringify(packageRoot + path.sep)}));`,
-].join(' ')
-const registerImport = `data:text/javascript,${encodeURIComponent(registerCode)}`
+const hasCompiledEntry = existsSync(compiledEntry)
+const hasSourceEntry = existsSync(sourceEntry)
 
-const nodeArgs = ['--import', registerImport, entryPoint, ...process.argv.slice(2)]
-const execOptions = {
-  env: { ...process.env, TS_NODE_PROJECT: tsconfigPath },
-  stdio: 'inherit',
+let nodeArgs
+let execOptions
+
+if (hasCompiledEntry) {
+  nodeArgs = [compiledEntry, ...args]
+  execOptions = { env: process.env, stdio: 'inherit' }
+} else if (hasSourceEntry) {
+  const require = createRequire(import.meta.url)
+  const tsNodeLoader = require.resolve('ts-node/esm.mjs')
+  const registerCode = [
+    'import { register } from "node:module";',
+    'import { pathToFileURL } from "node:url";',
+    `register(${JSON.stringify(tsNodeLoader)}, pathToFileURL(${JSON.stringify(packageRoot + path.sep)}));`,
+  ].join(' ')
+  const registerImport = `data:text/javascript,${encodeURIComponent(registerCode)}`
+  nodeArgs = ['--import', registerImport, sourceEntry, ...args]
+  execOptions = {
+    env: { ...process.env, TS_NODE_PROJECT: tsconfigPath },
+    stdio: 'inherit',
+  }
+} else {
+  console.error(
+    `manager-cli could not find a publish entry point (checked ${compiledEntry} and ${sourceEntry}).`,
+  )
+  process.exit(1)
 }
 
 const child = spawnSync(process.execPath, nodeArgs, execOptions)

package/dist/menu.js

@@ -95,6 +95,8 @@ export function buildPackageSelectionMenu(packages, onStepComplete) {
             onStepComplete?.(step);
         },
     }));
+    if (ordered.length === 0)
+        return entries;
     entries.push({
         name: 'All packages',
         emoji: globalEmoji,

package/dist/packages.js

@@ -37,7 +37,7 @@ function deriveSubstitute(name) {
         return '';
     const segments = trimmed.split(/[@\/\-]/).filter(Boolean);
     const transformed = segments
-        .map((segment) => segment.slice(0, 2))
+        .map((segment) => segment)
         .filter(Boolean)
         .join(' ');
     return transformed || trimmed;

package/dist/publish.js

@@ -5,6 +5,8 @@ import { getOrderedPackages, loadPackages, resolvePackage } from './packages.js'
 import { releaseMultiple, releaseSingle, } from './release.js';
 import { ensureWorkingTreeCommitted } from './preflight.js';
 import { publishCliState } from './prompts.js';
+import { createRrrPackage } from './create-package.js';
+import { colors, logGlobal } from './utils/log.js';
 function resolveTargetsFromArg(packages, arg) {
     if (arg.toLowerCase() === 'all')
         return getOrderedPackages(packages);
@@ -89,14 +91,27 @@ function optsFromParsed(p) {
 }
 async function runPackageSelectionLoop(packages, helperArgs) {
     let argv = [...helperArgs];
+    let currentPackages = packages;
     // eslint-disable-next-line no-constant-condition
     while (true) {
         let lastStep;
         await runHelperCli({
             title: 'Pick one of the packages or all',
-            scripts: buildPackageSelectionMenu(packages, (step) => {
-                lastStep = step;
-            }),
+            scripts: [
+                ...buildPackageSelectionMenu(currentPackages, (step) => {
+                    lastStep = step;
+                }),
+                {
+                    name: 'Create package',
+                    emoji: '✨',
+                    description: 'Scaffold a new rrr package (contract/server/client)',
+                    handler: async () => {
+                        await createRrrPackage();
+                        currentPackages = await loadPackages();
+                        lastStep = 'back';
+                    },
+                },
+            ],
             argv, // pass through CLI args only once; subsequent loops rely on selection
         });
         argv = [];
@@ -108,10 +123,11 @@ async function main() {
     const cliArgs = process.argv.slice(2);
     const parsed = parseCliArgs(cliArgs);
     const packages = await loadPackages();
-    if (packages.length === 0)
-        throw new Error('No packages found in ./packages');
     // If user provided non-interactive flags, run headless path
     if (parsed.nonInteractive) {
+        if (packages.length === 0) {
+            throw new Error('No packages found in ./packages');
+        }
         publishCliState.autoConfirmAll = true;
         if (!parsed.selectionArg) {
             throw new Error('Non-interactive mode requires a package selection: <pkg> or "all".');
@@ -128,6 +144,9 @@ async function main() {
             await releaseSingle(targets[0], packages, opts);
         return;
     }
+    if (packages.length === 0) {
+        logGlobal('No packages found in ./packages. Use "Create package" to scaffold one.', colors.yellow);
+    }
     // Interactive flow (unchanged): selection menu then step menu
     if (parsed.selectionArg) {
         const targets = resolveTargetsFromArg(packages, parsed.selectionArg);

package/package.json

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