@cjhyy/code-shell-server 0.9.51 → 0.10.1

package/dist/account/feature-service.js

@@ -0,0 +1,184 @@
+import { accountPublicOrigin, readAccountFeatures, resolveAccountFeatures, } from "@cjhyy/code-shell-web/account";
+import { DEFAULT_CLOUD_ACCOUNT_ORIGIN, } from "./types.js";
+/** Host-owned cache, bound to an account generation. Snapshot reads never perform I/O. */
+export class AccountFeatureService {
+    deps;
+    origin;
+    subject = "";
+    generation = 0;
+    deployment;
+    account;
+    reachable = false;
+    controller;
+    inFlight;
+    lastAttempt = 0;
+    timer;
+    disposed = false;
+    listeners = new Set();
+    unsubscribe;
+    constructor(deps) {
+        this.deps = deps;
+        this.origin = deps.origin ?? DEFAULT_CLOUD_ACCOUNT_ORIGIN;
+        // Desktop composes this before Electron ready; keep OS credential loading lazy.
+        this.unsubscribe = deps.account.onStatus(() => {
+            this.synchronize();
+            this.publish();
+            if (!this.disposed)
+                void this.refresh();
+        });
+    }
+    synchronize() {
+        const status = this.deps.account.status();
+        const origin = status.origin ?? this.origin;
+        const subject = JSON.stringify([origin, status.account?.id, status.state]);
+        if (subject !== this.subject) {
+            ++this.generation;
+            this.controller?.abort();
+            this.inFlight = undefined;
+            if (origin !== this.origin)
+                this.deployment = undefined;
+            this.origin = origin;
+            this.subject = subject;
+            this.account = undefined;
+            this.reachable = false;
+            this.lastAttempt = 0;
+        }
+        return status;
+    }
+    snapshot() {
+        if (this.disposed)
+            return resolveAccountFeatures({ signedIn: false, supported: [] });
+        const status = this.synchronize();
+        return this.resolve(status, this.deps.local?.(status));
+    }
+    resolve(status, local) {
+        return resolveAccountFeatures({
+            deployment: this.deployment,
+            account: this.account,
+            signedIn: status.state === "signed-in" && !!status.account,
+            supported: this.deps.supported,
+            reachable: this.reachable,
+            storageError: status.state === "storage-error",
+            local,
+        });
+    }
+    onChanged(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    publish() {
+        const snapshot = this.snapshot();
+        for (const listener of this.listeners) {
+            try {
+                listener(snapshot);
+            }
+            catch {
+                /* One detached host cannot stop others. */
+            }
+        }
+    }
+    localChanged() {
+        if (!this.disposed)
+            this.publish();
+    }
+    /** Checks remote entitlement before a setup action, independent of its local prerequisite. */
+    requireEntitled(id) {
+        if (this.disposed)
+            throw new Error("账号功能服务已关闭。");
+        const status = this.synchronize();
+        this.requireView(this.resolve(status)[id].state);
+    }
+    requireReady(id) {
+        this.requireView(this.snapshot()[id].state);
+    }
+    requireView(state) {
+        if (this.disposed)
+            throw new Error("账号功能服务已关闭。");
+        if (state === "sign-in")
+            throw new Error("请先登录 CodeShell 账号。");
+        if (state === "pending")
+            throw new Error("账号功能尚未准备好，请检查连接后重试。");
+        if (state !== "ready")
+            throw new Error("当前账号服务未开放此功能。");
+    }
+    refresh(origin, minIntervalMs = 0) {
+        if (this.disposed)
+            return Promise.resolve(this.snapshot());
+        let status = this.synchronize();
+        if (origin !== undefined) {
+            if (!accountPublicOrigin(origin))
+                return Promise.reject(new Error("无效的账号服务地址。"));
+            if (status.origin && status.state === "signed-in" && origin !== status.origin)
+                return Promise.reject(new Error("请先退出当前账号，再切换账号服务。"));
+            if (origin !== this.origin) {
+                this.origin = origin;
+                this.deployment = undefined;
+                this.subject = "";
+                status = this.synchronize();
+                this.publish();
+            }
+        }
+        if (this.inFlight)
+            return this.inFlight;
+        const now = this.deps.now?.() ?? Date.now();
+        if (minIntervalMs > 0 && this.lastAttempt && now - this.lastAttempt < minIntervalMs)
+            return Promise.resolve(this.snapshot());
+        this.lastAttempt = now;
+        if (!this.timer) {
+            this.timer = setInterval(() => {
+                void this.refresh();
+            }, 600_000);
+            this.timer.unref?.();
+        }
+        const generation = this.generation;
+        const targetOrigin = this.origin;
+        const controller = new AbortController();
+        this.controller = controller;
+        const current = () => !this.disposed && !controller.signal.aborted && generation === this.generation;
+        const pending = Promise.resolve().then(async () => {
+            try {
+                const publicValue = await this.deps.account.capabilities(targetOrigin, controller.signal);
+                if (!current())
+                    return this.snapshot();
+                const deployment = readAccountFeatures(publicValue);
+                this.deployment = deployment;
+                if (status.state === "signed-in" && status.account) {
+                    const value = await this.deps.account.overview({ origin: targetOrigin, accountId: status.account.id }, current, controller.signal);
+                    if (!current())
+                        return this.snapshot();
+                    this.account = readAccountFeatures(value);
+                }
+                else
+                    this.account = undefined;
+                this.reachable = true;
+            }
+            catch {
+                if (current())
+                    this.reachable = false;
+            }
+            finally {
+                if (current()) {
+                    this.inFlight = undefined;
+                    this.publish();
+                }
+            }
+            return this.snapshot();
+        });
+        this.inFlight = pending;
+        return pending;
+    }
+    dispose() {
+        this.disposed = true;
+        this.reachable = false;
+        this.account = undefined;
+        this.deployment = undefined;
+        this.inFlight = undefined;
+        ++this.generation;
+        this.controller?.abort();
+        clearInterval(this.timer);
+        this.unsubscribe();
+        this.listeners.clear();
+    }
+}

package/dist/account/http.d.ts

@@ -0,0 +1,17 @@
+import type { ConnectionOptions } from "node:tls";
+export declare class CloudAccountHttpError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(status: number, path?: string, code?: unknown);
+}
+export interface CloudAccountRequest {
+    origin: string;
+    path: string;
+    method?: "GET" | "POST" | "DELETE" | "PATCH";
+    body?: unknown;
+    token?: string;
+    signal?: AbortSignal;
+}
+export type CloudAccountTransport = (input: CloudAccountRequest) => Promise<unknown>;
+/** Exact-origin HTTPS, bounded JSON, no redirect/cookie inheritance or raw errors. */
+export declare function createCloudAccountTransport(ca?: ConnectionOptions["ca"]): CloudAccountTransport;

