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

package/src/workspaces/git-worktrees.ts

@@ -1,241 +0,0 @@
-import path from "path"
-import { spawn } from "child_process"
-import type { WorktreeDescriptor } from "../api-types"
-import { promises as fsp } from "fs"
-
-export interface LogLike {
-  debug?: (obj: any, msg?: string) => void
-  warn?: (obj: any, msg?: string) => void
-}
-
-type GitResult = { ok: true; stdout: string } | { ok: false; error: Error; stdout?: string; stderr?: string }
-
-function runGit(args: string[], cwd: string): Promise<GitResult> {
-  return new Promise((resolve) => {
-    const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] })
-    let stdout = ""
-    let stderr = ""
-
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString()
-    })
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString()
-    })
-    child.once("error", (error) => {
-      resolve({ ok: false, error, stdout, stderr })
-    })
-    child.once("close", (code) => {
-      if (code === 0) {
-        resolve({ ok: true, stdout })
-      } else {
-        const error = new Error(stderr.trim() || `git ${args.join(" ")} failed with code ${code}`)
-        resolve({ ok: false, error, stdout, stderr })
-      }
-    })
-  })
-}
-
-export async function resolveRepoRoot(folder: string, logger?: LogLike): Promise<{ repoRoot: string; isGitRepo: boolean }> {
-  const result = await runGit(["rev-parse", "--show-toplevel"], folder)
-  if (!result.ok) {
-    logger?.debug?.({ folder, err: result.error }, "Folder is not a Git repository; using workspace folder as root")
-    return { repoRoot: folder, isGitRepo: false }
-  }
-  const repoRoot = result.stdout.trim()
-  if (!repoRoot) {
-    return { repoRoot: folder, isGitRepo: false }
-  }
-  return { repoRoot, isGitRepo: true }
-}
-
-function parseWorktreePorcelain(output: string): Array<{ worktree: string; branch?: string; head?: string; detached?: boolean }> {
-  const records: Array<{ worktree: string; branch?: string; head?: string; detached?: boolean }> = []
-  const lines = output.split(/\r?\n/)
-  let current: { worktree?: string; branch?: string; head?: string; detached?: boolean } = {}
-
-  const flush = () => {
-    if (current.worktree) {
-      records.push({ worktree: current.worktree, branch: current.branch })
-    }
-    current = {}
-  }
-
-  for (const line of lines) {
-    const trimmed = line.trim()
-    if (!trimmed) {
-      flush()
-      continue
-    }
-    const [key, ...rest] = trimmed.split(" ")
-    const value = rest.join(" ").trim()
-    if (key === "worktree") {
-      current.worktree = value
-    } else if (key === "branch") {
-      // branch is like refs/heads/foo
-      current.branch = value.replace(/^refs\/heads\//, "")
-    } else if (key === "HEAD") {
-      current.head = value
-    } else if (key === "detached") {
-      current.detached = true
-    }
-  }
-  flush()
-  return records
-}
-
-export async function listWorktrees(params: {
-  repoRoot: string
-  workspaceFolder: string
-  logger?: LogLike
-}): Promise<WorktreeDescriptor[]> {
-  const { repoRoot, workspaceFolder, logger } = params
-  const rootDescriptor: WorktreeDescriptor = { slug: "root", directory: repoRoot, kind: "root" }
-
-  const result = await runGit(["worktree", "list", "--porcelain"], workspaceFolder)
-  if (!result.ok) {
-    logger?.debug?.({ repoRoot, err: result.error }, "Failed to list git worktrees; returning root only")
-    return [rootDescriptor]
-  }
-
-  const records = parseWorktreePorcelain(result.stdout)
-
-  const worktrees: WorktreeDescriptor[] = [rootDescriptor]
-  const seen = new Set<string>(["root"])
-
-  const normalizeSlug = (record: { branch?: string; head?: string; detached?: boolean; worktree: string }): string => {
-    const branch = (record.branch ?? "").trim()
-    if (branch) {
-      return branch
-    }
-    const head = (record.head ?? "").trim()
-    if (head && /^[0-9a-f]{7,40}$/i.test(head)) {
-      return `detached-${head.slice(0, 7)}`
-    }
-    // Fallback: stable-ish identifier derived from directory basename.
-    const base = path.basename(record.worktree || "")
-    return base ? `worktree-${base}` : "worktree"
-  }
-
-
-  for (const record of records) {
-    const abs = record.worktree
-    if (!abs || typeof abs !== "string") continue
-
-    // Skip the root record (we always expose it as slug="root").
-    if (path.resolve(abs) === path.resolve(repoRoot)) {
-      continue
-    }
-
-    const slug = normalizeSlug(record)
-    if (!slug || slug === "root") {
-      continue
-    }
-    if (seen.has(slug)) {
-      continue
-    }
-    seen.add(slug)
-    worktrees.push({ slug, directory: abs, kind: "worktree", branch: record.branch })
-  }
-
-  return worktrees
-}
-
-export function isValidWorktreeSlug(slug: string): boolean {
-  if (!slug) return false
-  const trimmed = slug.trim()
-  if (!trimmed) return false
-  if (trimmed.length > 200) return false
-  // Disallow control characters; allow branch-like slugs including '/'.
-  if (/[\x00-\x1F\x7F]/.test(trimmed)) return false
-  return true
-}
-
-export async function createManagedWorktree(params: {
-  repoRoot: string
-  workspaceFolder: string
-  slug: string
-  logger?: LogLike
-}): Promise<{ slug: string; directory: string; branch?: string }> {
-  const { repoRoot, workspaceFolder, logger } = params
-  const branch = params.slug.trim()
-
-  if (!branch || branch === "root" || !isValidWorktreeSlug(branch)) {
-    throw new Error("Invalid worktree slug")
-  }
-
-  const sanitizeDirName = (input: string): string => {
-    const normalized = input
-      .trim()
-      .replace(/[\\/]+/g, "-")
-      .replace(/\s+/g, "-")
-      .replace(/[^a-zA-Z0-9_.-]+/g, "-")
-      .replace(/-{2,}/g, "-")
-      .replace(/^-+|-+$/g, "")
-    return normalized || "worktree"
-  }
-
-  const worktreesDir = path.join(repoRoot, ".codenomad", "worktrees")
-  const targetDir = path.join(worktreesDir, sanitizeDirName(branch))
-  await fsp.mkdir(worktreesDir, { recursive: true })
-
-  try {
-    const stat = await fsp.stat(targetDir)
-    if (stat.isDirectory()) {
-      throw new Error("Worktree directory already exists")
-    }
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code
-    if (code !== "ENOENT") {
-      throw error
-    }
-  }
-
-  logger?.debug?.({ slug: branch, branch, targetDir }, "Creating managed git worktree")
-
-  // Prefer creating a new branch from HEAD.
-  const first = await runGit(["worktree", "add", "-b", branch, targetDir, "HEAD"], workspaceFolder)
-  if (first.ok) {
-    return { slug: branch, directory: targetDir, branch }
-  }
-
-  const message = first.stderr?.toLowerCase() ?? first.error.message.toLowerCase()
-  if (message.includes("already exists")) {
-    // If the branch already exists, add worktree for that branch.
-    const second = await runGit(["worktree", "add", targetDir, branch], workspaceFolder)
-    if (second.ok) {
-      return { slug: branch, directory: targetDir, branch }
-    }
-    throw second.error
-  }
-
-  throw first.error
-}
-
-export async function removeWorktree(params: {
-  workspaceFolder: string
-  directory: string
-  force?: boolean
-  logger?: LogLike
-}): Promise<void> {
-  const { workspaceFolder, logger } = params
-  const directory = (params.directory ?? "").trim()
-  if (!directory) {
-    throw new Error("Invalid worktree directory")
-  }
-  logger?.debug?.({ directory, force: Boolean(params.force) }, "Removing git worktree")
-
-  const args = ["worktree", "remove"]
-  if (params.force) {
-    args.push("--force")
-  }
-  args.push(directory)
-
-  const result = await runGit(args, workspaceFolder)
-  if (!result.ok) {
-    throw result.error
-  }
-
-  // Best-effort cleanup of stale metadata.
-  await runGit(["worktree", "prune"], workspaceFolder).catch(() => undefined)
-}

package/src/workspaces/instance-events.ts

@@ -1,226 +0,0 @@
-import { Agent, fetch } from "undici"
-import { Agent as UndiciAgent } from "undici"
-import { EventBus } from "../events/bus"
-import { Logger } from "../logger"
-import { WorkspaceManager } from "./manager"
-import { InstanceStreamEvent, InstanceStreamStatus } from "../api-types"
-
-const INSTANCE_HOST = "127.0.0.1"
-const STREAM_AGENT = new UndiciAgent({ bodyTimeout: 0, headersTimeout: 0 })
-const RECONNECT_DELAY_MS = 1000
-
-interface InstanceEventBridgeOptions {
-  workspaceManager: WorkspaceManager
-  eventBus: EventBus
-  logger: Logger
-}
-
-interface ActiveStream {
-  controller: AbortController
-  task: Promise<void>
-}
-
-export class InstanceEventBridge {
-  private readonly streams = new Map<string, ActiveStream>()
-
-  constructor(private readonly options: InstanceEventBridgeOptions) {
-    const bus = this.options.eventBus
-    bus.on("workspace.started", (event) => this.startStream(event.workspace.id))
-    bus.on("workspace.stopped", (event) => this.stopStream(event.workspaceId, "workspace stopped"))
-    bus.on("workspace.error", (event) => this.stopStream(event.workspace.id, "workspace error"))
-  }
-
-  shutdown() {
-    for (const [id, active] of this.streams) {
-      active.controller.abort()
-      this.publishStatus(id, "disconnected")
-    }
-    this.streams.clear()
-  }
-
-  private startStream(workspaceId: string) {
-    if (this.streams.has(workspaceId)) {
-      return
-    }
-
-    const controller = new AbortController()
-    const task = this.runStream(workspaceId, controller.signal)
-      .catch((error) => {
-        if (!controller.signal.aborted) {
-          this.options.logger.warn({ workspaceId, err: error }, "Instance event stream failed")
-          this.publishStatus(workspaceId, "error", error instanceof Error ? error.message : String(error))
-        }
-      })
-      .finally(() => {
-        const active = this.streams.get(workspaceId)
-        if (active?.controller === controller) {
-          this.streams.delete(workspaceId)
-        }
-      })
-
-    this.streams.set(workspaceId, { controller, task })
-  }
-
-  private stopStream(workspaceId: string, reason?: string) {
-    const active = this.streams.get(workspaceId)
-    if (!active) {
-      return
-    }
-    active.controller.abort()
-    this.streams.delete(workspaceId)
-    this.publishStatus(workspaceId, "disconnected", reason)
-  }
-
-  private async runStream(workspaceId: string, signal: AbortSignal) {
-    while (!signal.aborted) {
-      const port = this.options.workspaceManager.getInstancePort(workspaceId)
-      if (!port) {
-        await this.delay(RECONNECT_DELAY_MS, signal)
-        continue
-      }
-
-      this.publishStatus(workspaceId, "connecting")
-
-      try {
-        await this.consumeStream(workspaceId, port, signal)
-      } catch (error) {
-        if (signal.aborted) {
-          break
-        }
-        this.options.logger.warn({ workspaceId, err: error }, "Instance event stream disconnected")
-        this.publishStatus(workspaceId, "error", error instanceof Error ? error.message : String(error))
-        await this.delay(RECONNECT_DELAY_MS, signal)
-      }
-    }
-  }
-
-  private async consumeStream(workspaceId: string, port: number, signal: AbortSignal) {
-    const url = `http://${INSTANCE_HOST}:${port}/global/event`
-
-    const headers: Record<string, string> = { Accept: "text/event-stream" }
-    const authHeader = this.options.workspaceManager.getInstanceAuthorizationHeader(workspaceId)
-    if (authHeader) {
-      headers["Authorization"] = authHeader
-    }
-
-    const response = await fetch(url, {
-      headers,
-      signal,
-      dispatcher: STREAM_AGENT,
-    })
-
-    if (!response.ok || !response.body) {
-      throw new Error(`Instance event stream unavailable (${response.status})`)
-    }
-
-    this.publishStatus(workspaceId, "connected")
-
-    const reader = response.body.getReader()
-    const decoder = new TextDecoder()
-    let buffer = ""
-
-    while (!signal.aborted) {
-      const { done, value } = await reader.read()
-      if (done || !value) {
-        break
-      }
-      buffer += decoder.decode(value, { stream: true })
-      buffer = this.flushEvents(buffer, workspaceId)
-    }
-  }
-
-  private flushEvents(buffer: string, workspaceId: string) {
-    let separatorIndex = buffer.indexOf("\n\n")
-
-    while (separatorIndex >= 0) {
-      const chunk = buffer.slice(0, separatorIndex)
-      buffer = buffer.slice(separatorIndex + 2)
-      this.processChunk(chunk, workspaceId)
-      separatorIndex = buffer.indexOf("\n\n")
-    }
-
-    return buffer
-  }
-
-  private processChunk(chunk: string, workspaceId: string) {
-    const lines = chunk.split(/\r?\n/)
-    const dataLines: string[] = []
-
-    for (const line of lines) {
-      if (line.startsWith(":")) {
-        continue
-      }
-      if (line.startsWith("data:")) {
-        dataLines.push(line.slice(5).trimStart())
-      }
-    }
-
-    if (dataLines.length === 0) {
-      return
-    }
-
-    const payload = dataLines.join("\n").trim()
-    if (!payload) {
-      return
-    }
-
-    try {
-      const parsed = JSON.parse(payload) as any
-      if (!parsed || typeof parsed !== "object") {
-        this.options.logger.warn({ workspaceId, chunk: payload }, "Dropped malformed instance event")
-        return
-      }
-
-      // OpenCode SSE payload shapes vary across versions.
-      // Common variants:
-      // - { type, properties, ... }
-      // - { payload: { type, properties, ... }, directory: "/abs/path" }
-      // - { payload: { type, properties, ... } }
-      const base = parsed.payload && typeof parsed.payload === "object" ? parsed.payload : parsed
-
-      const event: InstanceStreamEvent | null = base && typeof base === "object" ? ({ ...base } as any) : null
-
-      // Attach directory when available (don't overwrite if already present).
-      if (event && !(event as any).directory && typeof (parsed as any).directory === "string") {
-        ;(event as any).directory = (parsed as any).directory
-      }
-
-      if (!event || typeof (event as any).type !== "string") {
-        this.options.logger.warn({ workspaceId, chunk: payload }, "Dropped malformed instance event")
-        return
-      }
-
-      this.options.logger.debug({ workspaceId, eventType: (event as any).type }, "Instance SSE event received")
-      if (this.options.logger.isLevelEnabled("trace")) {
-        this.options.logger.trace({ workspaceId, event }, "Instance SSE event payload")
-      }
-      this.options.eventBus.publish({ type: "instance.event", instanceId: workspaceId, event })
-    } catch (error) {
-      this.options.logger.warn({ workspaceId, chunk: payload, err: error }, "Failed to parse instance SSE payload")
-    }
-  }
-
-  private publishStatus(instanceId: string, status: InstanceStreamStatus, reason?: string) {
-    this.options.logger.debug({ instanceId, status, reason }, "Instance SSE status updated")
-    this.options.eventBus.publish({ type: "instance.eventStatus", instanceId, status, reason })
-  }
-
-  private delay(duration: number, signal: AbortSignal) {
-    if (duration <= 0) {
-      return Promise.resolve()
-    }
-    return new Promise<void>((resolve) => {
-      const timeout = setTimeout(() => {
-        signal.removeEventListener("abort", onAbort)
-        resolve()
-      }, duration)
-
-      const onAbort = () => {
-        clearTimeout(timeout)
-        resolve()
-      }
-
-      signal.addEventListener("abort", onAbort, { once: true })
-    })
-  }
-}