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

package/dist/opencode-config-template/plugin/lib/background-process.ts

@@ -0,0 +1,160 @@
+import { tool } from "@opencode-ai/plugin/tool"
+
+type BackgroundProcess = {
+  id: string
+  title: string
+  command: string
+  status: "running" | "stopped" | "error"
+  startedAt: string
+  stoppedAt?: string
+  exitCode?: number
+  outputSizeBytes?: number
+}
+
+type CodeNomadConfig = {
+  instanceId: string
+  baseUrl: string
+}
+
+export function createBackgroundProcessTools(config: CodeNomadConfig) {
+  const request = async <T>(path: string, init?: RequestInit): Promise<T> => {
+
+    const base = config.baseUrl.replace(/\/+$/, "")
+    const url = `${base}/workspaces/${config.instanceId}/plugin/background-processes${path}`
+    const headers = normalizeHeaders(init?.headers)
+    if (init?.body !== undefined) {
+      headers["Content-Type"] = "application/json"
+    }
+
+    const response = await fetch(url, {
+      ...init,
+      headers,
+    })
+
+    if (!response.ok) {
+      const message = await response.text()
+      throw new Error(message || `Request failed with ${response.status}`)
+    }
+
+    if (response.status === 204) {
+      return undefined as T
+    }
+
+    return (await response.json()) as T
+  }
+
+  return {
+    run_background_process: tool({
+      description:
+        "Run a long-lived background process (dev servers, DBs, watchers) so it keeps running while you do other tasks. Use it for running processes that timeout otherwise or produce a lot of output.",
+      args: {
+        title: tool.schema.string().describe("Short label for the process (e.g. Dev server, DB server)"),
+        command: tool.schema.string().describe("Shell command to run in the workspace"),
+      },
+      async execute(args) {
+        const process = await request<BackgroundProcess>("", {
+          method: "POST",
+          body: JSON.stringify({ title: args.title, command: args.command }),
+        })
+
+        return `Started background process ${process.id} (${process.title})\nStatus: ${process.status}\nCommand: ${process.command}`
+      },
+    }),
+    list_background_processes: tool({
+      description: "List background processes running for this workspace.",
+      args: {},
+      async execute() {
+        const response = await request<{ processes: BackgroundProcess[] }>("")
+        if (response.processes.length === 0) {
+          return "No background processes running."
+        }
+
+        return response.processes
+          .map((process) => {
+            const status = process.status === "running" ? "running" : process.status
+            const exit = process.exitCode !== undefined ? ` (exit ${process.exitCode})` : ""
+            const size =
+              typeof process.outputSizeBytes === "number" ? ` | ${Math.round(process.outputSizeBytes / 1024)}KB` : ""
+            return `- ${process.id} | ${process.title} | ${status}${exit}${size}\n  ${process.command}`
+          })
+          .join("\n")
+      },
+    }),
+    read_background_process_output: tool({
+      description: "Read output from a background process. Use full, grep, head, or tail.",
+      args: {
+        id: tool.schema.string().describe("Background process ID"),
+        method: tool.schema
+          .enum(["full", "grep", "head", "tail"])
+          .default("full")
+          .describe("Method to read output"),
+        pattern: tool.schema.string().optional().describe("Pattern for grep method"),
+        lines: tool.schema.number().optional().describe("Number of lines for head/tail methods"),
+      },
+      async execute(args) {
+        if (args.method === "grep" && !args.pattern) {
+          return "Pattern is required for grep method."
+        }
+
+        const params = new URLSearchParams({ method: args.method })
+        if (args.pattern) {
+          params.set("pattern", args.pattern)
+        }
+        if (args.lines) {
+          params.set("lines", String(args.lines))
+        }
+
+        const response = await request<{ id: string; content: string; truncated: boolean; sizeBytes: number }>(
+          `/${args.id}/output?${params.toString()}`,
+        )
+
+        const header = response.truncated
+          ? `Output (truncated, ${Math.round(response.sizeBytes / 1024)}KB):`
+          : `Output (${Math.round(response.sizeBytes / 1024)}KB):`
+
+        return `${header}\n\n${response.content}`
+      },
+    }),
+    stop_background_process: tool({
+      description: "Stop a background process (SIGTERM) but keep its output and entry.",
+      args: {
+        id: tool.schema.string().describe("Background process ID"),
+      },
+      async execute(args) {
+        const process = await request<BackgroundProcess>(`/${args.id}/stop`, { method: "POST" })
+        return `Stopped background process ${process.id} (${process.title}). Status: ${process.status}`
+      },
+    }),
+    terminate_background_process: tool({
+      description: "Terminate a background process and delete its output + entry.",
+      args: {
+        id: tool.schema.string().describe("Background process ID"),
+      },
+      async execute(args) {
+        await request<void>(`/${args.id}/terminate`, { method: "POST" })
+        return `Terminated background process ${args.id} and removed its output.`
+      },
+    }),
+  }
+}
+
+function normalizeHeaders(headers: HeadersInit | undefined): Record<string, string> {
+  const output: Record<string, string> = {}
+  if (!headers) return output
+
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      output[key] = value
+    })
+    return output
+  }
+
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      output[key] = value
+    }
+    return output
+  }
+
+  return { ...headers }
+}

