@open330/oac 2026.2.5

package/dist/dashboard/index.js

@@ -0,0 +1,1253 @@
+import {
+  cloneRepo,
+  resolveRepo
+} from "../chunk-CJAJ4MBO.js";
+import {
+  CompositeScanner,
+  GitHubIssuesScanner,
+  LintScanner,
+  TodoScanner,
+  rankTasks
+} from "../chunk-OTPXGXO7.js";
+import {
+  buildExecutionPlan,
+  estimateTokens
+} from "../chunk-5GAUWC3L.js";
+import {
+  CodexAdapter,
+  createSandbox,
+  executeTask
+} from "../chunk-QPVNC7S4.js";
+import {
+  createEventBus
+} from "../chunk-7C7SC4TZ.js";
+import "../chunk-6A37SKAJ.js";
+import {
+  buildLeaderboard,
+  contributionLogSchema,
+  writeContributionLog
+} from "../chunk-LQC5DLT7.js";
+
+// src/dashboard/server.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile, readdir } from "fs/promises";
+import { resolve } from "path";
+import cors from "@fastify/cors";
+import Fastify from "fastify";
+
+// src/dashboard/pipeline.ts
+import { randomUUID } from "crypto";
+import { execa } from "execa";
+import PQueue from "p-queue";
+function buildScanners() {
+  const scanners = [new LintScanner(), new TodoScanner()];
+  const names = ["lint", "todo"];
+  if (process.env.GITHUB_TOKEN) {
+    scanners.push(new GitHubIssuesScanner());
+    names.push("github-issues");
+  }
+  return { names, scanner: new CompositeScanner(scanners) };
+}
+async function executeWithCodex(input) {
+  const startedAt = Date.now();
+  const taskSlug = input.task.id.replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 30);
+  const branchName = `oac/${Date.now()}-${taskSlug}`;
+  const sandbox = await createSandbox(input.repoPath, branchName, input.baseBranch);
+  const eventBus = createEventBus();
+  const sandboxInfo = {
+    branchName,
+    sandboxPath: sandbox.path,
+    cleanup: sandbox.cleanup
+  };
+  try {
+    const result = await executeTask(input.codexAdapter, input.task, sandbox, eventBus, {
+      tokenBudget: input.estimate.totalEstimatedTokens,
+      timeoutMs: input.timeoutSeconds * 1e3
+    });
+    const commitResult = await commitSandboxChanges(sandbox.path, input.task);
+    const filesChanged = commitResult.filesChanged.length > 0 ? commitResult.filesChanged : result.filesChanged.length > 0 ? result.filesChanged : [];
+    return {
+      execution: {
+        success: result.success || commitResult.hasChanges,
+        exitCode: result.exitCode,
+        totalTokensUsed: result.totalTokensUsed,
+        filesChanged,
+        duration: result.duration > 0 ? result.duration / 1e3 : (Date.now() - startedAt) / 1e3,
+        error: result.error
+      },
+      sandbox: sandboxInfo
+    };
+  } catch (error) {
+    const commitResult = await commitSandboxChanges(sandbox.path, input.task);
+    if (commitResult.hasChanges) {
+      return {
+        execution: {
+          success: true,
+          exitCode: 0,
+          totalTokensUsed: 0,
+          filesChanged: commitResult.filesChanged,
+          duration: (Date.now() - startedAt) / 1e3
+        },
+        sandbox: sandboxInfo
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      execution: {
+        success: false,
+        exitCode: 1,
+        totalTokensUsed: 0,
+        filesChanged: [],
+        duration: (Date.now() - startedAt) / 1e3,
+        error: message
+      },
+      sandbox: sandboxInfo
+    };
+  }
+}
+async function commitSandboxChanges(sandboxPath, task) {
+  try {
+    const statusResult = await execa("git", ["status", "--porcelain"], { cwd: sandboxPath });
+    if (!statusResult.stdout.trim()) {
+      return { hasChanges: false, filesChanged: [] };
+    }
+    await execa("git", ["add", "-A"], { cwd: sandboxPath });
+    await execa("git", ["commit", "-m", `[OAC] ${task.title}
+
+Automated contribution by OAC.`], {
+      cwd: sandboxPath
+    });
+    const diffResult = await execa("git", ["diff", "--name-only", "HEAD~1", "HEAD"], {
+      cwd: sandboxPath
+    });
+    const changedFiles = diffResult.stdout.trim().split("\n").filter(Boolean);
+    return { hasChanges: true, filesChanged: changedFiles };
+  } catch {
+    return { hasChanges: false, filesChanged: [] };
+  }
+}
+async function resolveGitHubToken() {
+  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+  if (process.env.GH_TOKEN) return process.env.GH_TOKEN;
+  try {
+    const result = await execa("gh", ["auth", "token"], { reject: false, timeout: 5e3 });
+    if (result.exitCode === 0 && result.stdout.trim().length > 0) return result.stdout.trim();
+  } catch {
+  }
+  return void 0;
+}
+async function createPullRequest(input) {
+  const { branchName, sandboxPath } = input.sandbox;
+  try {
+    const ghToken = await resolveGitHubToken();
+    const ghEnv = { ...process.env };
+    if (ghToken) {
+      ghEnv.GH_TOKEN = ghToken;
+      ghEnv.GITHUB_TOKEN = ghToken;
+    }
+    await execa("git", ["push", "--set-upstream", "origin", branchName], {
+      cwd: sandboxPath,
+      env: ghEnv
+    });
+    const prTitle = `[OAC] ${input.task.title}`;
+    const prBody = [
+      "## Summary",
+      "",
+      input.task.description || `Automated contribution for task "${input.task.title}".`,
+      "",
+      "## Context",
+      "",
+      `- **Task source:** ${input.task.source}`,
+      `- **Complexity:** ${input.task.complexity}`,
+      `- **Tokens used:** ${input.execution.totalTokensUsed}`,
+      `- **Files changed:** ${input.execution.filesChanged.length}`,
+      "",
+      "---",
+      "*This PR was automatically generated by [OAC](https://github.com/Open330/open-agent-contribution).*"
+    ].join("\n");
+    const ghResult = await execa(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--repo",
+        input.repoFullName,
+        "--title",
+        prTitle,
+        "--body",
+        prBody,
+        "--head",
+        branchName,
+        "--base",
+        input.baseBranch
+      ],
+      { cwd: sandboxPath, env: ghEnv }
+    );
+    const prUrl = ghResult.stdout.trim();
+    const prNumberMatch = prUrl.match(/\/pull\/(\d+)/);
+    const prNumber = prNumberMatch ? Number.parseInt(prNumberMatch[1], 10) : 0;
+    return { number: prNumber, url: prUrl, status: "open" };
+  } catch {
+    return void 0;
+  }
+}
+function resolveGithubUsername() {
+  const candidates = [
+    process.env.GITHUB_USER,
+    process.env.GITHUB_USERNAME,
+    process.env.USER,
+    process.env.LOGNAME
+  ];
+  for (const c of candidates) {
+    const cleaned = c?.trim().replace(/[^A-Za-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (cleaned && cleaned.length <= 39 && /^(?!-)[A-Za-z0-9-]+(?<!-)$/.test(cleaned)) {
+      return cleaned;
+    }
+  }
+  return "oac-user";
+}
+async function executePipeline(config, onEvent) {
+  const runId = randomUUID();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const progress = {
+    tasksDiscovered: 0,
+    tasksSelected: 0,
+    tasksCompleted: 0,
+    tasksFailed: 0,
+    prsCreated: 0,
+    tokensUsed: 0,
+    prUrls: []
+  };
+  const state = {
+    runId,
+    status: "running",
+    stage: "resolving",
+    config,
+    startedAt,
+    progress
+  };
+  const emit = (event) => {
+    if (event.type === "run:stage") state.stage = event.stage;
+    if (event.type === "run:progress") state.progress = event.progress;
+    onEvent(event);
+  };
+  try {
+    const preAuthToken = await resolveGitHubToken();
+    if (preAuthToken && !process.env.GITHUB_TOKEN && !process.env.GH_TOKEN) {
+      process.env.GITHUB_TOKEN = preAuthToken;
+    }
+    emit({ type: "run:stage", stage: "resolving", message: `Resolving ${config.repo}...` });
+    const resolvedRepo = await resolveRepo(config.repo);
+    emit({ type: "run:stage", stage: "cloning", message: `Cloning ${resolvedRepo.fullName}...` });
+    await cloneRepo(resolvedRepo);
+    const { names, scanner } = buildScanners();
+    emit({
+      type: "run:stage",
+      stage: "scanning",
+      message: `Scanning with ${names.join(", ")}...`
+    });
+    const scannedTasks = await scanner.scan(resolvedRepo.localPath, {
+      repo: resolvedRepo
+    });
+    let candidateTasks = rankTasks(scannedTasks).filter((t) => t.priority >= 20);
+    if (config.source) {
+      candidateTasks = candidateTasks.filter((t) => t.source === config.source);
+    }
+    if (config.maxTasks) {
+      candidateTasks = candidateTasks.slice(0, config.maxTasks);
+    }
+    progress.tasksDiscovered = candidateTasks.length;
+    emit({ type: "run:progress", progress: { ...progress } });
+    if (candidateTasks.length === 0) {
+      emit({ type: "run:stage", stage: "completed", message: "No tasks discovered." });
+      state.status = "completed";
+      state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      emit({ type: "run:completed", summary: { ...state } });
+      return state;
+    }
+    emit({
+      type: "run:stage",
+      stage: "estimating",
+      message: `Estimating tokens for ${candidateTasks.length} task(s)...`
+    });
+    const estimates = /* @__PURE__ */ new Map();
+    for (const task of candidateTasks) {
+      const est = await estimateTokens(task, config.provider);
+      estimates.set(task.id, est);
+    }
+    emit({ type: "run:stage", stage: "planning", message: "Building execution plan..." });
+    const plan = buildExecutionPlan(candidateTasks, estimates, config.tokens);
+    progress.tasksSelected = plan.selectedTasks.length;
+    emit({ type: "run:progress", progress: { ...progress } });
+    if (plan.selectedTasks.length === 0) {
+      emit({ type: "run:stage", stage: "completed", message: "No tasks fit within budget." });
+      state.status = "completed";
+      state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      emit({ type: "run:completed", summary: { ...state } });
+      return state;
+    }
+    const concurrency = Math.max(1, config.concurrency ?? 1);
+    emit({
+      type: "run:stage",
+      stage: "executing",
+      message: `Executing ${plan.selectedTasks.length} task(s) (concurrency: ${concurrency})...`
+    });
+    const codexAdapter = new CodexAdapter();
+    const codexAvailability = await codexAdapter.checkAvailability();
+    const useRealExecution = config.provider.includes("codex") && codexAvailability.available;
+    const taskQueue = new PQueue({ concurrency });
+    const taskResults = await Promise.all(
+      plan.selectedTasks.map(
+        (entry) => taskQueue.add(async () => {
+          emit({ type: "run:task-start", taskId: entry.task.id, title: entry.task.title });
+          progress.currentTask = entry.task.title;
+          emit({ type: "run:progress", progress: { ...progress } });
+          let execution;
+          let sandbox;
+          if (useRealExecution) {
+            const result2 = await executeWithCodex({
+              task: entry.task,
+              estimate: entry.estimate,
+              codexAdapter,
+              repoPath: resolvedRepo.localPath,
+              baseBranch: resolvedRepo.meta.defaultBranch,
+              timeoutSeconds: 300
+            });
+            execution = result2.execution;
+            sandbox = result2.sandbox;
+          } else {
+            await new Promise((r) => setTimeout(r, 500));
+            execution = {
+              success: true,
+              exitCode: 0,
+              totalTokensUsed: Math.round(entry.estimate.totalEstimatedTokens * 0.9),
+              filesChanged: entry.task.targetFiles.slice(0, 4),
+              duration: 0.5
+            };
+          }
+          let pr;
+          if (execution.success && sandbox && execution.filesChanged.length > 0) {
+            emit({
+              type: "run:stage",
+              stage: "creating-pr",
+              message: `Creating PR for "${entry.task.title}"...`
+            });
+            pr = await createPullRequest({
+              task: entry.task,
+              execution,
+              sandbox,
+              repoFullName: resolvedRepo.fullName,
+              baseBranch: resolvedRepo.meta.defaultBranch
+            });
+            if (pr) {
+              progress.prsCreated += 1;
+              progress.prUrls.push(pr.url);
+            }
+          }
+          if (execution.success) {
+            progress.tasksCompleted += 1;
+          } else {
+            progress.tasksFailed += 1;
+          }
+          progress.tokensUsed += execution.totalTokensUsed;
+          progress.currentTask = void 0;
+          const result = { task: entry.task, execution, sandbox, pr };
+          emit({
+            type: "run:task-done",
+            taskId: entry.task.id,
+            title: entry.task.title,
+            success: execution.success,
+            prUrl: pr?.url,
+            filesChanged: execution.filesChanged.length
+          });
+          emit({ type: "run:progress", progress: { ...progress } });
+          return result;
+        })
+      )
+    );
+    emit({ type: "run:stage", stage: "tracking", message: "Writing contribution log..." });
+    const contributionLog = {
+      version: "1.0",
+      runId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      contributor: { githubUsername: resolveGithubUsername() },
+      repo: {
+        fullName: resolvedRepo.fullName,
+        headSha: resolvedRepo.git.headSha,
+        defaultBranch: resolvedRepo.meta.defaultBranch
+      },
+      budget: {
+        provider: config.provider,
+        totalTokensBudgeted: config.tokens,
+        totalTokensUsed: progress.tokensUsed
+      },
+      tasks: taskResults.map((r) => ({
+        taskId: r.task.id,
+        title: r.task.title,
+        source: r.task.source,
+        complexity: r.task.complexity,
+        status: r.execution.success ? "success" : "failed",
+        tokensUsed: r.execution.totalTokensUsed,
+        duration: r.execution.duration,
+        filesChanged: r.execution.filesChanged,
+        pr: r.pr,
+        error: r.execution.error
+      })),
+      metrics: {
+        tasksDiscovered: progress.tasksDiscovered,
+        tasksAttempted: taskResults.length,
+        tasksSucceeded: progress.tasksCompleted,
+        tasksFailed: progress.tasksFailed,
+        totalDuration: (Date.now() - new Date(startedAt).getTime()) / 1e3,
+        totalFilesChanged: taskResults.reduce((sum, r) => sum + r.execution.filesChanged.length, 0),
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0
+      }
+    };
+    try {
+      await writeContributionLog(contributionLog, resolvedRepo.localPath);
+    } catch {
+    }
+    emit({ type: "run:stage", stage: "completed", message: "Run completed successfully." });
+    state.status = "completed";
+    state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    emit({ type: "run:completed", summary: { ...state } });
+    return state;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    state.status = "failed";
+    state.stage = "failed";
+    state.error = message;
+    state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    emit({ type: "run:error", error: message });
+    return state;
+  }
+}
+
+// src/dashboard/ui.ts
+function renderDashboardHtml(port) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OAC Dashboard</title>
+  <style>
+    :root {
+      --bg: #0a0a0a; --card: #111; --border: #222; --text: #e5e5e5;
+      --muted: #888; --accent: #3b82f6; --green: #22c55e; --red: #ef4444;
+      --yellow: #eab308; --purple: #a855f7;
+    }
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", monospace; background: var(--bg); color: var(--text); }
+    .container { max-width: 1200px; margin: 0 auto; padding: 24px; }
+    header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 32px; border-bottom: 1px solid var(--border); padding-bottom: 16px; }
+    header h1 { font-size: 24px; font-weight: 700; }
+    header h1 span { color: var(--accent); }
+    .badge { display: inline-block; padding: 2px 10px; border-radius: 12px; font-size: 12px; font-weight: 600; }
+    .badge-idle { background: #1a1a2e; color: var(--muted); }
+    .badge-running { background: #0a2a1a; color: var(--green); animation: pulse 2s infinite; }
+    .badge-completed { background: #0a2a1a; color: var(--green); }
+    .badge-failed { background: #2a0a0a; color: var(--red); }
+    @keyframes pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.6; } }
+    .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-bottom: 20px; }
+    @media (max-width: 768px) { .grid { grid-template-columns: 1fr; } }
+    .card { background: var(--card); border: 1px solid var(--border); border-radius: 12px; padding: 20px; }
+    .card h2 { font-size: 14px; color: var(--muted); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 16px; }
+    .stat-row { display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid var(--border); }
+    .stat-row:last-child { border-bottom: none; }
+    .stat-label { color: var(--muted); font-size: 13px; }
+    .stat-value { font-weight: 600; font-size: 14px; }
+    .full-width { grid-column: 1 / -1; }
+    table { width: 100%; border-collapse: collapse; font-size: 13px; }
+    th { text-align: left; color: var(--muted); font-weight: 500; padding: 8px 12px; border-bottom: 1px solid var(--border); }
+    td { padding: 8px 12px; border-bottom: 1px solid var(--border); }
+    tr:hover td { background: #1a1a1a; }
+    .rank { color: var(--yellow); font-weight: 700; }
+    .empty { color: var(--muted); text-align: center; padding: 40px 0; font-size: 14px; }
+    .event-log { font-family: "SF Mono", "Fira Code", monospace; font-size: 12px; max-height: 200px; overflow-y: auto; padding: 12px; background: #050505; border-radius: 8px; }
+    .event-line { padding: 2px 0; color: var(--muted); }
+    .event-line .time { color: var(--accent); margin-right: 8px; }
+    .connected { color: var(--green); }
+    .toolbar { display: flex; gap: 8px; margin-bottom: 20px; }
+    .btn { padding: 8px 16px; border-radius: 8px; border: 1px solid var(--border); background: var(--card); color: var(--text); cursor: pointer; font-size: 13px; transition: all 0.15s; }
+    .btn:hover { background: #1a1a1a; border-color: var(--accent); }
+    .btn:disabled { opacity: 0.4; cursor: not-allowed; }
+    .btn-primary { background: var(--accent); border-color: var(--accent); color: white; }
+    .btn-primary:hover:not(:disabled) { opacity: 0.9; }
+    footer { text-align: center; padding: 32px 0 16px; color: var(--muted); font-size: 12px; }
+
+    /* Start Run Form */
+    .run-form { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+    .run-form .form-group { display: flex; flex-direction: column; gap: 4px; }
+    .run-form .form-group.full { grid-column: 1 / -1; }
+    .run-form label { font-size: 12px; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px; }
+    .run-form input, .run-form select {
+      padding: 8px 12px; border-radius: 8px; border: 1px solid var(--border);
+      background: #050505; color: var(--text); font-size: 13px; font-family: inherit;
+    }
+    .run-form input:focus, .run-form select:focus { outline: none; border-color: var(--accent); }
+    .run-form .form-actions { grid-column: 1 / -1; display: flex; gap: 8px; margin-top: 4px; }
+
+    /* Stage Progress */
+    .stage-pipeline { display: flex; align-items: center; gap: 0; margin: 16px 0; overflow-x: auto; padding-bottom: 4px; }
+    .stage-dot { display: flex; align-items: center; gap: 0; white-space: nowrap; }
+    .stage-dot .dot {
+      width: 10px; height: 10px; border-radius: 50%; background: var(--border);
+      flex-shrink: 0; transition: background 0.3s;
+    }
+    .stage-dot .dot.active { background: var(--accent); animation: pulse 1.5s infinite; }
+    .stage-dot .dot.done { background: var(--green); }
+    .stage-dot .dot.error { background: var(--red); }
+    .stage-dot .label { font-size: 11px; color: var(--muted); margin-left: 4px; margin-right: 4px; }
+    .stage-dot .label.active { color: var(--accent); font-weight: 600; }
+    .stage-dot .label.done { color: var(--green); }
+    .stage-connector { width: 16px; height: 1px; background: var(--border); flex-shrink: 0; }
+    .stage-connector.done { background: var(--green); }
+
+    /* Task Results */
+    .task-results { margin-top: 12px; }
+    .task-result { display: flex; align-items: center; gap: 8px; padding: 6px 0; border-bottom: 1px solid var(--border); font-size: 13px; }
+    .task-result:last-child { border-bottom: none; }
+    .task-result .icon { font-size: 14px; }
+    .task-result a { color: var(--accent); text-decoration: none; }
+    .task-result a:hover { text-decoration: underline; }
+    .task-result .meta { color: var(--muted); font-size: 12px; margin-left: auto; }
+
+    .hidden { display: none !important; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1><span>OAC</span> Dashboard</h1>
+      <div>
+        <span id="status-badge" class="badge badge-idle">idle</span>
+        <span id="sse-indicator" style="margin-left: 8px; font-size: 11px; color: var(--muted);">connecting...</span>
+      </div>
+    </header>
+
+    <!-- Start Run Form -->
+    <div id="run-form-card" class="card" style="margin-bottom: 20px;">
+      <h2>Start Run</h2>
+      <div class="run-form">
+        <div class="form-group full">
+          <label for="run-repo">Repository (owner/repo or GitHub URL)</label>
+          <input type="text" id="run-repo" placeholder="e.g. Open330/open-agent-contribution" />
+        </div>
+        <div class="form-group">
+          <label for="run-provider">Agent Provider</label>
+          <select id="run-provider">
+            <option value="claude-code">Claude Code</option>
+            <option value="codex">Codex CLI</option>
+          </select>
+        </div>
+        <div class="form-group">
+          <label for="run-tokens-mode">Token Budget</label>
+          <select id="run-tokens-mode" onchange="toggleTokenInput()">
+            <option value="fixed">Fixed</option>
+            <option value="unlimited">Unlimited (until rate-limited)</option>
+          </select>
+        </div>
+        <div class="form-group" id="run-tokens-value-group">
+          <label for="run-tokens">Token Amount</label>
+          <input type="number" id="run-tokens" value="100000" min="1000" step="1000" />
+        </div>
+        <div class="form-group">
+          <label for="run-max-tasks">Max Tasks</label>
+          <input type="number" id="run-max-tasks" value="5" min="1" max="50" />
+        </div>
+        <div class="form-group">
+          <label for="run-concurrency">Concurrency</label>
+          <input type="number" id="run-concurrency" value="2" min="1" max="10" />
+        </div>
+        <div class="form-group">
+          <label for="run-source">Source Filter</label>
+          <select id="run-source">
+            <option value="">All sources</option>
+            <option value="github-issue">GitHub Issues</option>
+            <option value="lint">Lint warnings</option>
+            <option value="todo">To-do comments</option>
+            <option value="test-gap">Test gaps</option>
+          </select>
+        </div>
+        <div class="form-actions">
+          <button id="run-start-btn" class="btn btn-primary" onclick="startRun()">Start Run</button>
+          <span id="run-error" style="color: var(--red); font-size: 13px; align-self: center;"></span>
+        </div>
+      </div>
+    </div>
+
+    <!-- Run Progress (shown during active run) -->
+    <div id="run-progress-card" class="card hidden" style="margin-bottom: 20px;">
+      <h2>Run Progress</h2>
+      <div id="stage-pipeline" class="stage-pipeline"></div>
+      <div id="run-progress-stats" style="margin-top: 8px;">
+        <div class="stat-row"><span class="stat-label">Tasks discovered</span><span class="stat-value" id="prog-discovered">0</span></div>
+        <div class="stat-row"><span class="stat-label">Tasks selected</span><span class="stat-value" id="prog-selected">0</span></div>
+        <div class="stat-row"><span class="stat-label">Completed</span><span class="stat-value" id="prog-completed">0</span></div>
+        <div class="stat-row"><span class="stat-label">Failed</span><span class="stat-value" id="prog-failed">0</span></div>
+        <div class="stat-row"><span class="stat-label">PRs created</span><span class="stat-value" id="prog-prs">0</span></div>
+        <div class="stat-row"><span class="stat-label">Tokens used</span><span class="stat-value" id="prog-tokens">0</span></div>
+      </div>
+      <div id="task-results" class="task-results"></div>
+    </div>
+
+    <div class="toolbar">
+      <button class="btn" onclick="fetchStatus()">Refresh Status</button>
+      <button class="btn" onclick="fetchLogs()">Refresh Logs</button>
+      <button class="btn" onclick="fetchLeaderboard()">Refresh Leaderboard</button>
+    </div>
+
+    <div class="grid">
+      <div class="card">
+        <h2>Run Status</h2>
+        <div id="status-content">
+          <div class="empty">Loading...</div>
+        </div>
+      </div>
+
+      <div class="card">
+        <h2>Quick Stats</h2>
+        <div id="stats-content">
+          <div class="empty">Loading...</div>
+        </div>
+      </div>
+
+      <div class="card full-width">
+        <h2>Contribution Log</h2>
+        <div id="logs-content">
+          <div class="empty">Loading...</div>
+        </div>
+      </div>
+
+      <div class="card full-width">
+        <h2>Leaderboard</h2>
+        <div id="leaderboard-content">
+          <div class="empty">Loading...</div>
+        </div>
+      </div>
+
+      <div class="card full-width">
+        <h2>Event Stream</h2>
+        <div id="event-log" class="event-log">
+          <div class="event-line" style="color: var(--muted);">Connecting to SSE...</div>
+        </div>
+      </div>
+    </div>
+
+    <footer>OAC v0.1.0 &mdash; Open Agent Contribution</footer>
+  </div>
+
+  <script>
+    const API = "";
+    const STAGES = ["resolving","cloning","scanning","estimating","planning","executing","creating-pr","tracking","completed"];
+    let activeRunId = null;
+
+    function formatDate(iso) {
+      if (!iso) return "-";
+      try { return new Date(iso).toLocaleString(); } catch { return iso; }
+    }
+
+    // ---- Start Run ----
+
+    function toggleTokenInput() {
+      const mode = document.getElementById("run-tokens-mode").value;
+      const group = document.getElementById("run-tokens-value-group");
+      if (mode === "unlimited") {
+        group.classList.add("hidden");
+      } else {
+        group.classList.remove("hidden");
+      }
+    }
+
+    async function startRun() {
+      const repo = document.getElementById("run-repo").value.trim();
+      const provider = document.getElementById("run-provider").value;
+      const tokensMode = document.getElementById("run-tokens-mode").value;
+      const tokens = tokensMode === "unlimited"
+        ? 9007199254740991
+        : parseInt(document.getElementById("run-tokens").value, 10);
+      const maxTasks = parseInt(document.getElementById("run-max-tasks").value, 10);
+      const concurrency = parseInt(document.getElementById("run-concurrency").value, 10) || 2;
+      const source = document.getElementById("run-source").value || undefined;
+      const errEl = document.getElementById("run-error");
+      const btn = document.getElementById("run-start-btn");
+
+      errEl.textContent = "";
+      if (!repo) { errEl.textContent = "Repository is required"; return; }
+      if (tokensMode !== "unlimited" && (!tokens || tokens < 1000)) { errEl.textContent = "Token budget must be >= 1000"; return; }
+
+      btn.disabled = true;
+      btn.textContent = "Starting...";
+
+      try {
+        const res = await fetch(API + "/api/v1/runs", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ repo, provider, tokens, maxTasks, concurrency, source }),
+        });
+        const data = await res.json();
+
+        if (!res.ok) {
+          errEl.textContent = data.error || "Failed to start run";
+          btn.disabled = false;
+          btn.textContent = "Start Run";
+          return;
+        }
+
+        activeRunId = data.runId;
+        showProgressCard();
+      } catch (e) {
+        errEl.textContent = "Network error: " + e.message;
+        btn.disabled = false;
+        btn.textContent = "Start Run";
+      }
+    }
+
+    function showProgressCard() {
+      document.getElementById("run-progress-card").classList.remove("hidden");
+      initStageList();
+      document.getElementById("task-results").innerHTML = "";
+      document.getElementById("prog-discovered").textContent = "0";
+      document.getElementById("prog-selected").textContent = "0";
+      document.getElementById("prog-completed").textContent = "0";
+      document.getElementById("prog-failed").textContent = "0";
+      document.getElementById("prog-prs").textContent = "0";
+      document.getElementById("prog-tokens").textContent = "0";
+
+      const badge = document.getElementById("status-badge");
+      badge.className = "badge badge-running";
+      badge.textContent = "running";
+    }
+
+    function initStageList() {
+      const pipeline = document.getElementById("stage-pipeline");
+      pipeline.innerHTML = "";
+      STAGES.forEach((stage, i) => {
+        const dot = document.createElement("div");
+        dot.className = "stage-dot";
+        dot.innerHTML = '<div class="dot" id="dot-' + stage + '"></div><span class="label" id="label-' + stage + '">' + stage + '</span>';
+        pipeline.appendChild(dot);
+        if (i < STAGES.length - 1) {
+          const conn = document.createElement("div");
+          conn.className = "stage-connector";
+          conn.id = "conn-" + stage;
+          pipeline.appendChild(conn);
+        }
+      });
+    }
+
+    function updateStage(currentStage) {
+      let reached = false;
+      STAGES.forEach((stage, i) => {
+        const dot = document.getElementById("dot-" + stage);
+        const label = document.getElementById("label-" + stage);
+        const conn = i < STAGES.length - 1 ? document.getElementById("conn-" + stage) : null;
+
+        if (!dot || !label) return;
+
+        if (stage === currentStage) {
+          reached = true;
+          dot.className = currentStage === "completed" ? "dot done" : "dot active";
+          label.className = currentStage === "completed" ? "label done" : "label active";
+          if (conn && currentStage === "completed") conn.className = "stage-connector done";
+        } else if (!reached) {
+          dot.className = "dot done";
+          label.className = "label done";
+          if (conn) conn.className = "stage-connector done";
+        } else {
+          dot.className = "dot";
+          label.className = "label";
+          if (conn) conn.className = "stage-connector";
+        }
+      });
+    }
+
+    function updateProgress(progress) {
+      document.getElementById("prog-discovered").textContent = progress.tasksDiscovered || 0;
+      document.getElementById("prog-selected").textContent = progress.tasksSelected || 0;
+      document.getElementById("prog-completed").textContent = progress.tasksCompleted || 0;
+      document.getElementById("prog-failed").textContent = progress.tasksFailed || 0;
+      document.getElementById("prog-prs").textContent = progress.prsCreated || 0;
+      document.getElementById("prog-tokens").textContent = (progress.tokensUsed || 0).toLocaleString();
+    }
+
+    function addTaskResult(data) {
+      const container = document.getElementById("task-results");
+      const div = document.createElement("div");
+      div.className = "task-result";
+      const icon = data.success ? "\\u2705" : "\\u274c";
+      let html = '<span class="icon">' + icon + '</span><span>' + escapeHtml(data.title) + '</span>';
+      if (data.prUrl) {
+        html += ' <a href="' + escapeHtml(data.prUrl) + '" target="_blank">PR \\u2197</a>';
+      }
+      html += '<span class="meta">' + (data.filesChanged || 0) + ' files</span>';
+      div.innerHTML = html;
+      container.appendChild(div);
+    }
+
+    function onRunCompleted(isError) {
+      const btn = document.getElementById("run-start-btn");
+      btn.disabled = false;
+      btn.textContent = "Start Run";
+      activeRunId = null;
+
+      const badge = document.getElementById("status-badge");
+      if (isError) {
+        badge.className = "badge badge-failed";
+        badge.textContent = "failed";
+      } else {
+        badge.className = "badge badge-completed";
+        badge.textContent = "completed";
+      }
+
+      // Refresh data
+      fetchStatus();
+      fetchLogs();
+      fetchLeaderboard();
+    }
+
+    function onRunError(errorMsg) {
+      const container = document.getElementById("task-results");
+      const div = document.createElement("div");
+      div.className = "task-result";
+      div.innerHTML = '<span class="icon">\\u274c</span><span style="color: var(--red);">Error: ' + escapeHtml(errorMsg) + '</span>';
+      container.appendChild(div);
+
+      // Mark failed stage
+      STAGES.forEach((stage) => {
+        const dot = document.getElementById("dot-" + stage);
+        if (dot && dot.className === "dot active") {
+          dot.className = "dot error";
+        }
+      });
+
+      onRunCompleted(true);
+    }
+
+    function escapeHtml(str) {
+      const div = document.createElement("div");
+      div.textContent = str || "";
+      return div.innerHTML;
+    }
+
+    // ---- Fetch functions ----
+
+    async function fetchStatus() {
+      try {
+        const res = await fetch(API + "/api/v1/status");
+        const data = await res.json();
+        const badge = document.getElementById("status-badge");
+
+        if (data.status === "running") {
+          badge.className = "badge badge-running";
+          badge.textContent = "running";
+          // Restore progress card if page was refreshed mid-run
+          if (!activeRunId) {
+            activeRunId = data.runId;
+            showProgressCard();
+            if (data.stage) updateStage(data.stage);
+            if (data.progress) updateProgress(data.progress);
+          }
+        } else if (data.status === "idle" && !activeRunId) {
+          badge.className = "badge badge-idle";
+          badge.textContent = "idle";
+        }
+
+        let html = "";
+        const displayKeys = ["status", "stage", "runId", "startedAt", "completedAt", "error"];
+        for (const key of displayKeys) {
+          if (data[key] !== undefined) {
+            html += '<div class="stat-row"><span class="stat-label">' + key + '</span><span class="stat-value">' + escapeHtml(String(data[key])) + '</span></div>';
+          }
+        }
+        if (!html) {
+          for (const [key, value] of Object.entries(data)) {
+            html += '<div class="stat-row"><span class="stat-label">' + key + '</span><span class="stat-value">' + escapeHtml(String(value)) + '</span></div>';
+          }
+        }
+        document.getElementById("status-content").innerHTML = html || '<div class="empty">No status data</div>';
+      } catch (e) {
+        document.getElementById("status-content").innerHTML = '<div class="empty">Failed to load status</div>';
+      }
+    }
+
+    async function fetchLogs() {
+      try {
+        const res = await fetch(API + "/api/v1/logs");
+        const data = await res.json();
+
+        if (!data.logs || data.logs.length === 0) {
+          document.getElementById("logs-content").innerHTML = '<div class="empty">No contributions yet. Run <code>oac run</code> to start contributing!</div>';
+          document.getElementById("stats-content").innerHTML = [
+            '<div class="stat-row"><span class="stat-label">Total Runs</span><span class="stat-value">0</span></div>',
+            '<div class="stat-row"><span class="stat-label">Total Tasks</span><span class="stat-value">0</span></div>',
+            '<div class="stat-row"><span class="stat-label">Total Tokens</span><span class="stat-value">0</span></div>',
+            '<div class="stat-row"><span class="stat-label">PRs Created</span><span class="stat-value">0</span></div>',
+          ].join("");
+          return;
+        }
+
+        const totalRuns = data.logs.length;
+        const totalTasks = data.logs.reduce((s, l) => s + (l.tasks?.length || 0), 0);
+        const totalTokens = data.logs.reduce((s, l) => s + (l.budget?.totalTokensUsed || 0), 0);
+        const totalPRs = data.logs.reduce((s, l) => s + (l.tasks?.filter(t => t.pr).length || 0), 0);
+
+        document.getElementById("stats-content").innerHTML = [
+          '<div class="stat-row"><span class="stat-label">Total Runs</span><span class="stat-value">' + totalRuns + '</span></div>',
+          '<div class="stat-row"><span class="stat-label">Total Tasks</span><span class="stat-value">' + totalTasks + '</span></div>',
+          '<div class="stat-row"><span class="stat-label">Total Tokens</span><span class="stat-value">' + totalTokens.toLocaleString() + '</span></div>',
+          '<div class="stat-row"><span class="stat-label">PRs Created</span><span class="stat-value">' + totalPRs + '</span></div>',
+        ].join("");
+
+        let html = '<table><thead><tr><th>Date</th><th>Repo</th><th>Tasks</th><th>Tokens</th><th>Agent</th></tr></thead><tbody>';
+        for (const log of data.logs.slice(0, 20)) {
+          html += '<tr>';
+          html += '<td>' + formatDate(log.timestamp) + '</td>';
+          html += '<td>' + escapeHtml(log.repo?.fullName || log.repoFullName || "-") + '</td>';
+          html += '<td>' + (log.tasks?.length || 0) + '</td>';
+          html += '<td>' + (log.budget?.totalTokensUsed || 0).toLocaleString() + '</td>';
+          html += '<td>' + escapeHtml(log.budget?.provider || log.agentProvider || "-") + '</td>';
+          html += '</tr>';
+        }
+        html += '</tbody></table>';
+        document.getElementById("logs-content").innerHTML = html;
+      } catch (e) {
+        document.getElementById("logs-content").innerHTML = '<div class="empty">Failed to load logs</div>';
+      }
+    }
+
+    async function fetchLeaderboard() {
+      try {
+        const res = await fetch(API + "/api/v1/leaderboard");
+        const data = await res.json();
+
+        if (!data.entries || data.entries.length === 0) {
+          document.getElementById("leaderboard-content").innerHTML = '<div class="empty">No contributors yet</div>';
+          return;
+        }
+
+        let html = '<table><thead><tr><th>#</th><th>User</th><th>Tasks</th><th>Tokens</th><th>PRs</th><th>Last Active</th></tr></thead><tbody>';
+        data.entries.forEach((entry, i) => {
+          html += '<tr>';
+          html += '<td class="rank">' + (i + 1) + '</td>';
+          html += '<td>' + escapeHtml(entry.githubUsername || "anonymous") + '</td>';
+          html += '<td>' + (entry.totalTasksCompleted || 0) + '</td>';
+          html += '<td>' + (entry.totalTokensDonated || 0).toLocaleString() + '</td>';
+          html += '<td>' + (entry.totalPRsCreated || 0) + '</td>';
+          html += '<td>' + formatDate(entry.lastContribution) + '</td>';
+          html += '</tr>';
+        });
+        html += '</tbody></table>';
+        document.getElementById("leaderboard-content").innerHTML = html;
+      } catch (e) {
+        document.getElementById("leaderboard-content").innerHTML = '<div class="empty">Failed to load leaderboard</div>';
+      }
+    }
+
+    // ---- SSE Connection ----
+
+    function connectSSE() {
+      const indicator = document.getElementById("sse-indicator");
+      const log = document.getElementById("event-log");
+
+      const es = new EventSource(API + "/api/v1/events");
+
+      es.addEventListener("connected", (e) => {
+        indicator.innerHTML = '<span class="connected">\\u25cf connected</span>';
+        addEventLine(log, "connected", "SSE stream connected");
+      });
+
+      es.addEventListener("heartbeat", (e) => {
+        // Silent heartbeat \u2014 no log spam
+      });
+
+      // Run events
+      es.addEventListener("run:stage", (e) => {
+        try {
+          const data = JSON.parse(e.data);
+          updateStage(data.stage);
+          addEventLine(log, "stage", data.message || data.stage);
+        } catch {} // best-effort: SSE event data may be malformed
+      });
+
+      es.addEventListener("run:progress", (e) => {
+        try {
+          const data = JSON.parse(e.data);
+          updateProgress(data.progress);
+        } catch {} // best-effort: SSE event data may be malformed
+      });
+
+      es.addEventListener("run:task-start", (e) => {
+        try {
+          const data = JSON.parse(e.data);
+          addEventLine(log, "task", "Starting: " + data.title);
+        } catch {} // best-effort: SSE event data may be malformed
+      });
+
+      es.addEventListener("run:task-done", (e) => {
+        try {
+          const data = JSON.parse(e.data);
+          const status = data.success ? "OK" : "FAILED";
+          let msg = "[" + status + "] " + data.title;
+          if (data.prUrl) msg += " - PR: " + data.prUrl;
+          addEventLine(log, "task", msg);
+          addTaskResult(data);
+        } catch {} // best-effort: SSE event data may be malformed
+      });
+
+      es.addEventListener("run:completed", (e) => {
+        try {
+          addEventLine(log, "completed", "Run finished successfully");
+          updateStage("completed");
+          onRunCompleted(false);
+        } catch {} // best-effort: SSE event data may be malformed
+      });
+
+      es.addEventListener("run:error", (e) => {
+        try {
+          const data = JSON.parse(e.data);
+          addEventLine(log, "error", data.error);
+          onRunError(data.error);
+        } catch {} // best-effort: SSE event data may be malformed
+      });
+
+      es.onerror = () => {
+        indicator.innerHTML = '<span style="color: var(--red);">\\u25cf disconnected</span>';
+        addEventLine(log, "error", "SSE disconnected, reconnecting...");
+      };
+
+      es.onmessage = (e) => {
+        addEventLine(log, "message", e.data);
+      };
+    }
+
+    function addEventLine(container, type, data) {
+      const now = new Date().toLocaleTimeString();
+      const line = document.createElement("div");
+      line.className = "event-line";
+      line.innerHTML = '<span class="time">' + now + '</span> <strong>' + type + '</strong> ' + escapeHtml(String(data));
+      container.appendChild(line);
+      container.scrollTop = container.scrollHeight;
+
+      while (container.children.length > 100) {
+        container.removeChild(container.firstChild);
+      }
+    }
+
+    // ---- Init ----
+    fetchStatus();
+    fetchLogs();
+    fetchLeaderboard();
+    connectSSE();
+
+    setInterval(() => { fetchStatus(); fetchLogs(); }, 30000);
+  </script>
+</body>
+</html>`;
+}
+
+// src/dashboard/server.ts
+var DEFAULT_OPTIONS = {
+  port: 3141,
+  host: "0.0.0.0",
+  openBrowser: false,
+  oacDir: process.cwd()
+};
+var MAX_SSE_CLIENTS = 50;
+var currentRun = null;
+var sseClients = /* @__PURE__ */ new Set();
+function broadcastEvent(event) {
+  for (const send of sseClients) {
+    try {
+      send(event);
+    } catch {
+    }
+  }
+}
+async function readContributionLogs(oacDir) {
+  const contributionsPath = resolve(oacDir, ".oac", "contributions");
+  let entries;
+  try {
+    entries = await readdir(contributionsPath, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return [];
+  }
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
+  const results = await Promise.all(
+    files.map(async (fileName) => {
+      try {
+        const content = await readFile(resolve(contributionsPath, fileName), "utf8");
+        const parsed = contributionLogSchema.safeParse(JSON.parse(content));
+        return parsed.success ? parsed.data : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return results.filter((log) => log !== null);
+}
+async function readRunStatus(oacDir) {
+  if (currentRun) {
+    return currentRun;
+  }
+  try {
+    const content = await readFile(resolve(oacDir, ".oac", "status.json"), "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { status: "idle", message: "No active runs" };
+  }
+}
+async function createDashboardServer(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const app = Fastify({ logger: false });
+  await app.register(cors, { origin: true });
+  app.get("/", async (_request, reply) => {
+    reply.type("text/html").send(renderDashboardHtml(opts.port));
+  });
+  app.get("/api/v1/status", async () => {
+    return readRunStatus(opts.oacDir);
+  });
+  app.get("/api/v1/logs", async () => {
+    const logs = await readContributionLogs(opts.oacDir);
+    return { count: logs.length, logs };
+  });
+  app.get("/api/v1/leaderboard", async () => {
+    const leaderboard = await buildLeaderboard(opts.oacDir);
+    return leaderboard;
+  });
+  app.get("/api/v1/config", async () => {
+    return {
+      oacDir: opts.oacDir,
+      port: opts.port,
+      host: opts.host
+    };
+  });
+  app.post("/api/v1/runs", async (request, reply) => {
+    if (currentRun && currentRun.status === "running") {
+      reply.code(409).send({ error: "A run is already in progress", runId: currentRun.runId });
+      return;
+    }
+    const body = request.body;
+    if (!body?.repo || !body.provider || !body.tokens) {
+      reply.code(400).send({ error: "Missing required fields: repo, provider, tokens" });
+      return;
+    }
+    const config = {
+      repo: body.repo,
+      provider: body.provider,
+      tokens: body.tokens,
+      concurrency: typeof body.concurrency === "number" ? body.concurrency : void 0,
+      maxTasks: body.maxTasks,
+      source: body.source
+    };
+    const runId = randomUUID2();
+    currentRun = {
+      runId,
+      status: "running",
+      stage: "resolving",
+      config,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      progress: {
+        tasksDiscovered: 0,
+        tasksSelected: 0,
+        tasksCompleted: 0,
+        tasksFailed: 0,
+        prsCreated: 0,
+        tokensUsed: 0,
+        prUrls: []
+      }
+    };
+    executePipeline(config, (event) => {
+      if (event.type === "run:stage" && currentRun) {
+        currentRun.stage = event.stage;
+      }
+      if (event.type === "run:progress" && currentRun) {
+        currentRun.progress = event.progress;
+      }
+      if (event.type === "run:completed" && currentRun) {
+        currentRun.status = "completed";
+        currentRun.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      if (event.type === "run:error" && currentRun) {
+        currentRun.status = "failed";
+        currentRun.error = event.error;
+        currentRun.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      broadcastEvent(event);
+    }).catch((err) => {
+      if (currentRun) {
+        currentRun.status = "failed";
+        currentRun.error = err instanceof Error ? err.message : String(err);
+        currentRun.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    });
+    reply.code(202).send({ runId, status: "started" });
+  });
+  app.get("/api/v1/events", async (_request, reply) => {
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    reply.raw.write(
+      `event: connected
+data: ${JSON.stringify({ time: (/* @__PURE__ */ new Date()).toISOString() })}
+
+`
+    );
+    const sendEvent = (event) => {
+      reply.raw.write(`event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`);
+    };
+    if (sseClients.size >= MAX_SSE_CLIENTS) {
+      reply.status(503).send({ error: "Too many SSE connections" });
+      return;
+    }
+    sseClients.add(sendEvent);
+    const interval = setInterval(() => {
+      reply.raw.write(
+        `event: heartbeat
+data: ${JSON.stringify({ time: (/* @__PURE__ */ new Date()).toISOString() })}
+
+`
+      );
+    }, 1e4);
+    _request.raw.on("close", () => {
+      clearInterval(interval);
+      sseClients.delete(sendEvent);
+    });
+  });
+  return app;
+}
+async function startDashboard(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const app = await createDashboardServer(opts);
+  await app.listen({ port: opts.port, host: opts.host });
+  const url = opts.host === "0.0.0.0" ? `http://localhost:${opts.port}` : `http://${opts.host}:${opts.port}`;
+  console.log(`
+  \u{1F680} OAC Dashboard running at ${url}`);
+  console.log(`     Network: http://0.0.0.0:${opts.port}`);
+  console.log(`
+  API: ${url}/api/v1/status`);
+  console.log(`  SSE: ${url}/api/v1/events
+`);
+  if (opts.openBrowser) {
+    const { execFile } = await import("child_process");
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    execFile(command, [url], (err) => {
+      if (err) {
+        console.warn(`Could not open browser: ${err.message}`);
+      }
+    });
+  }
+}
+export {
+  createDashboardServer,
+  renderDashboardHtml,
+  startDashboard
+};
+//# sourceMappingURL=index.js.map