station-kit 1.0.6 → 1.0.7

package/src/cli/parse-args.ts

@@ -0,0 +1,99 @@
+export interface CliArgs {
+  port?: number;
+  host?: string;
+  dir?: string;
+  noOpen?: boolean;
+  noRunners?: boolean;
+  config?: string;
+  subcommand?: string;
+  help?: boolean;
+}
+
+const FLAGS_WITH_VALUE = new Set(["--port", "--host", "--dir", "--config"]);
+
+export function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = {};
+  let i = 0;
+
+  while (i < argv.length) {
+    const arg = argv[i];
+
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+      i++;
+      continue;
+    }
+
+    if (arg === "--no-open") {
+      args.noOpen = true;
+      i++;
+      continue;
+    }
+
+    if (arg === "--no-runners" || arg === "--read-only") {
+      args.noRunners = true;
+      i++;
+      continue;
+    }
+
+    if (FLAGS_WITH_VALUE.has(arg)) {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith("--")) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+
+      switch (arg) {
+        case "--port": {
+          const n = parseInt(value, 10);
+          if (isNaN(n) || n < 1 || n > 65535) {
+            throw new Error(`Invalid port: ${value}`);
+          }
+          args.port = n;
+          break;
+        }
+        case "--host":
+          args.host = value;
+          break;
+        case "--dir":
+          args.dir = value;
+          break;
+        case "--config":
+          args.config = value;
+          break;
+      }
+
+      i += 2;
+      continue;
+    }
+
+    // First positional arg that doesn't start with -- is a subcommand
+    if (!arg.startsWith("-")) {
+      args.subcommand = arg;
+      i++;
+      continue;
+    }
+
+    throw new Error(`Unknown flag: ${arg}`);
+  }
+
+  return args;
+}
+
+export function printUsage(): void {
+  console.log(`
+Usage: station [command] [options]
+
+Commands:
+  deploy          Generate deployment files (Dockerfile, nixpacks.toml)
+
+Options:
+  --port <n>      Override server port (default: 4400)
+  --host <s>      Override server host (default: localhost)
+  --dir <path>    Set station directory for generated files (default: .station)
+  --config <path> Path to config file (default: station.config.ts)
+  --no-open       Don't open browser on start
+  --no-runners    Don't execute signal/broadcast runners (read-only mode)
+  --read-only     Alias for --no-runners
+  -h, --help      Show this help message
+`.trim());
+}

package/src/cli-main.ts

@@ -1,11 +1,38 @@
 import { loadConfig } from "./config/loader.js";
 import { createStation } from "./server/index.js";
+import { parseArgs, printUsage } from "./cli/parse-args.js";
 import { spawn, type ChildProcess } from "node:child_process";
 import { resolve } from "node:path";
 import { existsSync } from "node:fs";
 
+// Parse CLI arguments
+const cliArgs = parseArgs(process.argv.slice(2));
+
+if (cliArgs.help) {
+  printUsage();
+  process.exit(0);
+}
+
+if (cliArgs.subcommand === "deploy") {
+  await import("./cli/deploy.js");
+  process.exit(0);
+}
+
+if (cliArgs.subcommand) {
+  console.error(`[station] Unknown command: ${cliArgs.subcommand}`);
+  printUsage();
+  process.exit(1);
+}
+
 const cwd = process.cwd();
-const config = await loadConfig(cwd);
+const config = await loadConfig(cwd, cliArgs.config);
+
+// Apply CLI overrides
+if (cliArgs.port !== undefined) config.port = cliArgs.port;
+if (cliArgs.host !== undefined) config.host = cliArgs.host;
+if (cliArgs.dir !== undefined) config.stationDir = cliArgs.dir;
+if (cliArgs.noOpen) config.open = false;
+if (cliArgs.noRunners) config.runRunners = false;
 
 // Spawn Next.js standalone server for the dashboard
 const pkgRoot = resolve(import.meta.dirname, "..");

package/src/cli.ts

@@ -23,7 +23,7 @@ if (!process.env[MARKER]) {
   }
 
   const main = fileURLToPath(new URL("./cli-main.js", import.meta.url));
