@vibedeckx/linux-x64 0.1.10

package/dist/routes/project-routes.js

@@ -0,0 +1,286 @@
+import fp from "fastify-plugin";
+import path from "path";
+import { randomUUID } from "crypto";
+import { exec } from "child_process";
+import { readdir } from "fs/promises";
+import { selectFolder } from "../dialog.js";
+import { proxyToRemote } from "../utils/remote-proxy.js";
+import { resolveWorktreePath } from "../utils/worktree-paths.js";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+function sanitizeProject(project) {
+    const { remote_api_key, ...safe } = project;
+    return { ...safe, has_remote_api_key: !!remote_api_key };
+}
+const routes = async (fastify) => {
+    // 获取所有项目
+    fastify.get("/api/projects", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const projects = fastify.storage.projects.getAll(userId).map(sanitizeProject);
+        return reply.code(200).send({ projects });
+    });
+    // 获取单个项目
+    fastify.get("/api/projects/:id", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.id, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        return reply.code(200).send({ project: sanitizeProject(project) });
+    });
+    // 打开目录选择对话框
+    fastify.post("/api/dialog/select-folder", async (req, reply) => {
+        const folderPath = await selectFolder();
+        if (!folderPath) {
+            return reply.code(200).send({ path: null, cancelled: true });
+        }
+        return reply.code(200).send({ path: folderPath, cancelled: false });
+    });
+    // Browse directory - for remote access to list directories
+    fastify.get("/api/browse", async (req, reply) => {
+        const browsePath = req.query.path || "/";
+        try {
+            const entries = await readdir(browsePath, { withFileTypes: true });
+            const items = entries
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => ({
+                name: entry.name,
+                path: path.join(browsePath, entry.name),
+                type: "directory",
+            }))
+                .sort((a, b) => a.name.localeCompare(b.name));
+            return reply.code(200).send({ path: browsePath, items });
+        }
+        catch {
+            return reply.code(400).send({ error: "Failed to read directory" });
+        }
+    });
+    // 创建项目 (unified: local, remote, or both)
+    fastify.post("/api/projects", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const { name, path: projectPath, remotePath, remoteUrl, remoteApiKey, agentMode, executorMode } = req.body;
+        if (!name) {
+            return reply.code(400).send({ error: "Project name is required" });
+        }
+        if (remotePath && (!remoteUrl || !remoteApiKey)) {
+            return reply.code(400).send({ error: "Remote URL and API key are required when remote path is provided" });
+        }
+        if (projectPath) {
+            const existing = fastify.storage.projects.getByPath(projectPath);
+            if (existing) {
+                return reply.code(409).send({ error: "Project with this path already exists" });
+            }
+        }
+        const id = randomUUID();
+        const project = fastify.storage.projects.create({
+            id,
+            name,
+            path: projectPath || null,
+            remote_path: remotePath,
+            remote_url: remoteUrl,
+            remote_api_key: remoteApiKey,
+            agent_mode: agentMode,
+            executor_mode: executorMode,
+        }, userId);
+        return reply.code(201).send({ project: sanitizeProject(project) });
+    });
+    // 更新项目
+    fastify.put("/api/projects/:id", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.id, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const { name, path: newPath, remotePath, remoteUrl, remoteApiKey, agentMode, executorMode, syncUpConfig, syncDownConfig } = req.body;
+        const effectivePath = newPath !== undefined ? newPath : project.path;
+        const effectiveRemotePath = remotePath !== undefined ? remotePath : (project.remote_path ?? null);
+        const effectiveRemoteUrl = remoteUrl !== undefined ? remoteUrl : (project.remote_url ?? null);
+        const effectiveRemoteApiKey = remoteApiKey !== undefined ? remoteApiKey : (project.remote_api_key ?? null);
+        if (!effectivePath && !effectiveRemotePath) {
+            // Also check project_remotes table — multi-remote projects use it instead of legacy remote_path
+            const remotes = fastify.storage.projectRemotes.getByProject(req.params.id);
+            if (remotes.length === 0) {
+                return reply.code(400).send({ error: "Project must have at least one of local path or remote path" });
+            }
+        }
+        if (effectiveRemotePath && (!effectiveRemoteUrl || !effectiveRemoteApiKey)) {
+            return reply.code(400).send({ error: "Remote URL and API key are required when remote path is provided" });
+        }
+        if (newPath && newPath !== project.path) {
+            const existing = fastify.storage.projects.getByPath(newPath);
+            if (existing && existing.id !== req.params.id) {
+                return reply.code(409).send({ error: "Another project already uses this path" });
+            }
+        }
+        const updateOpts = {};
+        if (name !== undefined)
+            updateOpts.name = name;
+        if (newPath !== undefined)
+            updateOpts.path = newPath;
+        if (remotePath !== undefined)
+            updateOpts.remote_path = remotePath;
+        if (remoteUrl !== undefined)
+            updateOpts.remote_url = remoteUrl;
+        if (remoteApiKey !== undefined)
+            updateOpts.remote_api_key = remoteApiKey;
+        if (agentMode !== undefined)
+            updateOpts.agent_mode = agentMode;
+        if (executorMode !== undefined)
+            updateOpts.executor_mode = executorMode;
+        if (syncUpConfig !== undefined)
+            updateOpts.sync_up_config = syncUpConfig;
+        if (syncDownConfig !== undefined)
+            updateOpts.sync_down_config = syncDownConfig;
+        const updated = fastify.storage.projects.update(req.params.id, updateOpts, userId);
+        if (!updated) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        return reply.code(200).send({ project: sanitizeProject(updated) });
+    });
+    // 删除项目
+    fastify.delete("/api/projects/:id", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.id, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        fastify.storage.projects.delete(req.params.id, userId);
+        return reply.code(200).send({ success: true });
+    });
+    // Execute sync command for a project
+    fastify.post("/api/projects/:id/execute-sync", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.id, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const { syncType, branch, remoteServerId } = req.body;
+        let syncConfig;
+        let remoteUrl;
+        let remoteApiKey;
+        let remotePath;
+        if (remoteServerId) {
+            const pr = fastify.storage.projectRemotes.getByProjectAndServer(project.id, remoteServerId);
+            if (!pr) {
+                return reply.code(404).send({ error: "Remote not linked to project" });
+            }
+            syncConfig = syncType === 'up' ? pr.sync_up_config : pr.sync_down_config;
+            remoteUrl = pr.server_url ?? undefined;
+            remoteApiKey = pr.server_api_key;
+            remotePath = pr.remote_path;
+        }
+        else {
+            // Fallback to legacy project fields
+            syncConfig = syncType === 'up' ? project.sync_up_config : project.sync_down_config;
+            remoteUrl = project.remote_url;
+            remoteApiKey = project.remote_api_key;
+            remotePath = project.remote_path;
+        }
+        if (!syncConfig || syncConfig.actionType !== 'command') {
+            return reply.code(400).send({ error: "Sync command not configured or not a command type" });
+        }
+        const executionMode = syncConfig.executionMode;
+        if (executionMode === 'remote') {
+            if (!remoteUrl || !remoteApiKey) {
+                return reply.code(400).send({ error: "Remote not configured for this project" });
+            }
+            const remoteCwd = resolveWorktreePath(remotePath ?? '', branch ?? null);
+            const result = await proxyToRemote(remoteUrl, remoteApiKey, 'POST', '/api/execute-one-shot', {
+                command: syncConfig.content,
+                cwd: remoteCwd,
+            });
+            if (!result.ok) {
+                return reply.code(result.status || 500).send(result.data);
+            }
+            return reply.code(200).send(result.data);
+        }
+        // Local execution
+        const basePath = project.path;
+        if (!basePath) {
+            return reply.code(400).send({ error: "Project has no local path" });
+        }
+        const cwd = resolveWorktreePath(basePath, branch ?? null);
+        try {
+            const result = await new Promise((resolve) => {
+                exec(syncConfig.content, { cwd, timeout: 30000, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+                    resolve({
+                        stdout: stdout || '',
+                        stderr: stderr || '',
+                        exitCode: error ? (error.code ?? 1) : 0,
+                    });
+                });
+            });
+            return reply.code(200).send({ success: result.exitCode === 0, ...result });
+        }
+        catch {
+            return reply.code(500).send({ error: "Command execution failed" });
+        }
+    });
+    // Execute one-shot command (for remote instances)
+    fastify.post("/api/execute-one-shot", async (req, reply) => {
+        const { command, cwd } = req.body;
+        if (!command || !cwd) {
+            return reply.code(400).send({ error: "command and cwd are required" });
+        }
+        try {
+            const result = await new Promise((resolve) => {
+                exec(command, { cwd, timeout: 30000, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+                    resolve({
+                        stdout: stdout || '',
+                        stderr: stderr || '',
+                        exitCode: error ? (error.code ?? 1) : 0,
+                    });
+                });
+            });
+            return reply.code(200).send({ success: result.exitCode === 0, ...result });
+        }
+        catch {
+            return reply.code(500).send({ error: "Command execution failed" });
+        }
+    });
+    // 获取项目目录文件列表
+    fastify.get("/api/projects/:id/files", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.id, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        if (!project.path) {
+            return reply.code(400).send({ error: "Project has no local path" });
+        }
+        try {
+            const entries = await readdir(project.path, { withFileTypes: true });
+            const files = entries
+                .filter((entry) => !entry.name.startsWith("."))
+                .map((entry) => ({
+                name: entry.name,
+                type: entry.isDirectory() ? "directory" : "file",
+            }))
+                .sort((a, b) => {
+                if (a.type !== b.type) {
+                    return a.type === "directory" ? -1 : 1;
+                }
+                return a.name.localeCompare(b.name);
+            });
+            return reply.code(200).send({ files });
+        }
+        catch {
+            return reply.code(500).send({ error: "Failed to read directory" });
+        }
+    });
+};
+export default fp(routes, { name: "project-routes" });