package/dist/opencode-config-template/plugin/lib/client.ts

@@ -0,0 +1,165 @@
+export type PluginEvent = {
+  type: string
+  properties?: Record<string, unknown>
+}
+
+export type CodeNomadConfig = {
+  instanceId: string
+  baseUrl: string
+}
+
+export function getCodeNomadConfig(): CodeNomadConfig {
+  return {
+    instanceId: requireEnv("CODENOMAD_INSTANCE_ID"),
+    baseUrl: requireEnv("CODENOMAD_BASE_URL"),
+  }
+}
+
+export function createCodeNomadClient(config: CodeNomadConfig) {
+  return {
+    postEvent: (event: PluginEvent) => postPluginEvent(config.baseUrl, config.instanceId, event),
+    startEvents: (onEvent: (event: PluginEvent) => void) => startPluginEvents(config.baseUrl, config.instanceId, onEvent),
+  }
+}
+
+function requireEnv(key: string): string {
+  const value = process.env[key]
+  if (!value || !value.trim()) {
+    throw new Error(`[CodeNomadPlugin] Missing required env var ${key}`)
+  }
+  return value
+}
+
+function delay(ms: number) {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms))
+}
+
+async function postPluginEvent(baseUrl: string, instanceId: string, event: PluginEvent) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/workspaces/${instanceId}/plugin/event`
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(event),
+  })
+
+  if (!response.ok) {
+    throw new Error(`[CodeNomadPlugin] POST ${url} failed (${response.status})`)
+  }
+}
+
+async function startPluginEvents(baseUrl: string, instanceId: string, onEvent: (event: PluginEvent) => void) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/workspaces/${instanceId}/plugin/events`
+
+  // Fail plugin startup if we cannot establish the initial connection.
+  const initialBody = await connectWithRetries(url, 3)
+
+  // After startup, keep reconnecting; throw after 3 consecutive failures.
+  void consumeWithReconnect(url, onEvent, initialBody)
+}
+
+async function connectWithRetries(url: string, maxAttempts: number) {
+  let lastError: unknown
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const response = await fetch(url, { headers: { Accept: "text/event-stream" } })
+      if (!response.ok || !response.body) {
+        throw new Error(`[CodeNomadPlugin] SSE unavailable (${response.status})`)
+      }
+      return response.body
+    } catch (error) {
+      lastError = error
+      await delay(500 * attempt)
+    }
+  }
+
+  const reason = lastError instanceof Error ? lastError.message : String(lastError)
+  throw new Error(`[CodeNomadPlugin] Failed to connect to CodeNomad after ${maxAttempts} retries: ${reason}`)
+}
+
+async function consumeWithReconnect(
+  url: string,
+  onEvent: (event: PluginEvent) => void,
+  initialBody: ReadableStream<Uint8Array>,
+) {
+  let consecutiveFailures = 0
+  let body: ReadableStream<Uint8Array> | null = initialBody
+
+  while (true) {
+    try {
+      if (!body) {
+        body = await connectWithRetries(url, 3)
+      }
+
+      await consumeSseBody(body, onEvent)
+      body = null
+      consecutiveFailures = 0
+    } catch (error) {
+      body = null
+      consecutiveFailures += 1
+      if (consecutiveFailures >= 3) {
+        const reason = error instanceof Error ? error.message : String(error)
+        throw new Error(`[CodeNomadPlugin] Plugin event stream failed after 3 retries: ${reason}`)
+      }
+      await delay(500 * consecutiveFailures)
+    }
+  }
+}
+
+async function consumeSseBody(body: ReadableStream<Uint8Array>, onEvent: (event: PluginEvent) => void) {
+  const reader = body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ""
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done || !value) {
+      break
+    }
+
+    buffer += decoder.decode(value, { stream: true })
+
+    let separatorIndex = buffer.indexOf("\n\n")
+    while (separatorIndex >= 0) {
+      const chunk = buffer.slice(0, separatorIndex)
+      buffer = buffer.slice(separatorIndex + 2)
+      separatorIndex = buffer.indexOf("\n\n")
+
+      const event = parseSseChunk(chunk)
+      if (event) {
+        onEvent(event)
+      }
+    }
+  }
+
+  throw new Error("SSE stream ended")
+}
+
+function parseSseChunk(chunk: string): PluginEvent | null {
+  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 null
+
+  const payload = dataLines.join("\n").trim()
+  if (!payload) return null
+
+  try {
+    const parsed = JSON.parse(payload)
+    if (!parsed || typeof parsed !== "object" || typeof (parsed as any).type !== "string") {
+      return null
+    }
+    return parsed as PluginEvent
+  } catch {
+    return null
+  }
+}

package/dist/opencode-config.js

