@neuralnomads/codenomad-dev 0.10.3-dev-20260213-ba418a85

package/dist/server/routes/github-plugin.js

@@ -0,0 +1,215 @@
+import path from "path";
+import { z } from "zod";
+import { getGitHubWorkspaceContext } from "../../integrations/github/workspace-context";
+import { getGitHubWorktreeContext } from "../../integrations/github/worktree-context";
+import { createInstallationOctokit, getInstallationToken } from "../../integrations/github/octokit";
+import { gitCurrentBranch, gitIsClean, gitPushHead } from "../../integrations/github/git-ops";
+import { listWorktrees, resolveRepoRoot } from "../../workspaces/git-worktrees";
+import { sanitizeGitHubWebhookPayload } from "../../integrations/github/sanitize-webhook";
+import { appendCodeNomadBotSignature } from "../../integrations/github/bot-signature";
+const AddReactionSchema = z.object({
+    op: z.literal("add_reaction"),
+    commentId: z.number().int().positive(),
+    content: z.enum(["eyes", "rocket", "+1", "-1", "laugh", "confused", "heart", "hooray"]),
+});
+const PostIssueCommentSchema = z.object({
+    op: z.literal("post_issue_comment"),
+    issueNumber: z.number().int().positive(),
+    body: z.string().min(1),
+});
+const PublishPrSchema = z.object({
+    op: z.literal("publish_pr"),
+    directory: z.string().min(1),
+    title: z.string().min(1),
+    body: z.string().optional(),
+    base: z.string().optional(),
+    draft: z.boolean().optional(),
+});
+const ListIssueCommentsSchema = z.object({
+    op: z.literal("list_issue_comments"),
+    issueNumber: z.number().int().positive(),
+});
+const GitHubToolSchema = z.discriminatedUnion("op", [
+    AddReactionSchema,
+    PostIssueCommentSchema,
+    PublishPrSchema,
+    ListIssueCommentsSchema,
+]);
+export function registerGitHubPluginRoutes(app, deps) {
+    app.post("/workspaces/:id/plugin/integrations/github", async (request, reply) => {
+        const workspaceId = request.params.id;
+        const workspace = deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        const context = getGitHubWorkspaceContext(workspaceId);
+        if (!context) {
+            reply.code(400);
+            return { error: "Workspace is not configured for GitHub" };
+        }
+        const gh = deps.configStore.get().integrations?.github;
+        if (!gh?.enabled || !gh.appId || !gh.privateKeyPath) {
+            reply.code(400);
+            return { error: "GitHub integration is not configured" };
+        }
+        let parsed;
+        try {
+            parsed = GitHubToolSchema.parse(request.body ?? {});
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid GitHub tool request" };
+        }
+        const installationId = context.installationId;
+        const token = await getInstallationToken({ appId: gh.appId, privateKeyPath: gh.privateKeyPath }, installationId);
+        const octokit = createInstallationOctokit({ appId: gh.appId, privateKeyPath: gh.privateKeyPath }, installationId);
+        const owner = context.owner;
+        const repo = context.repo;
+        const defaultBase = context.defaultBranch;
+        try {
+            if (parsed.op === "add_reaction") {
+                const reaction = await octokit.request("POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
+                    owner,
+                    repo,
+                    comment_id: parsed.commentId,
+                    content: parsed.content,
+                    headers: { accept: "application/vnd.github+json" },
+                });
+                return { ok: true, op: "add_reaction", data: sanitizeGitHubWebhookPayload(reaction.data) };
+            }
+            if (parsed.op === "post_issue_comment") {
+                const body = appendCodeNomadBotSignature(parsed.body);
+                const res = await octokit.request("POST /repos/{owner}/{repo}/issues/{issue_number}/comments", {
+                    owner,
+                    repo,
+                    issue_number: parsed.issueNumber,
+                    body,
+                });
+                return { ok: true, op: "post_issue_comment", url: res.data?.html_url, data: sanitizeGitHubWebhookPayload(res.data) };
+            }
+            if (parsed.op === "list_issue_comments") {
+                const all = [];
+                let page = 1;
+                const perPage = 100;
+                while (true) {
+                    const res = await octokit.request("GET /repos/{owner}/{repo}/issues/{issue_number}/comments", {
+                        owner,
+                        repo,
+                        issue_number: parsed.issueNumber,
+                        per_page: perPage,
+                        page,
+                    });
+                    const items = Array.isArray(res.data) ? res.data : [];
+                    for (const item of items) {
+                        all.push({
+                            id: item.id,
+                            html_url: item.html_url,
+                            user: {
+                                login: item?.user?.login,
+                                type: item?.user?.type,
+                            },
+                            created_at: item.created_at,
+                            updated_at: item.updated_at,
+                            body: item.body,
+                        });
+                    }
+                    if (items.length < perPage)
+                        break;
+                    page += 1;
+                    if (page > 50)
+                        break;
+                }
+                return { ok: true, op: "list_issue_comments", data: all };
+            }
+            if (parsed.op === "publish_pr") {
+                let base = parsed.base ?? defaultBase;
+                const absDir = path.resolve(parsed.directory);
+                const workspaceRoot = path.resolve(workspace.path);
+                const rel = path.relative(workspaceRoot, absDir);
+                if (rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel))) {
+                    // ok
+                }
+                else {
+                    reply.code(400);
+                    return { error: "Invalid directory" };
+                }
+                // If base isn't provided, prefer a worktree-specific default base for this run.
+                if (!parsed.base) {
+                    try {
+                        const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, deps.logger);
+                        if (isGitRepo) {
+                            const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: deps.logger });
+                            const match = worktrees.find((wt) => path.resolve(wt.directory) === absDir);
+                            if (match) {
+                                const ctx = getGitHubWorktreeContext(workspaceId, match.slug);
+                                if (ctx?.publishBase) {
+                                    base = ctx.publishBase;
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+                const branch = await gitCurrentBranch(absDir);
+                if (!branch) {
+                    reply.code(400);
+                    return { error: "No current branch" };
+                }
+                const clean = await gitIsClean(absDir);
+                if (!clean) {
+                    reply.code(400);
+                    return { error: "Working tree has uncommitted changes" };
+                }
+                await gitPushHead({ cwd: absDir, remoteUrl: context.repoUrl, branch, token });
+                let prUrl;
+                let prNumber;
+                let pr;
+                try {
+                    const created = await octokit.request("POST /repos/{owner}/{repo}/pulls", {
+                        owner,
+                        repo,
+                        title: parsed.title,
+                        body: parsed.body ? appendCodeNomadBotSignature(parsed.body) : undefined,
+                        head: branch,
+                        base,
+                        draft: parsed.draft ?? false,
+                    });
+                    prUrl = created.data?.html_url;
+                    prNumber = created.data?.number;
+                    pr = created.data;
+                }
+                catch (error) {
+                    // If a PR already exists for this head, surface the existing PR.
+                    const status = error?.status;
+                    if (status === 422) {
+                        const head = `${owner}:${branch}`;
+                        const existing = await octokit.request("GET /repos/{owner}/{repo}/pulls", {
+                            owner,
+                            repo,
+                            state: "open",
+                            head,
+                        });
+                        const first = Array.isArray(existing.data) ? existing.data[0] : null;
+                        prUrl = first?.html_url;
+                        prNumber = first?.number;
+                        pr = first;
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                return { ok: true, op: "publish_pr", branch, url: prUrl, number: prNumber, base, data: sanitizeGitHubWebhookPayload(pr) };
+            }
+            reply.code(400);
+            return { error: "Unknown operation" };
+        }
+        catch (error) {
+            deps.logger.error({ err: error, workspaceId, op: parsed?.op }, "GitHub tool call failed");
+            reply.code(500);
+            return { error: error instanceof Error ? error.message : "GitHub operation failed" };
+        }
+    });
+}

package/dist/server/routes/github-webhook.js

@@ -0,0 +1,32 @@
+import { GitHubJobRunner } from "../../integrations/github/job-runner";
+export function registerGitHubWebhookRoutes(app, deps) {
+    // Ensure info-level GitHub lifecycle logs are visible at CLI_LOG_LEVEL=info.
+    const log = deps.logger.child({ component: "app", module: "github" });
+    const runner = new GitHubJobRunner({
+        workspaceManager: deps.workspaceManager,
+        configStore: deps.configStore,
+        eventBus: deps.eventBus,
+        logger: log,
+    });
+    app.register(async (instance) => {
+        instance.addContentTypeParser("application/json", { parseAs: "buffer" }, (_req, body, done) => done(null, body));
+        instance.post("/integrations/github/webhook", async (request, reply) => {
+            const event = request.headers["x-github-event"] ?? "";
+            const delivery = request.headers["x-github-delivery"] ?? "";
+            const signature = request.headers["x-hub-signature-256"] ?? undefined;
+            const body = request.body;
+            if (!Buffer.isBuffer(body)) {
+                reply.code(400).type("text/plain").send("Expected raw JSON body");
+                return;
+            }
+            log.info({ event, deliveryId: delivery }, "GitHub webhook received");
+            runner.enqueue({
+                deliveryId: delivery,
+                event,
+                signature,
+                body,
+            });
+            reply.code(202).send({ ok: true });
+        });
+    });
+}

package/dist/server/routes/meta.js

@@ -0,0 +1,47 @@
+import { resolveNetworkAddresses } from "../network-addresses";
+export function registerMetaRoutes(app, deps) {
+    app.get("/api/meta", async () => buildMetaResponse(deps.serverMeta));
+}
+function buildMetaResponse(meta) {
+    const localPort = resolveLocalPort(meta);
+    const remote = resolveRemote(meta);
+    const addresses = remote && remote.port > 0 ? resolveNetworkAddresses({ host: meta.host, protocol: remote.protocol, port: remote.port }) : [];
+    return {
+        ...meta,
+        localPort,
+        remotePort: remote?.port,
+        listeningMode: meta.host === "0.0.0.0" || !isLoopbackHost(meta.host) ? "all" : "local",
+        addresses,
+    };
+}
+function resolveLocalPort(meta) {
+    if (Number.isInteger(meta.localPort) && meta.localPort > 0) {
+        return meta.localPort;
+    }
+    try {
+        const parsed = new URL(meta.localUrl);
+        const port = Number(parsed.port);
+        return Number.isInteger(port) && port > 0 ? port : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function resolveRemote(meta) {
+    if (!meta.remoteUrl) {
+        return null;
+    }
+    try {
+        const parsed = new URL(meta.remoteUrl);
+        const protocol = parsed.protocol === "https:" ? "https" : "http";
+        const port = Number(parsed.port);
+        return { protocol, port: Number.isInteger(port) && port > 0 ? port : 0 };
+    }
+    catch {
+        return null;
+    }
+}
+function isLoopbackHost(host) {
+    return host === "127.0.0.1" || host === "::1" || host.startsWith("127.");
+}
+// NetworkAddress shape is resolved in ../network-addresses

package/dist/server/routes/plugin.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { PluginChannelManager } from "../../plugins/channel";
+import { buildPingEvent, handlePluginEvent } from "../../plugins/handlers";
+const PluginEventSchema = z.object({
+    type: z.string().min(1),
+    properties: z.record(z.unknown()).optional(),
+});
+export function registerPluginRoutes(app, deps) {
+    const channel = new PluginChannelManager(deps.logger.child({ component: "plugin-channel" }));
+    app.get("/workspaces/:id/plugin/events", (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404).send({ error: "Workspace not found" });
+            return;
+        }
+        reply.raw.setHeader("Content-Type", "text/event-stream");
+        reply.raw.setHeader("Cache-Control", "no-cache");
+        reply.raw.setHeader("Connection", "keep-alive");
+        reply.raw.flushHeaders?.();
+        reply.hijack();
+        const registration = channel.register(request.params.id, reply);
+        const heartbeat = setInterval(() => {
+            channel.send(request.params.id, buildPingEvent());
+        }, 15000);
+        const close = () => {
+            clearInterval(heartbeat);
+            registration.close();
+            reply.raw.end?.();
+        };
+        request.raw.on("close", close);
+        request.raw.on("error", close);
+    });
+    const handleWildcard = async (request, reply) => {
+        const workspaceId = request.params.id;
+        const workspace = deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            reply.code(404).send({ error: "Workspace not found" });
+            return;
+        }
+        const suffix = request.params["*"] ?? "";
+        const normalized = suffix.replace(/^\/+/, "");
+        if (normalized === "event" && request.method === "POST") {
+            const parsed = PluginEventSchema.parse(request.body ?? {});
+            handlePluginEvent(workspaceId, parsed, { workspaceManager: deps.workspaceManager, eventBus: deps.eventBus, logger: deps.logger });
+            reply.code(204).send();
+            return;
+        }
+        reply.code(404).send({ error: "Unknown plugin endpoint" });
+    };
+    app.all("/workspaces/:id/plugin/*", handleWildcard);
+    app.all("/workspaces/:id/plugin", handleWildcard);
+}

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,89 @@
+import { z } from "zod";
+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 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);
+        }
+    });
+}
+function handleWorkspaceError(error, reply) {
+    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" };
+}

