orch-mini 0.1.0

package/src/parser.ts

@@ -0,0 +1,83 @@
+import { readFileSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { z } from 'zod';
+import { expandFileRefs } from './file-refs.js';
+import { findStack, STACK_FILENAME, STACK_SUBDIRS } from './discover.js';
+import { stackSchema, type Stack } from './schema.js';
+
+export type LoadedStack = {
+  stack: Stack;
+  sourcePath: string;
+  workDir: string;          // dirname(stack.yaml)
+  workspaceRoot: string;    // donde van repos/ y .stack/ — padre del workDir si el yaml vive en arch/
+  outDir: string;           // workspaceRoot/.stack
+};
+
+export function loadStack(stackPath?: string): LoadedStack {
+  let absPath: string;
+  if (stackPath) {
+    absPath = resolve(process.cwd(), stackPath);
+  } else {
+    const found = findStack();
+    if (!found) {
+      throw new Error(
+        `no se encontró ${STACK_FILENAME} en ${process.cwd()} ni en ninguna carpeta superior`,
+      );
+    }
+    absPath = found;
+  }
+
+  let raw: string;
+  try {
+    raw = readFileSync(absPath, 'utf8');
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`no se pudo leer el stack en ${absPath}: ${msg}`);
+  }
+
+  let doc: unknown;
+  try {
+    doc = parseYaml(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`YAML inválido en ${absPath}: ${msg}`);
+  }
+
+  const workDir = resolve(absPath, '..');
+
+  // Expandir ${file:path} antes de validar — paths se resuelven relativo al workDir.
+  const expanded = expandFileRefs(doc, workDir);
+
+  const result = stackSchema.safeParse(expanded);
+  if (!result.success) {
+    throw new Error(formatZodError(result.error, absPath));
+  }
+
+  const workspaceRoot = computeWorkspaceRoot(workDir);
+
+  return {
+    stack: result.data,
+    sourcePath: absPath,
+    workDir,
+    workspaceRoot,
+    outDir: resolve(workspaceRoot, '.stack'),
+  };
+}
+
+function computeWorkspaceRoot(workDir: string): string {
+  // Si el stack.yaml vive en un subdir convencional (arch/), el workspaceRoot
+  // es el padre — repos/ y .stack/ no se mezclan con la definición.
+  if ((STACK_SUBDIRS as readonly string[]).includes(basename(workDir))) {
+    return dirname(workDir);
+  }
+  return workDir;
+}
+
+function formatZodError(err: z.ZodError, source: string): string {
+  const lines = err.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+    return `  - ${path}: ${issue.message}`;
+  });
+  return `stack inválido (${source}):\n${lines.join('\n')}`;
+}

package/src/renderer/compose.ts

