@walwal-harness/cli 7.1.7 → 7.1.9

package/apps/harness-dashboard/lib/i18n.ts

@@ -0,0 +1,26 @@
+export type Lang = "ko" | "en";
+
+const DICT: Record<string, { ko: string; en: string }> = {
+  "banner.run_dispatcher_first.ko": {
+    ko: "Dispatcher를 먼저 실행하세요.",
+    en: "Run Dispatcher first.",
+  },
+  "banner.progress_corrupt": {
+    ko: "progress.json이 손상되었습니다.",
+    en: "progress.json is corrupt.",
+  },
+  "drawer.tab.agent_log": { ko: "에이전트 로그", en: "Agent Log" },
+  "drawer.tab.room_metrics": { ko: "룸 메트릭", en: "Room Metrics" },
+  "drawer.tab.archive_list": { ko: "아카이브", en: "Archive" },
+  "header.subtitle": {
+    ko: "walwal-harness 라이브 운영 대시보드",
+    en: "walwal-harness live operations dashboard",
+  },
+  "goal.empty": { ko: "활성 GOAL 없음", en: "No active goal" },
+};
+
+export function t(key: string, lang: Lang = "ko"): string {
+  const entry = DICT[key];
+  if (!entry) return key;
+  return entry[lang] ?? entry.ko ?? key;
+}

package/apps/harness-dashboard/lib/iso.ts

