@nocoo/eagle-agent 0.3.0 → 0.5.0

package/dist/src/shared/realtime.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+const id = z.string().min(1).max(160);
+export const SubscriptionSchema = z.strictObject({
+    spaceId: id,
+    subscriptionId: id,
+});
+export const LivePaneSchema = z.strictObject({
+    id,
+    terminalId: id,
+    title: z.string().max(240),
+    rect: z.strictObject({
+        x: z.number().min(0).max(1),
+        y: z.number().min(0).max(1),
+        width: z.number().positive().max(1),
+        height: z.number().positive().max(1),
+    }),
+});
+export const TopologySchema = SubscriptionSchema.extend({
+    type: z.literal("topology"),
+    tabs: z
+        .array(z.strictObject({
+        id,
+        name: z.string().max(240),
+        panes: z.array(LivePaneSchema).max(32),
+    }))
+        .max(16),
+}).refine((v) => v.tabs.reduce((n, t) => n + t.panes.length, 0) <= 32);
+export const InputSchema = z
+    .strictObject({
+    type: z.literal("input"),
+    seq: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    paneId: id,
+    terminalId: id,
+    text: z.string().max(8000).default(""),
+    keys: z
+        .array(z.enum([
+        "enter",
+        "esc",
+        "tab",
+        "shift+tab",
+        "backspace",
+        "ctrl+c",
+        "ctrl+d",
+        "ctrl+l",
+    ]))
+        .max(4)
+        .default([]),
+})
+    .refine((v) => v.text.length > 0 || v.keys.length > 0);
+export const ViewerMessageSchema = z.union([
+    InputSchema,
+    z.strictObject({
+        type: z.literal("rendered"),
+        deliveryId: z.number().int().positive(),
+        deliveryBytes: z.number().int().positive(),
+    }),
+    z.strictObject({ type: z.enum(["ping", "control", "release"]) }),
+]);
+export const FrameSchema = SubscriptionSchema.extend({
+    type: z.literal("frame"),
+    paneId: id,
+    terminalId: id,
+    revision: z.number().int().nonnegative(),
+    text: z.string().max(32000),
+    observedAt: z.string().datetime(),
+    deliveryId: z.number().int().positive().optional(),
+    deliveryBytes: z.number().int().positive().optional(),
+});
+export const AckSchema = z.strictObject({
+    type: z.literal("ack"),
+    clientId: id,
+    seq: z.number().int().positive(),
+    status: z.enum(["submitted", "rejected", "unknown"]),
+});
+export const AgentMessageSchema = z.union([
+    TopologySchema,
+    FrameSchema,
+    AckSchema,
+    SubscriptionSchema.extend({ type: z.literal("unavailable") }),
+    z.strictObject({ type: z.literal("ping") }),
+]);
+export const BridgeMessageSchema = z.union([
+    z.strictObject({
+        type: z.literal("subscriptions"),
+        spaces: z.array(SubscriptionSchema).max(4),
+    }),
+    InputSchema.safeExtend({ ...SubscriptionSchema.shape, clientId: id }),
+    z.strictObject({ type: z.literal("pong") }),
+]);
+export const LiveServerMessageSchema = z.union([
+    TopologySchema,
+    FrameSchema,
+    AckSchema.omit({ clientId: true }),
+    z.strictObject({
+        type: z.literal("status"),
+        online: z.boolean(),
+        control: z.boolean(),
+    }),
+    z.strictObject({ type: z.literal("pong") }),
+]);

