源码快照 @ 2026-09-02 (source-only, 剔除非源码素材)

This commit is contained in:
agent-radar committed 2026-09-02 01:05:41 +08:00
commit 04bac1f6e2
2200 files changed
+489415

No files matched your search

@@ -0,0 +1,128 @@
import assert from "node:assert/strict";
import { createServer } from "node:http";
import test from "node:test";
import { deleteConnection, deleteConnectionsNamed, type DenSession } from "../src/den.ts";
function respondJson(response: import("node:http").ServerResponse, status: number, body: unknown): void {
response.writeHead(status, { "content-type": "application/json" });
response.end(JSON.stringify(body));
}
test("deleteConnection refreshes a stale session once before retrying teardown", async () => {
const requests: { path: string; authorization: string; body: string }[] = [];
const server = createServer((request, response) => {
const chunks: Buffer[] = [];
request.on("data", (chunk: Buffer) => chunks.push(chunk));
request.on("end", () => {
const path = new URL(request.url ?? "/", "http://stub.test").pathname;
const authorization = request.headers.authorization ?? "";
const body = Buffer.concat(chunks).toString("utf8");
requests.push({ path, authorization, body });
if (request.method === "DELETE" && path === "/v1/mcp-connections/connection-1" && authorization === "Bearer stale-token") {
respondJson(response, 403, { error: "reauth", reason: "fresh_auth_required" });
return;
}
if (request.method === "POST" && path === "/api/auth/sign-in/email") {
respondJson(response, 200, { token: "fresh-token" });
return;
}
if (request.method === "DELETE" && path === "/v1/mcp-connections/connection-1" && authorization === "Bearer fresh-token") {
respondJson(response, 204, null);
return;
}
respondJson(response, 500, { error: "unexpected_request" });
});
});
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
try {
const address = server.address();
assert.ok(address && typeof address === "object");
const session: DenSession = {
apiUrl: `http://127.0.0.1:${address.port}`,
webUrl: "http://localhost",
token: "stale-token",
email: "admin@example.com",
password: "same-password",
};
await deleteConnection(session, "connection-1");
assert.deepEqual(requests.map(({ path, authorization }) => ({ path, authorization })), [
{ path: "/v1/mcp-connections/connection-1", authorization: "Bearer stale-token" },
{ path: "/api/auth/sign-in/email", authorization: "" },
{ path: "/v1/mcp-connections/connection-1", authorization: "Bearer fresh-token" },
]);
assert.deepEqual(JSON.parse(requests[1]?.body ?? ""), {
email: "admin@example.com",
password: "same-password",
});
} finally {
await new Promise<void>((resolve, reject) => {
server.close((error) => error ? reject(error) : resolve());
});
}
});
test("deleteConnectionsNamed refreshes a stale list session once", async () => {
const requests: string[] = [];
const server = createServer((request, response) => {
const path = new URL(request.url ?? "/", "http://stub.test").pathname;
const authorization = request.headers.authorization ?? "";
requests.push(`${request.method} ${path} ${authorization}`.trim());
if (request.method === "GET" && path === "/v1/mcp-connections" && authorization === "Bearer stale-token") {
respondJson(response, 403, { error: "reauth", reason: "fresh_auth_required" });
return;
}
if (request.method === "POST" && path === "/api/auth/sign-in/email") {
respondJson(response, 200, { token: "fresh-token" });
return;
}
if (request.method === "GET" && path === "/v1/mcp-connections" && authorization === "Bearer fresh-token") {
respondJson(response, 200, {
connections: [
{ id: "delete-me", name: "eval-cleanup-one" },
{ id: "keep-me", name: "other-connection" },
],
});
return;
}
if (request.method === "DELETE" && path === "/v1/mcp-connections/delete-me" && authorization === "Bearer fresh-token") {
response.writeHead(204);
response.end();
return;
}
respondJson(response, 500, { error: "unexpected_request" });
});
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
try {
const address = server.address();
assert.ok(address && typeof address === "object");
await deleteConnectionsNamed({
apiUrl: `http://127.0.0.1:${address.port}`,
webUrl: "http://localhost",
token: "stale-token",
email: "admin@example.com",
password: "same-password",
}, "eval-cleanup-");
assert.deepEqual(requests, [
"GET /v1/mcp-connections Bearer stale-token",
"POST /api/auth/sign-in/email",
"GET /v1/mcp-connections Bearer fresh-token",
"DELETE /v1/mcp-connections/delete-me Bearer fresh-token",
]);
} finally {
await new Promise<void>((resolve, reject) => {
server.close((error) => error ? reject(error) : resolve());
});
}
});
@@ -0,0 +1,71 @@
import assert from "node:assert/strict";
import test from "node:test";
import { waitFor } from "../src/desktop.ts";
import type { CdpClient, Surface } from "@openwork/cdp";
function fakeSurface(valueForExpression: (expression: string) => unknown): Surface {
const client: CdpClient = {
async send(method, params = {}) {
assert.equal(method, "Runtime.evaluate");
const expression = typeof params.expression === "string" ? params.expression : "";
return { result: { value: valueForExpression(expression) } };
},
close() {},
};
return {
handle: {
name: "fake",
kind: "electron",
hostKind: "test",
cdpUrl: "http://127.0.0.1:1",
},
client,
};
}
function isScreenDump(expression: string): boolean {
return expression.includes("document.title") && expression.includes("querySelectorAll(\"button\")");
}
test("waitFor has a finite default timeout", async (context) => {
context.mock.timers.enable({ apis: ["Date"], now: 0 });
const surface = fakeSurface((expression) => {
if (isScreenDump(expression)) {
return { hash: "#/still-here", route: "/still-here", title: "Waiting", buttons: [], body: "Not ready" };
}
context.mock.timers.setTime(30_001);
return false;
});
await assert.rejects(waitFor(surface, "false"), /Timed out after 30000ms waiting for false/);
});
test("waitFor appends a bounded on-screen dump to timeout failures", async () => {
const surface = fakeSurface((expression) => isScreenDump(expression)
? {
hash: "#/workspace/demo/extensions",
route: "/workspace/demo/extensions",
title: "OpenWork",
buttons: ["Back", "Add extension"],
body: "Extensions Add an extension to this workspace",
}
: false);
await assert.rejects(
waitFor(surface, "false", { timeoutMs: 1, label: "extensions route" }),
/On screen: \{"hash":"#\/workspace\/demo\/extensions","route":"\/workspace\/demo\/extensions","title":"OpenWork","buttons":\["Back","Add extension"\],"body":"Extensions Add an extension to this workspace"\}/,
);
});
test("waitFor still reports timeout context when the on-screen dump fails", async () => {
const surface = fakeSurface((expression) => {
if (isScreenDump(expression)) throw new Error("renderer unavailable");
return false;
});
await assert.rejects(
waitFor(surface, "false", { timeoutMs: 1, label: "extensions route" }),
/Timed out after 1ms waiting for extensions route.*On screen: unavailable/,
);
});
@@ -0,0 +1,82 @@
import assert from "node:assert/strict";
import { createServer } from "node:http";
import test from "node:test";
import { ensureMemberSession, type DenSession } from "../src/den.ts";
function respondJson(response: import("node:http").ServerResponse, status: number, body: unknown): void {
response.writeHead(status, { "content-type": "application/json" });
response.end(JSON.stringify(body));
}
async function withStubServer(
allowPublicSignup: boolean,
run: (den: { apiUrl: string; webUrl: string }, requests: string[]) => Promise<void>,
): Promise<void> {
const requests: string[] = [];
const server = createServer((request, response) => {
const url = new URL(request.url ?? "/", "http://stub.test");
requests.push(`${request.method} ${url.pathname}`);
if (request.method === "POST" && url.pathname === "/api/auth/sign-in/email") {
respondJson(response, 401, { error: "invalid_credentials" });
return;
}
if (request.method === "GET" && url.pathname === "/v1/auth/login-options") {
respondJson(response, 200, {
email: url.searchParams.get("email"),
nextStep: allowPublicSignup ? "new_account" : "password",
allowPublicSignup,
});
return;
}
if (request.method === "POST" && url.pathname === "/v1/invitations") {
respondJson(response, 200, { inviteToken: "invite-token" });
return;
}
respondJson(response, 409, { error: "stop_after_invitation" });
});
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
try {
const address = server.address();
assert.ok(address && typeof address === "object");
await run({ apiUrl: `http://127.0.0.1:${address.port}`, webUrl: "http://localhost" }, requests);
} finally {
await new Promise<void>((resolve, reject) => {
server.close((error) => error ? reject(error) : resolve());
});
}
}
const credentials = { email: "member@example.com", password: "password123" };
function adminSession(den: { apiUrl: string; webUrl: string }): DenSession {
return { ...den, token: "admin-token", email: "admin@example.com", password: "admin-password" };
}
test("ensureMemberSession explains how to enable member bootstrap when signup is disabled", async () => {
await withStubServer(false, async (den, requests) => {
await assert.rejects(
ensureMemberSession(den, adminSession(den), credentials),
/Member bootstrap needs public signup.*DEN_ORG_MODE=multi_org.*DEN_SINGLE_ORG_ALLOW_PUBLIC_SIGNUP=true.*member@example\.com/,
);
assert.deepEqual(requests, ["POST /api/auth/sign-in/email", "GET /v1/auth/login-options"]);
});
});
test("ensureMemberSession proceeds to invitation when signup is allowed", async () => {
await withStubServer(true, async (den, requests) => {
await assert.rejects(
ensureMemberSession(den, adminSession(den), credentials),
/Member sign-up failed: HTTP 409/,
);
assert.deepEqual(requests, [
"POST /api/auth/sign-in/email",
"GET /v1/auth/login-options",
"POST /v1/invitations",
"POST /api/auth/sign-up/email",
]);
});
});
@@ -0,0 +1,32 @@
import assert from "node:assert/strict";
import test from "node:test";
import { startEgressLab } from "@openwork/labs";
import { diagnoseTls } from "@openwork/matchers";
import { probeTls } from "../src/diagnostics.ts";
test("probeTls and diagnoseTls identify a TLS 1.3-only stall without the eval framework", async () => {
await using lab = await startEgressLab({ profile: "tls12-only" });
const url = new URL(lab.url);
const facts = await probeTls({
// The lab listens on IPv4. Keep certificate verification on the generated
// localhost identity without depending on the runner's localhost family
// preference.
host: "127.0.0.1",
port: Number(url.port),
servername: url.hostname,
// Chain verification is back on: the lab root is now generated with an
// explicit basicConstraints extension, so it is a real CA on every openssl
// build (1.1.1 silently emitted CA:FALSE before).
ca: lab.rootPem,
});
const message = JSON.stringify(facts);
assert.equal(facts.tls12.handshakeOk, true, message);
assert.equal(facts.tls12.stalled, false, message);
assert.equal(facts.tls12.chainVerified, true, message);
assert.equal(facts.tls12.protocol, "TLSv1.2", message);
assert.equal(facts.tls13.stalled, true, message);
assert.equal(facts.tls13.errorCode, "ETIMEDOUT", message);
assert.equal(diagnoseTls(facts).code, "tls_handshake_stall_tls13_only", message);
// Lab-PKI chain trust is covered by the pure matcher tests (the tls_chain_untrusted branch) and the product-diagnostics spec; it is deliberately not asserted here because it varies with the runner's OpenSSL.
});
@@ -0,0 +1,37 @@
import assert from "node:assert/strict";
import test from "node:test";
import { parseSessionToolCalls } from "../src/desktop.ts";
test("parses namespaced and catalog tool calls from a session transcript", () => {
// Mirrors session.read_transcript's messages shape and messageToReadableText's
// dynamic-tool rendering in apps/app/src/.../session-surface.tsx:1853-1878,355-376.
const calls = parseSessionToolCalls({
sessionId: "ses_1",
messageCount: 1,
returned: 1,
messages: [{
index: 0,
role: "assistant",
text: [
"OpenWork",
"[tool:mcp:emc_labs:send_email] sent",
"[tool:native:emc_robotics:postCapabilitiesGoogleWorkspaceGmailDrafts] drafted",
"[tool:openwork-cloud_execute_capability] searched",
].join("\n\n"),
}],
});
assert.deepEqual(calls, [
{ capability: "mcp:emc_labs:send_email", connectionId: "emc_labs", at: "" },
{
capability: "native:emc_robotics:postCapabilitiesGoogleWorkspaceGmailDrafts",
connectionId: "emc_robotics",
at: "",
},
{ capability: "openwork-cloud_execute_capability", connectionId: null, at: "" },
]);
});
test("returns no tool calls for an empty transcript", () => {
assert.deepEqual(parseSessionToolCalls({ sessionId: "ses_1", messageCount: 0, returned: 0, messages: [] }), []);
});