@hasna/todos 0.9.7 → 0.9.9

package/dist/server/index.js

@@ -0,0 +1,1285 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/types/index.ts
+var VersionConflictError, TaskNotFoundError, ProjectNotFoundError, LockError, CompletionGuardError;
+var init_types = __esm(() => {
+  VersionConflictError = class VersionConflictError extends Error {
+    taskId;
+    expectedVersion;
+    actualVersion;
+    constructor(taskId, expectedVersion, actualVersion) {
+      super(`Version conflict for task ${taskId}: expected ${expectedVersion}, got ${actualVersion}`);
+      this.taskId = taskId;
+      this.expectedVersion = expectedVersion;
+      this.actualVersion = actualVersion;
+      this.name = "VersionConflictError";
+    }
+  };
+  TaskNotFoundError = class TaskNotFoundError extends Error {
+    taskId;
+    constructor(taskId) {
+      super(`Task not found: ${taskId}`);
+      this.taskId = taskId;
+      this.name = "TaskNotFoundError";
+    }
+  };
+  ProjectNotFoundError = class ProjectNotFoundError extends Error {
+    projectId;
+    constructor(projectId) {
+      super(`Project not found: ${projectId}`);
+      this.projectId = projectId;
+      this.name = "ProjectNotFoundError";
+    }
+  };
+  LockError = class LockError extends Error {
+    taskId;
+    lockedBy;
+    constructor(taskId, lockedBy) {
+      super(`Task ${taskId} is locked by ${lockedBy}`);
+      this.taskId = taskId;
+      this.lockedBy = lockedBy;
+      this.name = "LockError";
+    }
+  };
+  CompletionGuardError = class CompletionGuardError extends Error {
+    reason;
+    retryAfterSeconds;
+    constructor(reason, retryAfterSeconds) {
+      super(reason);
+      this.reason = reason;
+      this.retryAfterSeconds = retryAfterSeconds;
+      this.name = "CompletionGuardError";
+    }
+  };
+});
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+function isInMemoryDb(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
+function findNearestTodosDb(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join(dir, ".todos", "todos.db");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function findGitRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, ".git")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function getDbPath() {
+  if (process.env["TODOS_DB_PATH"]) {
+    return process.env["TODOS_DB_PATH"];
+  }
+  const cwd = process.cwd();
+  const nearest = findNearestTodosDb(cwd);
+  if (nearest)
+    return nearest;
+  if (process.env["TODOS_DB_SCOPE"] === "project") {
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot) {
+      return join(gitRoot, ".todos", "todos.db");
+    }
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".todos", "todos.db");
+}
+function ensureDir(filePath) {
+  if (isInMemoryDb(filePath))
+    return;
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || getDbPath();
+  ensureDir(path);
+  _db = new Database(path, { create: true });
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+  runMigrations(_db);
+  backfillTaskTags(_db);
+  return _db;
+}
+function runMigrations(db) {
+  try {
+    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
+    const currentLevel = result?.max_id ?? 0;
+    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
+      db.exec(MIGRATIONS[i]);
+    }
+  } catch {
+    for (const migration of MIGRATIONS) {
+      db.exec(migration);
+    }
+  }
+  ensureTableMigrations(db);
+}
+function ensureTableMigrations(db) {
+  try {
+    const hasAgents = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='agents'").get();
+    if (!hasAgents) {
+      db.exec(MIGRATIONS[4]);
+    }
+  } catch {}
+  try {
+    db.query("SELECT task_prefix FROM projects LIMIT 0").get();
+  } catch {
+    try {
+      db.exec(MIGRATIONS[5]);
+    } catch {}
+  }
+}
+function backfillTaskTags(db) {
+  try {
+    const count = db.query("SELECT COUNT(*) as count FROM task_tags").get();
+    if (count && count.count > 0)
+      return;
+  } catch {
+    return;
+  }
+  try {
+    const rows = db.query("SELECT id, tags FROM tasks WHERE tags IS NOT NULL AND tags != '[]'").all();
+    if (rows.length === 0)
+      return;
+    const insert = db.prepare("INSERT OR IGNORE INTO task_tags (task_id, tag) VALUES (?, ?)");
+    for (const row of rows) {
+      if (!row.tags)
+        continue;
+      let tags = [];
+      try {
+        tags = JSON.parse(row.tags);
+      } catch {
+        continue;
+      }
+      for (const tag of tags) {
+        if (tag)
+          insert.run(row.id, tag);
+      }
+    }
+  } catch {}
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function isLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  const lockTime = new Date(lockedAt).getTime();
+  const expiryMs = LOCK_EXPIRY_MINUTES * 60 * 1000;
+  return Date.now() - lockTime > expiryMs;
+}
+function lockExpiryCutoff(nowMs = Date.now()) {
+  const expiryMs = LOCK_EXPIRY_MINUTES * 60 * 1000;
+  return new Date(nowMs - expiryMs).toISOString();
+}
+function clearExpiredLocks(db) {
+  const cutoff = lockExpiryCutoff();
+  db.run("UPDATE tasks SET locked_by = NULL, locked_at = NULL WHERE locked_at IS NOT NULL AND locked_at < ?", [cutoff]);
+}
+var LOCK_EXPIRY_MINUTES = 30, MIGRATIONS, _db = null;
+var init_database = __esm(() => {
+  MIGRATIONS = [
+    `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    parent_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low', 'medium', 'high', 'critical')),
+    agent_id TEXT,
+    assigned_to TEXT,
+    session_id TEXT,
+    working_dir TEXT,
+    tags TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    version INTEGER NOT NULL DEFAULT 1,
+    locked_by TEXT,
+    locked_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS task_dependencies (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    depends_on TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    PRIMARY KEY (task_id, depends_on),
+    CHECK (task_id != depends_on)
+  );
+
+  CREATE TABLE IF NOT EXISTS task_comments (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    session_id TEXT,
+    content TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    working_dir TEXT,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_activity TEXT NOT NULL DEFAULT (datetime('now')),
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+  CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_to);
+  CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+  CREATE INDEX IF NOT EXISTS idx_comments_task ON task_comments(task_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (1);
+  `,
+    `
+  ALTER TABLE projects ADD COLUMN task_list_id TEXT;
+  INSERT OR IGNORE INTO _migrations (id) VALUES (2);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_tags (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (task_id, tag)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_tags_tag ON task_tags(tag);
+  CREATE INDEX IF NOT EXISTS idx_task_tags_task ON task_tags(task_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (3);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS plans (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'archived')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_plans_project ON plans(project_id);
+  CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+  ALTER TABLE tasks ADD COLUMN plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (4);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name);
+
+  CREATE TABLE IF NOT EXISTS task_lists (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    slug TEXT NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(project_id, slug)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_lists_project ON task_lists(project_id);
+  CREATE INDEX IF NOT EXISTS idx_task_lists_slug ON task_lists(slug);
+
+  ALTER TABLE tasks ADD COLUMN task_list_id TEXT REFERENCES task_lists(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_task_list ON tasks(task_list_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (5);
+  `,
+    `
+  ALTER TABLE projects ADD COLUMN task_prefix TEXT;
+  ALTER TABLE projects ADD COLUMN task_counter INTEGER NOT NULL DEFAULT 0;
+
+  ALTER TABLE tasks ADD COLUMN short_id TEXT;
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_short_id ON tasks(short_id) WHERE short_id IS NOT NULL;
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (6);
+  `,
+    `
+  ALTER TABLE tasks ADD COLUMN due_at TEXT;
+  CREATE INDEX IF NOT EXISTS idx_tasks_due_at ON tasks(due_at);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (7);
+  `
+  ];
+});
+
+// src/db/projects.ts
+var exports_projects = {};
+__export(exports_projects, {
+  updateProject: () => updateProject,
+  slugify: () => slugify,
+  nextTaskShortId: () => nextTaskShortId,
+  listProjects: () => listProjects,
+  getProjectByPath: () => getProjectByPath,
+  getProject: () => getProject,
+  ensureProject: () => ensureProject,
+  deleteProject: () => deleteProject,
+  createProject: () => createProject
+});
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function generatePrefix(name, db) {
+  const words = name.replace(/[^a-zA-Z0-9\s]/g, "").trim().split(/\s+/);
+  let prefix;
+  if (words.length >= 3) {
+    prefix = words.slice(0, 3).map((w) => w[0].toUpperCase()).join("");
+  } else if (words.length === 2) {
+    prefix = (words[0].slice(0, 2) + words[1][0]).toUpperCase();
+  } else {
+    prefix = words[0].slice(0, 3).toUpperCase();
+  }
+  let candidate = prefix;
+  let suffix = 1;
+  while (true) {
+    const existing = db.query("SELECT id FROM projects WHERE task_prefix = ?").get(candidate);
+    if (!existing)
+      return candidate;
+    suffix++;
+    candidate = `${prefix}${suffix}`;
+  }
+}
+function createProject(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const taskListId = input.task_list_id ?? `todos-${slugify(input.name)}`;
+  const taskPrefix = input.task_prefix || generatePrefix(input.name, d);
+  d.run(`INSERT INTO projects (id, name, path, description, task_list_id, task_prefix, task_counter, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)`, [id, input.name, input.path, input.description || null, taskListId, taskPrefix, timestamp, timestamp]);
+  return getProject(id, d);
+}
+function getProject(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM projects WHERE id = ?").get(id);
+  return row;
+}
+function getProjectByPath(path, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  return row;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM projects ORDER BY name").all();
+}
+function updateProject(id, input, db) {
+  const d = db || getDatabase();
+  const project = getProject(id, d);
+  if (!project)
+    throw new ProjectNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  params.push(id);
+  d.run(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getProject(id, d);
+}
+function deleteProject(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM projects WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function nextTaskShortId(projectId, db) {
+  const d = db || getDatabase();
+  const project = getProject(projectId, d);
+  if (!project || !project.task_prefix)
+    return null;
+  d.run("UPDATE projects SET task_counter = task_counter + 1, updated_at = ? WHERE id = ?", [now(), projectId]);
+  const updated = getProject(projectId, d);
+  const padded = String(updated.task_counter).padStart(5, "0");
+  return `${updated.task_prefix}-${padded}`;
+}
+function ensureProject(name, path, db) {
+  const d = db || getDatabase();
+  const existing = getProjectByPath(path, d);
+  if (existing) {
+    if (!existing.task_prefix) {
+      const prefix = generatePrefix(existing.name, d);
+      d.run("UPDATE projects SET task_prefix = ?, updated_at = ? WHERE id = ?", [prefix, now(), existing.id]);
+      return getProject(existing.id, d);
+    }
+    return existing;
+  }
+  return createProject({ name, path }, d);
+}
+var init_projects = __esm(() => {
+  init_types();
+  init_database();
+});
+
+// src/db/agents.ts
+var exports_agents = {};
+__export(exports_agents, {
+  updateAgentActivity: () => updateAgentActivity,
+  registerAgent: () => registerAgent,
+  listAgents: () => listAgents,
+  getAgentByName: () => getAgentByName,
+  getAgent: () => getAgent,
+  deleteAgent: () => deleteAgent
+});
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function rowToAgent(row) {
+  return {
+    ...row,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function registerAgent(input, db) {
+  const d = db || getDatabase();
+  const existing = getAgentByName(input.name, d);
+  if (existing) {
+    d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), existing.id]);
+    return getAgent(existing.id, d);
+  }
+  const id = shortUuid();
+  const timestamp = now();
+  d.run(`INSERT INTO agents (id, name, description, metadata, created_at, last_seen_at)
+     VALUES (?, ?, ?, ?, ?, ?)`, [id, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp, timestamp]);
+  return getAgent(id, d);
+}
+function getAgent(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM agents WHERE id = ?").get(id);
+  return row ? rowToAgent(row) : null;
+}
+function getAgentByName(name, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM agents WHERE name = ?").get(name);
+  return row ? rowToAgent(row) : null;
+}
+function listAgents(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM agents ORDER BY name").all().map(rowToAgent);
+}
+function updateAgentActivity(id, db) {
+  const d = db || getDatabase();
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), id]);
+}
+function deleteAgent(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM agents WHERE id = ?", [id]).changes > 0;
+}
+var init_agents = __esm(() => {
+  init_database();
+});
+
+// src/server/serve.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, dirname as dirname2, extname } from "path";
+import { fileURLToPath } from "url";
+
+// src/db/tasks.ts
+init_types();
+init_database();
+init_projects();
+
+// src/lib/completion-guard.ts
+init_types();
+
+// src/lib/config.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/sync-utils.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+var HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/config.ts
+var CONFIG_PATH = join2(HOME, ".todos", "config.json");
+var cached = null;
+function loadConfig() {
+  if (cached)
+    return cached;
+  if (!existsSync3(CONFIG_PATH)) {
+    cached = {};
+    return cached;
+  }
+  const config = readJsonFile(CONFIG_PATH) || {};
+  if (typeof config.sync_agents === "string") {
+    config.sync_agents = config.sync_agents.split(",").map((a) => a.trim()).filter(Boolean);
+  }
+  cached = config;
+  return cached;
+}
+var GUARD_DEFAULTS = {
+  enabled: false,
+  min_work_seconds: 30,
+  max_completions_per_window: 5,
+  window_minutes: 10,
+  cooldown_seconds: 60
+};
+function getCompletionGuardConfig(projectPath) {
+  const config = loadConfig();
+  const global = { ...GUARD_DEFAULTS, ...config.completion_guard };
+  if (projectPath && config.project_overrides?.[projectPath]?.completion_guard) {
+    return { ...global, ...config.project_overrides[projectPath].completion_guard };
+  }
+  return global;
+}
+
+// src/lib/completion-guard.ts
+init_projects();
+function checkCompletionGuard(task, agentId, db, configOverride) {
+  let config;
+  if (configOverride) {
+    config = configOverride;
+  } else {
+    const projectPath = task.project_id ? getProject(task.project_id, db)?.path : null;
+    config = getCompletionGuardConfig(projectPath);
+  }
+  if (!config.enabled)
+    return;
+  if (task.status !== "in_progress") {
+    throw new CompletionGuardError(`Task must be in 'in_progress' status before completing (current: '${task.status}'). Use start_task first.`);
+  }
+  const agent = agentId || task.assigned_to || task.agent_id;
+  if (config.min_work_seconds && task.locked_at) {
+    const startedAt = new Date(task.locked_at).getTime();
+    const elapsedSeconds = (Date.now() - startedAt) / 1000;
+    if (elapsedSeconds < config.min_work_seconds) {
+      const remaining = Math.ceil(config.min_work_seconds - elapsedSeconds);
+      throw new CompletionGuardError(`Too fast: task was started ${Math.floor(elapsedSeconds)}s ago. Minimum work duration is ${config.min_work_seconds}s. Wait ${remaining}s.`, remaining);
+    }
+  }
+  if (agent && config.max_completions_per_window && config.window_minutes) {
+    const windowStart = new Date(Date.now() - config.window_minutes * 60 * 1000).toISOString();
+    const result = db.query(`SELECT COUNT(*) as count FROM tasks
+         WHERE completed_at > ? AND (assigned_to = ? OR agent_id = ?)`).get(windowStart, agent, agent);
+    if (result.count >= config.max_completions_per_window) {
+      throw new CompletionGuardError(`Rate limit: ${result.count} tasks completed in the last ${config.window_minutes} minutes (max ${config.max_completions_per_window}). Slow down.`);
+    }
+  }
+  if (agent && config.cooldown_seconds) {
+    const result = db.query(`SELECT MAX(completed_at) as last_completed FROM tasks
+         WHERE completed_at IS NOT NULL AND (assigned_to = ? OR agent_id = ?) AND id != ?`).get(agent, agent, task.id);
+    if (result.last_completed) {
+      const elapsedSeconds = (Date.now() - new Date(result.last_completed).getTime()) / 1000;
+      if (elapsedSeconds < config.cooldown_seconds) {
+        const remaining = Math.ceil(config.cooldown_seconds - elapsedSeconds);
+        throw new CompletionGuardError(`Cooldown: last completion was ${Math.floor(elapsedSeconds)}s ago. Wait ${remaining}s between completions.`, remaining);
+      }
+    }
+  }
+}
+
+// src/db/tasks.ts
+function rowToTask(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    status: row.status,
+    priority: row.priority
+  };
+}
+function insertTaskTags(taskId, tags, db) {
+  if (tags.length === 0)
+    return;
+  const stmt = db.prepare("INSERT OR IGNORE INTO task_tags (task_id, tag) VALUES (?, ?)");
+  for (const tag of tags) {
+    if (tag)
+      stmt.run(taskId, tag);
+  }
+}
+function replaceTaskTags(taskId, tags, db) {
+  db.run("DELETE FROM task_tags WHERE task_id = ?", [taskId]);
+  insertTaskTags(taskId, tags, db);
+}
+function createTask(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const tags = input.tags || [];
+  const shortId = input.project_id ? nextTaskShortId(input.project_id, d) : null;
+  const title = shortId ? `${shortId}: ${input.title}` : input.title;
+  d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`, [
+    id,
+    shortId,
+    input.project_id || null,
+    input.parent_id || null,
+    input.plan_id || null,
+    input.task_list_id || null,
+    title,
+    input.description || null,
+    input.status || "pending",
+    input.priority || "medium",
+    input.agent_id || null,
+    input.assigned_to || null,
+    input.session_id || null,
+    input.working_dir || null,
+    JSON.stringify(tags),
+    JSON.stringify(input.metadata || {}),
+    timestamp,
+    timestamp,
+    input.due_at || null
+  ]);
+  if (tags.length > 0) {
+    insertTaskTags(id, tags, d);
+  }
+  return getTask(id, d);
+}
+function getTask(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return rowToTask(row);
+}
+function listTasks(filter = {}, db) {
+  const d = db || getDatabase();
+  clearExpiredLocks(d);
+  const conditions = [];
+  const params = [];
+  if (filter.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter.parent_id !== undefined) {
+    if (filter.parent_id === null) {
+      conditions.push("parent_id IS NULL");
+    } else {
+      conditions.push("parent_id = ?");
+      params.push(filter.parent_id);
+    }
+  }
+  if (filter.status) {
+    if (Array.isArray(filter.status)) {
+      conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
+      params.push(...filter.status);
+    } else {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+  }
+  if (filter.priority) {
+    if (Array.isArray(filter.priority)) {
+      conditions.push(`priority IN (${filter.priority.map(() => "?").join(",")})`);
+      params.push(...filter.priority);
+    } else {
+      conditions.push("priority = ?");
+      params.push(filter.priority);
+    }
+  }
+  if (filter.assigned_to) {
+    conditions.push("assigned_to = ?");
+    params.push(filter.assigned_to);
+  }
+  if (filter.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  if (filter.session_id) {
+    conditions.push("session_id = ?");
+    params.push(filter.session_id);
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    const placeholders = filter.tags.map(() => "?").join(",");
+    conditions.push(`id IN (SELECT task_id FROM task_tags WHERE tag IN (${placeholders}))`);
+    params.push(...filter.tags);
+  }
+  if (filter.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(filter.plan_id);
+  }
+  if (filter.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(filter.task_list_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  let limitClause = "";
+  if (filter.limit) {
+    limitClause = " LIMIT ?";
+    params.push(filter.limit);
+    if (filter.offset) {
+      limitClause += " OFFSET ?";
+      params.push(filter.offset);
+    }
+  }
+  const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY
+       CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+       created_at DESC${limitClause}`).all(...params);
+  return rows.map(rowToTask);
+}
+function updateTask(id, input, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (task.version !== input.version) {
+    throw new VersionConflictError(id, input.version, task.version);
+  }
+  const sets = ["version = version + 1", "updated_at = ?"];
+  const params = [now()];
+  if (input.title !== undefined) {
+    sets.push("title = ?");
+    params.push(input.title);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    if (input.status === "completed") {
+      checkCompletionGuard(task, task.assigned_to || task.agent_id || null, d);
+    }
+    sets.push("status = ?");
+    params.push(input.status);
+    if (input.status === "completed") {
+      sets.push("completed_at = ?");
+      params.push(now());
+    }
+  }
+  if (input.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(input.priority);
+  }
+  if (input.assigned_to !== undefined) {
+    sets.push("assigned_to = ?");
+    params.push(input.assigned_to);
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    params.push(input.plan_id);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  if (input.due_at !== undefined) {
+    sets.push("due_at = ?");
+    params.push(input.due_at);
+  }
+  params.push(id, input.version);
+  const result = d.run(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ? AND version = ?`, params);
+  if (result.changes === 0) {
+    const current = getTask(id, d);
+    throw new VersionConflictError(id, input.version, current?.version ?? -1);
+  }
+  if (input.tags !== undefined) {
+    replaceTaskTags(id, input.tags, d);
+  }
+  return getTask(id, d);
+}
+function deleteTask(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM tasks WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function startTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const cutoff = lockExpiryCutoff();
+  const timestamp = now();
+  const result = d.run(`UPDATE tasks SET status = 'in_progress', assigned_to = ?, locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ? AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, agentId, timestamp, timestamp, id, agentId, cutoff]);
+  if (result.changes === 0) {
+    const current = getTask(id, d);
+    if (!current)
+      throw new TaskNotFoundError(id);
+    if (current.locked_by && current.locked_by !== agentId && !isLockExpired(current.locked_at)) {
+      throw new LockError(id, current.locked_by);
+    }
+  }
+  return getTask(id, d);
+}
+function completeTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (agentId && task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
+    throw new LockError(id, task.locked_by);
+  }
+  checkCompletionGuard(task, agentId || null, d);
+  const timestamp = now();
+  d.run(`UPDATE tasks SET status = 'completed', locked_by = NULL, locked_at = NULL, completed_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ?`, [timestamp, timestamp, id]);
+  return getTask(id, d);
+}
+
+// src/server/serve.ts
+init_projects();
+init_agents();
+init_database();
+function resolveDashboardDir() {
+  const candidates = [];
+  try {
+    const scriptDir = dirname2(fileURLToPath(import.meta.url));
+    candidates.push(join3(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join3(scriptDir, "..", "..", "dashboard", "dist"));
+  } catch {}
+  if (process.argv[1]) {
+    const mainDir = dirname2(process.argv[1]);
+    candidates.push(join3(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join3(mainDir, "..", "..", "dashboard", "dist"));
+  }
+  candidates.push(join3(process.cwd(), "dashboard", "dist"));
+  for (const candidate of candidates) {
+    if (existsSync4(candidate))
+      return candidate;
+  }
+  return join3(process.cwd(), "dashboard", "dist");
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var SECURITY_HEADERS = {
+  "X-Content-Type-Options": "nosniff",
+  "X-Frame-Options": "DENY"
+};
+function json(data, status = 200, port) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": port ? `http://localhost:${port}` : "*",
+      ...SECURITY_HEADERS
+    }
+  });
+}
+function serveStaticFile(filePath) {
+  if (!existsSync4(filePath))
+    return null;
+  const ext = extname(filePath);
+  const contentType = MIME_TYPES[ext] || "application/octet-stream";
+  return new Response(Bun.file(filePath), {
+    headers: { "Content-Type": contentType }
+  });
+}
+function taskToSummary(task) {
+  return {
+    id: task.id,
+    short_id: task.short_id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    priority: task.priority,
+    project_id: task.project_id,
+    plan_id: task.plan_id,
+    task_list_id: task.task_list_id,
+    agent_id: task.agent_id,
+    assigned_to: task.assigned_to,
+    locked_by: task.locked_by,
+    tags: task.tags,
+    version: task.version,
+    created_at: task.created_at,
+    updated_at: task.updated_at,
+    completed_at: task.completed_at,
+    due_at: task.due_at
+  };
+}
+async function startServer(port, options) {
+  const shouldOpen = options?.open ?? true;
+  getDatabase();
+  const dashboardDir = resolveDashboardDir();
+  const dashboardExists = existsSync4(dashboardDir);
+  if (!dashboardExists) {
+    console.error(`
+Dashboard not found at: ${dashboardDir}`);
+    console.error(`Run this to build it:
+`);
+    console.error(`  cd dashboard && bun install && bun run build
+`);
+  }
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+      const method = req.method;
+      if (method === "OPTIONS") {
+        return new Response(null, {
+          headers: {
+            "Access-Control-Allow-Origin": `http://localhost:${port}`,
+            "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type"
+          }
+        });
+      }
+      if (path === "/api/stats" && method === "GET") {
+        const all = listTasks({ limit: 1e4 });
+        const projects = listProjects();
+        const agents = listAgents();
+        return json({
+          total_tasks: all.length,
+          pending: all.filter((t) => t.status === "pending").length,
+          in_progress: all.filter((t) => t.status === "in_progress").length,
+          completed: all.filter((t) => t.status === "completed").length,
+          failed: all.filter((t) => t.status === "failed").length,
+          cancelled: all.filter((t) => t.status === "cancelled").length,
+          projects: projects.length,
+          agents: agents.length
+        }, 200, port);
+      }
+      if (path === "/api/tasks" && method === "GET") {
+        const status = url.searchParams.get("status") || undefined;
+        const projectId = url.searchParams.get("project_id") || undefined;
+        const limitParam = url.searchParams.get("limit");
+        const tasks = listTasks({
+          status,
+          project_id: projectId,
+          limit: limitParam ? parseInt(limitParam, 10) : undefined
+        });
+        return json(tasks.map(taskToSummary), 200, port);
+      }
+      if (path === "/api/tasks" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.title)
+            return json({ error: "Missing 'title'" }, 400, port);
+          const task = createTask({
+            title: body.title,
+            description: body.description,
+            priority: body.priority,
+            project_id: body.project_id
+          });
+          return json(taskToSummary(task), 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to create task" }, 500, port);
+        }
+      }
+      if (path === "/api/tasks/export" && method === "GET") {
+        const format = url.searchParams.get("format") || "json";
+        const status = url.searchParams.get("status") || undefined;
+        const projectId = url.searchParams.get("project_id") || undefined;
+        const tasks = listTasks({ status, project_id: projectId, limit: 1e4 });
+        const summaries = tasks.map(taskToSummary);
+        if (format === "csv") {
+          const headers = ["id", "short_id", "title", "status", "priority", "project_id", "assigned_to", "agent_id", "created_at", "updated_at", "completed_at", "due_at"];
+          const rows = summaries.map((t) => headers.map((h) => {
+            const val = t[h];
+            if (val === null || val === undefined)
+              return "";
+            const str = String(val);
+            return str.includes(",") || str.includes('"') || str.includes(`
+`) ? `"${str.replace(/"/g, '""')}"` : str;
+          }).join(","));
+          const csv = [headers.join(","), ...rows].join(`
+`);
+          return new Response(csv, {
+            headers: {
+              "Content-Type": "text/csv",
+              "Content-Disposition": "attachment; filename=tasks.csv",
+              ...SECURITY_HEADERS
+            }
+          });
+        }
+        return new Response(JSON.stringify(summaries, null, 2), {
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Disposition": "attachment; filename=tasks.json",
+            ...SECURITY_HEADERS
+          }
+        });
+      }
+      if (path === "/api/tasks/bulk" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.ids?.length || !body.action)
+            return json({ error: "Missing ids or action" }, 400, port);
+          const results = [];
+          for (const id of body.ids) {
+            try {
+              if (body.action === "delete") {
+                deleteTask(id);
+                results.push({ id, success: true });
+              } else if (body.action === "start") {
+                startTask(id, "dashboard");
+                results.push({ id, success: true });
+              } else if (body.action === "complete") {
+                completeTask(id, "dashboard");
+                results.push({ id, success: true });
+              }
+            } catch (e) {
+              results.push({ id, success: false, error: e instanceof Error ? e.message : "Failed" });
+            }
+          }
+          return json({ results, succeeded: results.filter((r) => r.success).length, failed: results.filter((r) => !r.success).length }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const taskMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
+      if (taskMatch) {
+        const id = taskMatch[1];
+        if (method === "GET") {
+          const task = getTask(id);
+          if (!task)
+            return json({ error: "Task not found" }, 404, port);
+          return json(taskToSummary(task), 200, port);
+        }
+        if (method === "PATCH") {
+          try {
+            const body = await req.json();
+            const task = getTask(id);
+            if (!task)
+              return json({ error: "Task not found" }, 404, port);
+            const updated = updateTask(id, {
+              ...body,
+              version: task.version
+            });
+            return json(taskToSummary(updated), 200, port);
+          } catch (e) {
+            return json({ error: e instanceof Error ? e.message : "Failed to update task" }, 500, port);
+          }
+        }
+        if (method === "DELETE") {
+          const deleted = deleteTask(id);
+          if (!deleted)
+            return json({ error: "Task not found" }, 404, port);
+          return json({ success: true }, 200, port);
+        }
+      }
+      const startMatch = path.match(/^\/api\/tasks\/([^/]+)\/start$/);
+      if (startMatch && method === "POST") {
+        const id = startMatch[1];
+        try {
+          const task = startTask(id, "dashboard");
+          return json(taskToSummary(task), 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to start task" }, 500, port);
+        }
+      }
+      const completeMatch = path.match(/^\/api\/tasks\/([^/]+)\/complete$/);
+      if (completeMatch && method === "POST") {
+        const id = completeMatch[1];
+        try {
+          const task = completeTask(id, "dashboard");
+          return json(taskToSummary(task), 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to complete task" }, 500, port);
+        }
+      }
+      if (path === "/api/projects" && method === "GET") {
+        return json(listProjects(), 200, port);
+      }
+      if (path === "/api/agents" && method === "GET") {
+        return json(listAgents(), 200, port);
+      }
+      if (path === "/api/projects" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.name || !body.path)
+            return json({ error: "Missing name or path" }, 400, port);
+          const { createProject: createProject2 } = await Promise.resolve().then(() => (init_projects(), exports_projects));
+          const project = createProject2({ name: body.name, path: body.path, description: body.description });
+          return json(project, 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to create project" }, 500, port);
+        }
+      }
+      const projectDeleteMatch = path.match(/^\/api\/projects\/([^/]+)$/);
+      if (projectDeleteMatch && method === "DELETE") {
+        const id = projectDeleteMatch[1];
+        const { deleteProject: deleteProject2 } = await Promise.resolve().then(() => (init_projects(), exports_projects));
+        const deleted = deleteProject2(id);
+        if (!deleted)
+          return json({ error: "Project not found" }, 404, port);
+        return json({ success: true }, 200, port);
+      }
+      if (path === "/api/agents" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.name)
+            return json({ error: "Missing name" }, 400, port);
+          const { registerAgent: registerAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+          const agent = registerAgent2({ name: body.name, description: body.description });
+          return json(agent, 201, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to register agent" }, 500, port);
+        }
+      }
+      const agentDeleteMatch = path.match(/^\/api\/agents\/([^/]+)$/);
+      if (agentDeleteMatch && method === "DELETE") {
+        const id = agentDeleteMatch[1];
+        const { deleteAgent: deleteAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+        const deleted = deleteAgent2(id);
+        if (!deleted)
+          return json({ error: "Agent not found" }, 404, port);
+        return json({ success: true }, 200, port);
+      }
+      if (path === "/api/agents/bulk" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.ids?.length || body.action !== "delete")
+            return json({ error: "Missing ids or invalid action" }, 400, port);
+          const { deleteAgent: deleteAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+          let succeeded = 0;
+          for (const id of body.ids) {
+            if (deleteAgent2(id))
+              succeeded++;
+          }
+          return json({ succeeded, failed: body.ids.length - succeeded }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/projects/bulk" && method === "POST") {
+        try {
+          const body = await req.json();
+          if (!body.ids?.length || body.action !== "delete")
+            return json({ error: "Missing ids or invalid action" }, 400, port);
+          const { deleteProject: deleteProject2 } = await Promise.resolve().then(() => (init_projects(), exports_projects));
+          let succeeded = 0;
+          for (const id of body.ids) {
+            if (deleteProject2(id))
+              succeeded++;
+          }
+          return json({ succeeded, failed: body.ids.length - succeeded }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (dashboardExists && (method === "GET" || method === "HEAD")) {
+        if (path !== "/") {
+          const filePath = join3(dashboardDir, path);
+          const res2 = serveStaticFile(filePath);
+          if (res2)
+            return res2;
+        }
+        const indexPath = join3(dashboardDir, "index.html");
+        const res = serveStaticFile(indexPath);
+        if (res)
+          return res;
+      }
+      return json({ error: "Not found" }, 404, port);
+    }
+  });
+  const shutdown = () => {
+    server.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const serverUrl = `http://localhost:${port}`;
+  console.log(`Todos Dashboard running at ${serverUrl}`);
+  if (shouldOpen) {
+    try {
+      const { exec } = await import("child_process");
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${openCmd} ${serverUrl}`);
+    } catch {}
+  }
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 19427;
+function parsePort() {
+  const portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
+  if (portArg) {
+    if (portArg.includes("=")) {
+      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+    }
+    const idx = process.argv.indexOf(portArg);
+    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
+  }
+  return DEFAULT_PORT;
+}
+startServer(parsePort());