oh-my-opencode-dashboard 0.0.1

package/src/cli/dev.ts

@@ -0,0 +1,139 @@
+#!/usr/bin/env bun
+import { spawn } from 'node:child_process';
+import { cwd, exit } from 'node:process';
+
+import { findAvailablePort } from './ports';
+
+interface CliArgs {
+  project: string;
+  port: number;
+}
+
+function parseArgs(): CliArgs {
+  const args = process.argv.slice(2);
+  let project: string | undefined;
+  let port = 51234; // Default port
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (arg === '--project' && i + 1 < args.length) {
+      project = args[i + 1];
+      i++; // Skip next argument
+    } else if (arg === '--port' && i + 1 < args.length) {
+      const portStr = args[i + 1];
+      const parsedPort = parseInt(portStr, 10);
+      if (isNaN(parsedPort) || parsedPort <= 0) {
+        console.error('Error: --port must be a positive integer');
+        exit(1);
+      }
+      port = parsedPort;
+      i++; // Skip next argument
+    }
+  }
+
+  return { project: project ?? cwd(), port };
+}
+
+async function main() {
+  const { project, port } = parseArgs();
+
+  const host = '127.0.0.1';
+  const resolvedPort = await findAvailablePort({ host, preferredPort: port });
+  if (resolvedPort !== port) {
+    console.log(`Port ${port} is busy; using ${resolvedPort} instead`);
+  }
+  
+  console.log(`Starting dev servers for project: ${project}`);
+  console.log(`API port: ${resolvedPort}`);
+
+  const apiArgs = ['run', 'src/server/dev.ts', '--', '--project', project, '--port', resolvedPort.toString()];
+  const uiArgs = ['run', 'dev:ui'];
+
+  const apiServer = spawn('bun', apiArgs, {
+    stdio: 'inherit',
+    shell: true
+  });
+
+  const uiServer = spawn('bun', uiArgs, {
+    stdio: 'inherit',
+    shell: true,
+    env: {
+      ...process.env,
+      OMO_DASHBOARD_API_PORT: resolvedPort.toString(),
+    },
+  });
+
+  // Handle signals and clean up both processes
+  const cleanup = () => {
+    console.log('\nShutting down servers...');
+    apiServer.kill('SIGTERM');
+    uiServer.kill('SIGTERM');
+    
+    // Force kill if they don't terminate gracefully
+    setTimeout(() => {
+      apiServer.kill('SIGKILL');
+      uiServer.kill('SIGKILL');
+      exit(0);
+    }, 5000);
+  };
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+
+  // Wait for either process to exit
+  let apiExited = false;
+  let uiExited = false;
+
+  const handleExit = (processName: string) => {
+    if (processName === 'API') {
+      apiExited = true;
+    } else {
+      uiExited = true;
+    }
+
+    if (apiExited || uiExited) {
+      console.log(`${processName} server exited, shutting down the other server...`);
+      cleanup();
+    }
+  };
+
+  apiServer.on('exit', (code, signal) => {
+    if (signal) {
+      console.log(`API server killed by signal: ${signal}`);
+    } else if (code !== 0) {
+      console.log(`API server exited with code: ${code}`);
+    }
+    handleExit('API');
+  });
+
+  uiServer.on('exit', (code, signal) => {
+    if (signal) {
+      console.log(`UI server killed by signal: ${signal}`);
+    } else if (code !== 0) {
+      console.log(`UI server exited with code: ${code}`);
+    }
+    handleExit('UI');
+  });
+
+  apiServer.on('error', (error) => {
+    console.error('Failed to start API server:', error.message);
+    cleanup();
+    exit(1);
+  });
+
+  uiServer.on('error', (error) => {
+    console.error('Failed to start UI server:', error.message);
+    cleanup();
+    exit(1);
+  });
+
+  console.log('Both servers started successfully');
+  console.log(`API server: http://127.0.0.1:${resolvedPort}`);
+  console.log('UI server: check Vite output for URL');
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  exit(1);
+});

package/src/cli/ports.test.ts

@@ -0,0 +1,40 @@
+import net from "node:net"
+import { describe, expect, it } from "vitest"
+
+import { findAvailablePort } from "./ports"
+
+describe("findAvailablePort", () => {
+  it("returns a bindable port", async () => {
+    const port = await findAvailablePort({ host: "127.0.0.1", preferredPort: 51234 })
+
+    const server = net.createServer()
+    await new Promise<void>((resolve, reject) => {
+      server.once("error", reject)
+      server.listen(port, "127.0.0.1", () => resolve())
+    })
+
+    await new Promise<void>((resolve) => server.close(() => resolve()))
+    expect(port).toBeGreaterThan(0)
+  })
+
+  it("skips a port that is already in use", async () => {
+    const blocker = net.createServer()
+    await new Promise<void>((resolve, reject) => {
+      blocker.once("error", reject)
+      blocker.listen(0, "127.0.0.1", () => resolve())
+    })
+
+    const address = blocker.address()
+    if (!address || typeof address === "string") throw new Error("Unexpected address")
+    const usedPort = address.port
+
+    const port = await findAvailablePort({
+      host: "127.0.0.1",
+      preferredPort: usedPort,
+      maxTries: 50,
+    })
+
+    expect(port).not.toBe(usedPort)
+    await new Promise<void>((resolve) => blocker.close(() => resolve()))
+  })
+})

