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 Headers from "effect/unstable/http/Headers";
import * as Predicate from "effect/Predicate";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { AuthAdministrativeScopes } from "@akeru/contracts";
import { expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as ServerConfig from "../config.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import { SqlitePersistenceMemory } from "../persistence/Layers/Sqlite.ts";
import * as PairingGrantStore from "./PairingGrantStore.ts";
import * as EnvironmentAuth from "./EnvironmentAuth.ts";
import * as EnvironmentAuthPolicy from "./EnvironmentAuthPolicy.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
import * as SessionStore from "./SessionStore.ts";
/** Pinned so dev-mode cookie tests can assert the port-scoped name. */
const TEST_SERVER_PORT = 13_773;
const makeServerConfigLayer = (overrides?: Partial<ServerConfig.ServerConfig["Service"]>) =>
Layer.effect(
ServerConfig.ServerConfig,
Effect.gen(function* () {
const config = yield* ServerConfig.ServerConfig;
return {
...config,
...overrides,
// Keep the test server deterministic even when the default test layer
// changes its development port.
port: TEST_SERVER_PORT,
} satisfies ServerConfig.ServerConfig["Service"];
}),
).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-auth-server-test-" })));
const makeEnvironmentAuthLayer = (overrides?: Partial<ServerConfig.ServerConfig["Service"]>) =>
EnvironmentAuth.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
Layer.provide(ServerSecretStore.layer),
Layer.provide(ServerEnvironment.identityLayer),
Layer.provide(makeServerConfigLayer(overrides)),
);
// Yields inside the first-admin check so concurrent redemptions interleave
// there unless the redemption lock serializes them.
const makeInterleavingEnvironmentAuthLayer = () =>
Layer.effect(
EnvironmentAuth.EnvironmentAuth,
Effect.gen(function* () {
const sessions = yield* SessionStore.SessionStore;
return yield* EnvironmentAuth.make.pipe(
Effect.provideService(SessionStore.SessionStore, {
...sessions,
listActive: () => Effect.yieldNow.pipe(Effect.andThen(sessions.listActive())),
}),
);
}),
).pipe(
Layer.provideMerge(PairingGrantStore.layer),
Layer.provideMerge(SessionStore.layer),
Layer.provideMerge(EnvironmentAuthPolicy.layer),
Layer.provide(SqlitePersistenceMemory),
Layer.provide(ServerSecretStore.layer),
Layer.provide(ServerEnvironment.identityLayer),
Layer.provide(makeServerConfigLayer()),
);
const makeCookieRequest = (
cookieName: string,
sessionToken: string,
): Parameters<EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]>[0] => ({
cookies: {
[cookieName]: sessionToken,
},
headers: Headers.empty,
});
const requestMetadata = {
deviceType: "desktop" as const,
os: "macOS",
browser: "Chrome",
ipAddress: "192.168.1.23",
};
it.layer(NodeServices.layer)("EnvironmentAuth.layer", (it) => {
it.effect("classifies invalid bootstrap credential failures for the HTTP boundary", () =>
Effect.sync(() => {
const error = EnvironmentAuth.toBootstrapExchangeError(
new PairingGrantStore.UnknownBootstrapCredentialError({}),
);
expect(error._tag).toBe("ServerAuthInvalidCredentialError");
}),
);
it.effect("maps unexpected bootstrap failures to 500", () =>
Effect.sync(() => {
const cause = new PairingGrantStore.BootstrapCredentialConsumeError({
cause: new Error("sqlite is unavailable"),
});
const error = EnvironmentAuth.toBootstrapExchangeError(cause);
expect(error._tag).toBe("ServerAuthBootstrapCredentialValidationError");
expect(error.message).toBe("Failed to validate bootstrap credential.");
if (Predicate.isTagged(error, "ServerAuthBootstrapCredentialValidationError")) {
expect(error.cause).toBe(cause);
}
}),
);
it.effect("issues standard pairing credentials by default", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const pairingCredential = yield* serverAuth.issuePairingCredential();
const exchanged = yield* serverAuth.createBrowserSession(
pairingCredential.credential,
requestMetadata,
);
const verified = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, exchanged.sessionToken),
);
expect(verified.sessionId.length).toBeGreaterThan(0);
expect(verified.scopes).toEqual(["orchestration:read", "orchestration:operate"]);
expect(verified.subject).toBe("one-time-token");
}).pipe(Effect.provide(makeEnvironmentAuthLayer())),
);
it.effect("prefers a bearer token over a stale legacy cookie", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const bearer = yield* serverAuth.issueSession();
const verified = yield* serverAuth.authenticateHttpRequest({
cookies: { [sessions.legacyCookieName ?? "t3_session"]: "stale" },
headers: { authorization: `Bearer ${bearer.token}` },
} as never);
expect(verified.sessionId).toBe(bearer.sessionId);
}).pipe(Effect.provide(makeEnvironmentAuthLayer({ mode: "web", host: "192.168.1.50" }))),
);
it.effect("does not exchange ordinary pairing grants for administrative access tokens", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const pairingCredential = yield* serverAuth.issuePairingCredential();
const error = yield* serverAuth
.exchangeBootstrapCredentialForAccessToken(
pairingCredential.credential,
["orchestration:read", "access:write"],
requestMetadata,
)
.pipe(Effect.flip);
expect(error._tag).toBe("ServerAuthScopeNotGrantedError");
}).pipe(Effect.provide(makeEnvironmentAuthLayer())),
);
it.effect("inherits a constrained pairing grant when token exchange omits scope", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const pairingCredential = yield* serverAuth.issuePairingCredential({
scopes: ["orchestration:read"],
});
const token = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
pairingCredential.credential,
undefined,
requestMetadata,
);
expect(token.scope).toBe("orchestration:read");
}).pipe(Effect.provide(makeEnvironmentAuthLayer())),
);
it.effect("lets only one of two concurrent admin link redemptions become the first admin", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const browserLink = yield* serverAuth.issuePairingCredential({
scopes: AuthAdministrativeScopes,
});
const tokenLink = yield* serverAuth.issuePairingCredential({
scopes: AuthAdministrativeScopes,
});
const [browser, token] = yield* Effect.all(
[
Effect.result(serverAuth.createBrowserSession(browserLink.credential, requestMetadata)),
Effect.result(
serverAuth.exchangeBootstrapCredentialForAccessToken(
tokenLink.credential,
undefined,
requestMetadata,
),
),
],
{ concurrency: "unbounded" },
);
expect(
[browser, token].filter((result) => Predicate.isTagged(result, "Success")),
).toHaveLength(1);
expect(yield* serverAuth.listPairingLinks()).toHaveLength(0);
}).pipe(Effect.provide(makeInterleavingEnvironmentAuthLayer())),
);
it.effect("keeps user-issued administrative pairing links manageable", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const pairingCredential = yield* serverAuth.issuePairingCredential({
scopes: AuthAdministrativeScopes,
});
const listedPairingLinks = yield* serverAuth.listPairingLinks();
expect(
listedPairingLinks.find((pairingLink) => pairingLink.id === pairingCredential.id)?.subject,
).toBe("one-time-token");
}).pipe(Effect.provide(makeEnvironmentAuthLayer())),
);
it.effect("issues startup pairing URLs that bootstrap administrative sessions", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const pairingUrl = yield* serverAuth.issueStartupPairingUrl("http://127.0.0.1:3773");
const token = new URLSearchParams(new URL(pairingUrl).hash.slice(1)).get("token");
const listedPairingLinks = yield* serverAuth.listPairingLinks();
expect(token).toBeTruthy();
expect(
listedPairingLinks.some(
(pairingLink) => pairingLink.subject === "administrative-bootstrap",
),
).toBe(false);
const exchanged = yield* serverAuth.createBrowserSession(token ?? "", requestMetadata);
const verified = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, exchanged.sessionToken),
);
expect(verified.scopes).toEqual([
"orchestration:read",
"orchestration:operate",
"access:read",
"access:write",
]);
expect(verified.subject).toBe("administrative-bootstrap");
}).pipe(Effect.provide(makeEnvironmentAuthLayer())),
);
it.effect(
"lists pairing links and revokes other sessions while keeping the administrative session",
() =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const administrativeExchange = yield* serverAuth.createBrowserSession(
"desktop-bootstrap-token",
requestMetadata,
);
const administrativeSession = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, administrativeExchange.sessionToken),
);
const pairingCredential = yield* serverAuth.issuePairingCredential({
label: "Julius iPhone",
});
const listedPairingLinks = yield* serverAuth.listPairingLinks();
const clientExchange = yield* serverAuth.createBrowserSession(
pairingCredential.credential,
{
...requestMetadata,
deviceType: "mobile",
os: "iOS",
browser: "Safari",
ipAddress: "192.168.1.88",
},
);
const clientSession = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, clientExchange.sessionToken),
);
const clientsBeforeRevoke = yield* serverAuth.listClientSessions(
administrativeSession.sessionId,
);
const revokedCount = yield* serverAuth.revokeOtherClientSessions(
administrativeSession.sessionId,
);
const clientsAfterRevoke = yield* serverAuth.listClientSessions(
administrativeSession.sessionId,
);
expect(listedPairingLinks.map((entry) => entry.id)).toContain(pairingCredential.id);
expect(listedPairingLinks.find((entry) => entry.id === pairingCredential.id)?.label).toBe(
"Julius iPhone",
);
expect(clientsBeforeRevoke).toHaveLength(2);
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === administrativeSession.sessionId)
?.current,
).toBe(true);
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === clientSession.sessionId)?.current,
).toBe(false);
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === clientSession.sessionId)?.client
.label,
).toBe("Julius iPhone");
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === clientSession.sessionId)?.client
.deviceType,
).toBe("mobile");
expect(revokedCount).toBe(1);
expect(clientsAfterRevoke).toHaveLength(1);
expect(clientsAfterRevoke[0]?.sessionId).toBe(administrativeSession.sessionId);
}).pipe(
Effect.provide(
makeEnvironmentAuthLayer({
desktopBootstrapToken: "desktop-bootstrap-token",
}),
),
),
);
});