@cjhyy/code-shell-server 0.9.37 → 0.9.39

package/dist/hub/uploads.js

@@ -6,6 +6,8 @@ import { markAttachmentsSent, stageFileBytes, stageImageBytes, } from "../attach
 const MAX_BYTES = 20 * 1024 * 1024;
 const TTL_MS = 15 * 60 * 1000;
 const SAFE_ID = /^[a-zA-Z0-9_-]{8,80}$/;
+// Match the session/history boundary so existing dotted session IDs can attach files.
+const SAFE_SESSION_ID = /^(?!.*\.\.)[A-Za-z0-9_-][A-Za-z0-9_.-]{0,127}$/;
 const emptyUploads = () => ({
     attachments: [],
     commit: async () => { },
@@ -150,7 +152,7 @@ export class HubUploads {
         }
         if (!ids.length)
             return emptyUploads();
-        if (typeof sessionId !== "string" || !/^[a-zA-Z0-9_-]{1,128}$/.test(sessionId)) {
+        if (typeof sessionId !== "string" || !SAFE_SESSION_ID.test(sessionId)) {
             throw new Error("valid sessionId required for attachments");
         }
         const records = ids.map((id) => {

package/dist/index.serve.d.ts

@@ -2,6 +2,7 @@
 export * from "./serve/headless-server.js";
 export { startProjectControlServer, type ProjectControlServerOptions, } from "./project-runtime/control-server.js";
 export { CLOUD_MANAGEMENT_AUTHORITY_VERSION } from "./project-runtime/cloud-account-auth.js";
+export { CLOUD_BROWSER_AUTHORITY_VERSION } from "./project-runtime/cloud-browser-auth.js";
 export { adoptCloudAccount, inspectCloudAccountAdoption, type CloudAccountAdoptionOptions, } from "./project-runtime/account-adoption.js";
 export type { CloudAccountAuthority, CloudAccountPrincipal, CloudManagementSession, } from "./project-runtime/control-authority.js";
 export { parseServeArgs, resolveWebAppRoot, resolveWorkerCapabilityModules, resolveWorkerEntry, runServeCli, } from "./serve/cli.js";

package/dist/index.serve.js

@@ -2,6 +2,7 @@
 export * from "./serve/headless-server.js";
 export { startProjectControlServer, } from "./project-runtime/control-server.js";
 export { CLOUD_MANAGEMENT_AUTHORITY_VERSION } from "./project-runtime/cloud-account-auth.js";
+export { CLOUD_BROWSER_AUTHORITY_VERSION } from "./project-runtime/cloud-browser-auth.js";
 export { adoptCloudAccount, inspectCloudAccountAdoption, } from "./project-runtime/account-adoption.js";
 export { parseServeArgs, resolveWebAppRoot, resolveWorkerCapabilityModules, resolveWorkerEntry, runServeCli, } from "./serve/cli.js";
 export { backupProjectInstallation, restoreProjectInstallation, } from "./project-runtime/backup.js";

package/dist/project-runtime/account-binding.d.ts

@@ -7,6 +7,12 @@ export interface CloudAccountBinding {
     managementEpoch: string;
     createdAt: number;
 }
+/** Fresh installation policy. Each verified Account receives its own internal owner. */
+export interface CloudMultiAccountConfiguration {
+    accountOrigin: string;
+    managementEpoch: string;
+}
 export declare const CLOUD_ADOPTION_PENDING = "account-adoption-pending.json";
 export declare function isCloudAccountOrigin(value: unknown): value is string;
 export declare function isCloudAccountBinding(value: unknown): value is CloudAccountBinding;
+export declare function isCloudMultiAccountConfiguration(value: unknown): value is CloudMultiAccountConfiguration;

package/dist/project-runtime/account-binding.js

@@ -31,3 +31,12 @@ export function isCloudAccountBinding(value) {
         Number.isSafeInteger(row.createdAt) &&
         row.createdAt >= 0);
 }
+export function isCloudMultiAccountConfiguration(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const row = value;
+    return (Object.keys(row).sort().join() === "accountOrigin,managementEpoch" &&
+        isCloudAccountOrigin(row.accountOrigin) &&
+        typeof row.managementEpoch === "string" &&
+        UUID.test(row.managementEpoch));
+}

package/dist/project-runtime/backup.d.ts

@@ -5,11 +5,14 @@ export interface ProjectBackupOptions {
     destination: string;
     /** Locally available, administrator-reviewed Linux image containing tar. No pull occurs. */
     helperImage: string;
+    /** Explicit policy for a schema 3 installation; never inferred from backup data. */
+    multiAccountOrigin?: string;
 }
 export interface ProjectRestoreOptions {
     source: string;
     destination: string;
     helperImage: string;
+    multiAccountOrigin?: string;
     /** Fault injection for offline restore durability tests. */
     io?: {
         fsync?: typeof fsyncSync;

package/dist/project-runtime/backup.js

@@ -7,11 +7,13 @@ import { pipeline } from "node:stream/promises";
 import { Transform } from "node:stream";
 import { HubAuthStore } from "../hub/auth-store.js";
 import { ProjectRegistry } from "./registry.js";
+import { isCloudAccountOrigin } from "./account-binding.js";
 const LABEL = "io.codeshell.project-runtime";
 const FORMAT = "codeshell.project-installation-backup";
 const MAX_CONTROL_FILE = 16 * 1024 * 1024;
 const SHA = /^[a-f0-9]{64}$/;
 const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const MULTI_CONTROL_FILES = ["project-control/initialized", "project-control/registry.json"];
 const digest = (value) => ({
     sha256: createHash("sha256").update(value).digest("hex"),
     bytes: value.length,
@@ -256,6 +258,14 @@ async function copyControl(source, destination, records, prefix = "") {
         }
     }
 }
+async function assertMultiControlInventory(source) {
+    for (const name of await readdir(source))
+        if (!["project-control", "project-control.lock", "project-runtime-secrets"].includes(name))
+            throw new Error("Multi-account backup refuses unknown controller state files.");
+    for (const name of await readdir(join(source, "project-control")))
+        if (!["initialized", "registry.json"].includes(name))
+            throw new Error("Multi-account backup refuses unknown project control files.");
+}
 /** Offline, owner-only backup. It never stops projects or modifies their volumes. */
 export async function backupProjectInstallation(options) {
     imageId(options.helperImage);
@@ -263,15 +273,21 @@ export async function backupProjectInstallation(options) {
     await directory(source);
     // Do not initialize a fresh registry as a side effect of a mistaken backup path.
     await regular(join(source, "project-control/registry.json"), 512 * 1024);
-    const registry = new ProjectRegistry(source);
+    const registry = new ProjectRegistry(source, Date.now, {
+        multiAccountOrigin: options.multiAccountOrigin,
+    });
     let destination;
     try {
         const rows = registry.all();
         if (rows.some((row) => row.status !== "stopped"))
             throw new Error("Stop all projects and the controller before backup.");
-        const auth = new HubAuthStore({ dataDir: source });
-        if (!auth.isInitialized())
-            throw new Error("Complete administrator setup before backing up.");
+        if (registry.multiAccount)
+            await assertMultiControlInventory(source);
+        if (!registry.multiAccount) {
+            const auth = new HubAuthStore({ dataDir: source });
+            if (!auth.isInitialized())
+                throw new Error("Complete administrator setup before backing up.");
+        }
         const installationId = registry.installationId;
         const projects = rows.map(({ id, ownerId, generation }) => ({ id, ownerId, generation }));
         await stopped(installationId, projects);
@@ -281,7 +297,8 @@ export async function backupProjectInstallation(options) {
         await mkdir(join(destination, "volumes"), { mode: 0o700 });
         const manifest = {
             format: FORMAT,
-            version: 1,
+            version: registry.multiAccount ? 2 : 1,
+            ...(registry.multiAccount ? { multiAccountOrigin: registry.multiAccount.accountOrigin } : {}),
             createdAt: new Date().toISOString(),
             installationId,
             helperImage: options.helperImage,
@@ -289,7 +306,20 @@ export async function backupProjectInstallation(options) {
             control: Object.create(null),
             volumes: [],
         };
-        await copyControl(source, join(destination, "control"), manifest.control);
+        if (registry.multiAccount) {
+            await mkdir(join(destination, "control/project-control"), { mode: 0o700 });
+            for (const path of MULTI_CONTROL_FILES) {
+                const bytes = await controlBytes(source, path);
+                await writeFile(join(destination, "control", path), bytes, {
+                    mode: 0o600,
+                    flag: "wx",
+                    flush: true,
+                });
+                manifest.control[path] = digest(bytes);
+            }
+        }
+        else
+            await copyControl(source, join(destination, "control"), manifest.control);
         for (const project of projects) {
             let found = 0;
             for (const kind of ["data", "workspace"]) {
@@ -316,6 +346,8 @@ export async function backupProjectInstallation(options) {
         }
         await stopped(installationId, projects);
         registry.all(); // Recheck registry ownership and unchanged bytes after asynchronous work.
+        if (registry.multiAccount)
+            await assertMultiControlInventory(source);
         const manifestBytes = JSON.stringify(manifest, null, 2) + "\n";
         if (Buffer.byteLength(manifestBytes) > 1024 * 1024)
             throw new Error("Backup manifest exceeds its supported size.");
@@ -342,7 +374,10 @@ export async function backupProjectInstallation(options) {
 }
 function validateManifest(value) {
     if (value?.format !== FORMAT ||
-        value.version !== 1 ||
+        ![1, 2].includes(value.version) ||
+        (value.version === 1
+            ? value.multiAccountOrigin !== undefined
+            : !isCloudAccountOrigin(value.multiAccountOrigin)) ||
         !UUID.test(value.installationId) ||
         !Array.isArray(value.projects) ||
         value.projects.length > 128 ||
@@ -375,6 +410,9 @@ function validateManifest(value) {
     }
     if (Object.keys(value.control).length > 4096)
         throw new Error("Invalid control inventory.");
+    if (value.version === 2 &&
+        Object.keys(value.control).sort().join() !== MULTI_CONTROL_FILES.join())
+        throw new Error("Multi-account backup requires its exact controller inventory.");
     for (const [path, entry] of Object.entries(value.control)) {
         if (!path ||
             path.includes("\\") ||
@@ -405,7 +443,7 @@ function validateManifest(value) {
     for (const path of [
         "project-control/registry.json",
         "project-control/initialized",
-        "hub/auth.json",
+        ...(value.version === 1 ? ["hub/auth.json"] : []),
     ])
         if (!Object.hasOwn(value.control, path))
             throw new Error("Backup lacks required control data.");
@@ -419,6 +457,8 @@ export async function restoreProjectInstallation(options) {
     await directory(join(source, "volumes"));
     const manifest = JSON.parse((await regular(join(source, "manifest.json"), 1024 * 1024)).toString());
     validateManifest(manifest);
+    if (manifest.multiAccountOrigin !== options.multiAccountOrigin)
+        throw new Error("Restore requires the explicitly configured Account origin and matching installation mode.");
     // Verify every archive before creating a destination or Docker resource.
     for (const volume of manifest.volumes)
         same(await fileDigest(join(source, volume.file)), volume.digest);
@@ -467,21 +507,26 @@ export async function restoreProjectInstallation(options) {
                 directories.add(parent);
             await writeFile(join(destination, path), bytes, { mode: 0o600, flag: "wx", flush: true });
         }
-        registry = new ProjectRegistry(destination, Date.now, { fsync: options.io?.fsync });
+        registry = new ProjectRegistry(destination, Date.now, {
+            fsync: options.io?.fsync,
+            multiAccountOrigin: options.multiAccountOrigin,
+        });
         const rows = registry.all();
         if (registry.installationId !== manifest.installationId ||
             rows.some((p) => p.status !== "stopped") ||
             JSON.stringify(rows.map(({ id, ownerId, generation }) => ({ id, ownerId, generation }))) !==
                 JSON.stringify(manifest.projects))
             throw new Error("Backup control and volume identities disagree.");
-        const auth = new HubAuthStore({ dataDir: destination });
-        if (!auth.isInitialized())
-            throw new Error("Backup administrator is not initialized.");
-        auth.revokeAllSessions();
-        // HubAuthStore publishes by rename. Persist the replacement and its directory
-        // before a new namespace or removal of the restore barrier can become visible.
-        sync(join(destination, "hub/auth.json"));
-        sync(join(destination, "hub"));
+        if (!registry.multiAccount) {
+            const auth = new HubAuthStore({ dataDir: destination });
+            if (!auth.isInitialized())
+                throw new Error("Backup administrator is not initialized.");
+            auth.revokeAllSessions();
+            // HubAuthStore publishes by rename. Persist the replacement and its directory
+            // before a new namespace or removal of the restore barrier can become visible.
+            sync(join(destination, "hub/auth.json"));
+            sync(join(destination, "hub"));
+        }
         registry.renewInstallationForRestore();
         const installationId = registry.installationId;
         for (const volume of manifest.volumes) {

package/dist/project-runtime/cloud-browser-auth.d.ts

@@ -0,0 +1,15 @@
+import type { CloudAccountAuthority, ProjectControlAuthority } from "./control-authority.js";
+/** Browser bootstrap is separate from the native, single-operator v2 API. */
+export declare const CLOUD_BROWSER_AUTHORITY_VERSION = 1;
+export declare const CLOUD_BROWSER_COOKIE = "cs_cloud_browser";
+/** Every principal is independently scoped; a login never claims legacy projects. */
+export declare function createCloudBrowserAuth(options: {
+    accountOrigin: string;
+    managementEpoch: string;
+    installationId: string;
+    publicOrigin: string;
+    authority: CloudAccountAuthority;
+    ownerForAccount(accountOrigin: string, accountId: string): string;
+    onRevoke(sessionId: string, ownerId: string): void;
+    now?: () => number;
+}): ProjectControlAuthority;

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-server.d.ts

@@ -11,10 +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

@@ -6,10 +6,11 @@ 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";
@@ -70,6 +71,11 @@ 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);
     // Any entry is a barrier, including dangling symlinks. Only ENOENT means absent;
     // permission/I/O failures must abort before registry or Hub initialization.
@@ -81,23 +87,30 @@ export async function startProjectControlServer(options) {
         if (error.code !== "ENOENT")
             throw error;
     }
-    const registry = new ProjectRegistry(options.dataDir);
+    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 onRevoke = (sessionId) => {
+        const onRevoke = (sessionId, ownerId) => {
             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.
+                // Transports are already closed. If inner revocation fails, terminate
+                // only this Account owner's runtimes; legacy keeps its single-owner fallback.
                 try {
-                    await manager?.stopAll();
+                    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.");
@@ -105,21 +118,32 @@ export async function startProjectControlServer(options) {
             });
         };
         const binding = registry.accountBinding;
-        if (!!binding !== !!options.accountAuthority || (binding && !options.publicOrigin))
+        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 = binding
-            ? createCloudAccountAuth({
-                binding,
+        const auth = multiAccount
+            ? createCloudBrowserAuth({
+                ...multiAccount,
                 installationId: registry.installationId,
                 publicOrigin: options.publicOrigin,
                 authority: options.accountAuthority,
+                ownerForAccount: (origin, id) => registry.ensureAccountOwner(origin, id),
                 onRevoke,
             })
-            : legacyProjectAuthority(await createHubAuth({
-                dataDir: options.dataDir,
-                publicOrigin: options.publicOrigin,
-                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 =
@@ -128,15 +152,19 @@ 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.isActive(session),
-            ...(binding
+            ...(binding || multiAccount
                 ? {
                     revalidateSession: (session) => auth.revalidate(session),
                 }
@@ -177,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)))
@@ -263,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);
         };

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;

package/dist/project-runtime/docker-provider.js

@@ -103,6 +103,15 @@ async function within(promise, signal) {
             signal.removeEventListener("abort", onAbort);
     }
 }
+/** Shared trusted configuration parsing, including hosts with an injected provider. */
+export function resolveProjectRuntimeLimits(limits) {
+    const memoryMb = bounded(limits?.memoryMb ?? 2048, 128, 262144, "memory");
+    const cpus = bounded(limits?.cpus ?? 2, 0.1, 128, "CPU");
+    const pids = bounded(limits?.pids ?? 256, 16, 65536, "process");
+    if (!Number.isInteger(memoryMb) || !Number.isInteger(pids))
+        throw new ProjectRuntimeError("Invalid resource limits.");
+    return { memoryMb, cpus, pids };
+}
 /** An administrator-owned Docker control client. Project tasks never receive this client. */
 export function createDockerProjectProvider(options) {
     if (!UUID.test(options.installationId))
@@ -116,11 +125,7 @@ export function createDockerProjectProvider(options) {
     const dataDir = resolve(options.dataDir);
     if (/[\0,\r\n]/.test(dataDir))
         throw new ProjectRuntimeError("Unsupported project metadata path.");
-    const memory = bounded(options.limits?.memoryMb ?? 2048, 128, 262144, "memory");
-    const cpus = bounded(options.limits?.cpus ?? 2, 0.1, 128, "CPU");
-    const pids = bounded(options.limits?.pids ?? 256, 16, 65536, "process");
-    if (!Number.isInteger(memory) || !Number.isInteger(pids))
-        throw new ProjectRuntimeError("Invalid resource limits.");
+    const { memoryMb: memory, cpus, pids } = resolveProjectRuntimeLimits(options.limits);
     const commandTimeout = bounded(options.commandTimeoutMs ?? 15000, 10, 120000, "command timeout");
     const startupTimeout = bounded(options.startupTimeoutMs ?? 90000, 10, 300000, "startup timeout");
     const command = options.command ?? dockerCommand;

package/dist/project-runtime/manager.d.ts

@@ -9,6 +9,8 @@ export interface ProjectManagerOptions {
     revokeProject(id: string): Promise<void>;
     revalidateSession?(session: ProjectControlSession): Promise<void>;
     maxRunning?: number;
+    maxRunningPerOwner?: number;
+    maxProjectsPerOwner?: number;
     /** Clock seam for Docker observations; authorization is never cached. */
     now?: () => number;
 }
@@ -40,5 +42,7 @@ export declare class ProjectManager {
     stopAfterRevocationFailure(id: string): Promise<void>;
     /** Emergency fallback when an outer owner's affected projects are unavailable. */
     stopAll(): Promise<void>;
+    /** Revocation fallback for one Account; never interrupts another owner's runtimes. */
+    stopOwner(ownerId: string): Promise<void>;
     close(): Promise<void>;
 }

package/dist/project-runtime/manager.js

@@ -15,6 +15,12 @@ export class ProjectManager {
             (options.maxRunning ?? 4) < 1 ||
             (options.maxRunning ?? 4) > 32)
             throw new Error("Project running limit must be between 1 and 32.");
+        for (const [name, value, maximum] of [
+            ["running per owner", options.maxRunningPerOwner ?? 2, 32],
+            ["projects per owner", options.maxProjectsPerOwner ?? 16, 128],
+        ])
+            if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+                throw new Error(`Project ${name} limit must be between 1 and ${maximum}.`);
     }
     authorize(session) {
         if (this.closed)
@@ -62,6 +68,11 @@ export class ProjectManager {
     }
     create(session, name) {
         this.authorize(session);
+        if (this.options.registry.multiAccount &&
+            "kind" in session &&
+            this.options.registry.listAccount(session.ownerId).length >=
+                (this.options.maxProjectsPerOwner ?? 16))
+            throw new ProjectRegistryError(429, `每个账号最多创建 ${this.options.maxProjectsPerOwner ?? 16} 个项目。`);
         return projectView("kind" in session
             ? this.options.registry.createAccount(session.ownerId, name)
             : this.options.registry.create(session.username, name));
@@ -104,6 +115,16 @@ export class ProjectManager {
             item.generation > 0).length;
         if (count >= (this.options.maxRunning ?? 4))
             throw new ProjectRegistryError(429, `最多同时运行 ${this.options.maxRunning ?? 4} 个项目，请先停止其他项目。`);
+        if (this.options.registry.multiAccount) {
+            const ownerCount = this.options.registry
+                .all()
+                .filter((item) => item.ownerId === project.ownerId &&
+                item.id !== id &&
+                ["running", "starting", "stopping", "error"].includes(item.status) &&
+                item.generation > 0).length;
+            if (ownerCount >= (this.options.maxRunningPerOwner ?? 2))
+                throw new ProjectRegistryError(429, `每个账号最多同时运行 ${this.options.maxRunningPerOwner ?? 2} 个项目。`);
+        }
         this.statusChecks.delete(id);
         const record = this.options.registry.update(id, {
             status: "starting",
@@ -273,6 +294,18 @@ export class ProjectManager {
         if (results.some((result) => result.status === "rejected" || result.value.status !== "stopped"))
             throw new ProjectRegistryError(503, "部分项目尚未确认停止，请检查 Docker。");
     }
+    /** Revocation fallback for one Account; never interrupts another owner's runtimes. */
+    async stopOwner(ownerId) {
+        this.options.registry.listAccount(ownerId); // Require an actual Account owner.
+        const projects = this.options.registry.all().filter((project) => project.ownerId === ownerId);
+        for (const project of projects)
+            this.stopRevisions.set(project.id, (this.stopRevisions.get(project.id) ?? 0) + 1);
+        const results = await Promise.allSettled(projects
+            .filter((project) => project.generation > 0 && project.status !== "stopped")
+            .map((project) => this.beginStop(project.id)));
+        if (results.some((result) => result.status === "rejected" || result.value.status !== "stopped"))
+            throw new ProjectRegistryError(503, "部分账号项目尚未确认停止，请检查 Docker。");
+    }
     close() {
         if (this.closing)
             return this.closing;

package/dist/project-runtime/proxy.js

@@ -2,6 +2,7 @@ import { request as httpRequest } from "node:http";
 import { Transform } from "node:stream";
 import { WebSocket, WebSocketServer } from "ws";
 import { HUB_SESSION_COOKIE } from "../hub/auth-http.js";
+import { ProjectRegistryError } from "./registry.js";
 import { createLinkBrowserHandoff } from "../links/browser-handoff.js";
 const UUID = "[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}";
 const PROJECT_PATH = new RegExp(`^/p/(${UUID})(/.*)$`);
@@ -753,13 +754,19 @@ function httpError(res, error) {
         res.destroy();
         return;
     }
-    const status = error instanceof ProxyError ? error.status : 503;
+    const status = error instanceof ProxyError || error instanceof ProjectRegistryError ? error.status : 503;
     res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
     res.end(JSON.stringify({
-        error: error instanceof ProxyError ? error.message : "Project runtime unavailable",
+        error: error instanceof ProxyError
+            ? error.message
+            : status === 401
+                ? "Authentication required"
+                : status === 404
+                    ? "Project endpoint not found"
+                    : "Project runtime unavailable",
     }));
 }
 function upgradeError(socket, error) {
-    const status = error instanceof ProxyError ? error.status : 503;
-    socket.end(`HTTP/1.1 ${status} Error\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
+    const status = error instanceof ProxyError || error instanceof ProjectRegistryError ? error.status : 503;
+    socket.end(`HTTP/1.1 ${status} Error\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`, () => socket.destroy());
 }

package/dist/project-runtime/registry.d.ts

@@ -1,6 +1,6 @@
 import { fsyncSync, renameSync } from "node:fs";
 import type { ProjectRuntimeRecord } from "./types.js";
-import { type CloudAccountBinding } from "./account-binding.js";
+import { type CloudAccountBinding, type CloudMultiAccountConfiguration } from "./account-binding.js";
 export type ProjectStatus = "stopped" | "starting" | "running" | "stopping" | "error";
 export interface StoredProject extends ProjectRuntimeRecord {
     name: string;
@@ -38,6 +38,8 @@ export declare class ProjectRegistry {
         rename?: typeof renameSync;
         fsync?: typeof fsyncSync;
         offlineAccountAdoption?: boolean;
+        /** Explicit startup policy; never inferred from the first authenticated user. */
+        multiAccountOrigin?: string;
     });
     /** Release the single-controller lease on shutdown or startup failure. */
     close(): void;
@@ -45,6 +47,10 @@ export declare class ProjectRegistry {
     renewInstallationForRestore(): void;
     get installationId(): string;
     get accountBinding(): CloudAccountBinding | undefined;
+    get multiAccount(): CloudMultiAccountConfiguration | undefined;
+    /** Called only after trusted authority verification, never with browser-selected identity. */
+    ensureAccountOwner(accountOrigin: string, accountId: string): string;
+    private requireConfiguredMode;
     /** Offline migration only; the caller must durably preserve source evidence first. */
     bindAccount(binding: CloudAccountBinding): void;
     private validate;
@@ -60,6 +66,7 @@ export declare class ProjectRegistry {
     private requireLegacy;
     private requireAccountOwner;
     private createForOwner;
+    private createForAccountOwner;
     update(id: string, patch: {
         status: ProjectStatus;
         generation?: number;

package/dist/project-runtime/registry.js

@@ -2,7 +2,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { constants, chmodSync, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { acquireProjectControllerLock } from "./lock.js";
-import { CLOUD_ADOPTION_PENDING, isCloudAccountBinding, } from "./account-binding.js";
+import { CLOUD_ADOPTION_PENDING, isCloudAccountBinding, isCloudAccountOrigin, isCloudMultiAccountConfiguration, } from "./account-binding.js";
 const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
 const TOKEN = /^[A-Za-z0-9_-]{43}$/;
 const STATUSES = new Set(["stopped", "starting", "running", "stopping", "error"]);
@@ -63,6 +63,12 @@ export class ProjectRegistry {
     constructor(dataDir, now = Date.now, io = {}) {
         this.now = now;
         this.io = io;
+        if (this.io.multiAccountOrigin !== undefined &&
+            (!isCloudAccountOrigin(this.io.multiAccountOrigin) || this.io.offlineAccountAdoption))
+            throw new Error("Multi-account Cloud requires one explicit canonical Account origin.");
+        if (this.io.multiAccountOrigin &&
+            lstatSync(join(resolve(dataDir), "hub"), { throwIfNoEntry: false }))
+            throw new Error("Multi-account Cloud requires a fresh installation without legacy Hub authority.");
         this.directory = resolve(dataDir, "project-control");
         const existed = existsSync(this.directory);
         mkdirSync(this.directory, { recursive: true, mode: 0o700 });
@@ -93,12 +99,26 @@ export class ProjectRegistry {
                 const bytes = privateFileBytes(this.file);
                 this.data = JSON.parse(bytes.toString("utf8"));
                 this.validate();
+                this.requireConfiguredMode();
                 this.diskDigest = digest(bytes);
             }
             else {
                 if (existsSync(this.marker) || existed)
                     throw new Error("Project registry is missing; restore the existing registry before starting");
-                this.data = { version: 1, installationId: randomUUID(), owners: [], projects: [] };
+                this.data = {
+                    version: this.io.multiAccountOrigin ? 3 : 1,
+                    installationId: randomUUID(),
+                    owners: [],
+                    projects: [],
+                    ...(this.io.multiAccountOrigin
+                        ? {
+                            multiAccount: {
+                                accountOrigin: this.io.multiAccountOrigin,
+                                managementEpoch: randomUUID(),
+                            },
+                        }
+                        : {}),
+                };
                 this.write();
             }
             if (!this.markerEstablished) {
@@ -123,6 +143,8 @@ export class ProjectRegistry {
         next.installationId = randomUUID();
         if (next.accountBinding)
             next.accountBinding.managementEpoch = randomUUID();
+        if (next.multiAccount)
+            next.multiAccount.managementEpoch = randomUUID();
         for (const project of next.projects) {
             if (project.generation > 0)
                 project.generation += 1;
@@ -140,6 +162,40 @@ export class ProjectRegistry {
         this.assertStorage();
         return this.data.accountBinding && { ...this.data.accountBinding };
     }
+    get multiAccount() {
+        this.assertStorage();
+        return this.data.multiAccount && { ...this.data.multiAccount };
+    }
+    /** Called only after trusted authority verification, never with browser-selected identity. */
+    ensureAccountOwner(accountOrigin, accountId) {
+        this.assertStorage();
+        if (this.data.version !== 3 ||
+            accountOrigin !== this.data.multiAccount?.accountOrigin ||
+            typeof accountId !== "string" ||
+            !UUID.test(accountId))
+            throw new ProjectRegistryError(403, "此账号没有工作台权限。");
+        const existing = this.data.owners.find((owner) => "accountId" in owner &&
+            owner.accountOrigin === accountOrigin &&
+            owner.accountId === accountId);
+        if (existing)
+            return existing.id;
+        if (this.data.owners.length >= 128)
+            throw new ProjectRegistryError(429, "工作台账号数量已达到上限。");
+        const next = structuredClone(this.data), ownerId = randomUUID();
+        next.owners.push({ id: ownerId, accountOrigin, accountId });
+        this.write(next);
+        this.data = next;
+        return ownerId;
+    }
+    requireConfiguredMode() {
+        if (this.data.version === 3) {
+            if (this.io.multiAccountOrigin !== this.data.multiAccount?.accountOrigin)
+                throw new Error("Multi-account Cloud requires its configured Account origin; automatic mode adoption is refused.");
+        }
+        else if (this.io.multiAccountOrigin !== undefined) {
+            throw new Error("Multi-account Cloud requires a fresh installation; legacy adoption is refused.");
+        }
+    }
     /** Offline migration only; the caller must durably preserve source evidence first. */
     bindAccount(binding) {
         this.assertStorage();
@@ -160,23 +216,47 @@ export class ProjectRegistry {
     }
     validate(data = this.data) {
         if (!data ||
-            (data.version !== 1 && data.version !== 2) ||
+            ![1, 2, 3].includes(data.version) ||
             !UUID.test(data.installationId) ||
             !Array.isArray(data.owners) ||
             !Array.isArray(data.projects) ||
             data.owners.length > 128 ||
             data.projects.length > 128)
             throw new Error("Project registry is corrupt; restore its backup");
-        if ((data.version === 1 && data.accountBinding !== undefined) ||
+        if ((data.version !== 3 && data.multiAccount !== undefined) ||
+            (data.version === 1 && data.accountBinding !== undefined) ||
             (data.version === 2 &&
                 (!isCloudAccountBinding(data.accountBinding) ||
                     data.owners.length !== 1 ||
-                    data.owners[0]?.id !== data.accountBinding.ownerId)))
+                    data.owners[0]?.id !== data.accountBinding.ownerId)) ||
+            (data.version === 3 &&
+                (data.accountBinding !== undefined ||
+                    !isCloudMultiAccountConfiguration(data.multiAccount) ||
+                    typeof data.installationId !== "string" ||
+                    Object.keys(data).sort().join() !==
+                        "installationId,multiAccount,owners,projects,version")))
             throw new Error("Cloud account ownership is missing or corrupt; restore its backup.");
         const owners = new Set();
         const names = new Set();
         for (const owner of data.owners) {
+            if (data.version === 3) {
+                if (!owner ||
+                    typeof owner.id !== "string" ||
+                    !UUID.test(owner.id) ||
+                    owners.has(owner.id) ||
+                    !("accountId" in owner) ||
+                    Object.keys(owner).sort().join() !== "accountId,accountOrigin,id" ||
+                    owner.accountOrigin !== data.multiAccount.accountOrigin ||
+                    typeof owner.accountId !== "string" ||
+                    !UUID.test(owner.accountId) ||
+                    names.has(owner.accountId))
+                    throw new Error("Project account owner registry is corrupt");
+                owners.add(owner.id);
+                names.add(owner.accountId);
+                continue;
+            }
             if (!owner ||
+                !("username" in owner) ||
                 !UUID.test(owner.id) ||
                 typeof owner.username !== "string" ||
                 !owner.username.trim() ||
@@ -191,6 +271,27 @@ export class ProjectRegistry {
         }
         const ids = new Set();
         for (const project of data.projects) {
+            if (data.version === 3 &&
+                (!project ||
+                    typeof project.id !== "string" ||
+                    typeof project.ownerId !== "string" ||
+                    typeof project.runtimePassword !== "string" ||
+                    Object.keys(project).sort().join() !==
+                        [
+                            "id",
+                            "ownerId",
+                            "generation",
+                            "runtimeUsername",
+                            "runtimePassword",
+                            "name",
+                            "status",
+                            "createdAt",
+                            "updatedAt",
+                            ...(project.error === undefined ? [] : ["error"]),
+                        ]
+                            .sort()
+                            .join()))
+                throw new Error("Project account runtime registry is corrupt");
             if (!project ||
                 !UUID.test(project.id) ||
                 ids.has(project.id) ||
@@ -273,13 +374,13 @@ export class ProjectRegistry {
     list(username) {
         this.assertStorage();
         this.requireLegacy();
-        const owner = this.data.owners.find((item) => item.username === username);
+        const owner = this.data.owners.find((item) => "username" in item && item.username === username);
         return this.data.projects.filter((item) => item.ownerId === owner?.id).map(projectView);
     }
     get(username, id) {
         this.assertStorage();
         this.requireLegacy();
-        const owner = this.data.owners.find((item) => item.username === username);
+        const owner = this.data.owners.find((item) => "username" in item && item.username === username);
         const project = this.data.projects.find((item) => item.id === id && item.ownerId === owner?.id);
         if (!project)
             throw new ProjectRegistryError(404, "找不到这个项目。");
@@ -303,6 +404,8 @@ export class ProjectRegistry {
     }
     createAccount(ownerId, name) {
         this.requireAccountOwner(ownerId);
+        if (this.data.version === 3)
+            return this.createForAccountOwner(ownerId, name);
         // This username is internal legacy metadata, never the Account display name.
         return this.createForOwner(this.data.owners[0].username, name);
     }
@@ -312,8 +415,10 @@ export class ProjectRegistry {
     }
     requireAccountOwner(ownerId) {
         this.assertStorage();
-        if (this.data.version !== 2 || this.data.accountBinding?.ownerId !== ownerId)
-            throw new ProjectRegistryError(403, "此账号没有 Cloud 管理权限。");
+        if ((this.data.version === 2 && this.data.accountBinding?.ownerId === ownerId) ||
+            (this.data.version === 3 && this.data.owners.some((owner) => owner.id === ownerId)))
+            return;
+        throw new ProjectRegistryError(403, "此账号没有 Cloud 管理权限。");
     }
     createForOwner(username, name) {
         if (typeof name !== "string" ||
@@ -330,7 +435,7 @@ export class ProjectRegistry {
         if (this.data.projects.length >= 32)
             throw new ProjectRegistryError(429, "项目数量已达到上限（32 个）。");
         const next = structuredClone(this.data);
-        let owner = next.owners.find((item) => item.username === username);
+        let owner = next.owners.find((item) => "username" in item && item.username === username);
         if (!owner) {
             owner = { id: randomUUID(), username };
             next.owners.push(owner);
@@ -352,6 +457,30 @@ export class ProjectRegistry {
         this.data = next;
         return { ...project };
     }
+    createForAccountOwner(ownerId, name) {
+        if (typeof name !== "string" ||
+            !name.trim() ||
+            name.trim().length > 80 ||
+            /[\x00-\x1f\x7f]/.test(name))
+            throw new ProjectRegistryError(400, "请输入 1 至 80 个字符的项目名称。");
+        if (this.data.projects.length >= 128)
+            throw new ProjectRegistryError(429, "工作台项目数量已达到上限（128 个）。");
+        const next = structuredClone(this.data), timestamp = this.now(), project = {
+            id: randomUUID(),
+            ownerId,
+            name: name.trim(),
+            status: "stopped",
+            generation: 0,
+            runtimeUsername: "project-runtime",
+            runtimePassword: randomBytes(32).toString("base64url"),
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        next.projects.push(project);
+        this.write(next);
+        this.data = next;
+        return { ...project };
+    }
     update(id, patch) {
         this.assertStorage();
         const index = this.data.projects.findIndex((item) => item.id === id);

package/dist/serve/headless-server.js

@@ -594,6 +594,20 @@ export async function startHeadlessServer(opts) {
             hubJson(res, 200, { status: "ok", mode: hubAuth ? "hub" : "passcode" });
             return;
         }
+        // The public shell probes this before login. A standalone workspace has no
+        // Cloud browser authority; an explicit miss selects its existing Hub gate.
+        if (pathname === "/api/v1/cloud-browser/capabilities") {
+            if (req.url !== pathname) {
+                hubJson(res, 400, { error: "request parameters are not supported" });
+            }
+            else if (req.method !== "GET") {
+                hubJson(res, 405, { error: "method not allowed" });
+            }
+            else {
+                hubJson(res, 404, { error: "API endpoint not found" });
+            }
+            return;
+        }
         if (hubAuth) {
             if (await links?.handlePublic(req, res))
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-server",
-  "version": "0.9.37",
+  "version": "0.9.39",
   "description": "CodeShell server transport layer — mobile remote HTTP/WS host, pairing, passcode gate, tunnel, rooms, uploads, and session/attachment services. Electron-free; precursor of the auth gateway.",
   "type": "module",
   "main": "./dist/index.js",
@@ -61,13 +61,13 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-capability-coding": "0.9.37",
-    "@cjhyy/code-shell-core": "0.9.37",
-    "@cjhyy/code-shell-web": "0.9.37",
+    "@cjhyy/code-shell-capability-coding": "0.9.39",
+    "@cjhyy/code-shell-core": "0.9.39",
+    "@cjhyy/code-shell-web": "0.9.39",
     "@modelcontextprotocol/sdk": "^1.31.0",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0",
-    "@cjhyy/code-shell-link": "0.9.37"
+    "@cjhyy/code-shell-link": "0.9.39"
   },
   "engines": {
     "node": ">=20.10"