deepdebug-local-agent 1.3.0 → 1.5.0

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);