mlclaw 0.3.7 → 0.4.0

package/dist/mlclaw-space-runtime.js

@@ -12,7 +12,7 @@ import process2 from "node:process";
 
 // src/mlclaw-space-runtime/config.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 
 // src/hf-state-sync/paths.ts
 var DEFAULT_BUCKET_PREFIX = "openclaw-state";
@@ -5039,6 +5039,18 @@ function validatedBrokerPayload(value, schema, label) {
   return parsed.data;
 }
 
+// src/mlclaw-space-runtime/local-access.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+var LOCAL_ACCESS_CONTEXT = "mlclaw-local-access-v1";
+function deriveLocalAccessToken(sessionSecret) {
+  return createHmac("sha256", sessionSecret).update(LOCAL_ACCESS_CONTEXT).digest("base64url");
+}
+function localAccessTokenMatches(candidate, expected) {
+  const left = Buffer.from(candidate);
+  const right = Buffer.from(expected);
+  return left.length === right.length && timingSafeEqual(left, right);
+}
+
 // src/mlclaw-space-runtime/config.ts
 function loadConfig(env = process.env) {
   const port = integer(env.PORT ?? env.MLCLAW_SPACE_PORT, 7860);
@@ -5056,13 +5068,18 @@ function loadConfig(env = process.env) {
     spaceCreatorUserId
   });
   const owner = ownerFromSpaceId(spaceId);
+  const stateBucket = trim(env.OPENCLAW_HF_STATE_BUCKET);
+  const gatewayLocation = trim(env.MLCLAW_GATEWAY_LOCATION);
+  const localAccessUser = gatewayLocation === "local" ? trim(env.MLCLAW_LOCAL_ACCESS_USER) ?? ownerFromRepoId(stateBucket) : void 0;
   const configuredAllowedUsers = splitUsers(env.MLCLAW_ALLOWED_USERS ?? env.ALLOWED_USERS);
   const configuredAdmins = splitUsers(env.MLCLAW_ADMINS);
-  const resolvedAdmins = uniqueUsers(
-    configuredAdmins.length > 0 ? configuredAdmins : owner ? [owner] : configuredAllowedUsers.slice(0, 1)
-  );
+  const resolvedAdmins = uniqueUsers([
+    ...configuredAdmins.length > 0 ? configuredAdmins : owner ? [owner] : configuredAllowedUsers.slice(0, 1),
+    ...localAccessUser ? [localAccessUser] : []
+  ]);
   const allowedUsers = uniqueUsers([...configuredAllowedUsers, ...resolvedAdmins, ...owner ? [owner] : []]);
   const publicUrl = publicUrlFromEnv(env, port);
