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

package/dist/server/routes/github-plugin.js

@@ -1,215 +0,0 @@
-import path from "path";
-import { z } from "zod";
-import { getGitHubWorkspaceContext } from "../../integrations/github/workspace-context";
-import { getGitHubWorktreeContext } from "../../integrations/github/worktree-context";
-import { createInstallationOctokit, getInstallationToken } from "../../integrations/github/octokit";
-import { gitCurrentBranch, gitIsClean, gitPushHead } from "../../integrations/github/git-ops";
-import { listWorktrees, resolveRepoRoot } from "../../workspaces/git-worktrees";
-import { sanitizeGitHubWebhookPayload } from "../../integrations/github/sanitize-webhook";
-import { appendCodeNomadBotSignature } from "../../integrations/github/bot-signature";
-const AddReactionSchema = z.object({
-    op: z.literal("add_reaction"),
-    commentId: z.number().int().positive(),
-    content: z.enum(["eyes", "rocket", "+1", "-1", "laugh", "confused", "heart", "hooray"]),
-});
-const PostIssueCommentSchema = z.object({
-    op: z.literal("post_issue_comment"),
-    issueNumber: z.number().int().positive(),
-    body: z.string().min(1),
-});
-const PublishPrSchema = z.object({
-    op: z.literal("publish_pr"),
-    directory: z.string().min(1),
-    title: z.string().min(1),
-    body: z.string().optional(),
-    base: z.string().optional(),
-    draft: z.boolean().optional(),
-});
-const ListIssueCommentsSchema = z.object({
-    op: z.literal("list_issue_comments"),
-    issueNumber: z.number().int().positive(),
-});
-const GitHubToolSchema = z.discriminatedUnion("op", [
-    AddReactionSchema,
-    PostIssueCommentSchema,
-    PublishPrSchema,
-    ListIssueCommentsSchema,
-]);
-export function registerGitHubPluginRoutes(app, deps) {
-    app.post("/workspaces/:id/plugin/integrations/github", async (request, reply) => {
-        const workspaceId = request.params.id;
-        const workspace = deps.workspaceManager.get(workspaceId);
-        if (!workspace) {
-            reply.code(404);
-            return { error: "Workspace not found" };
-        }
-        const context = getGitHubWorkspaceContext(workspaceId);
-        if (!context) {
-            reply.code(400);
-            return { error: "Workspace is not configured for GitHub" };
-        }
-        const gh = deps.configStore.get().integrations?.github;
-        if (!gh?.enabled || !gh.appId || !gh.privateKeyPath) {
-            reply.code(400);
-            return { error: "GitHub integration is not configured" };
-        }
-        let parsed;
-        try {
-            parsed = GitHubToolSchema.parse(request.body ?? {});
-        }
-        catch (error) {
-            reply.code(400);
-            return { error: error instanceof Error ? error.message : "Invalid GitHub tool request" };
-        }
-        const installationId = context.installationId;
-        const token = await getInstallationToken({ appId: gh.appId, privateKeyPath: gh.privateKeyPath }, installationId);
-        const octokit = createInstallationOctokit({ appId: gh.appId, privateKeyPath: gh.privateKeyPath }, installationId);
-        const owner = context.owner;
-        const repo = context.repo;
-        const defaultBase = context.defaultBranch;
-        try {
-            if (parsed.op === "add_reaction") {
-                const reaction = await octokit.request("POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
-                    owner,
-                    repo,
-                    comment_id: parsed.commentId,
-                    content: parsed.content,
-                    headers: { accept: "application/vnd.github+json" },
-                });
-                return { ok: true, op: "add_reaction", data: sanitizeGitHubWebhookPayload(reaction.data) };
-            }
-            if (parsed.op === "post_issue_comment") {
-                const body = appendCodeNomadBotSignature(parsed.body);
-                const res = await octokit.request("POST /repos/{owner}/{repo}/issues/{issue_number}/comments", {
-                    owner,
-                    repo,
-                    issue_number: parsed.issueNumber,
-                    body,
-                });
-                return { ok: true, op: "post_issue_comment", url: res.data?.html_url, data: sanitizeGitHubWebhookPayload(res.data) };
-            }
-            if (parsed.op === "list_issue_comments") {
-                const all = [];
-                let page = 1;
-                const perPage = 100;
-                while (true) {
-                    const res = await octokit.request("GET /repos/{owner}/{repo}/issues/{issue_number}/comments", {
-                        owner,
-                        repo,
-                        issue_number: parsed.issueNumber,
-                        per_page: perPage,
-                        page,
-                    });
-                    const items = Array.isArray(res.data) ? res.data : [];
-                    for (const item of items) {
-                        all.push({
-                            id: item.id,
-                            html_url: item.html_url,
-                            user: {
-                                login: item?.user?.login,
-                                type: item?.user?.type,
-                            },
-                            created_at: item.created_at,
-                            updated_at: item.updated_at,
-                            body: item.body,
-                        });
-                    }
-                    if (items.length < perPage)
-                        break;
-                    page += 1;
-                    if (page > 50)
-                        break;
-                }
-                return { ok: true, op: "list_issue_comments", data: all };
-            }
-            if (parsed.op === "publish_pr") {
-                let base = parsed.base ?? defaultBase;
-                const absDir = path.resolve(parsed.directory);
-                const workspaceRoot = path.resolve(workspace.path);
-                const rel = path.relative(workspaceRoot, absDir);
-                if (rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel))) {
-                    // ok
-                }
-                else {
-                    reply.code(400);
-                    return { error: "Invalid directory" };
-                }
-                // If base isn't provided, prefer a worktree-specific default base for this run.
-                if (!parsed.base) {
-                    try {
-                        const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, deps.logger);
-                        if (isGitRepo) {
-                            const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: deps.logger });
-                            const match = worktrees.find((wt) => path.resolve(wt.directory) === absDir);
-                            if (match) {
-                                const ctx = getGitHubWorktreeContext(workspaceId, match.slug);
-                                if (ctx?.publishBase) {
-                                    base = ctx.publishBase;
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        // best-effort
-                    }
-                }
-                const branch = await gitCurrentBranch(absDir);
-                if (!branch) {
-                    reply.code(400);
-                    return { error: "No current branch" };
-                }
-                const clean = await gitIsClean(absDir);
-                if (!clean) {
-                    reply.code(400);
-                    return { error: "Working tree has uncommitted changes" };
-                }
-                await gitPushHead({ cwd: absDir, remoteUrl: context.repoUrl, branch, token });
-                let prUrl;
-                let prNumber;
-                let pr;
-                try {
-                    const created = await octokit.request("POST /repos/{owner}/{repo}/pulls", {
-                        owner,
-                        repo,
-                        title: parsed.title,
-                        body: parsed.body ? appendCodeNomadBotSignature(parsed.body) : undefined,
-                        head: branch,
-                        base,
-                        draft: parsed.draft ?? false,
-                    });
-                    prUrl = created.data?.html_url;
-                    prNumber = created.data?.number;
-                    pr = created.data;
-                }
-                catch (error) {
-                    // If a PR already exists for this head, surface the existing PR.
-                    const status = error?.status;
-                    if (status === 422) {
-                        const head = `${owner}:${branch}`;
-                        const existing = await octokit.request("GET /repos/{owner}/{repo}/pulls", {
-                            owner,
-                            repo,
-                            state: "open",
-                            head,
-                        });
-                        const first = Array.isArray(existing.data) ? existing.data[0] : null;
-                        prUrl = first?.html_url;
-                        prNumber = first?.number;
-                        pr = first;
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                return { ok: true, op: "publish_pr", branch, url: prUrl, number: prNumber, base, data: sanitizeGitHubWebhookPayload(pr) };
-            }
-            reply.code(400);
-            return { error: "Unknown operation" };
-        }
-        catch (error) {
-            deps.logger.error({ err: error, workspaceId, op: parsed?.op }, "GitHub tool call failed");
-            reply.code(500);
-            return { error: error instanceof Error ? error.message : "GitHub operation failed" };
-        }
-    });
-}

