vibora 1.9.1 → 1.11.0

package/README.md

@@ -5,37 +5,34 @@
 
 The Vibe Engineer's Cockpit. Vibora marries basic project management with actual software development by embedding terminals directly into the workflow.
 
+Available in English and Chinese. Works with [z.ai](https://z.ai) for Claude Code proxy integration.
+
 ## Philosophy
 
 - **Terminal-first AI agent orchestration** — Agents (Claude Code, Codex, etc.) run in terminals as-is. No abstraction layer, no wrapper APIs, no feature parity maintenance as agents evolve.
 - **Opinionated with few opinions** — Provides structure without dictating workflow.
 - **Git worktree isolation** — Tasks create isolated git worktrees, with architecture supporting evolution toward more general task types.
 
-## Requirements
-
-- [Bun](https://bun.sh/) — JavaScript runtime
-- [dtach](https://github.com/crigler/dtach) — Terminal session persistence
-
-## Tech Stack
-
-- **Frontend**: React 19, TanStack Router & Query, xterm.js, Tailwind CSS, shadcn/ui (v4 with baseui support)
-- **Backend**: Hono.js on Bun, SQLite with Drizzle ORM, WebSocket for terminal I/O
-
 ## Quick Start
 
-Run the latest vibora with a single command:
+Requires [Node.js](https://nodejs.org/). Run the latest vibora with a single command:
 
 ```bash
-bunx vibora@latest up
+npx vibora@latest up
 ```
 
-This starts the vibora server as a daemon. Open http://localhost:3333 in your browser.
+This starts the vibora server as a daemon. Open http://localhost:3333 in your browser. The `up` command will help you install any missing dependencies.
 
 ```bash
-bunx vibora@latest down    # Stop the server
-bunx vibora@latest status  # Check if running
+npx vibora@latest down    # Stop the server
+npx vibora@latest status  # Check if running
 ```
 
+## Tech Stack
+
+- **Frontend**: React 19, TanStack Router & Query, xterm.js, Tailwind CSS, shadcn/ui (v4 with baseui support)
+- **Backend**: Hono.js on Bun, SQLite with Drizzle ORM, WebSocket for terminal I/O
+
 ## Configuration
 
 Settings are stored in `.vibora/settings.json`.

package/bin/vibora.js

@@ -230,6 +230,26 @@ class ViboraClient {
   async resetConfig(key) {
     return this.fetch(`/api/config/${key}`, { method: "DELETE" });
   }
+  async getNotifications() {
+    return this.fetch("/api/config/notifications");
+  }
+  async updateNotifications(updates) {
+    return this.fetch("/api/config/notifications", {
+      method: "PUT",
+      body: JSON.stringify(updates)
+    });
+  }
+  async testNotification(channel) {
+    return this.fetch(`/api/config/notifications/test/${channel}`, {
+      method: "POST"
+    });
+  }
+  async sendNotification(title, message) {
+    return this.fetch("/api/config/notifications/send", {
+      method: "POST",
+      body: JSON.stringify({ title, message })
+    });
+  }
 }
 
 // cli/src/utils/output.ts
@@ -237,25 +257,6 @@ var prettyOutput = false;
 function setPrettyOutput(value) {
   prettyOutput = value;
 }
-function isPrettyOutput() {
-  return prettyOutput;
-}
-function prettyLog(type, message) {
-  const prefixes = {
-    success: "\u2713",
-    info: "\u2192",
-    error: "\u2717",
-    warning: "\u26A0"
-  };
-  console.log(`${prefixes[type]} ${message}`);
-}
-function outputSuccess(message) {
-  if (prettyOutput) {
-    prettyLog("success", message);
-  } else {
-    output({ message });
-  }
-}
 function output(data) {
   const response = {
     success: true,
@@ -277,7 +278,6 @@ function outputError(error) {
 
 // cli/src/commands/current-task.ts
 var STATUS_MAP = {
-  done: "DONE",
   review: "IN_REVIEW",
   cancel: "CANCELED",
   "in-progress": "IN_PROGRESS"
@@ -332,7 +332,7 @@ async function handleCurrentTaskCommand(action, rest, flags) {
   }
   const newStatus = STATUS_MAP[action];
   if (!newStatus) {
-    throw new CliError("INVALID_ACTION", `Unknown action: ${action}. Valid actions: done, review, cancel, in-progress, pr, linear`, ExitCodes.INVALID_ARGS);
+    throw new CliError("INVALID_ACTION", `Unknown action: ${action}. Valid actions: review, cancel, in-progress, pr, linear`, ExitCodes.INVALID_ARGS);
   }
   const task = await findCurrentTask(client, pathOverride);
   const updatedTask = await client.moveTask(task.id, newStatus);
@@ -341,7 +341,7 @@ async function handleCurrentTaskCommand(action, rest, flags) {
 
 // cli/src/commands/tasks.ts
 import { basename } from "path";
-var VALID_STATUSES = ["IN_PROGRESS", "IN_REVIEW", "DONE", "CANCELED"];
+var VALID_STATUSES = ["IN_PROGRESS", "IN_REVIEW", "CANCELED"];
 async function handleTasksCommand(action, positional, flags) {
   const client = new ViboraClient(flags.url, flags.port);
   switch (action) {
@@ -823,200 +823,78 @@ async function handleHealthCommand(flags) {
   output(health);
 }
 
-// cli/src/commands/hooks.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { execSync as execSync2 } from "child_process";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function getClaudeSettingsPath(global) {
-  if (global) {
-    return path.join(os.homedir(), ".claude", "settings.json");
-  }
-  return path.join(process.cwd(), ".claude", "settings.json");
-}
-function readClaudeSettings(settingsPath) {
-  if (!fs.existsSync(settingsPath)) {
-    return {};
-  }
-  try {
-    const content = fs.readFileSync(settingsPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function writeClaudeSettings(settingsPath, settings) {
-  const dir = path.dirname(settingsPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-}
-function getViboraHookPath() {
-  const currentFile = fileURLToPath2(import.meta.url);
-  const scriptDir = path.dirname(currentFile);
-  const possiblePaths = [
-    path.join(scriptDir, "..", "scripts", "vibora-plan-complete-hook"),
-    path.join(scriptDir, "..", "..", "scripts", "vibora-plan-complete-hook"),
-    "vibora-plan-complete-hook"
-  ];
-  for (const p of possiblePaths) {
-    if (p === "vibora-plan-complete-hook") {
-      try {
-        execSync2("which vibora-plan-complete-hook", { stdio: "pipe" });
-        return "vibora-plan-complete-hook";
-      } catch {
-        continue;
-      }
-    } else if (fs.existsSync(p)) {
-      return path.resolve(p);
-    }
-  }
-  return "vibora-plan-complete-hook";
-}
-function installStopHook(global) {
-  const settingsPath = getClaudeSettingsPath(global);
-  const settings = readClaudeSettings(settingsPath);
-  const hookCommand = getViboraHookPath();
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  const existingStopHooks = settings.hooks.Stop || [];
-  const hasViboraHook = existingStopHooks.some((hook) => hook.hooks.some((h) => h.type === "command" && h.command?.includes("vibora-plan-complete-hook")));
-  if (hasViboraHook) {
-    return { settingsPath, hookCommand };
-  }
-  settings.hooks.Stop = [
-    ...existingStopHooks,
-    {
-      hooks: [
-        {
-          type: "command",
-          command: hookCommand
-        }
-      ]
+// cli/src/commands/notifications.ts
+var VALID_CHANNELS = ["sound", "slack", "discord", "pushover"];
+async function handleNotificationsCommand(action, positional, flags) {
+  const client = new ViboraClient(flags.url, flags.port);
+  switch (action) {
+    case "status":
+    case undefined: {
+      const settings = await client.getNotifications();
+      output(settings);
+      break;
     }
-  ];
-  writeClaudeSettings(settingsPath, settings);
-  return { settingsPath, hookCommand };
-}
-function uninstallStopHook(global) {
-  const settingsPath = getClaudeSettingsPath(global);
-  const settings = readClaudeSettings(settingsPath);
-  if (!settings.hooks?.Stop) {
-    return { settingsPath, removed: false };
-  }
-  const originalLength = settings.hooks.Stop.length;
-  settings.hooks.Stop = settings.hooks.Stop.filter((hook) => !hook.hooks.some((h) => h.type === "command" && h.command?.includes("vibora-plan-complete-hook")));
-  const removed = settings.hooks.Stop.length < originalLength;
-  if (removed) {
-    if (settings.hooks.Stop.length === 0) {
-      delete settings.hooks.Stop;
+    case "enable": {
+      const updated = await client.updateNotifications({ enabled: true });
+      output(updated);
+      break;
     }
-    if (Object.keys(settings.hooks).length === 0) {
-      delete settings.hooks;
+    case "disable": {
+      const updated = await client.updateNotifications({ enabled: false });
+      output(updated);
+      break;
     }
-    writeClaudeSettings(settingsPath, settings);
-  }
-  return { settingsPath, removed };
-}
-function checkStopHook(global) {
-  const settingsPath = getClaudeSettingsPath(global);
-  const settings = readClaudeSettings(settingsPath);
-  if (!settings.hooks?.Stop) {
-    return { installed: false, settingsPath };
-  }
-  for (const hook of settings.hooks.Stop) {
-    for (const h of hook.hooks) {
-      if (h.type === "command" && h.command?.includes("vibora-plan-complete-hook")) {
-        return { installed: true, settingsPath, hookCommand: h.command };
+    case "test": {
+      const [channel] = positional;
+      if (!channel) {
+        throw new CliError("MISSING_CHANNEL", `Channel is required. Valid: ${VALID_CHANNELS.join(", ")}`, ExitCodes.INVALID_ARGS);
       }
-    }
-  }
-  return { installed: false, settingsPath };
-}
-async function handleHooksCommand(action, _rest, flags) {
-  const global = flags.global === "true" || flags.g === "true";
-  switch (action) {
-    case "install": {
-      const { settingsPath, hookCommand } = installStopHook(global);
-      if (isPrettyOutput()) {
-        prettyLog("success", `Installed Vibora Stop hook`);
-        prettyLog("info", `  Settings: ${settingsPath}`);
-        prettyLog("info", `  Command: ${hookCommand}`);
-        prettyLog("info", "");
-        prettyLog("info", "The hook will automatically transition tasks to IN_REVIEW");
-        prettyLog("info", "when Claude Code finishes in a Vibora worktree.");
-      } else {
-        outputSuccess({
-          action: "install",
-          settingsPath,
-          hookCommand,
-          message: "Stop hook installed successfully"
-        });
+      if (!VALID_CHANNELS.includes(channel)) {
+        throw new CliError("INVALID_CHANNEL", `Invalid channel: ${channel}. Valid: ${VALID_CHANNELS.join(", ")}`, ExitCodes.INVALID_ARGS);
       }
+      const result = await client.testNotification(channel);
+      output(result);
       break;
     }
-    case "uninstall": {
-      const { settingsPath, removed } = uninstallStopHook(global);
-      if (isPrettyOutput()) {
-        if (removed) {
-          prettyLog("success", `Removed Vibora Stop hook from ${settingsPath}`);
-        } else {
-          prettyLog("info", "Vibora Stop hook was not installed");
-        }
-      } else {
-        outputSuccess({
-          action: "uninstall",
-          settingsPath,
-          removed
-        });
+    case "set": {
+      const [channel, key, value] = positional;
+      if (!channel) {
+        throw new CliError("MISSING_CHANNEL", `Channel is required. Valid: ${VALID_CHANNELS.join(", ")}`, ExitCodes.INVALID_ARGS);
       }
-      break;
-    }
-    case "status": {
-      const { installed, settingsPath, hookCommand } = checkStopHook(global);
-      if (isPrettyOutput()) {
-        if (installed) {
-          prettyLog("success", "Vibora Stop hook is installed");
-          prettyLog("info", `  Settings: ${settingsPath}`);
-          prettyLog("info", `  Command: ${hookCommand}`);
-        } else {
-          prettyLog("info", "Vibora Stop hook is not installed");
-          prettyLog("info", `  Settings: ${settingsPath}`);
-          prettyLog("info", "");
-          prettyLog("info", 'Run "vibora hooks install" to install it.');
-        }
-      } else {
-        outputSuccess({
-          action: "status",
-          installed,
-          settingsPath,
-          hookCommand
-        });
+      if (!VALID_CHANNELS.includes(channel)) {
+        throw new CliError("INVALID_CHANNEL", `Invalid channel: ${channel}. Valid: ${VALID_CHANNELS.join(", ")}`, ExitCodes.INVALID_ARGS);
       }
+      if (!key) {
+        throw new CliError("MISSING_KEY", "Setting key is required", ExitCodes.INVALID_ARGS);
+      }
+      if (value === undefined) {
+        throw new CliError("MISSING_VALUE", "Setting value is required", ExitCodes.INVALID_ARGS);
+      }
+      const update = buildChannelUpdate(channel, key, value);
+      const updated = await client.updateNotifications(update);
+      output(updated);
       break;
     }
     default:
-      if (isPrettyOutput()) {
-        console.log(`Usage: vibora hooks <action> [--global]
-
-Actions:
-  install     Install the Stop hook for auto task transitions
-  uninstall   Remove the Stop hook
-  status      Check if the Stop hook is installed
-
-Options:
-  --global    Use global Claude settings (~/.claude/settings.json)
-              Default is project-local (.claude/settings.json)
+      throw new CliError("UNKNOWN_ACTION", `Unknown action: ${action}. Valid: status, enable, disable, test, set`, ExitCodes.INVALID_ARGS);
+  }
+}
+function buildChannelUpdate(channel, key, value) {
+  const parsedValue = value === "true" ? true : value === "false" ? false : value;
+  const channelConfig = { [key]: parsedValue };
+  return { [channel]: channelConfig };
+}
 
-The Stop hook automatically transitions tasks from IN_PROGRESS to IN_REVIEW
-when Claude Code finishes in a Vibora worktree.`);
-      } else {
-        throw new CliError("INVALID_ACTION", `Invalid hooks action: ${action}. Use install, uninstall, or status.`, ExitCodes.INVALID_ARGS);
-      }
+// cli/src/commands/notify.ts
+async function handleNotifyCommand(positional, flags) {
+  const client = new ViboraClient(flags.url, flags.port);
+  const title = flags.title || positional[0];
+  const message = flags.message || positional.slice(1).join(" ") || positional[0];
+  if (!title) {
+    throw new CliError("MISSING_TITLE", "Title is required. Usage: vibora notify <title> [message] or --title=<title> --message=<message>", ExitCodes.INVALID_ARGS);
   }
+  const result = await client.sendNotification(title, message || title);
+  output(result);
 }
 
 // cli/src/index.ts
@@ -1093,9 +971,14 @@ Commands:
   config get <key>          Get a config value
   config set <key> <value>  Set a config value
 
-  hooks install             Install Claude Code Stop hook
-  hooks uninstall           Remove Claude Code Stop hook
-  hooks status              Check if Stop hook is installed
+  notifications             Show notification settings
+  notifications enable      Enable notifications
+  notifications disable     Disable notifications
+  notifications test <ch>   Test a channel (sound, slack, discord, pushover)
+  notifications set <ch> <key> <value>
+                            Set a channel config (e.g., slack webhookUrl <url>)
+
+  notify <title> [message]  Send a notification to all enabled channels
 
   health                    Check server health
 
@@ -1157,9 +1040,13 @@ Examples:
         await handleHealthCommand(flags);
         break;
       }
-      case "hooks": {
-        const [action, ...hooksRest] = rest;
-        await handleHooksCommand(action, hooksRest, flags);
+      case "notifications": {
+        const [action, ...notificationsRest] = rest;
+        await handleNotificationsCommand(action, notificationsRest, flags);
+        break;
+      }
+      case "notify": {
+        await handleNotifyCommand(rest, flags);
         break;
       }
       default: