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

package/dist/integrations/github/sanitize-webhook.js

@@ -1,42 +0,0 @@
-const KEEP_URL_KEYS = new Set(["html_url"]);
-function shouldDropKey(key) {
-    if (key === "installation")
-        return true;
-    if (key === "url")
-        return true;
-    if (key.endsWith("_url") && !KEEP_URL_KEYS.has(key))
-        return true;
-    return false;
-}
-function sanitizeValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => sanitizeValue(item));
-    }
-    if (!value || typeof value !== "object") {
-        return value;
-    }
-    const out = {};
-    for (const [key, raw] of Object.entries(value)) {
-        // Never modify body fields; this preserves user content.
-        if (key === "body") {
-            out[key] = raw;
-            continue;
-        }
-        if (shouldDropKey(key)) {
-            continue;
-        }
-        out[key] = sanitizeValue(raw);
-    }
-    return out;
-}
-export function sanitizeGitHubWebhookPayload(payload) {
-    // Deep clone first to drop prototypes/functions and ensure deterministic output.
-    let cloned;
-    try {
-        cloned = JSON.parse(JSON.stringify(payload));
-    }
-    catch {
-        cloned = payload;
-    }
-    return sanitizeValue(cloned);
-}

package/dist/integrations/github/webhook-verify.js

@@ -1,21 +0,0 @@
-import crypto from "crypto";
-export function verifyGitHubWebhookSignature(params) {
-    const secret = (params.secret ?? "").trim();
-    if (!secret)
-        return false;
-    const signature = (params.signatureHeader ?? "").trim();
-    if (!signature.startsWith("sha256="))
-        return false;
-    const expectedHex = crypto.createHmac("sha256", secret).update(params.body).digest("hex");
-    const expected = `sha256=${expectedHex}`;
-    try {
-        const a = Buffer.from(signature, "utf8");
-        const b = Buffer.from(expected, "utf8");
-        if (a.length !== b.length)
-            return false;
-        return crypto.timingSafeEqual(a, b);
-    }
-    catch {
-        return false;
-    }
-}

package/dist/integrations/github/workspace-context.js

@@ -1,10 +0,0 @@
-const workspaceContext = new Map();
-export function setGitHubWorkspaceContext(workspaceId, context) {
-    workspaceContext.set(workspaceId, context);
-}
-export function getGitHubWorkspaceContext(workspaceId) {
-    return workspaceContext.get(workspaceId) ?? null;
-}
-export function clearGitHubWorkspaceContext(workspaceId) {
-    workspaceContext.delete(workspaceId);
-}

package/dist/integrations/github/worktree-context.js

@@ -1,15 +0,0 @@
-const worktreeContextByWorkspace = new Map();
-export function setGitHubWorktreeContext(workspaceId, worktreeSlug, context) {
-    let map = worktreeContextByWorkspace.get(workspaceId);
-    if (!map) {
-        map = new Map();
-        worktreeContextByWorkspace.set(workspaceId, map);
-    }
-    map.set(worktreeSlug, context);
-}
-export function getGitHubWorktreeContext(workspaceId, worktreeSlug) {
-    return worktreeContextByWorkspace.get(workspaceId)?.get(worktreeSlug) ?? null;
-}
-export function clearGitHubWorktreeContext(workspaceId) {
-    worktreeContextByWorkspace.delete(workspaceId);
-}

package/dist/opencode/request-context.js

@@ -1,39 +0,0 @@
-import { isValidWorktreeSlug } from "../workspaces/git-worktrees";
-import { resolveWorktreeDirectory } from "./worktree-directory";
-const INSTANCE_PROXY_HOST = "127.0.0.1";
-export async function buildOpencodeRequestContext(params) {
-    const workspace = params.workspaceManager.get(params.workspaceId);
-    if (!workspace) {
-        throw new Error("Workspace not found");
-    }
-    const port = params.workspaceManager.getInstancePort(params.workspaceId);
-    if (!port) {
-        throw new Error("Workspace instance is not ready");
-    }
-    if (!isValidWorktreeSlug(params.worktreeSlug)) {
-        throw new Error("Invalid worktree slug");
-    }
-    const directory = await resolveWorktreeDirectory({
-        workspaceId: params.workspaceId,
-        workspacePath: workspace.path,
-        worktreeSlug: params.worktreeSlug,
-        logger: params.logger,
-    });
-    if (!directory) {
-        throw new Error("Worktree not found");
-    }
-    const instanceAuthHeader = params.workspaceManager.getInstanceAuthorizationHeader(params.workspaceId);
-    const isNonASCII = /[^\x00-\x7F]/.test(directory);
-    const encodedDirectory = isNonASCII ? encodeURIComponent(directory) : directory;
-    const headers = {
-        "x-opencode-directory": encodedDirectory,
-    };
-    if (instanceAuthHeader) {
-        headers.authorization = instanceAuthHeader;
-    }
-    return {
-        baseUrl: `http://${INSTANCE_PROXY_HOST}:${port}`,
-        directory,
-        headers,
-    };
-}

package/dist/opencode/worktree-directory.js

