@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/packages/local-runtime/src/server-operations-runs-route.ts

@@ -0,0 +1,113 @@
+import type { WorkspaceFileSystem } from "@zaip-ai/core";
+import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
+import { type CompactLifecycleDetail, LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
+import type { Context, Hono } from "hono";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import { pageDailyReadModel } from "./server-daily-read-models.js";
+import {
+  aggregateOperationsPageRows,
+  filterOperationsMetricRows,
+  operationsPageFilters,
+} from "./server-operations-pages.js";
+import { projectionPeriodFilter } from "./server-period.js";
+
+type AggregateReader = <T>(key: string, build: () => Promise<T>) => Promise<T>;
+type Responder = (
+  context: Context,
+  payload: unknown,
+  status: ContentfulStatusCode,
+  cache: boolean,
+) => Response;
+
+export function registerOperationsRunsRoute(
+  app: Hono,
+  filesystem: WorkspaceFileSystem,
+  readAggregate: AggregateReader,
+  respond: Responder,
+) {
+  app.on(["GET", "HEAD"], "/api/v2/operations/runs", async (context) => {
+    const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+    const limit = Math.min(
+      200,
+      Math.max(1, Number.parseInt(context.req.query("limit") ?? "100", 10) || 100),
+    );
+    const { from, to } = projectionPeriodFilter(context);
+    const kind = context.req.query("kind") ?? "runs";
+    const filters = operationsPageFilters(context);
+    const payload = await readAggregate(
+      `operations:runs:${kind}:${from ?? ""}:${to ?? ""}:${offset}:${limit}:${filters.query}:${filters.status}:${filters.risk}`,
+      async () => {
+        if (kind === "executions" || kind === "conversations") {
+          const snapshot = await new LifecycleManifestStore(filesystem).readDailyReadModels(kind);
+          if (snapshot !== null) {
+            const page = pageDailyReadModel(snapshot, kind, { from, to }, filters, offset, limit);
+            return compactOperationsPage(
+              kind,
+              page,
+              page.rows as readonly CompactLifecycleDetail[],
+            );
+          }
+        }
+        const summary = JSON.parse(
+          await filesystem.readText(".agents/records/lifecycle/summary.json"),
+        ) as CostSummarySource;
+        const sourceRows = (summary.run_metrics ?? []).filter(
+          (run) =>
+            (from === null || run.started_at >= from) &&
+            (to === null || run.started_at <= to) &&
+            (kind === "runs" ||
+              (kind === "conversations" &&
+                run.phase === "conversation" &&
+                run.conversation_id !== null) ||
+              (kind === "executions" && run.execution_id !== null)),
+        );
+        const rows = filterOperationsMetricRows(
+          aggregateOperationsPageRows(sourceRows, kind),
+          filters,
+        );
+        return {
+          data_source: "lifecycle_manifest_summary",
+          kind,
+          offset,
+          limit,
+          total: rows.length,
+          rows: rows.slice(offset, offset + limit),
+        };
+      },
+    );
+    return respond(context, payload, 200, true);
+  });
+}
+
+export function compactOperationsPage(
+  kind: "executions" | "conversations",
+  page: { data_source: string; offset: number; limit: number; total: number },
+  rows: readonly CompactLifecycleDetail[],
+) {
+  const known = (metric: CompactLifecycleDetail["metrics"]["duration"]) =>
+    metric.complete || metric.known_sum > 0 ? metric.known_sum : null;
+  return {
+    data_source: page.data_source,
+    kind,
+    offset: page.offset,
+    limit: page.limit,
+    total: page.total,
+    rows: rows.map((row) => ({
+      id: row.id,
+      started_at: row.occurred_at,
+      finished_at: null,
+      task_id: row.kind === "execution" ? row.parent_id : null,
+      execution_id: row.kind === "execution" ? row.id : row.parent_id,
+      conversation_id: row.kind === "conversation" ? row.id : null,
+      parent_run_id: null,
+      run_kind: "run" as const,
+      phase: row.kind,
+      status: row.status,
+      duration_ms: known(row.metrics.duration),
+      lifecycle_elapsed_ms: row.lifecycle_elapsed_ms ?? null,
+      total_tokens: known(row.metrics.total_tokens),
+      cost: known(row.metrics.cost),
+      currency: row.cost_currency,
+    })),
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-overview.test.ts

@@ -0,0 +1,68 @@
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createDashboardApp } from "./server.js";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
+
+describe("dashboard overview transport", () => {
+  it("serves compact overview aggregates without transporting all Runs", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const response = await app.request("/api/v2/operations?scope=overview", {
+      headers: { "x-zaip-session": "test-session" },
+    });
+
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      prds: unknown[];
+      runs: unknown[];
+      specs: unknown[];
+      tasks: unknown[];
+      summary?: { overview_metrics?: unknown };
+    };
+    if (payload.summary?.overview_metrics === undefined)
+      throw new Error("Operations overview payload has no summary metrics");
+    expect(payload).toMatchObject({ changes: [], executions: [], decisions: [] });
+    expect(payload.runs).toEqual([]);
+    expect(payload.summary.overview_metrics).toEqual(
+      expect.objectContaining({
+        duration_ms: expect.any(Number),
+        execution_day_count: expect.any(Number),
+        tokens: expect.any(Number),
+        cost_brl: expect.any(Number),
+      }),
+    );
+  });
+
+  it("serves the partial quick projection only when explicitly requested", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const response = await app.request("/api/v2/operations?scope=quick", {
+      headers: { "x-zaip-session": "test-session" },
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      source: ".agents/records",
+      prds: expect.any(Array),
+      specs: expect.any(Array),
+      tasks: [],
+      changes: [],
+      executions: [],
+      runs: [],
+      decisions: [],
+      summary: {
+        overview_metrics: {
+          partial: true,
+          data_source: "lifecycle_manifest_summary",
+          duration_ms: expect.any(Number),
+          execution_day_count: expect.any(Number),
+          tokens: expect.any(Number),
+          cost_brl: expect.any(Number),
+          task_status_counts: expect.any(Object),
+          task_risk_counts: expect.any(Object),
+          top_tasks: expect.any(Array),
+        },
+      },
+    });
+    expect(response.headers.get("etag")).toMatch(/^".+"$/);
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/server-period.ts

@@ -0,0 +1,47 @@
+/** Date-only filters in the dashboard represent complete calendar days. */
+import type { Context } from "hono";
+
+export function projectionPeriodFilter(context: Pick<Context, "req">): {
+  from: string | null;
+  to: string | null;
+} {
+  const from = context.req.query("from") ?? null;
+  const to = context.req.query("to") ?? null;
+  return {
+    from: dateOnlyBoundary(from, "start"),
+    to: dateOnlyBoundary(to, "end"),
+  };
+}
+
+function dateOnlyBoundary(value: string | null, boundary: "start" | "end"): string | null {
+  if (value === null || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
+  // Do not encode the current -03:00 offset. Historical Brazilian DST has a
+  // different offset, so the calendar contract must be resolved through IANA.
+  const start = saoPauloMidnight(value);
+  if (boundary === "start") return new Date(start).toISOString();
+  const [year, month, day] = value.split("-").map(Number) as [number, number, number];
+  const tomorrow = new Date(Date.UTC(year, month - 1, day + 1)).toISOString().slice(0, 10);
+  return new Date(saoPauloMidnight(tomorrow) - 1).toISOString();
+}
+
+function saoPauloMidnight(date: string): number {
+  const [year, month, day] = date.split("-").map(Number) as [number, number, number];
+  const localMidnight = Date.UTC(year, month - 1, day);
+  // Re-evaluate the offset after the first conversion so transitions around
+  // midnight remain tied to the IANA zone rather than a fixed historical UTC.
+  let instant = localMidnight - saoPauloOffsetMs(localMidnight);
+  instant = localMidnight - saoPauloOffsetMs(instant);
+  return instant;
+}
+
+function saoPauloOffsetMs(instant: number): number {
+  const zone = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/Sao_Paulo",
+    timeZoneName: "longOffset",
+  }).formatToParts(new Date(instant));
+  const offset = zone.find((part) => part.type === "timeZoneName")?.value ?? "GMT";
+  const match = /^GMT([+-])(\d{2}):(\d{2})$/.exec(offset);
+  if (match === null) return 0;
+  const minutes = Number(match[2]) * 60 + Number(match[3]);
+  return (match[1] === "+" ? 1 : -1) * minutes * 60_000;
+}