orch-mini 0.1.0

package/src/schema.ts

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+
+const serviceNameSchema = z
+  .string()
+  .min(1)
+  .regex(/^[a-z][a-z0-9_-]*$/, 'service name debe ser kebab/snake-case y empezar con letra');
+
+const envValueSchema = z.union([z.string(), z.number(), z.boolean()]).transform(String);
+const envMapSchema = z.record(z.string(), envValueSchema);
+
+const routeSchema = z.object({
+  path: z.string().min(1),
+  service: serviceNameSchema,
+  strip_prefix: z.boolean().optional(),
+  rewrite: z.string().optional(),
+});
+
+const gatewaySchema = z.object({
+  port: z.number().int().positive(),
+  server_name: z.string().optional(),
+  routes: z.array(routeSchema).min(1),
+});
+
+const vscodeBrowserSchema = z.object({
+  url: z.string().optional(),
+  label: z.string().optional(),
+});
+
+const vscodeServiceSchema = z.object({
+  browser: vscodeBrowserSchema.optional(),
+});
+
+// Una entrada de service única. `image` y `build` son mutuamente excluyentes
+// pero al menos uno tiene que estar. `repo` es opcional para ambos (sirve a sync).
+// Para oneshot, `port` también es opcional (jobs efímeros no escuchan).
+const serviceSchema = z
+  .object({
+    kind: z.enum(['service', 'oneshot']).default('service'),
+    image: z.string().optional(),
+    build: z.string().optional(),
+    repo: z.string().optional(),
+    ref: z.string().optional(),
+    working_dir: z.string().optional(),
+    port: z.number().int().positive().optional(),
+    debug_port: z.number().int().positive().optional(),
+    env: envMapSchema.optional(),
+    needs: z.array(serviceNameSchema).optional(),
+    expose_host: z.number().int().positive().optional(),
+    volumes: z.array(z.string()).optional(),
+    command: z.union([z.string(), z.array(z.string())]).optional(),
+    databases: z.array(z.string().min(1)).optional(),
+    vscode: vscodeServiceSchema.optional(),
+  })
+  .superRefine((svc, ctx) => {
+    const hasImage = svc.image !== undefined;
+    const hasBuild = svc.build !== undefined;
+    if (hasImage === hasBuild) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: hasImage
+          ? 'no pueden coexistir image: y build: en el mismo service'
+          : 'el service necesita image: o build:',
+      });
+    }
+    if (hasBuild && svc.repo === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['repo'],
+        message: 'build: requiere repo: para resolver el build context',
+      });
+    }
+    if (svc.kind === 'service' && svc.port === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['port'],
+        message: 'port: es obligatorio para kind: service (omitilo solo en kind: oneshot)',
+      });
+    }
+    if (svc.databases !== undefined && svc.databases.length > 0) {
+      const img = svc.image ?? '';
+      if (!/^postgres(:|$)/i.test(img)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['databases'],
+          message: `databases: solo soportado en image: postgres (recibido: ${img || '(none)'})`,
+        });
+      }
+    }
+  });
+
+export const stackSchema = z
+  .object({
+    name: z
+      .string()
+      .min(1)
+      .regex(/^[a-z][a-z0-9-]*$/, 'name debe ser kebab-case y empezar con letra'),
+    gateway: gatewaySchema.optional(),
+    services: z
+      .record(serviceNameSchema, serviceSchema)
+      .refine((s) => Object.keys(s).length > 0, { message: 'el stack debe tener al menos un service' }),
+  })
+  .superRefine((stack, ctx) => {
+    const names = new Set(Object.keys(stack.services));
+
+    if (stack.gateway) {
+      for (const [i, route] of stack.gateway.routes.entries()) {
+        if (!names.has(route.service)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['gateway', 'routes', i, 'service'],
+            message: `route apunta a service inexistente: ${route.service}`,
+          });
+        }
+      }
+    }
+
+    for (const [svcName, svc] of Object.entries(stack.services)) {
+      for (const [i, dep] of (svc.needs ?? []).entries()) {
+        if (!names.has(dep)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['services', svcName, 'needs', i],
+            message: `needs apunta a service inexistente: ${dep}`,
+          });
+        }
+        if (dep === svcName) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['services', svcName, 'needs', i],
+            message: `un service no puede depender de sí mismo`,
+          });
+        }
+      }
+    }
+
+    const hostPorts = new Map<number, string[]>();
+    if (stack.gateway) hostPorts.set(stack.gateway.port, ['gateway']);
+    for (const [svcName, svc] of Object.entries(stack.services)) {
+      if (svc.expose_host !== undefined) {
+        const list = hostPorts.get(svc.expose_host) ?? [];
+        list.push(svcName);
+        hostPorts.set(svc.expose_host, list);
+      }
+      if (svc.debug_port !== undefined) {
+        const list = hostPorts.get(svc.debug_port) ?? [];
+        list.push(`${svcName}.debug_port`);
+        hostPorts.set(svc.debug_port, list);
+      }
+    }
+    for (const [port, owners] of hostPorts) {
+      if (owners.length > 1) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['services'],
+          message: `puerto host ${port} reclamado por: ${owners.join(', ')}`,
+        });
+      }
+    }
+  });
+
+export type Stack = z.infer<typeof stackSchema>;
+export type Service = Stack['services'][string];
+
+export function hasBuild(svc: Service): boolean {
+  return svc.build !== undefined;
+}
+
+export function hasRepo(svc: Service): svc is Service & { repo: string } {
+  return typeof svc.repo === 'string' && svc.repo.length > 0;
+}