+  const accessOrigins = accessOriginsFromEnv(env, publicUrl);
   const sessionSecret = trim(env.MLCLAW_SESSION_SECRET ?? env.SESSION_SECRET) ?? randomBytes(48).toString("base64url");
   const configuredCredentialKey = trim(env.MLCLAW_CREDENTIAL_KEY);
   if (mode === "app" && !configuredCredentialKey) {
@@ -5087,6 +5104,7 @@ function loadConfig(env = process.env) {
     openclawUid: integer(env.MLCLAW_OPENCLAW_UID, 1e3),
     openclawGid: integer(env.MLCLAW_OPENCLAW_GID, 1e3),
     publicUrl,
+    accessOrigins,
     providerUrl: trim(env.OPENID_PROVIDER_URL) ?? "https://huggingface.co",
     oauthClientId: trim(env.OAUTH_CLIENT_ID),
     oauthClientSecret: trim(env.OAUTH_CLIENT_SECRET),
@@ -5095,6 +5113,7 @@ function loadConfig(env = process.env) {
     credentialKey,
     credentialKeyGenerated: !configuredCredentialKey,
     cookieSecure: env.MLCLAW_COOKIE_SECURE === "0" ? false : !publicUrl.startsWith("http://"),
+    sessionCookieName: gatewayLocation === "local" ? localSessionCookieName(trim(env.MLCLAW_RUNTIME_ID) ?? publicUrl) : SESSION_COOKIE_PREFIX,
     spaceId,
     canonicalSpaceId,
     canonicalCreatorUserId,
@@ -5102,6 +5121,8 @@ function loadConfig(env = process.env) {
     allowedUsers,
     adminUsers: resolvedAdmins,
     allowAnySignedIn: env.MLCLAW_ALLOW_ANY_SIGNED_IN === "1" || env.MLCLAW_ALLOW_ANY_SIGNED_IN === "true",
+    localAccessUser,
+    localAccessToken: gatewayLocation === "local" && localAccessUser ? deriveLocalAccessToken(sessionSecret) : void 0,
     mode,
     hfToken: readOptionalSecret(trim(env.MLCLAW_TRUSTED_HF_TOKEN_FILE)) ?? trim(env.HF_TOKEN ?? env.HUGGINGFACE_HUB_TOKEN),
     routerToken: trim(env.MLCLAW_ROUTER_TOKEN ?? env.HF_ROUTER_TOKEN),
@@ -5127,10 +5148,10 @@ function loadConfig(env = process.env) {
     model,
     modelChoices: runtimeSettings2.modelChoices ?? parseModelChoicesEnv(env.MLCLAW_MODEL_CHOICES, model),
     routerModelsUrl: trim(env.MLCLAW_ROUTER_MODELS_URL) ?? "https://router.huggingface.co/v1/models",
-    stateBucket: trim(env.OPENCLAW_HF_STATE_BUCKET),
+    stateBucket,
     stateMountDir,
     statePrefix,
-    gatewayLocation: trim(env.MLCLAW_GATEWAY_LOCATION),
+    gatewayLocation,
     runtimeImage: trim(env.MLCLAW_RUNTIME_IMAGE),
     runtimeId: trim(env.MLCLAW_RUNTIME_ID),
     templateRev: trim(env.MLCLAW_TEMPLATE_REV),
@@ -5138,6 +5159,30 @@ function loadConfig(env = process.env) {
     branding: resolveBranding(env, agentName)
   };
 }
+var SESSION_COOKIE_PREFIX = "mlclaw_session";
+function localSessionCookieName(identity) {
+  return `${SESSION_COOKIE_PREFIX}_${createHash("sha256").update(identity).digest("hex").slice(0, 12)}`;
+}
+function accessOriginsFromEnv(env, publicUrl) {
+  const configured = (env.MLCLAW_ACCESS_ORIGINS ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+  if (configured.length > 8) {
+    throw new Error("MLCLAW_ACCESS_ORIGINS supports at most 8 origins");
+  }
+  const origins = [.../* @__PURE__ */ new Set([publicUrl, ...configured.map(parseAccessOrigin)])];
+  if (origins.length > 8) {
+    throw new Error("MLCLAW_ACCESS_ORIGINS supports at most 8 origins including MLCLAW_PUBLIC_URL");
+  }
+  return origins;
+}
+function parseAccessOrigin(value) {
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.hostname.includes("*") || url.pathname !== "/" || url.search || url.hash) {
+    throw new Error(
+      "MLCLAW_ACCESS_ORIGINS entries must be HTTP origins without credentials, wildcard hosts, paths, queries, or fragments"
+    );
+  }
+  return url.origin;
+}
 function readOptionalSecret(file) {
   if (!file) {
     return void 0;
@@ -5172,6 +5217,14 @@ function resolveMode(params) {
   return params.canonicalCreatorUserId === params.spaceCreatorUserId ? "template" : "app";
 }
 function publicUrlFromEnv(env, port) {
+  const explicit = trim(env.MLCLAW_PUBLIC_URL);
+  if (explicit) {
+    const url = new URL(explicit);
+    if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("MLCLAW_PUBLIC_URL must be one HTTP origin without credentials, path, query, or fragment");
+    }
+    return url.origin;
+  }
   const host = trim(env.SPACE_HOST);
   if (host) {
     return host.startsWith("http") ? host.replace(/\/+$/, "") : `https://${host.replace(/\/+$/, "")}`;
@@ -5179,7 +5232,10 @@ function publicUrlFromEnv(env, port) {
   return `http://127.0.0.1:${port}`;
 }
 function ownerFromSpaceId(spaceId) {
-  const owner = spaceId?.split("/")[0]?.trim();
+  return ownerFromRepoId(spaceId);
+}
+function ownerFromRepoId(repoId) {
+  const owner = repoId?.split("/")[0]?.trim();
   return owner || void 0;
 }
 function integer(value, fallback) {
@@ -7322,7 +7378,7 @@ var Hono2 = class extends Hono {
 };
 
 // src/mlclaw-space-runtime/csrf.ts
-import { createHmac, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
+import { createHmac as createHmac2, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 var CSRF_TTL_SECONDS = 60 * 60;
 function createCsrfToken(params) {
   const now = params.now ?? Date.now();
@@ -7355,16 +7411,16 @@ function verifyCsrfToken(params) {
   return payload.username === params.username && typeof payload.exp === "number" && payload.exp > now && typeof payload.nonce === "string" && payload.nonce.length > 0;
 }
 function sign(value, secret) {
-  return createHmac("sha256", secret).update(value).digest("base64url");
+  return createHmac2("sha256", secret).update(value).digest("base64url");
 }
 function signatureMatches(a, b) {
   const left = Buffer.from(a);
   const right = Buffer.from(b);
-  return left.length === right.length && timingSafeEqual(left, right);
+  return left.length === right.length && timingSafeEqual2(left, right);
 }
 
 // src/mlclaw-space-runtime/delegated-brokerkit.ts
-import { createHash, createHmac as createHmac2, randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash2, createHmac as createHmac3, randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
 
 // src/mlclaw-space-runtime/delegated-revisions.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
@@ -7449,7 +7505,7 @@ var DelegatedBrokerKit = class {
     this.registry = registry;
     this.now = now;
     this.sourceDeadlineMs = sourceDeadlineMs;
-    this.key = createHmac2("sha256", sessionSecret).update("mlclaw/brokerkit-delegated-web/v1", "utf8").digest();
+    this.key = createHmac3("sha256", sessionSecret).update("mlclaw/brokerkit-delegated-web/v1", "utf8").digest();
   }
   key;
   handles = /* @__PURE__ */ new Map();
@@ -7666,7 +7722,7 @@ var DelegatedBrokerKit = class {
     this.handlesByIdentity.delete(requestIdentity(record.sourceId, record.requestId, record.revision));
   }
   sign(encoded) {
-    return createHmac2("sha256", this.key).update(encoded, "utf8").digest("base64url");
+    return createHmac3("sha256", this.key).update(encoded, "utf8").digest("base64url");
   }
 };
 async function decideWithRecovery(source, requestId, action, decision) {
@@ -7740,7 +7796,7 @@ function handleExpiry(request) {
   return request.pending_expires_at ?? request.active_expires_at ?? "";
 }
 function decisionKey(record, action, actor) {
-  return createHash("sha256").update(
+  return createHash2("sha256").update(
     ["mlclaw-brokerkit-decision-v1", record.sourceId, record.requestId, String(record.revision), action, actor].join(
       "\0"
     ),
@@ -7813,7 +7869,7 @@ function validTokenNonce(record) {
 function safeEqual(left, right) {
   const a = Buffer.from(left, "utf8");
   const b = Buffer.from(right, "utf8");
-  return a.length === b.length && timingSafeEqual2(a, b);
+  return a.length === b.length && timingSafeEqual3(a, b);
 }
 function safeSourceError(error) {
   const code = error instanceof BrokerOperatorError ? error.code : error instanceof DelegatedBrokerKitError ? error.code : void 0;
@@ -7973,7 +8029,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 
 // src/mlclaw-space-runtime/mcp-integrations.ts
-import { createHmac as createHmac3, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { createHmac as createHmac4, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
 import http from "node:http";
 import { Readable } from "node:stream";
 var MAX_REQUEST_BYTES = 16 * 1024 * 1024;
@@ -8237,7 +8293,7 @@ var ResearchRpcError = class extends Error {
   }
 };
 function deriveInternalToken(secret) {
-  return createHmac3("sha256", secret).update("mlclaw:mcp-integrations:v1").digest("base64url");
+  return createHmac4("sha256", secret).update("mlclaw:mcp-integrations:v1").digest("base64url");
 }
 function managedMcpServerConfig(config2) {
   const headers = { [INTERNAL_HEADER]: deriveInternalToken(config2.sessionSecret) };
@@ -8467,7 +8523,7 @@ function validInternalToken(value, expected) {
   }
   const actualBuffer = Buffer.from(value);
   const expectedBuffer = Buffer.from(expected);
-  return actualBuffer.length === expectedBuffer.length && timingSafeEqual3(actualBuffer, expectedBuffer);
+  return actualBuffer.length === expectedBuffer.length && timingSafeEqual4(actualBuffer, expectedBuffer);
 }
 function requestHeader(headers, name) {
   const value = headers[name];
@@ -8547,7 +8603,7 @@ async function configureOpenClawGateway(config2) {
   gateway.controlUi = {
     ...typeof gateway.controlUi === "object" && gateway.controlUi ? gateway.controlUi : {},
     dangerouslyDisableDeviceAuth: true,
-    allowedOrigins: [config2.publicUrl],
+    allowedOrigins: config2.accessOrigins,
     embedSandbox: "scripts"
   };
   configureOpenClawModels(openclawConfig, config2);
@@ -8860,7 +8916,9 @@ function validateOpenAiApiKey(value) {
 
 // src/mlclaw-space-runtime/pages.ts
 function templatePage(config2) {
-  return page("ML Claw", `
+  return page(
+    "ML Claw",
+    `
     <main>
       <img src="/assets/mlclaw.svg" alt="ML Claw" class="logo">
       <h1>ML Claw</h1>
@@ -8880,30 +8938,85 @@ function templatePage(config2) {
       <p class="muted">Manual duplication is for development or advanced setup only.</p>
       <p class="muted">Source Space: ${escapeHtml(config2.spaceId ?? config2.canonicalSpaceId)}</p>
     </main>
-  `);
+  `
+  );
 }
 function loginPage(config2, message, next = "/") {
   const oauthReady = Boolean(config2.oauthClientId && config2.oauthClientSecret);
   const loginPath = next === "/" ? "/oauth/login" : `/oauth/login?next=${encodeURIComponent(next)}`;
   const loginHref = new URL(loginPath, config2.publicUrl).toString();
-  return page(`${config2.branding.name} Login`, `
+  return page(
+    `${config2.branding.name} Login`,
+    `
     <main>
       <img src="/assets/hf-logo.svg" alt="Hugging Face" class="logo">
       <h1>${escapeHtml(config2.branding.name)}</h1>
       ${message ? `<p class="notice">${escapeHtml(message)}</p>` : ""}
       ${oauthReady ? `<a class="button" href="${escapeHtml(loginHref)}" target="_blank" rel="noopener">Sign in with Hugging Face</a>` : `<p class="notice">Hugging Face OAuth is not configured for this Space. Update the Space README metadata to include <code>hf_oauth: true</code>, then rebuild.</p>`}
     </main>
-  `);
+  `
+  );
+}
+function localLoginPage(config2) {
+  return page(
+    `${config2.branding.name} Local Access`,
+    `
+    <main>
+      <img src="/assets/mlclaw.svg" alt="ML Claw" class="logo">
+      <h1>${escapeHtml(config2.branding.name)}</h1>
+      <p class="muted">Use the private access link printed by the ML Claw CLI.</p>
+      <form id="local-login-form">
+        <label for="local-access-token">Local access code</label>
+        <input id="local-access-token" name="token" type="password" autocomplete="off" required>
+        <button class="button" type="submit">Open gateway</button>
+      </form>
+      <p id="local-login-status" class="notice" role="status"></p>
+    </main>
+    <script>
+      const form = document.getElementById("local-login-form");
+      const input = document.getElementById("local-access-token");
+      const status = document.getElementById("local-login-status");
+      const submit = async () => {
+        status.textContent = "Signing in...";
+        const response = await fetch("/mlclaw/api/local-session", {
+          method: "POST",
+          credentials: "same-origin",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ token: input.value }),
+        });
+        input.value = "";
+        if (response.ok) {
+          location.replace("/");
+          return;
+        }
+        status.textContent = "The local access link is invalid. Run mlclaw gateway status again.";
+      };
+      form.addEventListener("submit", (event) => {
+        event.preventDefault();
+        submit().catch(() => { status.textContent = "The local gateway could not be reached."; });
+      });
+      const token = location.hash.slice(1);
+      if (token) {
+        history.replaceState(null, "", location.pathname);
+        input.value = token;
+        submit().catch(() => { status.textContent = "The local gateway could not be reached."; });
+      }
+    </script>
+  `
+  );
 }
 function unauthorizedPage(username) {
-  return page("ML Claw Access", `
+  return page(
+    "ML Claw Access",
+    `
     <main>
       <h1>Access not allowed</h1>
       <p>The signed-in Hugging Face account <strong>${escapeHtml(username)}</strong> is not allowed to operate this Space.</p>
       <p class="muted">Set <code>MLCLAW_ALLOWED_USERS</code> to a comma-separated list of usernames, then restart the Space.</p>
       <a class="button secondary" href="/mlclaw/logout">Sign out</a>
     </main>
-  `);
+  `
+  );
 }
 function page(title, body) {
   return `<!doctype html>
@@ -9120,7 +9233,7 @@ function positiveNumber2(value) {
 }
 
 // src/mlclaw-space-runtime/cookies.ts
-import { createHmac as createHmac4, randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
+import { createHmac as createHmac5, randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual5 } from "node:crypto";
 function createSignedCookie(options, payload) {
   const body = Buffer.from(JSON.stringify({
     ...payload,
@@ -9172,12 +9285,12 @@ function randomState() {
   return randomBytes6(24).toString("base64url");
 }
 function sign2(value, secret) {
-  return createHmac4("sha256", secret).update(value).digest("base64url");
+  return createHmac5("sha256", secret).update(value).digest("base64url");
 }
 function signatureMatches2(a, b) {
   const left = Buffer.from(a);
   const right = Buffer.from(b);
-  return left.length === right.length && timingSafeEqual4(left, right);
+  return left.length === right.length && timingSafeEqual5(left, right);
 }
 function parseCookies(header) {
   const cookies = /* @__PURE__ */ new Map();
@@ -9220,33 +9333,39 @@ var STATE_COOKIE = "mlclaw_oauth";
 var SESSION_TTL_SECONDS = 60 * 60 * 24 * 30;
 var STATE_TTL_SECONDS = 60 * 10;
 function createSessionCookie(params) {
-  return createSignedCookie({
-    name: SESSION_COOKIE,
-    secret: params.sessionSecret,
-    maxAgeSeconds: SESSION_TTL_SECONDS,
-    secure: params.secure
-  }, { username: params.username });
+  return createSignedCookie(
+    {
+      name: params.cookieName ?? SESSION_COOKIE,
+      secret: params.sessionSecret,
+      maxAgeSeconds: SESSION_TTL_SECONDS,
+      secure: params.secure
+    },
+    { username: params.username }
+  );
 }
 function createOauthStateCookie(params) {
   const state = params.state ?? randomState();
   return {
     state,
-    cookie: createSignedCookie({
-      name: STATE_COOKIE,
-      secret: params.sessionSecret,
-      maxAgeSeconds: STATE_TTL_SECONDS,
-      secure: params.secure
-    }, { state, next: normalizeNext(params.next), intent: params.intent ?? "login" })
+    cookie: createSignedCookie(
+      {
+        name: STATE_COOKIE,
+        secret: params.sessionSecret,
+        maxAgeSeconds: STATE_TTL_SECONDS,
+        secure: params.secure
+      },
+      { state, next: normalizeNext(params.next), intent: params.intent ?? "login" }
+    )
   };
 }
-function clearSessionCookie(secure) {
-  return clearCookie(SESSION_COOKIE, secure);
+function clearSessionCookie(secure, cookieName = SESSION_COOKIE) {
+  return clearCookie(cookieName, secure);
 }
 function clearOauthStateCookie(secure) {
   return clearCookie(STATE_COOKIE, secure);
 }
-function readSession(cookieHeader, sessionSecret) {
-  return verifySignedCookie(cookieHeader, SESSION_COOKIE, sessionSecret);
+function readSession(cookieHeader, sessionSecret, cookieName = SESSION_COOKIE) {
+  return verifySignedCookie(cookieHeader, cookieName, sessionSecret);
 }
 function readOauthState(cookieHeader, sessionSecret) {
   return verifySignedCookie(cookieHeader, STATE_COOKIE, sessionSecret);
@@ -9564,6 +9683,7 @@ function createSpaceRuntimeApp(config2, controls) {
   const allowBrokerKitSummary = fixedWindowRateLimit(12, 6e4);
   const allowDelegatedEvents = fixedWindowRateLimit(60, 6e4);
   const allowSummaryEvents = fixedWindowRateLimit(60, 6e4);
+  const allowLocalLogin = fixedWindowRateLimit(10, 6e4);
   const openAiCredentials = new OpenAiCredentialStore(config2.openaiCredentialStoreFile, config2.credentialKey);
   app.get("/health", (c) => health(c, config2, controls));
   app.get("/healthz", (c) => health(c, config2, controls));
@@ -9599,10 +9719,58 @@ function createSpaceRuntimeApp(config2, controls) {
   );
   app.get("/oauth/login", (c) => handleOauthLogin(c, config2));
   app.get("/oauth/callback", (c) => handleOauthCallback(c, config2, controls));
+  app.get("/mlclaw/local-login", (c) => {
+    if (!config2.localAccessUser || !config2.localAccessToken || config2.gatewayLocation !== "local") {
+      return c.text("not found\n", 404);
+    }
+    c.header(
+      "content-security-policy",
+      "default-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; base-uri 'none'; frame-ancestors 'none'; form-action 'self'"
+    );
+    c.header("cache-control", "no-store");
+    c.header("referrer-policy", "no-referrer");
+    return c.html(localLoginPage(config2));
+  });
+  app.post("/mlclaw/api/local-session", async (c) => {
+    if (!config2.localAccessUser || !config2.localAccessToken || config2.gatewayLocation !== "local") {
+      return c.json({ ok: false, error: "not found" }, 404);
+    }
+    const origin = c.req.header("origin");
+    if (!origin || !config2.accessOrigins.includes(origin) || !allowLocalLogin(origin)) {
+      return c.json({ ok: false, error: "access denied" }, 403);
+    }
+    const contentLength = Number.parseInt(c.req.header("content-length") ?? "0", 10);
+    if (contentLength > 512 || !(c.req.header("content-type") ?? "").startsWith("application/json")) {
+      return c.json({ ok: false, error: "invalid request" }, 400);
+    }
+    const text = await c.req.text();
+    if (text.length > 512) {
+      return c.json({ ok: false, error: "invalid request" }, 400);
+    }
+    let token;
+    try {
+      token = JSON.parse(text).token;
+    } catch {
+      return c.json({ ok: false, error: "invalid request" }, 400);
+    }
+    if (typeof token !== "string" || !localAccessTokenMatches(token, config2.localAccessToken)) {
+      return c.json({ ok: false, error: "access denied" }, 403);
+    }
+    c.header(
+      "set-cookie",
+      createSessionCookie({
+        username: config2.localAccessUser,
+        sessionSecret: config2.sessionSecret,
+        secure: origin.startsWith("https://"),
+        cookieName: config2.sessionCookieName
+      })
+    );
+    return c.json({ ok: true });
+  });
   app.get("/login", (c) => c.html(loginPage(config2, void 0, normalizeNext(c.req.query("next") ?? "/"))));
-  app.get("/logout", (c) => logoutResponse(config2, false));
-  app.get("/mlclaw/logout", (c) => logoutResponse(config2, false));
-  app.post("/mlclaw/api/logout", (c) => logoutResponse(config2, true));
+  app.get("/logout", (c) => logoutResponse(c, config2, false));
+  app.get("/mlclaw/logout", (c) => logoutResponse(c, config2, false));
+  app.post("/mlclaw/api/logout", (c) => logoutResponse(c, config2, true));
   app.get("/mlclaw/assets/*", async (c) => {
     const relative = c.req.path.slice("/mlclaw/assets/".length);
     const safe = safeRelativePath(relative);
@@ -9903,7 +10071,7 @@ function handleOauthLogin(c, config2) {
   if (!config2.oauthClientId || !config2.oauthClientSecret) {
     return c.html(loginPage(config2, "Hugging Face OAuth is not configured.", next));
   }
-  const session = readSession(c.req.header("cookie"), config2.sessionSecret);
+  const session = readSession(c.req.header("cookie"), config2.sessionSecret, config2.sessionCookieName);
   const integrationsRequested = c.req.query("intent") === "integrations";
   const intent = integrationsRequested && session && isAdmin(config2, session.username) ? "integrations" : "login";
   const { state, cookie } = createOauthStateCookie({
@@ -9948,7 +10116,7 @@ async function handleOauthCallback(c, config2, controls) {
     return c.html(loginPage(config2, "Hugging Face sign-in failed. Try again."), 401);
   }
   if (stateCookie.intent === "integrations") {
-    const session = readSession(c.req.header("cookie"), config2.sessionSecret);
+    const session = readSession(c.req.header("cookie"), config2.sessionSecret, config2.sessionCookieName);
     if (!session || !isAdmin(config2, session.username) || session.username !== identity.username) {
       return c.html(loginPage(config2, "Integration authorization requires the signed-in ML Claw administrator."), 403);
     }
@@ -9971,7 +10139,8 @@ async function handleOauthCallback(c, config2, controls) {
     createSessionCookie({
       username: identity.username,
       sessionSecret: config2.sessionSecret,
-      secure: config2.cookieSecure
+      secure: config2.cookieSecure,
+      cookieName: config2.sessionCookieName
     })
   );
   headers.append("set-cookie", clearOauthStateCookie(config2.cookieSecure));
@@ -10042,9 +10211,11 @@ function trustedBrokerKitHeaders(mode, origin) {
   if (asset) headers.set("access-control-allow-origin", "null");
   return headers;
 }
-function logoutResponse(config2, json) {
+function logoutResponse(c, config2, json) {
   const headers = new Headers();
-  headers.append("set-cookie", clearSessionCookie(config2.cookieSecure));
+  const origin = c.req.header("origin");
+  const secure = origin && config2.accessOrigins.includes(origin) ? origin.startsWith("https://") : config2.cookieSecure;
+  headers.append("set-cookie", clearSessionCookie(secure, config2.sessionCookieName));
   if (json) {
     headers.set("content-type", "application/json; charset=utf-8");
     return new Response(`${JSON.stringify({ ok: true })}
@@ -10054,7 +10225,7 @@ function logoutResponse(config2, json) {
   return new Response(null, { status: 302, headers });
 }
 function requireAllowed(c, config2) {
-  const session = readSession(c.req.header("cookie"), config2.sessionSecret);
+  const session = readSession(c.req.header("cookie"), config2.sessionSecret, config2.sessionCookieName);
   if (!session) {
     return unauthenticated(c, config2);
   }
@@ -10160,7 +10331,10 @@ function unauthenticated(c, config2) {
     return c.json({ ok: false, error: "authentication required" }, 401);
   }
   if (isBrowserNavigation(c)) {
-    return c.redirect(`/login?next=${encodeURIComponent(next)}`, 302);
+    return c.redirect(
+      config2.gatewayLocation === "local" ? "/mlclaw/local-login" : `/login?next=${encodeURIComponent(next)}`,
+      302
+    );
   }
   return c.html(loginPage(config2, void 0, next), 401);
 }
@@ -10739,7 +10913,7 @@ async function proxyHttp(req, res, config2, identity) {
     delete headers["accept-encoding"];
     delete headers["Accept-Encoding"];
   }
-  addTrustedProxyHeaders(headers, config2, identity);
+  addTrustedProxyHeaders(headers, config2, identity, requestAccessOrigin(req, config2));
   const upstream = http2.request(
     {
       host: config2.openclawHost,
@@ -10797,7 +10971,7 @@ function proxyWebSocket(req, socket, head, config2, identity) {
     headers.host = `${config2.openclawHost}:${config2.openclawPort}`;
     headers.connection = "Upgrade";
     headers.upgrade = req.headers.upgrade ?? "websocket";
-    addTrustedProxyHeaders(headers, config2, identity);
+    addTrustedProxyHeaders(headers, config2, identity, requestAccessOrigin(req, config2));
     upstream.write(`${req.method ?? "GET"} ${req.url ?? "/"} HTTP/${req.httpVersion}\r
 `);
     for (const [key, value] of Object.entries(headers)) {
@@ -10841,19 +11015,26 @@ function sanitizeHeaders(headers) {
     if (HOP_BY_HOP_HEADERS.has(lower)) {
       continue;
     }
-    if (lower.startsWith("x-forwarded-") || lower.startsWith("x-openclaw-") || lower === "authorization") {
+    if (lower.startsWith("x-forwarded-") || lower.startsWith("x-openclaw-") || lower.startsWith("tailscale-") || lower === "authorization") {
       continue;
     }
     out[key] = value;
   }
   return out;
 }
-function addTrustedProxyHeaders(headers, config2, identity) {
+function addTrustedProxyHeaders(headers, config2, identity, accessOrigin) {
   headers["x-forwarded-user"] = identity.username;
-  headers["x-forwarded-proto"] = config2.publicUrl.startsWith("https://") ? "https" : "http";
-  headers["x-forwarded-host"] = new URL(config2.publicUrl).host;
+  headers["x-forwarded-proto"] = accessOrigin.startsWith("https://") ? "https" : "http";
+  headers["x-forwarded-host"] = new URL(accessOrigin).host;
   headers["x-openclaw-scopes"] = resolveControlUiScopes(config2, identity).join(",");
 }
+function requestAccessOrigin(req, config2) {
+  const host = req.headers.host?.trim().toLowerCase();
+  if (!host) {
+    return config2.publicUrl;
+  }
+  return config2.accessOrigins.find((origin) => new URL(origin).host.toLowerCase() === host) ?? config2.publicUrl;
+}
 function resolveControlUiScopes(config2, identity) {
   return config2.adminUsers.includes(identity.username) ? ADMIN_CONTROL_UI_SCOPES : USER_CONTROL_UI_SCOPES;
 }
@@ -10934,7 +11115,7 @@ var SpaceRuntimeServer = class {
     server2.on("upgrade", (req, socket, head) => {
       const netSocket = socket;
       try {
-        const session = readSession(req.headers.cookie, this.config.sessionSecret);
+        const session = readSession(req.headers.cookie, this.config.sessionSecret, this.config.sessionCookieName);
         if (!session || !this.isAllowed(session.username)) {
           rejectWebSocket(netSocket);
           return;
@@ -11011,7 +11192,7 @@ var SpaceRuntimeServer = class {
         res.off("close", abortRequest);
       }
     }
-    const session = readSession(req.headers.cookie, this.config.sessionSecret);
+    const session = readSession(req.headers.cookie, this.config.sessionSecret, this.config.sessionCookieName);
     if (!session) {
       this.sendUnauthenticated(req, res, url);
       return;
@@ -11091,6 +11272,10 @@ var SpaceRuntimeServer = class {
   }
   sendUnauthenticated(req, res, url) {
     const next = normalizeNext(`${url.pathname}${url.search}`);
+    if (this.config.gatewayLocation === "local" && isBrowserNavigation2(req)) {
+      this.sendRedirect(res, "/mlclaw/local-login");
+      return;
+    }
     if (url.pathname === "/" && (req.method === "GET" || req.method === "HEAD")) {
       this.sendHtml(res, loginPage(this.config, void 0, next));
       return;