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 NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import { HttpBody, HttpClient } from "effect/unstable/http";
import { buildAppUnderTest } from "./serverTestApp.ts";
import {
getAuthenticatedSessionCookieHeader,
bootstrapBrowserSession,
getAuthenticatedBearerSessionToken,
jsonRequestBody,
getHttpServerUrl,
fetchEffect,
responseJsonEffect,
} from "./serverTestClients.ts";
it.layer(NodeServices.layer)("server router seam", (it) => {
it.effect("issues authenticated one-time pairing credentials for additional clients", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const response = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: yield* getAuthenticatedSessionCookieHeader(),
},
body: yield* HttpBody.json({}),
});
const body = (yield* response.json) as {
readonly credential: string;
readonly expiresAt: string;
};
assert.equal(response.status, 200);
assert.equal(Predicate.isString(body.credential), true);
assert.isTrue(body.credential.length > 0);
assert.equal(Predicate.isString(body.expiresAt), true);
const bootstrapResult = yield* bootstrapBrowserSession(body.credential);
assert.equal(bootstrapResult.response.status, 200);
const reusedResult = yield* bootstrapBrowserSession(body.credential);
assert.equal(reusedResult.response.status, 401);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("issues pairing credentials for bearer sessions with access management scope", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const bearerToken = yield* getAuthenticatedBearerSessionToken();
const response = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
authorization: `Bearer ${bearerToken}`,
},
body: yield* HttpBody.json({ label: "Hosted web" }),
});
const body = (yield* response.json) as {
readonly credential: string;
readonly label?: string;
};
assert.equal(response.status, 200);
assert.isTrue(body.credential.length > 0);
assert.equal(body.label, "Hosted web");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("rejects pairing credentials with an empty scope grant", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const response = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: yield* getAuthenticatedSessionCookieHeader(),
},
body: yield* HttpBody.json({ scopes: [] }),
});
const body = (yield* response.json) as {
readonly code: string;
readonly reason: string;
};
assert.equal(response.status, 400);
assert.equal(body.code, "invalid_request");
assert.equal(body.reason, "invalid_scope");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("rejects unauthenticated pairing credential requests", () =>
Effect.gen(function* () {
yield* buildAppUnderTest();
const response = yield* HttpClient.post("/api/auth/pairing-token", {
body: yield* HttpBody.json({}),
});
assert.equal(response.status, 401);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("lists and revokes pairing links for access management sessions", () =>
Effect.gen(function* () {
yield* buildAppUnderTest({
config: {
host: "0.0.0.0",
},
});
const ownerCookie = yield* getAuthenticatedSessionCookieHeader();
const createdResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: ownerCookie,
},
body: yield* HttpBody.json({}),
});
const createdBody = (yield* createdResponse.json) as {
readonly id: string;
readonly credential: string;
};
const listResponse = yield* HttpClient.get("/api/auth/pairing-links", {
headers: {
cookie: ownerCookie,
},
});
const listedLinks = (yield* listResponse.json) as ReadonlyArray<{
readonly id: string;
readonly credential: string;
}>;
const revokeResponse = yield* HttpClient.post("/api/auth/pairing-links/revoke", {
headers: {
cookie: ownerCookie,
"content-type": "application/json",
},
body: HttpBody.text(jsonRequestBody({ id: createdBody.id }), "application/json"),
});
const revokedBootstrap = yield* bootstrapBrowserSession(createdBody.credential);
assert.equal(createdResponse.status, 200);
assert.equal(listResponse.status, 200);
assert.isTrue(listedLinks.some((entry) => entry.id === createdBody.id));
assert.equal(revokeResponse.status, 200);
assert.equal(revokedBootstrap.response.status, 401);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("rejects pairing credential requests without access management scope", () =>
Effect.gen(function* () {
yield* buildAppUnderTest({
config: {
host: "0.0.0.0",
},
});
const ownerResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: yield* getAuthenticatedSessionCookieHeader(),
},
body: yield* HttpBody.json({}),
});
const ownerBody = (yield* ownerResponse.json) as {
readonly credential: string;
};
assert.equal(ownerResponse.status, 200);
const pairedSessionCookie = yield* getAuthenticatedSessionCookieHeader(ownerBody.credential);
const pairedResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: pairedSessionCookie,
},
body: yield* HttpBody.json({}),
});
const pairedBody = (yield* pairedResponse.json) as {
readonly _tag: string;
readonly code: string;
readonly requiredScope: string;
readonly traceId: string;
};
assert.equal(pairedResponse.status, 403);
assert.equal(pairedBody._tag, "EnvironmentScopeRequiredError");
assert.equal(pairedBody.code, "insufficient_scope");
assert.equal(pairedBody.requiredScope, "access:write");
assert.equal(Predicate.isString(pairedBody.traceId), true);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("lists paired clients and revokes other sessions while keeping the administrator", () =>
Effect.gen(function* () {
yield* buildAppUnderTest({
config: {
host: "0.0.0.0",
},
});
const ownerCookie = yield* getAuthenticatedSessionCookieHeader();
const pairingTokenUrl = yield* getHttpServerUrl("/api/auth/pairing-token");
const ownerPairingResponse = yield* fetchEffect(pairingTokenUrl, {
method: "POST",
headers: {
cookie: ownerCookie,
"content-type": "application/json",
},
body: jsonRequestBody({
label: "Julius iPhone",
}),
});
const ownerPairingBody = yield* responseJsonEffect<{
readonly credential: string;
readonly label?: string;
}>(ownerPairingResponse);
assert.equal(ownerPairingResponse.status, 200);
const pairedSessionBootstrap = yield* bootstrapBrowserSession(ownerPairingBody.credential, {
headers: {
"user-agent":
"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Mobile/15E148 Safari/604.1",
},
});
const pairedSessionCookie = pairedSessionBootstrap.cookie?.split(";")[0];
assert.isDefined(pairedSessionCookie);
const pairedSessionCookieHeader = pairedSessionCookie ?? "";
const listBeforeResponse = yield* HttpClient.get("/api/auth/clients", {
headers: {
cookie: ownerCookie,
},
});
const clientsBefore = (yield* listBeforeResponse.json) as ReadonlyArray<{
readonly sessionId: string;
readonly current: boolean;
readonly client: {
readonly label?: string;
readonly deviceType: string;
readonly ipAddress?: string;
readonly os?: string;
readonly browser?: string;
};
}>;
const pairedClientBefore = clientsBefore.find((entry) => !entry.current);
const pairedSessionId = clientsBefore.find((entry) => !entry.current)?.sessionId;
const revokeOthersResponse = yield* HttpClient.post("/api/auth/clients/revoke-others", {
headers: {
cookie: ownerCookie,
},
});
const revokeOthersBody = (yield* revokeOthersResponse.json) as {
readonly revokedCount: number;
};
const listAfterResponse = yield* HttpClient.get("/api/auth/clients", {
headers: {
cookie: ownerCookie,
},
});
const clientsAfter = (yield* listAfterResponse.json) as ReadonlyArray<{
readonly sessionId: string;
readonly current: boolean;
}>;
const pairedClientPairingResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: pairedSessionCookieHeader,
},
body: yield* HttpBody.json({}),
});
const pairedClientPairingBody = (yield* pairedClientPairingResponse.json) as {
readonly _tag: string;
readonly code: string;
readonly reason: string;
readonly traceId: string;
};
assert.equal(listBeforeResponse.status, 200);
assert.equal(ownerPairingBody.label, "Julius iPhone");
assert.lengthOf(clientsBefore, 2);
assert.isDefined(pairedSessionId);
assert.isDefined(pairedClientBefore);
assert.deepInclude(pairedClientBefore?.client, {
label: "Julius iPhone",
deviceType: "mobile",
os: "iOS",
browser: "Safari",
ipAddress: "127.0.0.1",
});
assert.equal(revokeOthersResponse.status, 200);
assert.equal(revokeOthersBody.revokedCount, 1);
assert.equal(listAfterResponse.status, 200);
assert.lengthOf(clientsAfter, 1);
assert.equal(clientsAfter[0]?.current, true);
assert.equal(pairedClientPairingResponse.status, 401);
assert.equal(pairedClientPairingBody._tag, "EnvironmentAuthInvalidError");
assert.equal(pairedClientPairingBody.code, "auth_invalid");
assert.equal(pairedClientPairingBody.reason, "invalid_credential");
assert.equal(Predicate.isString(pairedClientPairingBody.traceId), true);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("separates access inventory reads from credential management writes", () =>
Effect.gen(function* () {
yield* buildAppUnderTest({
config: {
host: "0.0.0.0",
},
});
const ownerCookie = yield* getAuthenticatedSessionCookieHeader();
const issueScopedSession = Effect.fnUntraced(function* (
scope: "access:read" | "access:write",
) {
const pairingResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: ownerCookie,
},
body: yield* HttpBody.json({ scopes: [scope] }),
});
assert.equal(pairingResponse.status, 200);
const pairingBody = (yield* pairingResponse.json) as {
readonly credential: string;
};
return yield* getAuthenticatedSessionCookieHeader(pairingBody.credential);
});
const readCookie = yield* issueScopedSession("access:read");
const readListResponse = yield* HttpClient.get("/api/auth/clients", {
headers: {
cookie: readCookie,
},
});
const readWriteResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: readCookie,
},
body: yield* HttpBody.json({}),
});
const readWriteBody = (yield* readWriteResponse.json) as {
readonly requiredScope: string;
};
const writeCookie = yield* issueScopedSession("access:write");
const writeListResponse = yield* HttpClient.get("/api/auth/clients", {
headers: {
cookie: writeCookie,
},
});
const writeListBody = (yield* writeListResponse.json) as {
readonly requiredScope: string;
};
assert.equal(readListResponse.status, 200);
assert.equal(readWriteResponse.status, 403);
assert.equal(readWriteBody.requiredScope, "access:write");
assert.equal(writeListResponse.status, 403);
assert.equal(writeListBody.requiredScope, "access:read");
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("revokes an individual paired client session", () =>
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 pairedSessionCookie = yield* getAuthenticatedSessionCookieHeader(
pairingBody.credential,
);
const clientsResponse = yield* HttpClient.get("/api/auth/clients", {
headers: {
cookie: ownerCookie,
},
});
const clients = (yield* clientsResponse.json) as ReadonlyArray<{
readonly sessionId: string;
readonly current: boolean;
}>;
const pairedSessionId = clients.find((entry) => !entry.current)?.sessionId;
assert.isDefined(pairedSessionId);
const revokeResponse = yield* HttpClient.post("/api/auth/clients/revoke", {
headers: {
cookie: ownerCookie,
"content-type": "application/json",
},
body: HttpBody.text(jsonRequestBody({ sessionId: pairedSessionId }), "application/json"),
});
const pairedClientPairingResponse = yield* HttpClient.post("/api/auth/pairing-token", {
headers: {
cookie: pairedSessionCookie,
},
body: yield* HttpBody.json({}),
});
assert.equal(revokeResponse.status, 200);
assert.equal(pairedClientPairingResponse.status, 401);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
});