Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
import * as NodeSocket from "@effect/platform-node/NodeSocket";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { AuthAccessTokenType, WS_METHODS } from "@akeru/contracts";
import { assert, it } from "@effect/vitest";
import { assertInclude } from "@effect/vitest/utils";
import * as Effect from "effect/Effect";
import { HttpBody, HttpClient } from "effect/unstable/http";
import { buildAppUnderTest } from "./serverTestApp.ts";
import {
getHttpServerUrl,
fetchEffect,
responseJsonEffect,
crossOriginClientOrigin,
assertBrowserApiCorsResponseHeaders,
bootstrapBrowserSession,
extractSessionTokenFromSetCookie,
exchangeAccessToken,
getAuthenticatedSessionCookieHeader,
parseSessionCookieFromWsUrl,
getWsServerUrl,
NodeHttpServerTestWithWsDeflate,
getAuthenticatedBearerSessionToken,
withWsRpcClient,
appendSessionCookieToWsUrl,
} from "./serverTestClients.ts";
import { testEnvironmentDescriptor, defaultDesktopBootstrapToken } from "./serverTestFixtures.ts";
it.layer(NodeServices.layer)("server router seam", (it) => {
it.effect("serves the public environment descriptor without requiring auth", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const url = yield* getHttpServerUrl("/.well-known/t3/environment");
const response = yield* fetchEffect(url);
const body = yield* responseJsonEffect<typeof testEnvironmentDescriptor>(response);
assert.equal(response.status, 200);
assert.deepEqual(body, testEnvironmentDescriptor);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("compresses large JSON responses through the composed routes", () =>
Effect.gen(function* () {
const descriptor = {
...testEnvironmentDescriptor,
label: "Test environment".repeat(100),
};
yield* buildAppUnderTest({
layers: {
serverEnvironment: {
getDescriptor: Effect.succeed(descriptor),
},
},
});
const url = yield* getHttpServerUrl("/.well-known/t3/environment");
const response = yield* fetchEffect(url, {
headers: {
"accept-encoding": "gzip",
},
});
const body = yield* responseJsonEffect<typeof descriptor>(response);
assert.equal(response.status, 200);
assert.equal(response.headers["content-encoding"], "gzip");
assert.equal(response.headers.vary, "Accept-Encoding");
assert.deepEqual(body, descriptor);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("includes CORS headers on public environment descriptor responses", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const url = yield* getHttpServerUrl("/.well-known/t3/environment");
const response = yield* fetchEffect(url, {
headers: {
origin: crossOriginClientOrigin,
},
});
const body = yield* responseJsonEffect<typeof testEnvironmentDescriptor>(response);
assert.equal(response.status, 200);
assertBrowserApiCorsResponseHeaders(response.headers);
assert.deepEqual(body, testEnvironmentDescriptor);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("reports unauthenticated session state without requiring auth", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const url = yield* getHttpServerUrl("/api/auth/session");
const response = yield* fetchEffect(url);
const body = yield* responseJsonEffect<{
readonly authenticated: boolean;
readonly auth: {
readonly policy: string;
readonly bootstrapMethods: ReadonlyArray<string>;
readonly sessionMethods: ReadonlyArray<string>;
readonly sessionCookieName: string;
};
}>(response);
assert.equal(response.status, 200);
assert.equal(body.authenticated, false);
assert.equal(body.auth.policy, "desktop-managed-local");
assert.deepEqual(body.auth.bootstrapMethods, ["desktop-bootstrap"]);
assert.deepEqual(body.auth.sessionMethods, ["browser-session-cookie", "bearer-access-token"]);
// Desktop, so port-scoped: instances scan for a free port and share
// 127.0.0.1, and cookies are not scoped by port.
assert.isTrue(body.auth.sessionCookieName.startsWith("t3_session_"));
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("bootstraps a browser session and authenticates the session endpoint via cookie", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const {
response: bootstrapResponse,
body: bootstrapBody,
cookie: setCookie,
} = yield* bootstrapBrowserSession();
assert.equal(bootstrapResponse.status, 200);
assert.equal(bootstrapBody.authenticated, true);
assert.equal(bootstrapBody.sessionMethod, "browser-session-cookie");
assert.isUndefined((bootstrapBody as { readonly sessionToken?: string }).sessionToken);
assert.isDefined(setCookie);
const sessionUrl = yield* getHttpServerUrl("/api/auth/session");
const sessionResponse = yield* fetchEffect(sessionUrl, {
headers: {
cookie: setCookie?.split(";")[0] ?? "",
},
});
const sessionBody = yield* responseJsonEffect<{
readonly authenticated: boolean;
readonly sessionMethod?: string;
}>(sessionResponse);
assert.equal(sessionResponse.status, 200);
assert.equal(sessionBody.authenticated, true);
assert.equal(sessionBody.sessionMethod, "browser-session-cookie");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("migrates a valid legacy remote-web session cookie", () =>
Effect.gen(function* () {
yield* buildAppUnderTest({ config: { mode: "web", host: "192.168.1.50" } });
const { cookie } = yield* bootstrapBrowserSession();
const currentCookie = cookie?.split(";")[0] ?? "";
const legacyCookie = currentCookie.replace(/^t3_session_[^=]+=/, "t3_session=");
const sessionUrl = yield* getHttpServerUrl("/api/auth/session");
const response = yield* fetchEffect(sessionUrl, {
headers: { cookie: legacyCookie },
});
const body = yield* responseJsonEffect<{ readonly authenticated: boolean }>(response);
assert.equal(body.authenticated, true);
assert.equal(response.headers["set-cookie"], cookie);
assert.equal(response.headers["cache-control"], "no-store");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect.each(["cookie", "bearer"])(
"does not migrate a stale legacy cookie when %s auth succeeds",
(source) =>
Effect.gen(function* () {
yield* buildAppUnderTest({ config: { mode: "web", host: "192.168.1.50" } });
const { cookie } = yield* bootstrapBrowserSession();
const sessionCookie = cookie?.split(";")[0] ?? "";
const sessionToken = extractSessionTokenFromSetCookie(cookie ?? "");
const sessionUrl = yield* getHttpServerUrl("/api/auth/session");
const response = yield* fetchEffect(sessionUrl, {
headers:
source === "cookie"
? { cookie: `${sessionCookie}; t3_session=stale` }
: { authorization: `Bearer ${sessionToken}`, cookie: "t3_session=stale" },
});
const body = yield* responseJsonEffect<{ readonly authenticated: boolean }>(response);
assert.equal(body.authenticated, true);
assert.isUndefined(response.headers["set-cookie"]);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("exchanges a bootstrap grant for a scoped bearer access token", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const { response: tokenResponse, body: tokenBody } = yield* exchangeAccessToken();
assert.equal(tokenResponse.status, 200);
assert.equal(tokenBody.issued_token_type, AuthAccessTokenType);
assert.equal(tokenBody.token_type, "Bearer");
assert.equal(
tokenBody.scope,
"orchestration:read orchestration:operate access:read access:write",
);
assert.equal(Predicate.isString(tokenBody.access_token), true);
const sessionUrl = yield* getHttpServerUrl("/api/auth/session");
const sessionResponse = yield* fetchEffect(sessionUrl, {
headers: {
authorization: `Bearer ${tokenBody.access_token ?? ""}`,
},
});
const sessionBody = yield* responseJsonEffect<{
readonly authenticated: boolean;
readonly sessionMethod?: string;
readonly scopes?: ReadonlyArray<string>;
}>(sessionResponse);
assert.equal(sessionResponse.status, 200);
assert.equal(sessionBody.authenticated, true);
assert.equal(sessionBody.sessionMethod, "bearer-access-token");
assert.deepEqual(sessionBody.scopes, [
"orchestration:read",
"orchestration:operate",
"access:read",
"access:write",
]);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("persists token exchange client display metadata for authorized-client listings", () =>
Effect.gen(function* () {
yield* buildAppUnderTest({
config: {
host: "0.0.0.0",
},
});
const ownerCookie = yield* getAuthenticatedSessionCookieHeader();
const pairingResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: ownerCookie,
},
body: yield* HttpBody.json({}),
});
const pairingBody = (yield* pairingResponse.json) as {
readonly credential: string;
};
const { response } = yield* exchangeAccessToken(pairingBody.credential, {
headers: {
"user-agent": "undici",
},
scope: "orchestration:read orchestration:operate",
clientMetadata: {
label: "T3 Code Mobile",
deviceType: "mobile",
os: "iOS",
},
});
const clientsResponse = yield* HttpClient.get("/api/auth/clients", {
headers: {
cookie: ownerCookie,
},
});
const clients = (yield* clientsResponse.json) as ReadonlyArray<{
readonly current: boolean;
readonly client: {
readonly label?: string;
readonly deviceType: string;
readonly ipAddress?: string;
readonly os?: string;
readonly userAgent?: string;
};
}>;
const mobileClient = clients.find((client) => !client.current);
assert.equal(pairingResponse.status, 200);
assert.equal(response.status, 200);
assert.equal(clientsResponse.status, 200);
assert.deepInclude(mobileClient?.client, {
label: "T3 Code Mobile",
deviceType: "mobile",
os: "iOS",
ipAddress: "127.0.0.1",
userAgent: "undici",
});
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect(
"accepts the retired review:write and terminal:operate scopes from older clients and drops them",
() =>
Effect.gen(function* () {
yield* buildAppUnderTest({
config: {
host: "0.0.0.0",
},
});
const ownerCookie = yield* getAuthenticatedSessionCookieHeader();
const pairingResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: ownerCookie,
},
body: yield* HttpBody.json({}),
});
const pairingBody = (yield* pairingResponse.json) as {
readonly credential: string;
};
const { response, body } = yield* exchangeAccessToken(pairingBody.credential, {
scope: "orchestration:read orchestration:operate terminal:operate review:write",
});
assert.equal(response.status, 200);
assert.equal(body.scope, "orchestration:read orchestration:operate");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("negotiates permessage-deflate with clients that offer it", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const { cookie, url } = parseSessionCookieFromWsUrl(yield* getWsServerUrl("/ws"));
const openSocket = (perMessageDeflate: boolean) =>
Effect.acquireRelease(
Effect.callback<NodeSocket.NodeWS.WebSocket, Error>((resume) => {
const socket = new NodeSocket.NodeWS.WebSocket(url, {
perMessageDeflate,
...(cookie ? { headers: { cookie } } : {}),
});
socket.on("open", () => resume(Effect.succeed(socket)));
socket.on("error", (error) => resume(Effect.fail(error)));
}),
(socket) => Effect.sync(() => socket.close()),
);
const compressed = yield* openSocket(true);
// The ws client records the negotiated extension only when the server's
// 101 response accepted the offer.
assert.include(compressed.extensions, "permessage-deflate");
const plain = yield* openSocket(false);
assert.notInclude(plain.extensions, "permessage-deflate");
}).pipe(Effect.scoped, Effect.provide(NodeHttpServerTestWithWsDeflate)),
);
it.effect("issues short-lived websocket tickets for authenticated bearer sessions", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const bearerToken = yield* getAuthenticatedBearerSessionToken();
const wsTicketUrl = yield* getHttpServerUrl("/api/auth/websocket-ticket");
const wsTicketResponse = yield* fetchEffect(wsTicketUrl, {
method: "POST",
headers: {
authorization: `Bearer ${bearerToken}`,
},
});
const wsTicketBody = yield* responseJsonEffect<{
readonly ticket: string;
readonly expiresAt: string;
}>(wsTicketResponse);
assert.equal(wsTicketResponse.status, 200);
assert.equal(Predicate.isString(wsTicketBody.ticket), true);
assert.isTrue(wsTicketBody.ticket.length > 0);
assert.equal(Predicate.isString(wsTicketBody.expiresAt), true);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("serves the remote doctor only to administrative clients", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const { body: tokenBody } = yield* exchangeAccessToken(defaultDesktopBootstrapToken, {
scope: "orchestration:read orchestration:operate terminal:operate review:write",
});
const ticketResponse = yield* HttpClient.post("/api/auth/websocket-ticket", {
headers: { authorization: `Bearer ${tokenBody.access_token ?? ""}` },
});
const ticketBody = (yield* ticketResponse.json) as { readonly ticket: string };
const standardWsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?wsTicket=${encodeURIComponent(ticketBody.ticket)}`;
const deniedRead = yield* Effect.flip(
Effect.scoped(
withWsRpcClient(standardWsUrl, (client) => client[WS_METHODS.serverGetRemoteDoctor]({})),
),
);
assert.equal(deniedRead._tag, "EnvironmentAuthorizationError");
if (Predicate.isTagged(deniedRead, "EnvironmentAuthorizationError")) {
assert.equal(deniedRead.requiredScope, "access:read");
}
const deniedRepair = yield* Effect.flip(
Effect.scoped(
withWsRpcClient(standardWsUrl, (client) =>
client[WS_METHODS.serverRepairRemoteDoctor]({ checkIds: ["logs"] }),
),
),
);
assert.equal(deniedRepair._tag, "EnvironmentAuthorizationError");
// The test server is not a remote install, so an admin sees an honest "not applicable".
const adminStatus = yield* Effect.scoped(
withWsRpcClient(yield* getWsServerUrl("/ws"), (client) =>
client[WS_METHODS.serverGetRemoteDoctor]({}),
),
);
assert.deepEqual(adminStatus, { applicable: false, report: null });
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("allows reusing the desktop bootstrap credential", () =>
Effect.gen(function* () {
// The desktop-bootstrap grant is delivered over trusted IPC at
// backend launch and needs to stay claimable after a renderer
// refresh, so it's intentionally reusable (unlike user-facing
// one-time pairing credentials).
yield* buildAppUnderTest();
const first = yield* bootstrapBrowserSession();
const second = yield* bootstrapBrowserSession();
assert.equal(first.response.status, 200);
assert.equal(second.response.status, 200);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("accepts websocket rpc handshake with a bootstrapped browser session cookie", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const { response: bootstrapResponse, cookie } = yield* bootstrapBrowserSession();
assert.equal(bootstrapResponse.status, 200);
assert.isDefined(cookie);
const wsUrl = appendSessionCookieToWsUrl(
yield* getWsServerUrl("/ws", { authenticated: false }),
cookie?.split(";")[0] ?? "",
);
const response = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverGetConfig]({})),
);
assert.equal(response.environment.environmentId, testEnvironmentDescriptor.environmentId);
assert.equal(response.auth.policy, "desktop-managed-local");
assert.equal(response.shellResumeCompletionMarker, true);
assert.isUndefined(response.shellRevealInFileManager);
assert.isUndefined(response.shellRevealInFileManagerKind);
assert.equal(response.threadResumeCompletionMarker, true);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("advertises the usable file manager and its reveal label", () =>
Effect.gen(function* () {
yield* buildAppUnderTest({
layers: {
externalLauncher: {
resolveAvailableEditors: () => Effect.succeed(["file-manager"]),
resolveFileManagerRevealKind: () => Effect.succeed("file-explorer"),
},
},
});
const { cookie } = yield* bootstrapBrowserSession();
const wsUrl = appendSessionCookieToWsUrl(
yield* getWsServerUrl("/ws", { authenticated: false }),
cookie?.split(";")[0] ?? "",
);
const response = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverGetConfig]({})),
);
assert.deepEqual(response.availableEditors, ["file-manager"]);
assert.equal(response.shellRevealInFileManager, true);
assert.equal(response.shellRevealInFileManagerKind, "file-explorer");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect(
"rejects websocket rpc handshake when a session token is only provided via query string",
() =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const { cookie } = yield* bootstrapBrowserSession();
assert.isDefined(cookie);
const sessionToken = extractSessionTokenFromSetCookie(cookie ?? "");
const wsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?token=${encodeURIComponent(sessionToken)}`;
const error = yield* Effect.flip(
Effect.scoped(withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverGetConfig]({}))),
);
assert.equal(error._tag, "RpcClientError");
assertInclude(String(error), "SocketOpenError");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect(
"accepts websocket rpc handshake with a dedicated websocket ticket in the query string",
() =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const bearerToken = yield* getAuthenticatedBearerSessionToken();
const wsTicketUrl = yield* getHttpServerUrl("/api/auth/websocket-ticket");
const wsTicketResponse = yield* fetchEffect(wsTicketUrl, {
method: "POST",
headers: {
authorization: `Bearer ${bearerToken}`,
},
});
const wsTicketBody = yield* responseJsonEffect<{
readonly ticket: string;
}>(wsTicketResponse);
const wsUrl = `${yield* getWsServerUrl("/ws", { authenticated: false })}?wsTicket=${encodeURIComponent(wsTicketBody.ticket)}`;
const response = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverGetConfig]({})),
);
assert.equal(response.environment.environmentId, testEnvironmentDescriptor.environmentId);
assert.equal(response.auth.policy, "desktop-managed-local");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
});