shipwright-cli 3.2.0 → 3.3.0

package/dashboard/services/config.ts

@@ -0,0 +1,26 @@
+// Centralized configuration for dashboard services
+import { join } from "path";
+
+const HOME = process.env.HOME || "";
+
+export const config = {
+  port: parseInt(
+    process.argv[2] || process.env.SHIPWRIGHT_DASHBOARD_PORT || "8767",
+  ),
+  home: HOME,
+  eventsFile: join(HOME, ".shipwright", "events.jsonl"),
+  daemonState: join(HOME, ".shipwright", "daemon-state.json"),
+  logsDir: join(HOME, ".shipwright", "logs"),
+  heartbeatDir: join(HOME, ".shipwright", "heartbeats"),
+  machinesFile: join(HOME, ".shipwright", "machines.json"),
+  costsFile: join(HOME, ".shipwright", "costs.json"),
+  budgetFile: join(HOME, ".shipwright", "budget.json"),
+  memoryDir: join(HOME, ".shipwright", "memory"),
+  publicDir: join(import.meta.dir, "../public"),
+  dbFile: join(HOME, ".shipwright", "shipwright.db"),
+  sessionsFile: join(HOME, ".shipwright", "sessions.json"),
+  developerRegistryFile: join(HOME, ".shipwright", "developer-registry.json"),
+  teamEventsFile: join(HOME, ".shipwright", "team-events.jsonl"),
+  inviteTokensFile: join(HOME, ".shipwright", "invite-tokens.json"),
+  notificationsConfigFile: join(HOME, ".shipwright", "notifications.json"),
+};

package/dashboard/services/db.ts

@@ -0,0 +1,118 @@
+import { Database } from "bun:sqlite";
+import { existsSync } from "fs";
+import { config } from "./config.js";
+import type { DaemonEvent } from "../types/index.js";
+
+let db: Database | null = null;
+
+export function getDb(): Database | null {
+  if (db) return db;
+  try {
+    if (!existsSync(config.dbFile)) return null;
+    db = new Database(config.dbFile, { readonly: true });
+    db.exec("PRAGMA journal_mode=WAL;");
+    return db;
+  } catch {
+    return null;
+  }
+}
+
+export function dbQueryEventsByIdGreaterThan(
+  afterId: number,
+  limit = 100,
+): Array<Record<string, unknown>> {
+  const conn = getDb();
+  if (!conn) return [];
+  try {
+    return conn
+      .query(`SELECT * FROM events WHERE id > ? ORDER BY id ASC LIMIT ?`)
+      .all(afterId, limit) as Array<Record<string, unknown>>;
+  } catch {
+    return [];
+  }
+}
+
+export function dbQueryEvents(since?: number, limit = 200): DaemonEvent[] {
+  const conn = getDb();
+  if (!conn) return [];
+  try {
+    const cutoff = since || 0;
+    const rows = conn
+      .query(
+        `SELECT ts, ts_epoch, type, job_id, stage, status, duration_secs, metadata
+         FROM events WHERE ts_epoch >= ? ORDER BY ts_epoch DESC LIMIT ?`,
+      )
+      .all(cutoff, limit) as Array<Record<string, unknown>>;
+    return rows.map((r) => {
+      const base: DaemonEvent = {
+        ts: r.ts as string,
+        ts_epoch: r.ts_epoch as number,
+        type: r.type as string,
+      };
+      if (r.job_id)
+        base.issue = parseInt(String(r.job_id).replace(/\D/g, "")) || undefined;
+      if (r.stage) base.stage = r.stage as string;
+      if (r.duration_secs) base.duration_s = r.duration_secs as number;
+      if (r.status) base.result = r.status as string;
+      if (r.metadata) {
+        try {
+          Object.assign(base, JSON.parse(r.metadata as string));
+        } catch {
+          /* ignore malformed metadata */
+        }
+      }
+      return base;
+    });
+  } catch {
+    return [];
+  }
+}
+
+export function dbQueryJobs(status?: string): Array<Record<string, unknown>> {
+  const conn = getDb();
+  if (!conn) return [];
+  try {
+    if (status) {
+      return conn
+        .query(
+          "SELECT * FROM daemon_state WHERE status = ? ORDER BY started_at DESC",
+        )
+        .all(status) as Array<Record<string, unknown>>;
+    }
+    return conn
+      .query("SELECT * FROM daemon_state ORDER BY started_at DESC LIMIT 50")
+      .all() as Array<Record<string, unknown>>;
+  } catch {
+    return [];
+  }
+}
+
+export function dbQueryCostsToday(): { total: number; count: number } {
+  const conn = getDb();
+  if (!conn) return { total: 0, count: 0 };
+  try {
+    const todayStart = new Date();
+    todayStart.setUTCHours(0, 0, 0, 0);
+    const epoch = Math.floor(todayStart.getTime() / 1000);
+    const row = conn
+      .query(
+        "SELECT COALESCE(SUM(cost_usd), 0) as total, COUNT(*) as count FROM cost_entries WHERE ts_epoch >= ?",
+      )
+      .get(epoch) as { total: number; count: number } | null;
+    return row || { total: 0, count: 0 };
+  } catch {
+    return { total: 0, count: 0 };
+  }
+}
+
+export function dbQueryHeartbeats(): Array<Record<string, unknown>> {
+  const conn = getDb();
+  if (!conn) return [];
+  try {
+    return conn
+      .query("SELECT * FROM heartbeats ORDER BY updated_at DESC")
+      .all() as Array<Record<string, unknown>>;
+  } catch {
+    return [];
+  }
+}