package/dist/server/routes/github-webhook.js

@@ -1,32 +0,0 @@
-import { GitHubJobRunner } from "../../integrations/github/job-runner";
-export function registerGitHubWebhookRoutes(app, deps) {
-    // Ensure info-level GitHub lifecycle logs are visible at CLI_LOG_LEVEL=info.
-    const log = deps.logger.child({ component: "app", module: "github" });
-    const runner = new GitHubJobRunner({
-        workspaceManager: deps.workspaceManager,
-        configStore: deps.configStore,
-        eventBus: deps.eventBus,
-        logger: log,
-    });
-    app.register(async (instance) => {
-        instance.addContentTypeParser("application/json", { parseAs: "buffer" }, (_req, body, done) => done(null, body));
-        instance.post("/integrations/github/webhook", async (request, reply) => {
-            const event = request.headers["x-github-event"] ?? "";
-            const delivery = request.headers["x-github-delivery"] ?? "";
-            const signature = request.headers["x-hub-signature-256"] ?? undefined;
-            const body = request.body;
-            if (!Buffer.isBuffer(body)) {
-                reply.code(400).type("text/plain").send("Expected raw JSON body");
-                return;
-            }
-            log.info({ event, deliveryId: delivery }, "GitHub webhook received");
-            runner.enqueue({
-                deliveryId: delivery,
-                event,
-                signature,
-                body,
-            });
-            reply.code(202).send({ ok: true });
-        });
-    });
-}

