@vibedeckx/linux-x64 0.1.10

package/dist/routes/settings-routes.js

@@ -0,0 +1,129 @@
+import fp from "fastify-plugin";
+import { getChatProviderConfig } from "../utils/chat-model.js";
+import "../server-types.js";
+const DEFAULT_PROXY_CONFIG = { type: "none", host: "", port: 0 };
+const routes = async (fastify) => {
+    // Get proxy settings
+    fastify.get("/api/settings/proxy", async (_req, reply) => {
+        const saved = fastify.storage.settings.get("proxy");
+        if (!saved) {
+            return reply.code(200).send(DEFAULT_PROXY_CONFIG);
+        }
+        try {
+            const config = JSON.parse(saved);
+            return reply.code(200).send(config);
+        }
+        catch {
+            return reply.code(200).send(DEFAULT_PROXY_CONFIG);
+        }
+    });
+    // Update proxy settings
+    fastify.put("/api/settings/proxy", async (req, reply) => {
+        const { type, host, port } = req.body;
+        if (!type || !["none", "http", "socks5"].includes(type)) {
+            return reply.code(400).send({ error: "type must be 'none', 'http', or 'socks5'" });
+        }
+        if (type !== "none") {
+            if (!host || typeof host !== "string" || host.trim() === "") {
+                return reply.code(400).send({ error: "host is required when proxy is enabled" });
+            }
+            if (!port || typeof port !== "number" || port < 1 || port > 65535) {
+                return reply.code(400).send({ error: "port must be a number between 1 and 65535" });
+            }
+        }
+        const config = {
+            type,
+            host: type === "none" ? "" : host.trim(),
+            port: type === "none" ? 0 : port,
+        };
+        fastify.storage.settings.set("proxy", JSON.stringify(config));
+        fastify.proxyManager.updateConfig(config);
+        console.log(`[Settings] Proxy updated: ${config.type}${config.type !== "none" ? ` ${config.host}:${config.port}` : ""}`);
+        return reply.code(200).send(config);
+    });
+    // Test proxy connection
+    fastify.post("/api/settings/proxy/test", async (req, reply) => {
+        const { type, host, port } = req.body;
+        if (!type || !["none", "http", "socks5"].includes(type)) {
+            return reply.code(400).send({ error: "type must be 'none', 'http', or 'socks5'" });
+        }
+        if (type === "none") {
+            return reply.code(200).send({ success: true, message: "Direct connection (no proxy)" });
+        }
+        if (!host || !port) {
+            return reply.code(400).send({ error: "host and port are required" });
+        }
+        try {
+            // Create a temporary proxy manager to test the connection
+            const { ProxyManager: PM } = await import("../utils/proxy-manager.js");
+            const testPm = new PM();
+            testPm.updateConfig({ type, host, port });
+            const dispatcher = testPm.getFetchDispatcher();
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 10_000);
+            try {
+                const fetchOptions = {
+                    signal: controller.signal,
+                };
+                if (dispatcher) {
+                    fetchOptions.dispatcher = dispatcher;
+                }
+                const response = await fetch("https://httpbin.org/get", fetchOptions);
+                clearTimeout(timer);
+                if (response.ok) {
+                    return reply.code(200).send({ success: true, message: `Proxy connection successful (status ${response.status})` });
+                }
+                else {
+                    return reply.code(200).send({ success: false, message: `Proxy returned status ${response.status}` });
+                }
+            }
+            catch (fetchError) {
+                clearTimeout(timer);
+                const msg = fetchError instanceof Error ? fetchError.message : "Connection failed";
+                return reply.code(200).send({ success: false, message: `Proxy connection failed: ${msg}` });
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            return reply.code(200).send({ success: false, message: `Failed to create proxy: ${msg}` });
+        }
+    });
+    // ---- Chat Provider Settings ----
+    function maskApiKey(key) {
+        if (!key || key.length <= 4)
+            return key ? "****" : "";
+        return "****" + key.slice(-4);
+    }
+    fastify.get("/api/settings/chat-provider", async (_req, reply) => {
+        const config = getChatProviderConfig(fastify.storage);
+        return reply.code(200).send({
+            provider: config.provider,
+            deepseekApiKey: maskApiKey(config.deepseekApiKey),
+            openrouterApiKey: maskApiKey(config.openrouterApiKey),
+            openrouterModel: config.openrouterModel,
+        });
+    });
+    fastify.put("/api/settings/chat-provider", async (req, reply) => {
+        const { provider, deepseekApiKey, openrouterApiKey, openrouterModel } = req.body;
+        if (provider && provider !== "deepseek" && provider !== "openrouter") {
+            return reply.code(400).send({ error: "provider must be 'deepseek' or 'openrouter'" });
+        }
+        // Merge with existing config so omitted fields are preserved
+        const existing = getChatProviderConfig(fastify.storage);
+        const updated = {
+            provider: provider ?? existing.provider,
+            deepseekApiKey: deepseekApiKey !== undefined ? deepseekApiKey : existing.deepseekApiKey,
+            openrouterApiKey: openrouterApiKey !== undefined ? openrouterApiKey : existing.openrouterApiKey,
+            openrouterModel: openrouterModel !== undefined ? openrouterModel : existing.openrouterModel,
+        };
+        fastify.storage.settings.set("chat_provider", JSON.stringify(updated));
+        console.log(`[Settings] Chat provider updated: ${updated.provider}`);
+        return reply.code(200).send({
+            provider: updated.provider,
+            deepseekApiKey: maskApiKey(updated.deepseekApiKey),
+            openrouterApiKey: maskApiKey(updated.openrouterApiKey),
+            openrouterModel: updated.openrouterModel,
+        });
+    });
+};
+export default fp(routes, { name: "settings-routes" });

