vibora 4.5.2 → 4.7.0

package/README.md

@@ -135,8 +135,9 @@ claude plugin install vibora@vibora --scope user
 
 ### MCP Tools
 
-The plugin includes an MCP server that exposes task management tools:
+The plugin includes an MCP server that exposes task management and remote execution tools:
 
+**Task Management:**
 - `list_tasks` — List all tasks with optional status/repo filter
 - `get_task` — Get task details by ID
 - `create_task` — Create a new task with git worktree
@@ -146,6 +147,14 @@ The plugin includes an MCP server that exposes task management tools:
 - `list_repositories` — List configured repositories
 - `send_notification` — Send notification to enabled channels
 
+**Remote Command Execution:**
+- `execute_command` — Execute shell commands on the Vibora server with persistent session support
+- `list_exec_sessions` — List active command execution sessions
+- `update_exec_session` — Rename a session
+- `destroy_exec_session` — Clean up a session
+
+The `execute_command` tool supports persistent sessions where environment variables, working directory, and shell state are preserved between commands. Sessions can be given optional names for identification and persist until manually destroyed.
+
 For Claude Desktop, add to your `claude_desktop_config.json`:
 
 ```json
@@ -163,18 +172,40 @@ For Claude Desktop, add to your `claude_desktop_config.json`:
 
 Run the backend on a remote server and connect from anywhere. Launch tasks, close your laptop, and your agents keep working. As AI becomes more capable of autonomous work, this becomes essential.
 
-1. **Set up a secure tunnel** — Use Tailscale (recommended) or Cloudflare Tunnels to securely expose your server
-   - **Tailscale** — Works with both web and desktop app. No CORS configuration needed.
-   - **Cloudflare Tunnels** — Alternative for web-only usage. Note: Desktop app has CORS limitations with Cloudflare Tunnels.
+### Desktop App: SSH Port Forwarding (Recommended)
+
+The desktop app connects to `localhost:7777`. Use SSH port forwarding to tunnel to your remote server:
+
+```bash
+# Forward local port 7777 to remote server's port 7777
+ssh -L 7777:localhost:7777 your-server
+
+# Or run in background with keep-alive
+ssh -fN -o ServerAliveInterval=30 -o ServerAliveCountMax=3 -L 7777:localhost:7777 your-server
+```
+
+On the remote server, start Vibora:
+```bash
+npx vibora@latest up
+```
+
+The desktop app will connect through the tunnel automatically. This approach is:
+- **Secure** — Backend stays bound to localhost, no exposed ports
+- **Performant** — Direct SSH connection, lower latency than overlay networks
+- **Simple** — No additional configuration needed
 
-2. **On the remote server:**
+For persistent tunnels on macOS, use a launchd agent. See [this guide](https://gist.github.com/knowsuchagency/60656087903cd56d3a9b5d1d5c803186).
+
+### Browser: Tailscale or Cloudflare Tunnels
+
+For browser-only access, you can use Tailscale or Cloudflare Tunnels to expose your server:
+
+1. **On the remote server:**
    ```bash
    npx vibora@latest up
    ```
 
-3. **Connect from desktop app** — Click "Connect to Remote" and enter the server URL (e.g., `http://your-server.tailnet.ts.net:7777`)
-
-4. **Or access via browser** — Open the tunnel URL in your browser
+2. **Access via browser** — Open the tunnel URL (e.g., `http://your-server.tailnet.ts.net:7777`)
 
 <details>
 <summary><strong>Configuration</strong></summary>
@@ -187,13 +218,12 @@ Settings are stored in `.vibora/settings.json`. The vibora directory is resolved
 
 | Setting | Env Var | Default |
 |---------|---------|---------|
