machine-bridge-mcp 0.17.0 → 0.18.0

package/src/worker/account-admin.ts

@@ -0,0 +1,103 @@
+import { json, methodNotAllowed, parseRequestBody } from "./http";
+import {
+  accountByName, createAccount, publicAccount, replaceAccountPassword, revokeAccountCredentials,
+  safeEqual, updateAccount, type AccountRecord, type OAuthStore,
+} from "./oauth-state";
+
+const BODY_LIMIT_BYTES = 64 * 1024;
+const MAX_ACCOUNTS = 64;
+
+export async function accountAdminAuthorized(request: Request, expected: string): Promise<boolean> {
+  const header = request.headers.get("authorization") ?? "";
+  const supplied = /^Bearer\s+(.+)$/i.exec(header)?.[1] ?? "";
+  return Boolean(expected && await safeEqual(supplied, expected));
+}
+
+export async function handleAccountAdminOperation(options: {
+  request: Request;
+  operation: "accounts" | "rotate-password";
+  store: OAuthStore;
+  save: () => Promise<void>;
+  now: number;
+}): Promise<Response> {
+  const { request, operation, store, save, now } = options;
+  if (operation === "rotate-password") return rotatePassword(request, store, save, now);
+  if (request.method === "GET") {
+    const accounts = Object.values(store.accounts)
+      .sort((left, right) => left.name.localeCompare(right.name))
+      .map(publicAccount);
+    return json({ accounts, maximum: MAX_ACCOUNTS });
+  }
+  const body = await parseRequestBody(request, BODY_LIMIT_BYTES);
+  if (request.method === "POST") return create(request, body, store, save, now);
+  if (request.method === "PATCH") return update(body, store, save, now);
+  if (request.method === "DELETE") return remove(body, store, save);
+  return methodNotAllowed("GET, POST, PATCH, DELETE");
+}
+
+async function create(
+  _request: Request,
+  body: Record<string, unknown>,
+  store: OAuthStore,
+  save: () => Promise<void>,
+  now: number,
+): Promise<Response> {
+  if (Object.keys(store.accounts).length >= MAX_ACCOUNTS) return json({ error: "account_limit_reached" }, 409);
+  if (accountByName(store, body.name)) return json({ error: "account_name_exists" }, 409);
+  if (Object.keys(store.accounts).length === 0 && body.role !== "owner") return json({ error: "first_account_must_be_owner" }, 409);
+  let account: AccountRecord;
+  try {
+    account = await createAccount({ name: body.name, displayName: body.display_name, role: body.role, password: body.password, now });
+  } catch {
+    return json({ error: "invalid_account", message: "account name, display name, role, or password is invalid" }, 400);
+  }
+  store.accounts[account.account_id] = account;
+  await save();
+  return json({ account: publicAccount(account) }, 201);
+}
+
+async function update(body: Record<string, unknown>, store: OAuthStore, save: () => Promise<void>, now: number): Promise<Response> {
+  const account = store.accounts[String(body.account_id ?? "")];
+  if (!account) return json({ error: "account_not_found" }, 404);
+  const removesLastOwner = account.active && account.role === "owner" && activeOwnerCount(store) === 1
+    && (body.active === false || (body.role !== undefined && body.role !== "owner"));
+  if (removesLastOwner) return json({ error: "last_owner_required" }, 409);
+  try {
+    updateAccount(account, { displayName: body.display_name, role: body.role, active: body.active }, now);
+  } catch {
+    return json({ error: "invalid_account", message: "account display name, role, or active state is invalid" }, 400);
+  }
+  revokeAccountCredentials(store, account.account_id);
+  await save();
+  return json({ account: publicAccount(account) });
+}
+
+async function remove(body: Record<string, unknown>, store: OAuthStore, save: () => Promise<void>): Promise<Response> {
+  const accountId = String(body.account_id ?? "");
+  const account = store.accounts[accountId];
+  if (!account) return json({ error: "account_not_found" }, 404);
+  if (account.active && account.role === "owner" && activeOwnerCount(store) === 1) return json({ error: "last_owner_required" }, 409);
+  revokeAccountCredentials(store, accountId);
+  delete store.accounts[accountId];
+  await save();
+  return new Response(null, { status: 204 });
+}
+
+async function rotatePassword(request: Request, store: OAuthStore, save: () => Promise<void>, now: number): Promise<Response> {
+  if (request.method !== "POST") return methodNotAllowed("POST");
+  const body = await parseRequestBody(request, BODY_LIMIT_BYTES);
+  const account = store.accounts[String(body.account_id ?? "")];
+  if (!account) return json({ error: "account_not_found" }, 404);
+  try {
+    await replaceAccountPassword(account, body.password, now);
+  } catch {
+    return json({ error: "invalid_password", message: "account password must be a generated 256-bit token" }, 400);
+  }
+  revokeAccountCredentials(store, account.account_id);
+  await save();
+  return json({ account: publicAccount(account) });
+}
+
+function activeOwnerCount(store: OAuthStore): number {
+  return Object.values(store.accounts).filter((account) => account.active && account.role === "owner").length;
+}