package/src/cli/ports.ts

@@ -0,0 +1,43 @@
+import net from "node:net"
+
+export interface FindAvailablePortOptions {
+  host: string
+  preferredPort: number
+  maxTries?: number
+}
+
+export async function findAvailablePort({
+  host,
+  preferredPort,
+  maxTries = 20,
+}: FindAvailablePortOptions): Promise<number> {
+  if (!Number.isInteger(preferredPort) || preferredPort <= 0) {
+    throw new Error("preferredPort must be a positive integer")
+  }
+
+  for (let offset = 0; offset < maxTries; offset++) {
+    const port = preferredPort + offset
+    const ok = await canListen({ host, port })
+    if (ok) return port
+  }
+
+  throw new Error(
+    `No available port found starting at ${preferredPort} after ${maxTries} attempts`,
+  )
+}
+
+function canListen({ host, port }: { host: string; port: number }): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer()
+
+    server.once("error", () => {
+      resolve(false)
+    })
+
+    server.once("listening", () => {
+      server.close(() => resolve(true))
+    })
+
+    server.listen(port, host)
+  })
+}

package/src/ding-policy.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest"
+
+import { computeWaitingDing } from "./ding-policy"
+
+describe("computeWaitingDing", () => {
+  it("dings on first observation when waiting", () => {
+    const res = computeWaitingDing({
+      prev: { prevWaiting: null, lastLeftWaitingAtMs: null },
+      waiting: true,
+      nowMs: 1000,
+    })
+
+    expect(res.play).toBe(true)
+    expect(res.next.prevWaiting).toBe(true)
+  })
+
+  it("dings when entering waiting if last idle round-trip is >= 20s", () => {
+    const res = computeWaitingDing({
+      prev: { prevWaiting: false, lastLeftWaitingAtMs: 1000 },
+      waiting: true,
+      nowMs: 21_000,
+    })
+
+    expect(res.play).toBe(true)
+  })
+
+  it("suppresses ding when waiting round-trip is < 20s", () => {
+    const left = computeWaitingDing({
+      prev: { prevWaiting: true, lastLeftWaitingAtMs: null },
+      waiting: false,
+      nowMs: 1000,
+    })
+
+    expect(left.play).toBe(false)
+    expect(left.next.prevWaiting).toBe(false)
+    expect(left.next.lastLeftWaitingAtMs).toBe(1000)
+
+    const back = computeWaitingDing({
+      prev: left.next,
+      waiting: true,
+      nowMs: 20_999,
+    })
+
+    expect(back.play).toBe(false)
+    expect(back.next.prevWaiting).toBe(true)
+    expect(back.next.lastLeftWaitingAtMs).toBe(null)
+  })
+})

package/src/ding-policy.ts

@@ -0,0 +1,39 @@
+export type WaitingDingState = {
+  prevWaiting: boolean | null
+  lastLeftWaitingAtMs: number | null
+}
+
+export function computeWaitingDing(opts: {
+  prev: WaitingDingState
+  waiting: boolean
+  nowMs: number
+  suppressMs?: number
+}): { play: boolean; next: WaitingDingState } {
+  const suppressMs = opts.suppressMs ?? 20_000
+
+  let lastLeftWaitingAtMs = opts.prev.lastLeftWaitingAtMs
+
+  if (opts.prev.prevWaiting === true && opts.waiting === false) {
+    lastLeftWaitingAtMs = opts.nowMs
+  }
+
+  let play = false
+  if (opts.prev.prevWaiting === null && opts.waiting === true) {
+    play = true
+  } else if (opts.prev.prevWaiting === false && opts.waiting === true) {
+    const dt = typeof lastLeftWaitingAtMs === "number" ? opts.nowMs - lastLeftWaitingAtMs : null
+    play = !(typeof dt === "number" && dt >= 0 && dt < suppressMs)
+  }
+
+  if (opts.waiting === true) {
+    lastLeftWaitingAtMs = null
+  }
+
+  return {
+    play,
+    next: {
+      prevWaiting: opts.waiting,
+      lastLeftWaitingAtMs,
+    },
+  }
+}