@dyyz1993/codenomad 0.15.0

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { isLoopbackAddress } from "../../auth/http-auth";
+const CreateSessionSchema = z.object({
+    baseUrl: z.string().min(1),
+    skipTlsVerify: z.boolean().optional(),
+});
+const SessionParamsSchema = z.object({
+    id: z.string().uuid(),
+});
+export function registerRemoteProxyRoutes(app, deps) {
+    app.post("/api/remote-proxy/sessions", async (request, reply) => {
+        try {
+            const body = CreateSessionSchema.parse(request.body ?? {});
+            return await deps.sessionManager.createSession(body.baseUrl, Boolean(body.skipTlsVerify));
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to create remote proxy session");
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to create remote proxy session" };
+        }
+    });
+    app.delete("/api/remote-proxy/sessions/:id", async (request, reply) => {
+        if (!isLoopbackAddress(request.socket.remoteAddress)) {
+            reply.code(404);
+            return { error: "Not found" };
+        }
+        try {
+            const params = SessionParamsSchema.parse(request.params ?? {});
+            const deleted = await deps.sessionManager.deleteSession(params.id);
+            if (!deleted) {
+                reply.code(404);
+                return { error: "Remote proxy session not found" };
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to delete remote proxy session");
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to delete remote proxy session" };
+        }
+    });
+}

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

@@ -0,0 +1,142 @@
+import { Agent, fetch } from "undici";
+import { z } from "zod";
+const ProbeSchema = z.object({
+    baseUrl: z.string().min(1),
+    skipTlsVerify: z.boolean().optional(),
+});
+const PROBE_TIMEOUT_MS = 8000;
+export function registerRemoteServerRoutes(app, deps) {
+    app.post("/api/remote-servers/probe", async (request, reply) => {
+        try {
+            const body = ProbeSchema.parse(request.body ?? {});
+            return await probeRemoteServer(body.baseUrl, Boolean(body.skipTlsVerify));
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to probe remote server");
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid request" };
+        }
+    });
+}
+async function probeRemoteServer(baseUrl, skipTlsVerify) {
+    const normalizedUrl = normalizeBaseUrl(baseUrl);
+    const probeUrl = new URL("./api/auth/status", `${normalizedUrl}/`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    const dispatcher = skipTlsVerify ? new Agent({ connect: { rejectUnauthorized: false } }) : undefined;
+    try {
+        const response = await fetch(probeUrl, {
+            method: "GET",
+            dispatcher,
+            signal: controller.signal,
+            headers: {
+                Accept: "application/json",
+            },
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                reachable: true,
+                normalizedUrl,
+                skipTlsVerify,
+                requiresAuth: false,
+                authenticated: false,
+                error: `Remote server returned HTTP ${response.status}`,
+                errorCode: "http_error",
+            };
+        }
+        const payload = (await response.json());
+        if (typeof payload?.authenticated !== "boolean") {
+            return {
+                ok: false,
+                reachable: true,
+                normalizedUrl,
+                skipTlsVerify,
+                requiresAuth: false,
+                authenticated: false,
+                error: "Remote server did not return a valid CodeNomad auth response",
+                errorCode: "invalid_server",
+            };
+        }
+        return {
+            ok: true,
+            reachable: true,
+            normalizedUrl,
+            skipTlsVerify,
+            requiresAuth: !payload.authenticated,
+            authenticated: payload.authenticated,
+        };
+    }
+    catch (error) {
+        const message = describeProbeError(error);
+        return {
+            ok: false,
+            reachable: false,
+            normalizedUrl,
+            skipTlsVerify,
+            requiresAuth: false,
+            authenticated: false,
+            error: message.message,
+            errorCode: message.code,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+        await dispatcher?.close().catch(() => { });
+    }
+}
+function normalizeBaseUrl(input) {
+    const parsed = new URL(input.trim());
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Server URL must use http:// or https://");
+    }
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname === "/" ? "/" : parsed.pathname.replace(/\/+$/, "") || "/";
+    const value = parsed.toString();
+    return parsed.pathname === "/" ? value.replace(/\/$/, "") : value.replace(/\/$/, "");
+}
+function describeProbeError(error) {
+    const chain = unwrapErrorChain(error);
+    const detailed = chain.find((entry) => {
+        const code = (entry?.code ?? "").toString();
+        return Boolean(code) && code !== "UND_ERR_RESPONSE_STATUS_CODE";
+    }) ?? chain[0];
+    const code = (detailed?.code ?? "").toString();
+    const exactMessage = detailed?.message?.trim() || chain.find((entry) => entry.message?.trim())?.message?.trim();
+    if (code === "DEPTH_ZERO_SELF_SIGNED_CERT" || code === "SELF_SIGNED_CERT_IN_CHAIN" || code === "CERT_HAS_EXPIRED") {
+        return {
+            code: "tls_error",
+            message: "Certificate check failed while connecting to the remote server.",
+        };
+    }
+    return {
+        code: code === "ERR_INVALID_URL"
+            ? "invalid_url"
+            : code === "ECONNREFUSED"
+                ? "connection_refused"
+                : code === "ENOTFOUND"
+                    ? "dns_error"
+                    : code === "UND_ERR_CONNECT_TIMEOUT" || code === "ABORT_ERR"
+                        ? "timeout"
+                        : code
+                            ? code.toLowerCase()
+                            : "probe_failed",
+        message: exactMessage || "Failed to connect to the remote server.",
+    };
+}
+function unwrapErrorChain(error) {
+    const results = [];
+    let current = error;
+    const seen = new Set();
+    while (current && typeof current === "object" && !seen.has(current)) {
+        seen.add(current);
+        const entry = current;
+        results.push({ code: entry.code, message: entry.message });
+        current = entry.cause;
+    }
+    if (results.length === 0 && error instanceof Error) {
+        results.push({ message: error.message });
+    }
+    return results;
+}

package/dist/server/routes/settings.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { probeBinaryVersion } from "../../workspaces/spawn";
+import { sanitizeConfigDoc, sanitizeConfigOwner } from "../../settings/public-config";
+const ValidateBinarySchema = z.object({
+    path: z.string(),
+});
+function validateBinaryPath(binaryPath) {
+    const result = probeBinaryVersion(binaryPath);
+    return { valid: result.valid, version: result.version, error: result.error };
+}
+export function registerSettingsRoutes(app, deps) {
+    // Full-document access
+    app.get("/api/storage/config", async () => sanitizeConfigDoc(deps.settings.getDoc("config")));
+    app.patch("/api/storage/config", async (request, reply) => {
+        try {
+            return sanitizeConfigDoc(deps.settings.mergePatchDoc("config", request.body ?? {}));
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    app.get("/api/storage/config/:owner", async (request) => {
+        return sanitizeConfigOwner(request.params.owner, deps.settings.getOwner("config", request.params.owner));
+    });
+    app.patch("/api/storage/config/:owner", async (request, reply) => {
+        try {
+            return sanitizeConfigOwner(request.params.owner, deps.settings.mergePatchOwner("config", request.params.owner, request.body ?? {}));
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    app.get("/api/storage/state", async () => deps.settings.getDoc("state"));
+    app.patch("/api/storage/state", async (request, reply) => {
+        try {
+            return deps.settings.mergePatchDoc("state", request.body ?? {});
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    app.get("/api/storage/state/:owner", async (request) => {
+        return deps.settings.getOwner("state", request.params.owner);
+    });
+    app.patch("/api/storage/state/:owner", async (request, reply) => {
+        try {
+            return deps.settings.mergePatchOwner("state", request.params.owner, request.body ?? {});
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    // Binary validation helper (used by UI when adding binaries)
+    app.post("/api/storage/binaries/validate", async (request, reply) => {
+        try {
+            const body = ValidateBinarySchema.parse(request.body ?? {});
+            return validateBinaryPath(body.path);
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to validate binary");
+            reply.code(400);
+            return { valid: false, error: error instanceof Error ? error.message : "Invalid request" };
+        }
+    });
+}

package/dist/server/routes/sidecars.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+const SideCarCreateSchema = z.object({
+    kind: z.literal("port").default("port"),
+    name: z.string().trim().min(1),
+    port: z.number().int().min(1).max(65535),
+    insecure: z.boolean().default(false),
+    prefixMode: z.enum(["strip", "preserve"]).default("strip"),
+});
+const SideCarUpdateSchema = SideCarCreateSchema.omit({ kind: true }).partial().refine((value) => Object.keys(value).length > 0, {
+    message: "At least one field is required",
+});
+export function registerSideCarRoutes(app, deps) {
+    app.get("/api/sidecars", async () => {
+        return { sidecars: await deps.sidecarManager.list() };
+    });
+    app.post("/api/sidecars", async (request, reply) => {
+        try {
+            const body = SideCarCreateSchema.parse(request.body ?? {});
+            const sidecar = await deps.sidecarManager.create(body);
+            reply.code(201);
+            return sidecar;
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to create SideCar" };
+        }
+    });
+    app.put("/api/sidecars/:id", async (request, reply) => {
+        try {
+            const body = SideCarUpdateSchema.parse(request.body ?? {});
+            return await deps.sidecarManager.update(request.params.id, body);
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to update SideCar" };
+        }
+    });
+    app.delete("/api/sidecars/:id", async (request, reply) => {
+        const removed = await deps.sidecarManager.delete(request.params.id);
+        if (!removed) {
+            reply.code(404);
+            return { error: "SideCar not found" };
+        }
+        reply.code(204);
+    });
+}

package/dist/server/routes/speech.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+const TranscribeBodySchema = z.object({
+    audioBase64: z.string().min(1, "Audio payload is required"),
+    mimeType: z.string().min(1, "Audio MIME type is required"),
+    filename: z.string().optional(),
+    language: z.string().optional(),
+    prompt: z.string().optional(),
+});
+const SynthesizeBodySchema = z.object({
+    text: z.string().trim().min(1, "Text is required"),
+    format: z.enum(["mp3", "wav", "opus", "aac"]).optional(),
+});
+function getSpeechErrorStatus(error) {
+    if (error instanceof z.ZodError) {
+        return 400;
+    }
+    if (error instanceof Error && /not configured/i.test(error.message)) {
+        return 503;
+    }
+    return 502;
+}
+function getSpeechErrorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+export function registerSpeechRoutes(app, deps) {
+    app.get("/api/speech/capabilities", async () => deps.speechService.getCapabilities());
+    app.post("/api/speech/transcribe", async (request, reply) => {
+        try {
+            const body = TranscribeBodySchema.parse(request.body ?? {});
+            return await deps.speechService.transcribe(body);
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to transcribe audio");
+            reply.code(getSpeechErrorStatus(error));
+            return { error: getSpeechErrorMessage(error, "Failed to transcribe audio") };
+        }
+    });
+    app.post("/api/speech/synthesize", async (request, reply) => {
+        try {
+            const body = SynthesizeBodySchema.parse(request.body ?? {});
+            return await deps.speechService.synthesize(body);
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to synthesize audio");
+            reply.code(getSpeechErrorStatus(error));
+            return { error: getSpeechErrorMessage(error, "Failed to synthesize audio") };
+        }
+    });
+    app.post("/api/speech/synthesize/stream", async (request, reply) => {
+        try {
+            const body = SynthesizeBodySchema.parse(request.body ?? {});
+            const result = await deps.speechService.synthesizeStream(body);
+            reply.header("Content-Type", result.mimeType);
+            reply.header("Cache-Control", "no-store");
+            return reply.send(result.stream);
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to stream synthesized audio");
+            reply.code(getSpeechErrorStatus(error));
+            return { error: getSpeechErrorMessage(error, "Failed to stream synthesized audio") };
+        }
+    });
+}

package/dist/server/routes/storage.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { ModelPreferenceSchema } from "../../config/schema";
+const InstanceDataSchema = z.object({
+    messageHistory: z.array(z.string()).default([]),
+    agentModelSelections: z.record(z.string(), ModelPreferenceSchema).default({}),
+});
+const EMPTY_INSTANCE_DATA = {
+    messageHistory: [],
+    agentModelSelections: {},
+};
+export function registerStorageRoutes(app, deps) {
+    const resolveStorageKey = (instanceId) => {
+        const workspace = deps.workspaceManager.get(instanceId);
+        return workspace?.path ?? instanceId;
+    };
+    app.get("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const storageId = resolveStorageKey(request.params.id);
+            const data = await deps.instanceStore.read(storageId);
+            return data;
+        }
+        catch (error) {
+            reply.code(500);
+            return { error: error instanceof Error ? error.message : "Failed to read instance data" };
+        }
+    });
+    app.put("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const body = InstanceDataSchema.parse(request.body ?? {});
+            const storageId = resolveStorageKey(request.params.id);
+            await deps.instanceStore.write(storageId, body);
+            deps.eventBus.publish({ type: "instance.dataChanged", instanceId: request.params.id, data: body });
+            reply.code(204);
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to save instance data" };
+        }
+    });
+    app.delete("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const storageId = resolveStorageKey(request.params.id);
+            await deps.instanceStore.delete(storageId);
+            deps.eventBus.publish({ type: "instance.dataChanged", instanceId: request.params.id, data: EMPTY_INSTANCE_DATA });
+            reply.code(204);
+        }
+        catch (error) {
+            reply.code(500);
+            return { error: error instanceof Error ? error.message : "Failed to delete instance data" };
+        }
+    });
+}

package/dist/server/routes/workspaces.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+import { getWorktreeGitDiff, getWorktreeGitStatus } from "../../workspaces/git-status";
+import { commitWorktreeChanges, isGitMutationError, stageWorktreePaths, unstageWorktreePaths } from "../../workspaces/git-mutations";
+import { isGitAvailable, resolveRepoRoot } from "../../workspaces/git-worktrees";
+import { resolveWorktreeDirectory } from "../../workspaces/worktree-directory";
+const WorkspaceCreateSchema = z.object({
+    path: z.string(),
+    name: z.string().optional(),
+});
+const WorkspaceFilesQuerySchema = z.object({
+    path: z.string().optional(),
+});
+const WorkspaceFileContentQuerySchema = z.object({
+    path: z.string(),
+});
+const WorkspaceFileContentBodySchema = z.object({
+    contents: z.string(),
+});
+const WorktreeGitDiffQuerySchema = z.object({
+    path: z.string().trim().min(1, "Path is required"),
+    originalPath: z.string().trim().optional(),
+    scope: z.enum(["staged", "unstaged"]),
+});
+const WorktreeGitPathsBodySchema = z.object({
+    paths: z.array(z.string().trim().min(1, "Path is required")).min(1, "At least one path is required"),
+});
+const WorktreeGitCommitBodySchema = z.object({
+    message: z.string().trim().min(1, "Commit message is required"),
+});
+const WorkspaceFileSearchQuerySchema = z.object({
+    q: z.string().trim().min(1, "Query is required"),
+    limit: z.coerce.number().int().positive().max(200).optional(),
+    type: z.enum(["all", "file", "directory"]).optional(),
+    refresh: z
+        .string()
+        .optional()
+        .transform((value) => (value === undefined ? undefined : value === "true")),
+});
+export function registerWorkspaceRoutes(app, deps) {
+    app.get("/api/workspaces", async () => {
+        return deps.workspaceManager.list();
+    });
+    app.post("/api/workspaces", async (request, reply) => {
+        try {
+            const body = WorkspaceCreateSchema.parse(request.body ?? {});
+            const workspace = await deps.workspaceManager.create(body.path, body.name);
+            reply.code(201);
+            return workspace;
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to create workspace");
+            const message = error instanceof Error ? error.message : "Failed to create workspace";
+            reply.code(400).type("text/plain").send(message);
+        }
+    });
+    app.get("/api/workspaces/:id", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        return workspace;
+    });
+    app.delete("/api/workspaces/:id", async (request, reply) => {
+        await deps.workspaceManager.delete(request.params.id);
+        reply.code(204);
+    });
+    app.get("/api/workspaces/:id/files", async (request, reply) => {
+        try {
+            const query = WorkspaceFilesQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.listFiles(request.params.id, query.path ?? ".");
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/files/search", async (request, reply) => {
+        try {
+            const query = WorkspaceFileSearchQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.searchFiles(request.params.id, query.q, {
+                limit: query.limit,
+                type: query.type,
+                refresh: query.refresh,
+            });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/files/content", async (request, reply) => {
+        try {
+            const query = WorkspaceFileContentQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.readFile(request.params.id, query.path);
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.put("/api/workspaces/:id/files/content", async (request, reply) => {
+        try {
+            const query = WorkspaceFileContentQuerySchema.parse(request.query ?? {});
+            const body = WorkspaceFileContentBodySchema.parse(request.body ?? {});
+            deps.workspaceManager.writeFile(request.params.id, query.path, body.contents);
+            reply.code(204);
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-status", async (request, reply) => {
+        try {
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitStatus({ workspaceFolder: directory, logger: request.log });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-diff", async (request, reply) => {
+        try {
+            const query = WorktreeGitDiffQuerySchema.parse(request.query ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitDiff({
+                workspaceFolder: directory,
+                path: query.path,
+                originalPath: query.originalPath,
+                scope: query.scope,
+            });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-stage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await stageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-unstage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await unstageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-commit", async (request, reply) => {
+        try {
+            const body = WorktreeGitCommitBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            const result = await commitWorktreeChanges({ workspaceFolder: directory, message: body.message });
+            return { ok: true, ...result };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+}
+async function resolveGitWorktreeDirectory(workspaceManager, workspaceId, worktreeSlug, logger, reply) {
+    const workspace = workspaceManager.get(workspaceId);
+    if (!workspace) {
+        reply.code(404);
+        reply.send({ error: "Workspace not found" });
+        return null;
+    }
+    const gitAvailable = await isGitAvailable(workspace.path);
+    if (!gitAvailable) {
+        reply.code(503);
+        reply.send({ error: "Git is not installed or not available in PATH" });
+        return null;
+    }
+    const { isGitRepo } = await resolveRepoRoot(workspace.path, logger);
+    if (!isGitRepo) {
+        reply.code(400);
+        reply.send({ error: "Workspace is not a Git repository" });
+        return null;
+    }
+    const directory = await resolveWorktreeDirectory({
+        workspaceId: workspace.id,
+        workspacePath: workspace.path,
+        worktreeSlug,
+        logger,
+    });
+    if (!directory) {
+        reply.code(404);
+        reply.send({ error: "Worktree not found" });
+        return null;
+    }
+    return directory;
+}
+function handleWorkspaceError(error, reply) {
+    if (isGitMutationError(error)) {
+        reply.code(error.statusCode);
+        return { error: error.message };
+    }
+    if (error instanceof Error && error.message === "Workspace not found") {
+        reply.code(404);
+        return { error: "Workspace not found" };
+    }
+    reply.code(400);
+    return { error: error instanceof Error ? error.message : "Unable to fulfill request" };
+}