@cjhyy/code-shell-server 0.9.36 → 0.9.38

package/dist/project-runtime/cloud-browser-auth.js

@@ -0,0 +1,352 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { isCloudAccountOrigin } from "./account-binding.js";
+import { cloudManagementSessionView } from "./cloud-account-auth.js";
+import { ProjectRegistryError } from "./registry.js";
+/** Browser bootstrap is separate from the native, single-operator v2 API. */
+export const CLOUD_BROWSER_AUTHORITY_VERSION = 1;
+export const CLOUD_BROWSER_COOKIE = "cs_cloud_browser";
+const TOKEN = /^[A-Za-z0-9_-]{43}$/;
+const UUID = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/;
+const hash = (token) => createHash("sha256").update(token).digest("hex");
+function principalValid(value) {
+    return (value &&
+        Object.keys(value).sort().join() ===
+            ["accountOrigin", "accountId", "sessionId", "rootSessionId", "authorityEpoch", "expiresAt"]
+                .sort()
+                .join() &&
+        isCloudAccountOrigin(value.accountOrigin) &&
+        UUID.test(value.accountId) &&
+        UUID.test(value.sessionId) &&
+        value.sessionId === value.rootSessionId &&
+        UUID.test(value.authorityEpoch) &&
+        Number.isSafeInteger(value.expiresAt));
+}
+/** Every principal is independently scoped; a login never claims legacy projects. */
+export function createCloudBrowserAuth(options) {
+    if (!isCloudAccountOrigin(options.publicOrigin) ||
+        !isCloudAccountOrigin(options.accountOrigin) ||
+        options.authority.accountOrigin !== options.accountOrigin ||
+        !UUID.test(options.installationId) ||
+        !UUID.test(options.managementEpoch))
+        throw new Error("Cloud browser authority requires a fixed installation and Account origin.");
+    const now = options.now ?? Date.now;
+    const entries = new Map();
+    const reading = new Set();
+    let closed = false, exchanging = 0, attempts = { until: now() + 60_000, count: 0 };
+    function revoke(entry) {
+        if (entry.revoked)
+            return;
+        entry.revoked = true;
+        if (entries.get(entry.session.id) === entry)
+            entries.delete(entry.session.id);
+        options.onRevoke(entry.session.id, entry.session.ownerId);
+    }
+    function entryFor(session) {
+        if (closed || !("kind" in session))
+            return;
+        const entry = entries.get(session.id);
+        if (!entry || entry.revoked || entry.session.expiresAt <= now()) {
+            if (entry)
+                revoke(entry);
+            return;
+        }
+        // A same-root renewal may extend the deadline while a lifecycle operation
+        // still holds an older safe session snapshot. Every identity field is fixed.
+        if (Object.keys(entry.session).some((key) => key !== "expiresAt" &&
+            entry.session[key] !==
+                session[key]) ||
+            !Number.isSafeInteger(session.expiresAt) ||
+            session.expiresAt <= 0 ||
+            session.expiresAt > entry.session.expiresAt)
+            return;
+        return entry;
+    }
+    async function revalidate(session, attempt = 0) {
+        const entry = entryFor(session);
+        if (!entry)
+            throw new ProjectRegistryError(401, "Cloud 工作台登录已失效。");
+        try {
+            const current = await options.authority.validate({ ...entry.principal }, options.installationId);
+            if (entries.get(session.id) !== entry) {
+                if (attempt === 0)
+                    return revalidate(session, 1);
+                throw new Error("Cloud browser authority changed while validating.");
+            }
+            if (!principalValid(current) ||
+                current.expiresAt <= now() ||
+                Object.keys(current).some((key) => current[key] !==
+                    entry.principal[key]) ||
+                !entryFor(session))
+                throw new Error("Cloud browser authority changed.");
+        }
+        catch {
+            // A delayed validation of the preceding token/root deadline must never
+            // revoke a newer, independently redeemed cookie for the same scope.
+            if (entries.get(session.id) !== entry) {
+                if (attempt === 0)
+                    return revalidate(session, 1);
+            }
+            else
+                revoke(entry);
+            throw new ProjectRegistryError(401, "Cloud 工作台授权已失效，请重新登录。");
+        }
+    }
+    function uniqueHeader(req, name) {
+        return (req.rawHeaders.filter((key, index) => index % 2 === 0 && key.toLowerCase() === name).length <=
+            1);
+    }
+    function isOriginAllowed(req) {
+        if (!uniqueHeader(req, "host") ||
+            !uniqueHeader(req, "origin") ||
+            !uniqueHeader(req, "cookie") ||
+            !uniqueHeader(req, "sec-fetch-site") ||
+            !uniqueHeader(req, "content-type") ||
+            req.headers.host !== new URL(options.publicOrigin).host ||
+            req.headers.authorization !== undefined ||
+            (req.headers.origin !== undefined && req.headers.origin !== options.publicOrigin) ||
+            ![undefined, "same-origin", "none"].includes(req.headers["sec-fetch-site"]))
+            return false;
+        if ((req.headers.cookie
+            ?.split(";")
+            .filter((part) => part.trim().startsWith(`${CLOUD_BROWSER_COOKIE}=`)).length ?? 0) > 1)
+            return false;
+        // Unsafe browser requests require both independently supplied browser checks.
+        // JSON alone is not the CSRF boundary and no CORS exception is installed.
+        return (["GET", "HEAD"].includes(req.method ?? "") ||
+            (req.headers.origin === options.publicOrigin &&
+                req.headers["sec-fetch-site"] === "same-origin"));
+    }
+    function cookieToken(req) {
+        const cookies = req.headers.cookie
+            ?.split(";")
+            .map((part) => part.trim())
+            .filter((part) => part.startsWith(`${CLOUD_BROWSER_COOKIE}=`));
+        if (cookies?.length === 1 && TOKEN.test(cookies[0].slice(CLOUD_BROWSER_COOKIE.length + 1)))
+            return cookies[0].slice(CLOUD_BROWSER_COOKIE.length + 1);
+    }
+    function entryFromRequest(req) {
+        const token = cookieToken(req);
+        if (token)
+            return [...entries.values()].find((row) => row.hash === hash(token));
+    }
+    async function authenticate(req) {
+        if (!isOriginAllowed(req))
+            return null;
+        const entry = entryFromRequest(req);
+        if (!entry || !entryFor(entry.session))
+            return null;
+        await revalidate(entry.session);
+        return { ...entry.session };
+    }
+    function json(res, status, value) {
+        if (res.destroyed || res.writableEnded)
+            return;
+        res.writeHead(status, {
+            "Content-Type": "application/json; charset=utf-8",
+            "Cache-Control": "no-store",
+            "Referrer-Policy": "no-referrer",
+            "X-Content-Type-Options": "nosniff",
+            "Content-Security-Policy": "frame-ancestors 'none'",
+        });
+        res.end(JSON.stringify(value));
+    }
+    function setCookie(res, token, expiresAt) {
+        res.setHeader("Set-Cookie", `${CLOUD_BROWSER_COOKIE}=${token}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${Math.max(0, Math.floor((expiresAt - now()) / 1000))}${options.publicOrigin.startsWith("https:") ? "; Secure" : ""}`);
+    }
+    async function readBody(req) {
+        if (!/^application\/json(?:\s*;|$)/i.test(req.headers["content-type"] ?? ""))
+            throw new ProjectRegistryError(415, "请使用 JSON 提交。");
+        const chunks = [];
+        let size = 0;
+        const timer = setTimeout(() => req.destroy(), 5000);
+        timer.unref();
+        reading.add(req);
+        try {
+            for await (const chunk of req) {
+                size += chunk.length;
+                if (size > 4096)
+                    throw new ProjectRegistryError(413, "请求过大。");
+                chunks.push(Buffer.from(chunk));
+            }
+        }
+        finally {
+            clearTimeout(timer);
+            reading.delete(req);
+        }
+        try {
+            const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            if (body && typeof body === "object" && !Array.isArray(body))
+                return body;
+        }
+        catch {
+            /* Only the fixed public error below is returned. */
+        }
+        throw new ProjectRegistryError(400, "请求格式无效。");
+    }
+    async function handle(req, res) {
+        const path = (req.url ?? "/").split("?", 1)[0];
+        if (!path.startsWith("/api/v1/cloud-browser/") &&
+            !path.startsWith("/api/v1/cloud-management/") &&
+            !path.startsWith("/api/v1/auth/"))
+            return false;
+        if (!isOriginAllowed(req))
+            throw new ProjectRegistryError(403, "请求来源无效。");
+        if (closed)
+            throw new ProjectRegistryError(503, "Cloud 工作台正在关闭。");
+        if (req.url !== path)
+            throw new ProjectRegistryError(400, "请求参数无效。");
+        if (["GET", "HEAD"].includes(req.method ?? "") &&
+            (Number(req.headers["content-length"] ?? 0) !== 0 ||
+                req.headers["transfer-encoding"] !== undefined))
+            throw new ProjectRegistryError(400, "读取请求不接受额外内容。");
+        // The controller owns the environment DTO; retain this authority's exact
+        // admission checks before delegating its browser-only alias.
+        if (path === "/api/v1/cloud-browser/environment")
+            return false;
+        if (path === "/api/v1/cloud-browser/capabilities" && req.method === "GET") {
+            json(res, 200, {
+                version: CLOUD_BROWSER_AUTHORITY_VERSION,
+                mode: "cloud-browser",
+                cloudOrigin: options.publicOrigin,
+                installationId: options.installationId,
+                accountOrigin: options.accountOrigin,
+            });
+            return true;
+        }
+        if (path === "/api/v1/cloud-browser/session" && req.method === "POST") {
+            if (now() >= attempts.until)
+                attempts = { until: now() + 60_000, count: 0 };
+            if (++attempts.count > 60 || exchanging >= 4)
+                throw new ProjectRegistryError(429, "Cloud 登录请求过多。");
+            // Capture before either request-body or private redemption awaits. A
+            // logout/account switch must fence the old request's eventual Set-Cookie.
+            const previous = entryFromRequest(req);
+            const wasRevoked = previous?.revoked;
+            exchanging++;
+            try {
+                const body = await readBody(req);
+                if (Object.keys(body).join() !== "ticket" ||
+                    typeof body.ticket !== "string" ||
+                    !TOKEN.test(body.ticket))
+                    throw new ProjectRegistryError(400, "Cloud 登录票据格式无效。");
+                let principal;
+                try {
+                    principal = await options.authority.redeem(body.ticket, options.installationId);
+                }
+                catch {
+                    throw new ProjectRegistryError(401, "云账号验证失败。");
+                }
+                if (closed ||
+                    res.destroyed ||
+                    res.writableEnded ||
+                    !principalValid(principal) ||
+                    principal.accountOrigin !== options.accountOrigin ||
+                    principal.expiresAt <= now())
+                    throw new ProjectRegistryError(401, "云账号验证失败。");
+                if (previous &&
+                    (entries.get(previous.session.id) !== previous || previous.revoked !== wasRevoked))
+                    throw new ProjectRegistryError(401, "Cloud 登录状态已改变，请重新进入工作台。");
+                for (const [id, entry] of entries)
+                    if (entry.session.expiresAt <= now()) {
+                        revoke(entry);
+                        entries.delete(id);
+                    }
+                const renewal = previous &&
+                    entryFor(previous.session) &&
+                    previous.principal.accountOrigin === principal.accountOrigin &&
+                    previous.principal.accountId === principal.accountId &&
+                    previous.principal.rootSessionId === principal.rootSessionId &&
+                    previous.principal.authorityEpoch === principal.authorityEpoch &&
+                    principal.expiresAt >= previous.principal.expiresAt;
+                const active = [...entries.values()].filter((entry) => !entry.revoked);
+                if (entries.size - (renewal ? 1 : 0) >= 256 ||
+                    active.filter((entry) => entry.session.accountId === principal.accountId && entry !== previous).length >= 8)
+                    throw new ProjectRegistryError(429, "Cloud 登录会话数量已达上限。");
+                const ownerId = options.ownerForAccount(principal.accountOrigin, principal.accountId);
+                if (!UUID.test(ownerId))
+                    throw new ProjectRegistryError(503, "Cloud 工作区暂不可用。");
+                const token = randomBytes(32).toString("base64url");
+                const session = {
+                    id: renewal ? previous.session.id : randomUUID(),
+                    kind: "cloud-management",
+                    audience: options.publicOrigin,
+                    installationId: options.installationId,
+                    accountOrigin: principal.accountOrigin,
+                    accountId: principal.accountId,
+                    managementEpoch: options.managementEpoch,
+                    expiresAt: Math.min(now() + 600_000, principal.expiresAt),
+                    ownerId,
+                };
+                entries.set(session.id, {
+                    hash: hash(token),
+                    session,
+                    principal: { ...principal },
+                    revoked: false,
+                });
+                if (renewal)
+                    previous.revoked = true;
+                else if (previous)
+                    revoke(previous);
+                setCookie(res, token, session.expiresAt);
+                json(res, 201, {
+                    authenticated: true,
+                    mode: "cloud-account",
+                    session: cloudManagementSessionView(session),
+                });
+            }
+            finally {
+                exchanging--;
+            }
+            return true;
+        }
+        if (["/api/v1/auth/status", "/api/v1/cloud-browser/status"].includes(path) &&
+            req.method === "GET") {
+            const session = await authenticate(req);
+            json(res, 200, {
+                initialized: true,
+                mode: "cloud-account",
+                authenticated: !!session,
+                ...(session && "kind" in session ? { session: cloudManagementSessionView(session) } : {}),
+            });
+            return true;
+        }
+        if (["/api/v1/cloud-browser/logout", "/api/v1/auth/logout"].includes(path) &&
+            req.method === "POST") {
+            const entry = entryFromRequest(req);
+            const body = await readBody(req);
+            if (Object.keys(body).length)
+                throw new ProjectRegistryError(400, "退出不接受额外参数。");
+            if (closed)
+                throw new ProjectRegistryError(503, "Cloud 工作台正在关闭。");
+            if (!entry || entry.revoked || entries.get(entry.session.id) !== entry)
+                throw new ProjectRegistryError(401, "Cloud 工作台登录已失效。");
+            revoke(entry);
+            setCookie(res, "", now());
+            json(res, 200, { revoked: true });
+            return true;
+        }
+        throw new ProjectRegistryError(403, "此 Cloud 使用独立账号的浏览器工作台登录。");
+    }
+    return {
+        cookieName: CLOUD_BROWSER_COOKIE,
+        store: {
+            listSessions: () => [...entries.values()]
+                .filter((row) => entryFor(row.session))
+                .map((row) => ({ ...row.session })),
+        },
+        handle,
+        authenticate,
+        isOriginAllowed,
+        isActive: (session) => !!entryFor(session),
+        revalidate,
+        close() {
+            closed = true;
+            for (const request of reading)
+                request.destroy();
+            reading.clear();
+            for (const entry of entries.values())
+                revoke(entry);
+            entries.clear();
+        },
+    };
+}

