deepdebug-local-agent 1.4.0 → 1.5.0

package/tools/interop/LaV2NodeContentInteropTest.java

@@ -0,0 +1,248 @@
+package io.visionhammer.gateway.cloud.infrastructure.byoc;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.visionhammer.gateway.cloud.application.byoc.v2.LaProtocolV2Properties;
+import io.visionhammer.gateway.cloud.application.byoc.v2.LaV2Chunk;
+import io.visionhammer.gateway.cloud.application.byoc.v2.LaV2InboundListener;
+import io.visionhammer.gateway.cloud.application.byoc.v2.LaV2Metrics;
+import io.visionhammer.gateway.cloud.application.byoc.v2.LaV2Session;
+import io.visionhammer.gateway.cloud.application.byoc.v2.LaV2SessionStore;
+import io.visionhammer.gateway.cloud.application.byoc.v2.LaV2TestKit;
+import io.visionhammer.gateway.governance.application.DataPlanePolicy;
+import io.visionhammer.gateway.identity.application.AgentAuthorizationEntity;
+import io.visionhammer.gateway.identity.application.AgentAuthorizationStore;
+import io.visionhammer.gateway.shared.localagent.AgentRequestSigner;
+import io.visionhammer.gateway.workspace.application.WorkspaceRepository;
+import org.junit.jupiter.api.Test;
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
+import org.springframework.web.reactive.socket.server.WebSocketService;
+import org.springframework.web.reactive.socket.server.support.HandshakeWebSocketService;
+import org.springframework.web.reactive.socket.server.upgrade.ReactorNettyRequestUpgradeStrategy;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+import reactor.netty.DisposableServer;
+import reactor.netty.http.server.HttpServer;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.time.Clock;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HexFormat;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import static io.visionhammer.gateway.cloud.application.byoc.v2.LaV2TestKit.OM;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * F3-07 interoperability: the REAL Node Local Agent content handlers (opaque ids, path guard, DLP enforce, git diff,
+ * chunking) against the REAL gateway {@link LaV2Session} behind a real Reactor Netty WebSocket on loopback, real
+ * system clock, real Ed25519 signer. Run from the gateway checkout (JDK 21):
+ *
+ *   LA_REPO=/path/to/deepdebug-local-agent mvn -o test -Dtest=LaV2NodeContentInteropTest
+ *
+ * Skipped when LA_REPO is not set. Not proven here: Cloud Run / LB / TLS, Memorystore, two gateway instances, the HTTP
+ * relay endpoint (F3-06) in front of this session.
+ */
+class LaV2NodeContentInteropTest {
+
+    private static final String TENANT = LaV2TestKit.TENANT;
+    private static final String AGENT = LaV2TestKit.AGENT;
+
+    private static Map<String, Object> request(String kind, String ref) {
+        return Map.of("kind", kind, "ref", ref, "actor", Map.of("userId", "usr-42", "role", "member"));
+    }
+
+    @Test
+    void realNodeContentHandlersAgainstTheRealLaV2Session() throws Exception {
+        String laRepo = System.getenv("LA_REPO");
+        assumeTrue(laRepo != null && !laRepo.isBlank(), "LA_REPO not set");
+
+        Clock clock = Clock.systemUTC();
+        LaProtocolV2Properties props = new LaProtocolV2Properties();
+        props.setEnabled(true);
+        List<String> rejected = Collections.synchronizedList(new ArrayList<>());
+        LaV2Metrics metrics = new LaV2Metrics() {
+            @Override public void rejected(String code) { rejected.add(code); }
+        };
+        LaV2InboundListener listener = (t, a, type, rid, payload) -> { };
+        AgentRequestSigner signer = new AgentRequestSigner(LaV2TestKit.PEM, "k1", clock);
+        LaV2Session.Env env = new LaV2Session.Env(LaV2TestKit.CONTRACT, props, signer, OM, clock, metrics, Schedulers.parallel(), List.of(listener));
+
+        AgentAuthorizationStore store = mock(AgentAuthorizationStore.class);
+        WorkspaceRepository workspaces = mock(WorkspaceRepository.class);
+        DataPlanePolicy policy = mock(DataPlanePolicy.class);
+        when(workspaces.findDefaultByTenantId(anyString())).thenReturn(Mono.empty());
+        when(store.save(any())).thenAnswer(i -> Mono.just(i.getArgument(0)));
+        when(store.touchLastSeen(any())).thenReturn(Mono.just(1));
+        when(policy.requiresEnforcedSigning(anyString())).thenReturn(Mono.just(true));
+        AgentAuthorizationEntity auth = new AgentAuthorizationEntity();
+        auth.setId(UUID.fromString(AGENT));
+        auth.setTenantId(UUID.fromString(TENANT));
+        auth.setAuthorizationToken("tok");
+        when(store.findByAuthorizationToken("tok")).thenReturn(Mono.just(auth));
+        AgentWebSocketHandler handler = new AgentWebSocketHandler(OM, workspaces, store, signer, null, null, null,
+                new LaV2SessionStore(env), props, policy);
+
+        WebSocketService wsService = new HandshakeWebSocketService(new ReactorNettyRequestUpgradeStrategy());
+        HttpHandler http = WebHttpHandlerBuilder.webHandler(exchange -> wsService.handleRequest(exchange, handler)).build();
+        DisposableServer server = HttpServer.create().host("127.0.0.1").port(0).handle(new ReactorHttpHandlerAdapter(http)).bindNow();
+
+        ProcessBuilder pb = new ProcessBuilder("node", laRepo + "/tools/interop/la-interop-content-client.mjs");
+        pb.environment().putAll(Map.of(
+                "GW_URL", "ws://127.0.0.1:" + server.port() + "/api/v1/agent/ws", "TOKEN", "tok", "TENANT", TENANT, "AGENT", AGENT,
+                "KEY_ID", "k1", "PUBLIC_KEY", LaV2TestKit.PUB, "MODE", "enforce", "LOCAL_AGENT_DLP_MODE", "enforce"));
+        pb.redirectErrorStream(true);
+        Process proc = pb.start();
+        BlockingQueue<JsonNode> events = new LinkedBlockingQueue<>();
+        List<String> transcript = Collections.synchronizedList(new ArrayList<>());
+        Thread reader = new Thread(() -> {
+            try (BufferedReader r = new BufferedReader(new InputStreamReader(proc.getInputStream(), StandardCharsets.UTF_8))) {
+                String line;
+                while ((line = r.readLine()) != null) {
+                    transcript.add(line);
+                    try {
+                        events.add(OM.readTree(line));
+                    } catch (Exception ignored) {
+                        // node warnings
+                    }
+                }
+            } catch (Exception ignored) {
+                // process ended
+            }
+        });
+        reader.setDaemon(true);
+        reader.start();
+        java.io.Writer stdin = new java.io.OutputStreamWriter(proc.getOutputStream(), StandardCharsets.UTF_8);
+
+        try {
+            JsonNode refsEvt = await(events, "refs", 20);
+            await(events, "ready", 15);
+            assertThat(handler.isAgentConnected(TENANT)).isTrue();
+            JsonNode refs = refsEvt.path("refs");
+            String ghp = refsEvt.path("ghp").asText();
+            assertThat(refs.path("envFile").isNull()).as("no id is minted for .env").isTrue();
+
+            // 1. a file with a token: served, the token masked (DLP enforce), the rest intact
+            List<LaV2Chunk> app = content("file", refs.path("app").asText(), handler);
+            assertThat(app.get(0).status()).isEqualTo("ok");
+            String appText = new String(concat(app), StandardCharsets.UTF_8);
+            assertThat(appText).contains("first line").contains("[REDACTED:github_token]").contains("last line").doesNotContain(ghp);
+
+            // 2. 1 MiB = 32 chunks, byte for byte (no secrets in it)
+            List<LaV2Chunk> big = content("file", refs.path("big").asText(), handler);
+            assertThat(big).hasSize(32);
+            assertThat(big.get(31).last()).isTrue();
+            assertThat(HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(concat(big)))).isEqualTo(refsEvt.path("bigSha256").asText());
+            assertThat(concat(big)).hasSize(refsEvt.path("bigBytes").asInt());
+
+            // 3. a token straddling the 32 KiB chunk boundary of the ORIGINAL file never appears, whole or in part
+            List<LaV2Chunk> mid = content("file", refs.path("mid").asText(), handler);
+            assertThat(mid.get(0).status()).isEqualTo("ok");
+            assertThat(mid.size()).isGreaterThanOrEqualTo(2);
+            for (LaV2Chunk c : mid) {
+                assertThat(new String(c.data(), StandardCharsets.UTF_8)).doesNotContain(ghp.substring(0, 12));
+            }
+            assertThat(new String(concat(mid), StandardCharsets.UTF_8)).contains("[REDACTED:github_token]");
+
+            // 4. an id handed out for an innocent file, later swapped for a link to a file outside the workspace: forbidden, no data
+            List<LaV2Chunk> swapped = content("file", refs.path("swapped").asText(), handler);
+            assertThat(swapped).hasSize(1);
+            assertThat(swapped.get(0).status()).isEqualTo("forbidden");
+            assertThat(swapped.get(0).data()).isEmpty();
+
+            // 5. paths are never ids: traversal, absolute, plain relative -> not_found; nothing else comes back
+            for (String ref : List.of("../../etc/passwd", "/etc/passwd", "src/app.txt", "..%2f..%2fetc%2fpasswd", "cr1_AAAAAAAAAAAAAAAAAAAAAA")) {
+                List<LaV2Chunk> r = content("file", ref, handler);
+                assertThat(r).hasSize(1);
+                assertThat(r.get(0).status()).as(ref).isEqualTo("not_found");
+                assertThat(r.get(0).data()).isEmpty();
+            }
+
+            // 6. a binary file cannot be inspected by the DLP: withheld in enforce
+            assertThat(content("file", refs.path("bin").asText(), handler).get(0).status()).isEqualTo("forbidden");
+
+            // 7. kinds the agent does not serve yet: error + protocol_unsupported (a code of the contract)
+            List<LaV2Chunk> report = content("report", refs.path("app").asText(), handler);
+            assertThat(report.get(0).status()).isEqualTo("error");
+            assertThat(report.get(0).errorCode()).isEqualTo("protocol_unsupported");
+
+            // 8. diff of the work tree (symbolic ref, no client data in it) and of one minted file: masked
+            List<LaV2Chunk> diff = content("diff", "worktree", handler);
+            assertThat(diff.get(0).status()).isEqualTo("ok");
+            assertThat(diff.get(0).contentType()).isEqualTo("text/x-diff");
+            String diffText = new String(concat(diff), StandardCharsets.UTF_8);
+            assertThat(diffText).contains("tracked.js").contains("[REDACTED:github_token]").doesNotContain(ghp).doesNotContain("SECRET-ENV-VALUE").doesNotContain(".env");
+            assertThat(new String(concat(content("diff", refs.path("diffFile").asText(), handler)), StandardCharsets.UTF_8)).contains("tracked.js");
+
+            // 9. the consumer cancels after the first chunk (the relay's client went away): the agent is not left blocked
+            List<LaV2Chunk> first = handler.requestContent(TENANT, null, request("file", refs.path("big").asText()), "ws-1")
+                    .take(1).collectList().block(Duration.ofSeconds(20));
+            assertThat(first).hasSize(1);
+            List<LaV2Chunk> afterCancel = content("file", refs.path("app").asText(), handler);
+            assertThat(afterCancel.get(0).status()).isEqualTo("ok");
+
+            // nothing the Node agent put on the wire was refused by the real gateway session
+            assertThat(rejected).as("frames the real LaV2Session rejected: %s", rejected).isEmpty();
+            // nothing in what the agent printed (events, warnings) carries content or a path
+            String printed = String.join("\n", transcript);
+            assertThat(printed).doesNotContain("OUTSIDE-SECRET").doesNotContain("SECRET-ENV-VALUE").doesNotContain("f307-interop-");
+            System.out.println("CONTENT INTEROP OK: rejected=" + rejected);
+        } finally {
+            try {
+                send(stdin, "quit");
+            } catch (Exception ignored) {
+                // gone
+            }
+            proc.waitFor(5, TimeUnit.SECONDS);
+            proc.destroyForcibly();
+            server.disposeNow();
+        }
+    }
+
+    private static List<LaV2Chunk> content(String kind, String ref, AgentWebSocketHandler handler) {
+        return handler.requestContent(TENANT, null, request(kind, ref), "ws-1").collectList().block(Duration.ofSeconds(30));
+    }
+
+    private static void send(java.io.Writer w, String line) throws Exception {
+        w.write(line + "\n");
+        w.flush();
+    }
+
+    private static JsonNode await(BlockingQueue<JsonNode> q, String evt, int seconds) throws Exception {
+        long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(seconds);
+        List<String> seen = new ArrayList<>();
+        while (System.nanoTime() < deadline) {
+            JsonNode n = q.poll(100, TimeUnit.MILLISECONDS);
+            if (n == null) {
+                continue;
+            }
+            if (evt.equals(n.path("evt").asText())) {
+                return n;
+            }
+            seen.add(n.path("evt").asText() + (n.has("code") ? ":" + n.path("code").asText() : "") + (n.has("m") ? ":" + n.path("m").asText() : ""));
+        }
+        throw new AssertionError("no '" + evt + "' event from the Node LA within " + seconds + " s; saw " + seen);
+    }
+
+    private static byte[] concat(List<LaV2Chunk> chunks) {
+        java.io.ByteArrayOutputStream o = new java.io.ByteArrayOutputStream();
+        chunks.forEach(c -> o.writeBytes(c.data()));
+        return o.toByteArray();
+    }
+}

