prodboard 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # prodboard
 
+## 0.2.2
+
+### Patch Changes
+
+- [`62ef4b0`](https://github.com/G4brym/prodboard/commit/62ef4b0a1f6969e3d06f549635ebfd337b84403c) Thanks [@G4brym](https://github.com/G4brym)! - Show config warnings (tmux availability, webui dependencies) on every CLI command. Improved webui dependency messages with actionable install commands.
+
+## 0.2.1
+
+### Patch Changes
+
+- [#9](https://github.com/G4brym/prodboard/pull/9) [`d418fc4`](https://github.com/G4brym/prodboard/commit/d418fc41b52e26789dd3b5be7f2dcdf9429ef287) Thanks [@G4brym](https://github.com/G4brym)! - Add `daemon restart` command with config validation and webui dependency checks. The `install` command now also validates config before proceeding. Invalid config values produce clear warnings with fix tips.
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -166,6 +166,7 @@ prodboard schedule stats --days 7                    # Statistics
 prodboard daemon                                     # Start (foreground)
 prodboard daemon --dry-run                           # Preview schedules
 prodboard daemon status                              # Check if running
+prodboard daemon restart                             # Restart via systemd
 ```
 
 ### Other

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prodboard",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Self-hosted, CLI-first issue tracker and cron scheduler for AI coding agents",
   "type": "module",
   "license": "MIT",

package/src/commands/daemon.ts

@@ -1,11 +1,13 @@
 import * as fs from "fs";
 import * as path from "path";
+import * as os from "os";
 import { ensureDb } from "../db.ts";
 import { loadConfig, PRODBOARD_DIR } from "../config.ts";
 import { listSchedules } from "../queries/schedules.ts";
 import { getNextFire } from "../cron.ts";
 import { formatDate } from "../format.ts";
 import { Daemon } from "../scheduler.ts";
+import { systemctlAvailable, runSystemctl } from "./install.ts";
 
 function parseArgs(args: string[]): { flags: Record<string, string | boolean>; positional: string[] } {
   const flags: Record<string, string | boolean> = {};
@@ -110,3 +112,29 @@ export async function daemonStatus(args: string[]): Promise<void> {
     try { fs.unlinkSync(pidFile); } catch {}
   }
 }
+
+export async function daemonRestart(_args: string[]): Promise<void> {
+  // Check systemd availability
+  if (!(await systemctlAvailable())) {
+    console.error("systemd is not available. daemon restart requires systemd.");
+    process.exit(1);
+  }
+
+  // Check service file exists
+  const servicePath = path.join(os.homedir(), ".config", "systemd", "user", "prodboard.service");
+  if (!fs.existsSync(servicePath)) {
+    console.error("prodboard is not installed as a systemd service. Run: prodboard install");
+    process.exit(1);
+  }
+
+  // Restart and show status
+  const restart = await runSystemctl("restart", "prodboard");
+  if (restart.exitCode !== 0) {
+    console.error("Failed to restart prodboard:", restart.stderr);
+    process.exit(1);
+  }
+
+  console.log("prodboard daemon restarted.");
+  const { stdout } = await runSystemctl("status", "prodboard");
+  console.log(stdout);
+}

package/src/commands/install.ts

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 
+
 const SERVICE_NAME = "prodboard";
 const SERVICE_DIR = path.join(os.homedir(), ".config", "systemd", "user");
 const SERVICE_PATH = path.join(SERVICE_DIR, `${SERVICE_NAME}.service`);
@@ -16,7 +17,7 @@ function parseArgs(args: string[]): { flags: Record<string, boolean> } {
   return { flags };
 }
 
-async function systemctlAvailable(): Promise<boolean> {
+export async function systemctlAvailable(): Promise<boolean> {
   try {
     const proc = Bun.spawn(["systemctl", "--version"], {
       stdout: "ignore",
@@ -29,7 +30,7 @@ async function systemctlAvailable(): Promise<boolean> {
   }
 }
 
-async function runSystemctl(...args: string[]): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+export async function runSystemctl(...args: string[]): Promise<{ exitCode: number; stdout: string; stderr: string }> {
   const proc = Bun.spawn(["systemctl", "--user", ...args], {
     stdout: "pipe",
     stderr: "pipe",

package/src/config.ts

@@ -140,13 +140,13 @@ export function deepMerge(defaults: any, user: any): any {
   return result;
 }
 
-export function loadConfig(configDir?: string): Config {
+export function loadConfigRaw(configDir?: string): { config: Config; rawParsed: any } {
   const dir = configDir ?? PRODBOARD_DIR;
   const configPath = path.join(dir, "config.jsonc");
   const defaults = getDefaults();
 
   if (!fs.existsSync(configPath)) {
-    return defaults;
+    return { config: defaults, rawParsed: {} };
   }
 
   let text: string;
@@ -165,5 +165,139 @@ export function loadConfig(configDir?: string): Config {
     throw new Error(`Invalid JSON in config file ${configPath}: ${err.message}`);
   }
 
-  return deepMerge(defaults, parsed);
+  return { config: deepMerge(defaults, parsed), rawParsed: parsed };
+}
+
+export function loadConfig(configDir?: string): Config {
+  return loadConfigRaw(configDir).config;
+}
+
+export function validateConfig(rawParsed: any): { errors: string[]; warnings: string[] } {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (typeof rawParsed !== "object" || rawParsed === null) {
+    errors.push("Config must be a JSON object.");
+    return { errors, warnings };
+  }
+
+  const knownTopLevel = ["general", "daemon", "webui"];
+  for (const key of Object.keys(rawParsed)) {
+    if (!knownTopLevel.includes(key)) {
+      warnings.push(`Unknown top-level key "${key}". Known keys: ${knownTopLevel.join(", ")}`);
+    }
+  }
+
+  const g = rawParsed.general;
+  if (g !== undefined) {
+    if (g.statuses !== undefined && (!Array.isArray(g.statuses) || !g.statuses.every((s: any) => typeof s === "string"))) {
+      warnings.push("general.statuses must be an array of strings.");
+    }
+    if (g.defaultStatus !== undefined && typeof g.defaultStatus !== "string") {
+      warnings.push(`general.defaultStatus must be a string, got ${typeof g.defaultStatus}.`);
+    }
+  }
+
+  const d = rawParsed.daemon;
+  if (d !== undefined) {
+    if (d.agent !== undefined && d.agent !== "claude" && d.agent !== "opencode") {
+      warnings.push(`daemon.agent must be "claude" or "opencode", got "${d.agent}".`);
+    }
+    if (d.useWorktrees !== undefined && !["auto", "always", "never"].includes(d.useWorktrees)) {
+      warnings.push(`daemon.useWorktrees must be "auto", "always", or "never", got "${d.useWorktrees}".`);
+    }
+    if (d.useTmux !== undefined && typeof d.useTmux !== "boolean") {
+      warnings.push(`daemon.useTmux must be a boolean, got ${typeof d.useTmux}.`);
+    }
+    for (const numField of ["maxConcurrentRuns", "maxTurns", "hardMaxTurns", "runTimeoutSeconds", "runRetentionDays"]) {
+      if (d[numField] !== undefined && typeof d[numField] !== "number") {
+        warnings.push(`daemon.${numField} must be a number, got ${typeof d[numField]}.`);
+      }
+    }
+  }
+
+  const w = rawParsed.webui;
+  if (w !== undefined) {
+    if (w.enabled !== undefined && typeof w.enabled !== "boolean") {
+      warnings.push(`webui.enabled must be a boolean, got ${typeof w.enabled}.`);
+    }
+    if (w.port !== undefined && (typeof w.port !== "number" || w.port < 1 || w.port > 65535)) {
+      warnings.push(`webui.port must be a number between 1 and 65535, got ${JSON.stringify(w.port)}.`);
+    }
+    if (w.hostname !== undefined && typeof w.hostname !== "string") {
+      warnings.push(`webui.hostname must be a string, got ${typeof w.hostname}.`);
+    }
+    if (w.password !== undefined && w.password !== null && typeof w.password !== "string") {
+      warnings.push(`webui.password must be a string or null, got ${typeof w.password}.`);
+    }
+  }
+
+  return { errors, warnings };
+}
+
+export async function checkWebuiDependencies(): Promise<string[]> {
+  const warnings: string[] = [];
+  try {
+    await import("hono");
+  } catch {
+    warnings.push(
+      "webui is enabled but 'hono' is not installed. " +
+      "Run: bun install hono (or bun install -g hono if prodboard is installed globally)"
+    );
+    return warnings; // skip JSX check if hono itself is missing
+  }
+  try {
+    await import("hono/jsx/jsx-runtime");
+  } catch {
+    warnings.push(
+      "webui is enabled but the Hono JSX runtime could not be loaded. " +
+      "Run: bun install hono (or bun install -g hono if prodboard is installed globally)"
+    );
+  }
+  return warnings;
+}
+
+export async function checkTmuxAvailable(): Promise<string | null> {
+  try {
+    const proc = Bun.spawn(["tmux", "-V"], { stdout: "ignore", stderr: "ignore" });
+    const code = await proc.exited;
+    if (code !== 0) {
+      return "daemon.useTmux is enabled but tmux is not installed. Install it (e.g. apt install tmux) or set useTmux to false.";
+    }
+    return null;
+  } catch {
+    return "daemon.useTmux is enabled but tmux is not installed. Install it (e.g. apt install tmux) or set useTmux to false.";
+  }
+}
+
+export async function printConfigWarnings(): Promise<void> {
+  let config: Config;
+  let rawParsed: any;
+  try {
+    const result = loadConfigRaw();
+    config = result.config;
+    rawParsed = result.rawParsed;
+  } catch (err: any) {
+    console.warn(`⚠ Config: ${err.message}`);
+    return;
+  }
+
+  const { warnings } = validateConfig(rawParsed);
+  for (const w of warnings) {
+    console.warn(`⚠ Config: ${w}`);
+  }
+
+  if (config.daemon.useTmux) {
+    const tmuxWarning = await checkTmuxAvailable();
+    if (tmuxWarning) {
+      console.warn(`⚠ ${tmuxWarning}`);
+    }
+  }
+
+  if (config.webui.enabled) {
+    const depWarnings = await checkWebuiDependencies();
+    for (const w of depWarnings) {
+      console.warn(`⚠ ${w}`);
+    }
+  }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 import { existsSync } from "fs";
-import { PRODBOARD_DIR } from "./config.ts";
+import { PRODBOARD_DIR, printConfigWarnings } from "./config.ts";
 
 export class NotInitializedError extends Error {
   constructor() {
@@ -36,6 +36,17 @@ export async function main(): Promise<void> {
     return;
   }
 
+  // Show config warnings for commands that use the config
+  const skipWarnings = ["init", "mcp", "version", "--version", "help", "--help", "uninstall"];
+  if (!skipWarnings.includes(command)) {
+    try {
+      ensureInitialized();
+      await printConfigWarnings();
+    } catch {
+      // ensureInitialized will throw again inside the switch if needed
+    }
+  }
+
   try {
     switch (command) {
       case "init": {
@@ -137,6 +148,8 @@ export async function main(): Promise<void> {
         const daemonMod = await import("./commands/daemon.ts");
         if (sub === "status") {
           await daemonMod.daemonStatus(args.slice(2));
+        } else if (sub === "restart") {
+          await daemonMod.daemonRestart(args.slice(2));
         } else {
           await daemonMod.daemonStart(args.slice(1));
         }
@@ -201,6 +214,8 @@ Commands:
   comments <id>     List comments for an issue
   schedule <sub>    Manage scheduled tasks
   daemon            Start the scheduler daemon
+  daemon restart    Restart the daemon (systemd)
+  daemon status     Show daemon status
   install           Install systemd service
   uninstall         Remove systemd service
   config            Show configuration