@vibedeckx/linux-x64 0.1.10

package/dist/routes/file-routes.js

@@ -0,0 +1,331 @@
+import fp from "fastify-plugin";
+import path from "path";
+import fs from "fs/promises";
+import { createReadStream } from "fs";
+import { Readable } from "stream";
+import { proxyToRemoteAuto, proxyToRemoteRaw } 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;
+}
+const MAX_FILE_SIZE = 1 * 1024 * 1024; // 1MB
+function isPathSafe(basePath, relativePath) {
+    const normalizedBase = path.resolve(basePath);
+    const resolved = path.resolve(normalizedBase, relativePath);
+    return resolved.startsWith(normalizedBase + path.sep) || resolved === normalizedBase;
+}
+async function isBinaryFile(filePath) {
+    const fd = await fs.open(filePath, "r");
+    try {
+        const buf = Buffer.alloc(8192);
+        const { bytesRead } = await fd.read(buf, 0, 8192, 0);
+        for (let i = 0; i < bytesRead; i++) {
+            if (buf[i] === 0)
+                return true;
+        }
+        return false;
+    }
+    finally {
+        await fd.close();
+    }
+}
+async function browseDirectory(dirPath) {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const items = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        if (entry.name === "node_modules")
+            continue;
+        if (entry.isDirectory()) {
+            try {
+                const stat = await fs.stat(path.join(dirPath, entry.name));
+                items.push({ name: entry.name, type: "directory", mtime: stat.mtime.toISOString() });
+            }
+            catch {
+                items.push({ name: entry.name, type: "directory" });
+            }
+        }
+        else if (entry.isFile()) {
+            try {
+                const stat = await fs.stat(path.join(dirPath, entry.name));
+                items.push({ name: entry.name, type: "file", size: stat.size, mtime: stat.mtime.toISOString() });
+            }
+            catch {
+                items.push({ name: entry.name, type: "file" });
+            }
+        }
+    }
+    // Sort: directories first, then alphabetical
+    items.sort((a, b) => {
+        if (a.type !== b.type)
+            return a.type === "directory" ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+    return { path: dirPath, items };
+}
+const routes = async (fastify) => {
+    // Browse directory (path-based, for remote execution)
+    fastify.get("/api/path/browse", 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 cwd = resolveWorktreePath(projectPath, branch ?? null);
+        try {
+            const result = await browseDirectory(cwd);
+            return reply.code(200).send(result);
+        }
+        catch {
+            return reply.code(500).send({ error: "Failed to browse directory" });
+        }
+    });
+    // Get file content (path-based, for remote execution)
+    fastify.get("/api/path/file-content", async (req, reply) => {
+        const projectPath = req.query.path;
+        const filePath = req.query.filePath;
+        if (!projectPath || !filePath) {
+            return reply.code(400).send({ error: "Path and filePath are required" });
+        }
+        const branch = req.query.branch;
+        const basePath = resolveWorktreePath(projectPath, branch ?? null);
+        if (!isPathSafe(basePath, filePath)) {
+            return reply.code(403).send({ error: "Path traversal not allowed" });
+        }
+        const fullPath = path.resolve(basePath, filePath);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.size > MAX_FILE_SIZE) {
+                return reply.code(200).send({ binary: false, tooLarge: true, content: null, size: stat.size });
+            }
+            const binary = await isBinaryFile(fullPath);
+            if (binary) {
+                return reply.code(200).send({ binary: true, content: null, size: stat.size });
+            }
+            const content = await fs.readFile(fullPath, "utf-8");
+            return reply.code(200).send({ binary: false, content, size: stat.size });
+        }
+        catch {
+            return reply.code(404).send({ error: "File not found" });
+        }
+    });
+    // Download file (path-based, for remote execution)
+    fastify.get("/api/path/file-download", async (req, reply) => {
+        const projectPath = req.query.path;
+        const filePath = req.query.filePath;
+        if (!projectPath || !filePath) {
+            return reply.code(400).send({ error: "Path and filePath are required" });
+        }
+        const branch = req.query.branch;
+        const basePath = resolveWorktreePath(projectPath, branch ?? null);
+        if (!isPathSafe(basePath, filePath)) {
+            return reply.code(403).send({ error: "Path traversal not allowed" });
+        }
+        const fullPath = path.resolve(basePath, filePath);
+        const fileName = path.basename(fullPath);
+        try {
+            await fs.access(fullPath);
+            const stream = createReadStream(fullPath);
+            return reply
+                .header("Content-Disposition", `attachment; filename="${fileName}"`)
+                .type("application/octet-stream")
+                .send(stream);
+        }
+        catch {
+            return reply.code(404).send({ error: "File not found" });
+        }
+    });
+    // Browse project directory (project-scoped)
+    fastify.get("/api/projects/:id/browse", 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 relativePath = req.query.path || "";
+        const branch = req.query.branch;
+        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 remotePath = relativePath
+                ? path.posix.join(remoteConfig.remotePath, relativePath)
+                : remoteConfig.remotePath;
+            const params = [`path=${encodeURIComponent(remotePath)}`];
+            if (branch)
+                params.push(`branch=${encodeURIComponent(branch)}`);
+            const result = await proxyToRemoteAuto(remoteConfig.serverId, remoteConfig.url, remoteConfig.apiKey, "GET", `/api/path/browse?${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 basePath = resolveWorktreePath(project.path, branch ?? null);
+        const dirPath = relativePath ? path.resolve(basePath, relativePath) : basePath;
+        if (!isPathSafe(basePath, relativePath || ".")) {
+            return reply.code(403).send({ error: "Path traversal not allowed" });
+        }
+        try {
+            const result = await browseDirectory(dirPath);
+            return reply.code(200).send(result);
+        }
+        catch {
+            return reply.code(500).send({ error: "Failed to browse directory" });
+        }
+    });
+    // Get file content (project-scoped)
+    fastify.get("/api/projects/:id/file-content", 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 filePath = req.query.path;
+        if (!filePath) {
+            return reply.code(400).send({ error: "File path is required" });
+        }
+        const branch = req.query.branch;
+        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)}`,
+                `filePath=${encodeURIComponent(filePath)}`,
+            ];
+            if (branch)
+                params.push(`branch=${encodeURIComponent(branch)}`);
+            const result = await proxyToRemoteAuto(remoteConfig.serverId, remoteConfig.url, remoteConfig.apiKey, "GET", `/api/path/file-content?${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 basePath = resolveWorktreePath(project.path, branch ?? null);
+        if (!isPathSafe(basePath, filePath)) {
+            return reply.code(403).send({ error: "Path traversal not allowed" });
+        }
+        const fullPath = path.resolve(basePath, filePath);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.size > MAX_FILE_SIZE) {
+                return reply.code(200).send({ binary: false, tooLarge: true, content: null, size: stat.size });
+            }
+            const binary = await isBinaryFile(fullPath);
+            if (binary) {
+                return reply.code(200).send({ binary: true, content: null, size: stat.size });
+            }
+            const content = await fs.readFile(fullPath, "utf-8");
+            return reply.code(200).send({ binary: false, content, size: stat.size });
+        }
+        catch {
+            return reply.code(404).send({ error: "File not found" });
+        }
+    });
+    // Download file (project-scoped)
+    fastify.get("/api/projects/:id/file-download", 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 filePath = req.query.path;
+        if (!filePath) {
+            return reply.code(400).send({ error: "File path is required" });
+        }
+        const branch = req.query.branch;
+        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)}`,
+                `filePath=${encodeURIComponent(filePath)}`,
+            ];
+            if (branch)
+                params.push(`branch=${encodeURIComponent(branch)}`);
+            const rcm = fastify.reverseConnectManager;
+            if (rcm && rcm.isConnected(remoteConfig.serverId)) {
+                // Reverse-connect: proxy through WebSocket tunnel (returns JSON)
+                const result = await proxyToRemoteAuto(remoteConfig.serverId, remoteConfig.url, remoteConfig.apiKey, "GET", `/api/path/file-download?${params.join("&")}`, undefined, { reverseConnectManager: rcm });
+                return reply.code(result.status || 200).send(result.data);
+            }
+            // Outbound: direct HTTP fetch for raw streaming response
+            const result = await proxyToRemoteRaw(remoteConfig.url, remoteConfig.apiKey, `/api/path/file-download?${params.join("&")}`);
+            if (!result.ok) {
+                return reply.code(result.status || 500).send({ error: "Failed to download file from remote" });
+            }
+            const fileName = path.basename(filePath);
+            reply.header("Content-Disposition", `attachment; filename="${fileName}"`);
+            reply.type("application/octet-stream");
+            if (result.body) {
+                // Convert web ReadableStream to Node.js Readable for Fastify
+                const nodeStream = Readable.fromWeb(result.body);
+                return reply.send(nodeStream);
+            }
+            return reply.code(500).send({ error: "No response body from remote" });
+        }
+        if (!project.path) {
+            return reply.code(400).send({ error: "Project has no local path" });
+        }
+        const basePath = resolveWorktreePath(project.path, branch ?? null);
+        if (!isPathSafe(basePath, filePath)) {
+            return reply.code(403).send({ error: "Path traversal not allowed" });
+        }
+        const fullPath = path.resolve(basePath, filePath);
+        const fileName = path.basename(fullPath);
+        try {
+            await fs.access(fullPath);
+            const stream = createReadStream(fullPath);
+            return reply
+                .header("Content-Disposition", `attachment; filename="${fileName}"`)
+                .type("application/octet-stream")
+                .send(stream);
+        }
+        catch {
+            return reply.code(404).send({ error: "File not found" });
+        }
+    });
+};
+export default fp(routes, { name: "file-routes" });

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

