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

package/src/launcher.ts

@@ -1,177 +0,0 @@
-import { spawn } from "child_process"
-import os from "os"
-import path from "path"
-import type { Logger } from "./logger"
-
-interface BrowserCandidate {
-  name: string
-  command: string
-  args: (url: string) => string[]
-}
-
-const APP_ARGS = (url: string) => [`--app=${url}`, "--new-window"]
-
-export async function launchInBrowser(url: string, logger: Logger): Promise<boolean> {
-  const { platform, candidates, manualExamples } = buildPlatformCandidates(url)
-
-  console.log(`Attempting to launch browser (${platform}) using:`)
-  candidates.forEach((candidate) => console.log(`  - ${candidate.name}: ${candidate.command}`))
-
-  for (const candidate of candidates) {
-    const success = await tryLaunch(candidate, url, logger)
-    if (success) {
-      return true
-    }
-  }
-
-  console.error(
-    "No supported browser found to launch. Run without --launch and use one of the commands below or install a compatible browser.",
-  )
-  if (manualExamples.length > 0) {
-    console.error("Manual launch commands:")
-    manualExamples.forEach((line) => console.error(`  ${line}`))
-  }
-
-  return false
-}
-
-async function tryLaunch(candidate: BrowserCandidate, url: string, logger: Logger): Promise<boolean> {
-  return new Promise((resolve) => {
-    let resolved = false
-    try {
-      const args = candidate.args(url)
-      const child = spawn(candidate.command, args, { stdio: "ignore", detached: true })
-
-      child.once("error", (error) => {
-        if (resolved) return
-        resolved = true
-        logger.debug({ err: error, candidate: candidate.name, command: candidate.command, args }, "Browser launch failed")
-        resolve(false)
-      })
-
-      child.once("spawn", () => {
-        if (resolved) return
-        resolved = true
-        logger.info(
-          {
-            browser: candidate.name,
-            command: candidate.command,
-            args,
-            fullCommand: [candidate.command, ...args].join(" "),
-          },
-          "Launched browser in app mode",
-        )
-        child.unref()
-        resolve(true)
-      })
-    } catch (error) {
-      if (resolved) return
-      resolved = true
-      logger.debug({ err: error, candidate: candidate.name, command: candidate.command }, "Browser spawn threw")
-      resolve(false)
-    }
-  })
-}
-
-function buildPlatformCandidates(url: string) {
-  switch (os.platform()) {
-    case "darwin":
-      return {
-        platform: "macOS",
-        candidates: buildMacCandidates(),
-        manualExamples: buildMacManualExamples(url),
-      }
-    case "win32":
-      return {
-        platform: "Windows",
-        candidates: buildWindowsCandidates(),
-        manualExamples: buildWindowsManualExamples(url),
-      }
-    default:
-      return {
-        platform: "Linux",
-        candidates: buildLinuxCandidates(),
-        manualExamples: buildLinuxManualExamples(url),
-      }
-  }
-}
-
-function buildMacCandidates(): BrowserCandidate[] {
-  const apps = [
-    { name: "Google Chrome", path: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" },
-    { name: "Google Chrome Canary", path: "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary" },
-    { name: "Microsoft Edge", path: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge" },
-    { name: "Brave Browser", path: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser" },
-    { name: "Chromium", path: "/Applications/Chromium.app/Contents/MacOS/Chromium" },
-    { name: "Vivaldi", path: "/Applications/Vivaldi.app/Contents/MacOS/Vivaldi" },
-    { name: "Arc", path: "/Applications/Arc.app/Contents/MacOS/Arc" },
-  ]
-
-  return apps.map((entry) => ({ name: entry.name, command: entry.path, args: APP_ARGS }))
-}
-
-function buildWindowsCandidates(): BrowserCandidate[] {
-  const programFiles = process.env["ProgramFiles"]
-  const programFilesX86 = process.env["ProgramFiles(x86)"]
-  const localAppData = process.env["LocalAppData"]
-
-  const paths = [
-    [programFiles, "Google/Chrome/Application/chrome.exe", "Google Chrome"],
-    [programFilesX86, "Google/Chrome/Application/chrome.exe", "Google Chrome (x86)"],
-    [localAppData, "Google/Chrome/Application/chrome.exe", "Google Chrome (User)"],
-    [programFiles, "Microsoft/Edge/Application/msedge.exe", "Microsoft Edge"],
-    [programFilesX86, "Microsoft/Edge/Application/msedge.exe", "Microsoft Edge (x86)"],
-    [localAppData, "Microsoft/Edge/Application/msedge.exe", "Microsoft Edge (User)"],
-    [programFiles, "BraveSoftware/Brave-Browser/Application/brave.exe", "Brave"],
-    [localAppData, "BraveSoftware/Brave-Browser/Application/brave.exe", "Brave (User)"],
-    [programFiles, "Chromium/Application/chromium.exe", "Chromium"],
-  ] as const
-
-  return paths
-    .filter(([root]) => Boolean(root))
-    .map(([root, rel, name]) => ({
-      name,
-      command: path.join(root as string, rel),
-      args: APP_ARGS,
-    }))
-}
-
-function buildLinuxCandidates(): BrowserCandidate[] {
-  const names = [
-    "google-chrome",
-    "google-chrome-stable",
-    "chromium",
-    "chromium-browser",
-    "brave-browser",
-    "microsoft-edge",
-    "microsoft-edge-stable",
-    "vivaldi",
-  ]
-
-  return names.map((name) => ({ name, command: name, args: APP_ARGS }))
-}
-
-function buildMacManualExamples(url: string) {
-  return [
-    `"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --app="${url}" --new-window`,
-    `"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge" --app="${url}" --new-window`,
-    `"/Applications/Brave Browser.app/Contents/MacOS/Brave Browser" --app="${url}" --new-window`,
-  ]
-}
-
-function buildWindowsManualExamples(url: string) {
-  return [
-    `"%ProgramFiles%\\Google\\Chrome\\Application\\chrome.exe" --app="${url}" --new-window`,
-    `"%ProgramFiles%\\Microsoft\\Edge\\Application\\msedge.exe" --app="${url}" --new-window`,
-    `"%ProgramFiles%\\BraveSoftware\\Brave-Browser\\Application\\brave.exe" --app="${url}" --new-window`,
-  ]
-}
-
-function buildLinuxManualExamples(url: string) {
-  return [
-    `google-chrome --app="${url}" --new-window`,
-    `chromium --app="${url}" --new-window`,
-    `brave-browser --app="${url}" --new-window`,
-    `microsoft-edge --app="${url}" --new-window`,
-  ]
-}

package/src/loader.ts

@@ -1,21 +0,0 @@
-export async function resolve(specifier: string, context: any, defaultResolve: any) {
-  try {
-    return await defaultResolve(specifier, context, defaultResolve)
-  } catch (error: any) {
-    if (shouldRetry(specifier, error)) {
-      const retried = specifier.endsWith(".js") ? specifier : `${specifier}.js`
-      return defaultResolve(retried, context, defaultResolve)
-    }
-    throw error
-  }
-}
-
-function shouldRetry(specifier: string, error: any) {
-  if (!error || error.code !== "ERR_MODULE_NOT_FOUND") {
-    return false
-  }
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return true
-  }
-  return false
-}

package/src/logger.ts

@@ -1,133 +0,0 @@
-import { Transform } from "node:stream"
-import pino, { Logger as PinoLogger } from "pino"
-
-export type Logger = PinoLogger
-
-interface LoggerOptions {
-  level?: string
-  destination?: string
-  component?: string
-}
-
-const LEVEL_LABELS: Record<number, string> = {
-  10: "trace",
-  20: "debug",
-  30: "info",
-  40: "warn",
-  50: "error",
-  60: "fatal",
-}
-
-const LIFECYCLE_COMPONENTS = new Set(["app", "workspace"])
-const OMITTED_FIELDS = new Set(["time", "msg", "level", "component", "module"])
-
-export function createLogger(options: LoggerOptions = {}): Logger {
-  const level = (options.level ?? process.env.CLI_LOG_LEVEL ?? "info").toLowerCase()
-  const destination = options.destination ?? process.env.CLI_LOG_DESTINATION ?? "stdout"
-  const baseComponent = options.component ?? "app"
-  const loggerOptions = {
-    level,
-    base: { component: baseComponent },
-    timestamp: false,
-  } as const
-
-  if (destination && destination !== "stdout") {
-    const stream = pino.destination({ dest: destination, mkdir: true, sync: false })
-    return pino(loggerOptions, stream)
-  }
-
-  const lifecycleStream = new LifecycleLogStream({ restrictInfoToLifecycle: level === "info" })
-  lifecycleStream.pipe(process.stdout)
-  return pino(loggerOptions, lifecycleStream)
-}
-
-interface LifecycleStreamOptions {
-  restrictInfoToLifecycle: boolean
-}
-
-class LifecycleLogStream extends Transform {
-  private buffer = ""
-
-  constructor(private readonly options: LifecycleStreamOptions) {
-    super()
-  }
-
-  _transform(chunk: Buffer, _encoding: BufferEncoding, callback: () => void) {
-    this.buffer += chunk.toString()
-    let newlineIndex = this.buffer.indexOf("\n")
-    while (newlineIndex >= 0) {
-      const line = this.buffer.slice(0, newlineIndex)
-      this.buffer = this.buffer.slice(newlineIndex + 1)
-      this.pushFormatted(line)
-      newlineIndex = this.buffer.indexOf("\n")
-    }
-    callback()
-  }
-
-  _flush(callback: () => void) {
-    if (this.buffer.length > 0) {
-      this.pushFormatted(this.buffer)
-      this.buffer = ""
-    }
-    callback()
-  }
-
-  private pushFormatted(line: string) {
-    if (!line.trim()) {
-      return
-    }
-
-    let entry: Record<string, unknown>
-    try {
-      entry = JSON.parse(line)
-    } catch {
-      return
-    }
-
-    const levelNumber = typeof entry.level === "number" ? entry.level : 30
-    const levelLabel = LEVEL_LABELS[levelNumber] ?? "info"
-    const component = (entry.component as string | undefined) ?? (entry.module as string | undefined) ?? "app"
-
-    if (this.options.restrictInfoToLifecycle && levelNumber <= 30 && !LIFECYCLE_COMPONENTS.has(component)) {
-      return
-    }
-
-    const message = typeof entry.msg === "string" ? entry.msg : ""
-    const metadata = this.formatMetadata(entry)
-    const formatted = metadata.length > 0 ? `[${levelLabel.toUpperCase()}] [${component}] ${message} ${metadata}` : `[${levelLabel.toUpperCase()}] [${component}] ${message}`
-    this.push(`${formatted}\n`)
-  }
-
-  private formatMetadata(entry: Record<string, unknown>): string {
-    const pairs: string[] = []
-    for (const [key, value] of Object.entries(entry)) {
-      if (OMITTED_FIELDS.has(key)) {
-        continue
-      }
-
-      if (key === "err" && value && typeof value === "object") {
-        const err = value as { type?: string; message?: string; stack?: string }
-        const errLabel = err.type ?? "Error"
-        const errMessage = err.message ? `: ${err.message}` : ""
-        pairs.push(`err=${errLabel}${errMessage}`)
-        if (err.stack) {
-          pairs.push(`stack="${err.stack}"`)
-        }
-        continue
-      }
-
-      pairs.push(`${key}=${this.stringifyValue(value)}`)
-    }
-
-    return pairs.join(" ").trim()
-  }
-
-  private stringifyValue(value: unknown): string {
-    if (value === undefined) return "undefined"
-    if (value === null) return "null"
-    if (typeof value === "string") return value
-    if (typeof value === "number" || typeof value === "boolean") return String(value)
-    if (value instanceof Error) return value.message ?? value.name
-    return JSON.stringify(value)
-  }
-}

package/src/opencode-config.ts

@@ -1,31 +0,0 @@
-import { existsSync } from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-import { createLogger } from "./logger"
-
-const log = createLogger({ component: "opencode-config" })
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const devTemplateDir = path.resolve(__dirname, "../../opencode-config")
-const resourcesPath = (process as NodeJS.Process & { resourcesPath?: string }).resourcesPath
-const prodTemplateDirs = [
-  resourcesPath ? path.resolve(resourcesPath, "opencode-config") : undefined,
-  path.resolve(__dirname, "opencode-config"),
-].filter((dir): dir is string => Boolean(dir))
-
-const isDevBuild = Boolean(process.env.CODENOMAD_DEV ?? process.env.CLI_UI_DEV_SERVER) || existsSync(devTemplateDir)
-const templateDir = isDevBuild
-  ? devTemplateDir
-  : prodTemplateDirs.find((dir) => existsSync(dir)) ?? prodTemplateDirs[0]
-
-export function getOpencodeConfigDir(): string {
-  if (!existsSync(templateDir)) {
-    throw new Error(`CodeNomad Opencode config template missing at ${templateDir}`)
-  }
-
-  if (isDevBuild) {
-    log.debug({ templateDir }, "Using Opencode config template directly (dev mode)")
-  }
-
-  return templateDir
-}

package/src/plugins/channel.ts

@@ -1,55 +0,0 @@
-import type { FastifyReply } from "fastify"
-import type { Logger } from "../logger"
-
-export interface PluginOutboundEvent {
-  type: string
-  properties?: Record<string, unknown>
-}
-
-interface ClientConnection {
-  reply: FastifyReply
-  workspaceId: string
-}
-
-export class PluginChannelManager {
-  private readonly clients = new Set<ClientConnection>()
-
-  constructor(private readonly logger: Logger) {}
-
-  register(workspaceId: string, reply: FastifyReply) {
-    const connection: ClientConnection = { workspaceId, reply }
-    this.clients.add(connection)
-    this.logger.debug({ workspaceId }, "Plugin SSE client connected")
-
-    let closed = false
-    const close = () => {
-      if (closed) return
-      closed = true
-      this.clients.delete(connection)
-      this.logger.debug({ workspaceId }, "Plugin SSE client disconnected")
-    }
-
-    return { close }
-  }
-
-  send(workspaceId: string, event: PluginOutboundEvent) {
-    for (const client of this.clients) {
-      if (client.workspaceId !== workspaceId) continue
-      this.write(client.reply, event)
-    }
-  }
-
-  broadcast(event: PluginOutboundEvent) {
-    for (const client of this.clients) {
-      this.write(client.reply, event)
-    }
-  }
-
-  private write(reply: FastifyReply, event: PluginOutboundEvent) {
-    try {
-      reply.raw.write(`data: ${JSON.stringify(event)}\n\n`)
-    } catch (error) {
-      this.logger.warn({ err: error }, "Failed to write plugin SSE event")
-    }
-  }
-}

package/src/plugins/handlers.ts

@@ -1,36 +0,0 @@
-import type { EventBus } from "../events/bus"
-import type { WorkspaceManager } from "../workspaces/manager"
-import type { Logger } from "../logger"
-import type { PluginOutboundEvent } from "./channel"
-
-export interface PluginInboundEvent {
-  type: string
-  properties?: Record<string, unknown>
-}
-
-interface HandlerDeps {
-  workspaceManager: WorkspaceManager
-  eventBus: EventBus
-  logger: Logger
-}
-
-export function handlePluginEvent(workspaceId: string, event: PluginInboundEvent, deps: HandlerDeps) {
-  switch (event.type) {
-    case "codenomad.pong":
-      deps.logger.debug({ workspaceId, properties: event.properties }, "Plugin pong received")
-      return
-
-    default:
-      deps.logger.debug({ workspaceId, eventType: event.type }, "Unhandled plugin event")
-  }
-}
-
-export function buildPingEvent(): PluginOutboundEvent {
-
-  return {
-    type: "codenomad.ping",
-    properties: {
-      ts: Date.now(),
-    },
-  }
-}

package/src/releases/dev-release-monitor.ts

@@ -1,118 +0,0 @@
-import { fetch } from "undici"
-import type { LatestReleaseInfo } from "../api-types"
-import type { Logger } from "../logger"
-import { compareVersionStrings, stripTagPrefix } from "./release-monitor"
-
-interface DevReleaseMonitorOptions {
-  /** Current running server version (from package.json). */
-  currentVersion: string
-  /** GitHub repo in the form "owner/name". */
-  repo: string
-  logger: Logger
-  onUpdate: (release: LatestReleaseInfo | null) => void
-  pollIntervalMs?: number
-}
-
-interface GithubReleaseListItem {
-  tag_name?: string
-  name?: string
-  html_url?: string
-  body?: string
-  published_at?: string
-  created_at?: string
-  prerelease?: boolean
-  draft?: boolean
-}
-
-export interface DevReleaseMonitor {
-  stop(): void
-}
-
-const DEFAULT_POLL_INTERVAL_MS = 15 * 60 * 1000
-
-export function startDevReleaseMonitor(options: DevReleaseMonitorOptions): DevReleaseMonitor {
-  let stopped = false
-  let timer: ReturnType<typeof setInterval> | null = null
-
-  const pollIntervalMs =
-    Number.isFinite(options.pollIntervalMs) && (options.pollIntervalMs ?? 0) > 0
-      ? (options.pollIntervalMs as number)
-      : DEFAULT_POLL_INTERVAL_MS
-
-  const refresh = async () => {
-    if (stopped) return
-    try {
-      const release = await fetchLatestPrerelease({
-        repo: options.repo,
-        currentVersion: options.currentVersion,
-      })
-      options.onUpdate(release)
-    } catch (error) {
-      options.logger.debug({ err: error }, "Failed to refresh dev prerelease information")
-    }
-  }
-
-  void refresh()
-  timer = setInterval(() => void refresh(), pollIntervalMs)
-
-  return {
-    stop() {
-      stopped = true
-      if (timer) {
-        clearInterval(timer)
-        timer = null
-      }
-    },
-  }
-}
-
-async function fetchLatestPrerelease(args: {
-  repo: string
-  currentVersion: string
-}): Promise<LatestReleaseInfo | null> {
-  const normalizedRepo = args.repo.trim()
-  if (!/^[^/\s]+\/[^/\s]+$/.test(normalizedRepo)) {
-    throw new Error(`Invalid GitHub repo: ${args.repo}`)
-  }
-
-  const apiUrl = `https://api.github.com/repos/${normalizedRepo}/releases?per_page=20`
-  const response = await fetch(apiUrl, {
-    headers: {
-      Accept: "application/vnd.github+json",
-      "User-Agent": "CodeNomad-CLI",
-    },
-  })
-
-  if (!response.ok) {
-    throw new Error(`GitHub releases API responded with ${response.status}`)
-  }
-
-  const list = (await response.json()) as GithubReleaseListItem[]
-  const latest = list.find((r) => r && r.prerelease === true && r.draft !== true)
-  if (!latest) {
-    return null
-  }
-
-  const tag = latest.tag_name || latest.name
-  if (!tag) {
-    return null
-  }
-
-  const normalizedVersion = stripTagPrefix(tag)
-  if (!normalizedVersion) {
-    return null
-  }
-
-  if (compareVersionStrings(normalizedVersion, args.currentVersion) <= 0) {
-    return null
-  }
-
-  return {
-    version: normalizedVersion,
-    tag,
-    url: latest.html_url ?? `https://github.com/${normalizedRepo}/releases/tag/${encodeURIComponent(tag)}`,
-    channel: "dev",
-    publishedAt: latest.published_at ?? latest.created_at,
-    notes: latest.body,
-  }
-}