@swissjs/swite 0.3.0

package/src/cli.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { SwiteServer } from "./dev-engine/server.js";
+import { loadUserConfig } from "./config/config-loader.js";
+import {
+  startPythonDevService,
+  stopPythonDevService,
+} from "./dev-engine/pythonDevManager.js";
+import { setProductionMode } from "./adapters/proxy/proxyToPython.js";
+
+const [, , command, ...args] = process.argv;
+const root = resolve(process.cwd());
+
+async function dev(): Promise<void> {
+  const config = await loadUserConfig(root);
+  const python = config.services?.python;
+
+  if (python?.autoStart) {
+    await startPythonDevService(python, root);
+  }
+
+  // Relay SIGINT: kill Python, then exit cleanly
+  process.on("SIGINT", () => {
+    stopPythonDevService();
+    process.exit(0);
+  });
+
+  // Ensure Python is killed if Node crashes
+  process.on("exit", () => {
+    stopPythonDevService();
+  });
+
+  const server = new SwiteServer({
+    root,
+    port: config.server?.port ?? 3000,
+    host: config.server?.host ?? "localhost",
+    publicDir: "public",
+    open: false,
+  });
+
+  await server.start();
+}
+
+async function start(): Promise<void> {
+  const config = await loadUserConfig(root);
+  const python = config.services?.python;
+
+  setProductionMode();
+
+  if (python && !process.env["PYTHON_SERVICE_URL"]) {
+    console.warn(
+      chalk.yellow(
+        "[swite] WARNING: services.python is configured but PYTHON_SERVICE_URL is not set.\n" +
+          "        Proxy calls to Python will fail. Set PYTHON_SERVICE_URL to the running service URL.",
+      ),
+    );
+  }
+
+  const server = new SwiteServer({
+    root,
+    port: config.server?.port ?? 3000,
+    host: config.server?.host ?? "localhost",
+    publicDir: "public",
+    open: false,
+  });
+
+  await server.start();
+}
+
+async function build(): Promise<void> {
+  const { SwiteBuilder } = await import("./builder.js");
+  const config = await loadUserConfig(root);
+  const builder = new SwiteBuilder({
+    root,
+    entry: resolve(root, "src/index.ui"),
+    outDir: resolve(root, "dist"),
+  });
+  await builder.build();
+}
+
+switch (command) {
+  case "dev":
+    dev().catch((err: unknown) => {
+      console.error(chalk.red("[swite] fatal:"), err);
+      stopPythonDevService();
+      process.exit(1);
+    });
+    break;
+
+  case "start":
+    start().catch((err: unknown) => {
+      console.error(chalk.red("[swite] fatal:"), err);
+      process.exit(1);
+    });
+    break;
+
+  case "build":
+    build().catch((err: unknown) => {
+      console.error(chalk.red("[swite] build failed:"), err);
+      process.exit(1);
+    });
+    break;
+
+  default:
+    console.error(chalk.red(`[swite] unknown command: ${command ?? "(none)"}`));
+    console.error("Usage: swite <dev|build|start>");
+    process.exit(1);
+}

package/src/config/config-loader.ts