package/dashboard/src/canvas/pixel-agent.ts

@@ -0,0 +1,298 @@
+// Pixel Agent State Machine — Submarine crew members animated across compartments
+
+import type { StageName } from "../design/tokens";
+import type { CrewRole } from "../design/submarine-theme";
+import { timing } from "../design/submarine-theme";
+import { crewRoleForStage } from "../design/submarine-theme";
+import type { SubmarineLayout } from "./submarine-layout";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type AgentState =
+  | "spawn"
+  | "idle"
+  | "walk"
+  | "working"
+  | "alert"
+  | "despawn";
+
+export type SpriteAction = "idle" | "walk" | "work" | "alert";
+
+// ── PixelAgent class ────────────────────────────────────────────────────────
+
+export class PixelAgent {
+  // Identity
+  issue: number;
+  stage: StageName;
+  role: CrewRole;
+
+  // Position & movement
+  x: number;
+  y: number;
+  targetX: number;
+  targetY: number;
+  direction: "left" | "right" = "right";
+  path: Point[] = [];
+  pathIndex: number = 0;
+
+  // Animation state
+  state: AgentState = "spawn";
+  stateTime: number = 0;
+  frameIndex: number = 0;
+  frameTimer: number = 0;
+
+  // Spawn/despawn progress (0-1)
+  spawnProgress: number = 0;
+
+  // Idle behavior
+  idleBobOffset: number = 0;
+  nextWanderTime: number = 0;
+
+  // Pipeline data
+  elapsed_s: number = 0;
+  iteration: number = 0;
+  status: string = "idle";
+
+  constructor(
+    issue: number,
+    stage: StageName,
+    role: CrewRole,
+    x: number,
+    y: number,
+  ) {
+    this.issue = issue;
+    this.stage = stage;
+    this.role = role;
+    this.x = x;
+    this.y = y;
+    this.targetX = x;
+    this.targetY = y;
+    this.nextWanderTime =
+      Math.random() * (timing.idleWanderRange[1] - timing.idleWanderRange[0]) +
+      timing.idleWanderRange[0];
+  }
+
+  update(dt: number, layout: SubmarineLayout): void {
+    this.stateTime += dt;
+    this.frameTimer += dt;
+
+    switch (this.state) {
+      case "spawn":
+        this.spawnProgress = Math.min(
+          1,
+          this.spawnProgress + dt / timing.spawnDuration,
+        );
+        if (this.spawnProgress >= 1) {
+          this.state = "idle";
+          this.stateTime = 0;
+        }
+        break;
+
+      case "idle":
+        this.updateIdleState(dt, layout);
+        break;
+
+      case "walk":
+        this.updateWalkState(dt);
+        break;
+
+      case "working":
+        this.updateWorkingState(dt);
+        break;
+
+      case "alert":
+        this.updateAlertState(dt);
+        break;
+
+      case "despawn":
+        this.spawnProgress = Math.max(
+          0,
+          this.spawnProgress - dt / timing.despawnDuration,
+        );
+        break;
+    }
+  }
+
+  private updateIdleState(dt: number, layout: SubmarineLayout): void {
+    // Idle bob animation
+    const bobFreq = (2 * Math.PI) / timing.idleBobPeriod;
+    this.idleBobOffset =
+      Math.sin(this.stateTime * bobFreq) * timing.idleBobAmplitude;
+
+    // Advance idle frame
+    const idleFrameInterval = 0.5;
+    if (this.frameTimer >= idleFrameInterval) {
+      this.frameIndex = (this.frameIndex + 1) % 2;
+      this.frameTimer = 0;
+    }
+
+    // Occasional wander
+    this.nextWanderTime -= dt;
+    if (this.nextWanderTime <= 0) {
+      const wanderDistance = 20;
+      const wanderX = this.x + (Math.random() - 0.5) * wanderDistance;
+      const wanderY = this.y + (Math.random() - 0.5) * wanderDistance;
+      this.targetX = wanderX;
+      this.targetY = wanderY;
+
+      this.nextWanderTime =
+        Math.random() *
+          (timing.idleWanderRange[1] - timing.idleWanderRange[0]) +
+        timing.idleWanderRange[0];
+    }
+  }
+
+  private updateWalkState(dt: number): void {
+    if (this.path.length === 0) {
+      this.state = "working";
+      this.stateTime = 0;
+      this.frameIndex = 0;
+      this.frameTimer = 0;
+      return;
+    }
+
+    const target = this.path[this.pathIndex];
+    const dx = target.x - this.x;
+    const dy = target.y - this.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+
+    // Update direction
+    if (dx !== 0) {
+      this.direction = dx > 0 ? "right" : "left";
+    }
+
+    if (distance < 2) {
+      // Reached waypoint, move to next
+      this.pathIndex++;
+      if (this.pathIndex >= this.path.length) {
+        this.x = target.x;
+        this.y = target.y;
+        this.state = "working";
+        this.stateTime = 0;
+        this.frameIndex = 0;
+        this.frameTimer = 0;
+      }
+      return;
+    }
+
+    // Move toward target
+    const moveDistance = Math.min(distance, timing.walkSpeed * dt);
+    const moveRatio = moveDistance / distance;
+    this.x += dx * moveRatio;
+    this.y += dy * moveRatio;
+
+    // Advance walk frame
+    const walkFrameInterval = 0.15;
+    if (this.frameTimer >= walkFrameInterval) {
+      this.frameIndex = (this.frameIndex + 1) % 4;
+      this.frameTimer = 0;
+    }
+  }
+
+  private updateWorkingState(dt: number): void {
+    // Work animation: 2 frames at 0.3s interval
+    const workFrameInterval = timing.workFrameInterval;
+    if (this.frameTimer >= workFrameInterval) {
+      this.frameIndex = (this.frameIndex + 1) % 2;
+      this.frameTimer = 0;
+    }
+  }
+
+  private updateAlertState(dt: number): void {
+    // Alert flash: frame 0 for 0.4s, frame 1 for 0.4s
+    const flashInterval = timing.alertFlashInterval;
+    const cycle = (this.stateTime % (flashInterval * 2)) / flashInterval;
+    this.frameIndex = cycle < 1 ? 0 : 1;
+  }
+
+  moveTo(stage: StageName, layout: SubmarineLayout): void {
+    const targetComp = layout.getCompartment(stage);
+    if (!targetComp) return;
+
+    const currentComp = layout.getCompartment(this.stage);
+    if (!currentComp) return;
+
+    this.path = layout.getPathBetween(this.stage, stage);
+    if (this.path.length === 0) return;
+
+    this.stage = stage;
+    this.role = crewRoleForStage(stage);
+    this.targetX = targetComp.stationX;
+    this.targetY = targetComp.stationY;
+    this.pathIndex = 0;
+    this.state = "walk";
+    this.stateTime = 0;
+    this.frameIndex = 0;
+    this.frameTimer = 0;
+  }
+
+  setAlert(): void {
+    this.state = "alert";
+    this.stateTime = 0;
+    this.frameIndex = 0;
+    this.frameTimer = 0;
+  }
+
+  setDespawn(): void {
+    this.state = "despawn";
+    this.spawnProgress = 1;
+  }
+
+  syncFromPipeline(
+    pipeline: {
+      stage: string;
+      elapsed_s: number;
+      iteration: number;
+      status: string;
+    },
+    layout: SubmarineLayout,
+  ): void {
+    const newStage = pipeline.stage as StageName;
+    const stageChanged = this.stage !== newStage;
+
+    this.elapsed_s = pipeline.elapsed_s;
+    this.iteration = pipeline.iteration;
+    this.status = pipeline.status;
+
+    if (stageChanged) {
+      this.moveTo(newStage, layout);
+    }
+
+    if (pipeline.status === "failed") {
+      this.setAlert();
+    }
+  }
+
+  isDead(): boolean {
+    return this.state === "despawn" && this.spawnProgress <= 0;
+  }
+
+  getSpriteAction(): SpriteAction {
+    switch (this.state) {
+      case "spawn":
+      case "idle":
+        return "idle";
+      case "walk":
+        return "walk";
+      case "working":
+        return "work";
+      case "alert":
+      case "despawn":
+        return "alert";
+    }
+  }
+
+  getSpriteFrame(): number {
+    return this.frameIndex;
+  }
+
+  getDisplayY(): number {
+    return this.y + this.idleBobOffset;
+  }
+}
+
+// Re-export Point type from layout
+export interface Point {
+  x: number;
+  y: number;
+}