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

package/src/server/routes/filesystem.ts

@@ -1,54 +0,0 @@
-import { FastifyInstance } from "fastify"
-import { z } from "zod"
-import { FileSystemBrowser } from "../../filesystem/browser"
-
-interface RouteDeps {
-  fileSystemBrowser: FileSystemBrowser
-}
-
-const FilesystemQuerySchema = z.object({
-  path: z.string().optional(),
-  includeFiles: z.coerce.boolean().optional(),
-})
-
-const FilesystemCreateFolderSchema = z.object({
-  parentPath: z.string().optional(),
-  name: z.string(),
-})
-
-export function registerFilesystemRoutes(app: FastifyInstance, deps: RouteDeps) {
-  app.get("/api/filesystem", async (request, reply) => {
-    const query = FilesystemQuerySchema.parse(request.query ?? {})
-
-    try {
-      return deps.fileSystemBrowser.browse(query.path, {
-        includeFiles: query.includeFiles,
-      })
-    } catch (error) {
-      reply.code(400)
-      return { error: (error as Error).message }
-    }
-  })
-
-  app.post("/api/filesystem/folders", async (request, reply) => {
-    const body = FilesystemCreateFolderSchema.parse(request.body ?? {})
-
-    try {
-      const created = deps.fileSystemBrowser.createFolder(body.parentPath, body.name)
-      reply.code(201)
-      return created
-    } catch (error) {
-      const err = error as NodeJS.ErrnoException
-      if (err?.code === "EEXIST") {
-        reply.code(409).type("text/plain").send("Folder already exists")
-        return
-      }
-      if (err?.code === "EACCES" || err?.code === "EPERM") {
-        reply.code(403).type("text/plain").send("Permission denied")
-        return
-      }
-
-      reply.code(400).type("text/plain").send((error as Error).message)
-    }
-  })
-}

package/src/server/routes/meta.ts

@@ -1,58 +0,0 @@
-import { FastifyInstance } from "fastify"
-import { ServerMeta } from "../../api-types"
-import { resolveNetworkAddresses } from "../network-addresses"
-
-interface RouteDeps {
-  serverMeta: ServerMeta
-}
-
-export function registerMetaRoutes(app: FastifyInstance, deps: RouteDeps) {
-  app.get("/api/meta", async () => buildMetaResponse(deps.serverMeta))
-}
-
-function buildMetaResponse(meta: ServerMeta): ServerMeta {
-  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: ServerMeta): number {
-  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: ServerMeta): { protocol: "http" | "https"; port: number } | null {
-  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: string): boolean {
-  return host === "127.0.0.1" || host === "::1" || host.startsWith("127.")
-}
-
-// NetworkAddress shape is resolved in ../network-addresses

package/src/server/routes/plugin.ts