package/dist/src/shared/summaries.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+const id = z
+    .string()
+    .min(1)
+    .max(160)
+    .regex(/^[\w.:/-]+$/);
+const timestamp = z.iso.datetime().transform((v) => new Date(v).toISOString());
+const text = z.string().trim().min(1).max(1200);
+const refs = z.array(z.string().regex(/^[a-f0-9]{64}$/)).max(30);
+export const SummaryCheckSchema = z.strictObject({
+    spaceId: id,
+    paneId: id,
+    taskId: id,
+    basis: refs,
+    observedAt: timestamp,
+});
+export const SemanticSummarySchema = z.strictObject({
+    task: text,
+    phase: z.enum([
+        "understand",
+        "implement",
+        "verify",
+        "deliver",
+        "waiting",
+        "complete",
+        "unknown",
+    ]),
+    progress: text,
+    outcomes: z
+        .array(z.strictObject({
+        kind: z.enum(["result", "test", "commit", "deployment"]),
+        text,
+        evidenceRefs: refs,
+    }))
+        .max(12),
+    blocker: text.nullable(),
+    nextStep: text,
+    rationale: text,
+    evidenceRefs: refs,
+});
+export const SummaryUpdateSchema = SummaryCheckSchema.extend({
+    summary: SemanticSummarySchema,
+});
+export const SummaryBatchSchema = z
+    .strictObject({
+    protocolVersion: z.literal(1),
+    machineId: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,79}$/),
+    managerId: id,
+    sequence: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    sentAt: timestamp,
+    updates: z.array(SummaryUpdateSchema).max(1000),
+    checks: z.array(SummaryCheckSchema).max(1000),
+})
+    .refine((b) => {
+    const keys = [...b.updates, ...b.checks].map(taskKey);
+    return keys.length <= 1000 && new Set(keys).size === keys.length;
+}, "Duplicate or too many pane entries");
+export const paneKey = (p) => `${encodeURIComponent(p.spaceId)}/${encodeURIComponent(p.paneId)}`;
+export const taskKey = (p) => `${paneKey(p)}/${encodeURIComponent(p.taskId)}`;
+export function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+export async function digest(value) {
+    return Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical(value)))), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function deterministicEvidence(evidence) {
+    return evidence.filter((e) => /^(git:HEAD\+status$|herdr:process-info|codex:(thread-goal|final-message|turn-event|tool-event)|grok:final-message|pi:final-message)/.test(e.source));
+}
+const stableEvidence = (e) => ({
+    ...e,
+    observedAt: ["git", "process"].includes(e.kind) ? null : e.observedAt,
+});
+export async function evidenceKeys(evidence) {
+    return Object.fromEntries(await Promise.all(deterministicEvidence(evidence).map(async (e) => [
+        await digest(stableEvidence(e)),
+        e,
+    ])));
+}
+export function semanticContent(entry) {
+    return canonical({ taskId: entry.taskId, summary: entry.summary });
+}
+export const PHASE_LABEL = {
+    understand: "梳理需求",
+    implement: "实施中",
+    verify: "验证中",
+    deliver: "交付中",
+    waiting: "等待处理",
+    complete: "声称完成",
+    unknown: "待判断",
+};
+export function summaryFreshness(summary, pane, lastSeen, now, capturedAt = now, availability) {
+    if (summary.taskId !== pane.task.id)
+        return "superseded";
+    if (!lastSeen || Date.parse(now) - Date.parse(lastSeen) > 90_000)
+        return "disconnected";
+    if (Date.parse(now) - Date.parse(summary.checkedAt) > 300_000)
+        return "stale";
+    if (availability || Date.parse(now) - Date.parse(capturedAt) > 90_000)
+        return "stale";
+    const facts = (items) => deterministicEvidence(items)
+        .filter((e) => e.taskId === pane.task.id)
+        .map((e) => canonical(stableEvidence(e)))
+        .sort();
+    if (canonical(facts(pane.evidence)) !== canonical(facts(summary.evidence)))
+        return "stale";
+    return "current";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocoo/eagle-agent",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Report all local Herdr spaces and machine resources to Eagle",
   "type": "module",
   "license": "UNLICENSED",
@@ -24,6 +24,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
+    "ws": "^8.21.3",
     "zod": "^4.1.0"
   },
   "publishConfig": {