Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions apps/api/autumn.config.ts
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@ import {
AI_CREDITS_FEATURE_ID,
AI_CREDITS_MARKUP_PERCENT,
BILLING_SUB_ORGS_FEATURE_ID,
ENTERPRISE_SSO_FEATURE_ID,
OPENROUTER_BYOK_ADDON_ID,
OPENROUTER_BYOK_FEATURE_ID,
UPTIME_MONITORS_FEATURE_ID,
Expand Down Expand Up @@ -112,6 +113,13 @@ export const billingSubOrgs = feature({
type: "boolean",
})

// SSO (SAML/OIDC) and SCIM provisioning. Enterprise is sales-led: granted per customer in Autumn.
export const enterpriseSso = feature({
id: ENTERPRISE_SSO_FEATURE_ID,
name: "Enterprise SSO and SCIM",
type: "boolean",
})

export const startup = plan({
id: "startup",
name: "Startup",
Expand Down
176 changes: 176 additions & 0 deletions apps/api/src/routes/internal/enterprise-sso.http.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,176 @@
import { afterEach, describe, expect, it } from "@effect/vitest"
import {
ApiSchemaErrors,
ApiUnexpectedErrors,
CurrentTenant,
EnterpriseSsoApiGroup,
EnterpriseSsoDocument,
EnterpriseSsoUnavailableError,
OrgId,
RoleName,
ScimTokenIssued,
UserId,
} from "@maple/domain/http"
import { Array as Arr, Context, Effect, Layer, Schema } from "effect"
import { HttpRouter } from "effect/http"
import { HttpApi, HttpApiBuilder } from "effect/http-api"
import { ApiErrorBoundaryLive } from "@maple/backend/http/error-boundary"
import { AuditLogService, type AuditLogRecordInput } from "@maple/backend/services/audit/AuditLogService"
import {
EnterpriseSsoService,
type EnterpriseSsoServiceApi,
} from "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService"
import { HttpEnterpriseSsoLive } from "./enterprise-sso.http"

class SsoOnlyApi extends HttpApi.make("MapleInternalApi")
.add(EnterpriseSsoApiGroup)
.middleware(ApiSchemaErrors)
.middleware(ApiUnexpectedErrors) {}

const ORG_ID = Schema.decodeSync(OrgId)("org_sso_route")
const USER_ID = Schema.decodeSync(UserId)("user_sso_route")
const SCIM_TOKEN = "scim_secret_value_shown_once"
const CLIENT_SECRET = "oidc-client-secret-value"

const document = new EnterpriseSsoDocument({
entitled: true,
domains: [],
connection: null,
directory: null,
roleMappings: [],
groups: [],
bypassUsers: [],
})

const handlers: Array<() => void> = []
afterEach(() => {
for (const dispose of handlers.splice(0)) dispose()
})

/** Every service method answers the empty document and records its name. */
const recordingService = (calls: Array<string>) => {
const ok = (name: string) => () => Effect.sync(() => (calls.push(name), document))
const issued = (name: string) => () =>
Effect.sync(() => (calls.push(name), new ScimTokenIssued({ document, token: SCIM_TOKEN })))
const api: EnterpriseSsoServiceApi = {
get: ok("get"),
addDomain: ok("addDomain"),
verifyDomain: ok("verifyDomain"),
removeDomain: ok("removeDomain"),
createConnection: ok("createConnection"),
updateConnection: ok("updateConnection"),
setEnforcement: ok("setEnforcement"),
deleteConnection: ok("deleteConnection"),
createDirectory: issued("createDirectory"),
rotateDirectoryToken: issued("rotateDirectoryToken"),
setDirectoryState: ok("setDirectoryState"),
deleteDirectory: ok("deleteDirectory"),
setRoleMappings: ok("setRoleMappings"),
addBypassUser: ok("addBypassUser"),
removeBypassUser: ok("removeBypassUser"),
applyDirectoryGroup: () => Effect.fail(new EnterpriseSsoUnavailableError({ message: "unused" })),
confirmDeprovisioned: () => Effect.succeed(true),
}
return Layer.succeed(EnterpriseSsoService, api)
}

const makeHarness = (role: string) => {
const calls: Array<string> = []
const audited: Array<Pick<AuditLogRecordInput, "action" | "metadata">> = []
const audit = Layer.succeed(AuditLogService, {
record: (input) =>
Effect.sync(() => void audited.push({ action: input.action, metadata: input.metadata })),
list: () => Effect.die("unused"),
})
const authorization = Layer.succeed(
CurrentTenant.SessionAuthorization,
CurrentTenant.SessionAuthorization.of({
bearer: (httpEffect) =>
Effect.provideService(
httpEffect,
CurrentTenant.Context,
new CurrentTenant.TenantSchema({
orgId: ORG_ID,
userId: USER_ID,
roles: [Schema.decodeSync(RoleName)(role)],
authMode: "clerk",
}),
),
}),
)
const routes = HttpApiBuilder.layer(SsoOnlyApi).pipe(
Layer.provide(HttpEnterpriseSsoLive),
Layer.provide(ApiErrorBoundaryLive),
Layer.provideMerge(authorization),
Layer.provide(Layer.mergeAll(recordingService(calls), audit)),
)
const { handler, dispose } = HttpRouter.toWebHandler(routes, { disableLogger: true })
handlers.push(() => void dispose())

const send = async (method: string, path: string, body?: unknown) => {
const response = await handler(
new Request(`http://maple.test/internal/enterprise-sso${path}`, {
method,
headers: { authorization: "Bearer test-token", "content-type": "application/json" },
body: body === undefined ? null : JSON.stringify(body),
}),
Context.empty() as never,
)
return { status: response.status, text: await response.text() }
}
return { send, calls, audited }
}

describe("/internal/enterprise-sso", () => {
it("lets a member read, but refuses every write before it reaches the service or the audit log", async () => {
const harness = makeHarness("org:member")
expect((await harness.send("GET", "/")).status).toBe(200)
const writes = [
["POST", "/domains", { domain: "acme.com" }],
["PUT", "/connection/enforcement", { enforced: false }],
["POST", "/directory"],
["DELETE", "/directory"],
["PUT", "/directory/role-mappings", { mappings: [] }],
] as const
for (const [method, path, body] of writes) {
const response = await harness.send(method, path, body)
expect(response.status, `${method} ${path}`).toBe(403)
}
expect(harness.calls).toEqual(["get"])
expect(harness.audited).toEqual([])
})

it("audits each admin write by action, and never with a secret in it", async () => {
const harness = makeHarness("org:admin")
expect((await harness.send("POST", "/domains", { domain: "acme.com" })).status).toBe(200)
const connection = await harness.send("POST", "/connection", {
name: "Acme",
provider: "oidc_custom",
domains: ["acme.com"],
oidc: {
discoveryUrl: "https://id.acme.com/.well-known/openid-configuration",
clientId: "maple",
clientSecret: CLIENT_SECRET,
},
})
expect(connection.status).toBe(200)
expect((await harness.send("PUT", "/connection/enforcement", { enforced: true })).status).toBe(200)
const created = await harness.send("POST", "/directory")
expect(created.status).toBe(200)
// The token goes back to the admin exactly once, in this response.
expect(created.text).toContain(SCIM_TOKEN)
expect((await harness.send("POST", "/directory/token")).status).toBe(200)

expect(Arr.map(harness.audited, (entry) => entry.action)).toEqual([
"enterprise_sso.domain_added",
"enterprise_sso.connection_created",
"enterprise_sso.connection_enforced",
"enterprise_sso.directory_created",
"enterprise_sso.directory_key_rotated",
])
const trail = JSON.stringify(harness.audited)
expect(trail).not.toContain(SCIM_TOKEN)
expect(trail).not.toContain(CLIENT_SECRET)
expect(harness.audited[0]?.metadata).toEqual({ domain: "acme.com" })
})
})
180 changes: 180 additions & 0 deletions apps/api/src/routes/internal/enterprise-sso.http.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,180 @@
import { HttpApiBuilder } from "effect/http-api"
import { CurrentTenant, EnterpriseSsoForbiddenError, MapleInternalApi } from "@maple/domain/http"
import { Array as Arr, Effect } from "effect"
import * as Policy from "@maple/domain/policy"
import { recordHttpAudit } from "@maple/backend/services/audit/AuditLogService"
import {
EnterpriseSsoService,
normalizeDomain,
} from "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService"

const requireSsoAdmin = Effect.gen(function* () {
const tenant = yield* CurrentTenant.Context
yield* Policy.check(
tenant.roles,
"sso:manage",
(denial) => new EnterpriseSsoForbiddenError({ message: denial.message }),
)
return tenant
})

// Reads are open to every member (the page says who to ask); every write is admin-only and audited.
// Audit metadata names what changed, never a secret: no client secret, certificate or SCIM token.
export const HttpEnterpriseSsoLive = HttpApiBuilder.group(MapleInternalApi, "enterpriseSso", (handlers) =>
Effect.gen(function* () {
const sso = yield* EnterpriseSsoService

return handlers
.handle("get", () =>
CurrentTenant.Context.pipe(
Effect.flatMap((tenant) => sso.get(tenant.orgId)),
Effect.withSpan("HttpEnterpriseSso.get"),
),
)
.handle("addDomain", ({ payload }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.addDomain(tenant.orgId, tenant.userId, payload.domain)
yield* recordHttpAudit("enterprise_sso.domain_added", {
metadata: { domain: normalizeDomain(payload.domain) },
})
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.addDomain")),
)
.handle("verifyDomain", ({ params }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.verifyDomain(tenant.orgId, params.domain)
yield* recordHttpAudit("enterprise_sso.domain_verified", {
metadata: { domain: normalizeDomain(params.domain) },
})
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.verifyDomain")),
)
.handle("removeDomain", ({ params }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.removeDomain(tenant.orgId, params.domain)
yield* recordHttpAudit("enterprise_sso.domain_removed", {
metadata: { domain: normalizeDomain(params.domain) },
})
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.removeDomain")),
)
.handle("createConnection", ({ payload }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.createConnection(tenant.orgId, tenant.userId, payload)
yield* recordHttpAudit("enterprise_sso.connection_created", {
metadata: {
provider: payload.provider,
name: payload.name,
domains: Arr.join(Arr.map(payload.domains, normalizeDomain), ","),
},
})
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.createConnection")),
)
.handle("updateConnection", ({ payload }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.updateConnection(tenant.orgId, payload)
yield* recordHttpAudit("enterprise_sso.connection_updated", {
metadata: {
name: payload.name,
domains: Arr.join(Arr.map(payload.domains, normalizeDomain), ","),
idpSettingsChanged: payload.saml !== undefined || payload.oidc !== undefined,
},
})
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.updateConnection")),
)
.handle("setEnforcement", ({ payload }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.setEnforcement(tenant.orgId, payload.enforced)
yield* recordHttpAudit(
payload.enforced
? "enterprise_sso.connection_enforced"
: "enterprise_sso.connection_relaxed",
)
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.setEnforcement")),
)
.handle("deleteConnection", () =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.deleteConnection(tenant.orgId)
yield* recordHttpAudit("enterprise_sso.connection_deleted")
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.deleteConnection")),
)
.handle("createDirectory", () =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const issued = yield* sso.createDirectory(tenant.orgId)
yield* recordHttpAudit("enterprise_sso.directory_created")
return issued
}).pipe(Effect.withSpan("HttpEnterpriseSso.createDirectory")),
)
.handle("rotateDirectoryToken", () =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const issued = yield* sso.rotateDirectoryToken(tenant.orgId)
yield* recordHttpAudit("enterprise_sso.directory_key_rotated")
return issued
}).pipe(Effect.withSpan("HttpEnterpriseSso.rotateDirectoryToken")),
)
.handle("setDirectoryState", ({ payload }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.setDirectoryState(tenant.orgId, payload.paused)
yield* recordHttpAudit(
payload.paused
? "enterprise_sso.directory_paused"
: "enterprise_sso.directory_resumed",
)
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.setDirectoryState")),
)
.handle("deleteDirectory", () =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.deleteDirectory(tenant.orgId)
yield* recordHttpAudit("enterprise_sso.directory_deleted")
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.deleteDirectory")),
)
.handle("setRoleMappings", ({ payload }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.setRoleMappings(tenant.orgId, payload.mappings)
yield* recordHttpAudit("enterprise_sso.role_mapping_updated", {
metadata: {
mappings: Arr.join(
Arr.map(payload.mappings, (m) => `${m.groupId}=${m.role}`),
",",
),
},
})
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.setRoleMappings")),
)
.handle("addBypassUser", ({ payload }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.addBypassUser(tenant.orgId, payload.userId)
yield* recordHttpAudit("enterprise_sso.bypass_added", { affectedUserId: payload.userId })
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.addBypassUser")),
)
.handle("removeBypassUser", ({ params }) =>
Effect.gen(function* () {
const tenant = yield* requireSsoAdmin
const document = yield* sso.removeBypassUser(tenant.orgId, params.userId)
yield* recordHttpAudit("enterprise_sso.bypass_removed", { affectedUserId: params.userId })
return document
}).pipe(Effect.withSpan("HttpEnterpriseSso.removeBypassUser")),
)
}),
)
Loading
Loading