@@ -1,42 +0,0 @@
-import { resolveRepoRoot, listWorktrees } from "../workspaces/git-worktrees";
-const WORKTREE_CACHE_TTL_MS = 2000;
-const worktreeCache = new Map();
-async function getCachedWorktrees(params) {
-    const cached = worktreeCache.get(params.workspaceId);
-    const now = Date.now();
-    if (cached && cached.expiresAt > now) {
-        return cached;
-    }
-    const { repoRoot } = await resolveRepoRoot(params.workspacePath, params.logger);
-    const worktrees = await listWorktrees({ repoRoot, workspaceFolder: params.workspacePath, logger: params.logger });
-    const entry = {
-        expiresAt: now + WORKTREE_CACHE_TTL_MS,
-        repoRoot,
-        worktrees: worktrees.map((wt) => ({ slug: wt.slug, directory: wt.directory })),
-    };
-    worktreeCache.set(params.workspaceId, entry);
-    return entry;
-}
-export async function resolveWorktreeDirectory(params) {
-    const { worktreeSlug } = params;
-    const cached = await getCachedWorktrees({
-        workspaceId: params.workspaceId,
-        workspacePath: params.workspacePath,
-        logger: params.logger,
-    });
-    const match = cached.worktrees.find((wt) => wt.slug === worktreeSlug);
-    if (match) {
-        return match.directory;
-    }
-    // If the slug is new (e.g., created moments ago), refresh once.
-    worktreeCache.delete(params.workspaceId);
-    const refreshed = await getCachedWorktrees({
-        workspaceId: params.workspaceId,
-        workspacePath: params.workspacePath,
-        logger: params.logger,
-    });
-    return refreshed.worktrees.find((wt) => wt.slug === worktreeSlug)?.directory ?? null;
-}
-export function clearWorktreeDirectoryCache(workspaceId) {
-    worktreeCache.delete(workspaceId);
-}

package/dist/opencode-config-template/README.md

@@ -1,32 +0,0 @@
-# opencode-config
-
-## TLDR
-Template config + plugins injected into every OpenCode instance that CodeNomad launches. It provides a CodeNomad bridge plugin for local event exchange between the CLI server and opencode.
-
-## What it is
-A packaged config directory that CodeNomad copies into `~/.config/codenomad/opencode-config` for production builds or uses directly in dev. OpenCode autoloads any `plugin/*.ts` or `plugin/*.js` from this directory.
-
-## How it works
-- CodeNomad sets `OPENCODE_CONFIG_DIR` when spawning each opencode instance (`packages/server/src/workspaces/manager.ts`).
-- This template is synced from `packages/opencode-config` (`packages/server/src/opencode-config.ts`, `packages/server/scripts/copy-opencode-config.mjs`).
-- OpenCode autoloads plugins from `plugin/` (`packages/opencode-config/plugin/codenomad.ts`).
-- The `CodeNomadPlugin` reads `CODENOMAD_INSTANCE_ID` + `CODENOMAD_BASE_URL`, connects to `GET /workspaces/:id/plugin/events`, and posts to `POST /workspaces/:id/plugin/event` (`packages/opencode-config/plugin/lib/client.ts`).
-- The server exposes the plugin routes and maps events into the UI SSE pipeline (`packages/server/src/server/routes/plugin.ts`, `packages/server/src/plugins/handlers.ts`).
-
-## Expectations
-- Local-only bridge (no auth/token yet).
-- Plugin must fail startup if it cannot connect after 3 retries.
-- Keep plugin entrypoints thin; put shared logic under `plugin/lib/` to avoid autoloaded helpers.
-- Keep event shapes small and explicit; use `type` + `properties` only.
-
-## Ideas
-- Add feature modules under `plugin/lib/features/` (tool lifecycle, permission prompts, custom commands).
-- Expand `/workspaces/:id/plugin/*` with dedicated endpoints as needed.
-- Promote stable event shapes and version tags once the protocol settles.
-
-## Pointers
-- Plugin entry: `packages/opencode-config/plugin/codenomad.ts`
-- Plugin client: `packages/opencode-config/plugin/lib/client.ts`
-- Plugin server routes: `packages/server/src/server/routes/plugin.ts`
-- Plugin event handling: `packages/server/src/plugins/handlers.ts`
-- Workspace env injection: `packages/server/src/workspaces/manager.ts`

package/dist/opencode-config-template/opencode.jsonc

@@ -1,3 +0,0 @@
-{
-  "$schema": "https://opencode.ai/config.json"
-}

package/dist/opencode-config-template/plugin/codenomad.ts

@@ -1,40 +0,0 @@
-import { createCodeNomadClient, getCodeNomadConfig } from "./lib/client"
-import { createBackgroundProcessTools } from "./lib/background-process"
-
-export async function CodeNomadPlugin() {
-  const config = getCodeNomadConfig()
-  const client = createCodeNomadClient(config)
-  const backgroundProcessTools = createBackgroundProcessTools(config)
-
-  await client.startEvents((event) => {
-    if (event.type === "codenomad.ping") {
-      void client.postEvent({
-        type: "codenomad.pong",
-        properties: {
-          ts: Date.now(),
-          pingTs: (event.properties as any)?.ts,
-        },
-      }).catch(() => {})
-    }
-  })
-
-  return {
-    tool: {
-      ...backgroundProcessTools,
-    },
-    async event(input: { event: any }) {
-      const opencodeEvent = input?.event
-      if (!opencodeEvent || typeof opencodeEvent !== "object") return
-
-      if (opencodeEvent.type === "session.idle") {
-        const sessionID = (opencodeEvent as any).properties?.sessionID
-        void client.postEvent({
-          type: "opencode.session.idle",
-          properties: {
-            sessionID,
-          },
-        }).catch(() => {})
-      }
-    },
-  }
-}

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

@@ -1,160 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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
-  }
-}