@chidchanun/bcp 0.1.0

package/packages/cli/bin/bcp.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import {
+    spawn,
+} from "node:child_process";
+import {
+    fileURLToPath,
+} from "node:url";
+
+const bootstrapFile =
+    fileURLToPath(
+        new URL(
+            "../src/bootstrap.ts",
+            import.meta.url
+        )
+    );
+
+const tsxImport =
+    import.meta.resolve(
+        "tsx"
+    );
+
+const child =
+    spawn(
+        process.execPath,
+        [
+            "--import",
+            tsxImport,
+            bootstrapFile,
+            ...process.argv.slice(2),
+        ],
+        {
+            cwd:
+                process.cwd(),
+            env:
+                process.env,
+            stdio:
+                "inherit",
+        }
+    );
+
+for (
+    const signal
+    of [
+        "SIGINT",
+        "SIGTERM",
+    ]
+) {
+    process.once(
+        signal,
+        () => {
+            if (
+                child.exitCode === null &&
+                child.signalCode === null
+            ) {
+                child.kill(
+                    signal
+                );
+            }
+        }
+    );
+}
+
+child.once(
+    "error",
+    (error) => {
+        console.error(
+            "BCP Framework CLI failed to start:",
+            error
+        );
+        process.exitCode =
+            1;
+    }
+);
+
+child.once(
+    "exit",
+    (
+        code,
+        signal
+    ) => {
+        if (signal) {
+            process.kill(
+                process.pid,
+                signal
+            );
+            return;
+        }
+
+        process.exitCode =
+            code ?? 1;
+    }
+);

package/packages/cli/src/args.ts

@@ -0,0 +1,305 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export type CliCommand =
+  | "dev"
+  | "build"
+  | "start"
+  | "routes"
+  | "help"
+  | "version";
+
+export interface CliOptions {
+  command: CliCommand;
+
+  rootDirectory?: string;
+
+  port?: number;
+
+  hostname?: string;
+}
+
+export function parseCliArgs(
+  argv: string[]
+): CliOptions {
+  let command: CliCommand = "dev";
+
+  let rootDirectory:
+    string | undefined;
+
+  let port:
+    number | undefined;
+
+  let hostname:
+    string | undefined;
+
+  let commandSet = false;
+
+  for (
+    let index = 0;
+    index < argv.length;
+    index++
+  ) {
+    const argument = argv[index];
+
+    if (
+      argument === "-h" ||
+      argument === "--help"
+    ) {
+      command = "help";
+      continue;
+    }
+
+    if (
+      argument === "-v" ||
+      argument === "--version"
+    ) {
+      command = "version";
+      continue;
+    }
+
+    if (
+      argument === "--root"
+    ) {
+      rootDirectory =
+        requireValue(
+          argv,
+          ++index,
+          "--root"
+        );
+
+      continue;
+    }
+
+    if (
+      argument.startsWith(
+        "--root="
+      )
+    ) {
+      rootDirectory =
+        argument.slice(
+          "--root=".length
+        );
+
+      continue;
+    }
+
+    if (
+      argument === "--port"
+    ) {
+      port = parsePort(
+        requireValue(
+          argv,
+          ++index,
+          "--port"
+        )
+      );
+
+      continue;
+    }
+
+    if (
+      argument.startsWith(
+        "--port="
+      )
+    ) {
+      port = parsePort(
+        argument.slice(
+          "--port=".length
+        )
+      );
+
+      continue;
+    }
+
+    if (
+      argument === "--hostname" ||
+      argument === "--host"
+    ) {
+      hostname =
+        requireValue(
+          argv,
+          ++index,
+          argument
+        );
+
+      continue;
+    }
+
+    if (
+      argument.startsWith(
+        "--hostname="
+      )
+    ) {
+      hostname =
+        argument.slice(
+          "--hostname=".length
+        );
+
+      continue;
+    }
+
+    if (
+      argument.startsWith(
+        "--host="
+      )
+    ) {
+      hostname =
+        argument.slice(
+          "--host=".length
+        );
+
+      continue;
+    }
+
+    if (
+      argument.startsWith("-")
+    ) {
+      throw new Error(
+        `Unknown option: ${argument}`
+      );
+    }
+
+    /**
+     * npm compatibility
+     *
+     * Some npm environments may consume an unknown script
+     * option such as --port and leave only its numeric value
+     * in argv. Accept a bare number for dev/start servers.
+     */
+    if (
+      isPortShortcut(argument) &&
+      (
+        !commandSet ||
+        command === "dev" ||
+        command === "start"
+      )
+    ) {
+      port = parsePort(argument);
+      continue;
+    }
+
+    if (commandSet) {
+      throw new Error(
+        `Unexpected argument: ${argument}`
+      );
+    }
+
+    if (
+      argument === "dev" ||
+      argument === "build" ||
+      argument === "start" ||
+      argument === "routes" ||
+      argument === "help" ||
+      argument === "version"
+    ) {
+      command = argument;
+      commandSet = true;
+      continue;
+    }
+
+    throw new Error(
+      `Unknown command: ${argument}`
+    );
+  }
+
+  return {
+    command,
+    rootDirectory,
+    port,
+    hostname,
+  };
+}
+
+export function resolveProjectRoot(
+  rootDirectory?: string
+): string {
+  if (rootDirectory) {
+    return path.resolve(
+      process.cwd(),
+      rootDirectory
+    );
+  }
+
+  const currentDirectory =
+    process.cwd();
+
+  if (
+    hasAppDirectory(
+      currentDirectory
+    )
+  ) {
+    return currentDirectory;
+  }
+
+  const exampleDirectory =
+    path.join(
+      currentDirectory,
+      "examples",
+      "basic-app"
+    );
+
+  if (
+    hasAppDirectory(
+      exampleDirectory
+    )
+  ) {
+    return exampleDirectory;
+  }
+
+  return currentDirectory;
+}
+
+function hasAppDirectory(
+  directory: string
+): boolean {
+  return fs.existsSync(
+    path.join(
+      directory,
+      "app"
+    )
+  );
+}
+
+function requireValue(
+  argv: string[],
+  index: number,
+  option: string
+): string {
+  const value = argv[index];
+
+  if (
+    !value ||
+    value.startsWith("-")
+  ) {
+    throw new Error(
+      `Option ${option} requires a value.`
+    );
+  }
+
+  return value;
+}
+
+function parsePort(
+  value: string
+): number {
+  const port = Number(value);
+
+  if (
+    !Number.isInteger(port) ||
+    port < 1 ||
+    port > 65535
+  ) {
+    throw new Error(
+      `Invalid port: ${value}. Port must be an integer between 1 and 65535.`
+    );
+  }
+
+  return port;
+}
+
+function isPortShortcut(
+  value: string
+): boolean {
+  return /^\d+$/.test(value);
+}