package/src/worker/index.ts

@@ -1,13 +1,16 @@
 import { DurableObject } from "cloudflare:workers";
-import toolCatalog from "../shared/tool-catalog.json";
 import serverMetadata from "../shared/server-metadata.json";
 import { PendingCallRegistry } from "./pending-calls";
 import { WorkerObservability } from "./observability";
 import { daemonToolError, publicWorkerToolError, WorkerToolError } from "./errors";
 import { sanitizeDaemonPolicy, sanitizeDaemonTools, type DaemonPolicy } from "./policy";
+import { accountRoleAllowsTool, accountRoleToolNames, type AccountRole } from "./access";
+import { accountAdminAuthorized, handleAccountAdminOperation } from "./account-admin";
+import { serverInfoTool, workspaceTools } from "./tool-catalog";
 import {
-  AUTH_BLOCK_SECONDS, authorizationIdentity, pkceS256, pruneAuthFailures, pruneClientRecordByExpiry, pruneRecordByExpiry,
-  randomToken, recordAuthorizationFailure, safeEqual, sha256Hex, validateAuthorizationRequest,
+  AUTH_BLOCK_SECONDS, accountByName, authorizationIdentity, emptyOAuthStore, isCurrentOAuthStore,
+  pkceS256, pruneAuthFailures, pruneClientRecordByExpiry, pruneRecordByExpiry, randomToken,
+  recordAuthorizationFailure, safeEqual, sha256Hex, validateAuthorizationRequest, verifyAccountPassword,
   type OAuthClient, type OAuthStore, type ValidatedAuthorization,
 } from "./oauth-state";
 import {
@@ -17,7 +20,7 @@ import {
 } from "./http";
 
 const SERVER_NAME = String(serverMetadata.name);
-const SERVER_VERSION = "0.17.0";
+const SERVER_VERSION = "0.18.0";
 const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
 const MCP_SUPPORTED_PROTOCOL_VERSIONS = serverMetadata.supportedProtocolVersions.map((value) => String(value));
 const JSONRPC_VERSION = "2.0";
@@ -41,7 +44,7 @@ const AUTHORIZATION_FIELDS = new Set(["response_type", "client_id", "redirect_ur
 
 interface BridgeEnv {
   BRIDGE: DurableObjectNamespace<BridgeRoom>;
-  MCP_OAUTH_PASSWORD: string;
+  ACCOUNT_ADMIN_SECRET: string;
   DAEMON_SHARED_SECRET: string;
   OAUTH_TOKEN_VERSION: string;
   MBM_WORKER_MAX_BODY_BYTES?: string;
@@ -64,27 +67,16 @@ interface DaemonAttachment {
   tools?: string[];
 }
 
-
-
 interface AuthorizedToken {
   tokenKey: string;
   clientId: string;
+  accountId: string;
+  accountVersion: number;
+  role: AccountRole;
 }
 
-type ToolDefinition = Record<string, unknown> & { name: string; availability?: string };
-
-const allCatalogTools = toolCatalog as ToolDefinition[];
-const serverInfoTool = publicTool(allCatalogTools.find((tool) => tool.name === "server_info")!);
-const workspaceTools = allCatalogTools.filter((tool) => tool.name !== "server_info").map(publicTool);
-
 const MCP_INSTRUCTIONS = serverMetadata.instructions.map((value) => String(value)).join("\n");
 
-
-function publicTool(tool: ToolDefinition): ToolDefinition {
-  const { availability: _availability, ...definition } = tool;
-  return structuredClone(definition) as ToolDefinition;
-}
-
 export class BridgeRoom extends DurableObject<BridgeEnv> {
   private readonly pending = new PendingCallRegistry(MAX_PENDING_CALLS);
   private readonly observability = new WorkerObservability();
@@ -133,7 +125,9 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
         if (request.method !== "GET") return methodNotAllowed("GET");
         return json(this.protectedResourceMetadata(base));
       }
-      if (url.pathname === "/oauth/register") {
+      if (url.pathname === "/admin/accounts") return await this.handleAccountAdmin(request, "accounts");
+      if (url.pathname === "/admin/accounts/rotate-password") return await this.handleAccountAdmin(request, "rotate-password");
+            if (url.pathname === "/oauth/register") {
         if (request.method !== "POST") return methodNotAllowed("POST");
         return await this.registerClient(request);
       }
@@ -278,6 +272,7 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
 
     const authorized = await this.verifyAccessToken(bearerToken(request), base);
     if (!authorized) {
+      try { await request.arrayBuffer(); } catch { /* The rejected body may already be unavailable; the 401 remains authoritative. */ }
       return new Response("OAuth bearer token required", {
         status: 401,
         headers: {
@@ -306,7 +301,7 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
         ? requested
         : MCP_PROTOCOL_VERSION;
       const bootstrap = this.daemonToolEnabled("session_bootstrap")
-        ? await this.callDaemonTool("session_bootstrap", { path: "." }).catch(() => null)
+        ? await this.callDaemonTool("session_bootstrap", { path: "." }, authorized).catch(() => null)
         : null;
       const localInstructions = sessionInstructionText(bootstrap);
       return rpcResult(request.id, {
@@ -328,14 +323,14 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     }
     if (request.method === "logging/setLevel") return rpcResult(request.id, {});
     if (request.method === "ping") return rpcResult(request.id, {});
-    if (request.method === "tools/list") return rpcResult(request.id, { tools: this.allTools() });
+    if (request.method === "tools/list") return rpcResult(request.id, { tools: this.allTools(authorized.role) });
     if (request.method === "tools/call") {
       if (request.id === undefined || request.id === null) return rpcError(null, -32600, "tools/call requires a non-null request id");
       const params = asObject(request.params);
       const name = requiredString(params, "name");
       const args = asObject(params.arguments);
       try {
-        const result = await this.callTool(name, args, base, clientRequestKey(authorized, request.id));
+        const result = await this.callTool(name, args, base, authorized, clientRequestKey(authorized, request.id));
         return rpcResult(request.id, textToolResult(result));
       } catch (error) {
         return rpcResult(request.id, textToolResult({ error: publicWorkerToolError(error) }, true));
@@ -344,15 +339,16 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     return rpcError(request.id, -32601, `Method not found: ${request.method}`);
   }
 
-  private async callTool(name: string, args: Record<string, unknown>, base: string, requestKey?: string): Promise<unknown> {
+  private async callTool(name: string, args: Record<string, unknown>, base: string, authorized: AuthorizedToken, requestKey?: string): Promise<unknown> {
     if (name === "server_info") {
       const daemon = this.daemonStatus(true);
-      const tools = this.allTools().map((tool) => tool.name);
+      const tools = this.allTools(authorized.role).map((tool) => tool.name);
       return {
         name: SERVER_NAME,
         version: SERVER_VERSION,
         mcp_url: `${base}/mcp`,
         oauth: this.authorizationServerMetadata(base),
+        account: { account_id: authorized.accountId, role: authorized.role, version: authorized.accountVersion },
         daemon,
         worker: {
           pending_calls: this.pending.snapshot(),
@@ -371,12 +367,13 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     }
     if (workspaceTools.some((tool) => tool.name === name)) {
       if (!this.daemonToolEnabled(name)) throw new Error(`tool disabled by local daemon policy: ${name}`);
-      return this.callDaemonTool(name, args, requestKey);
+      if (!accountRoleAllowsTool(authorized.role, name)) throw new WorkerToolError("authorization_denied", "tool is not allowed for this account role");
+      return this.callDaemonTool(name, args, authorized, requestKey);
     }
     throw new Error(`unknown tool: ${name}`);
   }
 
-  private async callDaemonTool(name: string, args: Record<string, unknown>, requestKey?: string): Promise<unknown> {
+  private async callDaemonTool(name: string, args: Record<string, unknown>, authorized: AuthorizedToken, requestKey?: string): Promise<unknown> {
     const socket = this.daemonSockets()[0];
     if (!socket) throw new WorkerToolError("unavailable", "local daemon is not connected; keep the CLI start command running", true);
     const id = randomToken("call");
@@ -393,7 +390,10 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     });
     this.observability.callStarted(name);
     try {
-      socket.send(JSON.stringify({ type: "tool_call", id, tool: name, arguments: args, timeout_ms: timeoutMs }));
+      socket.send(JSON.stringify({
+        type: "tool_call", id, tool: name, arguments: args, timeout_ms: timeoutMs,
+        authorization: { account_id: authorized.accountId, account_version: authorized.accountVersion, role: authorized.role },
+      }));
     } catch {
       this.pending.reject(id, new WorkerToolError("network_error", "failed to send daemon tool call", true), socket);
     }
@@ -438,8 +438,8 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     return new Response(null, { status: 101, webSocket: client });
   }
 
-  private allTools(): Array<Record<string, unknown>> {
-    const advertised = this.daemonAdvertisedTools();
+  private allTools(role: AccountRole): Array<Record<string, unknown>> {
+    const advertised = accountRoleToolNames(role, this.daemonAdvertisedTools());
     const localTools = workspaceTools.filter((tool) => advertised.has(tool.name));
     return [serverInfoTool, ...localTools].map((tool) => structuredClone(tool));
   }
@@ -587,21 +587,24 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
   }
 
   private async oauthStore(): Promise<OAuthStore> {
-    const store = (await this.ctx.storage.get<OAuthStore>("oauth")) ?? { clients: {}, codes: {}, tokens: {}, auth_failures: {} };
-    store.clients ||= {};
-    store.codes ||= {};
-    store.tokens ||= {};
-    store.auth_failures ||= {};
-    const now = Math.floor(Date.now() / 1000);
+    const raw = await this.ctx.storage.get<unknown>("oauth");
+    if (raw !== undefined && !isCurrentOAuthStore(raw)) {
+      throw new HttpError(503, "oauth_state_schema_mismatch", "OAuth state requires the one-time multi-account upgrade");
+    }
+    const store = isCurrentOAuthStore(raw) ? raw : emptyOAuthStore();
     let changed = false;
+    const now = Math.floor(Date.now() / 1000);
+
     for (const [code, value] of Object.entries(store.codes)) {
-      if (value.expires_at <= now) {
+      const account = store.accounts[value.account_id];
+      if (value.expires_at <= now || !account || !account.active || account.version !== value.account_version || account.role !== value.role) {
         delete store.codes[code];
         changed = true;
       }
     }
     for (const [token, value] of Object.entries(store.tokens)) {
-      if (value.expires_at <= now) {
+      const account = store.accounts[value.account_id];
+      if (value.expires_at <= now || !account || !account.active || account.version !== value.account_version || account.role !== value.role) {
         delete store.tokens[token];
         changed = true;
       }
@@ -621,10 +624,6 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
         delete client.registration_identity;
         changed = true;
       }
-      if (!client.last_used_at) {
-        client.last_used_at = client.created_at;
-        changed = true;
-      }
       const ttl = client.last_used_at === client.created_at ? OAUTH_UNUSED_CLIENT_TTL_SECONDS : OAUTH_CLIENT_IDLE_TTL_SECONDS;
       if (!activeClientIds.has(clientId) && client.last_used_at + ttl <= now) {
         delete store.clients[clientId];
@@ -635,6 +634,17 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     return store;
   }
 
+  private async handleAccountAdmin(request: Request, operation: "accounts" | "rotate-password"): Promise<Response> {
+    if (!(await accountAdminAuthorized(request, this.env.ACCOUNT_ADMIN_SECRET ?? ""))) return json({ error: "unauthorized" }, 401);
+    return this.withOAuthLock(async () => {
+      const store = await this.oauthStore();
+      return handleAccountAdminOperation({
+        request, operation, store, now: Math.floor(Date.now() / 1000),
+        save: () => this.ctx.storage.put("oauth", store),
+      });
+    });
+  }
+
   private async registerClient(request: Request): Promise<Response> {
     const body = await parseRequestBody(request, OAUTH_BODY_LIMIT_BYTES);
     const redirectUris = body.redirect_uris;
@@ -727,7 +737,8 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     const form = allowSubmit
       ? `<form method="post" action="/oauth/authorize">
       ${hidden}
-      <label>Connection password<br><input name="login_token" type="password" autocomplete="current-password" autofocus required style="width: 100%; box-sizing: border-box; padding: 8px;"></label>
+      <label>Account name<br><input name="account_name" autocomplete="username" autofocus required style="width: 100%; box-sizing: border-box; padding: 8px;"></label>
+      <p><label>Account password<br><input name="account_password" type="password" autocomplete="current-password" required style="width: 100%; box-sizing: border-box; padding: 8px;"></label></p>
       <p><button type="submit">Authorize</button></p>
     </form>`
       : "<p>Authorization cannot continue. Return to the MCP client and start the connection again.</p>";
@@ -761,13 +772,14 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
         return this.authorizePage(request, base, "Too many failed attempts. Try again later.", body, 429, validation.value);
       }
 
-      const expectedLogin = this.env.MCP_OAUTH_PASSWORD ?? "";
-      if (!expectedLogin || !(await safeEqual(String(body.login_token ?? ""), expectedLogin))) {
+      const account = accountByName(store, body.account_name);
+      const credentialsValid = Boolean(account?.active && await verifyAccountPassword(account, body.account_password));
+      if (!account || !credentialsValid) {
         recordAuthorizationFailure(store, identity, now);
         pruneAuthFailures(store, MAX_AUTH_FAILURE_IDENTITIES);
         await this.ctx.storage.put("oauth", store);
         const status = store.auth_failures[identity]?.blocked_until > now ? 429 : 401;
-        return this.authorizePage(request, base, "Invalid connection password.", body, status, validation.value);
+        return this.authorizePage(request, base, "Invalid account credentials.", body, status, validation.value);
       }
       delete store.auth_failures[identity];
       client.last_used_at = now;
@@ -776,6 +788,9 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
       const redirectLocation = authorizationRedirectLocation(redirectUri, code, state);
       store.codes[code] = {
         client_id: clientId,
+        account_id: account.account_id,
+        account_version: account.version,
+        role: account.role,
         redirect_uri: redirectUri,
         code_challenge: codeChallenge,
         scope,
@@ -817,6 +832,9 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
       const accessToken = randomToken("mcp_at");
       store.tokens[`sha256:${await sha256Hex(accessToken)}`] = {
         client_id: record.client_id,
+        account_id: record.account_id,
+        account_version: record.account_version,
+        role: record.role,
         scope: record.scope,
         resource: `${base}/mcp`,
         version: tokenVersion,
@@ -844,7 +862,16 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
       const currentVersion = this.env.OAUTH_TOKEN_VERSION ?? "";
       if (!record.version || !currentVersion || !(await safeEqual(record.version, currentVersion))) return null;
       if (record.resource !== `${base}/mcp`) return null;
-      return { tokenKey: key, clientId: record.client_id };
+      const account = store.accounts[record.account_id];
+      if (!account || !account.active || account.version !== record.account_version || account.role !== record.role) {
+        delete store.tokens[key];
+        await this.ctx.storage.put("oauth", store);
+        return null;
+      }
+      return {
+        tokenKey: key, clientId: record.client_id, accountId: account.account_id,
+        accountVersion: account.version, role: account.role,
+      };
     });
   }
 
@@ -861,7 +888,7 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
   }
 
   private identityKey(): string {
-    const key = this.env.OAUTH_TOKEN_VERSION || this.env.DAEMON_SHARED_SECRET || this.env.MCP_OAUTH_PASSWORD;
+    const key = this.env.OAUTH_TOKEN_VERSION || this.env.DAEMON_SHARED_SECRET || this.env.ACCOUNT_ADMIN_SECRET;
     if (!key) throw new HttpError(503, "server_not_configured", "OAuth identity key is not configured");
     return key;
   }

package/src/worker/oauth-state.ts

@@ -1,3 +1,21 @@
+import { normalizeAccountRole, type AccountRole } from "./access";
+
+export const OAUTH_STORE_SCHEMA_VERSION = 1;
+const PASSWORD_TOKEN_PATTERN = /^[a-z][a-z0-9_]{2,31}_[A-Za-z0-9_-]{43}$/;
+
+export interface AccountRecord {
+  account_id: string;
+  name: string;
+  display_name: string;
+  role: AccountRole;
+  active: boolean;
+  version: number;
+  password_salt: string;
+  password_hash: string;
+  created_at: number;
+  updated_at: number;
+}
+
 export interface OAuthClient {
   client_id: string;
   client_name: string;
@@ -9,6 +27,9 @@ export interface OAuthClient {
 
 export interface OAuthCode {
   client_id: string;
+  account_id: string;
+  account_version: number;
+  role: AccountRole;
   redirect_uri: string;
   code_challenge: string;
   scope: string;
@@ -18,6 +39,9 @@ export interface OAuthCode {
 
 export interface OAuthToken {
   client_id: string;
+  account_id: string;
+  account_version: number;
+  role: AccountRole;
   scope: string;
   resource: string;
   version: string;
@@ -32,6 +56,8 @@ export interface OAuthFailure {
 }
 
 export interface OAuthStore {
+  schema_version: number;
+  accounts: Record<string, AccountRecord>;
   clients: Record<string, OAuthClient>;
   codes: Record<string, OAuthCode>;
   tokens: Record<string, OAuthToken>;
@@ -52,6 +78,28 @@ const AUTH_FAILURE_WINDOW_SECONDS = 10 * 60;
 export const AUTH_BLOCK_SECONDS = 15 * 60;
 const AUTH_FAILURE_LIMIT = 10;
 
+export function emptyOAuthStore(): OAuthStore {
+  return {
+    schema_version: OAUTH_STORE_SCHEMA_VERSION,
+    accounts: {},
+    clients: {},
+    codes: {},
+    tokens: {},
+    auth_failures: {},
+  };
+}
+
+export function isCurrentOAuthStore(value: unknown): value is OAuthStore {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const store = value as Partial<OAuthStore>;
+  return store.schema_version === OAUTH_STORE_SCHEMA_VERSION
+    && isRecord(store.accounts)
+    && isRecord(store.clients)
+    && isRecord(store.codes)
+    && isRecord(store.tokens)
+    && isRecord(store.auth_failures);
+}
+
 export function validateAuthorizationRequest(
   body: Record<string, unknown>,
   base: string,
@@ -81,6 +129,106 @@ export function validateAuthorizationRequest(
   return { value: { client, clientId, redirectUri, codeChallenge, requestedResource, scope, state } };
 }
 
+export function normalizeAccountName(value: unknown): string | null {
+  const name = String(value ?? "").trim().toLowerCase();
+  return /^[a-z0-9](?:[a-z0-9._-]{1,62}[a-z0-9])?$/.test(name) ? name : null;
+}
+
+export function accountByName(store: OAuthStore, name: unknown): AccountRecord | null {
+  const normalized = normalizeAccountName(name);
+  if (!normalized) return null;
+  return Object.values(store.accounts).find((account) => account.name === normalized) ?? null;
+}
+
+export async function createAccount(input: { name: unknown; displayName?: unknown; role: unknown; password: unknown; now: number }): Promise<AccountRecord> {
+  const name = normalizeAccountName(input.name);
+  const role = normalizeAccountRole(input.role);
+  const password = normalizePassword(input.password);
+  if (!name) throw new Error("account name must be 3-64 lowercase letters, digits, dots, underscores, or hyphens");
+  if (!role) throw new Error("account role is invalid");
+  const displayName = normalizeDisplayName(input.displayName, name);
+  const salt = new Uint8Array(16);
+  crypto.getRandomValues(salt);
+  return {
+    account_id: randomToken("acct"),
+    name,
+    display_name: displayName,
+    role,
+    active: true,
+    version: 1,
+    password_salt: base64Url(salt),
+    password_hash: await derivePasswordHash(password, salt),
+    created_at: input.now,
+    updated_at: input.now,
+  };
+}
+
+export async function replaceAccountPassword(account: AccountRecord, passwordValue: unknown, now: number): Promise<void> {
+  const password = normalizePassword(passwordValue);
+  const salt = new Uint8Array(16);
+  crypto.getRandomValues(salt);
+  account.password_salt = base64Url(salt);
+  account.password_hash = await derivePasswordHash(password, salt);
+  account.version += 1;
+  account.updated_at = now;
+}
+
+export async function verifyAccountPassword(account: AccountRecord, passwordValue: unknown): Promise<boolean> {
+  try {
+    const password = normalizePassword(passwordValue);
+    const salt = base64UrlDecode(account.password_salt);
+    const hash = await derivePasswordHash(password, salt);
+    return safeEqual(hash, account.password_hash);
+  } catch {
+    return false;
+  }
+}
+
+export function publicAccount(account: AccountRecord): Record<string, unknown> {
+  return {
+    account_id: account.account_id,
+    name: account.name,
+    display_name: account.display_name,
+    role: account.role,
+    active: account.active,
+    version: account.version,
+    created_at: account.created_at,
+    updated_at: account.updated_at,
+  };
+}
+
+export function updateAccount(account: AccountRecord, input: { displayName?: unknown; role?: unknown; active?: unknown }, now: number): void {
+  let changed = false;
+  if (input.displayName !== undefined) {
+    account.display_name = normalizeDisplayName(input.displayName, account.name);
+    changed = true;
+  }
+  if (input.role !== undefined) {
+    const role = normalizeAccountRole(input.role);
+    if (!role) throw new Error("account role is invalid");
+    if (role !== account.role) {
+      account.role = role;
+      changed = true;
+    }
+  }
+  if (input.active !== undefined) {
+    if (typeof input.active !== "boolean") throw new Error("active must be a boolean");
+    if (account.active !== input.active) {
+      account.active = input.active;
+      changed = true;
+    }
+  }
+  if (changed) {
+    account.version += 1;
+    account.updated_at = now;
+  }
+}
+
+export function revokeAccountCredentials(store: OAuthStore, accountId: string): void {
+  for (const [key, value] of Object.entries(store.codes)) if (value.account_id === accountId) delete store.codes[key];
+  for (const [key, value] of Object.entries(store.tokens)) if (value.account_id === accountId) delete store.tokens[key];
+}
+
 export function pruneClientRecordByExpiry<T extends { client_id: string; expires_at: number }>(record: Record<string, T>, clientId: string, keep: number): void {
   const allowed = new Set(Object.entries(record)
     .filter(([, value]) => value.client_id === clientId)
@@ -111,7 +259,7 @@ export async function authorizationIdentity(request: Request, keyMaterial: strin
     ["sign"],
   );
   const digest = await crypto.subtle.sign("HMAC", key, encoder.encode(source));
-  return `hmac-sha256:${[...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  return `hmac-sha256:${hex(new Uint8Array(digest))}`;
 }
 
 export function recordAuthorizationFailure(store: OAuthStore, identity: string, now: number): void {
@@ -142,7 +290,7 @@ export function randomToken(prefix: string): string {
 
 export async function sha256Hex(value: string): Promise<string> {
   const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
-  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return hex(new Uint8Array(digest));
 }
 
 export async function safeEqual(left: string, right: string): Promise<boolean> {
@@ -165,6 +313,40 @@ export async function pkceS256(verifier: string): Promise<string> {
   return base64Url(new Uint8Array(digest));
 }
 
+function normalizePassword(value: unknown): string {
+  if (typeof value !== "string" || !PASSWORD_TOKEN_PATTERN.test(value)) {
+    throw new Error("account password must be a generated 256-bit token");
+  }
+  return value;
+}
+
+function normalizeDisplayName(value: unknown, fallback: string): string {
+  const text = typeof value === "string" ? value.trim().replace(/[\r\n\t\u0000-\u001f\u007f]/g, " ").slice(0, 128) : "";
+  return text || fallback;
+}
+
+async function derivePasswordHash(password: string, salt: Uint8Array): Promise<string> {
+  if (salt.byteLength !== 16) throw new Error("account password salt is invalid");
+  const saltBuffer = salt.buffer.slice(salt.byteOffset, salt.byteOffset + salt.byteLength) as ArrayBuffer;
+  const key = await crypto.subtle.importKey("raw", saltBuffer, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(password));
+  return base64Url(new Uint8Array(signature));
+}
+
 function base64Url(bytes: Uint8Array): string {
   return btoa(String.fromCharCode(...bytes)).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
 }
+
+function base64UrlDecode(value: string): Uint8Array {
+  const normalized = value.replaceAll("-", "+").replaceAll("_", "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  return Uint8Array.from(atob(padded), (character) => character.charCodeAt(0));
+}
+
+function hex(bytes: Uint8Array): string {
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/src/worker/tool-catalog.ts

@@ -0,0 +1,13 @@
+import toolCatalog from "../shared/tool-catalog.json";
+
+export type WorkerToolDefinition = Record<string, unknown> & { name: string; availability?: string };
+
+const allTools = toolCatalog as WorkerToolDefinition[];
+
+export const serverInfoTool = publicTool(allTools.find((tool) => tool.name === "server_info")!);
+export const workspaceTools = Object.freeze(allTools.filter((tool) => tool.name !== "server_info").map(publicTool));
+
+function publicTool(tool: WorkerToolDefinition): WorkerToolDefinition {
+  const { availability: _availability, ...definition } = tool;
+  return structuredClone(definition) as WorkerToolDefinition;
+}