-  const child = spawn(execPath, ["--import", tsxSpecifier, main], {
+  const child = spawn(execPath, ["--import", tsxSpecifier, main, ...process.argv.slice(2)], {
     stdio: "inherit",
     env: { ...process.env, [MARKER]: "1", __STATION_TSX: tsxSpecifier },
   });

package/src/config/loader.ts

@@ -9,10 +9,14 @@ const CONFIG_NAMES = [
   "station.config.mjs",
 ];
 
-export async function loadConfig(cwd: string): Promise<StationConfig> {
-  const configPath = findConfigFile(cwd);
+export async function loadConfig(cwd: string, configFile?: string): Promise<StationConfig> {
+  const configPath = configFile ? resolve(cwd, configFile) : findConfigFile(cwd);
 
-  if (!configPath) {
+  if (!configPath || !existsSync(configPath)) {
+    if (configFile) {
+      console.error(`[station] Config file not found: ${configFile}`);
+      process.exit(1);
+    }
     console.log("[station] No config file found. Using defaults.");
     return resolveConfig({});
   }

package/src/config/schema.ts

@@ -18,6 +18,10 @@ export interface BroadcastRunnerConfig {
   pollIntervalMs: number;
 }
 
+export interface DeployConfig {
+  include?: string[];
+}
+
 export interface StationConfig {
   port: number;
   host: string;
@@ -25,12 +29,14 @@ export interface StationConfig {
   broadcastAdapter?: BroadcastQueueAdapter;
   signalsDir?: string;
   broadcastsDir?: string;
+  stationDir: string;
   runner: RunnerConfig;
   broadcastRunner: BroadcastRunnerConfig;
   runRunners: boolean;
   open: boolean;
   logLevel: "debug" | "info" | "warn" | "error";
   auth?: AuthConfig;
+  deploy?: DeployConfig;
 }
 
 export type StationUserConfig = Partial<Omit<StationConfig, "runner" | "broadcastRunner">> & {
@@ -41,6 +47,7 @@ export type StationUserConfig = Partial<Omit<StationConfig, "runner" | "broadcas
 const DEFAULTS: StationConfig = {
   port: 4400,
   host: "localhost",
+  stationDir: ".station",
   runner: {
     pollIntervalMs: 1000,
     maxConcurrent: 5,
@@ -56,13 +63,31 @@ const DEFAULTS: StationConfig = {
 };
 
 export function resolveConfig(input: StationUserConfig): StationConfig {
+  const envPort = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
+  const envHost = process.env.HOST;
+  const envAuthUser = process.env.STATION_AUTH_USERNAME;
+  const envAuthPass = process.env.STATION_AUTH_PASSWORD;
+
+  // Env vars for auth: override config values, or create auth if both are set
+  let auth = input.auth;
+  if (auth) {
+    auth = {
+      ...auth,
+      username: envAuthUser ?? auth.username,
+      password: envAuthPass ?? auth.password,
+    };
+  } else if (envAuthUser && envAuthPass) {
+    auth = { username: envAuthUser, password: envAuthPass };
+  }
+
   return {
-    port: input.port ?? DEFAULTS.port,
-    host: input.host ?? DEFAULTS.host,
+    port: input.port ?? envPort ?? DEFAULTS.port,
+    host: input.host ?? envHost ?? DEFAULTS.host,
     adapter: input.adapter,
     broadcastAdapter: input.broadcastAdapter,
     signalsDir: input.signalsDir,
     broadcastsDir: input.broadcastsDir,
+    stationDir: input.stationDir ?? DEFAULTS.stationDir,
     runner: {
       pollIntervalMs: input.runner?.pollIntervalMs ?? DEFAULTS.runner.pollIntervalMs,
       maxConcurrent: input.runner?.maxConcurrent ?? DEFAULTS.runner.maxConcurrent,
@@ -75,6 +100,7 @@ export function resolveConfig(input: StationUserConfig): StationConfig {
     runRunners: input.runRunners ?? DEFAULTS.runRunners,
     open: input.open ?? DEFAULTS.open,
     logLevel: input.logLevel ?? DEFAULTS.logLevel,
-    auth: input.auth,
+    auth,
+    deploy: input.deploy,
   };
 }

package/src/index.ts

@@ -4,4 +4,4 @@ export function defineConfig(config: StationUserConfig): StationUserConfig {
   return config;
 }
 
-export type { StationConfig, StationUserConfig, AuthConfig } from "./config/schema.js";
+export type { StationConfig, StationUserConfig, AuthConfig, DeployConfig } from "./config/schema.js";

package/src/server/index.ts

@@ -9,6 +9,7 @@ import { BroadcastRunner, BroadcastMemoryAdapter } from "station-broadcast";
 import type { SignalQueueAdapter } from "station-signal";
 import type { BroadcastQueueAdapter } from "station-broadcast";
 import type { StationConfig } from "../config/schema.js";
+import { ensureStationDir } from "../station-dir.js";
 import { WebSocketHub } from "./ws.js";
 import { SSEHub } from "./sse.js";
 import { LogBuffer } from "./log-buffer.js";
@@ -42,17 +43,19 @@ export async function createStation(config: StationConfig, cwd: string, nextPort
   const broadcastAdapter: BroadcastQueueAdapter | undefined =
     config.broadcastAdapter ?? (config.broadcastsDir ? new BroadcastMemoryAdapter() : undefined);
 
+  const { dataDir } = ensureStationDir(cwd, config.stationDir);
+
   const wsHub = new WebSocketHub();
   const sseHub = new SSEHub();
   const logBuffer = new LogBuffer();
-  const logStore = new LogStore(resolve(cwd, "station-logs.db"));
+  const logStore = new LogStore(resolve(dataDir, "station-logs.db"));
 
   // Auth: create KeyStore and SessionConfig if auth is configured
   let keyStore: KeyStore | undefined;
   let sessionConfig: SessionConfig | undefined;
 
   if (config.auth) {
-    keyStore = new KeyStore(resolve(cwd, "station-keys.db"));
+    keyStore = new KeyStore(resolve(dataDir, "station-keys.db"));
     sessionConfig = {
       username: config.auth.username,
       password: config.auth.password,

package/src/station-dir.ts

@@ -0,0 +1,24 @@
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+
+export interface StationDirs {
+  baseDir: string;
+  dataDir: string;
+  outDir: string;
+}
+
+export function ensureStationDir(cwd: string, stationDir: string): StationDirs {
+  const baseDir = resolve(cwd, stationDir);
+  const dataDir = join(baseDir, "data");
+  const outDir = join(baseDir, "out");
+
+  mkdirSync(dataDir, { recursive: true });
+  mkdirSync(outDir, { recursive: true });
+
+  const gitignorePath = join(baseDir, ".gitignore");
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, "data/\n");
+  }
+
+  return { baseDir, dataDir, outDir };
+}