package/dist/account/http.js

@@ -0,0 +1,158 @@
+import { request } from "node:https";
+import { isRelayOrigin } from "../remote-relay/protocol.js";
+function accountErrorMessage(status, path, code) {
+    if (status === 403 && code === "feature_not_entitled")
+        return "此账号功能当前不可用，请刷新功能状态。";
+    if (path === "/api/v1/account/profile") {
+        if (status === 400 && code === "invalid_display_name")
+            return "昵称需为 1–64 个字符，不能包含控制字符。";
+        if (status === 400 && code === "invalid_username")
+            return "用户名需为 3–64 位字母、数字、点、下划线或连字符，并以字母或数字开头。";
+        if (status === 409 && code === "username_unavailable")
+            return "此用户名已被使用，请换一个用户名。";
+        if (status === 404)
+            return "此云服务尚未启用账号资料编辑。";
+    }
+    if (path === "/api/v1/account/links" || path?.startsWith("/api/v1/account/links/")) {
+        if (status === 503 && code === "link_management_disabled")
+            return "此云服务尚未启用连接管理。";
+        if (status === 503 && code === "link_management_view_too_large")
+            return "连接管理列表超过服务上限，请联系服务管理员。";
+        if (status === 404 && code === "link_item_not_found")
+            return "此连接或授权不可用，请重新加载列表。";
+        if (status === 502)
+            return "连接服务暂时不可用，请稍后重新加载。";
+    }
+    const register = path === "/api/v1/account/register";
+    const login = path === "/api/v1/account/login";
+    if ((register || login) && status === 400) {
+        if (code === "invalid_username")
+            return "用户名需为 3–64 位字母、数字、点、下划线或连字符，并以字母或数字开头。";
+        if (code === "invalid_password")
+            return "密码需为 12–1024 位字符。";
+    }
+    if (register && status === 409 && code === "username_unavailable")
+        return "此用户名已被使用，请换一个用户名。";
+    if (login && status === 401 && code === "invalid_credentials")
+        return "用户名或密码错误，请重新输入。";
+    if ((register || path === "/api/v1/account/github/poll") &&
+        status === 403 &&
+        code === "registration_disabled")
+        return "此云服务暂未开放注册，请登录已有账号。";
+    const github = ["status", "start", "poll", "cancel"].some((action) => path === `/api/v1/account/github/${action}`);
+    if (github && status === 503) {
+        if (code === "github_disabled")
+            return "此云服务尚未配置 GitHub 登录，请使用账号密码。";
+        if (code === "github_unavailable")
+            return "GitHub 登录暂时不可用，请稍后重试。";
+    }
+    if (path === "/api/v1/account/github/poll") {
+        if (status === 409 && code === "provider_already_linked")
+            return "GitHub 关联冲突：当前账号或此 GitHub 已有其他关联。";
+        if (status === 401 && code === "github_login_denied")
+            return "GitHub 登录未获授权，请重新发起登录。";
+        if (status === 401 && code === "invalid_github_receipt")
+            return "GitHub 登录请求已过期，请重新发起登录。";
+        if (status === 502 && code === "github_login_failed")
+            return "GitHub 登录未完成，请重新发起登录。";
+    }
+    const browser = ["start", "poll", "cancel"].some((action) => path === `/api/v1/account/browser/${action}`);
+    if (browser) {
+        if (status === 400 &&
+            (code === "invalid_browser_login_request" || code === "invalid_device_name"))
+            return "网页登录请求无效，请重新发起登录。";
+        if (status === 401 && code === "invalid_browser_receipt")
+            return "网页登录请求已失效，请重新发起登录。";
+        if (status === 429 && code === "browser_login_limit")
+            return "网页登录请求过多，请稍后重试。";
+        if (path === "/api/v1/account/browser/poll") {
+            if (status === 401 && code === "browser_login_expired")
+                return "网页账号登录已失效，请在浏览器重新登录后重试。";
+            if (status === 403 && code === "browser_login_denied")
+                return "已取消此次桌面登录。如需登录，请重新发起。";
+        }
+    }
+    return status === 401 || status === 403
+        ? "云账号授权已失效，请重新登录。"
+        : status === 409
+            ? "账号或关联已存在冲突，请检查当前账号。"
+            : status === 429
+                ? "请求过于频繁，请稍后重试。"
+                : "云服务请求未完成，请检查服务地址和网络。";
+}
+export class CloudAccountHttpError extends Error {
+    status;
+    code;
+    constructor(status, path, code) {
+        super(accountErrorMessage(status, path, code));
+        this.status = status;
+        if (code === "feature_not_entitled" || code === "authentication_required")
+            this.code = code;
+    }
+}
+/** Exact-origin HTTPS, bounded JSON, no redirect/cookie inheritance or raw errors. */
+export function createCloudAccountTransport(ca) {
+    return (input) => {
+        if (!isRelayOrigin(input.origin) || !/^\/api\/v1\/(?:account|remote-hosts)\//.test(input.path))
+            return Promise.reject(new Error("无效的云服务地址。"));
+        if (input.method === "PATCH" && input.path !== "/api/v1/account/profile")
+            return Promise.reject(new Error("云账号资料请求无效。"));
+        if (input.method === "DELETE" &&
+            (!/^\/api\/v1\/account\/links\/(?:connections|grants)\/[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(input.path) ||
+                input.body !== undefined))
+            return Promise.reject(new Error("无效的云账号撤销请求。"));
+        const maxResponseBytes = input.method === "GET" && input.path === "/api/v1/account/links" ? 1_048_576 : 16_384;
+        return new Promise((resolve, reject) => {
+            const bytes = input.body === undefined ? undefined : Buffer.from(JSON.stringify(input.body));
+            const req = request(new URL(input.path, input.origin), {
+                method: input.method ?? "POST",
+                ca,
+                signal: input.signal,
+                headers: {
+                    Origin: input.origin,
+                    Accept: "application/json",
+                    ...(input.token ? { Authorization: `Bearer ${input.token}` } : {}),
+                    ...(bytes
+                        ? { "Content-Type": "application/json", "Content-Length": bytes.length }
+                        : {}),
+                },
+            }, (res) => {
+                const chunks = [];
+                let size = 0;
+                res.on("data", (chunk) => {
+                    size += chunk.length;
+                    if (size > maxResponseBytes)
+                        req.destroy(new Error("response too large"));
+                    else
+                        chunks.push(chunk);
+                });
+                res.on("error", () => reject(new CloudAccountHttpError(0)));
+                res.on("end", () => {
+                    if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+                        let code;
+                        try {
+                            const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+                            if (value && typeof value === "object" && !Array.isArray(value))
+                                code = value.error;
+                        }
+                        catch {
+                            // Invalid error bodies retain their HTTP status and safe fallback text.
+                        }
+                        reject(new CloudAccountHttpError(res.statusCode ?? 0, input.path, code));
+                        return;
+                    }
+                    try {
+                        resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+                    }
+                    catch {
+                        reject(new CloudAccountHttpError(0));
+                    }
+                });
+            });
+            const timer = setTimeout(() => req.destroy(new Error("deadline")), 15_000);
+            req.on("close", () => clearTimeout(timer));
+            req.on("error", () => reject(new CloudAccountHttpError(0)));
+            req.end(bytes);
+        });
+    };
+}

package/dist/account/links.d.ts

@@ -0,0 +1,13 @@
+import type { CloudAccountLinksRequest, CloudAccountLinkView, CloudAccountGitHubRequest } from "./types.js";
+export declare function accountGitHubRequest(value: unknown): CloudAccountGitHubRequest;
+export declare function accountLinksRequest(value: unknown): CloudAccountLinksRequest;
+/** Explicit projection strips unknown fields instead of forwarding server objects to the renderer. */
+export declare function accountLinkView(value: unknown): CloudAccountLinkView;
+export declare function accountLinkRevocation(value: unknown, input: Extract<CloudAccountLinksRequest, {
+    action: "revoke";
+}>): {
+    action: "revoke";
+    revoked: true;
+    kind: "connections" | "grants";
+    id: string;
+};

package/dist/account/links.js

@@ -0,0 +1,137 @@
+import { isRelayOrigin } from "../remote-relay/protocol.js";
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const invalid = () => new Error("云服务返回了无效的连接管理信息。");
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalid();
+    return value;
+}
+function text(value, max) {
+    if (typeof value !== "string" ||
+        !value.length ||
+        value.length > max ||
+        /[\x00-\x1f\x7f]/.test(value))
+        throw invalid();
+    return value;
+}
+function id(value) {
+    if (typeof value !== "string" || !uuid.test(value))
+        throw invalid();
+    return value;
+}
+function flag(value) {
+    if (typeof value !== "boolean")
+        throw invalid();
+    return value;
+}
+function strings(value, maxLength) {
+    if (!Array.isArray(value) || value.length > 100)
+        throw invalid();
+    return value.map((item) => text(item, maxLength));
+}
+function keys(value, expected) {
+    if (Object.keys(value).length !== expected.length || expected.some((key) => !(key in value)))
+        throw new Error("云账号请求无效。");
+}
+export function accountGitHubRequest(value) {
+    const input = object(value);
+    if (input.mode === "link") {
+        keys(input, ["mode"]);
+        return { mode: "link" };
+    }
+    if (input.mode !== "login")
+        throw new Error("GitHub 登录请求无效。");
+    keys(input, ["mode", "input"]);
+    const login = object(input.input);
+    if (Object.keys(login).some((key) => !["origin", "deviceName", "connectGitHub"].includes(key)))
+        throw new Error("GitHub 登录请求无效。");
+    if (!isRelayOrigin(login.origin) ||
+        login.origin.length > 2048 ||
+        (login.deviceName !== undefined && typeof login.deviceName !== "string") ||
+        (login.connectGitHub !== undefined && typeof login.connectGitHub !== "boolean"))
+        throw new Error("GitHub 登录请求无效。");
+    return {
+        mode: "login",
+        input: {
+            origin: login.origin,
+            ...(login.deviceName === undefined ? {} : { deviceName: login.deviceName }),
+            ...(login.connectGitHub === undefined
+                ? {}
+                : { connectGitHub: login.connectGitHub }),
+        },
+    };
+}
+export function accountLinksRequest(value) {
+    const input = object(value);
+    if (!isRelayOrigin(input.origin) || input.origin.length > 2048)
+        throw new Error("云账号请求无效。");
+    const identity = { origin: input.origin, accountId: id(input.accountId) };
+    if (input.action === "list") {
+        keys(input, ["action", "origin", "accountId"]);
+        return { ...identity, action: "list" };
+    }
+    if (input.action !== "revoke" || !["connections", "grants"].includes(input.kind))
+        throw new Error("云账号请求无效。");
+    keys(input, ["action", "origin", "accountId", "kind", "id"]);
+    return {
+        ...identity,
+        action: "revoke",
+        kind: input.kind,
+        id: id(input.id),
+    };
+}
+/** Explicit projection strips unknown fields instead of forwarding server objects to the renderer. */
+export function accountLinkView(value) {
+    const view = object(value);
+    if (!isRelayOrigin(view.linkOrigin) ||
+        view.linkOrigin.length > 2048 ||
+        !Array.isArray(view.connections) ||
+        view.connections.length > 512 ||
+        !Array.isArray(view.grants) ||
+        view.grants.length > 4096)
+        throw invalid();
+    const connectionIds = new Set();
+    const grantIds = new Set();
+    const connections = view.connections.map((raw) => {
+        const item = object(raw);
+        const account = object(item.account);
+        const connectionId = id(item.id);
+        if (connectionIds.has(connectionId))
+            throw invalid();
+        connectionIds.add(connectionId);
+        return {
+            id: connectionId,
+            provider: text(item.provider, 64),
+            account: {
+                id: text(account.id, 256),
+                ...(account.login === undefined ? {} : { login: text(account.login, 256) }),
+                ...(account.label === undefined ? {} : { label: text(account.label, 256) }),
+            },
+            revoked: flag(item.revoked),
+        };
+    });
+    const grants = view.grants.map((raw) => {
+        const item = object(raw);
+        const client = object(item.client);
+        const grantId = id(item.id);
+        const connectionId = id(item.connectionId);
+        if (grantIds.has(grantId) || !connectionIds.has(connectionId))
+            throw invalid();
+        grantIds.add(grantId);
+        return {
+            id: grantId,
+            connectionId,
+            client: { id: id(client.id), name: text(client.name, 100) },
+            scopes: strings(item.scopes, 128),
+            resources: strings(item.resources, 2048),
+            revoked: flag(item.revoked),
+        };
+    });
+    return { linkOrigin: view.linkOrigin, connections, grants };
+}
+export function accountLinkRevocation(value, input) {
+    const result = object(value);
+    if (result.revoked !== true || result.kind !== input.kind || result.id !== input.id)
+        throw invalid();
+    return { action: "revoke", revoked: true, kind: input.kind, id: input.id };
+}

