tpsdev-ai
diff --git a/‎bun.lock‎
Lines changed: 11 additions & 0 deletions b/‎bun.lock‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎package.json‎
Lines changed: 3 additions & 3 deletions b/‎package.json‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎packages/cap-observatory/package.json‎
Lines changed: 48 additions & 0 deletions b/‎packages/cap-observatory/package.json‎
Lines changed: 48 additions & 0 deletions
diff --git a/‎packages/cap-observatory/src/capability.ts‎
Lines changed: 88 additions & 0 deletions b/‎packages/cap-observatory/src/capability.ts‎
Lines changed: 88 additions & 0 deletions
diff --git a/‎packages/cap-observatory/src/client.ts‎
Lines changed: 164 additions & 0 deletions b/‎packages/cap-observatory/src/client.ts‎
Lines changed: 164 additions & 0 deletions
@@ -7,9 +7,9 @@
     "packages/*"
   ],
   "scripts": {
-    "build": "cd packages/shell && bun run build && cd ../discord && bun run build && cd ../cap-discord && bun run build && cd ../cap-flair && bun run build && cd ../cli && bun run build",
-    "test": "cd packages/shell && bun test && cd ../discord && bun test && cd ../cap-discord && bun test && cd ../cap-flair && bun test && cd ../cli && bun test",
-    "typecheck": "cd packages/shell && bun run build && bun run typecheck && cd ../discord && bun run build && bun run typecheck && cd ../cap-discord && bun run build && bun run typecheck && cd ../cap-flair && bun run build && bun run typecheck && cd ../cli && bun run typecheck",
+    "build": "cd packages/shell && bun run build && cd ../discord && bun run build && cd ../cap-discord && bun run build && cd ../cap-flair && bun run build && cd ../cap-observatory && bun run build && cd ../cli && bun run build",
+    "test": "cd packages/shell && bun test && cd ../discord && bun test && cd ../cap-discord && bun test && cd ../cap-flair && bun test && cd ../cap-observatory && bun test && cd ../cli && bun test",
+    "typecheck": "cd packages/shell && bun run build && bun run typecheck && cd ../discord && bun run build && bun run typecheck && cd ../cap-discord && bun run build && bun run typecheck && cd ../cap-flair && bun run build && bun run typecheck && cd ../cap-observatory && bun run build && bun run typecheck && cd ../cli && bun run typecheck",
     "lint": "biome check .",
     "lint:fix": "biome check --write ."
   },
 