package/dist/project-runtime/control-authority.d.ts

@@ -0,0 +1,46 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { HubAuth } from "../hub/auth-http.js";
+import type { HubSession } from "../hub/auth-store.js";
+/** Public Account identity; access/refresh credentials never enter project workers. */
+export interface CloudAccountPrincipal {
+    accountOrigin: string;
+    accountId: string;
+    sessionId: string;
+    rootSessionId: string;
+    authorityEpoch: string;
+    expiresAt: number;
+}
+export interface CloudManagementSession {
+    id: string;
+    kind: "cloud-management";
+    audience: string;
+    installationId: string;
+    accountOrigin: string;
+    accountId: string;
+    managementEpoch: string;
+    expiresAt: number;
+    /** Internal owner scope, excluded from every response. */
+    ownerId: string;
+}
+export type ProjectControlSession = HubSession | CloudManagementSession;
+export interface ProjectControlAuthority {
+    bootstrapToken?: string;
+    cookieName: string;
+    store: {
+        listSessions(): ProjectControlSession[];
+    };
+    handle(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    authenticate(req: IncomingMessage): Promise<ProjectControlSession | null>;
+    isOriginAllowed(req: IncomingMessage): boolean;
+    /** Local lifetime check, synchronous so an already revoked transport closes promptly. */
+    isActive(session: ProjectControlSession): boolean;
+    /** Continuous authority check, also called around asynchronous lifecycle work. */
+    revalidate(session: ProjectControlSession): Promise<void>;
+    close?(): void;
+}
+export interface CloudAccountAuthority {
+    accountOrigin: string;
+    redeem(ticket: string, installationId: string): Promise<CloudAccountPrincipal>;
+    validate(principal: CloudAccountPrincipal, installationId: string): Promise<CloudAccountPrincipal>;
+}
+export declare function legacyProjectAuthority(auth: HubAuth): ProjectControlAuthority;

package/dist/project-runtime/control-authority.js

@@ -0,0 +1,15 @@
+export function legacyProjectAuthority(auth) {
+    const isActive = (session) => !("kind" in session) &&
+        auth.store
+            .listSessions()
+            .some((row) => row.id === session.id && row.username === session.username);
+    return {
+        ...auth,
+        cookieName: "cs_hub_session",
+        isActive,
+        async revalidate(session) {
+            if (!isActive(session))
+                throw new Error("Project control authority expired.");
+        },
+    };
+}

package/dist/project-runtime/control-server.d.ts

@@ -1,4 +1,5 @@
 import type { RemoteLinkConfiguration } from "@cjhyy/code-shell-core";
+import { type CloudAccountAuthority } from "./control-authority.js";
 import type { ProjectRuntimeProvider } from "./types.js";
 export interface ProjectControlServerOptions {
     host: string;
@@ -10,8 +11,24 @@ export interface ProjectControlServerOptions {
     runtimeImage?: string;
     /** Trusted operator configuration, never accepted from project requests. */
     runtimeSeccompProfile?: string;
+    /** Administrator-owned runtime resources; project requests cannot override these. */
+    runtimeLimits?: {
+        memoryMb?: number;
+        cpus?: number;
+        pids?: number;
+    };
+    /** Installation and per-account project quotas from trusted server configuration. */
+    projectLimits?: {
+        maxRunning?: number;
+        maxRunningPerOwner?: number;
+        maxProjectsPerOwner?: number;
+    };
     /** Dependency injection for lifecycle/transport integration tests. */
     provider?: ProjectRuntimeProvider;
+    /** Trusted fixed Account-origin verifier. Requires explicit offline ownership adoption. */
+    accountAuthority?: CloudAccountAuthority;
+    /** Explicit fresh-install multi-account browser workspaces; never adopts old owners. */
+    accountMode?: "multi-account";
 }
 /** A small account/project gateway. It never creates a worker, executes tools or mounts cwd. */
 export declare function startProjectControlServer(options: ProjectControlServerOptions): Promise<{

package/dist/project-runtime/control-server.js

@@ -1,13 +1,16 @@
 import { remoteLinkHostConfiguration } from "../links/remote-configuration.js";
 import { describeEnvironment } from "../environment-identity.js";
 import { createServer } from "node:http";
-import { existsSync, readFileSync } from "node:fs";
+import { lstatSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { extname } from "node:path";
 import { createHubAuth } from "../hub/auth-http.js";
+import { createCloudAccountAuth } from "./cloud-account-auth.js";
+import { createCloudBrowserAuth } from "./cloud-browser-auth.js";
+import { legacyProjectAuthority } from "./control-authority.js";
 import { resolveSafe } from "../mobile-remote/mobile-static.js";
 import { contentTypeFor } from "../static-files.js";
-import { createDockerProjectProvider } from "./docker-provider.js";
+import { createDockerProjectProvider, resolveProjectRuntimeLimits } from "./docker-provider.js";
 import { ProjectManager } from "./manager.js";
 import { createProjectRuntimeProxy } from "./proxy.js";
 import { ProjectRegistry, ProjectRegistryError } from "./registry.js";
@@ -68,36 +71,79 @@ async function readBody(request) {
 }
 /** A small account/project gateway. It never creates a worker, executes tools or mounts cwd. */
 export async function startProjectControlServer(options) {
+    const runtimeLimits = resolveProjectRuntimeLimits(options.runtimeLimits);
+    if ((options.accountMode !== undefined && options.accountMode !== "multi-account") ||
+        (options.accountMode === "multi-account" &&
+            (!options.accountAuthority || !options.publicOrigin)))
+        throw new Error("Multi-account Cloud requires an explicit fixed Account authority and public origin.");
     const remoteLink = remoteLinkHostConfiguration(options.remoteLink, options.publicOrigin);
-    if (existsSync(join(options.dataDir, "restore-in-progress")))
+    // Any entry is a barrier, including dangling symlinks. Only ENOENT means absent;
+    // permission/I/O failures must abort before registry or Hub initialization.
+    try {
+        lstatSync(join(options.dataDir, "restore-in-progress"));
         throw new Error("Cloud installation restore is incomplete; do not start this directory.");
-    const registry = new ProjectRegistry(options.dataDir);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const registry = new ProjectRegistry(options.dataDir, Date.now, {
+        ...(options.accountMode === "multi-account"
+            ? { multiAccountOrigin: options.accountAuthority.accountOrigin }
+            : {}),
+    });
     let proxy;
     let manager;
     let provider;
     let server;
     let shuttingDown = false;
     try {
-        const auth = await createHubAuth({
-            dataDir: options.dataDir,
-            publicOrigin: options.publicOrigin,
-            onRevoke: (sessionId) => {
+        const onRevoke = (sessionId, ownerId) => {
+            if (shuttingDown)
+                return;
+            void proxy?.revokeOwner(sessionId).catch(async () => {
                 if (shuttingDown)
                     return;
-                void proxy?.revokeOwner(sessionId).catch(async () => {
-                    if (shuttingDown)
-                        return;
-                    // The revoked browser's transports are already closed. If its inner
-                    // session cannot be revoked, stop the single administrator's runtimes.
-                    try {
+                // Transports are already closed. If inner revocation fails, terminate
+                // only this Account owner's runtimes; legacy keeps its single-owner fallback.
+                try {
+                    if (options.accountMode === "multi-account" && ownerId)
+                        await manager?.stopOwner(ownerId);
+                    else
                         await manager?.stopAll();
-                    }
-                    catch {
-                        console.error("[project-control] could not confirm project termination after session revocation.");
-                    }
-                });
-            },
-        });
+                }
+                catch {
+                    console.error("[project-control] could not confirm project termination after session revocation.");
+                }
+            });
+        };
+        const binding = registry.accountBinding;
+        const multiAccount = registry.multiAccount;
+        if (!!(binding || multiAccount) !== !!options.accountAuthority ||
+            ((binding || multiAccount) && !options.publicOrigin))
+            throw new Error("Cloud account authority requires explicit matching ownership and public origin.");
+        const auth = multiAccount
+            ? createCloudBrowserAuth({
+                ...multiAccount,
+                installationId: registry.installationId,
+                publicOrigin: options.publicOrigin,
+                authority: options.accountAuthority,
+                ownerForAccount: (origin, id) => registry.ensureAccountOwner(origin, id),
+                onRevoke,
+            })
+            : binding
+                ? createCloudAccountAuth({
+                    binding,
+                    installationId: registry.installationId,
+                    publicOrigin: options.publicOrigin,
+                    authority: options.accountAuthority,
+                    onRevoke,
+                })
+                : legacyProjectAuthority(await createHubAuth({
+                    dataDir: options.dataDir,
+                    publicOrigin: options.publicOrigin,
+                    onRevoke,
+                }));
         let listeningOrigin = "";
         const publicOrigin = () => options.publicOrigin ?? listeningOrigin;
         provider =
@@ -106,16 +152,23 @@ export async function startProjectControlServer(options) {
                     installationId: registry.installationId,
                     dataDir: options.dataDir,
                     image: options.runtimeImage,
+                    limits: runtimeLimits,
                     seccompProfile: options.runtimeSeccompProfile,
                     remoteLink,
                 });
         manager = new ProjectManager({
+            maxRunning: options.projectLimits?.maxRunning,
+            maxRunningPerOwner: options.projectLimits?.maxRunningPerOwner,
+            maxProjectsPerOwner: options.projectLimits?.maxProjectsPerOwner,
             registry,
             provider,
             publicOrigin,
-            isSessionActive: (session) => auth.store
-                .listSessions()
-                .some((item) => item.id === session.id && item.username === session.username),
+            isSessionActive: (session) => auth.isActive(session),
+            ...(binding || multiAccount
+                ? {
+                    revalidateSession: (session) => auth.revalidate(session),
+                }
+                : {}),
             revokeProject: async (id) => {
                 await proxy?.revokeProject(id);
             },
@@ -152,7 +205,10 @@ export async function startProjectControlServer(options) {
                 return;
             if (await transport.handle(request, response))
                 return;
-            if (pathname === "/api/v1/environment") {
+            if (pathname === "/api/v1/environment" ||
+                (multiAccount && pathname === "/api/v1/cloud-browser/environment")) {
+                if (pathname === "/api/v1/cloud-browser/environment" && url.search)
+                    throw new ProjectRegistryError(400, "环境请求参数无效。");
                 if (!auth.isOriginAllowed(request))
                     throw new ProjectRegistryError(403, "请求来源无效。");
                 if (!(await auth.authenticate(request)))
@@ -172,6 +228,7 @@ export async function startProjectControlServer(options) {
                     throw new ProjectRegistryError(400, "项目请求参数无效。");
                 if (pathname === "/api/v1/projects" && request.method === "GET") {
                     const availability = await provider.availability();
+                    await auth.revalidate(session);
                     json(response, 200, {
                         runtime: "docker",
                         ...availability,
@@ -183,10 +240,11 @@ export async function startProjectControlServer(options) {
                     const body = await readBody(request);
                     if (Object.keys(body).some((key) => key !== "name"))
                         throw new ProjectRegistryError(400, "仅支持设置项目名称。");
+                    await auth.revalidate(session);
                     json(response, 201, { project: projects.create(session, body.name) });
                     return;
                 }
-                const match = /^\/api\/v1\/projects\/([a-f0-9-]{36})(?:\/(start|stop))?$/.exec(pathname);
+                const match = /^\/api\/v1\/projects\/([a-f0-9-]{36})(?:\/(start|stop|open))?$/.exec(pathname);
                 if (match && request.method === "GET" && !match[2]) {
                     json(response, 200, { project: projects.get(session, match[1]) });
                     return;
@@ -195,6 +253,14 @@ export async function startProjectControlServer(options) {
                     const body = await readBody(request);
                     if (Object.keys(body).length)
                         throw new ProjectRegistryError(400, "启动和停止不接受额外参数。");
+                    if (match[2] === "open") {
+                        await projects.resolveTarget(session, match[1]);
+                        json(response, 200, {
+                            project: projects.get(session, match[1]),
+                            url: `${publicOrigin()}/?project=${match[1]}`,
+                        });
+                        return;
+                    }
                     const project = match[2] === "start"
                         ? await projects.start(session, match[1])
                         : await projects.stop(session, match[1]);
@@ -228,6 +294,7 @@ export async function startProjectControlServer(options) {
                 "Content-Type": contentTypeFor(extname(file)),
                 "Content-Length": bytes.length,
                 "Cache-Control": "no-cache",
+                ...(multiAccount ? { "Content-Security-Policy": "frame-ancestors 'none'" } : {}),
             });
             response.end(request.method === "HEAD" ? undefined : bytes);
         };
@@ -286,6 +353,7 @@ export async function startProjectControlServer(options) {
                         // Revoke streams and inner sessions before stopping their servers.
                         // If logout is unreachable, confirmed runtime termination is the
                         // fallback; a real stop failure must still reject close().
+                        auth.close?.();
                         await transport.close().catch(() => { });
                         await projects.close();
                     }

package/dist/project-runtime/docker-provider.d.ts

@@ -33,5 +33,11 @@ export declare class ProjectRuntimeError extends Error {
 }
 export declare function validateProjectRuntimeRecord(project: ProjectRuntimeRecord): void;
 export declare function validateProjectPublicOrigin(value: string): string;
+/** Shared trusted configuration parsing, including hosts with an injected provider. */
+export declare function resolveProjectRuntimeLimits(limits: DockerProjectProviderOptions["limits"]): {
+    memoryMb: number;
+    cpus: number;
+    pids: number;
+};
 /** An administrator-owned Docker control client. Project tasks never receive this client. */
 export declare function createDockerProjectProvider(options: DockerProjectProviderOptions): ProjectRuntimeProvider;