package/dist/account/manager.d.ts

@@ -0,0 +1,96 @@
+import { type CloudManagementTicket } from "./cloud-contract.js";
+import type { CloudAccountCapabilities, CloudAccountBrowserLogin, CloudAccountOverview, CloudAccountGitHubLogin, CloudAccountLogin, CloudAccountStatus, CloudAccountLogoutResult, CloudAccountLinksRequest, CloudAccountLinksResult, CloudAccountProfileRequest } from "./types.js";
+import { CloudAccountStore } from "./store.js";
+import { type CloudAccountTransport } from "./http.js";
+/** Main-only continuation of the independent Link authorization job. */
+export interface PreparedGitHubLink {
+    authorizationUrl: string;
+    continue(url: string): Promise<"connected" | "cancelled">;
+    cancel(): void;
+}
+/** Optional cloud identity. Construction/status never initiate network activity. */
+export declare class CloudAccountManager {
+    private readonly deps;
+    private loaded;
+    private disposed;
+    private readonly statusListeners;
+    private saved?;
+    private state;
+    private generation;
+    private operation;
+    private refresh?;
+    private refreshResponse?;
+    private readonly revocationResponses;
+    private readonly request;
+    private githubConnection?;
+    private pendingGitHubLink?;
+    private profileRevision;
+    private profileRequestRevision;
+    private profileUpdate?;
+    private activation?;
+    private expiryTimer?;
+    constructor(deps: {
+        store: Pick<CloudAccountStore, "preflight" | "load" | "save" | "forget">;
+        request?: CloudAccountTransport;
+        openExternal: (url: string) => Promise<void>;
+        prepareGitHubLink?: (signal: AbortSignal, authorized: () => boolean) => Promise<PreparedGitHubLink>;
+        changed: (status: CloudAccountStatus) => void;
+        /** Retire only this account's remote access; never local work or LAN. */
+        retireRelay?: (identity: {
+            origin: string;
+            accountId: string;
+        }) => Promise<void>;
+        /** Explicit desktop login/resume enables account-owned device collaboration. */
+        activateRelay?: (identity: {
+            origin: string;
+            accountId: string;
+        }, authorized: () => boolean) => Promise<void>;
+        now?: () => number;
+        sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    });
+    private now;
+    private load;
+    status(): CloudAccountStatus;
+    onStatus(listener: (status: CloudAccountStatus) => void): () => void;
+    /** Cancel this host's work without revoking a saved account session. */
+    dispose(): void;
+    overview(input: {
+        origin: string;
+        accountId: string;
+    }, authorized?: () => boolean, signal?: AbortSignal): Promise<CloudAccountOverview>;
+    /** Public service discovery never reads or changes this device's account authority. */
+    capabilities(origin: string, signal?: AbortSignal): Promise<CloudAccountCapabilities>;
+    private relayCapability;
+    private armExpiry;
+    private activate;
+    /** The application explicitly restores saved authority once its main window is ready. */
+    resume(authorized?: () => boolean): Promise<CloudAccountStatus>;
+    private publish;
+    private invalidate;
+    private current;
+    private retire;
+    private validGrant;
+    private complete;
+    private revoke;
+    private prepare;
+    signIn(kind: "login" | "register", input: CloudAccountLogin, authorized?: () => boolean): Promise<CloudAccountStatus>;
+    /** The website confirms identity; only this Host can redeem and persist its own session. */
+    signInWithBrowser(input: CloudAccountBrowserLogin, authorized?: () => boolean): Promise<CloudAccountStatus>;
+    linkGitHub(authorized?: () => boolean): Promise<CloudAccountStatus>;
+    /** Every read/revoke is bound to the reviewed identity and the current local account incarnation. */
+    manageLinks(raw: CloudAccountLinksRequest, authorized?: () => boolean): Promise<CloudAccountLinksResult>;
+    profile(raw: CloudAccountProfileRequest, authorized?: () => boolean): Promise<CloudAccountStatus>;
+    signInWithGitHub(input: CloudAccountGitHubLogin, authorized?: () => boolean): Promise<CloudAccountStatus>;
+    private github;
+    private continueGitHubLink;
+    cancelSignIn(): void;
+    logout(): Promise<CloudAccountLogoutResult>;
+    /** Main-only root authority lease; refresh preserves it, logout/relogin invalidates it. */
+    captureRootAccount(origin: string, accountId: string, authorized: () => boolean): {
+        signal: AbortSignal;
+        current: () => void;
+        ticket: (targetOrigin: string, installationId: string) => Promise<CloudManagementTicket>;
+    };
+    /** Returns credentials only to main callers, for one exact service/account. */
+    getCredential(origin: string, accountId?: string, signal?: AbortSignal): Promise<string>;
+}