@@ -0,0 +1,150 @@
+import type { RoomId } from "./types";
+
+// Isometric projection (2:1 dimetric). Tile basis vectors:
+//   X axis (world right) → screen ( +TILE_W/2, +TILE_H/2 )
+//   Y axis (world down)  → screen ( -TILE_W/2, +TILE_H/2 )
+// Caller multiplies by world coordinates and adds an origin offset.
+export const TILE_W = 64;
+export const TILE_H = 32;
+
+export interface ScreenPoint {
+  sx: number;
+  sy: number;
+}
+
+export function worldToScreen(
+  wx: number,
+  wy: number,
+  origin: ScreenPoint = { sx: 0, sy: 0 }
+): ScreenPoint {
+  return {
+    sx: origin.sx + (wx - wy) * (TILE_W / 2),
+    sy: origin.sy + (wx + wy) * (TILE_H / 2),
+  };
+}
+
+// Each room is a world-coordinate axis-aligned rectangle. Floor plan is laid out
+// in a 12x8 world grid. Rectangles do not overlap interior cells.
+export interface RoomRect {
+  id: RoomId;
+  wx: number;
+  wy: number;
+  ww: number;
+  wh: number;
+}
+
+// Rooms are now spaced apart so the gaps between them form a real corridor
+// network (1 unit wide). The corridor mesh is rendered in Floor3D.
+export const ROOM_RECTS: RoomRect[] = [
+  { id: "ceo",         wx: 0,  wy: 0, ww: 3, wh: 2 },
+  { id: "meeting",     wx: 4,  wy: 0, ww: 3, wh: 2 },
+  { id: "coo",         wx: 8,  wy: 0, ww: 3, wh: 2 },
+  { id: "cto-team",    wx: 0,  wy: 3, ww: 5, wh: 3 },
+  { id: "cqo-team",    wx: 6,  wy: 3, ww: 5, wh: 3 },
+  { id: "service-ops", wx: 0,  wy: 7, ww: 4, wh: 2 },
+  { id: "archive",     wx: 5,  wy: 7, ww: 6, wh: 2 },
+];
+
+export interface CorridorRect {
+  wx: number;
+  wy: number;
+  ww: number;
+  wh: number;
+}
+
+// Corridor segments — vertical gaps between rooms in the same row, plus the
+// horizontal corridors that run between row blocks.
+export const CORRIDOR_RECTS: CorridorRect[] = [
+  { wx: 3, wy: 0, ww: 1, wh: 2 },   // ceo ↔ meeting
+  { wx: 7, wy: 0, ww: 1, wh: 2 },   // meeting ↔ coo
+  { wx: 5, wy: 3, ww: 1, wh: 3 },   // cto-team ↔ cqo-team
+  { wx: 4, wy: 7, ww: 1, wh: 2 },   // service-ops ↔ archive
+  { wx: 0, wy: 2, ww: 11, wh: 1 },  // horizontal corridor (top ↔ middle row)
+  { wx: 0, wy: 6, ww: 11, wh: 1 },  // horizontal corridor (middle ↔ bottom row)
+];
+
+// Free-roam waypoint pool: union of room interiors + corridor cells + a few
+// outdoor strolling spots. Coordinates are in world space. The minifig roam
+// loop picks a random target from this list when idle, so the office reads as
+// "people moving naturally" instead of marching a rectangular track.
+export const ROAM_POOL: Array<[number, number]> = [
+  // room interiors (center + a corner each)
+  [1.5, 1], [5.5, 1], [9.5, 1],
+  [2.5, 4.5], [8.5, 4.5],
+  [2, 8], [8, 8],
+  // corridor — top row gaps
+  [3.5, 1], [3.5, 1.5], [7.5, 1], [7.5, 1.5],
+  // corridor — between top and middle row (runs full width)
+  [1, 2.5], [3, 2.5], [5.5, 2.5], [8, 2.5], [10, 2.5],
+  // corridor — between middle and bottom row
+  [1, 6.5], [3, 6.5], [5.5, 6.5], [8, 6.5], [10, 6.5],
+  // corridor — between cto/cqo teams
+  [5.5, 4], [5.5, 5],
+  // corridor — between service-ops/archive
+  [4.5, 7.5], [4.5, 8.5],
+  // outdoor strolling spots
+  [-1, -0.6], [12, -0.6], [-1, 4], [12, 4], [-1, 9.5], [12, 9.5],
+  [3, 10], [8, 10],
+];
+
+// Canvas origin chosen so every projected room point falls inside viewBox 0..1200 x 0..720.
+// World grid spans x:[0..9], y:[0..7]. Projected x range = (0-7..9-0) = -7..+9 cells →
+// width (-7..+9)*TILE_W/2 = (-224..+288). Shift x so min becomes ~80.
+// Projected y range = (0+0..9+7) = 0..16 cells → height 16*TILE_H/2 = 256. Shift y so top
+// is at ~140 (leaves room for header inside layout).
+export const ISO_ORIGIN: ScreenPoint = { sx: 80 + 224, sy: 140 };
+
+export function roomPolygon(rect: RoomRect): string {
+  const o = ISO_ORIGIN;
+  const a = worldToScreen(rect.wx, rect.wy, o);
+  const b = worldToScreen(rect.wx + rect.ww, rect.wy, o);
+  const c = worldToScreen(rect.wx + rect.ww, rect.wy + rect.wh, o);
+  const d = worldToScreen(rect.wx, rect.wy + rect.wh, o);
+  return `${a.sx},${a.sy} ${b.sx},${b.sy} ${c.sx},${c.sy} ${d.sx},${d.sy}`;
+}
+
+export function roomCenter(rect: RoomRect): ScreenPoint {
+  return worldToScreen(rect.wx + rect.ww / 2, rect.wy + rect.wh / 2, ISO_ORIGIN);
+}
+
+// Returns N seat positions inside a room rectangle, arranged in a grid that fits
+// gracefully even when the room is small. Used by Minifig placement.
+export function seatPositions(rect: RoomRect, count: number): ScreenPoint[] {
+  if (count <= 0) return [];
+  const cols = Math.min(count, Math.max(2, Math.floor(rect.ww)));
+  const rows = Math.ceil(count / cols);
+  const padX = rect.ww / (cols + 1);
+  const padY = rect.wh / (rows + 1);
+  const out: ScreenPoint[] = [];
+  for (let i = 0; i < count; i++) {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    const wx = rect.wx + padX * (col + 1);
+    const wy = rect.wy + padY * (row + 1);
+    out.push(worldToScreen(wx, wy, ISO_ORIGIN));
+  }
+  return out;
+}
+
+// Given a world rectangle, returns the smallest screen-space bounding box.
+// Used by tests to assert non-overlap.
+export function rectBounds(rect: RoomRect): {
+  minX: number;
+  maxX: number;
+  minY: number;
+  maxY: number;
+} {
+  const o = ISO_ORIGIN;
+  const corners = [
+    worldToScreen(rect.wx, rect.wy, o),
+    worldToScreen(rect.wx + rect.ww, rect.wy, o),
+    worldToScreen(rect.wx + rect.ww, rect.wy + rect.wh, o),
+    worldToScreen(rect.wx, rect.wy + rect.wh, o),
+  ];
+  return {
+    minX: Math.min(...corners.map((c) => c.sx)),
+    maxX: Math.max(...corners.map((c) => c.sx)),
+    minY: Math.min(...corners.map((c) => c.sy)),
+    maxY: Math.max(...corners.map((c) => c.sy)),
+  };
+}

package/apps/harness-dashboard/lib/log-filter.ts