package/tools/interop/README.md

@@ -19,3 +19,20 @@ a type with no handler -> rejected ack `protocol_unsupported`; 20 `job.event` in
 with the same session id and consecutive seq; content after the resume; zero frames refused by the gateway.
 It is skipped when `LA_REPO` is not set. It does not prove Cloud Run / the load balancer / TLS / Memorystore /
 two gateway instances.
+
+## F3-07: content handlers against the real `LaV2Session`
+
+`la-interop-content-client.mjs` is a Local Agent with the REAL content handlers (opaque ids, path guard, DLP `enforce`,
+git diff, chunking) on a temp workspace; `LaV2NodeContentInteropTest.java` drives it through `AgentWebSocketHandler.requestContent`.
+
+```bash
+cp tools/interop/LaV2NodeContentInteropTest.java <gateway>/src/test/java/io/visionhammer/gateway/cloud/infrastructure/byoc/
+LA_REPO=/path/to/deepdebug-local-agent mvn -o test -Dtest=LaV2NodeContentInteropTest   # JDK 21
+```
+
+It checks: a token masked in a served file; 1 MiB = 32 chunks byte for byte (sha256); a token straddling the 32 KiB
+boundary never appears, whole or in part; an id swapped for a link to a file outside the workspace -> `forbidden`;
+`../../etc/passwd`, `/etc/passwd`, a plain relative path and a made-up id -> `not_found`; binary -> `forbidden` in enforce;
+`report` -> `error` + `protocol_unsupported`; the diff of the work tree masked and without `.env`; the consumer cancels
+after the first chunk and the next request still works; zero frames refused by the gateway; nothing printed by the agent
+carries content or a path. Negative control: with the DLP step disabled in the agent the test fails.