package/scripts/copy-auth-pages.mjs

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-import { cpSync, existsSync, mkdirSync, rmSync } from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const cliRoot = path.resolve(__dirname, "..")
-
-const sourceDir = path.resolve(cliRoot, "src/server/routes/auth-pages")
-const targetDir = path.resolve(cliRoot, "dist/server/routes/auth-pages")
-
-if (!existsSync(sourceDir)) {
-  console.error(`[copy-auth-pages] Missing auth pages at ${sourceDir}`)
-  process.exit(1)
-}
-
-rmSync(targetDir, { recursive: true, force: true })
-mkdirSync(targetDir, { recursive: true })
-cpSync(sourceDir, targetDir, { recursive: true })
-
-console.log(`[copy-auth-pages] Copied ${sourceDir} -> ${targetDir}`)

package/scripts/copy-opencode-config.mjs

@@ -1,61 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from "child_process"
-import { cpSync, existsSync, mkdirSync, rmSync } from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const cliRoot = path.resolve(__dirname, "..")
-const sourceDir = path.resolve(cliRoot, "../opencode-config")
-const targetDir = path.resolve(cliRoot, "dist/opencode-config")
-const nodeModulesDir = path.resolve(sourceDir, "node_modules")
-const selfLinkDir = path.resolve(nodeModulesDir, "@codenomad", "opencode-config")
-const npmExecPath = process.env.npm_execpath
-const npmNodeExecPath = process.env.npm_node_execpath
-
-if (!existsSync(sourceDir)) {
-  console.error(`[copy-opencode-config] Missing source directory at ${sourceDir}`)
-  process.exit(1)
-}
-
-if (!existsSync(nodeModulesDir)) {
-  console.log(`[copy-opencode-config] Installing opencode-config dependencies in ${sourceDir}`)
-
-  const npmArgs = [
-    "install",
-    "--prefix",
-    sourceDir,
-    "--omit=dev",
-    "--ignore-scripts",
-    "--fund=false",
-    "--audit=false",
-    "--package-lock=false",
-    "--workspaces=false",
-  ]
-
-  const env = { ...process.env, npm_config_workspaces: "false" }
-
-  const npmCli = npmExecPath && npmNodeExecPath ? [npmNodeExecPath, [npmExecPath, ...npmArgs]] : null
-  const result = npmCli
-    ? spawnSync(npmCli[0], npmCli[1], { cwd: sourceDir, stdio: "inherit", env })
-    : spawnSync("npm", npmArgs, { cwd: sourceDir, stdio: "inherit", env, shell: process.platform === "win32" })
-
-  if (result.status !== 0) {
-    if (result.error) {
-      console.error("[copy-opencode-config] npm install failed to start", result.error)
-    }
-    console.error("[copy-opencode-config] Failed to install opencode-config dependencies")
-    process.exit(result.status ?? 1)
-  }
-}
-
-// npm can create a self-referential link for scoped packages on Windows.
-// That link causes recursive copies (ELOOP) during bundling.
-rmSync(selfLinkDir, { recursive: true, force: true })
-
-rmSync(targetDir, { recursive: true, force: true })
-mkdirSync(path.dirname(targetDir), { recursive: true })
-cpSync(sourceDir, targetDir, { recursive: true })
-
-console.log(`[copy-opencode-config] Copied ${sourceDir} -> ${targetDir}`)

