machine-bridge-mcp 2.0.0 → 3.0.0-beta.9

package/src/local/workspace-file-service.mjs

@@ -12,10 +12,11 @@ const MAX_WALK_ENTRIES = 200_000;
 const MAX_IMAGE_BYTES = 4 * 1024 * 1024;
 
 export class WorkspaceFileService {
-  constructor({ workspace, policy, policyGate, resolveExistingPath, resolveWritePath, displayPath, throwIfCancelled, withMutationLock }) {
+  constructor({ workspace, policy, policyGate, policyForContext = null, resolveExistingPath, resolveWritePath, displayPath, throwIfCancelled, withMutationLock }) {
     this.workspace = workspace;
     this.policy = policy;
     this.policyGate = policyGate;
+    this.policyForContext = typeof policyForContext === "function" ? policyForContext : () => this.policy;
     this.resolveExistingPath = resolveExistingPath;
     this.resolveWritePath = resolveWritePath;
     this.displayPath = displayPath;
@@ -23,18 +24,19 @@ export class WorkspaceFileService {
     this.withMutationLock = withMutationLock;
   }
 
-  listRoots() {
-    const roots = [{ name: this.policy.exposeAbsolutePaths ? basename(this.workspace) : "workspace", path: this.displayPath(this.workspace), default: true }];
-    if (this.policy.unrestrictedPaths) {
+  listRoots(context = {}) {
+    const policy = this.policyForContext(context);
+    const roots = [{ name: policy.exposeAbsolutePaths ? basename(this.workspace) : "workspace", path: this.displayPath(this.workspace, context), default: true }];
+    if (policy.unrestrictedPaths) {
       const home = process.env.HOME || process.env.USERPROFILE;
-      if (home && home !== this.workspace) roots.push({ name: "home", path: this.displayPath(resolve(home)), default: false });
-      roots.push({ name: "filesystem-root", path: this.displayPath(path.parse(this.workspace).root), default: false });
+      if (home && home !== this.workspace) roots.push({ name: "home", path: this.displayPath(resolve(home), context), default: false });
+      roots.push({ name: "filesystem-root", path: this.displayPath(path.parse(this.workspace).root, context), default: false });
     }
     return { roots };
   }
 
   async listDir(inputPath, context = {}) {
-    const full = await this.resolveExistingPath(inputPath);
+    const full = await this.resolveExistingPath(inputPath, context);
     const entries = [];
     let resultBytes = 0;
     let truncated = false;
@@ -44,7 +46,7 @@ export class WorkspaceFileService {
       const info = await lstat(entryPath).catch(() => null);
       const item = {
         name: entry.name,
-        path: this.displayPath(entryPath),
+        path: this.displayPath(entryPath, context),
         type: entry.isDirectory() ? "directory" : entry.isFile() ? "file" : entry.isSymbolicLink() ? "symlink" : "other",
         size: info?.size ?? 0,
       };
@@ -57,26 +59,26 @@ export class WorkspaceFileService {
       resultBytes += itemBytes;
     }
     entries.sort((a, b) => a.type.localeCompare(b.type) || a.name.localeCompare(b.name));
-    return { path: this.displayPath(full), entries, truncated };
+    return { path: this.displayPath(full, context), entries, truncated };
   }
 
   async listFiles(inputPath, maxFiles, context = {}) {
-    const root = await this.resolveExistingPath(inputPath);
+    const root = await this.resolveExistingPath(inputPath, context);
     const info = await stat(root);
-    if (info.isFile()) return { path: this.displayPath(root), files: [this.displayPath(root)], truncated: false };
+    if (info.isFile()) return { path: this.displayPath(root, context), files: [this.displayPath(root, context)], truncated: false };
     if (!info.isDirectory()) throw new Error("path is not a file or directory");
     const files = [];
     let resultBytes = 0;
     const walkResult = await this.walk(root, async full => {
       this.throwIfCancelled(context);
-      const shown = this.displayPath(full);
+      const shown = this.displayPath(full, context);
       const pathBytes = Buffer.byteLength(shown) + 8;
       if (files.length >= maxFiles || resultBytes + pathBytes > MAX_PATH_RESULT_BYTES) return false;
       files.push(shown);
       resultBytes += pathBytes;
       return true;
     }, context);
-    return { path: this.displayPath(root), files, truncated: files.length >= maxFiles || resultBytes >= MAX_PATH_RESULT_BYTES || walkResult.truncated };
+    return { path: this.displayPath(root, context), files, truncated: files.length >= maxFiles || resultBytes >= MAX_PATH_RESULT_BYTES || walkResult.truncated };
   }
 
   async readFile(args, context = {}) {
@@ -85,7 +87,7 @@ export class WorkspaceFileService {
       context = {};
     }
     if (!args.path) throw new Error("path is required");
-    const full = await this.resolveExistingPath(args.path);
+    const full = await this.resolveExistingPath(args.path, context);
     this.throwIfCancelled(context);
     const { buffer, info } = await readBoundedFile(full, MAX_WRITE_BYTES, "readable text file");
     const content = decodeUtf8(buffer);
@@ -107,7 +109,7 @@ export class WorkspaceFileService {
     const selectedBytes = Buffer.byteLength(selected);
     if (selectedBytes > maxBytes) throw new Error(`selected content exceeds max_bytes (${selectedBytes} > ${maxBytes})`);
     return {
-      path: this.displayPath(full),
+      path: this.displayPath(full, context),
       size: info.size,
       sha256: sha256(content),
       content: selected,
@@ -120,7 +122,7 @@ export class WorkspaceFileService {
 
   async viewImage(args, context = {}) {
     if (!args.path) throw new Error("path is required");
-    const full = await this.resolveExistingPath(args.path);
+    const full = await this.resolveExistingPath(args.path, context);
     this.throwIfCancelled(context);
     const { buffer, info } = await readBoundedFile(full, MAX_IMAGE_BYTES, "image");
     this.throwIfCancelled(context);
@@ -130,7 +132,7 @@ export class WorkspaceFileService {
       $mcp: {
         content: [{ type: "image", data: buffer.toString("base64"), mimeType }],
         structuredContent: {
-          path: this.displayPath(full),
+          path: this.displayPath(full, context),
           size: info.size,
           sha256: createHash("sha256").update(buffer).digest("hex"),
           mime_type: mimeType,
@@ -147,7 +149,7 @@ export class WorkspaceFileService {
       const content = String(args.content ?? "");
       const bytes = Buffer.byteLength(content);
       if (bytes > MAX_WRITE_BYTES) throw new Error(`content exceeds maximum write size (${bytes} > ${MAX_WRITE_BYTES})`);
-      const full = await this.resolveWritePath(args.path);
+      const full = await this.resolveWritePath(args.path, context);
       const existing = await lstat(full).catch(() => null);
       if (existing?.isSymbolicLink()) throw new Error("refusing to overwrite a symbolic link");
       if (args.create_only && existing) throw new Error("file exists and create_only=true");
@@ -162,7 +164,7 @@ export class WorkspaceFileService {
         createOnly: args.create_only === true,
         expectedHash: args.expected_sha256 ? String(args.expected_sha256).toLowerCase() : undefined,
       });
-      return { ok: true, path: this.displayPath(full), sha256: sha256(content), bytes };
+      return { ok: true, path: this.displayPath(full, context), sha256: sha256(content), bytes };
     });
   }
 
@@ -174,7 +176,7 @@ export class WorkspaceFileService {
       const oldText = String(args.old_text ?? "");
       const newText = String(args.new_text ?? "");
       if (!oldText) throw new Error("old_text must not be empty");
-      const full = await this.resolveExistingPath(args.path);
+      const full = await this.resolveExistingPath(args.path, context);
       const info = await lstat(full);
       if (!info.isFile() || info.isSymbolicLink()) throw new Error("path is not a regular non-symbolic-link file");
       const current = await readUtf8File(full);
@@ -187,7 +189,7 @@ export class WorkspaceFileService {
       if (bytes > MAX_WRITE_BYTES) throw new Error(`edited content exceeds maximum write size (${bytes} > ${MAX_WRITE_BYTES})`);
       this.throwIfCancelled(context);
       await atomicWriteText(full, updated, info, { expectedHash: sha256(current) });
-      return { ok: true, path: this.displayPath(full), replacements: args.replace_all ? occurrences : 1, sha256: sha256(updated), bytes };
+      return { ok: true, path: this.displayPath(full, context), replacements: args.replace_all ? occurrences : 1, sha256: sha256(updated), bytes };
     });
   }
 
@@ -203,13 +205,13 @@ export class WorkspaceFileService {
       for (const operation of parsed) {
         this.throwIfCancelled(context);
         if (operation.kind === "add") {
-          const target = await this.resolveWritePath(operation.path);
+          const target = await this.resolveWritePath(operation.path, context);
           if (await lstat(target).catch(() => null)) throw new Error(`add target already exists: ${operation.path}`);
           assertTextSize(operation.content, operation.path);
           prepared.push({ kind: "add", source: null, target, content: operation.content, mode: 0o600 });
           continue;
         }
-        const source = await this.resolveExistingPath(operation.path);
+        const source = await this.resolveExistingPath(operation.path, context);
         const sourceInfo = await lstat(source);
         if (!sourceInfo.isFile() || sourceInfo.isSymbolicLink()) throw new Error(`patch source is not a regular file: ${operation.path}`);
         const original = await readUtf8File(source);
@@ -219,7 +221,7 @@ export class WorkspaceFileService {
         }
         const content = applyUpdateHunks(original, operation.hunks, operation.path);
         assertTextSize(content, operation.path);
-        const target = operation.moveTo ? await this.resolveWritePath(operation.moveTo) : source;
+        const target = operation.moveTo ? await this.resolveWritePath(operation.moveTo, context) : source;
         if (target !== source && await lstat(target).catch(() => null)) throw new Error(`move target already exists: ${operation.moveTo}`);
         prepared.push({ kind: operation.moveTo ? "move" : "update", source, target, content, originalHash: sha256(original), mode: sourceInfo.mode & 0o777 });
       }
@@ -231,9 +233,9 @@ export class WorkspaceFileService {
         ...(transaction.warnings.length ? { warnings: transaction.warnings } : {}),
         files: prepared.map((item) => ({
           operation: item.kind,
-          path: this.displayPath(item.target || item.source),
-          from: item.kind === "move" ? this.displayPath(item.source) : undefined,
-          sha256: item.content === undefined ? undefined : sha256(item.content),
+          path: this.displayPath(item.target || item.source, context),
+          ...(item.kind === "move" ? { from: this.displayPath(item.source, context) } : {}),
+          ...(item.content === undefined ? {} : { sha256: sha256(item.content) }),
         })),
       };
     });
@@ -242,7 +244,7 @@ export class WorkspaceFileService {
   async searchText(args, context = {}) {
     const query = String(args.query || "");
     if (!query) throw new Error("query is required");
-    const root = await this.resolveExistingPath(args.path || ".");
+    const root = await this.resolveExistingPath(args.path || ".", context);
     const max = clampInteger(args.max_matches, 100, 1, 1000);
     const maxFiles = clampInteger(args.max_files, 10000, 1, 100000);
     let visitedFiles = 0;
@@ -250,7 +252,7 @@ export class WorkspaceFileService {
     const rootInfo = await stat(root);
     if (rootInfo.isFile()) {
       await this.searchOneFile(root, query, matches, max, context);
-      return { query, root: this.displayPath(root), matches, visited_files: 1, truncated: matches.length >= max };
+      return { query, root: this.displayPath(root, context), matches, visited_files: 1, truncated: matches.length >= max };
     }
     if (!rootInfo.isDirectory()) throw new Error("path is not a file or directory");
     const walkResult = await this.walk(root, async full => {
@@ -260,7 +262,7 @@ export class WorkspaceFileService {
       await this.searchOneFile(full, query, matches, max, context);
       return matches.length < max && visitedFiles < maxFiles;
     }, context);
-    return { query, root: this.displayPath(root), matches, visited_files: visitedFiles, truncated: matches.length >= max || visitedFiles >= maxFiles || walkResult.truncated };
+    return { query, root: this.displayPath(root, context), matches, visited_files: visitedFiles, truncated: matches.length >= max || visitedFiles >= maxFiles || walkResult.truncated };
   }
 
   async searchOneFile(full, query, matches, max, context = {}) {
@@ -274,7 +276,7 @@ export class WorkspaceFileService {
     const lines = text.split(/\r?\n/);
     for (let index = 0; index < lines.length; index += 1) {
       if (lines[index].includes(query)) {
-        matches.push({ path: this.displayPath(full), line: index + 1, text: lines[index].slice(0, 500) });
+        matches.push({ path: this.displayPath(full, context), line: index + 1, text: lines[index].slice(0, 500) });
         if (matches.length >= max) break;
       }
     }
@@ -311,6 +313,7 @@ export async function readBoundedFile(filePath, maxBytes, label) {
   try {
     const info = await handle.stat();
     if (!info.isFile()) throw new Error(`${label} is not a regular file`);
+    if (Number(info.nlink) > 1) throw new Error(`refusing to read ${label} with multiple hard links`);
     if (info.size > maxBytes) throw new Error(`${label} exceeds maximum size (${info.size} > ${maxBytes})`);
     const buffer = Buffer.alloc(info.size);
     let offset = 0;

package/src/shared/admin-auth.d.mts

@@ -1,10 +1,11 @@
-export const ADMIN_AUTH_SCHEME: "hmac-sha256-v1";
+export const ADMIN_AUTH_SCHEME: "device-admin-signature-v1";
 export const ADMIN_AUTH_TTL_SECONDS: number;
 export function adminAuthTranscript(input: {
   origin: unknown;
   method: unknown;
   pathname: unknown;
   bodyHash: unknown;
+  keyId: unknown;
   issuedAt: unknown;
   nonce: unknown;
 }): string;

package/src/shared/admin-auth.mjs

@@ -1,4 +1,4 @@
-export const ADMIN_AUTH_SCHEME = "hmac-sha256-v1";
+export const ADMIN_AUTH_SCHEME = "device-admin-signature-v1";
 export const ADMIN_AUTH_TTL_SECONDS = 5 * 60;
 
 export function adminAuthTranscript(input = {}) {
@@ -6,12 +6,12 @@ export function adminAuthTranscript(input = {}) {
   const method = requiredToken(input.method, "method", /^[A-Z]{3,10}$/);
   const pathname = requiredToken(input.pathname, "pathname", /^\/[A-Za-z0-9/_-]{1,255}$/);
   const bodyHash = requiredToken(input.bodyHash, "body hash", /^[a-f0-9]{64}$/);
+  const keyId = requiredToken(input.keyId, "session key id", /^device_[A-Za-z0-9_-]{32}$/);
   const issuedAt = requiredInteger(input.issuedAt, "issued at");
   const nonce = requiredToken(input.nonce, "nonce", /^[A-Za-z0-9_-]{32,128}$/);
-  return [ADMIN_AUTH_SCHEME, origin, method, pathname, bodyHash, issuedAt, nonce].join("\0");
+  return [ADMIN_AUTH_SCHEME, origin, method, pathname, bodyHash, keyId, issuedAt, nonce].join("\0");
 }
 
-
 function requiredOrigin(value) {
   let url;
   try { url = new URL(String(value || "")); } catch { throw new Error("admin authentication origin is invalid"); }

package/src/shared/device-session-auth.d.mts

@@ -0,0 +1,20 @@
+export const DEVICE_SESSION_CERTIFICATE_SCHEME: "device-session-certificate-v1";
+export const DEVICE_SESSION_MAX_LIFETIME_SECONDS: number;
+
+export function deviceSessionCertificateTranscript(input?: {
+  workerOrigin?: unknown;
+  server?: unknown;
+  version?: unknown;
+  rootKeyId?: unknown;
+  publicJwk?: unknown;
+  issuedAt?: unknown;
+  expiresAt?: unknown;
+  nonce?: unknown;
+}): string;
+
+export function canonicalPublicJwk(value: unknown): {
+  kty: "EC";
+  crv: "P-256";
+  x: string;
+  y: string;
+};

package/src/shared/device-session-auth.mjs

@@ -0,0 +1,51 @@
+export const DEVICE_SESSION_CERTIFICATE_SCHEME = "device-session-certificate-v1";
+export const DEVICE_SESSION_MAX_LIFETIME_SECONDS = 24 * 60 * 60;
+
+export function deviceSessionCertificateTranscript(input = {}) {
+  const publicJwk = canonicalPublicJwk(input.publicJwk);
+  return [
+    DEVICE_SESSION_CERTIFICATE_SCHEME,
+    requiredOrigin(input.workerOrigin),
+    requiredText(input.server, "server", 1, 128),
+    requiredText(input.version, "version", 1, 64),
+    requiredText(input.rootKeyId, "root key id", 16, 128),
+    JSON.stringify(publicJwk),
+    requiredInteger(input.issuedAt, "issued at"),
+    requiredInteger(input.expiresAt, "expires at"),
+    requiredText(input.nonce, "nonce", 24, 128),
+  ].join("\0");
+}
+
+export function canonicalPublicJwk(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("device session public key is invalid");
+  if (value.kty !== "EC" || value.crv !== "P-256" || typeof value.x !== "string" || typeof value.y !== "string" || value.d !== undefined) {
+    throw new Error("device session public key is invalid");
+  }
+  if (!/^[A-Za-z0-9_-]{42,44}$/.test(value.x) || !/^[A-Za-z0-9_-]{42,44}$/.test(value.y)) {
+    throw new Error("device session public key is invalid");
+  }
+  return { crv: "P-256", kty: "EC", x: value.x, y: value.y };
+}
+
+function requiredOrigin(value) {
+  let url;
+  try { url = new URL(String(value || "")); } catch { throw new Error("device session Worker origin is invalid"); }
+  const secure = url.protocol === "https:";
+  const loopback = url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname);
+  if ((!secure && !loopback) || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw new Error("device session Worker origin is invalid");
+  }
+  return url.origin;
+}
+
+function requiredText(value, label, minimum, maximum) {
+  const text = String(value || "");
+  if (text.length < minimum || text.length > maximum || /[\0\r\n]/.test(text)) throw new Error(`device session ${label} is invalid`);
+  return text;
+}
+
+function requiredInteger(value, label) {
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number <= 0) throw new Error(`device session ${label} is invalid`);
+  return String(number);
+}

package/src/shared/server-metadata.json

@@ -18,7 +18,7 @@
     "The local daemon may advertise the full catalog as its capability ceiling. In remote mode, the Worker relays only the intersection allowed by the authenticated account role; a connector host may then expose an even smaller subset that Machine Bridge cannot observe or override.",
     "Use diagnose_runtime to distinguish a request that reached the daemon from local filesystem, process-spawn, shell, managed-job-storage, and resource failures. A tool call blocked before any response cannot be diagnosed by the server.",
     "Never request or return secret-file contents when a local resource alias can be used. Resources are registered through the local machine-mcp CLI; under canonical full policy, generate_ssh_key_resource can generate and register an Ed25519 key without returning private content and may be injected by path, stdin, or environment without entering MCP arguments.",
-    "If execution-class tools are unavailable but write access remains, use stage_job to persist a reviewed plan without running it; the operator can launch it locally with machine-mcp job approve JOB_ID.",
+    "stage_job persists a validated non-running draft only. It is not an approval workflow and cannot be promoted from the terminal; execution requires owner-authorized start_job or an explicit local machine-mcp job submit PLAN.json operation.",
     "For multi-step, remote, long-running, or cleanup-sensitive work, prefer one start_job call with argv steps, job-scoped temporary_files, and idempotent finally_steps. The detached runner continues after MCP disconnects; inspect it with read_job or the local machine-mcp job CLI.",
     "Prefer sending remote shell programs through a process stdin rather than creating remote helper files. If temporary files are necessary, use {{temp:name}} or explicit finally_steps.",
     "Managed-job resource redaction is defense in depth, not a guarantee against transformed or partial secret output. Use capture_output=discard for steps that may echo credentials.",

package/src/shared/tool-catalog.json

@@ -1915,8 +1915,8 @@
   },
   {
     "name": "stage_job",
-    "title": "Stage managed job for local approval",
-    "description": "Validate and persist a managed-job plan without starting any process. Use this when execution tools are unavailable or local operator review is required; launch later with machine-mcp job approve JOB_ID.",
+    "title": "Stage managed job draft",
+    "description": "Validate and persist a durable managed-job draft without starting any process. This is a non-executing record only; a trusted owner client starts work with start_job after reviewing or reconstructing the plan.",
     "availability": "write",
     "annotations": {
       "readOnlyHint": false,

package/src/worker/account-admin.ts

@@ -1,9 +1,10 @@
 import { ADMIN_AUTH_SCHEME, ADMIN_AUTH_TTL_SECONDS, adminAuthTranscript } from "../shared/admin-auth.mjs";
+import { decodeBase64Url, verifyDeviceSessionCertificate, verifyP256Signature } from "./device-session-verifier.ts";
 import { json, methodNotAllowed, parseRequestBody } from "./http.ts";
 import { consumeBoundedNonce } from "./nonce-store.ts";
 import {
   accountByName, createAccount, publicAccount, replaceAccountPassword, revokeAccountCredentials,
-  safeEqual, updateAccount, type AccountRecord, type OAuthStore,
+  updateAccount, type AccountRecord, type OAuthStore,
 } from "./oauth-state.ts";
 
 const BODY_LIMIT_BYTES = 64 * 1024;
@@ -16,18 +17,31 @@ export interface AccountAdminAuthorization {
 
 export async function accountAdminAuthorized(
   request: Request,
-  expected: string,
+  rootPublicKeyJson: string,
+  workerOrigin: string,
+  server: string,
+  version: string,
   now = Math.floor(Date.now() / 1000),
 ): Promise<AccountAdminAuthorization | null> {
-  if (!expected) return null;
+  if (!rootPublicKeyJson) return null;
   const scheme = request.headers.get("X-Bridge-Admin-Scheme") || "";
   const issuedAt = Number(request.headers.get("X-Bridge-Admin-Time"));
   const nonce = request.headers.get("X-Bridge-Admin-Nonce") || "";
   const bodyHash = request.headers.get("X-Bridge-Admin-Body-SHA256") || "";
-  const suppliedSignature = request.headers.get("X-Bridge-Admin-Signature") || "";
-  if (scheme !== ADMIN_AUTH_SCHEME) return null;
+  const keyId = request.headers.get("X-Bridge-Admin-Key") || "";
+  const suppliedSignature = decodeBase64Url(request.headers.get("X-Bridge-Admin-Signature") || "", 64);
+  if (scheme !== ADMIN_AUTH_SCHEME || !suppliedSignature) return null;
   if (!Number.isSafeInteger(issuedAt) || Math.abs(now - issuedAt) > ADMIN_AUTH_TTL_SECONDS) return null;
-  if (!/^[A-Za-z0-9_-]{32,128}$/.test(nonce) || !/^[a-f0-9]{64}$/.test(bodyHash) || !/^[A-Za-z0-9_-]{43}$/.test(suppliedSignature)) return null;
+  if (!/^[A-Za-z0-9_-]{32,128}$/.test(nonce) || !/^[a-f0-9]{64}$/.test(bodyHash) || !/^device_[A-Za-z0-9_-]{32}$/.test(keyId)) return null;
+  const certificate = await verifyDeviceSessionCertificate({
+    encodedCertificate: request.headers.get("X-Bridge-Device-Certificate") || "",
+    rootPublicKeyJson,
+    workerOrigin,
+    server,
+    version,
+    now,
+  });
+  if (!certificate || certificate.sessionKeyId !== keyId) return null;
   let transcript: string;
   try {
     transcript = adminAuthTranscript({
@@ -35,25 +49,18 @@ export async function accountAdminAuthorized(
       method: request.method.toUpperCase(),
       pathname: new URL(request.url).pathname,
       bodyHash,
+      keyId,
       issuedAt,
       nonce,
     });
   } catch {
     return null;
   }
-  const key = await crypto.subtle.importKey(
-    "raw",
-    new TextEncoder().encode(expected),
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"],
-  );
-  const expectedSignature = base64Url(new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(transcript))));
-  if (!(await safeEqual(suppliedSignature, expectedSignature))) return null;
+  if (!(await verifyP256Signature(certificate.sessionPublicJwk, transcript, suppliedSignature))) return null;
   const body = new Uint8Array(await request.clone().arrayBuffer());
   if (body.byteLength > BODY_LIMIT_BYTES) return null;
   const actualBodyHash = hex(new Uint8Array(await crypto.subtle.digest("SHA-256", body)));
-  if (!(await safeEqual(bodyHash, actualBodyHash))) return null;
+  if (bodyHash !== actualBodyHash) return null;
   return { nonce, expiresAt: Math.max(now, issuedAt) + ADMIN_AUTH_TTL_SECONDS };
 }
 
@@ -161,12 +168,6 @@ function activeOwnerCount(store: OAuthStore): number {
   return Object.values(store.accounts).filter((account) => account.active && account.role === "owner").length;
 }
 
-function base64Url(bytes: Uint8Array): string {
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-}
-
 function hex(bytes: Uint8Array): string {
   return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }

package/src/worker/authority.ts

@@ -86,8 +86,15 @@ export function accountAuthoritySnapshot(input: AccountIdentity & {
 
 export function decorateProjectOverview(value: unknown, account: AccountIdentity): unknown {
   if (!isRecord(value)) return value;
-  const daemonPolicy = isDaemonPolicy(value.policy) ? value.policy : null;
-  const daemonTools = Array.isArray(value.tools) ? value.tools.filter((item): item is string => typeof item === "string") : [];
+  const daemonPolicy = isDaemonPolicy(value.daemonPolicy)
+    ? value.daemonPolicy
+    : isDaemonPolicy(value.policy)
+      ? value.policy
+      : null;
+  const daemonToolSource = Array.isArray(value.daemonTools) ? value.daemonTools : value.tools;
+  const daemonTools = Array.isArray(daemonToolSource)
+    ? daemonToolSource.filter((item): item is string => typeof item === "string")
+    : [];
   const effectiveTools = ["server_info", ...accountRoleToolNames(account.role, daemonTools)];
   const authority = accountAuthoritySnapshot({ ...account, daemonPolicy, effectiveTools });
   return {