@jango-blockchained/hoox-cli 0.4.1 → 0.5.1

package/src/commands/logs/logs-command.ts

@@ -0,0 +1,452 @@
+/**
+ * `hoox logs` command group — real-time log tailing for Cloudflare Workers.
+ *
+ * Subcommands:
+ *   worker <name>  — Tail logs for a specific worker
+ *   all            — Tail logs from all enabled workers concurrently
+ *
+ * Uses Bun.spawn to run `wrangler tail` with streaming output.
+ * Supports --level (log/info/warn/error), --follow/--no-follow, and --json flags.
+ */
+
+import { Command } from "commander";
+import { ConfigService } from "../../services/config/index.js";
+import { CLIError, ExitCode } from "../../utils/errors.js";
+import {
+  formatError,
+  formatSuccess,
+  getFormatOptions,
+} from "../../utils/formatters.js";
+import { theme } from "../../utils/theme.js";
+import type { FormatOptions } from "../../utils/formatters.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Valid log levels for filtering */
+const VALID_LEVELS = ["log", "info", "warn", "error", "debug", "all"] as const;
+type LogLevel = (typeof VALID_LEVELS)[number];
+
+interface WorkerLogOptions {
+  level: LogLevel;
+  follow: boolean;
+  json: boolean;
+}
+
+interface WranglerLogEntry {
+  outcome: string;
+  scriptName?: string;
+  logs?: Array<{
+    message: string[];
+    level: string;
+    timestamp: number;
+  }>;
+  exceptions?: Array<{
+    name: string;
+    message: string;
+  }>;
+  eventTimestamp?: number;
+  event?: unknown;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Validate and normalize the log level string.
+ * Defaults to "all" for unknown values.
+ */
+function normalizeLevel(raw: string): LogLevel {
+  const lower = raw.toLowerCase();
+  if (VALID_LEVELS.includes(lower as LogLevel)) {
+    return lower as LogLevel;
+  }
+  return "all";
+}
+
+/**
+ * Check whether a log entry matches the requested level filter.
+ * "all" matches everything; otherwise, the entry's level must equal the filter.
+ */
+function matchesLevel(entry: WranglerLogEntry, level: LogLevel): boolean {
+  if (level === "all") return true;
+  const entryLogs = entry.logs ?? [];
+  return entryLogs.some((l) => l.level === level);
+}
+
+/**
+ * Format a single JSON log line from wrangler for human-readable output.
+ * Extracts timestamp, level, and message fields.
+ */
+function formatLogLine(entry: WranglerLogEntry): string {
+  const timestamp = entry.eventTimestamp
+    ? new Date(entry.eventTimestamp).toISOString()
+    : new Date().toISOString();
+
+  const logs = entry.logs ?? [];
+  if (logs.length === 0) {
+    // Non-log events (e.g. request outcome)
+    return theme.dim(`[${timestamp}]`) + ` ${entry.outcome}`;
+  }
+
+  const parts = logs.map((l) => {
+    const levelColor =
+      l.level === "error"
+        ? theme.error
+        : l.level === "warn"
+          ? theme.warning
+          : l.level === "info"
+            ? theme.info
+            : theme.dim;
+    const msg = l.message.join(" ");
+    return `${theme.dim(`[${timestamp}]`)} ${levelColor(`[${l.level.toUpperCase()}]`)} ${msg}`;
+  });
+
+  return parts.join("\n");
+}
+
+/**
+ * Parse a line from wrangler tail --format json output.
+ * Returns null if the line is not valid JSON.
+ */
+function parseLogLine(line: string): WranglerLogEntry | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed) as WranglerLogEntry;
+  } catch {
+    // Non-JSON lines are passed through as-is (e.g. wrangler status messages)
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tail implementation
+// ---------------------------------------------------------------------------
+
+/**
+ * Tail logs for a single worker using wrangler.
+ *
+ * Spawns `wrangler tail <workerName>` and streams stdout to the terminal.
+ * With --follow (default), runs until interrupted (Ctrl+C).
+ * With --no-follow, captures output for 5 seconds then exits.
+ * With --level, filters JSON log entries by log level.
+ * With --json, passes through wrangler's JSON output directly.
+ */
+async function tailWorker(
+  workerName: string,
+  opts: WorkerLogOptions,
+  fmt: FormatOptions
+): Promise<void> {
+  const wranglerArgs = ["wrangler", "tail", workerName];
+
+  // Use JSON format when level filtering or --json output is requested
+  if (opts.level !== "all" || opts.json) {
+    wranglerArgs.push("--format", "json");
+  }
+
+  let proc: Bun.Subprocess | null = null;
+
+  try {
+    proc = Bun.spawn(wranglerArgs, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    if (!proc.stdout || typeof proc.stdout === "number") {
+      throw new CLIError(
+        "Failed to get stdout stream from wrangler tail",
+        ExitCode.ERROR
+      );
+    }
+
+    const reader = (proc.stdout as ReadableStream<Uint8Array>).getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    const readLoop = async () => {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+
+        // Process complete lines
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? ""; // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+
+          if (opts.level !== "all" || opts.json) {
+            const entry = parseLogLine(line);
+
+            if (entry !== null) {
+              // JSON parse succeeded
+              if (!matchesLevel(entry, opts.level)) continue;
+
+              if (opts.json) {
+                process.stdout.write(JSON.stringify(entry) + "\n");
+              } else {
+                process.stdout.write(formatLogLine(entry) + "\n");
+              }
+            } else {
+              // Non-JSON line (wrangler status message) — pass through
+              if (opts.level === "all") {
+                process.stdout.write(line + "\n");
+              }
+            }
+          } else {
+            // Raw pass-through mode
+            process.stdout.write(line + "\n");
+          }
+        }
+      }
+
+      // Flush remaining buffer
+      if (buffer.trim()) {
+        process.stdout.write(buffer + "\n");
+      }
+    };
+
+    if (opts.follow) {
+      // Continuous streaming — run until interrupted
+      await readLoop();
+    } else {
+      // Show recent and exit after a short timeout
+      const timeout = 5000;
+      const timeoutPromise = new Promise<void>((resolve) =>
+        setTimeout(resolve, timeout)
+      );
+
+      await Promise.race([readLoop(), timeoutPromise]);
+
+      // Kill the wrangler process after timeout
+      if (proc && !proc.killed) {
+        proc.kill();
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    formatError(
+      new CLIError(
+        `Failed to tail logs for "${workerName}": ${message}`,
+        ExitCode.ERROR
+      ),
+      fmt
+    );
+    process.exitCode = ExitCode.ERROR;
+  } finally {
+    // Ensure the process is killed on cleanup
+    if (proc && !proc.killed) {
+      proc.kill();
+    }
+  }
+}
+
+/**
+ * Tail logs for all enabled workers concurrently.
+ *
+ * Loads ConfigService.listEnabledWorkers(), spawns a tail process for each,
+ * and prefixes output with the worker name.
+ */
+async function tailAllWorkers(
+  opts: WorkerLogOptions,
+  fmt: FormatOptions
+): Promise<void> {
+  const configService = new ConfigService();
+  await configService.load();
+  const workers = configService.listEnabledWorkers();
+
+  if (workers.length === 0) {
+    formatSuccess("No enabled workers found to tail", fmt);
+    return;
+  }
+
+  const wranglerArgsBase = ["wrangler", "tail"];
+  if (opts.level !== "all" || opts.json) {
+    wranglerArgsBase.push("--format", "json");
+  }
+
+  const processes: Array<{
+    name: string;
+    proc: Bun.Subprocess;
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+  }> = [];
+
+  try {
+    // Spawn a tail process for each worker
+    for (const workerName of workers) {
+      const proc = Bun.spawn(
+        ["wrangler", "tail", workerName, ...wranglerArgsBase.slice(2)],
+        {
+          stdout: "pipe",
+          stderr: "pipe",
+        }
+      );
+      processes.push({
+        name: workerName,
+        proc,
+        reader: proc.stdout.getReader(),
+      });
+    }
+
+    // Read from all workers concurrently, prefixing with worker name
+    const decoder = new TextDecoder();
+    const buffers = new Map<string, string>();
+
+    const readFromWorker = async (p: (typeof processes)[0]) => {
+      let buffer = buffers.get(p.name) ?? "";
+      while (true) {
+        const { done, value } = await p.reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+
+          const prefix = theme.bold(`[${p.name}]`);
+
+          if (opts.level !== "all" || opts.json) {
+            const entry = parseLogLine(line);
+            if (entry !== null) {
+              if (!matchesLevel(entry, opts.level)) continue;
+              if (opts.json) {
+                process.stdout.write(
+                  JSON.stringify({ worker: p.name, ...entry }) + "\n"
+                );
+              } else {
+                process.stdout.write(`${prefix} ${formatLogLine(entry)}\n`);
+              }
+            } else if (opts.level === "all") {
+              process.stdout.write(`${prefix} ${line}\n`);
+            }
+          } else {
+            process.stdout.write(`${prefix} ${line}\n`);
+          }
+        }
+      }
+
+      // Flush remaining buffer
+      if (buffer.trim()) {
+        process.stdout.write(`${theme.bold(`[${p.name}]`)} ${buffer}\n`);
+      }
+
+      buffers.set(p.name, buffer);
+    };
+
+    if (opts.follow) {
+      // Run all readers concurrently until interrupted
+      await Promise.all(processes.map((p) => readFromWorker(p)));
+    } else {
+      // Show recent and exit after timeout
+      const timeout = 5000;
+      const timeoutPromise = new Promise<void>((resolve) =>
+        setTimeout(resolve, timeout)
+      );
+
+      await Promise.race([
+        Promise.all(processes.map((p) => readFromWorker(p))),
+        timeoutPromise,
+      ]);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    formatError(
+      new CLIError(`Failed to tail workers: ${message}`, ExitCode.ERROR),
+      fmt
+    );
+    process.exitCode = ExitCode.ERROR;
+  } finally {
+    // Kill all processes on cleanup
+    for (const p of processes) {
+      if (!p.proc.killed) {
+        p.proc.kill();
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Register the `hoox logs` command group with subcommands:
+ * worker <name> and all.
+ */
+export function registerLogsCommand(program: Command): void {
+  const logsCmd = program
+    .command("logs")
+    .description("Tail and view Cloudflare Worker logs in real-time");
+
+  // -- logs worker <name> ---------------------------------------------------
+  logsCmd
+    .command("worker <name>")
+    .description("Tail logs for a specific Cloudflare Worker")
+    .option(
+      "--level <level>",
+      "Filter by log level (log, info, warn, error, debug, all)",
+      "all"
+    )
+    .option("--follow", "Continuously stream logs (default)", true)
+    .option("--no-follow", "Show recent logs and exit after 5 seconds")
+    .option("--json", "Output logs in JSON format")
+    .action(
+      async (
+        name: string,
+        options: { level?: string; follow?: boolean; json?: boolean }
+      ) => {
+        const fmt = getFormatOptions(program);
+        const workerOpts: WorkerLogOptions = {
+          level: normalizeLevel(options.level ?? "all"),
+          follow: options.follow !== false, // --no-follow sets follow to false
+          json: Boolean(options.json),
+        };
+
+        try {
+          await tailWorker(name, workerOpts, fmt);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          formatError(message, fmt);
+          process.exitCode = ExitCode.ERROR;
+        }
+      }
+    );
+
+  // -- logs all -------------------------------------------------------------
+  logsCmd
+    .command("all")
+    .description("Tail logs from all enabled workers concurrently")
+    .option(
+      "--level <level>",
+      "Filter by log level (log, info, warn, error, debug, all)",
+      "all"
+    )
+    .option("--follow", "Continuously stream logs (default)", true)
+    .option("--no-follow", "Show recent logs and exit after 5 seconds")
+    .option("--json", "Output logs in JSON format")
+    .action(
+      async (options: { level?: string; follow?: boolean; json?: boolean }) => {
+        const fmt = getFormatOptions(program);
+        const workerOpts: WorkerLogOptions = {
+          level: normalizeLevel(options.level ?? "all"),
+          follow: options.follow !== false,
+          json: Boolean(options.json),
+        };
+
+        try {
+          await tailAllWorkers(workerOpts, fmt);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          formatError(message, fmt);
+          process.exitCode = ExitCode.ERROR;
+        }
+      }
+    );
+}

package/src/commands/update/update-command.ts

@@ -1,46 +1,163 @@
 import { Command } from "commander";
+import { spinner } from "@clack/prompts";
+import { ConfigService } from "../../services/config/index.js";
 import { UpdateService } from "../../services/update/index.js";
-import {
-  formatSuccess,
-  formatError,
-  getFormatOptions,
-} from "../../utils/formatters.js";
+import { formatError, getFormatOptions } from "../../utils/formatters.js";
 import { CLIError, ExitCode } from "../../utils/errors.js";
+import { theme } from "../../utils/theme.js";
+
+async function gitPull(cwd: string): Promise<string> {
+  const proc = Bun.spawn(["git", "pull", "--ff-only"], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const exitCode = await proc.exited;
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || `git pull failed (exit ${exitCode})`);
+  }
+  return stdout.trim();
+}
+
+async function gitSubmoduleUpdate(
+  cwd: string,
+  submodulePath: string
+): Promise<string> {
+  const proc = Bun.spawn(
+    ["git", "submodule", "update", "--remote", "--init", "--", submodulePath],
+    {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    }
+  );
+  const exitCode = await proc.exited;
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+
+  if (exitCode !== 0) {
+    throw new Error(
+      stderr.trim() || `git submodule update failed (exit ${exitCode})`
+    );
+  }
+  return stdout.trim();
+}
+
+async function isGitRepo(cwd: string): Promise<boolean> {
+  const proc = Bun.spawn(["git", "rev-parse", "--is-inside-work-tree"], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const exitCode = await proc.exited;
+  return exitCode === 0;
+}
+
+async function isSubmodule(
+  cwd: string,
+  submodulePath: string
+): Promise<boolean> {
+  const proc = Bun.spawn(["git", "submodule", "status", "--", submodulePath], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) return false;
+  const out = (await new Response(proc.stdout).text()).trim();
+  return out.length > 0;
+}
 
 export function registerUpdateCommand(program: Command): void {
   program
     .command("update")
-    .summary("Update project dependencies (default: wrangler)")
+    .summary("Sync repo from GitHub or update wrangler")
     .description(
-      `Update wrangler to the latest available version.
+      `Update your local project from GitHub or update wrangler.
 
-Updates wrangler in the project's package.json
-via \`bun update wrangler\`.
+Without arguments, pulls latest changes for the main repo.
+With a worker name, updates that worker's submodule from its remote.
+With "wrangler", updates wrangler to the latest version.
 
 EXAMPLES:
-  hoox update              Check and update wrangler`
+  hoox update              Pull latest for main repo
+  hoox update d1-worker    Update the d1-worker submodule
+  hoox update wrangler     Update wrangler to latest version`
     )
-    .action(async () => {
+    .argument(
+      "[target]",
+      'What to update: worker name (e.g. d1-worker) or "wrangler"'
+    )
+    .action(async (target?: string) => {
       const fmt = getFormatOptions(program);
+      const cwd = process.cwd();
+
       try {
-        const service = new UpdateService();
-        const result = await service.updateWrangler();
-
-        if (result.updated) {
-          formatSuccess(
-            result.newVersion
-              ? `Wrangler updated to ${result.newVersion}`
-              : "Wrangler updated",
-            fmt
+        if (target === "wrangler") {
+          const service = new UpdateService();
+          const result = await service.updateWrangler();
+
+          if (result.error) {
+            formatError(
+              new CLIError(`Update failed: ${result.error}`, ExitCode.ERROR),
+              fmt
+            );
+            process.exitCode = ExitCode.ERROR;
+          }
+          return;
+        }
+
+        if (!(await isGitRepo(cwd))) {
+          throw new CLIError(
+            "Not a git repository — run this command from the project root",
+            ExitCode.INVALID_USAGE
           );
-        } else if (result.error) {
-          formatError(
-            new CLIError(`Update failed: ${result.error}`, ExitCode.ERROR),
-            fmt
+        }
+
+        if (target) {
+          const configService = new ConfigService();
+          await configService.load();
+          const worker = configService.getWorker(target);
+
+          if (!worker) {
+            throw new CLIError(
+              `Unknown worker "${target}" — not found in wrangler.jsonc`,
+              ExitCode.INVALID_USAGE
+            );
+          }
+
+          const submodulePath = worker.path;
+          if (!(await isSubmodule(cwd, submodulePath))) {
+            throw new CLIError(
+              `"${submodulePath}" is not a git submodule — nothing to update`,
+              ExitCode.INVALID_USAGE
+            );
+          }
+
+          const s = spinner();
+          s.start(`Updating ${target}...`);
+
+          const output = await gitSubmoduleUpdate(cwd, submodulePath);
+
+          s.stop(
+            output
+              ? theme.success(`Updated ${target}`)
+              : theme.muted(`${target} already up to date`)
           );
-          process.exitCode = ExitCode.ERROR;
         } else {
-          formatSuccess("Wrangler is already up to date", fmt);
+          const s = spinner();
+          s.start("Pulling latest from remote...");
+
+          const output = await gitPull(cwd);
+
+          s.stop(
+            output
+              ? theme.success("Repository up to date")
+              : theme.muted("Already up to date")
+          );
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/src/index.ts

@@ -131,6 +131,7 @@ process.on("unhandledRejection", (reason) => {
 // ---------------------------------------------------------------------------
 
 import { registerInitCommand } from "./commands/init/index.js";
+import { WIZARD_STATE_PATH } from "@jango-blockchained/hoox-shared";
 import { registerDevCommand } from "./commands/dev/index.js";
 import { registerDeployCommand } from "./commands/deploy/index.js";
 import { registerInfraCommand } from "./commands/infra/index.js";
@@ -222,6 +223,25 @@ export async function main(): Promise<void> {
   if (hasArgs) {
     program.parse();
   } else {
+    // Auto-launch the setup wizard if not yet initialized
+    const configFile = Bun.file("wrangler.jsonc");
+    const hasConfig = await configFile.exists();
+    const wizardStateFile = Bun.file(WIZARD_STATE_PATH);
+    const hasWizardState = await wizardStateFile.exists();
+
+    if (!hasConfig) {
+      // No wrangler.jsonc → project is uninitialized → run the wizard
+      // If there's a partial wizard state file, auto-resume
+      const args = hasWizardState ? ["init", "--resume"] : ["init"];
+      await program.parseAsync(args, { from: "user" });
+      process.exit(ExitCode.SUCCESS);
+    }
+
+    // Clean up stale wizard state if project is already initialized
+    if (hasWizardState) {
+      await Bun.write(WIZARD_STATE_PATH, "");
+    }
+
     // Interactive TUI mode — launches when hoox is called with no arguments
     await runInteractiveTUI(program);
     process.exit(ExitCode.SUCCESS);