-| port | `PORT` | 7777 |
-| defaultGitReposDir | `VIBORA_GIT_REPOS_DIR` | ~ |
-| remoteHost | `VIBORA_REMOTE_HOST` | (empty) |
-| sshPort | `VIBORA_SSH_PORT` | 22 |
-| linearApiKey | `LINEAR_API_KEY` | null |
-| githubPat | `GITHUB_PAT` | null |
-| language | — | null (auto-detect) |
+| server.port | `PORT` | 7777 |
+| paths.defaultGitReposDir | `VIBORA_GIT_REPOS_DIR` | ~ |
+| editor.sshPort | `VIBORA_SSH_PORT` | 22 |
+| integrations.linearApiKey | `LINEAR_API_KEY` | null |
+| integrations.githubPat | `GITHUB_PAT` | null |
+| appearance.language | — | null (auto-detect) |
 
 Notification settings (sound, Slack, Discord, Pushover) are configured via the Settings UI or CLI.
 

package/bin/vibora.js

@@ -274,6 +274,30 @@ class ViboraClient {
       method: "POST"
     });
   }
+  async executeCommand(command, options) {
+    const body = {
+      command,
+      ...options
+    };
+    return this.fetch("/api/exec", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async listExecSessions() {
+    return this.fetch("/api/exec/sessions");
+  }
+  async updateExecSession(sessionId, updates) {
+    return this.fetch(`/api/exec/sessions/${sessionId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+  }
+  async destroyExecSession(sessionId) {
+    return this.fetch(`/api/exec/sessions/${sessionId}`, {
+      method: "DELETE"
+    });
+  }
 }
 var init_client = __esm(() => {
   init_server();
@@ -29776,6 +29800,49 @@ function registerTools(server, client) {
       return handleToolError(err);
     }
   });
+  server.tool("execute_command", "Execute a CLI command on the remote Vibora server. Supports persistent sessions for stateful workflows where environment variables, working directory, and shell state are preserved between commands.", {
+    command: exports_external.string().describe("The shell command to execute"),
+    sessionId: exports_external.optional(exports_external.string()).describe("Session ID for stateful workflows. Omit to create a new session. Reuse to maintain shell state."),
+    cwd: exports_external.optional(exports_external.string()).describe("Initial working directory (only used when creating a new session)"),
+    timeout: exports_external.optional(exports_external.number()).describe("Timeout in milliseconds (default: 30000). Use longer timeouts for slow commands."),
+    name: exports_external.optional(exports_external.string()).describe("Optional session name for identification (only used when creating a new session)")
+  }, async ({ command, sessionId, cwd, timeout, name }) => {
+    try {
+      const result = await client.executeCommand(command, { sessionId, cwd, timeout, name });
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+  server.tool("list_exec_sessions", "List all active command execution sessions on the Vibora server", {}, async () => {
+    try {
+      const sessions = await client.listExecSessions();
+      return formatSuccess(sessions);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+  server.tool("update_exec_session", "Update an existing command execution session (e.g., rename it)", {
+    sessionId: exports_external.string().describe("The session ID to update"),
+    name: exports_external.optional(exports_external.string()).describe("New name for the session")
+  }, async ({ sessionId, name }) => {
+    try {
+      const result = await client.updateExecSession(sessionId, { name });
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+  server.tool("destroy_exec_session", "Destroy an active command execution session to free resources", {
+    sessionId: exports_external.string().describe("The session ID to destroy")
+  }, async ({ sessionId }) => {
+    try {
+      const result = await client.destroyExecSession(sessionId);
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
 }
 var TaskStatusSchema2;
 var init_tools = __esm(() => {
@@ -30567,8 +30634,9 @@ async function main() {
 Usage: vibora <command> [options]
 
 Commands:
-  current-task              Get task for current worktree
+  current-task              Get task for current worktree (use inside a Vibora task worktree)
   current-task pr <url>     Associate a PR with current task
+  current-task linear <url> Link a Linear ticket to current task
   current-task in-progress  Mark current task as IN_PROGRESS
   current-task review       Mark current task as IN_REVIEW
   current-task done         Mark current task as DONE