package/tools/interop/la-interop-content-client.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// F3-07 interoperability client: the REAL Local Agent content handlers (src/la-protocol-v2/content-handlers, DLP, path
+// guard, opaque ids) around the real v2 link, against the real gateway LaV2Session (driven by LaV2NodeContentInteropTest).
+// Nothing is faked on the agent side except the workspace manager (one temp workspace). It prepares files, mints the
+// opaque ids the way a future inventory would (link.content.mintRef) and prints them, one JSON per line, for the test.
+//
+//   env: GW_URL TOKEN TENANT AGENT KEY_ID PUBLIC_KEY MODE(enforce) LOCAL_AGENT_DLP_MODE ... (LOCAL_AGENT_CONTENT_HANDLERS is forced on)
+//   stdin: "quit"
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { execFileSync } from "node:child_process";
+import WebSocket from "ws";
+import { buildV2Link } from "../../src/la-protocol-v2/runtime.js";
+import { resolveSigningConfig } from "../../src/utils/request-signing.js";
+
+const { GW_URL, TOKEN, TENANT, AGENT, KEY_ID, PUBLIC_KEY, MODE = "enforce" } = process.env;
+const out = (o) => process.stdout.write(JSON.stringify(o) + "\n");
+
+const base = fs.mkdtempSync(path.join(os.tmpdir(), "f307-interop-"));
+const ROOT = path.join(base, "ws");
+fs.mkdirSync(ROOT);
+const put = (rel, data) => { const p = path.join(ROOT, rel); fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, data); };
+const git = (...a) => execFileSync("git", ["-c", "user.email=t@t", "-c", "user.name=t", "-c", "commit.gpgsign=false", ...a], { cwd: ROOT, stdio: "ignore" });
+
+export const GH = "ghp_" + "A1b2C3d4E5f6G7h8I9j0K1l2M3n4O5p6Q7r8";
+// letters only: the DLP phone rule masks long digit runs, which would make 1 MiB grow past the limit
+const bigText = Buffer.from("alpha beta gamma delta epsilon zeta eta theta\n".repeat(30000)).subarray(0, 1024 * 1024);
+const straddle = "a".repeat(32766 - 20 - 1) + "\n" + `k=${GH}\n` + "z\n".repeat(60000);
+
+put("src/app.txt", `first line\ntoken = "${GH}"\nlast line\n`);
+put("big.txt", bigText);
+put("mid.txt", straddle);
+put("swapped.txt", "innocent");
+put("bin.png", Buffer.concat([Buffer.from([0x89, 0x50, 0x4e, 0x47, 0]), crypto.randomBytes(4000)]));
+put(".env", "API=SECRET-ENV-VALUE-123456\n");
+put("tracked.js", "const a = 1;\n");
+fs.writeFileSync(path.join(base, "outside-secret.txt"), "OUTSIDE-SECRET-CONTENT");
+git("init", "-q", "-b", "main"); git("add", "-f", "-A"); git("commit", "-q", "-m", "init");
+put("tracked.js", `const a = 2;\nconst t = "${GH}";\n`);
+
+const signing = resolveSigningConfig({
+    LOCAL_AGENT_SIGNATURE_MODE: MODE, LOCAL_AGENT_SIGNING_PUBLIC_KEYS: `${KEY_ID}=${PUBLIC_KEY}`, LOCAL_AGENT_TENANT_ID: TENANT,
+}, { defaultFile: null, fileCfg: {} });
+
+const env = { ...process.env, LOCAL_AGENT_CONTENT_HANDLERS: "true", LOCAL_AGENT_PROTOCOL_V2: "true" };
+const link = await buildV2Link({
+    tenantId: TENANT, agentId: AGENT, signing, getWorkspaceRoot: () => ROOT, env,
+    wsManager: { list: () => [{ id: "ws-1", root: ROOT, tenantId: TENANT }] },
+    log: { info: () => {}, log: () => {}, warn: (m) => out({ evt: "warn", m }) },
+});
+const session = link.session;
+session.on("ready", (i) => out({ evt: "ready", resumed: i.resumed, sessionId: i.sessionId }));
+session.on("refused", (c) => out({ evt: "refused", code: c }));
+session.on("peer-error", (c) => out({ evt: "peer-error", code: c }));
+
+const mint = (kind, rel) => link.content.mintRef({ workspaceId: "ws-1", kind, rel })?.id ?? null;
+const refs = {
+    app: mint("file", "src/app.txt"), big: mint("file", "big.txt"), mid: mint("file", "mid.txt"), swapped: mint("file", "swapped.txt"),
+    bin: mint("file", "bin.png"), envFile: mint("file", ".env"), diffFile: mint("diff", "tracked.js"),
+};
+// after the id was handed out the file becomes a link to a file OUTSIDE the workspace
+fs.rmSync(path.join(ROOT, "swapped.txt"));
+fs.symlinkSync(path.join(base, "outside-secret.txt"), path.join(ROOT, "swapped.txt"));
+out({ evt: "refs", refs, bigSha256: crypto.createHash("sha256").update(bigText).digest("hex"), bigBytes: bigText.length, ghp: GH });
+
+let ws;
+let quitting = false;
+function connect() {
+    ws = new WebSocket(GW_URL, { headers: { Authorization: `Bearer ${TOKEN}` } });
+    const mine = ws;
+    ws.on("open", () => {
+        const legacy = () => { out({ evt: "legacy-register" }); mine.send(JSON.stringify({ type: "register", tenantId: TENANT, port: 5055, workspacePath: null })); };
+        if (!link.begin(mine, legacy)) legacy();
+        const hb = setInterval(() => { if (mine.readyState === 1) mine.send("ping"); else clearInterval(hb); }, 5000);
+    });
+    ws.on("message", (data, isBinary) => {
+        const text = data.toString();
+        if (text === "pong") return;
+        if (link.handleMessage(mine, text, isBinary)) return;
+        out({ evt: "v1-message" });
+    });
+    ws.on("close", (code) => { out({ evt: "closed", code }); link.onClose(mine); if (!quitting) setTimeout(connect, 100); });
+    ws.on("error", () => {});
+}
+connect();
+
+const done = () => { quitting = true; try { ws.terminate(); } catch { /* gone */ } link.close(); fs.rmSync(base, { recursive: true, force: true }); process.exit(0); };
+readline.createInterface({ input: process.stdin }).on("line", (l) => { if (l.trim() === "quit") done(); }).on("close", done);