@@ -0,0 +1,46 @@
+import { build } from "esbuild";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
+import type { SwiteUserConfig } from "./config.js";
+
+/**
+ * Load swiss.config.ts from the project root.
+ * Transpiles to a temp ESM file via esbuild, imports it, then cleans up.
+ * Returns empty config if no config file found.
+ */
+export async function loadUserConfig(root: string): Promise<SwiteUserConfig> {
+  const tsConfig = join(root, "swiss.config.ts");
+  const jsConfig = join(root, "swiss.config.js");
+
+  const configPath = existsSync(tsConfig)
+    ? tsConfig
+    : existsSync(jsConfig)
+      ? jsConfig
+      : null;
+
+  if (!configPath) {
+    return {};
+  }
+
+  const tempDir = await mkdtemp(join(tmpdir(), "swite-config-"));
+  const outFile = join(tempDir, "swiss.config.mjs");
+
+  try {
+    await build({
+      entryPoints: [configPath],
+      bundle: false,
+      format: "esm",
+      outfile: outFile,
+      platform: "node",
+      logLevel: "silent",
+    });
+
+    const mod = await import(pathToFileURL(outFile).href);
+    return (mod.default ?? {}) as SwiteUserConfig;
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,34 @@
+export interface PythonServiceConfig {
+  /** Path to the Python entry file, relative to project root */
+  entry: string;
+  /** Port the Python service listens on */
+  port: number;
+  /** Whether swite dev should spawn the Python process automatically */
+  autoStart: boolean;
+  /** Health check endpoint polled before Node server starts */
+  healthCheck: string;
+  /** Additional environment variables passed to the Python process */
+  env?: Record<string, string>;
+}
+
+export interface ServicesConfig {
+  python?: PythonServiceConfig;
+}
+
+export interface ServerConfig {
+  port?: number;
+  host?: string;
+}
+
+export interface SwiteUserConfig {
+  server?: ServerConfig;
+  services?: ServicesConfig;
+}
+
+/**
+ * Define swite configuration with full TypeScript validation.
+ * Unknown fields are rejected at compile time.
+ */
+export function defineConfig(config: SwiteUserConfig): SwiteUserConfig {
+  return config;
+}

package/src/config/env.ts

@@ -0,0 +1,98 @@
+/*
+ * Environment Variable Support for SWITE
+ * Provides import.meta.env replacement for SWITE
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+export interface EnvConfig {
+  mode?: "development" | "production";
+  prefix?: string; // Default: "SWITE_"
+}
+
+/**
+ * Load environment variables from .env files.
+ * Supports .env, .env.local, .env.[mode], .env.[mode].local
+ */
+export function loadEnv(
+  root: string,
+  mode: string = "development",
+  prefix: string = "SWITE_",
+): Record<string, string> {
+  const env: Record<string, string> = {};
+  const envFiles = [`.env.${mode}.local`, `.env.${mode}`, `.env.local`, `.env`];
+
+  for (const file of envFiles) {
+    const envPath = join(root, file);
+    if (!existsSync(envPath)) continue;
+    const content = readFileSync(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const match = trimmed.match(/^([^=]+)=(.*)$/);
+      if (!match) continue;
+      const key = match[1].trim();
+      const value = match[2].replace(/^["']|["']$/g, "");
+      if (key.startsWith(prefix) || key.startsWith("PUBLIC_")) {
+        env[key] = value;
+      }
+    }
+  }
+
+  return env;
+}
+
+/**
+ * Replace all import.meta.env references in compiled code with their literal values.
+ *
+ * This is the only correct approach for ES modules — import.meta is sealed and
+ * import.meta.env cannot be assigned at runtime. All substitution must happen at
+ * transform time (here, after esbuild strips TypeScript).
+ *
+ * Handles:
+ *  - import.meta.env.KEY  → JSON.stringify(env[KEY]) or "undefined"
+ *  - import.meta.env.DEV  → true/false literal
+ *  - import.meta.env.PROD → true/false literal
+ *  - import.meta.env.MODE → "development"/"production" literal
+ *  - bare import.meta.env → serialized object literal (for spread, typeof, etc.)
+ */
+export function inlineEnvReferences(
+  code: string,
+  env: Record<string, string>,
+  mode: string = "development",
+): string {
+  if (!code.includes("import.meta.env")) return code;
+
+  const isDev = mode !== "production";
+
+  // Named key access first (most specific)
+  code = code.replace(/\bimport\.meta\.env\.([A-Z_][A-Z0-9_]*)\b/g, (_, key: string) => {
+    if (key === "DEV") return String(isDev);
+    if (key === "PROD") return String(!isDev);
+    if (key === "MODE") return JSON.stringify(mode);
+    if (key === "SSR") return "false";
+    if (key in env) return JSON.stringify(env[key]);
+    return "undefined";
+  });
+
+  // Bare import.meta.env (spread/typeof patterns)
+  if (code.includes("import.meta.env")) {
+    const envLiteral = buildEnvLiteral(env, mode);
+    code = code.replace(/\bimport\.meta\.env\b/g, envLiteral);
+  }
+
+  return code;
+}
+
+function buildEnvLiteral(env: Record<string, string>, mode: string): string {
+  const isDev = mode !== "production";
+  const entries: string[] = [
+    `MODE:${JSON.stringify(mode)}`,
+    `DEV:${isDev}`,
+    `PROD:${!isDev}`,
+    `SSR:false`,
+    ...Object.entries(env).map(([k, v]) => `${JSON.stringify(k)}:${JSON.stringify(v)}`),
+  ];
+  return `({${entries.join(",")}})`;
+}

package/src/dev-engine/handlers/base-handler.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import type { Response } from "express";
+import { promises as fs } from "node:fs";
+import { ModuleResolver } from "../../resolution/resolver.js";
+import { resolveFilePath } from "../../resolution/path/file-path-resolver.js";
+
+export interface HandlerContext {
+  resolver: ModuleResolver;
+  root: string;
+  workspaceRoot: string | null;
+  env: Record<string, string>;
+}
+
+/**
+ * Set cache-busting headers for development
+ */
+export function setDevHeaders(res: Response): void {
+  // Prevent all caching during development
+  res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+  res.setHeader("Pragma", "no-cache");
+  res.setHeader("Expires", "0");
+  res.setHeader("Surrogate-Control", "no-store");
+}
+
+/**
+ * Base handler utilities
+ */
+export class BaseHandler {
+  constructor(protected context: HandlerContext) {}
+
+  protected async resolveFilePath(url: string): Promise<string> {
+    return resolveFilePath(url, this.context.root, this.context.workspaceRoot);
+  }
+
+  protected async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  protected async getDependencies(compiled: string): Promise<string[]> {
+    const deps: string[] = [];
+    const importPattern = /(?:import|from|export).*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importPattern.exec(compiled)) !== null) {
+      const specifier = match[1];
+      if (specifier.startsWith("/") || specifier.startsWith("@")) {
+        try {
+          const resolved = await this.context.resolver.resolve(specifier, "");
+          if (resolved && !resolved.startsWith("http")) {
+            deps.push(resolved);
+          }
+        } catch {
+          // ignore resolution errors during dependency tracking
+        }
+      }
+    }
+    return deps;
+  }
+}

package/src/dev-engine/handlers/js-handler.ts

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import type { Response } from "express";
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { rewriteImports } from "../../resolution/rewriting/import-rewriter.js";
+import {
+  BaseHandler,
+  setDevHeaders,
+  type HandlerContext,
+} from "./base-handler.js";
+import { UIHandler } from "./ui-handler.js";
+import { UIXHandler } from "./uix-handler.js";
+import { TSHandler } from "./ts-handler.js";
+
+export class JSHandler extends BaseHandler {
+  private uiHandler: UIHandler;
+  private uixHandler: UIXHandler;
+  private tsHandler: TSHandler;
+
+  constructor(context: HandlerContext) {
+    super(context);
+    this.uiHandler = new UIHandler(context);
+    this.uixHandler = new UIXHandler(context);
+    this.tsHandler = new TSHandler(context);
+  }
+
+  async handle(url: string, res: Response): Promise<void> {
+    const filePath = await this.resolveFilePath(url);
+
+    // Check if .js file exists, if not try .ts, .ui, .uix
+    try {
+      await fs.access(filePath);
+    } catch {
+      // .js doesn't exist, try alternatives
+      const basePath = filePath.slice(0, -3); // Remove .js
+      const alternatives = [
+        {
+          ext: ".ts",
+          handler: () =>
+            this.tsHandler.handle(url.replace(/\.js$/, ".ts"), res),
+        },
+        {
+          ext: ".ui",
+          handler: () =>
+            this.uiHandler.handle(url.replace(/\.js$/, ".ui"), res),
+        },
+        {
+          ext: ".uix",
+          handler: () =>
+            this.uixHandler.handle(url.replace(/\.js$/, ".uix"), res),
+        },
+      ];
+
+      for (const alt of alternatives) {
+        try {
+          const altPath = basePath + alt.ext;
+          await fs.access(altPath);
+          console.log(
+            chalk.yellow(
+              `[.js→${alt.ext}] ${url} → ${url.replace(/\.js$/, alt.ext)} (file: ${altPath})`,
+            ),
+          );
+          return await alt.handler();
+        } catch {
+          // Try next alternative
+          console.log(
+            chalk.gray(
+              `[.js→${alt.ext}] ${basePath + alt.ext} not found, trying next...`,
+            ),
+          );
+        }
+      }
+
+      // No alternatives found, throw error
+      console.error(
+        chalk.red(`[.js] File not found: ${url} (tried .js, .ts, .ui, .uix)`),
+      );
+      console.error(chalk.red(`[.js] filePath was: ${filePath}`));
+      console.error(chalk.red(`[.js] basePath was: ${basePath}`));
+      throw new Error(`File not found: ${url} (tried .js, .ts, .ui, .uix)`);
+    }
+
+    // .js file exists, process it normally
+    const source = await fs.readFile(filePath, "utf-8");
+
+    // Debug: Check for bare imports (including simple npm packages like bcryptjs)
+    const bareImportPattern =
+      /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)[^'"]*['"]/;
+    const simpleNpmPattern =
+      /(?:import|from|export).*['"]([a-zA-Z][a-zA-Z0-9_-]*)[^'"]*['"]/;
+    if (bareImportPattern.test(source) || simpleNpmPattern.test(source)) {
+      console.log(chalk.yellow(`[.js] Found imports in ${url}, rewriting...`));
+      // Log the actual imports found
+      const importMatches = source.matchAll(
+        /(?:import|from)\s+['"]([^'"]+)['"]/g,
+      );
+      for (const match of importMatches) {
+        console.log(chalk.cyan(`[.js] Found import: ${match[1]}`));
+      }
+    }
+
+    const rewritten = await rewriteImports(
+      source,
+      filePath,
+      this.context.resolver,
+    );
+
+    // Debug: Verify no bare imports remain after rewriting
+    if (bareImportPattern.test(rewritten)) {
+      console.error(
+        chalk.red(
+          `[.js] WARNING: Bare imports still present in ${url} after rewriting!`,
+        ),
+      );
+      const matches = Array.from(
+        rewritten.matchAll(
+          /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)[^'"]*['"]/g,
+        ),
+      );
+      for (const match of matches.slice(0, 3)) {
+        console.error(chalk.red(`[.js] Unresolved: ${match[1]}`));
+      }
+    }
+
+    setDevHeaders(res);
+    res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+    res.send(rewritten);
+  }
+}

package/src/dev-engine/handlers/mjs-handler.ts

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import type { Response } from "express";
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { rewriteImports } from "../../resolution/rewriting/import-rewriter.js";
+import {
+  BaseHandler,
+  setDevHeaders,
+  type HandlerContext,
+} from "./base-handler.js";
+import { JSHandler } from "./js-handler.js";
+
+export class MJSHandler extends BaseHandler {
+  private jsHandler: JSHandler;
+
+  constructor(context: HandlerContext) {
+    super(context);
+    this.jsHandler = new JSHandler(context);
+  }
+
+  async handle(url: string, res: Response): Promise<void> {
+    const filePath = await this.resolveFilePath(url);
+
+    // Check if .mjs file exists
+    try {
+      await fs.access(filePath);
+    } catch {
+      // .mjs doesn't exist, try .js as fallback
+      const jsPath = filePath.replace(/\.mjs$/, ".js");
+      try {
+        await fs.access(jsPath);
+        console.log(
+          chalk.yellow(
+            `[.mjs→.js] ${url} → ${url.replace(/\.mjs$/, ".js")} (file: ${jsPath})`,
+          ),
+        );
+        return await this.jsHandler.handle(url.replace(/\.mjs$/, ".js"), res);
+      } catch {
+        console.error(
+          chalk.red(`[.mjs] File not found: ${url} (tried .mjs, .js)`),
+        );
+        throw new Error(`File not found: ${url} (tried .mjs, .js)`);
+      }
+    }
+
+    // .mjs file exists, process it normally
+    const source = await fs.readFile(filePath, "utf-8");
+    const rewritten = await rewriteImports(
+      source,
+      filePath,
+      this.context.resolver,
+    );
+
+    // Set proper MIME type for ES modules (.mjs)
+    // According to MDN Web Standards: .mjs files should use "application/javascript"
+    setDevHeaders(res);
+    res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+    res.send(rewritten);
+  }
+}