package/dist/routes/remote-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from "fastify";
+import "../server-types.js";
+declare const _default: FastifyPluginAsync;
+export default _default;

package/dist/routes/remote-routes.js

@@ -0,0 +1,59 @@
+import fp from "fastify-plugin";
+import { randomUUID } from "crypto";
+import { proxyToRemote } from "../utils/remote-proxy.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // Test connection to remote vibedeckx server
+    fastify.post("/api/remote/test-connection", async (req, reply) => {
+        const { url, apiKey } = req.body;
+        if (!url || !apiKey) {
+            return reply.code(400).send({ error: "URL and API key are required" });
+        }
+        const result = await proxyToRemote(url, apiKey, "GET", "/api/projects");
+        if (result.ok) {
+            return reply.code(200).send({ success: true, message: "Connection successful" });
+        }
+        else if (result.status === 401) {
+            return reply.code(401).send({ error: "Invalid API key" });
+        }
+        else if (result.status === 0) {
+            return reply.code(502).send({ error: "Cannot connect to remote server" });
+        }
+        else {
+            return reply.code(result.status).send(result.data);
+        }
+    });
+    // Browse remote directory
+    fastify.post("/api/remote/browse", async (req, reply) => {
+        const { url, apiKey, path: browsePath } = req.body;
+        if (!url || !apiKey) {
+            return reply.code(400).send({ error: "URL and API key are required" });
+        }
+        const queryPath = browsePath || "/";
+        const result = await proxyToRemote(url, apiKey, "GET", `/api/browse?path=${encodeURIComponent(queryPath)}`);
+        if (result.ok) {
+            return reply.code(200).send(result.data);
+        }
+        else {
+            return reply.code(result.status || 502).send(result.data);
+        }
+    });
+    // Create remote project (stores connection config locally only)
+    fastify.post("/api/projects/remote", async (req, reply) => {
+        const { name, path: projectPath, remoteUrl, remoteApiKey } = req.body;
+        if (!name || !projectPath || !remoteUrl || !remoteApiKey) {
+            return reply.code(400).send({ error: "All fields are required" });
+        }
+        const id = randomUUID();
+        const project = fastify.storage.projects.create({
+            id,
+            name,
+            remote_path: projectPath,
+            remote_url: remoteUrl,
+            remote_api_key: remoteApiKey,
+        });
+        const { remote_api_key: _, ...safeProject } = project;
+        return reply.code(201).send({ project: safeProject });
+    });
+};
+export default fp(routes, { name: "remote-routes" });