package/dist/routes/task-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/task-routes.js

@@ -0,0 +1,107 @@
+import fp from "fastify-plugin";
+import { randomUUID } from "crypto";
+import { generateText } from "ai";
+import { resolveChatModel } from "../utils/chat-model.js";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // List tasks for a project (ordered by position)
+    fastify.get("/api/projects/:projectId/tasks", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.projectId, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const tasks = fastify.storage.tasks.getByProjectId(req.params.projectId);
+        return reply.code(200).send({ tasks });
+    });
+    // Create task
+    fastify.post("/api/projects/:projectId/tasks", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.projectId, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const { title: providedTitle, description, status, priority, assigned_branch } = req.body;
+        if (!description) {
+            return reply.code(400).send({ error: "description is required" });
+        }
+        let title = providedTitle;
+        if (!title) {
+            try {
+                const { text } = await generateText({
+                    model: resolveChatModel(fastify.storage),
+                    prompt: `Generate a concise task title (under 10 words) that captures the essence of this task description. Return only the title text, nothing else.\n\nDescription: ${description}`,
+                });
+                title = text.trim();
+            }
+            catch {
+                title = description.length > 50 ? description.slice(0, 50) + "..." : description;
+            }
+        }
+        const id = randomUUID();
+        const task = fastify.storage.tasks.create({
+            id,
+            project_id: req.params.projectId,
+            title,
+            description,
+            status: status,
+            priority: priority,
+            assigned_branch,
+        });
+        return reply.code(201).send({ task });
+    });
+    // Update task
+    fastify.put("/api/tasks/:id", async (req, reply) => {
+        const existing = fastify.storage.tasks.getById(req.params.id);
+        if (!existing) {
+            return reply.code(404).send({ error: "Task not found" });
+        }
+        const task = fastify.storage.tasks.update(req.params.id, {
+            title: req.body.title,
+            description: req.body.description,
+            status: req.body.status,
+            priority: req.body.priority,
+            assigned_branch: req.body.assigned_branch,
+            position: req.body.position,
+        });
+        return reply.code(200).send({ task });
+    });
+    // Delete task
+    fastify.delete("/api/tasks/:id", async (req, reply) => {
+        const existing = fastify.storage.tasks.getById(req.params.id);
+        if (!existing) {
+            return reply.code(404).send({ error: "Task not found" });
+        }
+        fastify.storage.tasks.delete(req.params.id);
+        return reply.code(200).send({ success: true });
+    });
+    // Reorder tasks
+    fastify.put("/api/projects/:projectId/tasks/reorder", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.projectId, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const { orderedIds } = req.body;
+        if (!Array.isArray(orderedIds)) {
+            return reply.code(400).send({ error: "orderedIds must be an array" });
+        }
+        const existingTasks = fastify.storage.tasks.getByProjectId(req.params.projectId);
+        const existingIds = new Set(existingTasks.map(t => t.id));
+        for (const id of orderedIds) {
+            if (!existingIds.has(id)) {
+                return reply.code(400).send({ error: `Task ${id} not found in project` });
+            }
+        }
+        fastify.storage.tasks.reorder(req.params.projectId, orderedIds);
+        return reply.code(200).send({ success: true });
+    });
+};
+export default fp(routes, { name: "task-routes" });

