@zaip-ai/cli 1.0.4 → 1.0.7

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

@@ -0,0 +1,526 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createDashboardApp } from "./server.js";
+import { pricedUsageBucket, pricingCatalog } from "./server.test-fixtures.js";
+
+describe("dashboard backend snapshot", () => {
+  it("serves operations and costs from one coherent snapshot", async () => {
+    const fixtureRoot = await mkdtemp(join(tmpdir(), "zaip-dashboard-snapshot-"));
+    const updatedAt = "2026-07-14T00:00:00.000Z";
+    await mkdir(join(fixtureRoot, ".agents", "config"), { recursive: true });
+    await mkdir(join(fixtureRoot, ".agents", "records", "lifecycle", "indexes"), {
+      recursive: true,
+    });
+    await mkdir(join(fixtureRoot, ".agents", "config", "pricing", "fx", "2026", "07", "15"), {
+      recursive: true,
+    });
+    await writeFile(
+      join(fixtureRoot, ".agents", "config", "project.yaml"),
+      [
+        "schema_version: 1",
+        "project:",
+        "  id: dashboard-fixture",
+        "  name: dashboard-fixture",
+        "  timezone: UTC",
+        "stack:",
+        "  id: typescript-hono-kysely",
+        "  overrides: {}",
+        "clients:",
+        "  codex: true",
+        "  claude: true",
+        "tracking:",
+        "  enabled: true",
+        "  currency: USD",
+        "  storage_mode: tracked_sanitized",
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+    await writeFile(
+      join(fixtureRoot, ".agents", "config", "framework.lock.yaml"),
+      [
+        "lock_version: 1",
+        "framework:",
+        "  version: 1.0.0",
+        "  distribution_sha256: null",
+        "layout:",
+        "  version: 3",
+        "resolved_profile:",
+        "  id: null",
+        "  sha256: null",
+        "managed_files: {}",
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+    await writeFile(
+      join(fixtureRoot, ".agents", "records", "lifecycle", "indexes", "task.json"),
+      `${JSON.stringify({
+        schema_version: 1,
+        entities: {
+          "TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2": {
+            kind: "task",
+            id: "TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+            title: "Dashboard fixture",
+            status: "completed",
+            risk: "standard",
+            priority: "medium",
+            updated_at: updatedAt,
+            relations: [],
+            usage: null,
+            data: {
+              created_at: updatedAt,
+              finished_at: updatedAt,
+              change_id: "CHG-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+            },
+          },
+        },
+      })}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(fixtureRoot, ".agents", "records", "lifecycle", "indexes", "execution.json"),
+      `${JSON.stringify({
+        schema_version: 1,
+        entities: {
+          "EXEC-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2": {
+            kind: "execution",
+            id: "EXEC-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+            title: null,
+            status: "completed",
+            risk: null,
+            priority: null,
+            updated_at: updatedAt,
+            relations: ["TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2"],
+            usage: null,
+            data: {
+              schema_version: 2,
+              id: "EXEC-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+              revision: 1,
+              status: "completed",
+              status_reason: null,
+              created_at: updatedAt,
+              updated_at: updatedAt,
+              started_at: updatedAt,
+              finished_at: updatedAt,
+              result: "Dashboard fixture passed",
+              kind: "delivery",
+              client_turn_id: "TURN-DASHBOARD-FIXTURE",
+              origin: {
+                type: "task",
+                task_id: "TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+              },
+              plan_revision: 1,
+              plan_hash: "dashboard-fixture-plan",
+              dag: {
+                nodes: [
+                  {
+                    task_id: "TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+                    change_id: "CHG-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+                    depends_on: [],
+                  },
+                ],
+                topological_order: ["TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2"],
+              },
+            },
+          },
+        },
+      })}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(fixtureRoot, ".agents", "records", "lifecycle", "indexes", "run.json"),
+      `${JSON.stringify({
+        schema_version: 1,
+        entities: {
+          "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2": {
+            kind: "run",
+            id: "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+            title: null,
+            status: "completed",
+            risk: null,
+            priority: null,
+            updated_at: updatedAt,
+            relations: [],
+            usage: null,
+            data: {
+              started_at: updatedAt,
+              finished_at: updatedAt,
+              entrypoint: "task",
+              work_type: "new",
+              client: "codex",
+              agent: "codex",
+              provider: "openai",
+              model: "dynamic-model",
+              service_tier: "standard",
+              conversation_id: "CONV-A1B2",
+              entrypoint_usage: pricedUsageBucket(),
+            },
+          },
+          "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-LIFECYCLE": {
+            kind: "run",
+            id: "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-LIFECYCLE",
+            title: null,
+            status: "completed",
+            risk: null,
+            priority: null,
+            updated_at: updatedAt,
+            relations: [],
+            usage: null,
+            data: {
+              started_at: updatedAt,
+              finished_at: updatedAt,
+              entrypoint: "task",
+              work_type: "new",
+              client: "codex",
+              agent: "codex",
+              provider: null,
+              model: "unavailable",
+              service_tier: null,
+              conversation_id: "CONV-LIFECYCLE",
+            },
+          },
+        },
+      })}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(fixtureRoot, ".agents", "config", "pricing", "models.json"),
+      `${JSON.stringify(pricingCatalog(1))}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(fixtureRoot, ".agents", "config", "pricing", "fx", "2026", "07", "15", "usd-brl.json"),
+      `${JSON.stringify({
+        schema_version: 1,
+        base: "USD",
+        quote: "BRL",
+        rate: 5,
+        as_of: updatedAt,
+        source_label: "test",
+        source_url: "https://example.com/fx",
+      })}\n`,
+      "utf8",
+    );
+    const v2Run = (runId: string, usage: boolean) =>
+      [
+        {
+          schema_version: 2,
+          event_id: `${runId}:000001`,
+          run_id: runId,
+          sequence: 1,
+          occurred_at: updatedAt,
+          type: "run.started",
+          attribution_status: "legacy_unattributed",
+          phase: "execution",
+          entrypoint: "task",
+          work_type: "new",
+          storage_mode: "tracked_sanitized",
+          client: "codex",
+          agent: "codex",
+          provider: "openai",
+          model: "dynamic-model",
+          conversation_id: `CONV-${runId.slice(-4)}`,
+          execution_id: "EXEC-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+          task_id: "TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+          spec_id: null,
+          prd_id: null,
+          change_id: "CHG-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+          parent_run_id: null,
+          continuation_of_run_id: null,
+          retry_of_run_id: null,
+        },
+        ...(usage
+          ? [
+              {
+                schema_version: 2,
+                event_id: `${runId}:000002`,
+                run_id: runId,
+                sequence: 2,
+                occurred_at: "2026-07-14T00:00:05.000Z",
+                type: "usage.recorded",
+                phase: "execution",
+                activity_kind: "implementation",
+                classification_source: "current_context",
+                tokens: {
+                  input: 10,
+                  cached_input: 0,
+                  output: 5,
+                  reasoning: 0,
+                  total: 15,
+                  source: "provider_reported",
+                },
+                cost: { usd: 1.25, brl: 6.25 },
+                provider: "openai",
+                model: "dynamic-model",
+                source_segment_key: null,
+                supersedes_event_id: null,
+                duration_ms: 5_000,
+                duration_provenance: "observed",
+              },
+            ]
+          : []),
+        {
+          schema_version: 2,
+          event_id: `${runId}:${usage ? "000003" : "000002"}`,
+          run_id: runId,
+          sequence: usage ? 3 : 2,
+          occurred_at: "2026-07-14T00:00:05.000Z",
+          type: "run.finished",
+          phase: "execution",
+          status: "completed",
+          duration_ms: null,
+          duration_provenance: null,
+        },
+      ]
+        .map((record) => JSON.stringify(record))
+        .join("\n");
+    await mkdir(join(fixtureRoot, ".agents", "records", "runs", "2026", "07"), { recursive: true });
+    await writeFile(
+      join(
+        fixtureRoot,
+        ".agents",
+        "records",
+        "runs",
+        "2026",
+        "07",
+        "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2.jsonl",
+      ),
+      `${v2Run("RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2", true)}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(
+        fixtureRoot,
+        ".agents",
+        "records",
+        "runs",
+        "2026",
+        "07",
+        "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-LIFECYCLE.jsonl",
+      ),
+      `${v2Run("RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-LIFECYCLE", false)}\n`,
+      "utf8",
+    );
+
+    try {
+      const app = createDashboardApp(fixtureRoot, "test-session");
+      const allCosts = await app.request("/api/v2/cost-monitor?currency=BRL", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      const julyOperations = await app.request("/api/v2/operations?from=2026-07-01&to=2026-07-31", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      const monthlyCosts = await app.request(
+        "/api/v2/cost-monitor?currency=BRL&from=2026-07-01&to=2026-07-31",
+        { headers: { "x-zaip-session": "test-session" } },
+      );
+      const response = await app.request("/api/v2/snapshot", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      const julySnapshot = await app.request("/api/v2/snapshot?from=2026-07-01&to=2026-07-31", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      const operations = await app.request("/api/v2/operations", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      const portableServerPath = new URL("../server.mjs", import.meta.url).href;
+      const { createDashboardApp: createPortableDashboardApp } = await import(portableServerPath);
+      const portableApp = createPortableDashboardApp(fixtureRoot, "test-session");
+      const portableAllCosts = await portableApp.request("/api/v2/cost-monitor?currency=BRL", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      const portableJulyCosts = await portableApp.request(
+        "/api/v2/cost-monitor?currency=BRL&from=2026-07-01&to=2026-07-31",
+        { headers: { "x-zaip-session": "test-session" } },
+      );
+
+      expect(monthlyCosts.status, await monthlyCosts.clone().text()).toBe(200);
+      expect(allCosts.status, await allCosts.clone().text()).toBe(200);
+      await expect(monthlyCosts.clone().json()).resolves.toMatchObject({
+        readonly: true,
+        currency: "BRL",
+      });
+      expect(response.status, await response.clone().text()).toBe(200);
+      expect(julySnapshot.status, await julySnapshot.clone().text()).toBe(200);
+      expect(operations.status, await operations.clone().text()).toBe(200);
+      const allOperationsPayload = (await operations.clone().json()) as {
+        runs: Array<{
+          id: string;
+          duration_ms: number | null;
+          source_duration_ms: number | null;
+          usage: { total: { tokens: { total: number | null }; cost: { brl: number | null } } };
+        }>;
+      };
+      type OperationRunMetric = {
+        id: string;
+        duration_ms: number | null;
+        source_duration_ms: number | null;
+        usage: { total: { tokens: { total: number | null }; cost: { brl: number | null } } };
+      };
+      type CostRunMetric = {
+        run_id: string;
+        duration_ms: number | null;
+        total_tokens: number | null;
+        estimated_brl: number | null;
+      };
+      const julyOperationsPayload = (await julyOperations.json()) as { runs: OperationRunMetric[] };
+      const allCostsPayload = (await allCosts.json()) as {
+        runs: Array<{
+          run_id: string;
+          duration_ms: number | null;
+          total_tokens: number | null;
+          estimated_brl: number | null;
+        }>;
+      };
+      const julyCostsPayload = (await monthlyCosts.clone().json()) as { runs: CostRunMetric[] };
+      const portableAllCostsPayload = (await portableAllCosts.json()) as { runs: CostRunMetric[] };
+      const portableJulyCostsPayload = (await portableJulyCosts.json()) as {
+        runs: CostRunMetric[];
+      };
+      const julySnapshotPayload = (await julySnapshot.json()) as {
+        operations: { summary: { execution_duration_ms: number } };
+        costs: {
+          groups: Record<"daily" | "monthly" | "annual", Array<{ duration_ms: number | null }>>;
+        };
+      };
+      const runIds = (rows: readonly { id: string }[] | readonly { run_id: string }[]) =>
+        rows.map((row) => ("id" in row ? row.id : row.run_id)).sort();
+      expect(runIds(allCostsPayload.runs)).toEqual(runIds(allOperationsPayload.runs));
+      expect(runIds(julyCostsPayload.runs)).toEqual(runIds(julyOperationsPayload.runs));
+      expect(runIds(portableAllCostsPayload.runs)).toEqual(runIds(allCostsPayload.runs));
+      expect(runIds(portableJulyCostsPayload.runs)).toEqual(runIds(julyCostsPayload.runs));
+      const expectMetricParity = (
+        costRows: readonly CostRunMetric[],
+        operationRows: readonly OperationRunMetric[],
+      ) => {
+        const operationsById = new Map(operationRows.map((run) => [run.id, run] as const));
+        for (const cost of costRows) {
+          const operation = operationsById.get(cost.run_id);
+          expect(operation).toBeDefined();
+          expect(cost).toMatchObject({
+            duration_ms: operation?.source_duration_ms ?? operation?.duration_ms,
+            total_tokens: operation?.usage.total.tokens.total,
+            estimated_brl: operation?.usage.total.cost.brl,
+          });
+        }
+      };
+      expectMetricParity(allCostsPayload.runs, allOperationsPayload.runs);
+      expectMetricParity(julyCostsPayload.runs, julyOperationsPayload.runs);
+      expect(portableAllCostsPayload.runs).toEqual(allCostsPayload.runs);
+      expect(portableJulyCostsPayload.runs).toEqual(julyCostsPayload.runs);
+      const groupDuration = (group: readonly { duration_ms: number | null }[]) =>
+        group.reduce((sum, row) => sum + (row.duration_ms ?? 0), 0);
+      expect(julySnapshotPayload.operations.summary.execution_duration_ms).toBe(
+        groupDuration(julySnapshotPayload.costs.groups.daily),
+      );
+      expect(julySnapshotPayload.operations.summary.execution_duration_ms).toBe(
+        groupDuration(julySnapshotPayload.costs.groups.monthly),
+      );
+      expect(julySnapshotPayload.operations.summary.execution_duration_ms).toBe(
+        groupDuration(julySnapshotPayload.costs.groups.annual),
+      );
+      const rootOperations = allOperationsPayload.runs.find(
+        (run) => run.id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+      );
+      const rootCosts = allCostsPayload.runs.find(
+        (run) => run.run_id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+      );
+      expect(
+        allOperationsPayload.runs.filter(
+          (run) => run.id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+        ),
+      ).toHaveLength(1);
+      expect(
+        allCostsPayload.runs.filter(
+          (run) => run.run_id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+        ),
+      ).toHaveLength(1);
+      expect(rootCosts).toMatchObject({
+        // Cost reports analytical duration, which is the observed source
+        // duration when it exists; Operations also exposes lifecycle elapsed
+        // separately as duration_ms.
+        duration_ms: rootOperations?.source_duration_ms ?? rootOperations?.duration_ms,
+        total_tokens: rootOperations?.usage.total.tokens.total,
+        estimated_brl: rootOperations?.usage.total.cost.brl,
+      });
+      expect(
+        allCostsPayload.runs.find(
+          (run) => run.run_id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-LIFECYCLE",
+        ),
+      ).toMatchObject({
+        total_tokens: null,
+        estimated_brl: null,
+      });
+      await expect(operations.json()).resolves.toMatchObject({
+        tasks: [
+          {
+            id: "TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+            status: "completed",
+          },
+        ],
+        executions: [
+          {
+            id: "EXEC-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
+            status: "completed",
+          },
+        ],
+      });
+      await expect(response.json()).resolves.toMatchObject({
+        dashboard: {
+          title: "Dashboard Zaip AIOS",
+          repository_name: "",
+        },
+        operations: { readonly: true, summary: { source_latest_at: "2026-07-14T00:00:05.000Z" } },
+        costs: {
+          readonly: true,
+          currency: "BRL",
+        },
+        projection: {
+          source_latest_at: "2026-07-14T00:00:05.000Z",
+          served_at: expect.any(String),
+        },
+      });
+
+      const reconciliation = await app.request("/api/v2/reconcile-open-work", {
+        method: "POST",
+        headers: { "x-zaip-session": "test-session" },
+      });
+      expect(reconciliation.status, await reconciliation.clone().text()).toBe(200);
+      await expect(reconciliation.json()).resolves.toMatchObject({
+        reconciliation: { reconciled_ids: [] },
+      });
+
+      const update = await app.request("/api/v2/pricing", {
+        method: "PUT",
+        headers: {
+          "content-type": "application/json",
+          "x-zaip-session": "test-session",
+        },
+        body: JSON.stringify(pricingCatalog(3)),
+      });
+      expect(update.status, await update.clone().text()).toBe(200);
+
+      const updated = await app.request("/api/v2/snapshot?currency=BRL", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      await expect(updated.json()).resolves.toMatchObject({
+        costs: { readonly: true, currency: "BRL" },
+      });
+
+      const usd = await app.request("/api/v2/snapshot?currency=USD", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      await expect(usd.json()).resolves.toMatchObject({
+        costs: {
+          currency: "USD",
+          pricing: { fx_rate: null, conversion_applied: false },
+        },
+      });
+    } finally {
+      await rm(fixtureRoot, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,73 @@
+import { parseAgentCatalog, parseYaml, type WorkspaceFileSystem } from "@zaip-ai/core";
+import { type InvocationSummaryV1, queryInvocationManifestPeriod } from "@zaip-ai/costs";
+import type { Context } from "hono";
+
+export function selectedCurrency(context: Context): "BRL" | "USD" {
+  return context.req.query("currency") === "USD" ? "USD" : "BRL";
+}
+
+export function queryValues(context: Context, key: string): string[] {
+  const value = context.req.query(key);
+  return value === undefined || value === "" ? [] : value.split(",").filter(Boolean);
+}
+
+export async function invocationSummariesForPeriod(
+  filesystem: WorkspaceFileSystem,
+  query: Omit<Parameters<typeof queryInvocationManifestPeriod>[1], "page" | "page_size">,
+): Promise<InvocationSummaryV1[]> {
+  const cache = new Map<string, string>();
+  const summaries = new Map<string, InvocationSummaryV1>();
+  let page = 1;
+  let hasMore = true;
+  while (hasMore) {
+    const result = await queryInvocationManifestPeriod(filesystem, {
+      ...query,
+      cache,
+      page,
+      page_size: 500,
+    });
+    for (const summary of result.summaries) {
+      if (isInvocationSummary(summary)) summaries.set(summary.agent_invocation_id, summary);
+    }
+    hasMore = result.has_more;
+    page += 1;
+  }
+  return [...summaries.values()];
+}
+
+export function isInvocationSummary(value: unknown): value is InvocationSummaryV1 {
+  if (typeof value !== "object" || value === null) return false;
+  const summary = value as Partial<InvocationSummaryV1>;
+  return (
+    typeof summary.agent_invocation_id === "string" &&
+    typeof summary.root_agent_invocation_id === "string" &&
+    (summary.parent_agent_invocation_id === null ||
+      typeof summary.parent_agent_invocation_id === "string") &&
+    (summary.invocation_kind === "orchestrator" || summary.invocation_kind === "delegated") &&
+    typeof summary.run_id === "string" &&
+    typeof summary.quantitative_metrics === "object" &&
+    summary.quantitative_metrics !== null &&
+    typeof summary.time === "object" &&
+    summary.time !== null &&
+    Array.isArray(summary.usage_segments)
+  );
+}
+
+export async function configuredAgentNames(filesystem: WorkspaceFileSystem): Promise<{
+  agentNames: string[];
+  agentNamesById: Record<string, string>;
+  agentNamesByRole: Record<string, string>;
+}> {
+  try {
+    const agents = parseAgentCatalog(
+      parseYaml(await filesystem.readText(".agents/config/agents/catalog.yaml")),
+    ).agents;
+    return {
+      agentNames: agents.map((agent) => agent.codex_name),
+      agentNamesById: Object.fromEntries(agents.map((agent) => [agent.id, agent.codex_name])),
+      agentNamesByRole: Object.fromEntries(agents.map((agent) => [agent.role, agent.codex_name])),
+    };
+  } catch {
+    return { agentNames: [], agentNamesById: {}, agentNamesByRole: {} };
+  }
+}