package/dist/routes/remote-server-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from "fastify";
+import "../server-types.js";
+declare const _default: FastifyPluginAsync;
+export default _default;

package/dist/routes/remote-server-routes.js

@@ -0,0 +1,157 @@
+import fp from "fastify-plugin";
+import { proxyToRemote, proxyToRemoteAuto } from "../utils/remote-proxy.js";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+function sanitizeServer(server) {
+    const { api_key: _, connect_token: _t, ...safe } = server;
+    return safe;
+}
+const routes = async (fastify) => {
+    // GET /api/remote-servers — list all (api_key sanitized)
+    fastify.get("/api/remote-servers", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const servers = fastify.storage.remoteServers.getAll(userId);
+        return reply.send(servers.map(sanitizeServer));
+    });
+    // POST /api/remote-servers — create
+    fastify.post("/api/remote-servers", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { name, url, apiKey, connectionMode } = request.body;
+        if (!name)
+            return reply.code(400).send({ error: "name is required" });
+        if (connectionMode !== "inbound" && !url)
+            return reply.code(400).send({ error: "url is required for outbound servers" });
+        try {
+            const server = fastify.storage.remoteServers.create({
+                name,
+                url: url || null,
+                api_key: apiKey,
+                connection_mode: connectionMode,
+            }, userId);
+            return reply.code(201).send(sanitizeServer(server));
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint failed")) {
+                return reply.code(409).send({ error: "A server with this URL already exists" });
+            }
+            throw err;
+        }
+    });
+    // PUT /api/remote-servers/:id — update
+    fastify.put("/api/remote-servers/:id", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const { name, url, apiKey } = request.body;
+        const server = fastify.storage.remoteServers.update(id, {
+            name,
+            url,
+            api_key: apiKey,
+        }, userId);
+        if (!server)
+            return reply.code(404).send({ error: "Server not found" });
+        return reply.send(sanitizeServer(server));
+    });
+    // DELETE /api/remote-servers/:id — delete
+    fastify.delete("/api/remote-servers/:id", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const deleted = fastify.storage.remoteServers.delete(id, userId);
+        if (!deleted)
+            return reply.code(404).send({ error: "Server not found" });
+        return reply.send({ success: true });
+    });
+    // POST /api/remote-servers/:id/test — test connection
+    fastify.post("/api/remote-servers/:id/test", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const server = fastify.storage.remoteServers.getById(id, userId);
+        if (!server)
+            return reply.code(404).send({ error: "Server not found" });
+        // For inbound servers, check if reverse-connected
+        if (server.connection_mode === "inbound") {
+            const connected = fastify.reverseConnectManager.isConnected(id);
+            return reply.send({ success: connected, status: connected ? "online" : "offline" });
+        }
+        try {
+            const result = await proxyToRemote(server.url, server.api_key ?? "", "GET", "/api/projects");
+            if (result.ok)
+                return reply.send({ success: true });
+            return reply
+                .code(502)
+                .send({ error: "Connection failed", details: result.data });
+        }
+        catch (err) {
+            return reply.code(502).send({ error: "Connection failed" });
+        }
+    });
+    // POST /api/remote-servers/:id/generate-token — generate a connect token for inbound servers
+    fastify.post("/api/remote-servers/:id/generate-token", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const server = fastify.storage.remoteServers.getById(id, userId);
+        if (!server)
+            return reply.code(404).send({ error: "Server not found" });
+        if (server.connection_mode !== "inbound")
+            return reply.code(400).send({ error: "Token generation is only available for inbound servers" });
+        const token = fastify.storage.remoteServers.generateToken(id, userId);
+        if (!token)
+            return reply.code(500).send({ error: "Failed to generate token" });
+        // Derive server URL from the incoming request
+        const proto = request.headers["x-forwarded-proto"] || request.protocol || "http";
+        const host = request.headers["x-forwarded-host"] || request.headers.host || "localhost";
+        const serverUrl = `${proto}://${host}`;
+        const connectCommand = `vibedeckx connect --connect-to ${serverUrl} --token ${token}`;
+        return reply.send({ token, connectCommand });
+    });
+    // POST /api/remote-servers/:id/browse — browse directories on remote server
+    fastify.post("/api/remote-servers/:id/browse", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const { path: browsePath } = request.body ?? {};
+        const server = fastify.storage.remoteServers.getById(id, userId);
+        if (!server)
+            return reply.code(404).send({ error: "Server not found" });
+        try {
+            const queryPath = browsePath ? `?path=${encodeURIComponent(browsePath)}` : "";
+            const result = await proxyToRemoteAuto(id, server.url ?? "", server.api_key ?? "", "GET", `/api/browse${queryPath}`, undefined, { reverseConnectManager: fastify.reverseConnectManager });
+            if (result.ok) {
+                return reply.send(result.data);
+            }
+            return reply.code(502).send({ error: "Failed to browse remote directory", details: result.data });
+        }
+        catch (err) {
+            return reply.code(502).send({ error: "Failed to browse remote directory" });
+        }
+    });
+    // POST /api/remote-servers/:id/revoke-token — revoke connect token and disconnect
+    fastify.post("/api/remote-servers/:id/revoke-token", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const server = fastify.storage.remoteServers.getById(id, userId);
+        if (!server)
+            return reply.code(404).send({ error: "Server not found" });
+        if (fastify.reverseConnectManager.isConnected(id)) {
+            fastify.reverseConnectManager.unregisterConnection(id);
+            fastify.storage.remoteServers.updateStatus(id, "offline");
+        }
+        const revoked = fastify.storage.remoteServers.revokeToken(id, userId);
+        return reply.send({ success: revoked });
+    });
+};
+export default fp(routes, { name: "remote-server-routes" });

