@noego/wood 0.0.1

package/bin/wood.js

@@ -0,0 +1,572 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync, copyFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+import { globSync } from 'glob';
+import chokidar from 'chokidar';
+
+// ---------------------------------------------------------------------------
+// Resolve the built @noego/wood dist directory (sibling to bin/)
+// ---------------------------------------------------------------------------
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const distDir = path.resolve(__dirname, '..', 'dist');
+
+// Dynamic import from the built dist
+const {
+  parseOperationsFile,
+  parseViewsFile,
+  generatePreload,
+  generateRuntime,
+  generateRendererApp,
+} = await import(path.join(distDir, 'index.js'));
+const {
+  resolveWoodRemoteDebuggingPort,
+  writeWoodDevMetadata,
+  removeWoodDevMetadata,
+} = await import(path.join(distDir, 'dev', 'dev_metadata.js'));
+
+// ---------------------------------------------------------------------------
+// CLI entry
+// ---------------------------------------------------------------------------
+const command = process.argv[2];
+const extraArgs = process.argv.slice(3);
+
+const COMMANDS = ['dev', 'build'];
+
+if (!command || !COMMANDS.includes(command)) {
+  console.log('Usage: wood <command>');
+  console.log('');
+  console.log('Commands:');
+  console.log('  dev     Generate code and start electron-vite in development mode');
+  console.log('  build   Generate code and run electron-vite production build');
+  console.log('');
+  console.log('Options are passed through to electron-vite.');
+  process.exit(command ? 1 : 0);
+}
+
+// ---------------------------------------------------------------------------
+// Resolve the user's project from cwd
+// ---------------------------------------------------------------------------
+const projectRoot = process.cwd();
+
+// ---------------------------------------------------------------------------
+// 1. Read wood.config.yml
+// ---------------------------------------------------------------------------
+const configPath = path.resolve(projectRoot, 'wood.config.yml');
+if (!existsSync(configPath)) {
+  console.error('[wood] wood.config.yml not found in', projectRoot);
+  process.exit(1);
+}
+
+const configRaw = yaml.load(readFileSync(configPath, 'utf-8'));
+if (!configRaw || typeof configRaw !== 'object') {
+  console.error('[wood] Invalid wood.config.yml');
+  process.exit(1);
+}
+
+const config = configRaw;
+const mainSection = config.main;
+const rendererSection = config.renderer;
+
+if (!mainSection || !mainSection.openapi || !mainSection.controllers) {
+  console.error('[wood] wood.config.yml must define main.openapi and main.controllers');
+  process.exit(1);
+}
+
+if (!rendererSection || !rendererSection.openapi || !rendererSection.componentDir || !rendererSection.controllers) {
+  console.error('[wood] wood.config.yml must define renderer.openapi, renderer.componentDir, and renderer.controllers');
+  process.exit(1);
+}
+
+if (rendererSection.entry !== undefined) {
+  if (typeof rendererSection.entry !== 'string' || rendererSection.entry.trim().length === 0) {
+    console.error('[wood] wood.config.yml renderer.entry must be a non-empty string when provided');
+    process.exit(1);
+  }
+}
+
+const outDir = path.resolve(projectRoot, config.outDir || 'out');
+
+function hasGlobPattern(value) {
+  return /[*?[\]{}]/.test(value);
+}
+
+function resolveYamlFiles(yamlPath) {
+  const resolved = path.resolve(projectRoot, yamlPath);
+
+  if (!existsSync(resolved)) {
+    throw new Error(`[wood] YAML file not found: ${resolved}`);
+  }
+
+  const content = readFileSync(resolved, 'utf-8');
+  const doc = yaml.load(content);
+
+  if (doc && doc.stitch && Array.isArray(doc.stitch)) {
+    const baseDir = path.dirname(resolved);
+    const files = [];
+    const seen = new Set();
+
+    for (const entry of doc.stitch) {
+      const entryPath = path.resolve(baseDir, String(entry));
+      let matches = [];
+
+      if (hasGlobPattern(String(entry))) {
+        matches = globSync(entryPath.replace(/\\/g, '/'), {
+          absolute: true,
+          nodir: true,
+        }).sort();
+      } else if (existsSync(entryPath)) {
+        matches = [entryPath];
+      }
+
+      if (matches.length === 0) {
+        throw new Error(`[wood] Stitch entry not found: ${entry} (resolved to ${entryPath})`);
+      }
+
+      for (const file of matches) {
+        if (!seen.has(file)) {
+          seen.add(file);
+          files.push(file);
+        }
+      }
+    }
+
+    return { stitchPath: resolved, yamlFiles: files };
+  }
+
+  return { stitchPath: resolved, yamlFiles: [resolved] };
+}
+
+function parseAllOperations(operationFiles) {
+  const allOperations = new Map();
+  for (const file of operationFiles) {
+    const ops = parseOperationsFile(file);
+    ops.forEach((value, key) => allOperations.set(key, value));
+  }
+  return allOperations;
+}
+
+function parseAllViews(viewFiles) {
+  const dedupedViews = new Map();
+
+  for (const file of viewFiles) {
+    const views = parseViewsFile(file);
+    for (const view of views) {
+      const key = `${view.windowName}.${view.pageName}`;
+      dedupedViews.set(key, view);
+    }
+  }
+
+  return Array.from(dedupedViews.values());
+}
+
+function generateWindowConfigSnippet(rawWindows) {
+  const windowDefs = rawWindows && typeof rawWindows === 'object' ? rawWindows : {};
+  const serializedDefs = JSON.stringify(windowDefs, null, 2);
+
+  return `export type WoodWindowConfig = {
+  title: string;
+  width: number;
+  height: number;
+  defaultRoute?: string;
+  frame?: boolean;
+  transparent?: boolean;
+  resizable?: boolean;
+  alwaysOnTop?: boolean;
+  minWidth?: number;
+  minHeight?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  show?: boolean;
+  parent?: string;
+  modal?: boolean;
+  vibrancy?: string;
+  backgroundMaterial?: string;
+  backgroundColor?: string;
+  rememberBounds?: boolean;
+  contextMenu?: 'native' | 'custom';
+};
+
+export const WINDOW_DEFS = ${serializedDefs} as Record<string, WoodWindowConfig>;
+
+export function getWindowDef(windowId = 'main'): WoodWindowConfig {
+  const def = WINDOW_DEFS[windowId];
+  if (!def) {
+    throw new Error(\`Window "\${windowId}" not defined in wood.config.yml\`);
+  }
+  return def;
+}
+`;
+}
+
+function computeImportPath(fromDir, toFile) {
+  let rel = path.relative(fromDir, toFile);
+  if (!rel.startsWith('.')) {
+    rel = `./${rel}`;
+  }
+  rel = rel.replace(/\\/g, '/');
+  if (rel.endsWith('.ts')) {
+    return rel.slice(0, -3);
+  }
+  if (rel.endsWith('.js')) {
+    return rel.slice(0, -3);
+  }
+  return rel;
+}
+
+function readProjectName() {
+  const packageJsonPath = path.resolve(projectRoot, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    return path.basename(projectRoot);
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    if (parsed && typeof parsed.name === 'string' && parsed.name.trim().length > 0) {
+      return parsed.name.trim();
+    }
+  } catch {
+    // Fall back to directory name.
+  }
+  return path.basename(projectRoot);
+}
+
+function generateMainAppCode() {
+  const mainCodegenOutDir = path.resolve(projectRoot, 'src', 'main', 'generated');
+  const appBootImport = computeImportPath(mainCodegenOutDir, path.resolve(projectRoot, config.app.boot));
+  const mainEntryImport = computeImportPath(mainCodegenOutDir, path.resolve(projectRoot, mainSection.entry));
+  const scope = readProjectName().replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+  const controllersDir = String(mainSection.controllers).replace(/\\/g, '/').replace(/'/g, "\\'");
+  const middlewareDir = String(mainSection.middleware).replace(/\\/g, '/').replace(/'/g, "\\'");
+  const outDirValue = String(config.outDir || 'out').replace(/\\/g, '/').replace(/'/g, "\\'");
+
+  const code = `// AUTO-GENERATED by @noego/wood -- do not edit
+import type { StartWoodMainOptions, WoodMainAppBootResult } from '@noego/wood/main';
+import appBootModule from '${appBootImport}';
+import mainBootModule from '${mainEntryImport}';
+import { registerRuntime, WINDOW_DEFS } from '../runtime.generated';
+
+type HookFn = (...args: any[]) => unknown;
+type MainBootCleanup = () => void | Promise<void>;
+
+function assertHook(name: string, value: unknown): HookFn {
+  if (typeof value !== 'function') {
+    throw new Error(\`\${name} must default export a function.\`);
+  }
+  return value as HookFn;
+}
+
+const appBoot = assertHook('app.boot', appBootModule);
+const mainBoot = assertHook('main.entry', mainBootModule);
+
+async function runAppBoot(
+  context: Parameters<NonNullable<StartWoodMainOptions['appBoot']>>[0],
+): Promise<void | WoodMainAppBootResult> {
+  return await (
+    appBoot(context) as void
+    | WoodMainAppBootResult
+    | Promise<void | WoodMainAppBootResult>
+  );
+}
+
+async function runMainBoot(
+  appBootResult: Parameters<NonNullable<StartWoodMainOptions['mainBoot']>>[0],
+  context: Parameters<NonNullable<StartWoodMainOptions['mainBoot']>>[1],
+): Promise<void | MainBootCleanup> {
+  return await (
+    mainBoot(appBootResult, context) as void
+    | MainBootCleanup
+    | Promise<void | MainBootCleanup>
+  );
+}
+
+export const app: StartWoodMainOptions = {
+  scope: '${scope}',
+  outDir: '${outDirValue}',
+  registerRuntime,
+  windowDefs: WINDOW_DEFS,
+  controllersDir: '${controllersDir}',
+  middlewareDir: '${middlewareDir}',
+  appBoot: runAppBoot,
+  mainBoot: runMainBoot,
+};
+`;
+
+  return { mainCodegenOutDir, mainAppCode: code };
+}
+
+function buildCodegenArtifacts(allOperations, allViews) {
+  const mainControllersDir = path.resolve(projectRoot, mainSection.controllers);
+  const codegenOutDir = path.resolve(projectRoot, 'src', 'main');
+
+  const runtimeCode = generateRuntime(allOperations, {
+    controllersDir: mainControllersDir,
+    outDir: codegenOutDir,
+  });
+  const windowConfigSnippet = generateWindowConfigSnippet(config.windows);
+  const runtimeWithWindowConfigCode = `${runtimeCode}\n\n${windowConfigSnippet}`;
+
+  const preloadCode = generatePreload(allOperations);
+
+  const rendererComponentDir = path.resolve(projectRoot, rendererSection.componentDir);
+  const rendererCodegenOutDir = path.resolve(projectRoot, rendererSection.componentDir, 'generated');
+
+  const rendererAppCode = generateRendererApp(allViews, {
+    componentDir: rendererComponentDir,
+    outDir: rendererCodegenOutDir,
+    entryViewKey: rendererSection.entry,
+  });
+
+  const { mainCodegenOutDir, mainAppCode } = generateMainAppCode();
+
+  return {
+    codegenOutDir,
+    runtimeCode: runtimeWithWindowConfigCode,
+    preloadCode,
+    rendererCodegenOutDir,
+    rendererAppCode,
+    mainCodegenOutDir,
+    mainAppCode,
+  };
+}
+
+function writeCodegenArtifacts(artifacts) {
+  mkdirSync(artifacts.codegenOutDir, { recursive: true });
+
+  // Remove legacy artifacts that are no longer generated.
+  for (const staleFile of ['controllers.generated.ts', 'wood.d.ts', 'wood.mock.ts']) {
+    rmSync(path.join(artifacts.codegenOutDir, staleFile), { force: true });
+  }
+
+  writeFileSync(path.join(artifacts.codegenOutDir, 'runtime.generated.ts'), artifacts.runtimeCode);
+  console.log('[wood] Generated runtime.generated.ts');
+
+  writeFileSync(path.join(artifacts.codegenOutDir, 'preload.generated.ts'), artifacts.preloadCode);
+  console.log('[wood] Generated preload.generated.ts');
+
+  mkdirSync(artifacts.rendererCodegenOutDir, { recursive: true });
+
+  writeFileSync(
+    path.join(artifacts.rendererCodegenOutDir, 'app.ts'),
+    artifacts.rendererAppCode,
+  );
+  console.log('[wood] Generated ui/generated/app.ts');
+
+  mkdirSync(artifacts.mainCodegenOutDir, { recursive: true });
+  writeFileSync(
+    path.join(artifacts.mainCodegenOutDir, 'app.ts'),
+    artifacts.mainAppCode,
+  );
+  console.log('[wood] Generated src/main/generated/app.ts');
+}
+
+function copyAssets(stitchPath, operationFiles) {
+  const serverOutDir = path.join(outDir, 'server');
+
+  // Clean stale server artifacts (electron-vite cleans main/preload/renderer)
+  rmSync(serverOutDir, { recursive: true, force: true });
+
+  mkdirSync(serverOutDir, { recursive: true });
+  copyFileSync(stitchPath, path.join(serverOutDir, path.basename(stitchPath)));
+  console.log(`[wood] Copied ${path.basename(stitchPath)} → out/server/`);
+
+  const opsOutDir = path.join(serverOutDir, 'operations');
+  mkdirSync(opsOutDir, { recursive: true });
+  for (const opFile of operationFiles) {
+    copyFileSync(opFile, path.join(opsOutDir, path.basename(opFile)));
+  }
+  console.log(`[wood] Copied ${operationFiles.length} operation file(s) → out/server/operations/`);
+
+  const assets = Array.isArray(config.assets) ? config.assets : [];
+  if (assets.length > 0) {
+    const matched = new Set();
+    for (const pattern of assets) {
+      const files = globSync(pattern, { cwd: projectRoot, absolute: true, nodir: true, dot: true });
+      for (const file of files) {
+        const rel = path.relative(projectRoot, file);
+        if (rel.startsWith('..')) continue;
+        if (matched.has(rel)) continue;
+        matched.add(rel);
+        const dest = path.join(outDir, rel);
+        mkdirSync(path.dirname(dest), { recursive: true });
+        copyFileSync(file, dest);
+      }
+    }
+    console.log(`[wood] Copied ${matched.size} asset file(s) from ${assets.length} pattern(s)`);
+  }
+}
+
+function runGeneration(reason) {
+  const { stitchPath: operationsStitchPath, yamlFiles: operationFiles } = resolveYamlFiles(mainSection.openapi);
+  const { yamlFiles: viewFiles } = resolveYamlFiles(rendererSection.openapi);
+
+  const allOperations = parseAllOperations(operationFiles);
+  const allViews = parseAllViews(viewFiles);
+
+  console.log(`[wood] Parsed ${allOperations.size} operations from ${operationFiles.length} file(s)` +
+    (reason ? ` [${reason}]` : ''));
+  console.log(`[wood] Parsed ${allViews.length} views from ${viewFiles.length} file(s)` +
+    (reason ? ` [${reason}]` : ''));
+
+  // Generate all code in-memory first. If anything fails, do not overwrite files.
+  const artifacts = buildCodegenArtifacts(allOperations, allViews);
+
+  writeCodegenArtifacts(artifacts);
+  copyAssets(operationsStitchPath, operationFiles);
+}
+
+try {
+  runGeneration('initial');
+} catch (err) {
+  console.error(`[wood] Initial generation failed: ${err.message || err}`);
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// 2. Optional dev watcher (YAML + controllers)
+// ---------------------------------------------------------------------------
+let watcher = null;
+let pendingTimer = null;
+
+if (command === 'dev') {
+  const openapiAbs = path.resolve(projectRoot, mainSection.openapi);
+  const operationsDir = path.dirname(openapiAbs);
+  const controllersDirAbs = path.resolve(projectRoot, mainSection.controllers);
+
+  const viewsOpenapiAbs = path.resolve(projectRoot, rendererSection.openapi);
+  const viewsDir = path.dirname(viewsOpenapiAbs);
+  const rendererControllersDirAbs = path.resolve(projectRoot, rendererSection.controllers);
+
+  const operationsDirPrefix = operationsDir + path.sep;
+  const controllersDirPrefix = controllersDirAbs + path.sep;
+  const viewsDirPrefix = viewsDir + path.sep;
+  const rendererControllersDirPrefix = rendererControllersDirAbs + path.sep;
+
+  // chokidar v4 dropped glob-based path watching; watch concrete roots
+  // and filter matching files in callbacks.
+  const watchTargets = [
+    openapiAbs,
+    operationsDir,
+    controllersDirAbs,
+    viewsOpenapiAbs,
+    viewsDir,
+    rendererControllersDirAbs,
+  ];
+
+  watcher = chokidar.watch(watchTargets, {
+    ignoreInitial: true,
+  });
+
+  const toAbsPath = (changedPath) =>
+    path.isAbsolute(changedPath) ? changedPath : path.resolve(projectRoot, changedPath);
+
+  const shouldRegenerate = (changedPath) => {
+    const absPath = toAbsPath(changedPath);
+    const ext = path.extname(absPath).toLowerCase();
+
+    if (absPath === openapiAbs) return true;
+    if (absPath.startsWith(operationsDirPrefix) && (ext === '.yaml' || ext === '.yml')) return true;
+    if (absPath.startsWith(controllersDirPrefix) && (ext === '.ts' || ext === '.js')) return true;
+
+    if (absPath === viewsOpenapiAbs) return true;
+    if (absPath.startsWith(viewsDirPrefix) && (ext === '.yaml' || ext === '.yml')) return true;
+    if (absPath.startsWith(rendererControllersDirPrefix) && (ext === '.ts' || ext === '.js')) return true;
+
+    return false;
+  };
+
+  const scheduleRegen = (event, changedPath) => {
+    if (!shouldRegenerate(changedPath)) return;
+
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+    }
+
+    pendingTimer = setTimeout(() => {
+      pendingTimer = null;
+      try {
+        const absPath = toAbsPath(changedPath);
+        const relativePath = path.relative(projectRoot, absPath).split(path.sep).join('/');
+        runGeneration(`${event}:${relativePath}`);
+      } catch (err) {
+        console.error(`[wood] Regeneration failed (last good outputs kept): ${err.message || err}`);
+      }
+    }, 100);
+  };
+
+  watcher.on('add', (p) => scheduleRegen('add', p));
+  watcher.on('change', (p) => scheduleRegen('change', p));
+  watcher.on('unlink', (p) => scheduleRegen('unlink', p));
+
+  console.log('[wood] Watching operations/views YAML and controller files for regeneration');
+}
+
+// ---------------------------------------------------------------------------
+// 3. Spawn electron-vite
+// ---------------------------------------------------------------------------
+const modeEnv = command === 'dev' ? 'development' : 'production';
+const electronViteCmd = command === 'dev' ? 'dev' : 'build';
+const debugPort = resolveWoodRemoteDebuggingPort(process.env);
+
+console.log(`[wood] Starting electron-vite ${electronViteCmd} (WOOD_MODE=${modeEnv})`);
+
+const child = spawn('npx', ['electron-vite', electronViteCmd, ...extraArgs], {
+  stdio: 'inherit',
+  shell: true,
+  cwd: projectRoot,
+  env: {
+    ...process.env,
+    WOOD_MODE: modeEnv,
+    ...(command === 'dev' ? { WOOD_REMOTE_DEBUGGING_PORT: String(debugPort) } : {}),
+  },
+});
+
+if (command === 'dev') {
+  const metadataPath = writeWoodDevMetadata(projectRoot, {
+    projectRoot,
+    projectName: readProjectName(),
+    mode: 'development',
+    debugPort,
+    browserUrl: `http://127.0.0.1:${debugPort}`,
+    pid: child.pid,
+    startedAt: new Date().toISOString(),
+  });
+  console.log(`[wood] Wrote dev metadata ${metadataPath}`);
+}
+
+function shutdown(code) {
+  if (command === 'dev') {
+    removeWoodDevMetadata(projectRoot);
+  }
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+  }
+  if (pendingTimer) {
+    clearTimeout(pendingTimer);
+    pendingTimer = null;
+  }
+  process.exit(code ?? 0);
+}
+
+child.on('close', (code) => {
+  shutdown(code);
+});
+
+child.on('error', (err) => {
+  console.error(`[wood] Failed to start electron-vite: ${err.message}`);
+  shutdown(1);
+});
+
+process.on('SIGINT', () => {
+  if (!child.killed) child.kill('SIGINT');
+  shutdown(130);
+});
+
+process.on('SIGTERM', () => {
+  if (!child.killed) child.kill('SIGTERM');
+  shutdown(143);
+});