@@ -0,0 +1,26 @@
+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.resourcesPath;
+const prodTemplateDirs = [
+    resourcesPath ? path.resolve(resourcesPath, "opencode-config") : undefined,
+    path.resolve(__dirname, "opencode-config"),
+].filter((dir) => 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() {
+    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/dist/plugins/channel.js

@@ -0,0 +1,40 @@
+export class PluginChannelManager {
+    constructor(logger) {
+        this.logger = logger;
+        this.clients = new Set();
+    }
+    register(workspaceId, reply) {
+        const connection = { 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, event) {
+        for (const client of this.clients) {
+            if (client.workspaceId !== workspaceId)
+                continue;
+            this.write(client.reply, event);
+        }
+    }
+    broadcast(event) {
+        for (const client of this.clients) {
+            this.write(client.reply, event);
+        }
+    }
+    write(reply, event) {
+        try {
+            reply.raw.write(`data: ${JSON.stringify(event)}\n\n`);
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to write plugin SSE event");
+        }
+    }
+}

package/dist/plugins/handlers.js

@@ -0,0 +1,17 @@
+export function handlePluginEvent(workspaceId, event, deps) {
+    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() {
+    return {
+        type: "codenomad.ping",
+        properties: {
+            ts: Date.now(),
+        },
+    };
+}

package/dist/releases/dev-release-monitor.js

@@ -0,0 +1,75 @@
+import { fetch } from "undici";
+import { compareVersionStrings, stripTagPrefix } from "./release-monitor";
+const DEFAULT_POLL_INTERVAL_MS = 15 * 60 * 1000;
+export function startDevReleaseMonitor(options) {
+    let stopped = false;
+    let timer = null;
+    const pollIntervalMs = Number.isFinite(options.pollIntervalMs) && (options.pollIntervalMs ?? 0) > 0
+        ? options.pollIntervalMs
+        : 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) {
+    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());
+    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,
+    };
+}

package/dist/releases/release-monitor.js

@@ -0,0 +1,107 @@
+import { fetch } from "undici";
+const RELEASES_API_URL = "https://api.github.com/repos/NeuralNomadsAI/CodeNomad/releases/latest";
+export function startReleaseMonitor(options) {
+    let stopped = false;
+    const refreshRelease = async () => {
+        if (stopped)
+            return;
+        try {
+            const release = await fetchLatestRelease(options);
+            options.onUpdate(release);
+        }
+        catch (error) {
+            options.logger.warn({ err: error }, "Failed to refresh release information");
+        }
+    };
+    void refreshRelease();
+    return {
+        stop() {
+            stopped = true;
+        },
+    };
+}
+export function compareVersionStrings(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    return compareVersions(left, right);
+}
+async function fetchLatestRelease(options) {
+    const response = await fetch(RELEASES_API_URL, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "CodeNomad-CLI",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Release API responded with ${response.status}`);
+    }
+    const json = (await response.json());
+    const tagFromServer = json.tag_name || json.name;
+    if (!tagFromServer) {
+        return null;
+    }
+    const normalizedVersion = stripTagPrefix(tagFromServer);
+    if (!normalizedVersion) {
+        return null;
+    }
+    const current = parseVersion(options.currentVersion);
+    const remote = parseVersion(normalizedVersion);
+    if (compareVersions(remote, current) <= 0) {
+        return null;
+    }
+    return {
+        version: normalizedVersion,
+        tag: tagFromServer,
+        url: json.html_url ?? `https://github.com/NeuralNomadsAI/CodeNomad/releases/tag/${encodeURIComponent(tagFromServer)}`,
+        channel: json.prerelease || normalizedVersion.includes("-") ? "dev" : "stable",
+        publishedAt: json.published_at ?? json.created_at,
+        notes: json.body,
+    };
+}
+export function stripTagPrefix(tag) {
+    if (!tag)
+        return null;
+    const trimmed = tag.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.replace(/^v/i, "");
+}
+function parseVersion(value) {
+    const normalized = stripTagPrefix(value) ?? "0.0.0";
+    const dashIndex = normalized.indexOf("-");
+    const core = dashIndex >= 0 ? normalized.slice(0, dashIndex) : normalized;
+    const prerelease = dashIndex >= 0 ? normalized.slice(dashIndex + 1) : null;
+    const [major = 0, minor = 0, patch = 0] = core.split(".").map((segment) => {
+        const parsed = Number.parseInt(segment, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    return {
+        major,
+        minor,
+        patch,
+        prerelease,
+    };
+}
+function compareVersions(a, b) {
+    if (a.major !== b.major) {
+        return a.major > b.major ? 1 : -1;
+    }
+    if (a.minor !== b.minor) {
+        return a.minor > b.minor ? 1 : -1;
+    }
+    if (a.patch !== b.patch) {
+        return a.patch > b.patch ? 1 : -1;
+    }
+    const aPre = a.prerelease && a.prerelease.length > 0 ? a.prerelease : null;
+    const bPre = b.prerelease && b.prerelease.length > 0 ? b.prerelease : null;
+    if (aPre === bPre) {
+        return 0;
+    }
+    if (!aPre) {
+        return 1;
+    }
+    if (!bPre) {
+        return -1;
+    }
+    return aPre.localeCompare(bPre);
+}