package/scripts/copy-ui-dist.mjs

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import { cpSync, existsSync, mkdirSync, rmSync } from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const cliRoot = path.resolve(__dirname, "..")
-const uiDistDir = path.resolve(cliRoot, "../ui/src/renderer/dist")
-const targetDir = path.resolve(cliRoot, "public")
-
-if (!existsSync(uiDistDir)) {
-  console.error(`[copy-ui-dist] Expected UI build artifacts at ${uiDistDir}. Run the UI build before bundling the CLI.`)
-  process.exit(1)
-}
-
-rmSync(targetDir, { recursive: true, force: true })
-mkdirSync(targetDir, { recursive: true })
-cpSync(uiDistDir, targetDir, { recursive: true })
-
-console.log(`[copy-ui-dist] Copied UI bundle from ${uiDistDir} -> ${targetDir}`)

package/src/api-types.ts

@@ -1,326 +0,0 @@
-import type {
-  AgentModelSelection,
-  AgentModelSelections,
-  ConfigFile,
-  ModelPreference,
-  OpenCodeBinary,
-  Preferences,
-  RecentFolder,
-} from "./config/schema"
-
-/**
- * Canonical HTTP/SSE contract for the CLI server.
- * These types are consumed by both the CLI implementation and any UI clients.
- */
-
-export type WorkspaceStatus = "starting" | "ready" | "stopped" | "error"
-
-export interface WorkspaceDescriptor {
-  id: string
-  /** Absolute path on the server host. */
-  path: string
-  name?: string
-  status: WorkspaceStatus
-  /** PID/port are populated when the workspace is running. */
-  pid?: number
-  port?: number
-  /** Canonical proxy path the CLI exposes for this instance. */
-  proxyPath: string
-  /** Identifier of the binary resolved from config. */
-  binaryId: string
-  binaryLabel: string
-  binaryVersion?: string
-  createdAt: string
-  updatedAt: string
-  /** Present when `status` is "error". */
-  error?: string
-}
-
-export interface WorkspaceCreateRequest {
-  path: string
-  name?: string
-}
-
-export type WorkspaceCreateResponse = WorkspaceDescriptor
-export type WorkspaceListResponse = WorkspaceDescriptor[]
-export type WorkspaceDetailResponse = WorkspaceDescriptor
-
-export interface WorkspaceDeleteResponse {
-  id: string
-  status: WorkspaceStatus
-}
-
-export type WorktreeKind = "root" | "worktree"
-
-export interface WorktreeDescriptor {
-  /** Stable identifier used by CodeNomad + clients ("root" for repo root). */
-  slug: string
-  /** Absolute directory path on the server host. */
-  directory: string
-  kind: WorktreeKind
-  /** Optional VCS branch name when available. */
-  branch?: string
-}
-
-export interface WorktreeListResponse {
-  worktrees: WorktreeDescriptor[]
-  /** True when the workspace folder resolves to a Git repository. */
-  isGitRepo?: boolean
-}
-
-export interface WorktreeCreateRequest {
-  slug: string
-  /** Optional branch name (defaults to slug). */
-  branch?: string
-}
-
-export interface WorktreeMap {
-  version: 1
-  /** Default worktree to use for new sessions and as fallback. */
-  defaultWorktreeSlug: string
-  /** Mapping of *parent* session IDs to a worktree slug. */
-  parentSessionWorktreeSlug: Record<string, string>
-}
-
-export type LogLevel = "debug" | "info" | "warn" | "error"
-
-export interface WorkspaceLogEntry {
-  workspaceId: string
-  timestamp: string
-  level: LogLevel
-  message: string
-}
-
-export interface FileSystemEntry {
-  name: string
-  /** Path relative to the CLI server root ("." represents the root itself). */
-  path: string
-  /** Absolute path when available (unrestricted listings). */
-  absolutePath?: string
-  type: "file" | "directory"
-  size?: number
-  /** ISO timestamp of last modification when available. */
-  modifiedAt?: string
-}
-
-export type FileSystemScope = "restricted" | "unrestricted"
-export type FileSystemPathKind = "relative" | "absolute" | "drives"
-
-export interface FileSystemListingMetadata {
-  scope: FileSystemScope
-  /** Canonical identifier of the current view ("." for restricted roots, absolute paths otherwise). */
-  currentPath: string
-  /** Optional parent path if navigation upward is allowed. */
-  parentPath?: string
-  /** Absolute path representing the root or origin point for this listing. */
-  rootPath: string
-  /** Absolute home directory of the CLI host (useful defaults for unrestricted mode). */
-  homePath: string
-  /** Human-friendly label for the current path. */
-  displayPath: string
-  /** Indicates whether entry paths are relative, absolute, or represent drive roots. */
-  pathKind: FileSystemPathKind
-}
-
-export interface FileSystemListResponse {
-  entries: FileSystemEntry[]
-  metadata: FileSystemListingMetadata
-}
-
-export interface FileSystemCreateFolderRequest {
-  /**
-   * Path identifier for the currently browsed directory.
-   * Matches the `path` parameter used for `/api/filesystem`.
-   */
-  parentPath?: string
-  /** Single folder name (no separators). */
-  name: string
-}
-
-export interface FileSystemCreateFolderResponse {
-  /**
-   * Path identifier that can be passed back to `/api/filesystem` to browse the new folder.
-   * Relative for restricted listings, absolute for unrestricted.
-   */
-  path: string
-  /** Absolute folder path on the server host. */
-  absolutePath: string
-}
-
-export const WINDOWS_DRIVES_ROOT = "__drives__"
-
-export interface WorkspaceFileResponse {
-  workspaceId: string
-  relativePath: string
-  /** UTF-8 file contents; binary files should be base64 encoded by the caller. */
-  contents: string
-}
-
-export type WorkspaceFileSearchResponse = FileSystemEntry[]
-
-export interface InstanceData {
-  messageHistory: string[]
-  agentModelSelections: AgentModelSelection
-}
-
-export type InstanceStreamStatus = "connecting" | "connected" | "error" | "disconnected"
-
-export interface InstanceStreamEvent {
-  type: string
-  properties?: Record<string, unknown>
-  [key: string]: unknown
-}
-
-export interface BinaryRecord {
-  id: string
-  path: string
-  label: string
-  version?: string
-
-  /** Indicates that this binary will be picked when workspaces omit an explicit choice. */
-  isDefault: boolean
-  lastValidatedAt?: string
-  validationError?: string
-}
-
-export type AppConfig = ConfigFile
-export type AppConfigResponse = AppConfig
-export type AppConfigUpdateRequest = Partial<AppConfig>
-
-export interface BinaryListResponse {
-  binaries: BinaryRecord[]
-}
-
-export interface BinaryCreateRequest {
-  path: string
-  label?: string
-  makeDefault?: boolean
-}
-
-export interface BinaryUpdateRequest {
-  label?: string
-  makeDefault?: boolean
-}
-
-export interface BinaryValidationResult {
-  valid: boolean
-  version?: string
-  error?: string
-}
-
-export type WorkspaceEventType =
-  | "workspace.created"
-  | "workspace.started"
-  | "workspace.error"
-  | "workspace.stopped"
-  | "workspace.log"
-  | "config.appChanged"
-  | "config.binariesChanged"
-  | "instance.dataChanged"
-  | "instance.event"
-  | "instance.eventStatus"
-
-export type WorkspaceEventPayload =
-  | { type: "workspace.created"; workspace: WorkspaceDescriptor }
-  | { type: "workspace.started"; workspace: WorkspaceDescriptor }
-  | { type: "workspace.error"; workspace: WorkspaceDescriptor }
-  | { type: "workspace.stopped"; workspaceId: string }
-  | { type: "workspace.log"; entry: WorkspaceLogEntry }
-  | { type: "config.appChanged"; config: AppConfig }
-  | { type: "config.binariesChanged"; binaries: BinaryRecord[] }
-  | { type: "instance.dataChanged"; instanceId: string; data: InstanceData }
-  | { type: "instance.event"; instanceId: string; event: InstanceStreamEvent }
-  | { type: "instance.eventStatus"; instanceId: string; status: InstanceStreamStatus; reason?: string }
-
-export interface NetworkAddress {
-  ip: string
-  family: "ipv4" | "ipv6"
-  scope: "external" | "internal" | "loopback"
-  /** Remote URL using the server's remote protocol/port for this IP. */
-  remoteUrl: string
-}
-
-export interface LatestReleaseInfo {
-  version: string
-  tag: string
-  url: string
-  channel: "stable" | "dev"
-  publishedAt?: string
-  notes?: string
-}
-
-export interface UiMeta {
-  version?: string
-  source: "bundled" | "downloaded" | "previous" | "override" | "dev-proxy" | "missing"
-}
-
-export interface SupportMeta {
-  supported: boolean
-  message?: string
-  minServerVersion?: string
-  latestServerVersion?: string
-  latestServerUrl?: string
-}
-
-export interface ServerMeta {
-  /** URL desktop apps should use to connect (prefers loopback HTTP when enabled). */
-  localUrl: string
-  /** URL remote clients should use (prefers HTTPS when enabled). */
-  remoteUrl?: string
-  /** SSE endpoint advertised to clients (`/api/events` by default). */
-  eventsUrl: string
-  /** Host the server is bound to (e.g., 127.0.0.1 or 0.0.0.0). */
-  host: string
-  /** Listening mode derived from host binding. */
-  listeningMode: "local" | "all"
-  /** Actual local port in use after binding. */
-  localPort: number
-  /** Actual remote port in use after binding (when remoteUrl is set). */
-  remotePort?: number
-  /** Display label for the host (e.g., hostname or friendly name). */
-  hostLabel: string
-  /** Absolute path of the filesystem root exposed to clients. */
-  workspaceRoot: string
-  /** Reachable addresses for this server, external first. */
-  addresses: NetworkAddress[]
-  serverVersion?: string
-  ui?: UiMeta
-  support?: SupportMeta
-  /** Optional update info (dev channel only). */
-  update?: LatestReleaseInfo | null
-}
-
-export type BackgroundProcessStatus = "running" | "stopped" | "error"
-
-export interface BackgroundProcess {
-  id: string
-  workspaceId: string
-  title: string
-  command: string
-  cwd: string
-  status: BackgroundProcessStatus
-  pid?: number
-  startedAt: string
-  stoppedAt?: string
-  exitCode?: number
-  outputSizeBytes?: number
-}
-
-export interface BackgroundProcessListResponse {
-  processes: BackgroundProcess[]
-}
-
-export interface BackgroundProcessOutputResponse {
-  id: string
-  content: string
-  truncated: boolean
-  sizeBytes: number
-}
-
-export type {
-  Preferences,
-  ModelPreference,
-  AgentModelSelections,
-  RecentFolder,
-  OpenCodeBinary,
-}