package/dist/routes/terminal-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/terminal-routes.js

@@ -0,0 +1,187 @@
+import fp from "fastify-plugin";
+import { resolveWorktreePath } from "../utils/worktree-paths.js";
+import { proxyToRemoteAuto } from "../utils/remote-proxy.js";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+function getRemoteConfig(fastify, project, remoteServerId) {
+    // Check project_remotes table first (new approach)
+    const remotes = fastify.storage.projectRemotes.getByProject(project.id);
+    if (remotes.length > 0) {
+        const target = remoteServerId
+            ? remotes.find((r) => r.remote_server_id === remoteServerId)
+            : remotes[0]; // sorted by sort_order
+        if (target) {
+            return {
+                serverId: target.remote_server_id,
+                url: target.server_url ?? "",
+                apiKey: target.server_api_key ?? "",
+                remotePath: target.remote_path,
+            };
+        }
+    }
+    // Fallback to legacy project fields
+    if (project.remote_url && project.remote_api_key && project.remote_path) {
+        return {
+            serverId: "",
+            url: project.remote_url,
+            apiKey: project.remote_api_key,
+            remotePath: project.remote_path,
+        };
+    }
+    return null;
+}
+const routes = async (fastify) => {
+    // Remote-side endpoint: spawn a terminal at a given path
+    fastify.post("/api/path/terminals", async (req, reply) => {
+        const { path: projectPath, branch } = req.body;
+        if (!projectPath) {
+            return reply.code(400).send({ error: "Path is required" });
+        }
+        const resolvedPath = resolveWorktreePath(projectPath, branch ?? null);
+        try {
+            const terminal = fastify.processManager.startTerminal("remote", resolvedPath);
+            return reply.code(201).send({ terminal: { id: terminal.id, name: terminal.name, cwd: resolvedPath } });
+        }
+        catch (error) {
+            return reply.code(500).send({ error: String(error) });
+        }
+    });
+    // Remote-side endpoint: send a command to a terminal (fire-and-forget)
+    fastify.post("/api/path/terminals/:terminalId/send", async (req, reply) => {
+        const { terminalId } = req.params;
+        const { command } = req.body;
+        if (!command) {
+            return reply.code(400).send({ error: "Command is required" });
+        }
+        try {
+            fastify.processManager.sendToTerminal(terminalId, command);
+            return reply.send({ sent: true });
+        }
+        catch (error) {
+            return reply.code(404).send({ error: String(error) });
+        }
+    });
+    // List terminals for a project (local + remote)
+    fastify.get("/api/projects/:projectId/terminals", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.projectId, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const branch = req.query.branch !== undefined ? (req.query.branch || null) : undefined;
+        // Local terminals (filtered by branch)
+        const localTerminals = fastify.processManager
+            .getTerminals(req.params.projectId, branch)
+            .map((t) => ({ ...t, location: "local" }));
+        // Remote terminals from remoteExecutorMap (filtered by project and branch)
+        const remoteTerminals = [];
+        for (const [key, info] of fastify.remoteExecutorMap.entries()) {
+            if (!key.startsWith("remote-terminal-"))
+                continue;
+            if (info.projectId && info.projectId !== req.params.projectId)
+                continue;
+            if (branch !== undefined && (info.branch ?? null) !== branch)
+                continue;
+            remoteTerminals.push({
+                id: key,
+                name: key,
+                projectId: req.params.projectId,
+                branch: info.branch,
+                location: "remote",
+            });
+        }
+        const terminals = [...localTerminals, ...remoteTerminals];
+        return reply.code(200).send({ terminals });
+    });
+    // Create a new terminal (local or remote)
+    fastify.post("/api/projects/:projectId/terminals", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const project = fastify.storage.projects.getById(req.params.projectId, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const branch = req.body?.branch;
+        const explicitLocation = req.body?.location;
+        const executorMode = project.executor_mode;
+        const remoteConfig = getRemoteConfig(fastify, project, req.body?.remote_server_id);
+        const useRemote = explicitLocation === "remote" ||
+            (explicitLocation === undefined &&
+                remoteConfig &&
+                (!project.path || executorMode !== "local"));
+        if (useRemote) {
+            if (!remoteConfig) {
+                return reply
+                    .code(400)
+                    .send({ error: "Project has no remote configuration" });
+            }
+            const result = await proxyToRemoteAuto(remoteConfig.serverId, remoteConfig.url, remoteConfig.apiKey, "POST", "/api/path/terminals", {
+                path: remoteConfig.remotePath,
+                branch: branch ?? undefined,
+            }, { reverseConnectManager: fastify.reverseConnectManager });
+            if (result.ok) {
+                const remoteData = result.data;
+                const remoteId = remoteData.terminal.id;
+                const localId = `remote-terminal-${remoteId}`;
+                fastify.remoteExecutorMap.set(localId, {
+                    remoteServerId: remoteConfig.serverId,
+                    remoteUrl: remoteConfig.url,
+                    remoteApiKey: remoteConfig.apiKey,
+                    remoteProcessId: remoteId,
+                    executorId: "",
+                    projectId: req.params.projectId,
+                    branch: branch ?? null,
+                });
+                return reply.code(201).send({
+                    terminal: {
+                        id: localId,
+                        name: remoteData.terminal.name,
+                        cwd: remoteData.terminal.cwd,
+                        location: "remote",
+                    },
+                });
+            }
+            return reply.code(result.status || 502).send(result.data);
+        }
+        // Local terminal
+        if (!project.path) {
+            return reply.code(400).send({ error: "Project has no local path" });
+        }
+        const basePath = resolveWorktreePath(project.path, branch ?? null);
+        const cwd = req.body?.cwd || basePath;
+        try {
+            const terminal = fastify.processManager.startTerminal(req.params.projectId, cwd, branch ?? null);
+            return reply.code(201).send({ terminal: { ...terminal, cwd, branch: branch ?? null, location: "local" } });
+        }
+        catch (error) {
+            return reply.code(500).send({ error: String(error) });
+        }
+    });
+    // Close a terminal (local or remote)
+    fastify.delete("/api/terminals/:terminalId", async (req, reply) => {
+        const { terminalId } = req.params;
+        // Remote terminal
+        if (terminalId.startsWith("remote-terminal-")) {
+            const remoteInfo = fastify.remoteExecutorMap.get(terminalId);
+            if (!remoteInfo) {
+                return reply.code(404).send({ error: "Remote terminal not found" });
+            }
+            const result = await proxyToRemoteAuto(remoteInfo.remoteServerId, remoteInfo.remoteUrl, remoteInfo.remoteApiKey, "POST", `/api/executor-processes/${remoteInfo.remoteProcessId}/stop`, undefined, { reverseConnectManager: fastify.reverseConnectManager });
+            fastify.remoteExecutorMap.delete(terminalId);
+            if (!result.ok) {
+                return reply.code(result.status || 502).send(result.data);
+            }
+            return reply.code(200).send({ success: true });
+        }
+        // Local terminal
+        const stopped = fastify.processManager.stop(terminalId);
+        if (!stopped) {
+            return reply.code(404).send({ error: "Terminal not found or already closed" });
+        }
+        return reply.code(200).send({ success: true });
+    });
+};
+export default fp(routes, { name: "terminal-routes" });

package/dist/routes/translate-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/translate-routes.js

@@ -0,0 +1,38 @@
+import fp from "fastify-plugin";
+import { generateText } from "ai";
+import { resolveChatModel } from "../utils/chat-model.js";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    fastify.post("/api/translate", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const { text } = req.body;
+        if (!text || !text.trim()) {
+            return reply.code(400).send({ error: "text is required" });
+        }
+        try {
+            const { text: translatedText } = await generateText({
+                model: resolveChatModel(fastify.storage),
+                prompt: `You are a precise translation assistant for software development.
+Translate the following text into English. This text is an instruction for an AI coding agent.
+
+Rules:
+1. Preserve ALL technical terms exactly (function names, variable names, file paths, CLI commands, package names, code snippets)
+2. Preserve all markdown formatting, code blocks, and special characters
+3. If the text is already in English, return it EXACTLY as-is
+4. Return ONLY the translated text, nothing else
+
+Text:
+${text}`,
+            });
+            return reply.code(200).send({ translatedText: translatedText.trim() });
+        }
+        catch (error) {
+            console.error("[translate] Translation failed:", error);
+            return reply.code(500).send({ error: "Translation failed" });
+        }
+    });
+};
+export default fp(routes, { name: "translate-routes" });

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

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