package/dist/routes/reverse-connect-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from "fastify";
+import "../server-types.js";
+declare const _default: FastifyPluginAsync;
+export default _default;

package/dist/routes/reverse-connect-routes.js

@@ -0,0 +1,33 @@
+import fp from "fastify-plugin";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // Must be registered after websocket plugin
+    fastify.after(() => {
+        // GET /api/reverse-connect?token=<token> — WebSocket upgrade for inbound remote nodes
+        fastify.get("/api/reverse-connect", { websocket: true }, (socket, req) => {
+            const token = req.query.token;
+            if (!token) {
+                socket.send(JSON.stringify({ error: "Token required" }));
+                socket.close(4001, "Token required");
+                return;
+            }
+            const server = fastify.storage.remoteServers.getByToken(token);
+            if (!server) {
+                socket.send(JSON.stringify({ error: "Invalid token" }));
+                socket.close(4001, "Invalid token");
+                return;
+            }
+            if (server.connection_mode !== "inbound") {
+                socket.send(JSON.stringify({ error: "Server is not configured for inbound connections" }));
+                socket.close(4001, "Not inbound");
+                return;
+            }
+            console.log(`[ReverseConnect] Inbound connection from remote server: ${server.name} (${server.id})`);
+            // Register the connection with the manager
+            fastify.reverseConnectManager.registerConnection(server.id, socket);
+            // Update DB status
+            fastify.storage.remoteServers.updateStatus(server.id, "online");
+        });
+    });
+};
+export default fp(routes, { name: "reverse-connect-routes" });

package/dist/routes/settings-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from "fastify";
+import "../server-types.js";
+declare const _default: FastifyPluginAsync;
+export default _default;