package/src/sync.ts

@@ -0,0 +1,125 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { isLocalRepo, normalizeGitUrl, repoSlug } from './repo.js';
+import { hasRepo, type Stack } from './schema.js';
+
+export type SyncResult = {
+  service: string;
+  repo: string;
+  action:
+    | 'cloned'
+    | 'pulled'
+    | 'switched'
+    | 'local-ok'
+    | 'local-missing'
+    | 'failed'
+    | 'skipped-no-repo'
+    | 'skipped-dup';
+  message?: string;
+};
+
+export function syncStack(
+  stack: Stack,
+  opts: { workDir: string; reposDir: string },
+): SyncResult[] {
+  const results: SyncResult[] = [];
+  const seenSlugs = new Set<string>();
+
+  for (const [name, svc] of Object.entries(stack.services)) {
+    if (!hasRepo(svc)) {
+      results.push({ service: name, repo: '(no repo)', action: 'skipped-no-repo' });
+      continue;
+    }
+    const slug = repoSlug(svc.repo);
+    if (seenSlugs.has(slug)) {
+      results.push({
+        service: name,
+        repo: svc.repo,
+        action: 'skipped-dup',
+        message: `mismo repo que un service anterior (slug=${slug})`,
+      });
+      continue;
+    }
+    seenSlugs.add(slug);
+    results.push(syncOne(name, svc.repo, svc.ref, opts));
+  }
+
+  return results;
+}
+
+function syncOne(
+  service: string,
+  repo: string,
+  ref: string | undefined,
+  opts: { workDir: string; reposDir: string },
+): SyncResult {
+  if (isLocalRepo(repo)) {
+    const abs = isAbsolute(repo) ? repo : resolve(opts.workDir, repo);
+    if (existsSync(abs)) {
+      return { service, repo, action: 'local-ok', message: abs };
+    }
+    return { service, repo, action: 'local-missing', message: `no existe: ${abs}` };
+  }
+
+  const url = normalizeGitUrl(repo);
+  const slug = repoSlug(repo);
+  const targetDir = join(opts.reposDir, slug);
+
+  if (existsSync(join(targetDir, '.git'))) {
+    // Repo ya clonado. Si declara ref distinto al actual, switchear; sino pull --ff-only.
+    if (ref !== undefined) {
+      const current = git(['rev-parse', '--abbrev-ref', 'HEAD'], targetDir);
+      const currentBranch = current.stdout.trim();
+      if (currentBranch !== ref) {
+        const fetchRes = git(['fetch', 'origin', ref], targetDir);
+        if (fetchRes.status !== 0) {
+          return {
+            service,
+            repo,
+            action: 'failed',
+            message: `git fetch origin ${ref} falló: ${fetchRes.stderr}`,
+          };
+        }
+        const checkoutRes = git(['checkout', ref], targetDir);
+        if (checkoutRes.status !== 0) {
+          return {
+            service,
+            repo,
+            action: 'failed',
+            message: `git checkout ${ref} falló: ${checkoutRes.stderr}`,
+          };
+        }
+        return { service, repo, action: 'switched', message: `${targetDir} → ${ref}` };
+      }
+    }
+    const pullRes = git(['pull', '--ff-only'], targetDir);
+    if (pullRes.status !== 0) {
+      return { service, repo, action: 'failed', message: `git pull falló: ${pullRes.stderr}` };
+    }
+    return { service, repo, action: 'pulled', message: targetDir };
+  }
+
+  const cloneArgs = ['clone'];
+  if (ref !== undefined) cloneArgs.push('--branch', ref);
+  cloneArgs.push(url, targetDir);
+  const cloneRes = git(cloneArgs, opts.reposDir);
+  if (cloneRes.status !== 0) {
+    return { service, repo, action: 'failed', message: `git clone falló: ${cloneRes.stderr}` };
+  }
+  return {
+    service,
+    repo,
+    action: 'cloned',
+    message: ref !== undefined ? `${targetDir} (ref=${ref})` : targetDir,
+  };
+}
+
+function git(args: string[], cwd: string): { status: number; stderr: string; stdout: string } {
+  const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  return {
+    status: res.status ?? 1,
+    stderr: (res.stderr ?? '').trim(),
+    stdout: res.stdout ?? '',
+  };
+}