otavia 0.1.0

package/src/commands/dev.ts

@@ -0,0 +1,107 @@
+import { resolve } from "node:path";
+import { checkAwsCredentials } from "./aws-auth.js";
+import { runGatewayDev } from "./dev/gateway.js";
+import { startViteDev } from "./dev/vite-dev.js";
+import { startTunnel } from "./dev/tunnel.js";
+import { loadEnvForCell } from "../utils/env.js";
+import { resolvePortsFromEnv } from "../config/ports.js";
+
+export function resolveDevPublicBaseUrl(options: {
+  tunnelEnabled?: boolean;
+  tunnelPublicBaseUrl?: string;
+  gatewayOnly: boolean;
+  vitePort: number;
+}): string | undefined {
+  if (options.tunnelEnabled) return options.tunnelPublicBaseUrl;
+  if (options.gatewayOnly) return undefined;
+  return `http://localhost:${options.vitePort}`;
+}
+
+export function resolveDevTunnelEnabled(options?: { tunnel?: boolean }): boolean {
+  return options?.tunnel ?? false;
+}
+
+/**
+ * Dev command: validate otavia.yaml, start backend gateway, then Vite dev server.
+ * When OTAVIA_DEV_GATEWAY_ONLY=1 (e.g. for e2e), only run gateway with PORT and optional
+ * DYNAMODB_ENDPOINT/S3_ENDPOINT overrides; do not start Vite.
+ * On SIGINT/SIGTERM stops and exits.
+ */
+export async function devCommand(
+  rootDir: string,
+  options?: { tunnel?: boolean; tunnelHost?: string; tunnelConfig?: string; tunnelProtocol?: string }
+): Promise<void> {
+  const root = resolve(rootDir);
+  const aws = await checkAwsCredentials(root);
+  if (!aws.ok) {
+    console.error(
+      `AWS credentials are invalid or expired for profile "${aws.profile}".`
+    );
+    console.error("Run: bun run otavia aws login");
+    process.exit(1);
+  }
+  const stageEnv = loadEnvForCell(root, root, { stage: "dev" });
+  const ports = resolvePortsFromEnv("dev", { ...stageEnv, ...process.env });
+  const backendPort = ports.backend;
+  const vitePort = ports.frontend;
+  const gatewayOnly = process.env.OTAVIA_DEV_GATEWAY_ONLY === "1";
+  const overrides: { dynamoEndpoint?: string; s3Endpoint?: string } | undefined = gatewayOnly
+    ? (process.env.DYNAMODB_ENDPOINT || process.env.S3_ENDPOINT
+        ? {
+            dynamoEndpoint: process.env.DYNAMODB_ENDPOINT,
+            s3Endpoint: process.env.S3_ENDPOINT,
+          }
+        : undefined)
+    : undefined;
+
+  let tunnelHandle: { publicBaseUrl: string; stop: () => void } | undefined;
+  let publicBaseUrl: string | undefined;
+  const tunnelEnabled = resolveDevTunnelEnabled(options);
+  if (tunnelEnabled) {
+    tunnelHandle = await startTunnel(root, {
+      tunnelConfigPath: options?.tunnelConfig,
+      tunnelHost: options?.tunnelHost,
+      tunnelProtocol: options?.tunnelProtocol,
+    });
+    publicBaseUrl = tunnelHandle.publicBaseUrl;
+    console.log(`[tunnel] Started. Public base URL: ${publicBaseUrl}`);
+  }
+
+  const effectivePublicBaseUrl = resolveDevPublicBaseUrl({
+    tunnelEnabled,
+    tunnelPublicBaseUrl: publicBaseUrl,
+    gatewayOnly,
+    vitePort,
+  });
+  const server = await runGatewayDev(root, backendPort, overrides, {
+    publicBaseUrl: effectivePublicBaseUrl,
+    dynamodbPort: ports.dynamodb,
+    minioPort: ports.minio,
+  });
+
+  if (gatewayOnly) {
+    process.on("SIGINT", () => {
+      tunnelHandle?.stop();
+      server.stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      tunnelHandle?.stop();
+      server.stop();
+      process.exit(0);
+    });
+    await new Promise(() => {});
+  }
+
+  const viteHandle = await startViteDev(root, backendPort, vitePort, effectivePublicBaseUrl);
+
+  const cleanup = () => {
+    tunnelHandle?.stop();
+    server.stop();
+    viteHandle.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  await new Promise(() => {});
+}

package/src/commands/init.ts

@@ -0,0 +1,69 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { loadOtaviaYaml } from "../config/load-otavia-yaml.js";
+
+const DEFAULT_MOUNT = "app";
+
+function yamlScalar(s: string): string {
+  if (/^[\w.-]+$/.test(s)) return s;
+  return JSON.stringify(s);
+}
+
+function mergeGitignore(root: string): void {
+  const lines = ["node_modules/", "dist/", ".otavia/", ".env.local"];
+  const p = resolve(root, ".gitignore");
+  if (!existsSync(p)) {
+    writeFileSync(p, `${lines.join("\n")}\n`, "utf-8");
+    return;
+  }
+  const existing = readFileSync(p, "utf-8");
+  const missing = lines.filter((line) => !existing.split("\n").some((l) => l.trim() === line.trim()));
+  if (missing.length === 0) return;
+  appendFileSync(p, `${existing.endsWith("\n") ? "" : "\n"}${missing.join("\n")}\n`, "utf-8");
+}
+
+/**
+ * Scaffold a new Otavia stack: otavia.yaml, cells/<defaultMount>/cell.yaml, and optional .gitignore entries.
+ */
+export function initCommand(
+  rootDir: string,
+  options: { force?: boolean; stackName?: string; domain?: string }
+): void {
+  const root = resolve(rootDir);
+  const configPath = resolve(root, "otavia.yaml");
+
+  if (existsSync(configPath) && !options.force) {
+    throw new Error("otavia.yaml already exists. Use --force to overwrite.");
+  }
+
+  const stackName =
+    options.stackName?.trim() ||
+    basename(root).replace(/[^a-zA-Z0-9-]+/g, "-").replace(/^-|-$/g, "").toLowerCase() ||
+    "my-stack";
+  const domainHost = options.domain?.trim() || "example.com";
+
+  const yamlContent = `# Otavia stack — edit stackName, domain, and cells.
+stackName: ${yamlScalar(stackName)}
+domain:
+  host: ${yamlScalar(domainHost)}
+cells:
+  ${DEFAULT_MOUNT}: "@otavia/${DEFAULT_MOUNT}"
+`;
+
+  writeFileSync(configPath, yamlContent, "utf-8");
+
+  const cellDir = resolve(root, "cells", DEFAULT_MOUNT);
+  mkdirSync(cellDir, { recursive: true });
+  const cellYamlPath = resolve(cellDir, "cell.yaml");
+  if (!existsSync(cellYamlPath) || options.force) {
+    writeFileSync(cellYamlPath, `name: ${DEFAULT_MOUNT}\n`, "utf-8");
+  }
+
+  mergeGitignore(root);
+
+  loadOtaviaYaml(root);
+
+  console.log(`Initialized Otavia stack in ${root}`);
+  console.log(`  ${configPath}`);
+  console.log(`  ${cellYamlPath}`);
+}

package/src/commands/lint.ts

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadOtaviaYaml } from "../config/load-otavia-yaml.js";
+import { resolveCellDir } from "../config/resolve-cell-dir.js";
+
+/**
+ * Run biome check in each resolved cellDir. With fix: add --write; with unsafe: add --unsafe.
+ * Aggregate exit codes; if any cell fails, exit(1). Cells without cell.yaml are skipped.
+ * Cells should have biome in their dependencies, or the monorepo root may provide it.
+ */
+export async function lintCommand(
+  rootDir: string,
+  options?: { fix?: boolean; unsafe?: boolean }
+): Promise<void> {
+  const root = path.resolve(rootDir);
+  const otavia = loadOtaviaYaml(root);
+  let failed = false;
+
+  const args = [
+    "bun",
+    "x",
+    "biome",
+    "check",
+    ".",
+    ...(options?.fix ? ["--write"] : []),
+    ...(options?.unsafe ? ["--unsafe"] : []),
+  ];
+
+  for (const entry of otavia.cellsList) {
+    const cellDir = resolveCellDir(root, entry.package);
+    if (!fs.existsSync(path.join(cellDir, "cell.yaml"))) {
+      console.warn(`Skipping ${entry.mount}: cell not found`);
+      continue;
+    }
+
+    const proc = Bun.spawn(args, {
+      cwd: cellDir,
+      stdio: ["inherit", "inherit", "inherit"],
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      failed = true;
+    }
+  }
+
+  if (failed) {
+    process.exit(1);
+  }
+}