@@ -0,0 +1,153 @@
+import { stringify as stringifyYaml } from 'yaml';
+import { repoSlug } from '../repo.js';
+import { hasBuild, type Stack } from '../schema.js';
+import { renderDbInit } from './db-init.js';
+
+const REPOS_DIR_VAR = '${REPOS_DIR}';
+
+export function renderCompose(stack: Stack): string {
+  const services: Record<string, unknown> = {};
+  const namedVolumes = new Set<string>();
+
+  // Pre-calcular qué services son oneshot — necesario para decidir el formato
+  // de depends_on cuando otros services los referencian.
+  const oneshotSet = new Set(
+    Object.entries(stack.services)
+      .filter(([, svc]) => svc.kind === 'oneshot')
+      .map(([name]) => name),
+  );
+
+  // db-init: auto-mount de scripts SQL para services postgres con databases:.
+  const dbInitFiles = renderDbInit(stack);
+  const dbInitByService = new Map(dbInitFiles.map((f) => [f.service, f]));
+
+  for (const [name, svc] of Object.entries(stack.services)) {
+    const entry: Record<string, unknown> = {
+      container_name: `${stack.name}-${name}`,
+    };
+
+    if (hasBuild(svc)) {
+      entry.build = {
+        context: `${REPOS_DIR_VAR}/${repoSlug(svc.repo!)}`,
+        dockerfile: svc.build,
+      };
+    } else {
+      entry.image = svc.image;
+    }
+
+    if (svc.working_dir !== undefined) {
+      entry.working_dir = svc.working_dir;
+    }
+
+    if (svc.port !== undefined) {
+      entry.expose = [String(svc.port)];
+    }
+
+    const ports: string[] = [];
+    if (svc.expose_host !== undefined && svc.port !== undefined) {
+      ports.push(`${svc.expose_host}:${svc.port}`);
+    }
+    if (svc.debug_port !== undefined) ports.push(`${svc.debug_port}:${svc.debug_port}`);
+    if (ports.length > 0) entry.ports = ports;
+
+    const environment: Record<string, string> = { ...(svc.env ?? {}) };
+    if (svc.debug_port !== undefined) {
+      const inspectFlag = `--inspect=0.0.0.0:${svc.debug_port}`;
+      environment.NODE_OPTIONS = environment.NODE_OPTIONS
+        ? `${environment.NODE_OPTIONS} ${inspectFlag}`
+        : inspectFlag;
+    }
+    if (Object.keys(environment).length > 0) {
+      entry.environment = environment;
+    }
+
+    // Volumes — combinar declarados + auto-mount del db-init si aplica.
+    const volumes: string[] = [...(svc.volumes ?? [])];
+    const dbInit = dbInitByService.get(name);
+    if (dbInit) {
+      volumes.push(`./${dbInit.path}:${dbInit.mountTarget}:ro`);
+    }
+    if (volumes.length > 0) {
+      entry.volumes = volumes;
+      for (const v of volumes) {
+        const namedVol = extractNamedVolume(v);
+        if (namedVol) namedVolumes.add(namedVol);
+      }
+    }
+
+    if (svc.command !== undefined) {
+      entry.command = svc.command;
+    }
+
+    if (svc.needs && svc.needs.length > 0) {
+      entry.depends_on = renderDependsOn(svc.needs, oneshotSet);
+    }
+
+    entry.networks = ['default'];
+    // oneshot: corre una vez y termina sin restartear.
+    entry.restart = svc.kind === 'oneshot' ? 'no' : 'unless-stopped';
+
+    services[name] = entry;
+  }
+
+  if (stack.gateway) {
+    services.gateway = renderGatewayService(stack, oneshotSet);
+  }
+
+  const compose: Record<string, unknown> = {
+    name: stack.name,
+    services,
+    networks: {
+      default: { name: `${stack.name}_default` },
+    },
+  };
+
+  if (namedVolumes.size > 0) {
+    compose.volumes = Object.fromEntries(
+      [...namedVolumes].sort().map((n) => [n, { name: `${stack.name}_${n}` }]),
+    );
+  }
+
+  return stringifyYaml(compose, { lineWidth: 0 });
+}
+
+function renderDependsOn(needs: string[], oneshotSet: Set<string>): unknown {
+  // Si TODOS los needs son services normales, formato array (más simple/legible).
+  // Si alguno es oneshot, usar formato objeto extendido para poder declarar
+  // condition: service_completed_successfully en los oneshots.
+  const hasOneshot = needs.some((n) => oneshotSet.has(n));
+  if (!hasOneshot) return [...needs];
+
+  const out: Record<string, { condition: string }> = {};
+  for (const n of needs) {
+    out[n] = {
+      condition: oneshotSet.has(n) ? 'service_completed_successfully' : 'service_started',
+    };
+  }
+  return out;
+}
+
+function renderGatewayService(
+  stack: Stack,
+  oneshotSet: Set<string>,
+): Record<string, unknown> {
+  const targets = [...new Set(stack.gateway!.routes.map((r) => r.service))];
+  return {
+    container_name: `${stack.name}-gateway`,
+    image: 'nginx:1.27-alpine',
+    ports: [`${stack.gateway!.port}:80`],
+    volumes: ['./nginx.conf:/etc/nginx/nginx.conf:ro'],
+    depends_on: renderDependsOn(targets, oneshotSet),
+    networks: ['default'],
+    restart: 'unless-stopped',
+  };
+}
+
+function extractNamedVolume(spec: string): string | null {
+  const colonIdx = spec.indexOf(':');
+  if (colonIdx <= 0) return null;
+  const left = spec.slice(0, colonIdx);
+  if (left.startsWith('/') || left.startsWith('.') || left.includes('$')) return null;
+  if (!/^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/.test(left)) return null;
+  return left;
+}