@@ -0,0 +1,183 @@
+import fp from "fastify-plugin";
+import path from "path";
+import { randomUUID } from "crypto";
+import { proxyToRemoteAuto } from "../utils/remote-proxy.js";
+import { resolveWorktreePath } from "../utils/worktree-paths.js";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // Execute command at a path (for remote executor)
+    fastify.post("/api/path/execute", async (req, reply) => {
+        const { path: projectPath, command, executor_type, prompt_provider, cwd, branch, pty } = req.body;
+        if (!projectPath || !command) {
+            return reply.code(400).send({ error: "Path and command are required" });
+        }
+        const resolvedBase = resolveWorktreePath(projectPath, branch ?? null);
+        const resolvedCwd = cwd ? path.join(resolvedBase, cwd) : null;
+        const tempExecutor = {
+            id: randomUUID(),
+            project_id: "remote",
+            group_id: "",
+            name: "remote-command",
+            command,
+            executor_type: (executor_type === 'prompt' ? 'prompt' : 'command'),
+            prompt_provider: (prompt_provider === 'codex' ? 'codex' : 'claude'),
+            cwd: resolvedCwd,
+            pty: pty !== false,
+            position: 0,
+            created_at: new Date().toISOString(),
+        };
+        try {
+            const processId = fastify.processManager.start(tempExecutor, resolvedBase, true);
+            return reply.code(200).send({ processId });
+        }
+        catch (error) {
+            return reply.code(500).send({ error: String(error) });
+        }
+    });
+    // 启动 Executor
+    fastify.post("/api/executors/:id/start", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const executor = fastify.storage.executors.getById(req.params.id);
+        if (!executor) {
+            return reply.code(404).send({ error: "Executor not found" });
+        }
+        const project = fastify.storage.projects.getById(executor.project_id, userId);
+        if (!project) {
+            return reply.code(404).send({ error: "Project not found" });
+        }
+        const branch = req.body?.branch;
+        // Use explicit target from request if provided, otherwise fall back to project setting
+        let executorMode = req.body?.target || project.executor_mode;
+        let useRemoteExecutor = executorMode !== 'local';
+        // Fallback: legacy "remote" value → resolve to actual remote server ID
+        if (useRemoteExecutor && executorMode === 'remote') {
+            const remotes = fastify.storage.projectRemotes.getByProject(project.id);
+            if (remotes.length > 0) {
+                const fallback = remotes[0];
+                executorMode = fallback.remote_server_id;
+                fastify.storage.projects.update(project.id, { executor_mode: fallback.remote_server_id });
+                console.log(`[API] Auto-resolved executor_mode from 'remote' to '${fallback.remote_server_id}' (legacy value)`);
+            }
+        }
+        // Fallback: if local mode but no local path, try to find a remote to use
+        if (!useRemoteExecutor && !project.path) {
+            const remotes = fastify.storage.projectRemotes.getByProject(project.id);
+            if (remotes.length > 0) {
+                const fallback = remotes[0];
+                useRemoteExecutor = true;
+                executorMode = fallback.remote_server_id;
+                fastify.storage.projects.update(project.id, { executor_mode: fallback.remote_server_id });
+                console.log(`[API] Auto-resolved executor_mode from 'local' to '${fallback.remote_server_id}' (no local path)`);
+            }
+        }
+        // When remote, resolve connection info from project_remotes table
+        const remoteConfig = useRemoteExecutor
+            ? fastify.storage.projectRemotes.getByProjectAndServer(project.id, executorMode)
+            : undefined;
+        console.log(`[API] POST executors/${req.params.id}/start: ` +
+            `executor_mode=${executorMode}, useRemoteExecutor=${useRemoteExecutor}, ` +
+            `remoteConfig=${remoteConfig ? `url=${remoteConfig.server_url}, path=${remoteConfig.remote_path}` : 'none'}`);
+        if (useRemoteExecutor) {
+            if (!remoteConfig) {
+                return reply.code(400).send({ error: `Remote server configuration not found for executor_mode="${executorMode}"` });
+            }
+            const result = await proxyToRemoteAuto(executorMode, remoteConfig.server_url ?? "", remoteConfig.server_api_key || "", "POST", `/api/path/execute`, {
+                path: remoteConfig.remote_path,
+                command: executor.command,
+                executor_type: executor.executor_type,
+                prompt_provider: executor.prompt_provider,
+                branch: branch ?? undefined,
+                cwd: executor.cwd || undefined,
+                pty: executor.pty,
+            }, { reverseConnectManager: fastify.reverseConnectManager });
+            if (result.ok) {
+                const remoteData = result.data;
+                const localProcessId = `remote-${executor.id}-${remoteData.processId}`;
+                fastify.remoteExecutorMap.set(localProcessId, {
+                    remoteServerId: executorMode,
+                    remoteUrl: remoteConfig.server_url ?? "",
+                    remoteApiKey: remoteConfig.server_api_key || "",
+                    remoteProcessId: remoteData.processId,
+                    executorId: executor.id,
+                    projectId: project.id,
+                });
+                fastify.eventBus.emit({
+                    type: "executor:started",
+                    projectId: project.id,
+                    executorId: executor.id,
+                    processId: localProcessId,
+                    target: executorMode,
+                });
+                return reply.code(200).send({ processId: localProcessId });
+            }
+            return reply.code(result.status || 502).send(result.data);
+        }
+        if (!project.path) {
+            return reply.code(400).send({ error: "Project has no local path" });
+        }
+        const basePath = resolveWorktreePath(project.path, branch ?? null);
+        try {
+            const processId = fastify.processManager.start(executor, basePath);
+            return reply.code(200).send({ processId });
+        }
+        catch (error) {
+            console.error("[API] Failed to start executor:", error);
+            return reply.code(500).send({ error: String(error) });
+        }
+    });
+    // 停止进程
+    fastify.post("/api/executor-processes/:processId/stop", async (req, reply) => {
+        console.log(`[API] Stop process requested: ${req.params.processId}`);
+        if (req.params.processId.startsWith("remote-")) {
+            const remoteInfo = fastify.remoteExecutorMap.get(req.params.processId);
+            if (!remoteInfo) {
+                return reply.code(404).send({ error: "Remote process not found" });
+            }
+            const result = await proxyToRemoteAuto(remoteInfo.remoteServerId, remoteInfo.remoteUrl, remoteInfo.remoteApiKey, "POST", `/api/executor-processes/${remoteInfo.remoteProcessId}/stop`, undefined, { reverseConnectManager: fastify.reverseConnectManager });
+            if (result.ok) {
+                fastify.eventBus.emit({
+                    type: "executor:stopped",
+                    projectId: remoteInfo.projectId ?? "",
+                    executorId: remoteInfo.executorId,
+                    processId: req.params.processId,
+                    exitCode: 0,
+                    target: remoteInfo.remoteServerId,
+                });
+                fastify.remoteExecutorMap.delete(req.params.processId);
+            }
+            return reply.code(result.status || 200).send(result.data);
+        }
+        const stopped = fastify.processManager.stop(req.params.processId);
+        console.log(`[API] Stop result: ${stopped}`);
+        if (!stopped) {
+            return reply.code(404).send({ error: "Process not found or already stopped" });
+        }
+        return reply.code(200).send({ success: true });
+    });
+    // 获取所有运行中的进程
+    fastify.get("/api/executor-processes/running", async (req, reply) => {
+        // Local processes
+        const runningProcessIds = fastify.processManager.getRunningProcessIds();
+        const processes = runningProcessIds.map((id) => {
+            const dbProcess = fastify.storage.executorProcesses.getById(id);
+            return dbProcess ? { ...dbProcess, target: "local" } : null;
+        }).filter(Boolean);
+        // Remote processes (tracked in remoteExecutorMap)
+        for (const [localProcessId, info] of fastify.remoteExecutorMap) {
+            processes.push({
+                id: localProcessId,
+                executor_id: info.executorId,
+                status: "running",
+                exit_code: null,
+                started_at: new Date().toISOString(),
+                finished_at: null,
+                target: info.remoteServerId,
+            });
+        }
+        return reply.code(200).send({ processes });
+    });
+};
+export default fp(routes, { name: "process-routes" });

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

