@vibedeckx/linux-x64 0.1.10

package/dist/routes/diff-routes.js

@@ -0,0 +1,208 @@
+import fp from "fastify-plugin";
+import { parseDiffOutput } from "../utils/diff-parser.js";
+import { proxyToRemoteAuto } from "../utils/remote-proxy.js";
+import { resolveWorktreePath } from "../utils/worktree-paths.js";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+function getRemoteConfig(fastify, project) {
+    // Check project_remotes table first (new approach)
+    const remotes = fastify.storage.projectRemotes.getByProject(project.id);
+    if (remotes.length > 0) {
+        const primary = remotes[0]; // sorted by sort_order
+        return {
+            serverId: primary.remote_server_id,
+            url: primary.server_url ?? "",
+            apiKey: primary.server_api_key ?? "",
+            remotePath: primary.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;
+}
+function parseGitLogOutput(output) {
+    const lines = output.trim().split("\n");
+    const commits = [];
+    // 5 lines per commit: hash, shortHash, message, author, date
+    for (let i = 0; i + 4 < lines.length; i += 5) {
+        commits.push({
+            hash: lines[i],
+            shortHash: lines[i + 1],
+            message: lines[i + 2],
+            author: lines[i + 3],
+            date: lines[i + 4],
+        });
+    }
+    return commits;
+}
+function buildDiffCommand(since) {
+    const ref = since || "HEAD";
+    return `git diff ${ref} --no-color`;
+}
+const routes = async (fastify) => {
+    // Get diff for a path (path-based, for remote execution)
+    fastify.get("/api/path/diff", async (req, reply) => {
+        const projectPath = req.query.path;
+        if (!projectPath) {
+            return reply.code(400).send({ error: "Path is required" });
+        }
+        const branch = req.query.branch;
+        const since = req.query.since;
+        if (since && !/^[0-9a-f]+$/i.test(since)) {
+            return reply.code(400).send({ error: "Invalid commit hash" });
+        }
+        const cwd = resolveWorktreePath(projectPath, branch ?? null);
+        try {
+            const { execSync } = await import("child_process");
+            const diffOutput = execSync(buildDiffCommand(since), {
+                cwd,
+                encoding: "utf-8",
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            const files = parseDiffOutput(diffOutput);
+            return reply.code(200).send({ files });
+        }
+        catch {
+            try {
+                const { execSync } = await import("child_process");
+                const diffOutput = execSync("git diff --no-color", {
+                    cwd,
+                    encoding: "utf-8",
+                    maxBuffer: 10 * 1024 * 1024,
+                });
+                const files = parseDiffOutput(diffOutput);
+                return reply.code(200).send({ files });
+            }
+            catch {
+                return reply.code(200).send({ files: [] });
+            }
+        }
+    });
+    // Get commits for a path (path-based, for remote execution)
+    fastify.get("/api/path/commits", async (req, reply) => {
+        const projectPath = req.query.path;
+        if (!projectPath) {
+            return reply.code(400).send({ error: "Path is required" });
+        }
+        const branch = req.query.branch;
+        const limit = parseInt(req.query.limit || "20", 10);
+        const cwd = resolveWorktreePath(projectPath, branch ?? null);
+        try {
+            const { execSync } = await import("child_process");
+            const output = execSync(`git log --format=%H%n%h%n%s%n%an%n%aI -n ${limit}`, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+            const commits = parseGitLogOutput(output);
+            return reply.code(200).send({ commits });
+        }
+        catch {
+            return reply.code(200).send({ commits: [] });
+        }
+    });
+    // Get git diff for uncommitted changes (project-based)
+    fastify.get("/api/projects/:id/diff", 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 branch = req.query.branch;
+        const since = req.query.since;
+        const target = req.query.target;
+        if (since && !/^[0-9a-f]+$/i.test(since)) {
+            return reply.code(400).send({ error: "Invalid commit hash" });
+        }
+        const useRemote = target === 'remote'
+            || (!target && !project.path);
+        if (useRemote) {
+            const remoteConfig = getRemoteConfig(fastify, project);
+            if (!remoteConfig) {
+                return reply.code(400).send({ error: "Project has no remote configuration" });
+            }
+            const params = [`path=${encodeURIComponent(remoteConfig.remotePath)}`];
+            if (branch)
+                params.push(`branch=${encodeURIComponent(branch)}`);
+            if (since)
+                params.push(`since=${encodeURIComponent(since)}`);
+            const result = await proxyToRemoteAuto(remoteConfig.serverId, remoteConfig.url, remoteConfig.apiKey, "GET", `/api/path/diff?${params.join("&")}`, undefined, { reverseConnectManager: fastify.reverseConnectManager });
+            return reply.code(result.status || 200).send(result.data);
+        }
+        if (!project.path) {
+            return reply.code(400).send({ error: "Project has no local path" });
+        }
+        const cwd = resolveWorktreePath(project.path, branch ?? null);
+        try {
+            const { execSync } = await import("child_process");
+            const diffOutput = execSync(buildDiffCommand(since), {
+                cwd,
+                encoding: "utf-8",
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            const files = parseDiffOutput(diffOutput);
+            return reply.code(200).send({ files });
+        }
+        catch {
+            try {
+                const { execSync } = await import("child_process");
+                const diffOutput = execSync("git diff --no-color", {
+                    cwd,
+                    encoding: "utf-8",
+                    maxBuffer: 10 * 1024 * 1024,
+                });
+                const files = parseDiffOutput(diffOutput);
+                return reply.code(200).send({ files });
+            }
+            catch {
+                return reply.code(200).send({ files: [] });
+            }
+        }
+    });
+    // Get commits for a project (project-based)
+    fastify.get("/api/projects/:id/commits", 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 branch = req.query.branch;
+        const limit = parseInt(req.query.limit || "20", 10);
+        const target = req.query.target;
+        const useRemote = target === 'remote'
+            || (!target && !project.path);
+        if (useRemote) {
+            const remoteConfig = getRemoteConfig(fastify, project);
+            if (!remoteConfig) {
+                return reply.code(400).send({ error: "Project has no remote configuration" });
+            }
+            const params = [`path=${encodeURIComponent(remoteConfig.remotePath)}`];
+            if (branch)
+                params.push(`branch=${encodeURIComponent(branch)}`);
+            params.push(`limit=${limit}`);
+            const result = await proxyToRemoteAuto(remoteConfig.serverId, remoteConfig.url, remoteConfig.apiKey, "GET", `/api/path/commits?${params.join("&")}`, undefined, { reverseConnectManager: fastify.reverseConnectManager });
+            return reply.code(result.status || 200).send(result.data);
+        }
+        if (!project.path) {
+            return reply.code(400).send({ error: "Project has no local path" });
+        }
+        const cwd = resolveWorktreePath(project.path, branch ?? null);
+        try {
+            const { execSync } = await import("child_process");
+            const output = execSync(`git log --format=%H%n%h%n%s%n%an%n%aI -n ${limit}`, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+            const commits = parseGitLogOutput(output);
+            return reply.code(200).send({ commits });
+        }
+        catch {
+            return reply.code(200).send({ commits: [] });
+        }
+    });
+};
+export default fp(routes, { name: "diff-routes" });

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

@@ -0,0 +1,52 @@
+import fp from "fastify-plugin";
+import "../server-types.js";
+const routes = async (fastify) => {
+    fastify.get("/api/events", async (req, reply) => {
+        // SSE doesn't support Authorization headers, so verify token from query param
+        if (fastify.authEnabled) {
+            const apiKey = req.headers["x-vibedeckx-api-key"];
+            if (!apiKey) {
+                const token = req.query.token;
+                if (!token) {
+                    return reply.code(401).send({ error: "Unauthorized" });
+                }
+                try {
+                    const { verifyToken } = await import("@clerk/backend");
+                    const payload = await verifyToken(token, {
+                        secretKey: process.env.CLERK_SECRET_KEY,
+                    });
+                    if (!payload.sub) {
+                        return reply.code(401).send({ error: "Unauthorized" });
+                    }
+                }
+                catch {
+                    return reply.code(401).send({ error: "Unauthorized" });
+                }
+            }
+        }
+        reply.raw.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+        });
+        // Send initial keepalive
+        reply.raw.write(":ok\n\n");
+        // Subscribe to all events
+        const unsubscribe = fastify.eventBus.subscribe((event) => {
+            reply.raw.write(`data: ${JSON.stringify(event)}\n\n`);
+        });
+        // Keepalive every 15 seconds
+        const keepalive = setInterval(() => {
+            reply.raw.write(":keepalive\n\n");
+        }, 15000);
+        // Cleanup on client disconnect
+        req.raw.on("close", () => {
+            unsubscribe();
+            clearInterval(keepalive);
+        });
+        // Prevent Fastify from sending a response (we're handling it raw)
+        await reply;
+    });
+};
+export default fp(routes, { name: "event-routes" });

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

@@ -0,0 +1,76 @@
+import fp from "fastify-plugin";
+import { randomUUID } from "crypto";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // List all executor groups for a project
+    fastify.get("/api/projects/:projectId/executor-groups", 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 groups = fastify.storage.executorGroups.getByProjectId(req.params.projectId);
+        return reply.code(200).send({ groups });
+    });
+    // Get executor group by branch
+    fastify.get("/api/projects/:projectId/executor-groups/by-branch", 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 ?? "";
+        const group = fastify.storage.executorGroups.getByBranch(req.params.projectId, branch);
+        if (!group) {
+            return reply.code(404).send({ error: "Executor group not found for this branch" });
+        }
+        return reply.code(200).send({ group });
+    });
+    // Create executor group
+    fastify.post("/api/projects/:projectId/executor-groups", 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 { name, branch } = req.body;
+        const existing = fastify.storage.executorGroups.getByBranch(req.params.projectId, branch);
+        if (existing) {
+            return reply.code(409).send({ error: "An executor group already exists for this branch" });
+        }
+        const id = randomUUID();
+        const group = fastify.storage.executorGroups.create({
+            id,
+            project_id: req.params.projectId,
+            name,
+            branch,
+        });
+        return reply.code(201).send({ group });
+    });
+    // Update executor group (rename)
+    fastify.put("/api/executor-groups/:id", async (req, reply) => {
+        const existing = fastify.storage.executorGroups.getById(req.params.id);
+        if (!existing) {
+            return reply.code(404).send({ error: "Executor group not found" });
+        }
+        const group = fastify.storage.executorGroups.update(req.params.id, req.body);
+        return reply.code(200).send({ group });
+    });
+    // Delete executor group (cascades executors)
+    fastify.delete("/api/executor-groups/:id", async (req, reply) => {
+        const existing = fastify.storage.executorGroups.getById(req.params.id);
+        if (!existing) {
+            return reply.code(404).send({ error: "Executor group not found" });
+        }
+        fastify.storage.executorGroups.delete(req.params.id);
+        return reply.code(200).send({ success: true });
+    });
+};
+export default fp(routes, { name: "executor-group-routes" });

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