package/src/renderer/db-init.ts

@@ -0,0 +1,44 @@
+import type { Stack } from '../schema.js';
+
+export type DbInitFile = {
+  path: string;           // relativo al outDir (.stack/)
+  content: string;
+  service: string;        // service postgres-like al que pertenece
+  mountTarget: string;    // path adentro del container donde se monta
+};
+
+// Genera SQL scripts de "CREATE DATABASE" idempotente para cada service
+// con databases:. Postgres NO soporta IF NOT EXISTS para DATABASE, así que
+// usamos un bloque DO con consulta a pg_database.
+export function renderDbInit(stack: Stack): DbInitFile[] {
+  const files: DbInitFile[] = [];
+
+  for (const [name, svc] of Object.entries(stack.services)) {
+    if (!svc.databases || svc.databases.length === 0) continue;
+    files.push({
+      path: `db-init/${name}.sql`,
+      content: renderPostgresInit(svc.databases),
+      service: name,
+      mountTarget: `/docker-entrypoint-initdb.d/00-om-databases.sql`,
+    });
+  }
+
+  return files;
+}
+
+function renderPostgresInit(databases: string[]): string {
+  const lines: string[] = ['-- Generado por om — CREATE DATABASE idempotente.'];
+  for (const db of databases) {
+    // Escape simple del identificador (alphanumeric + underscore + dash permitidos en pg).
+    const safe = db.replace(/[^a-zA-Z0-9_-]/g, '');
+    if (safe !== db) {
+      throw new Error(
+        `databases: nombre inválido '${db}' — solo se permiten [a-zA-Z0-9_-]`,
+      );
+    }
+    lines.push(`SELECT 'CREATE DATABASE ${safe}'`);
+    lines.push(`WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = '${safe}')\\gexec`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}

package/src/renderer/env.ts

@@ -0,0 +1,15 @@
+import type { Stack } from '../schema.js';
+
+export function renderEnv(
+  stack: Stack,
+  opts: { reposDir: string; stackDir: string },
+): string {
+  const lines: string[] = [
+    '# Generado por om — interpolado por docker compose.',
+    `COMPOSE_PROJECT_NAME=${stack.name}`,
+    `REPOS_DIR=${opts.reposDir}`,
+    `STACK_DIR=${opts.stackDir}`,
+    '',
+  ];
+  return lines.join('\n');
+}

package/src/renderer/nginx.ts

@@ -0,0 +1,93 @@
+import type { Stack } from '../schema.js';
+
+export function renderNginx(stack: Stack): string {
+  if (!stack.gateway) return '';
+
+  const usedServices = [...new Set(stack.gateway.routes.map((r) => r.service))];
+
+  const upstreams = usedServices
+    .map((svcName) => {
+      const svc = stack.services[svcName]!;
+      return `upstream ${svcName} {\n    server ${svcName}:${svc.port};\n}`;
+    })
+    .join('\n\n');
+
+  // Orden por especificidad (longitud del path) — más largo gana. nginx hace
+  // longest-prefix match nativo, pero ordenar mantiene el archivo legible.
+  const sortedRoutes = [...stack.gateway.routes].sort(
+    (a, b) => effectivePathLength(b.path) - effectivePathLength(a.path),
+  );
+
+  const locations = sortedRoutes.map((route) => renderLocation(route)).join('\n\n');
+
+  const serverName = stack.gateway.server_name ?? '_';
+
+  return `# Generado por om — no editar a mano
+worker_processes 1;
+
+events {
+    worker_connections 1024;
+}
+
+http {
+    sendfile on;
+    keepalive_timeout 65;
+    client_max_body_size 50m;
+
+${indent(upstreams, 4)}
+
+    server {
+        listen 80;
+        server_name ${serverName};
+
+${locations}
+    }
+}
+`;
+}
+
+function renderLocation(route: {
+  path: string;
+  service: string;
+  strip_prefix?: boolean;
+  rewrite?: string;
+}): string {
+  const directives: string[] = [];
+
+  if (route.rewrite) {
+    directives.push(`rewrite ${route.rewrite};`);
+  } else if (route.strip_prefix) {
+    // /provider-api/foo → /foo
+    const prefix = route.path.replace(/^=\s*/, '').replace(/\/$/, '');
+    if (prefix.length > 0) {
+      directives.push(`rewrite ^${prefix}/(.*)$ /$1 break;`);
+    }
+  }
+
+  directives.push(
+    `proxy_pass http://${route.service};`,
+    `proxy_http_version 1.1;`,
+    `proxy_set_header Host $host;`,
+    `proxy_set_header X-Real-IP $remote_addr;`,
+    `proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;`,
+    `proxy_set_header X-Forwarded-Proto $scheme;`,
+    `proxy_set_header Upgrade $http_upgrade;`,
+    `proxy_set_header Connection "upgrade";`,
+  );
+
+  const body = directives.map((l) => `            ${l}`).join('\n');
+  return `        location ${route.path} {\n${body}\n        }`;
+}
+
+function effectivePathLength(path: string): number {
+  // Para ordenamiento: ignorar modificador "= " o "^~ " del prefix.
+  return path.replace(/^(=|\^~)\s*/, '').length;
+}
+
+function indent(text: string, spaces: number): string {
+  const pad = ' '.repeat(spaces);
+  return text
+    .split('\n')
+    .map((line) => (line.length > 0 ? pad + line : line))
+    .join('\n');
+}

package/src/renderer/scripts.ts

@@ -0,0 +1,139 @@
+import { repoSlug } from '../repo.js';
+import { hasRepo, type Stack } from '../schema.js';
+
+export type ScriptFile = {
+  path: string;
+  content: string;
+  executable: boolean;
+};
+
+// Para acciones sobre el stack (up/down/logs/ps) usar el CLI `om` directamente.
+// Acá solo generamos el caso único que el CLI no cubre: correr un service nativo
+// en el host con env apuntando al resto del compose. Se emite en bash (.sh) y
+// PowerShell (.ps1) para soporte cross-platform.
+// Solo aplica a services con repo: (los que tienen código local que se puede correr nativo).
+export function renderScripts(stack: Stack): ScriptFile[] {
+  const files: ScriptFile[] = [];
+
+  for (const [name, svc] of Object.entries(stack.services)) {
+    if (!hasRepo(svc)) continue;
+    files.push({
+      path: `scripts/${name}.sh`,
+      content: svcStandaloneBash(stack, name),
+      executable: true,
+    });
+    files.push({
+      path: `scripts/${name}.ps1`,
+      content: svcStandalonePwsh(stack, name),
+      executable: false,
+    });
+  }
+
+  return files;
+}
+
+function svcStandaloneBash(stack: Stack, svcName: string): string {
+  const svc = stack.services[svcName]!;
+  if (!hasRepo(svc)) return '';
+
+  const envLines: string[] = [`export PORT="${svc.port}"`];
+  for (const [k, v] of Object.entries(svc.env ?? {})) {
+    envLines.push(`export ${k}="${escapeForBash(rewriteForHost(v, stack))}"`);
+  }
+
+  const slug = repoSlug(svc.repo);
+
+  return `#!/usr/bin/env bash
+# Generado por om — no editar a mano.
+# Corre ${svcName} nativo en el host (sin docker), conectado al resto del stack.
+# Útil para debugging con IDE/debugger nativo.
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+REPOS_DIR="\${REPOS_DIR:-$(pwd)/../repos}"
+SERVICE_DIR="$REPOS_DIR/${slug}"
+
+if [ ! -d "$SERVICE_DIR" ]; then
+  echo "no se encuentra el repo en $SERVICE_DIR — clonalo primero" >&2
+  exit 1
+fi
+
+${envLines.join('\n')}
+
+cd "$SERVICE_DIR"
+
+if [ -n "\${OM_CMD:-}" ]; then
+  exec $OM_CMD
+elif [ -f package.json ] && command -v npm >/dev/null 2>&1; then
+  exec npm run dev
+fi
+
+echo "no se detectó comando de arranque — setea OM_CMD" >&2
+exit 1
+`;
+}
+
+function svcStandalonePwsh(stack: Stack, svcName: string): string {
+  const svc = stack.services[svcName]!;
+  if (!hasRepo(svc)) return '';
+
+  const envLines: string[] = [`$env:PORT = "${svc.port}"`];
+  for (const [k, v] of Object.entries(svc.env ?? {})) {
+    envLines.push(`$env:${k} = "${escapeForPwsh(rewriteForHost(v, stack))}"`);
+  }
+
+  const slug = repoSlug(svc.repo);
+
+  return `# Generado por om — no editar a mano.
+# Corre ${svcName} nativo en el host (sin docker), conectado al resto del stack.
+# Útil para debugging con IDE/debugger nativo.
+$ErrorActionPreference = 'Stop'
+Set-Location (Join-Path $PSScriptRoot '..')
+
+$ReposDir = if ($env:REPOS_DIR) { $env:REPOS_DIR } else { Join-Path (Get-Location) '..\\repos' }
+$ServiceDir = Join-Path $ReposDir '${slug}'
+
+if (-not (Test-Path $ServiceDir)) {
+    Write-Error "no se encuentra el repo en $ServiceDir — clonalo primero"
+    exit 1
+}
+
+${envLines.join('\n')}
+
+Set-Location $ServiceDir
+
+if ($env:OM_CMD) {
+    Invoke-Expression $env:OM_CMD
+} elseif ((Test-Path 'package.json') -and (Get-Command npm -ErrorAction SilentlyContinue)) {
+    & npm run dev
+} else {
+    Write-Error "no se detectó comando de arranque — setea OM_CMD"
+    exit 1
+}
+`;
+}
+
+function rewriteForHost(value: string, stack: Stack): string {
+  // En el compose "api" resuelve por DNS interno; corriendo nativo en el host
+  // hay que ir a localhost:<expose_host>. Matchea tanto //host:port (URL plain)
+  // como @host:port (URL con userinfo).
+  return value.replace(
+    /(\/\/|@)([a-z][a-z0-9_-]*):(\d+)/g,
+    (match, prefix: string, target: string, _port: string) => {
+      const targetSvc = stack.services[target];
+      if (!targetSvc) return match;
+      if (targetSvc.expose_host === undefined) return match;
+      return `${prefix}localhost:${targetSvc.expose_host}`;
+    },
+  );
+}
+
+function escapeForBash(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$');
+}
+
+function escapeForPwsh(value: string): string {
+  // En PowerShell double-quoted strings: " se escapa como `", $ como `$, ` como ``.
+  return value.replace(/`/g, '``').replace(/"/g, '`"').replace(/\$/g, '`$');
+}
+

package/src/renderer/vscode.ts

@@ -0,0 +1,93 @@
+import { repoSlug } from '../repo.js';
+import { hasRepo, type Stack } from '../schema.js';
+
+// Genera el contenido de .vscode/launch.json para attach al inspector Node
+// de cada service con debug_port + launch del browser para services con
+// vscode.browser. Incluye una compound config para attach a todos a la vez.
+export function renderVscodeLaunch(stack: Stack): string {
+  const configurations: Array<Record<string, unknown>> = [];
+  const compounds: Array<Record<string, unknown>> = [];
+  const attachNames: string[] = [];
+
+  for (const [name, svc] of Object.entries(stack.services)) {
+    if (svc.debug_port !== undefined) {
+      const cfgName = `[${stack.name}] Attach (${name})`;
+      attachNames.push(cfgName);
+      configurations.push(attachConfig(stack, name, svc.debug_port, cfgName));
+    }
+
+    if (svc.vscode?.browser !== undefined) {
+      configurations.push(browserConfig(stack, name, svc));
+    }
+  }
+
+  if (attachNames.length > 1) {
+    compounds.push({
+      name: `[${stack.name}] Attach all`,
+      configurations: attachNames,
+      stopAll: true,
+    });
+  }
+
+  const launch: Record<string, unknown> = {
+    version: '0.2.0',
+    configurations,
+  };
+  if (compounds.length > 0) launch.compounds = compounds;
+
+  return JSON.stringify(launch, null, 2) + '\n';
+}
+
+function attachConfig(
+  stack: Stack,
+  svcName: string,
+  debugPort: number,
+  name: string,
+): Record<string, unknown> {
+  const svc = stack.services[svcName]!;
+  const cfg: Record<string, unknown> = {
+    name,
+    type: 'node',
+    request: 'attach',
+    address: 'localhost',
+    port: debugPort,
+    restart: true,
+    timeout: 30000,
+    skipFiles: ['<node_internals>/**'],
+  };
+
+  // Si el service monta el código del host adentro del container, mapear paths
+  // para que VS Code resuelva los source files al filesystem local.
+  if (hasRepo(svc) && svc.working_dir) {
+    cfg.localRoot = `\${workspaceFolder}/repos/${repoSlug(svc.repo)}`;
+    cfg.remoteRoot = svc.working_dir;
+  }
+
+  return cfg;
+}
+
+function browserConfig(
+  stack: Stack,
+  svcName: string,
+  svc: Stack['services'][string],
+): Record<string, unknown> {
+  const browser = svc.vscode!.browser!;
+  const label = browser.label ?? `Browser (${svcName})`;
+  const url =
+    browser.url ??
+    (stack.gateway ? `http://localhost:${stack.gateway.port}/` : `http://localhost:${svc.port}/`);
+
+  const cfg: Record<string, unknown> = {
+    name: `[${stack.name}] ${label}`,
+    type: 'pwa-chrome',
+    request: 'launch',
+    url,
+    sourceMaps: true,
+  };
+
+  if (hasRepo(svc)) {
+    cfg.webRoot = `\${workspaceFolder}/repos/${repoSlug(svc.repo)}`;
+  }
+
+  return cfg;
+}

package/src/repo.ts

@@ -0,0 +1,30 @@
+// Helpers de URL/slug de repos — usados por compose, scripts, sync y deben coincidir.
+
+export function isLocalRepo(repo: string): boolean {
+  return repo.startsWith('./') || repo.startsWith('../') || repo.startsWith('/');
+}
+
+export function normalizeGitUrl(repo: string): string {
+  if (/^https?:\/\//.test(repo)) return repo;
+  if (/^git@/.test(repo)) return repo;
+  if (/^ssh:\/\//.test(repo)) return repo;
+
+  if (/^[a-z0-9.-]+\/[^/]+\/[^/]+/.test(repo)) {
+    const withGit = repo.endsWith('.git') ? repo : `${repo}.git`;
+    return `https://${withGit}`;
+  }
+  return repo;
+}
+
+export function repoSlug(repo: string): string {
+  if (isLocalRepo(repo)) {
+    const parts = repo.replace(/\/$/, '').split('/');
+    return parts[parts.length - 1] ?? repo;
+  }
+  const cleaned = repo.replace(/\.git$/, '').replace(/\/$/, '');
+  const colonIdx = cleaned.indexOf(':');
+  const tail =
+    colonIdx >= 0 && !cleaned.startsWith('http') ? cleaned.slice(colonIdx + 1) : cleaned;
+  const parts = tail.split('/');
+  return parts[parts.length - 1] ?? tail;
+}