@@ -0,0 +1,23 @@
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+
+export interface LogFilterOptions {
+  agentId?: string;
+  limit?: number;
+}
+
+export function readProgressLog(rootDir: string, opts: LogFilterOptions = {}): string[] {
+  const limit = opts.limit ?? 50;
+  const file = path.join(rootDir, ".harness", "progress.log");
+  if (!existsSync(file)) return [];
+  let raw: string;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = raw.split("\n").filter((l) => l.length > 0);
+  const filtered = opts.agentId ? lines.filter((l) => l.includes(opts.agentId!)) : lines;
+  // Most-recent-first (we tail from the bottom).
+  return filtered.slice(-limit);
+}

package/apps/harness-dashboard/lib/markdown.tsx

@@ -0,0 +1,306 @@
+"use client";
+import React from "react";
+
+// ---------------------------------------------------------------------------
+// Inline renderer — handles **bold**, `code`, *italic*
+// ---------------------------------------------------------------------------
+function renderInline(text: string): React.ReactNode[] {
+  const parts: React.ReactNode[] = [];
+  // Pattern order matters: bold, inline-code, italic
+  const re = /(\*\*(.+?)\*\*|`(.+?)`|\*(.+?)\*)/g;
+  let last = 0;
+  let match: RegExpExecArray | null;
+  let key = 0;
+
+  while ((match = re.exec(text)) !== null) {
+    if (match.index > last) {
+      parts.push(text.slice(last, match.index));
+    }
+    if (match[0].startsWith("**")) {
+      parts.push(
+        <strong key={key++} className="text-white font-semibold">
+          {match[2]}
+        </strong>
+      );
+    } else if (match[0].startsWith("`")) {
+      parts.push(
+        <code
+          key={key++}
+          className="bg-gray-800 text-amber-300 text-[11px] px-1 rounded"
+        >
+          {match[3]}
+        </code>
+      );
+    } else {
+      parts.push(
+        <em key={key++} className="italic text-gray-300">
+          {match[4]}
+        </em>
+      );
+    }
+    last = match.index + match[0].length;
+  }
+  if (last < text.length) parts.push(text.slice(last));
+  return parts;
+}
+
+// ---------------------------------------------------------------------------
+// Table renderer
+// ---------------------------------------------------------------------------
+function renderTable(rows: string[]): React.ReactNode {
+  // rows[0] = header, rows[1] = separator, rows[2+] = data
+  const parseRow = (row: string): string[] =>
+    row
+      .split("|")
+      .map((c) => c.trim())
+      .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+
+  const headers = parseRow(rows[0]);
+  const dataRows = rows.slice(2).map(parseRow);
+
+  return (
+    <div key={Math.random()} className="overflow-x-auto">
+      <table className="w-full border-collapse font-mono text-[11px]">
+        <thead>
+          <tr>
+            {headers.map((h, i) => (
+              <th
+                key={i}
+                className="border border-gray-700/60 bg-gray-800/50 px-2 py-1 text-left text-cyan-300/90"
+              >
+                {renderInline(h)}
+              </th>
+            ))}
+          </tr>
+        </thead>
+        <tbody>
+          {dataRows.map((row, ri) => (
+            <tr key={ri} className="border-b border-gray-700/40">
+              {row.map((cell, ci) => (
+                <td
+                  key={ci}
+                  className="border border-gray-700/40 px-2 py-1 text-gray-300"
+                >
+                  {renderInline(cell)}
+                </td>
+              ))}
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Block renderer state machine
+// ---------------------------------------------------------------------------
+function renderBlocks(content: string): React.ReactNode[] {
+  const lines = content.split("\n");
+  const nodes: React.ReactNode[] = [];
+  let i = 0;
+  let keyCounter = 0;
+  const k = () => keyCounter++;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // ---- Fenced code block ----
+    if (line.startsWith("```")) {
+      const lang = line.slice(3).trim();
+      const codeLines: string[] = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++; // skip closing ```
+      nodes.push(
+        <pre
+          key={k()}
+          className="overflow-x-auto rounded border border-gray-700/60 bg-[#0d1117] p-3 my-2"
+        >
+          <code className="text-emerald-300/90 text-[11px] font-mono whitespace-pre">
+            {lang ? (
+              <span className="block text-[10px] text-gray-600 mb-1">{lang}</span>
+            ) : null}
+            {codeLines.join("\n")}
+          </code>
+        </pre>
+      );
+      continue;
+    }
+
+    // ---- HR ----
+    if (/^---+$/.test(line.trim())) {
+      nodes.push(<hr key={k()} className="border-gray-700/50 my-3" />);
+      i++;
+      continue;
+    }
+
+    // ---- H1 ----
+    if (line.startsWith("# ")) {
+      nodes.push(
+        <h1 key={k()} className="text-[16px] font-bold text-white mt-3 mb-1">
+          {renderInline(line.slice(2))}
+        </h1>
+      );
+      i++;
+      continue;
+    }
+
+    // ---- H2 ----
+    if (line.startsWith("## ")) {
+      nodes.push(
+        <h2
+          key={k()}
+          className="text-[13px] font-bold text-cyan-300/90 mt-4 mb-0.5 pb-0.5 border-b border-gray-700/40"
+        >
+          {renderInline(line.slice(3))}
+        </h2>
+      );
+      i++;
+      continue;
+    }
+
+    // ---- H3 ----
+    if (line.startsWith("### ")) {
+      nodes.push(
+        <h3 key={k()} className="text-[12px] font-semibold text-gray-200 mt-3 mb-0.5">
+          {renderInline(line.slice(4))}
+        </h3>
+      );
+      i++;
+      continue;
+    }
+
+    // ---- H4 ----
+    if (line.startsWith("#### ")) {
+      nodes.push(
+        <h4 key={k()} className="text-[11px] font-semibold text-gray-300 mt-2 mb-0.5">
+          {renderInline(line.slice(5))}
+        </h4>
+      );
+      i++;
+      continue;
+    }
+
+    // ---- Table ----
+    if (line.includes("|") && i + 1 < lines.length && /^\|?[\s\-:|]+\|/.test(lines[i + 1])) {
+      const tableRows: string[] = [line];
+      i++;
+      while (i < lines.length && lines[i].includes("|")) {
+        tableRows.push(lines[i]);
+        i++;
+      }
+      if (tableRows.length >= 2) {
+        nodes.push(
+          <div key={k()} className="my-2">
+            {renderTable(tableRows)}
+          </div>
+        );
+      }
+      continue;
+    }
+
+    // ---- Checkbox list items ----
+    if (/^- \[x\]/i.test(line)) {
+      nodes.push(
+        <div key={k()} className="flex items-start gap-1.5 text-[12px] text-gray-300 pl-2">
+          <span className="text-emerald-400 shrink-0">✓</span>
+          <span>{renderInline(line.slice(6).trim())}</span>
+        </div>
+      );
+      i++;
+      continue;
+    }
+    if (/^- \[ \]/.test(line)) {
+      nodes.push(
+        <div key={k()} className="flex items-start gap-1.5 text-[12px] text-gray-400 pl-2">
+          <span className="text-gray-600 shrink-0">○</span>
+          <span>{renderInline(line.slice(6).trim())}</span>
+        </div>
+      );
+      i++;
+      continue;
+    }
+
+    // ---- Bullet list ----
+    if (/^(\s*)([-*])\s/.test(line)) {
+      const listItems: React.ReactNode[] = [];
+      while (i < lines.length && /^(\s*)([-*])\s/.test(lines[i])) {
+        const indent = lines[i].match(/^(\s*)/)?.[1].length ?? 0;
+        const text = lines[i].replace(/^\s*[-*]\s/, "");
+        listItems.push(
+          <li
+            key={k()}
+            style={{ paddingLeft: indent > 0 ? `${indent * 8}px` : undefined }}
+            className="flex items-start gap-1.5"
+          >
+            <span className="text-gray-600 shrink-0 mt-0.5">•</span>
+            <span>{renderInline(text)}</span>
+          </li>
+        );
+        i++;
+      }
+      nodes.push(
+        <ul key={k()} className="space-y-0.5 text-[12px] text-gray-300 my-1">
+          {listItems}
+        </ul>
+      );
+      continue;
+    }
+
+    // ---- Numbered list ----
+    if (/^\d+\.\s/.test(line)) {
+      const listItems: React.ReactNode[] = [];
+      let num = 1;
+      while (i < lines.length && /^\d+\.\s/.test(lines[i])) {
+        const text = lines[i].replace(/^\d+\.\s/, "");
+        listItems.push(
+          <li key={k()} className="flex items-start gap-1.5">
+            <span className="text-gray-500 shrink-0 tabular-nums">{num}.</span>
+            <span>{renderInline(text)}</span>
+          </li>
+        );
+        i++;
+        num++;
+      }
+      nodes.push(
+        <ol key={k()} className="space-y-0.5 text-[12px] text-gray-300 my-1">
+          {listItems}
+        </ol>
+      );
+      continue;
+    }
+
+    // ---- Blank line ----
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+
+    // ---- Regular paragraph ----
+    nodes.push(
+      <p key={k()} className="text-gray-300 text-[12px] leading-relaxed">
+        {renderInline(line)}
+      </p>
+    );
+    i++;
+  }
+
+  return nodes;
+}
+
+// ---------------------------------------------------------------------------
+// Public component
+// ---------------------------------------------------------------------------
+export function MarkdownView({ source }: { source: string }) {
+  // Strip YAML frontmatter (between --- ... ---)
+  const content = source.replace(/^---[\s\S]*?---\n+/, "").trim();
+  return (
+    <div className="space-y-1.5 text-[12px] leading-relaxed">
+      {renderBlocks(content)}
+    </div>
+  );
+}

package/apps/harness-dashboard/lib/path-planning.ts

@@ -0,0 +1,72 @@
+import { ROOM_RECTS, CORRIDOR_RECTS } from "./iso";
+import { doorsForRoom } from "./furniture";
+import type { RoomId } from "./types";
+
+export type Zone = RoomId | "corridor" | "outdoor";
+
+export function zoneAt(x: number, z: number): Zone {
+  for (const r of ROOM_RECTS) {
+    if (x >= r.wx && x <= r.wx + r.ww && z >= r.wy && z <= r.wy + r.wh) {
+      return r.id;
+    }
+  }
+  for (const c of CORRIDOR_RECTS) {
+    if (x >= c.wx && x <= c.wx + c.ww && z >= c.wy && z <= c.wy + c.wh) {
+      return "corridor";
+    }
+  }
+  return "outdoor";
+}
+
+// Returns the corridor-side foot of the room's primary door — i.e. a point
+// just outside the wall, so a minifig walking to it leaves the room cleanly
+// through the door opening.
+export function exitWaypoint(roomId: RoomId): [number, number] | null {
+  const rect = ROOM_RECTS.find((r) => r.id === roomId);
+  if (!rect) return null;
+  const doors = doorsForRoom(rect);
+  if (doors.length === 0) return null;
+  // Pick the door that points "down" (toward south corridor) when available;
+  // it gives the most natural look because all rooms have a south or north
+  // corridor adjacency.
+  const preferred =
+    doors.find((d) => d.side === "south") ??
+    doors.find((d) => d.side === "north") ??
+    doors[0];
+  const offset = 0.6;
+  switch (preferred.side) {
+    case "north":
+      return [preferred.position[0], preferred.position[1] - offset];
+    case "south":
+      return [preferred.position[0], preferred.position[1] + offset];
+    case "east":
+      return [preferred.position[0] + offset, preferred.position[1]];
+    case "west":
+      return [preferred.position[0] - offset, preferred.position[1]];
+  }
+}
+
+// Plans a wall-respecting path from `from` to `to`.
+// Rule: leaving a room or entering a room must pass through that room's door.
+// Movement within the same zone (or between corridor / outdoor) is direct.
+export function planPath(
+  from: [number, number],
+  to: [number, number]
+): Array<[number, number]> {
+  const fromZone = zoneAt(from[0], from[1]);
+  const toZone = zoneAt(to[0], to[1]);
+  const waypoints: Array<[number, number]> = [];
+
+  const isRoom = (z: Zone): z is RoomId => z !== "corridor" && z !== "outdoor";
+
+  if (isRoom(fromZone) && fromZone !== toZone) {
+    const exit = exitWaypoint(fromZone);
+    if (exit) waypoints.push(exit);
+  }
+  if (isRoom(toZone) && fromZone !== toZone) {
+    const entry = exitWaypoint(toZone);
+    if (entry) waypoints.push(entry);
+  }
+  waypoints.push(to);
+  return waypoints;
+}

package/apps/harness-dashboard/lib/safe-json.ts

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+
+export type SafeJsonResult<T> =
+  | { ok: true; value: T }
+  | { ok: false; reason: "missing" | "corrupt"; error?: unknown };
+
+export function readJsonSafe<T = unknown>(filePath: string): SafeJsonResult<T> {
+  let raw: string;
+  try {
+    raw = readFileSync(filePath, "utf8");
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === "ENOENT") {
+      return { ok: false, reason: "missing", error };
+    }
+    return { ok: false, reason: "corrupt", error };
+  }
+  try {
+    const value = JSON.parse(raw) as T;
+    return { ok: true, value };
+  } catch (error) {
+    return { ok: false, reason: "corrupt", error };
+  }
+}