@@ -0,0 +1,48 @@
+{
+  "name": "@tpsdev-ai/bob-cap-observatory",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Bob capability: Team-View observatory producer. A pi extension — each office self-reports sanitized, OFFICE-key-signed agent snapshots + event feed to /IngestEvents.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./manifest": {
+      "import": "./dist/manifest.js",
+      "types": "./dist/manifest.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "typecheck": "tsc -p . --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@mariozechner/pi-coding-agent": "0.73.1",
+    "@tpsdev-ai/bob-shell": "workspace:*",
+    "typebox": "1.1.38"
+  },
+  "keywords": [
+    "observatory",
+    "team-view",
+    "cockpit",
+    "bob",
+    "agent",
+    "pi-coding-agent",
+    "capability"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tpsdev-ai/bob.git",
+    "directory": "packages/cap-observatory"
+  },
+  "homepage": "https://github.com/tpsdev-ai/bob#readme",
+  "bugs": "https://github.com/tpsdev-ai/bob/issues",
+  "license": "Apache-2.0"
+}
@@ -0,0 +1,88 @@
+// The testable core of the observatory (team-view producer) capability, decoupled
+// from pi's real ExtensionAPI so it can be unit-tested with fakes (no live
+// observatory, no real office key, no network). `index.ts` is the thin factory
+// that builds the real ObservatoryHttpClient + reader and calls this.
+//
+// What this wires — ONE OUTBOUND tool via pi.registerTool:
+//   observatory_report — build the office's snapshots/events, sanitize, sign with
+//                        the OFFICE key, and POST ONE batched call to /IngestEvents.
+//
+// CRON MODEL (see bob/packages/shell/src/cron.ts): cron does NOT call the
+// capability directly — it injects a prompt into the AGENT, which then calls this
+// tool. So the capability EXPOSES the report logic as a tool; bob.yaml wires a
+// `cron:` entry whose prompt says "report your status to the observatory". Same
+// shape as flair_write / discord_send. There is NO inbound listener (serves:false).
+
+import { type TSchema, Type } from "typebox";
+import type { IngestBatch, ObservatoryClient } from "./client.js";
+import type { AgentSignal } from "./snapshot.js";
+import { buildBatch } from "./snapshot.js";
+
+// The minimal slice of pi's ExtensionAPI this core needs — declared structurally
+// so a tiny test fake and the real ExtensionAPI both satisfy it.
+export interface PiLike {
+  registerTool(tool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: TSchema;
+    execute: (
+      toolCallId: string,
+      params: Record<string, unknown>,
+    ) => Promise<{ content: Array<{ type: "text"; text: string }>; details: unknown }>;
+  }): void;
+}
+
+export interface WireOptions {
+  pi: PiLike;
+  client: ObservatoryClient;
+  // Reads the office's live signals each tick (fs seam). Returns the AgentSignal[]
+  // the builder turns into the batched snapshot/event payload.
+  readSignals: () => AgentSignal[];
+  // Threshold (s) past which an agent is reported stale. Defaults to 600.
+  staleThresholdSeconds?: number;
+  // Logger seam — defaults to console.error. NOTHING here ever logs the key (it
+  // lives only inside the client) or a raw signal (only counts/status).
+  log?: (msg: string) => void;
+}
+
+function ok(text: string): { content: Array<{ type: "text"; text: string }>; details: unknown } {
+  return { content: [{ type: "text", text }], details: {} };
+}
+
+export function wireObservatoryCapability(opts: WireOptions): void {
+  const { pi, client, readSignals } = opts;
+  const log = opts.log ?? ((m: string) => console.error(m));
+
+  // --- observatory_report ------------------------------------------------
+  pi.registerTool({
+    name: "observatory_report",
+    label: "Observatory Report",
+    description:
+      "Report this office's live status to the team observatory. Builds each agent's snapshot (role/model/status/current-task) + the events they caused, sanitizes them (no paths/secrets/bodies), signs with the office key, and POSTs ONE batched call. Call this on each cron tick.",
+    parameters: Type.Object({}),
+    async execute() {
+      const signals = readSignals();
+      const batch: IngestBatch = buildBatch(signals, {
+        staleThresholdSeconds: opts.staleThresholdSeconds,
+      });
+      // post() runs sanitize() + the office-key signature internally — exactly
+      // one redacted, signed path to the wire.
+      const result = await client.post(batch);
+      // Status line names counts + per-agent status ONLY — never a task summary,
+      // a path, or the key.
+      const byStatus = batch.agents.reduce<Record<string, number>>((acc, a) => {
+        acc[a.status] = (acc[a.status] ?? 0) + 1;
+        return acc;
+      }, {});
+      const statusLine = Object.entries(byStatus)
+        .map(([s, n]) => `${n} ${s}`)
+        .join(", ");
+      const msg = `reported ${result.agents} agent(s) [${statusLine}] + ${result.events} event(s) to the observatory`;
+      log(`observatory capability: ${msg}`);
+      return ok(msg);
+    },
+  });
+
+  log("observatory capability: registered observatory_report");
+}
@@ -0,0 +1,164 @@
+// Ed25519-authenticated HTTP client for the observatory, decoupled from the pi
+// ExtensionAPI so it can be unit-tested with injected fetch/clock/key. This is
+// the observatory analog of cap-flair's FlairHttpClient — same TPS-Ed25519 wire
+// protocol — with TWO deliberate differences:
+//   1. it signs with the OFFICE key (not a per-agent Flair key): the endpoint
+//      verifies ObsOffice.publicKey (see tps-observatory/resources/IngestEvents.ts).
+//   2. it POSTs ONE batched call per office per tick to /IngestEvents (the
+//      endpoint rate-limits 1 call/10s per office and accepts arrays).
+//
+// PROTOCOL (mirrors flair's canonical scripts/flair-client.mjs + IngestEvents):
+//   Authorization: TPS-Ed25519 <officeId>:<tsMs>:<nonce>:<sigB64>
+//   signature = Ed25519( "<officeId>:<tsMs>:<nonce>:POST:/IngestEvents" )
+//   - tsMs is Date.now() in MILLISECONDS (NOT seconds — a 1000x error → 401).
+//   - the server enforces a ±window on tsMs + (by CP2) nonce dedup; each record
+//     ALSO carries its own nonce+tsMs for the per-record replay store.
+//   body: { officeId, events: OrgEventRecord[], agents: AgentStatus[], syncedAt }
+//
+// SECURITY:
+//   * The OFFICE private key is read from a FILE PATH once, imported as a
+//     non-extractable CryptoKey, and used only to sign. It is never logged,
+//     echoed, returned in a tool result, or placed in an error message.
+//   * sanitize() runs HERE, immediately before the POST is assembled, so there
+//     is exactly one path to the wire and it is always redacted (defense in
+//     depth — the builder already passes summaries only).
+
+import { webcrypto } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { sanitize } from "./sanitize.js";
+import type { AgentStatus, OrgEventRecord } from "./snapshot.js";
+
+const { subtle } = webcrypto;
+
+// The signed POST path — bound into the signature payload (so a signature for
+// one endpoint can't be replayed against another).
+const INGEST_PATH = "/IngestEvents";
+
+export interface IngestBatch {
+  events: OrgEventRecord[];
+  agents: AgentStatus[];
+}
+
+export interface IngestResult {
+  ok: boolean;
+  events: number;
+  agents: number;
+}
+
+export interface ObservatoryClient {
+  // POST one batched, signed, sanitized call for the whole office.
+  post(batch: IngestBatch): Promise<IngestResult>;
+}
+
+// Minimal fetch shape we depend on (so tests pass a fake without DOM lib types).
+type FetchLike = (
+  url: string,
+  init: { method: string; headers: Record<string, string>; body?: string },
+) => Promise<{ ok: boolean; status: number; text(): Promise<string> }>;
+
+export interface ObservatoryHttpClientOptions {
+  url: string;
+  officeId: string;
+  // Path to the base64-PKCS8 OFFICE Ed25519 private key. Read once, lazily.
+  officeKeyFile: string;
+  // Seams (tests). Production uses global fetch, Date.now, randomUUID, fs.
+  fetchImpl?: FetchLike;
+  now?: () => number;
+  uuid?: () => string;
+  readFile?: (path: string) => string;
+}
+
+export class ObservatoryHttpClient implements ObservatoryClient {
+  private readonly url: string;
+  private readonly officeId: string;
+  private readonly officeKeyFile: string;
+  private readonly fetchImpl: FetchLike;
+  private readonly now: () => number;
+  private readonly uuid: () => string;
+  private readonly readFile: (path: string) => string;
+  // Imported once; reused across requests.
+  private keyPromise?: Promise<webcrypto.CryptoKey>;
+
+  constructor(opts: ObservatoryHttpClientOptions) {
+    // Drop trailing slashes so `${url}${path}` never doubles them. A linear loop
+    // (not a `/\/+$/` regex) — the regex form is a polynomial-ReDoS class on
+    // uncontrolled (config) input that CodeQL rightly flags.
+    let base = opts.url;
+    while (base.endsWith("/")) base = base.slice(0, -1);
+    this.url = base;
+    this.officeId = opts.officeId;
+    // Expand a leading ~/ so configs can use the ~/.flair/keys/<name>.key
+    // convention without the caller pre-resolving it.
+    this.officeKeyFile = opts.officeKeyFile.startsWith("~/")
+      ? `${homedir()}/${opts.officeKeyFile.slice(2)}`
+      : opts.officeKeyFile;
+    this.fetchImpl = opts.fetchImpl ?? ((u, i) => fetch(u, i) as unknown as ReturnType<FetchLike>);
+    this.now = opts.now ?? (() => Date.now());
+    this.uuid = opts.uuid ?? (() => webcrypto.randomUUID());
+    this.readFile = opts.readFile ?? ((p) => readFileSync(p, "utf8"));
+  }
+
+  private loadKey(): Promise<webcrypto.CryptoKey> {
+    if (!this.keyPromise) {
+      const b64 = this.readFile(this.officeKeyFile).trim();
+      this.keyPromise = subtle.importKey(
+        "pkcs8",
+        Buffer.from(b64, "base64"),
+        { name: "Ed25519" },
+        false,
+        ["sign"],
+      );
+    }
+    return this.keyPromise;
+  }
+
+  // post — sanitize → sign with the OFFICE key → POST one batched call.
+  async post(batch: IngestBatch): Promise<IngestResult> {
+    // REDACTION BOUNDARY: the only path to the wire, always sanitized.
+    const clean = sanitize(batch);
+
+    const key = await this.loadKey();
+    const ts = String(this.now());
+    const nonce = this.uuid();
+    // tsMs in MILLISECONDS. Signature binds officeId + ts + nonce + METHOD+path,
+    // so a captured signature can't be replayed against another endpoint/office.
+    const payload = `${this.officeId}:${ts}:${nonce}:POST:${INGEST_PATH}`;
+    const sig = await subtle.sign("Ed25519", key, new TextEncoder().encode(payload));
+
+    const body = JSON.stringify({
+      officeId: this.officeId,
+      events: clean.events,
+      agents: clean.agents,
+      syncedAt: new Date(Number(ts)).toISOString(),
+    });
+
+    const headers: Record<string, string> = {
+      Authorization: `TPS-Ed25519 ${this.officeId}:${ts}:${nonce}:${Buffer.from(sig).toString("base64")}`,
+      "Content-Type": "application/json",
+    };
+
+    const res = await this.fetchImpl(`${this.url}${INGEST_PATH}`, {
+      method: "POST",
+      headers,
+      body,
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      // Never include the request body or auth header — only status + a short,
+      // server-provided reason (which names no secret).
+      throw new Error(`observatory POST ${INGEST_PATH} -> ${res.status}: ${text.slice(0, 200)}`);
+    }
+    let parsed: { ok?: boolean; events?: number; agents?: number } = {};
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      // Endpoint returned non-JSON 200 — treat as success with unknown counts.
+    }
+    return {
+      ok: parsed.ok ?? true,
+      events: typeof parsed.events === "number" ? parsed.events : clean.events.length,
+      agents: typeof parsed.agents === "number" ? parsed.agents : clean.agents.length,
+    };
+  }
+}