@@ -0,0 +1,106 @@
+import fp from "fastify-plugin";
+import { randomUUID } from "crypto";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // Get executors — optionally scoped to a group
+    fastify.get("/api/projects/:projectId/executors", 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 executors = req.query.groupId
+            ? fastify.storage.executors.getByGroupId(req.query.groupId)
+            : fastify.storage.executors.getByProjectId(req.params.projectId);
+        return reply.code(200).send({ executors });
+    });
+    // Create Executor
+    fastify.post("/api/projects/:projectId/executors", 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 { name, command, executor_type, prompt_provider, cwd, pty, group_id } = req.body;
+        if (!group_id) {
+            return reply.code(400).send({ error: "group_id is required" });
+        }
+        const parsedType = (executor_type === 'prompt' ? 'prompt' : 'command');
+        const parsedProvider = (prompt_provider === 'codex' ? 'codex' : 'claude');
+        const id = randomUUID();
+        const executor = fastify.storage.executors.create({
+            id,
+            project_id: req.params.projectId,
+            group_id,
+            name,
+            command,
+            executor_type: parsedType,
+            prompt_provider: parsedType === 'prompt' ? parsedProvider : null,
+            cwd,
+            pty,
+        });
+        return reply.code(201).send({ executor });
+    });
+    // 更新 Executor
+    fastify.put("/api/executors/:id", async (req, reply) => {
+        const existing = fastify.storage.executors.getById(req.params.id);
+        if (!existing) {
+            return reply.code(404).send({ error: "Executor not found" });
+        }
+        const { executor_type, prompt_provider, ...rest } = req.body;
+        const parsedType = executor_type !== undefined
+            ? (executor_type === 'prompt' ? 'prompt' : 'command')
+            : undefined;
+        const parsedProvider = prompt_provider !== undefined
+            ? (prompt_provider === 'codex' ? 'codex' : 'claude')
+            : undefined;
+        const updateOpts = {
+            ...rest,
+            ...(parsedType !== undefined ? { executor_type: parsedType } : {}),
+            ...(parsedProvider !== undefined ? { prompt_provider: parsedProvider } : {}),
+        };
+        const executor = fastify.storage.executors.update(req.params.id, updateOpts);
+        return reply.code(200).send({ executor });
+    });
+    // 删除 Executor
+    fastify.delete("/api/executors/:id", async (req, reply) => {
+        const existing = fastify.storage.executors.getById(req.params.id);
+        if (!existing) {
+            return reply.code(404).send({ error: "Executor not found" });
+        }
+        fastify.storage.executors.delete(req.params.id);
+        return reply.code(200).send({ success: true });
+    });
+    // Reorder Executors within a group
+    fastify.put("/api/projects/:projectId/executors/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, groupId } = req.body;
+        if (!Array.isArray(orderedIds)) {
+            return reply.code(400).send({ error: "orderedIds must be an array" });
+        }
+        if (!groupId) {
+            return reply.code(400).send({ error: "groupId is required" });
+        }
+        const existingExecutors = fastify.storage.executors.getByGroupId(groupId);
+        const existingIds = new Set(existingExecutors.map(e => e.id));
+        for (const id of orderedIds) {
+            if (!existingIds.has(id)) {
+                return reply.code(400).send({ error: `Executor ${id} not found in group` });
+            }
+        }
+        fastify.storage.executors.reorder(groupId, orderedIds);
+        return reply.code(200).send({ success: true });
+    });
+};
+export default fp(routes, { name: "executor-routes" });

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

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