@tothalex/nulljs 0.0.54 → 0.0.57

package/dist/cli.js

@@ -0,0 +1,2553 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+// ../../packages/api/types/index.ts
+var init_types = () => {};
+
+// ../../packages/api/actions/client.ts
+var buildUrl = (path, options) => {
+  let fullPath = options?.url ? `${options.url}${path}` : path;
+  if (options?.query) {
+    const params = [];
+    for (const [key, value] of Object.entries(options.query)) {
+      if (value === undefined || value === null)
+        continue;
+      if (Array.isArray(value)) {
+        params.push(`${key}=${value.join(",")}`);
+      } else {
+        params.push(`${key}=${encodeURIComponent(String(value))}`);
+      }
+    }
+    const queryString = params.join("&");
+    if (queryString) {
+      fullPath = `${fullPath}?${queryString}`;
+    }
+  }
+  return fullPath;
+}, apiGet = async (path, options) => {
+  const url = options?.url ? `${options.url}${path}` : path;
+  const headers = {};
+  if (options?.publicKey) {
+    headers["x-public-key"] = options.publicKey;
+  }
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    const message = await response.text().catch(() => "");
+    throw new Error(`HTTP error! status: ${response.status}${message ? ` message: ${message}` : ""}`);
+  }
+  return response.json();
+};
+
+// ../../packages/api/actions/deployments.ts
+var init_deployments = () => {};
+
+// ../../packages/api/actions/deploy.ts
+var getMimeType = (fileName) => {
+  if (fileName.endsWith(".js"))
+    return "application/javascript";
+  if (fileName.endsWith(".css"))
+    return "text/css";
+  if (fileName.endsWith(".html"))
+    return "text/html";
+  if (fileName.endsWith(".json"))
+    return "application/json";
+  return "application/octet-stream";
+}, createFormDataWithInfo = (assets2) => {
+  const form = new FormData;
+  const blobs = [];
+  for (const asset of assets2) {
+    const mime = getMimeType(asset.fileName);
+    const buffer = Buffer.from(asset.code);
+    const blob = new Blob([buffer], { type: mime });
+    form.append(asset.fileName, blob);
+    blobs.push({ fileName: asset.fileName, size: blob.size, type: mime });
+  }
+  return { form, blobs };
+}, createSignature = async (blobs, privateKey) => {
+  const sortedBlobs = [...blobs].sort((a, b) => a.fileName.localeCompare(b.fileName));
+  const dataString = sortedBlobs.map((b) => `${b.fileName}:${b.size}:${b.type}`).join("|");
+  const sign = await crypto.subtle.sign("Ed25519", privateKey, Buffer.from(dataString));
+  return btoa(String.fromCharCode(...new Uint8Array(sign)));
+}, createFunctionDeployment = async (deployment2, options) => {
+  const handler = deployment2.assets.find((asset) => asset.fileName === "handler.js");
+  if (!handler) {
+    throw new Error(`Handler not found for ${deployment2.name}`);
+  }
+  const { form, blobs } = createFormDataWithInfo([handler]);
+  const signature = await createSignature(blobs, options.privateKey);
+  const baseUrl = options.url || "";
+  const response = await fetch(`${baseUrl}/api/deployment`, {
+    method: "POST",
+    headers: {
+      authorization: signature
+    },
+    body: form
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Deployment failed (${response.status}): ${errorText}`);
+  }
+}, createReactDeployment = async (deployment2, options) => {
+  const { form, blobs } = createFormDataWithInfo(deployment2.assets);
+  const signature = await createSignature(blobs, options.privateKey);
+  const baseUrl = options.url || "";
+  const response = await fetch(`${baseUrl}/api/deployment/react`, {
+    method: "POST",
+    headers: {
+      authorization: signature
+    },
+    body: form
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Deployment failed (${response.status}): ${errorText}`);
+  }
+};
+
+// ../../packages/api/actions/invocations.ts
+var init_invocations = () => {};
+
+// ../../packages/api/actions/logs.ts
+var getSystemLogs = async (public_key, query, url) => {
+  const path = buildUrl("/api/system/logs", { url, query });
+  return apiGet(path, { publicKey: public_key });
+}, searchDeploymentLogs = async (public_key, props, url) => {
+  const path = buildUrl("/api/logs/search", { url, query: props });
+  return apiGet(path, { publicKey: public_key });
+};
+var init_logs = () => {};
+
+// ../../packages/api/actions/assets.ts
+var init_assets = () => {};
+
+// ../../packages/api/actions/activity.ts
+var init_activity = () => {};
+
+// ../../packages/api/actions/secrets.ts
+var createSignatureHeader = async (privateKey, props) => {
+  const timestamp = new Date().toISOString();
+  const raw = `${props.method}-${props.path}-${timestamp}${props.body ? "-" + props.body : ""}`;
+  const sign = await crypto.subtle.sign("Ed25519", privateKey, Buffer.from(raw));
+  const signature = btoa(String.fromCharCode(...new Uint8Array(sign)));
+  const header = {
+    authorization: signature,
+    "x-time": timestamp
+  };
+  if (props.body) {
+    header["x-body"] = btoa(props.body);
+  }
+  return header;
+}, listSecrets = async (options) => {
+  const baseUrl = options.url || "";
+  const path = `${baseUrl}/api/secrets`;
+  const headers = await createSignatureHeader(options.privateKey, {
+    method: "GET",
+    path
+  });
+  let response;
+  try {
+    response = await fetch(path, {
+      method: "GET",
+      headers
+    });
+  } catch (err) {
+    throw new Error(`Network error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to list secrets (${response.status}): ${errorText}`);
+  }
+  return response.json();
+}, createSecret = async (secret, options) => {
+  const baseUrl = options.url || "";
+  const path = `${baseUrl}/api/secrets`;
+  const body = JSON.stringify(secret);
+  const headers = await createSignatureHeader(options.privateKey, {
+    method: "POST",
+    path,
+    body
+  });
+  const response = await fetch(path, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    body
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to create secret (${response.status}): ${errorText}`);
+  }
+};
+
+// ../../packages/api/actions/index.ts
+var init_actions = __esm(() => {
+  init_deployments();
+  init_invocations();
+  init_logs();
+  init_assets();
+  init_activity();
+});
+
+// ../../packages/api/index.ts
+var init_api = __esm(() => {
+  init_types();
+  init_actions();
+});
+
+// src/config/index.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+var getLocalConfigDir = () => join(process.cwd(), ".nulljs"), getLocalConfigFile = () => join(getLocalConfigDir(), "config.json"), ensureLocalConfigDir = () => {
+  const localDir = getLocalConfigDir();
+  if (!existsSync(localDir)) {
+    mkdirSync(localDir, { recursive: true });
+  }
+}, readConfigStore = () => {
+  try {
+    const localFile = getLocalConfigFile();
+    if (!existsSync(localFile)) {
+      return null;
+    }
+    const data = readFileSync(localFile, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}, writeConfigStore = (store) => {
+  ensureLocalConfigDir();
+  writeFileSync(getLocalConfigFile(), JSON.stringify(store, null, 2));
+}, readLocalConfig = () => {
+  const store = readConfigStore();
+  if (!store)
+    return null;
+  return store.configs[store.current] ?? null;
+}, getConfig = (name) => {
+  const store = readConfigStore();
+  if (!store)
+    return null;
+  return store.configs[name] ?? null;
+}, listConfigs = () => {
+  const store = readConfigStore();
+  if (!store)
+    return null;
+  return {
+    configs: Object.values(store.configs),
+    current: store.current
+  };
+}, useConfig = (name) => {
+  const store = readConfigStore();
+  if (!store) {
+    console.error(chalk.red('\u2717 No configurations found. Run "nulljs dev" first.'));
+    return false;
+  }
+  if (!store.configs[name]) {
+    console.error(chalk.red(`\u2717 Config "${name}" not found.`));
+    console.log(chalk.gray("Available configs:"));
+    Object.keys(store.configs).forEach((n) => {
+      console.log(chalk.gray(`  - ${n}`));
+    });
+    return false;
+  }
+  store.current = name;
+  writeConfigStore(store);
+  console.log(chalk.green(`\u2713 Now using config "${name}"`));
+  return true;
+}, createConfig = async (name, api) => {
+  const store = readConfigStore() ?? { current: "dev", configs: {} };
+  if (store.configs[name]) {
+    console.error(chalk.red(`\u2717 Config "${name}" already exists.`));
+    process.exit(1);
+  }
+  const keyPair = await crypto.subtle.generateKey({
+    name: "Ed25519",
+    namedCurve: "Ed25519"
+  }, true, ["sign", "verify"]);
+  const privateKeyBuffer = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+  const publicKeyBuffer = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+  const privateKey = btoa(String.fromCharCode(...new Uint8Array(privateKeyBuffer)));
+  const publicKey = btoa(String.fromCharCode(...new Uint8Array(publicKeyBuffer)));
+  const newConfig = {
+    name,
+    key: {
+      public: publicKey,
+      private: privateKey
+    },
+    api
+  };
+  store.configs[name] = newConfig;
+  writeConfigStore(store);
+  console.log(chalk.green(`\u2713 Config "${name}" created`));
+  console.log(chalk.blue("  API:") + ` ${api}`);
+  console.log(chalk.blue("  Public Key:") + ` ${publicKey.substring(0, 30)}...`);
+  return newConfig;
+}, getOrCreateLocalDevConfig = async (api = "http://localhost:3000") => {
+  const store = readConfigStore();
+  if (store?.configs["dev"]) {
+    return store.configs["dev"];
+  }
+  const keyPair = await crypto.subtle.generateKey({
+    name: "Ed25519",
+    namedCurve: "Ed25519"
+  }, true, ["sign", "verify"]);
+  const privateKeyBuffer = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+  const publicKeyBuffer = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+  const privateKey = btoa(String.fromCharCode(...new Uint8Array(privateKeyBuffer)));
+  const publicKey = btoa(String.fromCharCode(...new Uint8Array(publicKeyBuffer)));
+  const devConfig = {
+    name: "dev",
+    key: {
+      public: publicKey,
+      private: privateKey
+    },
+    api
+  };
+  const newStore = store ?? { current: "dev", configs: {} };
+  newStore.configs["dev"] = devConfig;
+  newStore.current = "dev";
+  writeConfigStore(newStore);
+  return devConfig;
+}, loadPrivateKey = async (config) => {
+  const privateKeyBytes = Uint8Array.from(atob(config.key.private), (c) => c.charCodeAt(0));
+  return crypto.subtle.importKey("pkcs8", privateKeyBytes, { name: "Ed25519", namedCurve: "Ed25519" }, false, ["sign"]);
+};
+var init_config = () => {};
+
+// src/lib/server.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, realpathSync } from "fs";
+import { join as join2, dirname } from "path";
+import chalk2 from "chalk";
+var CLI_DIR, PLATFORMS, getPlatformKey = () => {
+  return `${process.platform}-${process.arch}`;
+}, findProjectRoot = (startPath = process.cwd()) => {
+  let currentPath = startPath;
+  while (currentPath !== dirname(currentPath)) {
+    if (existsSync2(join2(currentPath, "package.json"))) {
+      return currentPath;
+    }
+    currentPath = dirname(currentPath);
+  }
+  return startPath;
+}, findMonorepoRoot = (startPath = process.cwd()) => {
+  let currentPath = startPath;
+  while (currentPath !== dirname(currentPath)) {
+    if (existsSync2(join2(currentPath, "Cargo.toml")) && existsSync2(join2(currentPath, "package.json"))) {
+      return currentPath;
+    }
+    currentPath = dirname(currentPath);
+  }
+  return null;
+}, getLocalBinaryPath = () => {
+  const envBinary = process.env.NULLJS_SERVER_BINARY;
+  if (envBinary && existsSync2(envBinary)) {
+    return { path: envBinary, source: "local-env" };
+  }
+  const monorepoRoot = findMonorepoRoot() || findMonorepoRoot(CLI_DIR);
+  if (monorepoRoot) {
+    const debugBinary = join2(monorepoRoot, "target", "debug", "server");
+    if (existsSync2(debugBinary)) {
+      return { path: debugBinary, source: "local-debug" };
+    }
+    const releaseBinary = join2(monorepoRoot, "target", "release", "server");
+    if (existsSync2(releaseBinary)) {
+      return { path: releaseBinary, source: "local-release" };
+    }
+  }
+  return null;
+}, waitForServer = async (port, maxRetries = 30, delayMs = 1000) => {
+  for (let i = 0;i < maxRetries; i++) {
+    try {
+      const response = await fetch(`http://localhost:${port}/api/health`);
+      if (response.ok) {
+        return;
+      }
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  throw new Error(`Server did not start within ${maxRetries * delayMs / 1000}s`);
+}, buildDevArgs = async () => {
+  const devConfig = await getOrCreateLocalDevConfig();
+  const args = ["--dev"];
+  args.push("--api-port", "3000");
+  args.push("--gateway-port", "3001");
+  const projectRoot = findProjectRoot();
+  const cloudPath = join2(projectRoot, ".nulljs");
+  args.push("--cloud-path", cloudPath);
+  if (!existsSync2(cloudPath)) {
+    mkdirSync2(cloudPath, { recursive: true });
+  }
+  args.push("--public-key", devConfig.key.public);
+  return args;
+}, startServer = async () => {
+  const localBinary = getLocalBinaryPath();
+  let binaryPath;
+  let binarySource;
+  if (localBinary) {
+    console.log(chalk2.cyan(`Using local binary: ${localBinary.path}`));
+    binaryPath = localBinary.path;
+    binarySource = localBinary.source;
+  } else {
+    const platformKey = getPlatformKey();
+    const pkgName = PLATFORMS[platformKey];
+    if (!pkgName) {
+      console.error(chalk2.red(`\u2717 Unsupported platform: ${platformKey}`));
+      throw new Error(`Unsupported platform: ${platformKey}`);
+    }
+    binaryPath = __require.resolve(`${pkgName}/bin/server`);
+    binarySource = "npm";
+    console.log(chalk2.cyan(`Using npm binary: ${pkgName}`));
+  }
+  try {
+    const args = await buildDevArgs();
+    console.log(chalk2.yellow(`Starting server with args: ${args.join(" ")}`));
+    const proc = Bun.spawn([binaryPath, ...args], {
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    console.log(chalk2.green("\u2713 Server process started, waiting for server to be ready..."));
+    await waitForServer(3000);
+    console.log(chalk2.green("\u2713 Server is ready"));
+    return { process: proc, binarySource, binaryPath };
+  } catch (error) {
+    console.error(chalk2.red(`\u2717 Failed to start server: ${error instanceof Error ? error.message : String(error)}`));
+    throw error;
+  }
+};
+var init_server = __esm(() => {
+  init_config();
+  CLI_DIR = dirname(realpathSync(import.meta.dir));
+  PLATFORMS = {
+    "linux-x64": "@tothalex/nulljs-linux-x64",
+    "linux-arm64": "@tothalex/nulljs-linux-arm64",
+    "darwin-arm64": "@tothalex/nulljs-darwin-arm64"
+  };
+});
+
+// src/lib/bundle/react.ts
+import { basename, extname } from "path";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+var jsConfig = ({ filePath }) => {
+  const entry = basename(filePath, extname(filePath));
+  const virtualPrefix = `virtual:config/${entry}.tsx`;
+  return {
+    name: "nulljs-config-plugin",
+    apply: "build",
+    config: async (config, { command }) => {
+      if (command !== "build") {
+        return config;
+      }
+      return {
+        build: {
+          ssr: true,
+          rollupOptions: {
+            input: {
+              [entry]: virtualPrefix
+            },
+            external: ["react", "react/jsx-runtime"],
+            output: {
+              entryFileNames: "[name].js"
+            },
+            preserveEntrySignatures: "strict"
+          }
+        }
+      };
+    },
+    resolveId: (id) => {
+      if (id === virtualPrefix) {
+        return id;
+      }
+      return null;
+    },
+    load: (id) => {
+      if (id === virtualPrefix) {
+        const script = `
+          import { config } from "${filePath.replace(/\\/g, "\\\\")}";
+
+          export default config;
+        `;
+        return script;
+      }
+      return null;
+    },
+    transform: (code, id) => {
+      if (id === filePath) {
+        const configMatch = code.match(/export const config = \{[^}]*\};/);
+        return configMatch ? { code: configMatch[0], map: null } : null;
+      }
+    }
+  };
+}, spaConfigConfig = (filePath) => {
+  return {
+    logLevel: "error",
+    plugins: [
+      jsConfig({
+        filePath
+      })
+    ],
+    build: {
+      outDir: "/tmp"
+    }
+  };
+}, jsSpa = ({ filePath }) => {
+  const entry = basename(filePath, extname(filePath));
+  const virtualPrefix = `virtual:spa/${entry}.tsx`;
+  return {
+    name: "nulljs-spa-client-plugin",
+    apply: "build",
+    config: async (config, { command }) => {
+      if (command !== "build") {
+        return config;
+      }
+      return {
+        build: {
+          rollupOptions: {
+            input: {
+              [entry]: virtualPrefix
+            },
+            external: ["cloud"],
+            output: {
+              entryFileNames: "[name].js"
+            }
+          }
+        },
+        plugins: [react()]
+      };
+    },
+    resolveId: (id) => {
+      if (id === virtualPrefix) {
+        return id;
+      }
+      return null;
+    },
+    load: (id) => {
+      if (id === virtualPrefix) {
+        const script = `
+          import { StrictMode } from 'react'
+          import { createRoot } from 'react-dom/client'
+
+          import { Page } from "${filePath.replace(/\\/g, "\\\\")}";
+
+          createRoot(document.getElementById('root')!).render(
+            <StrictMode>
+              <Page />
+            </StrictMode>
+          )`;
+        return script;
+      }
+      return null;
+    }
+  };
+}, spaClientConfig = (filePath) => {
+  return {
+    logLevel: "error",
+    plugins: [
+      jsSpa({
+        filePath
+      }),
+      tailwindcss()
+    ],
+    build: {
+      outDir: "/tmp"
+    }
+  };
+};
+var init_react = () => {};
+
+// src/lib/bundle/external.ts
+var external;
+var init_external = __esm(() => {
+  external = [
+    "cloud/cache",
+    "cloud/event",
+    "cloud",
+    "cloud/postgres",
+    "cloud/secret",
+    "cloud/uuid",
+    "assert",
+    "buffer",
+    "crypto",
+    "dns",
+    "events",
+    "net",
+    "os",
+    "process",
+    "stream/web",
+    "string_decoder",
+    "timers",
+    "tty",
+    "url",
+    "util",
+    "zlib"
+  ];
+});
+
+// src/lib/bundle/function.ts
+var jsFunction = ({ filePath }) => {
+  return {
+    name: "nulljs-function-plugin",
+    apply: "build",
+    config: async (config, { command }) => {
+      if (command !== "build") {
+        return config;
+      }
+      return {
+        build: {
+          rollupOptions: {
+            input: {
+              handler: filePath
+            },
+            external,
+            output: {
+              entryFileNames: "[name].js"
+            },
+            preserveEntrySignatures: "strict"
+          }
+        }
+      };
+    }
+  };
+}, functionConfig = (filePath) => {
+  return {
+    logLevel: "error",
+    plugins: [
+      jsFunction({
+        filePath
+      })
+    ],
+    build: {
+      outDir: "/tmp",
+      minify: false
+    }
+  };
+}, jsFunctionWatch = (entries, callbacks) => {
+  const outputToEntry = new Map;
+  return {
+    name: "nulljs-function-watch-plugin",
+    apply: "build",
+    config: async (config, { command }) => {
+      if (command !== "build") {
+        return config;
+      }
+      const input = {};
+      for (const entry of entries) {
+        input[entry.name] = entry.path;
+        outputToEntry.set(`${entry.name}.js`, entry);
+      }
+      return {
+        build: {
+          rollupOptions: {
+            input,
+            external,
+            output: {
+              entryFileNames: "[name].js"
+            },
+            preserveEntrySignatures: "strict"
+          }
+        }
+      };
+    },
+    async writeBundle(_, bundle) {
+      const results = [];
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== "chunk" || !chunk.isEntry)
+          continue;
+        const entry = outputToEntry.get(fileName);
+        if (!entry)
+          continue;
+        results.push({ entry, code: chunk.code });
+      }
+      await callbacks.onBuildComplete(results);
+    }
+  };
+}, functionWatchConfig = (entries, callbacks) => {
+  return {
+    logLevel: "error",
+    plugins: [jsFunctionWatch(entries, callbacks)],
+    build: {
+      outDir: "/tmp/nulljs-dev",
+      minify: false,
+      watch: {}
+    }
+  };
+};
+var init_function = __esm(() => {
+  init_external();
+});
+
+// src/lib/bundle/index.ts
+var isReact = (file) => file.endsWith(".tsx");
+var init_bundle = __esm(() => {
+  init_react();
+  init_function();
+});
+
+// src/lib/deploy.ts
+var exports_deploy = {};
+__export(exports_deploy, {
+  deployReact: () => deployReact,
+  deployFunction: () => deployFunction,
+  clearDeployCache: () => clearDeployCache
+});
+import { basename as basename2 } from "path";
+import { build } from "vite";
+var deployedHashes, clearDeployCache = () => {
+  deployedHashes.clear();
+}, hashCode = (code) => {
+  return Bun.hash(code).toString(16);
+}, deployFunction = async (filePath, privateKey, apiUrl) => {
+  const fileName = basename2(filePath);
+  const result = await build(functionConfig(filePath));
+  const handler = result.output.find((output) => output.type === "chunk" && output.fileName === "handler.js");
+  if (!handler) {
+    throw new Error("Bundle failed: handler.js not found in output");
+  }
+  const hash = hashCode(handler.code);
+  const lastHash = deployedHashes.get(filePath);
+  if (lastHash === hash) {
+    return { deployed: false, skipped: true };
+  }
+  await createFunctionDeployment({ name: fileName, assets: [{ fileName: "handler.js", code: handler.code }] }, { privateKey, url: apiUrl });
+  deployedHashes.set(filePath, hash);
+  return { deployed: true, skipped: false };
+}, deployReact = async (filePath, privateKey, apiUrl) => {
+  const fileName = basename2(filePath);
+  const configResult = await build(spaConfigConfig(filePath));
+  const configOutput = configResult.output.find((output) => output.type === "chunk" && output.fileName === "index.js");
+  if (!configOutput) {
+    throw new Error("Config build failed: config file not found in output");
+  }
+  const result = await build(spaClientConfig(filePath));
+  const assets3 = [];
+  assets3.push({ fileName: "config.js", code: configOutput.code });
+  for (const output of result.output) {
+    if (output.type === "chunk") {
+      assets3.push({ fileName: output.fileName, code: output.code });
+    } else if (output.type === "asset" && typeof output.source === "string") {
+      assets3.push({ fileName: output.fileName, code: output.source });
+    }
+  }
+  const combinedCode = assets3.map((a) => a.code).join("");
+  const hash = hashCode(combinedCode);
+  const lastHash = deployedHashes.get(filePath);
+  if (lastHash === hash) {
+    return { deployed: false, skipped: true };
+  }
+  await createReactDeployment({ name: fileName, assets: assets3 }, { privateKey, url: apiUrl });
+  deployedHashes.set(filePath, hash);
+  return { deployed: true, skipped: false };
+};
+var init_deploy = __esm(() => {
+  init_api();
+  init_bundle();
+  deployedHashes = new Map;
+});
+
+// src/lib/watcher.ts
+import { watch, existsSync as existsSync3 } from "fs";
+import { readdir } from "fs/promises";
+import { join as join3 } from "path";
+import { build as build2 } from "vite";
+var FUNCTION_DIRS, deployedHashes2, hashCode2 = (code) => {
+  return Bun.hash(code).toString(16);
+}, findFunctionEntries = async (functionsPath) => {
+  const entries = [];
+  for (const dir of FUNCTION_DIRS) {
+    const dirPath = join3(functionsPath, dir);
+    try {
+      const items = await readdir(dirPath, { withFileTypes: true });
+      for (const item of items) {
+        if (item.isFile() && (item.name.endsWith(".ts") || item.name.endsWith(".tsx"))) {
+          const fullPath = join3(dirPath, item.name);
+          const name = `${dir}/${item.name.replace(/\.tsx?$/, "")}`;
+          entries.push({
+            name,
+            path: fullPath,
+            type: dir
+          });
+        }
+      }
+    } catch {}
+  }
+  return entries;
+}, startWatcher = async (srcPath, options = {}) => {
+  const { silent = false, onDeploy, onDeployBatch, onReady } = options;
+  const config = readLocalConfig();
+  if (!config) {
+    if (!silent)
+      console.error('No local configuration found. Run "nulljs dev" first.');
+    return () => {};
+  }
+  const functionsPath = join3(srcPath, "function");
+  let entries = await findFunctionEntries(functionsPath);
+  let viteWatcher = null;
+  let isRestarting = false;
+  onReady?.(entries.length);
+  const privateKey = await loadPrivateKey(config);
+  const deployBatch = async (builds) => {
+    const results = [];
+    for (const { entry, code } of builds) {
+      const hash = hashCode2(code);
+      const lastHash = deployedHashes2.get(entry.name);
+      if (lastHash === hash) {
+        continue;
+      }
+      try {
+        await createFunctionDeployment({
+          name: `${entry.name}.ts`,
+          assets: [{ fileName: "handler.js", code }]
+        }, { privateKey, url: config.api });
+        deployedHashes2.set(entry.name, hash);
+        results.push({ name: entry.name, success: true, skipped: false });
+      } catch (error) {
+        results.push({
+          name: entry.name,
+          success: false,
+          skipped: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return results;
+  };
+  const startViteWatcher = async () => {
+    if (entries.length === 0) {
+      return null;
+    }
+    const result = await build2(functionWatchConfig(entries, {
+      onBuildComplete: async (builds) => {
+        const results = await deployBatch(builds);
+        if (results.length > 0) {
+          onDeployBatch?.(results);
+          for (const r of results) {
+            onDeploy?.(r.name, r.success, r.skipped, r.error);
+          }
+        }
+      }
+    }));
+    if ("on" in result) {
+      return result;
+    }
+    return null;
+  };
+  const restartViteWatcher = async () => {
+    if (isRestarting)
+      return;
+    isRestarting = true;
+    try {
+      if (viteWatcher) {
+        await viteWatcher.close();
+        viteWatcher = null;
+      }
+      entries = await findFunctionEntries(functionsPath);
+      onReady?.(entries.length);
+      viteWatcher = await startViteWatcher();
+    } finally {
+      isRestarting = false;
+    }
+  };
+  viteWatcher = await startViteWatcher();
+  const dirWatchers = [];
+  for (const dir of FUNCTION_DIRS) {
+    const dirPath = join3(functionsPath, dir);
+    if (!existsSync3(dirPath))
+      continue;
+    try {
+      const watcher = watch(dirPath, async (eventType, filename) => {
+        if (!filename)
+          return;
+        if (!filename.endsWith(".ts") && !filename.endsWith(".tsx"))
+          return;
+        const fullPath = join3(dirPath, filename);
+        const entryName = `${dir}/${filename.replace(/\.tsx?$/, "")}`;
+        const existingEntry = entries.find((e) => e.name === entryName);
+        const fileExists = existsSync3(fullPath);
+        if (!existingEntry && fileExists || existingEntry && !fileExists) {
+          await restartViteWatcher();
+        }
+      });
+      dirWatchers.push(watcher);
+    } catch {}
+  }
+  return () => {
+    for (const watcher of dirWatchers) {
+      watcher.close();
+    }
+    if (viteWatcher) {
+      viteWatcher.close();
+    }
+  };
+}, forceDeployAll = async (srcPath, options = {}) => {
+  const { onDeploy, onComplete } = options;
+  const config = readLocalConfig();
+  if (!config) {
+    throw new Error('No local configuration found. Run "nulljs dev" first.');
+  }
+  const privateKey = await loadPrivateKey(config);
+  deployedHashes2.clear();
+  const functionsPath = join3(srcPath, "function");
+  const entries = await findFunctionEntries(functionsPath);
+  const reactEntry = join3(srcPath, "index.tsx");
+  const hasReact = existsSync3(reactEntry);
+  let total = entries.length + (hasReact ? 1 : 0);
+  let successful = 0;
+  let failed = 0;
+  const { deployFunction: deployFunction2, deployReact: deployReact2, clearDeployCache: clearDeployCache2 } = await Promise.resolve().then(() => (init_deploy(), exports_deploy));
+  clearDeployCache2();
+  for (const entry of entries) {
+    try {
+      await deployFunction2(entry.path, privateKey, config.api);
+      successful++;
+      onDeploy?.(entry.name, true);
+    } catch (error) {
+      failed++;
+      onDeploy?.(entry.name, false, error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (hasReact) {
+    const fileName = "index.tsx";
+    try {
+      await deployReact2(reactEntry, privateKey, config.api);
+      successful++;
+      onDeploy?.(fileName, true);
+    } catch (error) {
+      failed++;
+      onDeploy?.(fileName, false, error instanceof Error ? error.message : String(error));
+    }
+  }
+  onComplete?.(total, successful, failed);
+};
+var init_watcher = __esm(() => {
+  init_config();
+  init_bundle();
+  init_api();
+  FUNCTION_DIRS = ["api", "cron", "event"];
+  deployedHashes2 = new Map;
+});
+
+// src/lib/vite.ts
+import { createServer } from "vite";
+import { dirname as dirname2, resolve, basename as basename3 } from "path";
+import react3 from "@vitejs/plugin-react";
+import tailwindcss2 from "@tailwindcss/vite";
+import { writeFile, unlink } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+var VITE_PORT = 5173, GATEWAY_PORT = 3001, createViteLogger = (onLog) => {
+  return {
+    info: (msg) => onLog?.(msg, "info"),
+    warn: (msg) => onLog?.(msg, "warn"),
+    warnOnce: (msg) => onLog?.(msg, "warn"),
+    error: (msg) => onLog?.(msg, "error"),
+    clearScreen: () => {},
+    hasErrorLogged: () => false,
+    hasWarned: false
+  };
+}, createTempIndexHtml = (componentPath, projectRoot) => {
+  const relativePath = resolve(componentPath).replace(projectRoot + "/", "");
+  const componentName = basename3(componentPath, ".tsx");
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${componentName} - Dev Mode</title>
+    <style>
+      * { box-sizing: border-box; }
+      body { margin: 0; padding: 0; font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
+      #root { min-height: 100vh; }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">
+      import React from 'react'
+      import ReactDOM from 'react-dom/client'
+      import { Page } from '/${relativePath}'
+
+      const root = ReactDOM.createRoot(document.getElementById('root'))
+      root.render(
+        React.createElement(React.StrictMode, null,
+          React.createElement(Page)
+        )
+      )
+    </script>
+  </body>
+</html>`;
+}, startViteServer = async (options) => {
+  const indexTsxPath = resolve(options.srcDir, "index.tsx");
+  if (!existsSync4(indexTsxPath)) {
+    return null;
+  }
+  const projectDir = dirname2(options.srcDir);
+  const tempIndexPath = resolve(projectDir, "index.html");
+  try {
+    const indexHtml = createTempIndexHtml(indexTsxPath, projectDir);
+    await writeFile(tempIndexPath, indexHtml);
+    const server = await createServer({
+      root: projectDir,
+      plugins: [react3(), tailwindcss2()],
+      customLogger: createViteLogger(options.onLog),
+      server: {
+        port: VITE_PORT,
+        host: true,
+        proxy: {
+          "/api": {
+            target: `http://localhost:${GATEWAY_PORT}`,
+            changeOrigin: true,
+            secure: false
+          },
+          "/assets": {
+            target: `http://localhost:${GATEWAY_PORT}`,
+            changeOrigin: true,
+            secure: false
+          }
+        }
+      }
+    });
+    await server.listen();
+    options.onLog?.(`Vite server started on http://localhost:${VITE_PORT}`, "info");
+    return { server, indexHtmlPath: tempIndexPath };
+  } catch (error) {
+    options.onLog?.(`Failed to start Vite: ${error}`, "error");
+    return null;
+  }
+}, stopViteServer = async (info) => {
+  await info.server.close();
+  try {
+    await unlink(info.indexHtmlPath);
+  } catch {}
+};
+var init_vite = () => {};
+
+// src/components/DeploymentLogsPane.tsx
+import { jsxDEV } from "@opentui/react/jsx-dev-runtime";
+var getLevelColor = (level) => {
+  switch (level.toLowerCase()) {
+    case "error":
+      return "red";
+    case "warn":
+    case "warning":
+      return "yellow";
+    case "info":
+      return "cyan";
+    case "debug":
+      return "gray";
+    default:
+      return "white";
+  }
+}, sanitizeMessage = (message) => {
+  return message.replace(/\x1b\[[0-9;]*m/g, "").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}, DeploymentLogsPane = (props) => {
+  if (props.loading && props.logs.length === 0) {
+    return /* @__PURE__ */ jsxDEV("box", {
+      flexDirection: "column",
+      padding: 1,
+      children: /* @__PURE__ */ jsxDEV("text", {
+        children: "Loading deployment logs..."
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  if (!props.loading && props.logs.length === 0) {
+    return /* @__PURE__ */ jsxDEV("box", {
+      flexDirection: "column",
+      padding: 1,
+      children: /* @__PURE__ */ jsxDEV("text", {
+        children: "No deployment logs found"
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  const logsInOrder = [...props.logs].reverse();
+  return /* @__PURE__ */ jsxDEV("scrollbox", {
+    focused: true,
+    stickyStart: props.autoScroll ? "bottom" : "top",
+    stickyScroll: props.autoScroll,
+    children: logsInOrder.map((log) => {
+      const time = new Date(log.time).toLocaleTimeString();
+      const timestamp = `[${time}]`;
+      const level = log.level.toUpperCase();
+      return /* @__PURE__ */ jsxDEV("box", {
+        flexDirection: "row",
+        children: /* @__PURE__ */ jsxDEV("text", {
+          children: [
+            /* @__PURE__ */ jsxDEV("span", {
+              fg: "gray",
+              children: timestamp
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("span", {
+              fg: getLevelColor(log.level),
+              children: ` ${level} `
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("span", {
+              fg: "blue",
+              children: `(${log.deployment_name})`
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("span", {
+              fg: "cyan",
+              children: ` ${log.trigger} `
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV("span", {
+              children: sanitizeMessage(log.message)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, log.id, false, undefined, this);
+    })
+  }, `${props.autoScroll}-${props.jumpTrigger}`, false, undefined, this);
+};
+var init_DeploymentLogsPane = () => {};
+
+// src/components/SystemLogsPane.tsx
+import { jsxDEV as jsxDEV2 } from "@opentui/react/jsx-dev-runtime";
+var getLevelColor2 = (level) => {
+  switch (level.toLowerCase()) {
+    case "error":
+      return "red";
+    case "warn":
+    case "warning":
+      return "yellow";
+    case "info":
+      return "green";
+    case "debug":
+    case "trace":
+      return "gray";
+    default:
+      return "white";
+  }
+}, sanitizeMessage2 = (message) => {
+  return message.replace(/\x1b\[[0-9;]*m/g, "").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}, SystemLogsPane = (props) => {
+  if (props.loading && props.logs.length === 0) {
+    return /* @__PURE__ */ jsxDEV2("box", {
+      flexDirection: "column",
+      padding: 1,
+      children: /* @__PURE__ */ jsxDEV2("text", {
+        children: "Loading system logs..."
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  if (!props.loading && props.logs.length === 0) {
+    return /* @__PURE__ */ jsxDEV2("box", {
+      flexDirection: "column",
+      padding: 1,
+      children: /* @__PURE__ */ jsxDEV2("text", {
+        children: "No system logs found"
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  const logsInOrder = [...props.logs].reverse();
+  return /* @__PURE__ */ jsxDEV2("scrollbox", {
+    focused: true,
+    stickyStart: props.autoScroll ? "bottom" : "top",
+    stickyScroll: props.autoScroll,
+    children: logsInOrder.map((log) => {
+      const time = new Date(log.timestamp).toLocaleTimeString();
+      const timestamp = `[${time}]`;
+      const level = log.level.toUpperCase();
+      return /* @__PURE__ */ jsxDEV2("box", {
+        flexDirection: "row",
+        children: /* @__PURE__ */ jsxDEV2("text", {
+          children: [
+            /* @__PURE__ */ jsxDEV2("span", {
+              fg: "gray",
+              children: timestamp
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV2("span", {
+              fg: getLevelColor2(log.level),
+              children: ` ${level} `
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV2("span", {
+              children: sanitizeMessage2(log.message)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, log.id, false, undefined, this);
+    })
+  }, `${props.autoScroll}-${props.jumpTrigger}`, false, undefined, this);
+};
+var init_SystemLogsPane = () => {};
+
+// src/components/DeployAnimation.tsx
+import { useEffect, useState, useRef } from "react";
+import { jsxDEV as jsxDEV3 } from "@opentui/react/jsx-dev-runtime";
+var DeployAnimation = (props) => {
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const [progress, setProgress] = useState(0);
+  const intervalRef = useRef(null);
+  const completedRef = useRef(false);
+  const duration = 400;
+  const frameRate = 16;
+  useEffect(() => {
+    if (props.deployed.length === 0) {
+      props.onComplete();
+      return;
+    }
+    if (completedRef.current) {
+      return;
+    }
+    setProgress(0);
+    const startTime = Date.now();
+    intervalRef.current = setInterval(() => {
+      const elapsed = Date.now() - startTime;
+      const newProgress = Math.min(100, elapsed / duration * 100);
+      setProgress(newProgress);
+      if (newProgress >= 100) {
+        if (intervalRef.current) {
+          clearInterval(intervalRef.current);
+          intervalRef.current = null;
+        }
+        setTimeout(() => {
+          if (currentIndex >= props.deployed.length - 1) {
+            completedRef.current = true;
+            props.onComplete();
+          } else {
+            setCurrentIndex((prev) => prev + 1);
+          }
+        }, 150);
+      }
+    }, frameRate);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [currentIndex, props.deployed.length, props.onComplete]);
+  const current = props.deployed[currentIndex];
+  if (props.deployed.length === 0 || !current || completedRef.current) {
+    return null;
+  }
+  const barWidth = 8;
+  const filled = Math.round(progress / 100 * barWidth);
+  const empty = barWidth - filled;
+  const bar = "\u2501".repeat(filled) + "\u2500".repeat(empty);
+  return /* @__PURE__ */ jsxDEV3("box", {
+    backgroundColor: "black",
+    flexDirection: "row",
+    paddingLeft: 1,
+    paddingRight: 1,
+    children: /* @__PURE__ */ jsxDEV3("text", {
+      children: [
+        /* @__PURE__ */ jsxDEV3("span", {
+          fg: current.success ? "#22c55e" : "#ef4444",
+          children: [
+            bar,
+            " ",
+            current.success ? "\u2713" : "\u2717"
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV3("span", {
+          children: [
+            " ",
+            current.name
+          ]
+        }, undefined, true, undefined, this),
+        props.deployed.length > 1 && /* @__PURE__ */ jsxDEV3("span", {
+          fg: "#666",
+          children: [
+            " ",
+            "(",
+            currentIndex + 1,
+            "/",
+            props.deployed.length,
+            ")"
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+};
+var init_DeployAnimation = () => {};
+
+// src/components/Header.tsx
+import { jsxDEV as jsxDEV4, Fragment } from "@opentui/react/jsx-dev-runtime";
+var getBinarySourceLabel = (source) => {
+  switch (source) {
+    case "local-debug":
+      return "local (debug)";
+    case "local-release":
+      return "local (release)";
+    case "local-env":
+      return "local (env)";
+    case "npm":
+      return "npm";
+  }
+}, Header = (props) => {
+  const { activeTab, functionCount, viteRunning, isDeploying, binarySource } = props;
+  return /* @__PURE__ */ jsxDEV4("box", {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    children: [
+      /* @__PURE__ */ jsxDEV4("box", {
+        flexDirection: "row",
+        children: [
+          /* @__PURE__ */ jsxDEV4("text", {
+            fg: activeTab === "system" ? "cyan" : undefined,
+            content: "[1] System Logs"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV4("text", {
+            content: " | "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV4("text", {
+            fg: activeTab === "deployment" ? "cyan" : undefined,
+            content: "[2] Deployment Logs"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV4("box", {
+        flexDirection: "row",
+        children: [
+          isDeploying ? /* @__PURE__ */ jsxDEV4("text", {
+            fg: "yellow",
+            content: "\u25CF deploying all..."
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV4("text", {
+            fg: functionCount > 0 ? "green" : "yellow",
+            content: "\u25CF watching"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV4("text", {
+            fg: "gray",
+            content: ` (${functionCount} functions)`
+          }, undefined, false, undefined, this),
+          viteRunning && /* @__PURE__ */ jsxDEV4(Fragment, {
+            children: [
+              /* @__PURE__ */ jsxDEV4("text", {
+                fg: "gray",
+                content: " | vite: "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV4("text", {
+                fg: "magenta",
+                content: ":5173"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV4("text", {
+            fg: "gray",
+            content: " | server: "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV4("text", {
+            fg: binarySource.startsWith("local") ? "yellow" : "green",
+            content: getBinarySourceLabel(binarySource)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
+var init_Header = () => {};
+
+// src/components/HelpModal.tsx
+import { jsxDEV as jsxDEV5 } from "@opentui/react/jsx-dev-runtime";
+var KeyBinding = ({ keys, description }) => /* @__PURE__ */ jsxDEV5("text", {
+  children: [
+    "  ",
+    /* @__PURE__ */ jsxDEV5("span", {
+      fg: "green",
+      children: keys
+    }, undefined, false, undefined, this),
+    /* @__PURE__ */ jsxDEV5("span", {
+      fg: "gray",
+      children: " - "
+    }, undefined, false, undefined, this),
+    description
+  ]
+}, undefined, true, undefined, this), Section = ({ title }) => /* @__PURE__ */ jsxDEV5("text", {
+  children: /* @__PURE__ */ jsxDEV5("span", {
+    fg: "gray",
+    children: title
+  }, undefined, false, undefined, this)
+}, undefined, false, undefined, this), HelpModal = ({ visible }) => {
+  if (!visible)
+    return null;
+  return /* @__PURE__ */ jsxDEV5("box", {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%",
+    backgroundColor: "black",
+    opacity: 0.9,
+    justifyContent: "center",
+    alignItems: "center",
+    children: /* @__PURE__ */ jsxDEV5("box", {
+      width: 50,
+      height: 18,
+      border: true,
+      borderStyle: "rounded",
+      flexDirection: "column",
+      padding: 1,
+      backgroundColor: "black",
+      children: [
+        /* @__PURE__ */ jsxDEV5("text", {
+          children: /* @__PURE__ */ jsxDEV5("span", {
+            fg: "cyan",
+            children: /* @__PURE__ */ jsxDEV5("strong", {
+              children: "Keyboard Shortcuts"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5("text", {}, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(Section, {
+          title: "Navigation"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "1/2",
+          description: "Switch tabs"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "h/l",
+          description: "Previous/next tab"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "Tab",
+          description: "Cycle tabs"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5("text", {}, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(Section, {
+          title: "Scrolling"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "j/k",
+          description: "Scroll down/up"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "g/G",
+          description: "Top/bottom"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5("text", {}, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(Section, {
+          title: "Actions"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "d",
+          description: "Deploy all"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "?",
+          description: "Toggle help"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV5(KeyBinding, {
+          keys: "Esc",
+          description: "Close help"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+};
+var init_HelpModal = () => {};
+
+// src/ui.tsx
+var exports_ui = {};
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import { jsxDEV as jsxDEV6 } from "@opentui/react/jsx-dev-runtime";
+var App = (props) => {
+  const [error, setError] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [deploymentLogs, setDeploymentLogs] = useState2([]);
+  const [systemLogs, setSystemLogs] = useState2([]);
+  const [activeTab, setActiveTab] = useState2("system");
+  const [autoScroll, setAutoScroll] = useState2(true);
+  const [jumpTrigger, setJumpTrigger] = useState2(0);
+  const [watcherStatus, setWatcherStatus] = useState2(null);
+  const [showKeyBindings, setShowKeyBindings] = useState2(false);
+  const [isDeploying, setIsDeploying] = useState2(false);
+  useEffect2(() => {
+    props.onWatcherEvent((event) => {
+      console.error("DEBUG: received watcher event:", event.type, event.deployed?.length);
+      setWatcherStatus(event);
+    });
+  }, [props.onWatcherEvent]);
+  useEffect2(() => {
+    const fn = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const [deploymentLogsData, systemLogsData] = await Promise.all([
+          searchDeploymentLogs(props.config.key.public, { limit: 100 }, props.config.api),
+          getSystemLogs(props.config.key.public, { limit: 100 }, props.config.api)
+        ]);
+        setDeploymentLogs(deploymentLogsData);
+        setSystemLogs(systemLogsData);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        console.error("Failed to fetch logs:", err);
+      } finally {
+        setLoading(false);
+      }
+    };
+    fn();
+  }, [props.config.key.public, props.config.api]);
+  useEffect2(() => {
+    const interval = setInterval(async () => {
+      if (loading)
+        return;
+      try {
+        const [newDeploymentLogs, newSystemLogs] = await Promise.all([
+          searchDeploymentLogs(props.config.key.public, { limit: 100 }, props.config.api),
+          getSystemLogs(props.config.key.public, { limit: 100 }, props.config.api)
+        ]);
+        if (newDeploymentLogs.length > 0) {
+          setDeploymentLogs(newDeploymentLogs);
+        }
+        if (newSystemLogs.length > 0) {
+          setSystemLogs(newSystemLogs);
+        }
+      } catch (err) {
+        console.error("Failed to poll for new logs:", err);
+      }
+    }, 2000);
+    return () => clearInterval(interval);
+  }, [loading, props.config.key.public, props.config.api]);
+  useEffect2(() => {
+    const handleKeyPress = (data) => {
+      const key = data.toString();
+      if (key === "1") {
+        setActiveTab("system");
+        return;
+      }
+      if (key === "2") {
+        setActiveTab("deployment");
+        return;
+      }
+      if (key === "\t") {
+        setActiveTab((prev) => prev === "system" ? "deployment" : "system");
+        return;
+      }
+      if (key === "h") {
+        setActiveTab("system");
+        return;
+      }
+      if (key === "l") {
+        setActiveTab("deployment");
+        return;
+      }
+      if (key === "g") {
+        setAutoScroll(false);
+        setJumpTrigger((prev) => prev + 1);
+        return;
+      }
+      if (key === "G") {
+        setAutoScroll(true);
+        setJumpTrigger((prev) => prev + 1);
+        return;
+      }
+      if (key === "?") {
+        setShowKeyBindings((prev) => !prev);
+        return;
+      }
+      if (key === "\x1B") {
+        setShowKeyBindings(false);
+        return;
+      }
+      if (key === "d" && !isDeploying) {
+        setIsDeploying(true);
+        props.onForceDeploy().finally(() => {
+          setIsDeploying(false);
+        });
+        return;
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.on("data", handleKeyPress);
+    return () => {
+      process.stdin.setRawMode(false);
+      process.stdin.off("data", handleKeyPress);
+    };
+  }, [isDeploying, props.onForceDeploy]);
+  if (error) {
+    return /* @__PURE__ */ jsxDEV6("box", {
+      flexGrow: 1,
+      flexDirection: "column",
+      padding: 1,
+      children: /* @__PURE__ */ jsxDEV6("text", {
+        children: /* @__PURE__ */ jsxDEV6("span", {
+          fg: "red",
+          children: [
+            "Error: ",
+            error
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV6("box", {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV6(Header, {
+        activeTab,
+        functionCount: props.functionCount,
+        viteRunning: props.viteRunning,
+        isDeploying,
+        binarySource: props.binarySource
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV6("box", {
+        paddingTop: 1,
+        flexDirection: "column",
+        children: [
+          activeTab === "system" ? /* @__PURE__ */ jsxDEV6(SystemLogsPane, {
+            logs: systemLogs,
+            loading,
+            autoScroll,
+            jumpTrigger
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV6(DeploymentLogsPane, {
+            logs: deploymentLogs,
+            loading,
+            autoScroll,
+            jumpTrigger
+          }, undefined, false, undefined, this),
+          watcherStatus?.type === "deploy" && watcherStatus.deployed && watcherStatus.deployed.length > 0 && /* @__PURE__ */ jsxDEV6(DeployAnimation, {
+            deployed: watcherStatus.deployed,
+            onComplete: () => {
+              console.error("DEBUG: animation complete");
+              setWatcherStatus(null);
+            }
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV6(HelpModal, {
+        visible: showKeyBindings
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}, main = async () => {
+  let serverInfo = null;
+  let viteInfo = null;
+  let stopWatcher = null;
+  let isCleaningUp = false;
+  const cleanup = async (exitAfter = true) => {
+    if (isCleaningUp)
+      return;
+    isCleaningUp = true;
+    if (stopWatcher) {
+      stopWatcher();
+      stopWatcher = null;
+    }
+    if (viteInfo) {
+      await stopViteServer(viteInfo);
+      viteInfo = null;
+    }
+    if (serverInfo) {
+      const pid = serverInfo.process.pid;
+      serverInfo = null;
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {}
+    }
+    if (exitAfter) {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", () => cleanup(true));
+  process.on("SIGTERM", () => cleanup(true));
+  process.on("exit", () => cleanup(false));
+  try {
+    serverInfo = await startServer();
+    const devConfig = await getOrCreateLocalDevConfig();
+    const srcPath = process.cwd() + "/src";
+    viteInfo = await startViteServer({
+      srcDir: srcPath,
+      onLog: (_msg, _level) => {}
+    });
+    let watcherEventHandler = null;
+    let pendingEvents = [];
+    let functionCount = 0;
+    const sendEvent = (event) => {
+      if (watcherEventHandler) {
+        watcherEventHandler(event);
+      } else {
+        pendingEvents.push(event);
+      }
+    };
+    const renderer = await createCliRenderer();
+    const root = createRoot(renderer);
+    const handleForceDeploy = async () => {
+      const deployResults = [];
+      await forceDeployAll(srcPath, {
+        onDeploy: (filePath, success, error) => {
+          deployResults.push({ name: filePath, success, error });
+        }
+      });
+      if (deployResults.length > 0) {
+        sendEvent({
+          type: "deploy",
+          deployed: deployResults,
+          timestamp: new Date
+        });
+      }
+    };
+    stopWatcher = await startWatcher(srcPath, {
+      silent: true,
+      onReady: (count) => {
+        functionCount = count;
+      },
+      onDeployBatch: (results) => {
+        sendEvent({
+          type: "deploy",
+          deployed: results.map((r) => ({
+            name: r.name,
+            success: r.success,
+            error: r.error
+          })),
+          timestamp: new Date
+        });
+      }
+    });
+    root.render(/* @__PURE__ */ jsxDEV6(App, {
+      config: devConfig,
+      binarySource: serverInfo.binarySource,
+      functionCount,
+      viteRunning: viteInfo !== null,
+      onWatcherEvent: (handler) => {
+        watcherEventHandler = handler;
+        if (pendingEvents.length > 0) {
+          for (const event of pendingEvents) {
+            handler(event);
+          }
+          pendingEvents = [];
+        }
+      },
+      onForceDeploy: handleForceDeploy
+    }, undefined, false, undefined, this));
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    cleanup();
+  }
+};
+var init_ui = __esm(() => {
+  init_api();
+  init_server();
+  init_watcher();
+  init_vite();
+  init_config();
+  init_DeploymentLogsPane();
+  init_SystemLogsPane();
+  init_DeployAnimation();
+  init_Header();
+  init_HelpModal();
+  main();
+});
+
+// src/cli.ts
+import { Command as Command3 } from "commander";
+
+// src/commands/dev.ts
+var registerDevCommand = (program) => {
+  program.command("dev").description("Launch the development renderer").action(async () => {
+    await Promise.resolve().then(() => (init_ui(), exports_ui));
+  });
+};
+// src/commands/deploy.ts
+init_config();
+init_bundle();
+init_deploy();
+import chalk3 from "chalk";
+import { basename as basename4, resolve as resolve2, join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import * as p from "@clack/prompts";
+var FUNCTION_DIRS2 = ["api", "cron", "event"];
+var selectConfig = async () => {
+  const configList = listConfigs();
+  if (!configList || configList.configs.length === 0) {
+    return null;
+  }
+  if (configList.configs.length === 1) {
+    return configList.configs[0] ?? null;
+  }
+  const selected = await p.select({
+    message: "Select config to deploy to",
+    options: configList.configs.map((c) => ({
+      value: c.name,
+      label: c.name,
+      hint: c.name === configList.current ? "current" : c.api
+    })),
+    initialValue: configList.current
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Deployment cancelled");
+    process.exit(0);
+  }
+  return getConfig(selected);
+};
+var findAllDeployables = async (srcPath) => {
+  const functions = [];
+  const functionsPath = join4(srcPath, "function");
+  for (const dir of FUNCTION_DIRS2) {
+    const dirPath = join4(functionsPath, dir);
+    try {
+      const items = await readdir2(dirPath, { withFileTypes: true });
+      for (const item of items) {
+        if (item.isFile() && (item.name.endsWith(".ts") || item.name.endsWith(".tsx"))) {
+          functions.push(join4(dirPath, item.name));
+        }
+      }
+    } catch {}
+  }
+  const reactEntry = join4(srcPath, "index.tsx");
+  const hasReact = existsSync5(reactEntry);
+  return { functions, reactEntry: hasReact ? reactEntry : null };
+};
+var deployAll = async (config, options) => {
+  const srcPath = join4(process.cwd(), "src");
+  if (!existsSync5(srcPath)) {
+    console.error(chalk3.red("\u2717 No src directory found"));
+    process.exit(1);
+  }
+  const { functions, reactEntry } = await findAllDeployables(srcPath);
+  const total = functions.length + (reactEntry ? 1 : 0);
+  if (total === 0) {
+    console.log(chalk3.yellow("No functions or React app found to deploy"));
+    return;
+  }
+  if (options.force) {
+    clearDeployCache();
+  }
+  const privateKey = await loadPrivateKey(config);
+  let successful = 0;
+  let failed = 0;
+  let skipped = 0;
+  console.log(chalk3.cyan(`Deploying ${total} file(s) to ${config.name}...
+`));
+  for (const filePath of functions) {
+    const fileName = basename4(filePath);
+    try {
+      console.log(chalk3.yellow("Bundling ") + chalk3.bold(fileName));
+      const result = await deployFunction(filePath, privateKey, config.api);
+      if (result.skipped) {
+        console.log(chalk3.gray("\u2013 Skipped ") + chalk3.bold(fileName) + chalk3.gray(" (unchanged)"));
+        skipped++;
+      } else {
+        console.log(chalk3.green("\u2713 Deployed ") + chalk3.bold(fileName));
+        successful++;
+      }
+    } catch (error) {
+      console.error(chalk3.red("\u2717 Failed ") + chalk3.bold(fileName) + chalk3.red(`: ${error instanceof Error ? error.message : error}`));
+      failed++;
+    }
+  }
+  if (reactEntry) {
+    const fileName = basename4(reactEntry);
+    try {
+      console.log(chalk3.yellow("Bundling React SPA ") + chalk3.bold(fileName));
+      const result = await deployReact(reactEntry, privateKey, config.api);
+      if (result.skipped) {
+        console.log(chalk3.gray("\u2013 Skipped ") + chalk3.bold(fileName) + chalk3.gray(" (unchanged)"));
+        skipped++;
+      } else {
+        console.log(chalk3.green("\u2713 Deployed ") + chalk3.bold(fileName));
+        successful++;
+      }
+    } catch (error) {
+      console.error(chalk3.red("\u2717 Failed ") + chalk3.bold(fileName) + chalk3.red(`: ${error instanceof Error ? error.message : error}`));
+      failed++;
+    }
+  }
+  console.log("");
+  if (failed > 0) {
+    console.log(chalk3.red(`Deployment completed with errors: ${successful} deployed, ${skipped} skipped, ${failed} failed`));
+    process.exit(1);
+  } else {
+    console.log(chalk3.green(`Deployment completed: ${successful} deployed, ${skipped} skipped`));
+  }
+};
+var registerDeployCommand = (program) => {
+  program.command("deploy").description("Bundle and deploy functions and React SPAs").argument("[file]", "Path to a specific file (deploys all if omitted)").option("-e, --env <name>", "Use a specific config environment").option("-f, --force", "Force deploy even if unchanged").action(async (file, options) => {
+    let config;
+    if (options.env) {
+      config = getConfig(options.env);
+      if (!config) {
+        console.error(chalk3.red(`\u2717 Config "${options.env}" not found.`));
+        console.error(chalk3.gray('  Run "nulljs config list" to see available configs'));
+        process.exit(1);
+      }
+    } else {
+      config = await selectConfig();
+      if (!config) {
+        console.error(chalk3.red("\u2717 No configurations found."));
+        console.error(chalk3.gray('  Run "nulljs dev" first to initialize the project'));
+        process.exit(1);
+      }
+    }
+    if (!file) {
+      await deployAll(config, options);
+      return;
+    }
+    const filePath = resolve2(file);
+    if (!existsSync5(filePath)) {
+      console.error(chalk3.red(`\u2717 File not found: ${filePath}`));
+      process.exit(1);
+    }
+    if (options.force) {
+      clearDeployCache();
+    }
+    const fileName = basename4(filePath);
+    const privateKey = await loadPrivateKey(config);
+    try {
+      if (isReact(filePath)) {
+        console.log(chalk3.yellow("Bundling React SPA ") + chalk3.bold(fileName));
+        const result = await deployReact(filePath, privateKey, config.api);
+        if (result.skipped) {
+          console.log(chalk3.gray("\u2013 Skipped ") + chalk3.bold(fileName) + chalk3.gray(" (unchanged)"));
+        } else {
+          console.log(chalk3.green("\u2713 Deployed ") + chalk3.bold(fileName) + chalk3.gray(` to ${config.name}`));
+        }
+      } else {
+        console.log(chalk3.yellow("Bundling ") + chalk3.bold(fileName));
+        const result = await deployFunction(filePath, privateKey, config.api);
+        if (result.skipped) {
+          console.log(chalk3.gray("\u2013 Skipped ") + chalk3.bold(fileName) + chalk3.gray(" (unchanged)"));
+        } else {
+          console.log(chalk3.green("\u2713 Deployed ") + chalk3.bold(fileName) + chalk3.gray(` to ${config.name}`));
+        }
+      }
+    } catch (error) {
+      console.error(chalk3.red("\u2717 Deployment failed:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+};
+// src/commands/config.ts
+init_config();
+import { Command } from "commander";
+import chalk4 from "chalk";
+import * as p2 from "@clack/prompts";
+var registerConfigCommand = (program) => {
+  program.command("config").description("Configuration management").addCommand(new Command("new").description("Create a new configuration").argument("[name]", "Configuration name (e.g., prod, staging)").argument("[api]", "API endpoint (e.g., https://api.example.com)").action(async (name, api) => {
+    let configName = name;
+    let configApi = api;
+    if (!configName || !configApi) {
+      p2.intro(chalk4.cyan("Create new configuration"));
+      if (!configName) {
+        const nameInput = await p2.text({
+          message: "Configuration name",
+          placeholder: "e.g., prod, staging",
+          validate: (value) => {
+            if (!value.trim())
+              return "Name is required";
+            if (!/^[a-zA-Z0-9-_]+$/.test(value)) {
+              return "Name can only contain letters, numbers, hyphens and underscores";
+            }
+          }
+        });
+        if (p2.isCancel(nameInput)) {
+          p2.cancel("Configuration cancelled");
+          process.exit(0);
+        }
+        configName = nameInput;
+      }
+      if (!configApi) {
+        const apiInput = await p2.text({
+          message: "API endpoint",
+          placeholder: "e.g., https://api.example.com",
+          validate: (value) => {
+            if (!value.trim())
+              return "API endpoint is required";
+            try {
+              new URL(value);
+            } catch {
+              return "Please enter a valid URL";
+            }
+          }
+        });
+        if (p2.isCancel(apiInput)) {
+          p2.cancel("Configuration cancelled");
+          process.exit(0);
+        }
+        configApi = apiInput;
+      }
+    }
+    await createConfig(configName, configApi);
+  })).addCommand(new Command("list").description("List all configurations").action(() => {
+    const result = listConfigs();
+    if (!result || result.configs.length === 0) {
+      console.log(chalk4.yellow("No configurations found."));
+      console.log(chalk4.gray('  Run "nulljs dev" to create a dev config, or'));
+      console.log(chalk4.gray('  Run "nulljs config new <name> <api>" to create a new config'));
+      return;
+    }
+    console.log(chalk4.bold("Configurations:"));
+    result.configs.forEach((config) => {
+      const isActive = config.name === result.current;
+      const marker = isActive ? chalk4.green("\u25CF") : chalk4.gray("\u25CB");
+      const name = isActive ? chalk4.green(config.name) : config.name;
+      const suffix = isActive ? chalk4.green(" (active)") : "";
+      console.log(`  ${marker} ${name}${suffix}`);
+      console.log(chalk4.gray(`    API: ${config.api}`));
+    });
+  })).addCommand(new Command("use").description("Switch to a configuration").argument("[name]", "Configuration name").action(async (name) => {
+    let configName = name;
+    if (!configName) {
+      const configList = listConfigs();
+      if (!configList || configList.configs.length === 0) {
+        console.log(chalk4.yellow("No configurations found."));
+        console.log(chalk4.gray('  Run "nulljs dev" to create a dev config, or'));
+        console.log(chalk4.gray('  Run "nulljs config new" to create a new config'));
+        return;
+      }
+      const selected = await p2.select({
+        message: "Select config to use",
+        options: configList.configs.map((c) => ({
+          value: c.name,
+          label: c.name,
+          hint: c.name === configList.current ? "current" : c.api
+        })),
+        initialValue: configList.current
+      });
+      if (p2.isCancel(selected)) {
+        p2.cancel("Cancelled");
+        process.exit(0);
+      }
+      configName = selected;
+    }
+    useConfig(configName);
+  }));
+};
+// src/commands/status.ts
+init_config();
+import chalk5 from "chalk";
+var registerStatusCommand = (program) => {
+  program.action(() => {
+    const result = listConfigs();
+    if (result && result.configs.length > 0) {
+      const currentConfig = result.configs.find((c) => c.name === result.current);
+      if (currentConfig) {
+        console.log(chalk5.green("\u25CF") + " " + chalk5.bold(`Active: ${currentConfig.name}`));
+        console.log(chalk5.blue("  API:") + ` ${currentConfig.api}`);
+        console.log(chalk5.blue("  Public Key:") + ` ${currentConfig.key.public.substring(0, 20)}...`);
+        if (result.configs.length > 1) {
+          console.log(chalk5.gray(`
+  ${result.configs.length - 1} other config(s) available`));
+        }
+      }
+    } else {
+      console.log(chalk5.yellow("\u25CB No local configuration found."));
+      console.log(chalk5.gray('  Run "nulljs dev" to initialize the project'));
+    }
+    printAvailableCommands();
+  });
+};
+var printAvailableCommands = () => {
+  console.log(`
+` + chalk5.bold("Commands:"));
+  console.log(chalk5.cyan("  nulljs dev") + chalk5.gray(" - Launch development server"));
+  console.log(chalk5.cyan("  nulljs deploy") + chalk5.gray(" - Deploy all functions and React apps"));
+  console.log(chalk5.cyan("  nulljs config list") + chalk5.gray(" - List all configurations"));
+  console.log(chalk5.cyan("  nulljs config new") + chalk5.gray(" - Create new configuration"));
+  console.log(chalk5.cyan("  nulljs config use") + chalk5.gray(" - Switch active configuration"));
+  console.log(chalk5.cyan("  nulljs secret list") + chalk5.gray(" - List all secret keys"));
+  console.log(chalk5.cyan("  nulljs secret create") + chalk5.gray(" - Create a new secret"));
+  console.log(chalk5.cyan("  nulljs secret deploy") + chalk5.gray(" - Deploy secrets from .secret file"));
+  console.log(chalk5.cyan("  nulljs host") + chalk5.gray(" - Set up production hosting with systemd"));
+};
+// src/commands/secret.ts
+init_api();
+init_config();
+import { Command as Command2 } from "commander";
+import chalk6 from "chalk";
+import { resolve as resolve3 } from "path";
+import { readFile, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import * as p3 from "@clack/prompts";
+var selectConfig2 = async () => {
+  const configList = listConfigs();
+  if (!configList || configList.configs.length === 0) {
+    return null;
+  }
+  if (configList.configs.length === 1) {
+    return configList.configs[0] ?? null;
+  }
+  const selected = await p3.select({
+    message: "Select config",
+    options: configList.configs.map((c) => ({
+      value: c.name,
+      label: c.name,
+      hint: c.name === configList.current ? "current" : c.api
+    })),
+    initialValue: configList.current
+  });
+  if (p3.isCancel(selected)) {
+    p3.cancel("Cancelled");
+    process.exit(0);
+  }
+  return getConfig(selected);
+};
+var selectFile = async (cwd) => {
+  const files = [];
+  try {
+    const items = await readdir3(cwd);
+    for (const item of items) {
+      if (item === ".secret" || item.startsWith(".secret.")) {
+        files.push(item);
+      }
+    }
+  } catch {}
+  if (files.length === 0) {
+    console.log(chalk6.yellow("No .secret files found in current directory"));
+    return null;
+  }
+  const selected = await p3.select({
+    message: "Select file to import secrets from",
+    options: files.map((f) => ({
+      value: f,
+      label: f
+    }))
+  });
+  if (p3.isCancel(selected)) {
+    p3.cancel("Cancelled");
+    process.exit(0);
+  }
+  return resolve3(cwd, selected);
+};
+var parseEnvFile = async (filePath) => {
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.split(`
+`);
+  const secrets2 = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex === -1) {
+      continue;
+    }
+    const key = trimmed.substring(0, equalIndex).trim();
+    let value = trimmed.substring(equalIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key) {
+      secrets2.push({ key, value });
+    }
+  }
+  return secrets2;
+};
+var registerSecretCommand = (program) => {
+  program.command("secret").description("Secret management").addCommand(new Command2("list").description("List all secret keys").option("-e, --env <name>", "Use a specific config environment").action(async (options) => {
+    let config;
+    try {
+      config = options.env ? getConfig(options.env) : await selectConfig2();
+    } catch (err) {
+      console.error(chalk6.red("\u2717 Failed to get config:"), err);
+      process.exit(1);
+    }
+    await new Promise((resolve4) => setImmediate(resolve4));
+    if (!config) {
+      console.error(chalk6.red("\u2717 No configuration found."));
+      console.error(chalk6.gray('  Run "nulljs dev" first to initialize the project'));
+      process.exit(1);
+    }
+    try {
+      console.log(chalk6.gray(`Fetching secrets from ${config.api}...`));
+      const privateKey = await loadPrivateKey(config);
+      const keys = await listSecrets({ privateKey, url: config.api });
+      if (keys.length === 0) {
+        console.log(chalk6.yellow("No secrets found"));
+        return;
+      }
+      console.log(chalk6.bold(`
+Secret keys:`));
+      keys.forEach((key, index) => {
+        console.log(chalk6.green(`  ${index + 1}.`) + ` ${chalk6.cyan(key)}`);
+      });
+    } catch (error) {
+      console.error(chalk6.red("\u2717 Failed to list secrets:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  })).addCommand(new Command2("create").description("Create a new secret").argument("[key]", "Secret key").argument("[value]", "Secret value").option("-e, --env <name>", "Use a specific config environment").action(async (key, value, options) => {
+    const config = options?.env ? getConfig(options.env) : await selectConfig2();
+    if (!config) {
+      console.error(chalk6.red("\u2717 No configuration found."));
+      console.error(chalk6.gray('  Run "nulljs dev" first to initialize the project'));
+      process.exit(1);
+    }
+    let secretKey = key;
+    let secretValue = value;
+    if (!secretKey || !secretValue) {
+      if (!secretKey) {
+        const keyInput = await p3.text({
+          message: "Secret key",
+          placeholder: "e.g., API_KEY, DATABASE_URL",
+          validate: (v) => {
+            if (!v.trim())
+              return "Key is required";
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(v)) {
+              return "Key must start with a letter or underscore and contain only letters, numbers, and underscores";
+            }
+          }
+        });
+        if (p3.isCancel(keyInput)) {
+          p3.cancel("Cancelled");
+          process.exit(0);
+        }
+        secretKey = keyInput;
+      }
+      if (!secretValue) {
+        const valueInput = await p3.password({
+          message: "Secret value",
+          validate: (v) => {
+            if (!v)
+              return "Value is required";
+          }
+        });
+        if (p3.isCancel(valueInput)) {
+          p3.cancel("Cancelled");
+          process.exit(0);
+        }
+        secretValue = valueInput;
+      }
+    }
+    await new Promise((resolve4) => setImmediate(resolve4));
+    try {
+      const privateKey = await loadPrivateKey(config);
+      await createSecret({ key: secretKey, value: secretValue }, { privateKey, url: config.api });
+      console.log(chalk6.green("\u2713 Secret created:") + ` ${chalk6.cyan(secretKey)}`);
+    } catch (error) {
+      console.error(chalk6.red("\u2717 Failed to create secret:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  })).addCommand(new Command2("deploy").description("Deploy secrets from a .secret file").argument("[file]", "Path to .secret file").option("-e, --env <name>", "Use a specific config environment").action(async (file, options) => {
+    const config = options?.env ? getConfig(options.env) : await selectConfig2();
+    if (!config) {
+      console.error(chalk6.red("\u2717 No configuration found."));
+      console.error(chalk6.gray('  Run "nulljs dev" first to initialize the project'));
+      process.exit(1);
+    }
+    let filePath = file ? resolve3(file) : null;
+    if (!filePath) {
+      filePath = await selectFile(process.cwd());
+      if (!filePath) {
+        process.exit(1);
+      }
+    }
+    if (!existsSync6(filePath)) {
+      console.error(chalk6.red(`\u2717 File not found: ${filePath}`));
+      process.exit(1);
+    }
+    await new Promise((resolve4) => setImmediate(resolve4));
+    try {
+      const secrets2 = await parseEnvFile(filePath);
+      if (secrets2.length === 0) {
+        console.log(chalk6.yellow("No secrets found in file"));
+        return;
+      }
+      const privateKey = await loadPrivateKey(config);
+      let created = 0;
+      let failed = 0;
+      console.log(chalk6.cyan(`Deploying ${secrets2.length} secret(s) to ${config.name}...
+`));
+      for (const secret of secrets2) {
+        try {
+          await createSecret(secret, { privateKey, url: config.api });
+          console.log(chalk6.green("\u2713") + ` ${secret.key}`);
+          created++;
+        } catch (error) {
+          console.log(chalk6.red("\u2717") + ` ${secret.key}: ${error instanceof Error ? error.message : error}`);
+          failed++;
+        }
+      }
+      console.log("");
+      if (failed > 0) {
+        console.log(chalk6.yellow(`Deploy completed: ${created} created, ${failed} failed`));
+      } else {
+        console.log(chalk6.green(`Deploy completed: ${created} secret(s) created`));
+      }
+    } catch (error) {
+      console.error(chalk6.red("\u2717 Failed to deploy secrets:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  })).addCommand(new Command2("import").description("Import secrets from a file (alias for deploy)").argument("[file]", "Path to .secret file").option("-e, --env <name>", "Use a specific config environment").action(async (file, options) => {
+    const config = options?.env ? getConfig(options.env) : await selectConfig2();
+    if (!config) {
+      console.error(chalk6.red("\u2717 No configuration found."));
+      console.error(chalk6.gray('  Run "nulljs dev" first to initialize the project'));
+      process.exit(1);
+    }
+    let filePath = file ? resolve3(file) : null;
+    if (!filePath) {
+      filePath = await selectFile(process.cwd());
+      if (!filePath) {
+        process.exit(1);
+      }
+    }
+    if (!existsSync6(filePath)) {
+      console.error(chalk6.red(`\u2717 File not found: ${filePath}`));
+      process.exit(1);
+    }
+    await new Promise((resolve4) => setImmediate(resolve4));
+    try {
+      const secrets2 = await parseEnvFile(filePath);
+      if (secrets2.length === 0) {
+        console.log(chalk6.yellow("No secrets found in file"));
+        return;
+      }
+      const privateKey = await loadPrivateKey(config);
+      let created = 0;
+      let failed = 0;
+      console.log(chalk6.cyan(`Importing ${secrets2.length} secret(s) to ${config.name}...
+`));
+      for (const secret of secrets2) {
+        try {
+          await createSecret(secret, { privateKey, url: config.api });
+          console.log(chalk6.green("\u2713") + ` ${secret.key}`);
+          created++;
+        } catch (error) {
+          console.log(chalk6.red("\u2717") + ` ${secret.key}: ${error instanceof Error ? error.message : error}`);
+          failed++;
+        }
+      }
+      console.log("");
+      if (failed > 0) {
+        console.log(chalk6.yellow(`Import completed: ${created} created, ${failed} failed`));
+      } else {
+        console.log(chalk6.green(`Import completed: ${created} secret(s) created`));
+      }
+    } catch (error) {
+      console.error(chalk6.red("\u2717 Failed to import secrets:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  }));
+};
+// src/commands/host.ts
+import { existsSync as existsSync7, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join5 } from "path";
+import { execSync } from "child_process";
+import { homedir } from "os";
+import chalk7 from "chalk";
+var PLATFORMS2 = {
+  "linux-x64": "@tothalex/nulljs-linux-x64",
+  "linux-arm64": "@tothalex/nulljs-linux-arm64",
+  "darwin-arm64": "@tothalex/nulljs-darwin-arm64"
+};
+var getPlatformKey2 = () => {
+  return `${process.platform}-${process.arch}`;
+};
+var getServerBinPath = () => {
+  const platformKey = getPlatformKey2();
+  const pkgName = PLATFORMS2[platformKey];
+  if (!pkgName) {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return __require.resolve(`${pkgName}/bin/server`);
+};
+var generateProductionKeys = async () => {
+  console.log(chalk7.blue("Generating production keys..."));
+  const keyPair = await crypto.subtle.generateKey({
+    name: "Ed25519",
+    namedCurve: "Ed25519"
+  }, true, ["sign", "verify"]);
+  const privateKeyBuffer = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+  const publicKeyBuffer = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+  const privateKey = btoa(String.fromCharCode(...new Uint8Array(privateKeyBuffer)));
+  const publicKey = btoa(String.fromCharCode(...new Uint8Array(publicKeyBuffer)));
+  return { privateKey, publicKey };
+};
+var saveProductionConfig = (cloudPath, privateKey, publicKey) => {
+  const configPath = join5(cloudPath, "config.json");
+  const config = {
+    key: {
+      private: privateKey,
+      public: publicKey
+    }
+  };
+  console.log(chalk7.blue("Saving production configuration..."));
+  writeFileSync2(configPath, JSON.stringify(config, null, 2));
+  execSync(`chmod 600 ${configPath}`, { stdio: "inherit" });
+  console.log(chalk7.green("Production configuration saved"));
+};
+var createSystemdService = (cloudPath, publicKey, serverBinPath, userName) => {
+  const serviceContent = `[Unit]
+Description=NullJS Server
+After=network.target
+StartLimitIntervalSec=0
+
+[Service]
+Type=simple
+Restart=always
+RestartSec=1
+User=${userName}
+ExecStart=${serverBinPath}
+Environment=CLOUD_PATH=${cloudPath}
+Environment=PUBLIC_KEY=${publicKey}
+WorkingDirectory=${cloudPath}
+
+[Install]
+WantedBy=multi-user.target
+`;
+  return serviceContent;
+};
+var ensureCloudDirectory = (cloudPath) => {
+  if (!existsSync7(cloudPath)) {
+    console.log(chalk7.blue("Creating cloud directory..."));
+    try {
+      mkdirSync3(cloudPath, { recursive: true });
+      console.log(chalk7.green(`Cloud directory created: ${cloudPath}`));
+    } catch (error) {
+      console.log(chalk7.red("Failed to create cloud directory:"), error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  } else {
+    console.log(chalk7.gray(`Cloud directory already exists: ${cloudPath}`));
+  }
+};
+var installSystemdService = (serviceContent) => {
+  const servicePath = "/etc/systemd/system/nulljs.service";
+  console.log(chalk7.blue("Installing systemd service..."));
+  writeFileSync2("/tmp/nulljs.service", serviceContent);
+  execSync(`sudo mv /tmp/nulljs.service ${servicePath}`, { stdio: "inherit" });
+  execSync("sudo systemctl daemon-reload", { stdio: "inherit" });
+  execSync("sudo systemctl enable nulljs.service", { stdio: "inherit" });
+  console.log(chalk7.green("Systemd service installed and enabled"));
+};
+var validateLinux = () => {
+  if (process.platform !== "linux") {
+    console.log(chalk7.red("This command only works on Linux"));
+    process.exit(1);
+  }
+};
+var validateServerBinary = (serverBinPath) => {
+  if (!existsSync7(serverBinPath)) {
+    console.log(chalk7.red("Server binary not found at:"), serverBinPath);
+    console.log(chalk7.yellow("Make sure you have installed the package correctly"));
+    process.exit(1);
+  }
+};
+var checkExistingProductionConfig = (cloudPath) => {
+  const configPath = join5(cloudPath, "config.json");
+  if (!existsSync7(configPath)) {
+    return null;
+  }
+  try {
+    const configContent = JSON.parse(readFileSync2(configPath, "utf8"));
+    if (configContent.key?.private && configContent.key?.public) {
+      return configContent;
+    }
+  } catch {
+    console.log(chalk7.yellow("Existing production config is invalid, will regenerate"));
+  }
+  return null;
+};
+var unhost = async (options = {}) => {
+  validateLinux();
+  console.log(chalk7.blue("Removing NullJS production hosting..."));
+  try {
+    console.log(chalk7.blue("Stopping NullJS service..."));
+    try {
+      execSync("sudo systemctl stop nulljs", { stdio: "inherit" });
+      console.log(chalk7.green("Service stopped"));
+    } catch {
+      console.log(chalk7.yellow("Service was not running"));
+    }
+    try {
+      execSync("sudo systemctl disable nulljs", { stdio: "inherit" });
+      console.log(chalk7.green("Service disabled"));
+    } catch {
+      console.log(chalk7.yellow("Service was not enabled"));
+    }
+    const servicePath = "/etc/systemd/system/nulljs.service";
+    if (existsSync7(servicePath)) {
+      console.log(chalk7.blue("Removing systemd service file..."));
+      execSync(`sudo rm ${servicePath}`, { stdio: "inherit" });
+      execSync("sudo systemctl daemon-reload", { stdio: "inherit" });
+      console.log(chalk7.green("Systemd service file removed"));
+    }
+    if (!options.keepData) {
+      const defaultCloudPath = join5(homedir(), ".nulljs");
+      if (existsSync7(defaultCloudPath)) {
+        console.log(chalk7.blue("Removing cloud directory..."));
+        execSync(`rm -rf ${defaultCloudPath}`, { stdio: "inherit" });
+        console.log(chalk7.green("Cloud directory removed"));
+      } else {
+        console.log(chalk7.gray("Cloud directory does not exist"));
+      }
+    } else {
+      console.log(chalk7.gray("Keeping cloud data (--keep-data specified)"));
+    }
+    console.log(chalk7.green("NullJS hosting cleanup complete!"));
+    console.log("");
+    console.log(chalk7.blue("Summary:"));
+    console.log(chalk7.gray("   - Systemd service stopped and removed"));
+    if (!options.keepData) {
+      console.log(chalk7.gray("   - Cloud directory removed"));
+    }
+  } catch (error) {
+    console.log(chalk7.red("Failed to remove hosting setup:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+};
+var host = async (cloudPath) => {
+  validateLinux();
+  const resolvedCloudPath = cloudPath ? cloudPath.startsWith("/") ? cloudPath : join5(process.cwd(), cloudPath) : join5(homedir(), ".nulljs");
+  console.log(chalk7.blue("Setting up NullJS production hosting..."));
+  console.log(chalk7.gray(`   Cloud path: ${resolvedCloudPath}`));
+  const serverBinPath = getServerBinPath();
+  validateServerBinary(serverBinPath);
+  const currentUser = process.env.USER || process.env.USERNAME || "root";
+  console.log(chalk7.blue(`Setting up service to run as user: ${currentUser}`));
+  ensureCloudDirectory(resolvedCloudPath);
+  let productionConfig = checkExistingProductionConfig(resolvedCloudPath);
+  if (!productionConfig) {
+    const { privateKey, publicKey } = await generateProductionKeys();
+    saveProductionConfig(resolvedCloudPath, privateKey, publicKey);
+    productionConfig = { key: { private: privateKey, public: publicKey } };
+    console.log(chalk7.green("Production keys generated"));
+    console.log(chalk7.blue("Production Public Key:"));
+    console.log(chalk7.gray(productionConfig.key.public));
+  } else {
+    console.log(chalk7.green("Using existing production keys"));
+    console.log(chalk7.blue("Production Public Key:"));
+    console.log(chalk7.gray(productionConfig.key.public));
+  }
+  const serviceContent = createSystemdService(resolvedCloudPath, productionConfig.key.public, serverBinPath, currentUser);
+  installSystemdService(serviceContent);
+  console.log(chalk7.green("NullJS hosting setup complete!"));
+  console.log("");
+  console.log(chalk7.blue("Service management commands:"));
+  console.log(chalk7.gray("   Start:   "), chalk7.white("sudo systemctl start nulljs"));
+  console.log(chalk7.gray("   Stop:    "), chalk7.white("sudo systemctl stop nulljs"));
+  console.log(chalk7.gray("   Status:  "), chalk7.white("sudo systemctl status nulljs"));
+  console.log(chalk7.gray("   Logs:    "), chalk7.white("sudo journalctl -u nulljs -f"));
+  console.log("");
+  console.log(chalk7.yellow("Remember to start the service: sudo systemctl start nulljs"));
+};
+var registerHostCommand = (program) => {
+  const hostCmd = program.command("host").description("Set up NullJS production hosting with systemd").argument("[cloud-path]", "Path for cloud storage (default: ~/.nulljs)").action(async (cloudPath) => {
+    await host(cloudPath);
+  });
+  hostCmd.command("remove").description("Remove NullJS production hosting").option("--keep-data", "Keep cloud data directory").action(async (options) => {
+    await unhost(options);
+  });
+  hostCmd.command("logs").description("View NullJS server logs").option("-n, --lines <number>", "Number of lines to show", "100").option("--no-follow", "Do not follow log output").action((options) => {
+    validateLinux();
+    const args = ["-u", "nulljs", "-n", options.lines];
+    if (options.follow) {
+      args.push("-f");
+    }
+    try {
+      execSync(`journalctl ${args.join(" ")}`, { stdio: "inherit" });
+    } catch {}
+  });
+};
+// src/cli.ts
+var program = new Command3;
+program.name("nulljs").description("NullJS CLI").version("0.0.49");
+registerDevCommand(program);
+registerDeployCommand(program);
+registerConfigCommand(program);
+registerStatusCommand(program);
+registerSecretCommand(program);
+registerHostCommand(program);
+program.parse();