package/dist/server/routes/worktrees.js

@@ -0,0 +1,156 @@
+import { z } from "zod";
+import { resolveRepoRoot, listWorktrees, isValidWorktreeSlug, createManagedWorktree, removeWorktree, } from "../../workspaces/git-worktrees";
+import { ensureCodenomadGitExclude, readWorktreeMap, writeWorktreeMap } from "../../workspaces/worktree-map";
+const WorktreeMapSchema = z.object({
+    version: z.literal(1),
+    defaultWorktreeSlug: z.string().min(1).default("root"),
+    parentSessionWorktreeSlug: z.record(z.string(), z.string()).default({}),
+});
+const WorktreeCreateSchema = z.object({
+    slug: z.string().trim().min(1),
+    branch: z.string().trim().min(1).optional(),
+});
+export function registerWorktreeRoutes(app, deps) {
+    app.get("/api/workspaces/:id/worktrees", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
+        const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: request.log });
+        const response = { worktrees, isGitRepo };
+        return response;
+    });
+    app.post("/api/workspaces/:id/worktrees", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        try {
+            const body = WorktreeCreateSchema.parse(request.body ?? {});
+            const slug = body.slug;
+            if (!isValidWorktreeSlug(slug) || slug === "root") {
+                reply.code(400);
+                return { error: "Invalid worktree slug" };
+            }
+            if (body.branch) {
+                if (!isValidWorktreeSlug(body.branch) || body.branch === "root") {
+                    reply.code(400);
+                    return { error: "Invalid worktree branch" };
+                }
+                if (body.branch !== slug) {
+                    reply.code(400);
+                    return { error: "Branch must match slug" };
+                }
+            }
+            const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
+            if (!isGitRepo) {
+                reply.code(400);
+                return { error: "Workspace is not a Git repository" };
+            }
+            await ensureCodenomadGitExclude(workspace.path, request.log).catch(() => undefined);
+            const created = await createManagedWorktree({
+                repoRoot,
+                workspaceFolder: workspace.path,
+                slug,
+                logger: request.log,
+            });
+            reply.code(201);
+            return created;
+        }
+        catch (error) {
+            return handleError(error, reply);
+        }
+    });
+    app.delete("/api/workspaces/:id/worktrees/:slug", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        const slug = (request.params.slug ?? "").trim();
+        if (!isValidWorktreeSlug(slug) || slug === "root") {
+            reply.code(400);
+            return { error: "Invalid worktree slug" };
+        }
+        const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
+        if (!isGitRepo) {
+            reply.code(400);
+            return { error: "Workspace is not a Git repository" };
+        }
+        const force = (request.query?.force ?? "").toString().toLowerCase() === "true";
+        try {
+            const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: request.log });
+            const match = worktrees.find((wt) => wt.slug === slug);
+            if (!match || match.kind === "root") {
+                reply.code(404);
+                return { error: "Worktree not found" };
+            }
+            await removeWorktree({ workspaceFolder: workspace.path, directory: match.directory, force, logger: request.log });
+            // Best-effort: prune any mappings that point at the deleted worktree.
+            const current = await readWorktreeMap(workspace.path, request.log);
+            let changed = false;
+            const nextMapping = { ...(current.parentSessionWorktreeSlug ?? {}) };
+            for (const [sessionId, mapped] of Object.entries(nextMapping)) {
+                if (mapped === slug) {
+                    delete nextMapping[sessionId];
+                    changed = true;
+                }
+            }
+            const nextDefault = current.defaultWorktreeSlug === slug ? "root" : current.defaultWorktreeSlug;
+            if (nextDefault !== current.defaultWorktreeSlug) {
+                changed = true;
+            }
+            if (changed) {
+                await writeWorktreeMap(workspace.path, {
+                    version: 1,
+                    defaultWorktreeSlug: nextDefault,
+                    parentSessionWorktreeSlug: nextMapping,
+                }, request.log);
+            }
+            reply.code(204);
+        }
+        catch (error) {
+            return handleError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/map", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        return await readWorktreeMap(workspace.path, request.log);
+    });
+    app.put("/api/workspaces/:id/worktrees/map", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        try {
+            const parsed = WorktreeMapSchema.parse(request.body ?? {});
+            if (!isValidWorktreeSlug(parsed.defaultWorktreeSlug)) {
+                reply.code(400);
+                return { error: "Invalid defaultWorktreeSlug" };
+            }
+            for (const slug of Object.values(parsed.parentSessionWorktreeSlug ?? {})) {
+                if (!isValidWorktreeSlug(slug)) {
+                    reply.code(400);
+                    return { error: "Invalid worktree slug in mapping" };
+                }
+            }
+            await writeWorktreeMap(workspace.path, parsed, request.log);
+            reply.code(204);
+        }
+        catch (error) {
+            return handleError(error, reply);
+        }
+    });
+}
+function handleError(error, reply) {
+    reply.code(400);
+    return { error: error instanceof Error ? error.message : "Unable to fulfill request" };
+}