@@ -1,75 +0,0 @@
-import { FastifyInstance } from "fastify"
-import { z } from "zod"
-import type { WorkspaceManager } from "../../workspaces/manager"
-import type { EventBus } from "../../events/bus"
-import type { Logger } from "../../logger"
-import { PluginChannelManager } from "../../plugins/channel"
-import { buildPingEvent, handlePluginEvent } from "../../plugins/handlers"
-
-interface RouteDeps {
-  workspaceManager: WorkspaceManager
-  eventBus: EventBus
-  logger: Logger
-}
-
-const PluginEventSchema = z.object({
-  type: z.string().min(1),
-  properties: z.record(z.unknown()).optional(),
-})
-
-export function registerPluginRoutes(app: FastifyInstance, deps: RouteDeps) {
-  const channel = new PluginChannelManager(deps.logger.child({ component: "plugin-channel" }))
-
-  app.get<{ Params: { id: string } }>("/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: any, reply: any) => {
-    const workspaceId = request.params.id as string
-    const workspace = deps.workspaceManager.get(workspaceId)
-    if (!workspace) {
-      reply.code(404).send({ error: "Workspace not found" })
-      return
-    }
-
-    const suffix = (request.params["*"] as string | undefined) ?? ""
-    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/src/server/routes/storage.ts

@@ -1,66 +0,0 @@
-import { FastifyInstance } from "fastify"
-import { z } from "zod"
-import { InstanceStore } from "../../storage/instance-store"
-import { EventBus } from "../../events/bus"
-import { ModelPreferenceSchema } from "../../config/schema"
-import type { InstanceData } from "../../api-types"
-import { WorkspaceManager } from "../../workspaces/manager"
-
-interface RouteDeps {
-  instanceStore: InstanceStore
-  eventBus: EventBus
-  workspaceManager: WorkspaceManager
-}
-
-const InstanceDataSchema = z.object({
-  messageHistory: z.array(z.string()).default([]),
-  agentModelSelections: z.record(z.string(), ModelPreferenceSchema).default({}),
-})
-
-const EMPTY_INSTANCE_DATA: InstanceData = {
-  messageHistory: [],
-  agentModelSelections: {},
-}
-
-export function registerStorageRoutes(app: FastifyInstance, deps: RouteDeps) {
-  const resolveStorageKey = (instanceId: string): string => {
-    const workspace = deps.workspaceManager.get(instanceId)
-    return workspace?.path ?? instanceId
-  }
-
-  app.get<{ Params: { id: string } }>("/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<{ Params: { id: string } }>("/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<{ Params: { id: string } }>("/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/src/server/routes/workspaces.ts

@@ -1,113 +0,0 @@
-import { FastifyInstance, FastifyReply } from "fastify"
-import { z } from "zod"
-import { WorkspaceManager } from "../../workspaces/manager"
-
-interface RouteDeps {
-  workspaceManager: WorkspaceManager
-}
-
-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: FastifyInstance, deps: RouteDeps) {
-  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<{ Params: { id: string } }>("/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<{ Params: { id: string } }>("/api/workspaces/:id", async (request, reply) => {
-    await deps.workspaceManager.delete(request.params.id)
-    reply.code(204)
-  })
-
-  app.get<{
-    Params: { id: string }
-    Querystring: { path?: string }
-  }>("/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<{
-    Params: { id: string }
-    Querystring: { q?: string; limit?: string; type?: "all" | "file" | "directory"; refresh?: string }
-  }>("/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<{
-    Params: { id: string }
-    Querystring: { path?: string }
-  }>("/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: unknown, reply: FastifyReply) {
-  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/src/server/routes/worktrees.ts

@@ -1,195 +0,0 @@
-import type { FastifyInstance, FastifyReply } from "fastify"
-import { z } from "zod"
-import { WorkspaceManager } from "../../workspaces/manager"
-import {
-  resolveRepoRoot,
-  listWorktrees,
-  isValidWorktreeSlug,
-  createManagedWorktree,
-  removeWorktree,
-} from "../../workspaces/git-worktrees"
-import type { WorktreeListResponse, WorktreeMap } from "../../api-types"
-import { ensureCodenomadGitExclude, readWorktreeMap, writeWorktreeMap } from "../../workspaces/worktree-map"
-
-interface RouteDeps {
-  workspaceManager: WorkspaceManager
-}
-
-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: FastifyInstance, deps: RouteDeps) {
-  app.get<{ Params: { id: string } }>("/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: WorktreeListResponse = { worktrees, isGitRepo }
-    return response
-  })
-
-  app.post<{ Params: { id: string } }>("/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<{ Params: { id: string; slug: string }; Querystring: { force?: string } }>(
-    "/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: Record<string, string> = { ...(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<{ Params: { id: string } }>("/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<{ Params: { id: string } }>("/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 ?? {}) as WorktreeMap
-      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: unknown, reply: FastifyReply) {
-  reply.code(400)
-  return { error: error instanceof Error ? error.message : "Unable to fulfill request" }
-}