@@ -0,0 +1,82 @@
+import fp from "fastify-plugin";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+function sanitizeProjectRemote(pr) {
+    const { server_api_key: _, ...safe } = pr;
+    return safe;
+}
+const routes = async (fastify) => {
+    // GET /api/projects/:id/remotes — list all remotes for a project (api_key sanitized)
+    fastify.get("/api/projects/:id/remotes", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const project = fastify.storage.projects.getById(id, userId);
+        if (!project)
+            return reply.code(404).send({ error: "Project not found" });
+        const remotes = fastify.storage.projectRemotes.getByProject(id);
+        return reply.send(remotes.map(sanitizeProjectRemote));
+    });
+    // POST /api/projects/:id/remotes — add a remote to a project
+    fastify.post("/api/projects/:id/remotes", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { id } = request.params;
+        const { remoteServerId, remotePath, sortOrder, syncUpConfig, syncDownConfig } = request.body;
+        if (!remoteServerId || !remotePath)
+            return reply
+                .code(400)
+                .send({ error: "remoteServerId and remotePath are required" });
+        const project = fastify.storage.projects.getById(id, userId);
+        if (!project)
+            return reply.code(404).send({ error: "Project not found" });
+        const server = fastify.storage.remoteServers.getById(remoteServerId, userId);
+        if (!server)
+            return reply.code(404).send({ error: "Remote server not found" });
+        const existing = fastify.storage.projectRemotes.getByProjectAndServer(id, remoteServerId);
+        if (existing)
+            return reply
+                .code(409)
+                .send({ error: "This remote server is already associated with the project" });
+        const projectRemote = fastify.storage.projectRemotes.add({
+            project_id: id,
+            remote_server_id: remoteServerId,
+            remote_path: remotePath,
+            sort_order: sortOrder,
+            sync_up_config: syncUpConfig,
+            sync_down_config: syncDownConfig,
+        });
+        return reply.code(201).send(projectRemote);
+    });
+    // PUT /api/projects/:id/remotes/:rid — update a project-remote association
+    fastify.put("/api/projects/:id/remotes/:rid", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { rid } = request.params;
+        const { remotePath, sortOrder, syncUpConfig, syncDownConfig } = request.body;
+        const updated = fastify.storage.projectRemotes.update(rid, {
+            remote_path: remotePath,
+            sort_order: sortOrder,
+            sync_up_config: syncUpConfig,
+            sync_down_config: syncDownConfig,
+        });
+        if (!updated)
+            return reply.code(404).send({ error: "Project remote not found" });
+        return reply.send(updated);
+    });
+    // DELETE /api/projects/:id/remotes/:rid — remove a remote from a project
+    fastify.delete("/api/projects/:id/remotes/:rid", async (request, reply) => {
+        const userId = requireAuth(request, reply);
+        if (userId === null)
+            return;
+        const { rid } = request.params;
+        const removed = fastify.storage.projectRemotes.remove(rid);
+        if (!removed)
+            return reply.code(404).send({ error: "Project remote not found" });
+        return reply.send({ success: true });
+    });
+};
+export default fp(routes, { name: "project-remote-routes" });

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

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