@cjhyy/code-shell-server 0.9.51 → 0.10.1

package/dist/account/cli.d.ts

@@ -0,0 +1,23 @@
+import { CloudAccountManager } from "./manager.js";
+export declare const ACCOUNT_HELP = "Usage: account <login|status|features|links|logout|register> [options]\n  --origin <https-origin>  Account service (default: https://115.159.45.55)\n  --username <name>        Password login; password is prompted without echo\n  --password-stdin         Read one password from stdin; never put it in arguments\n  --github                 Sign in using GitHub in the browser\n  --memory                 Keep an interactive account session in this process only\n  --no-open                Print browser URLs instead of opening them\n\nCredentials use the OS credential store; no plaintext fallback. Registration opens\n<origin>/register. Local tasks and serve's Hub/passcode identity remain independent.\nWith --memory, login keeps an account console open: status, features, links, logout,\nregister, exit. Closing this console revokes its temporary login. No device relay\nor upload is started. Use the same --origin on later account commands. Persistent\ncommands for one origin are serialized; finish an active login before retrying.";
+export interface AccountCliOptions {
+    action: "login" | "status" | "features" | "links" | "logout" | "register";
+    origin: string;
+    username?: string;
+    github: boolean;
+    passwordStdin: boolean;
+    memory: boolean;
+    open: boolean;
+}
+export declare function parseAccountArgs(argv: string[]): AccountCliOptions;
+export interface AccountCliDependencies {
+    createManager?: (options: AccountCliOptions, openExternal: (url: string) => Promise<void>) => CloudAccountManager;
+    write?: (text: string) => void;
+    open?: (url: string) => Promise<void>;
+    prompt?: (label: string, secret?: boolean) => Promise<string>;
+    readPassword?: () => Promise<string>;
+    interactive?: boolean;
+    acquireLock?: (origin: string) => Promise<() => Promise<void>>;
+}
+/** Shared entry for TUI and serve; it never changes Host/Hub authentication. */
+export declare function runAccountCli(argv: string[], deps?: AccountCliDependencies): Promise<void>;

package/dist/account/cli.js

@@ -0,0 +1,249 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { CloudAccountManager } from "./manager.js";
+import { DEFAULT_CLOUD_ACCOUNT_ORIGIN } from "./types.js";
+import { MemoryAccountStore, NativeAccountStore } from "./native-store.js";
+import { acquireNativeAccountLock } from "./native-lock.js";
+import { accountRegistrationUrl, readAccountFeatures, resolveAccountFeatures, } from "@cjhyy/code-shell-web/account";
+export const ACCOUNT_HELP = `Usage: account <login|status|features|links|logout|register> [options]
+  --origin <https-origin>  Account service (default: ${DEFAULT_CLOUD_ACCOUNT_ORIGIN})
+  --username <name>        Password login; password is prompted without echo
+  --password-stdin         Read one password from stdin; never put it in arguments
+  --github                 Sign in using GitHub in the browser
+  --memory                 Keep an interactive account session in this process only
+  --no-open                Print browser URLs instead of opening them
+
+Credentials use the OS credential store; no plaintext fallback. Registration opens
+<origin>/register. Local tasks and serve's Hub/passcode identity remain independent.
+With --memory, login keeps an account console open: status, features, links, logout,
+register, exit. Closing this console revokes its temporary login. No device relay
+or upload is started. Use the same --origin on later account commands. Persistent
+commands for one origin are serialized; finish an active login before retrying.`;
+export function parseAccountArgs(argv) {
+    const [action, ...flags] = argv;
+    if (!["login", "status", "features", "links", "logout", "register"].includes(action))
+        throw new Error(ACCOUNT_HELP);
+    const options = {
+        action: action,
+        origin: DEFAULT_CLOUD_ACCOUNT_ORIGIN,
+        github: false,
+        passwordStdin: false,
+        memory: false,
+        open: true,
+    };
+    for (let i = 0; i < flags.length; i++) {
+        const flag = flags[i];
+        if (flag === "--origin" || flag === "--username") {
+            const value = flags[++i];
+            if (!value || value.startsWith("--"))
+                throw new Error(`Missing value for ${flag}`);
+            if (flag === "--origin")
+                options.origin = value;
+            else
+                options.username = value;
+        }
+        else if (flag === "--github")
+            options.github = true;
+        else if (flag === "--password-stdin")
+            options.passwordStdin = true;
+        else if (flag === "--memory")
+            options.memory = true;
+        else if (flag === "--no-open")
+            options.open = false;
+        else
+            throw new Error("Unknown account option. Passwords must use the hidden prompt or --password-stdin.");
+    }
+    accountRegistrationUrl(options.origin);
+    if (options.github && (options.username || options.passwordStdin))
+        throw new Error("Choose GitHub or password login.");
+    if (options.action !== "login" &&
+        (options.github || options.username || options.passwordStdin || options.memory))
+        throw new Error("Login options require account login.");
+    return options;
+}
+async function openBrowser(url) {
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "rundll32.exe"
+            : "xdg-open";
+    const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: "ignore", windowsHide: true });
+        child.on("error", () => reject(new Error("无法打开浏览器，请手动访问显示的地址。")));
+        child.on("exit", (code) => code === 0 ? resolve() : reject(new Error("无法打开浏览器，请手动访问显示的地址。")));
+    });
+}
+async function question(label, secret = false) {
+    if (!process.stdin.isTTY)
+        throw new Error("Interactive login needs a terminal. Use --username and --password-stdin.");
+    let muted = false;
+    const output = new Writable({
+        write(chunk, _encoding, done) {
+            if (!muted)
+                process.stderr.write(chunk);
+            done();
+        },
+    });
+    const rl = createInterface({ input: process.stdin, output, terminal: true });
+    try {
+        const answer = rl.question(label);
+        muted = secret;
+        return await answer;
+    }
+    finally {
+        rl.close();
+        if (secret)
+            process.stderr.write("\n");
+    }
+}
+async function stdinPassword() {
+    if (process.stdin.isTTY)
+        throw new Error("--password-stdin expects piped input.");
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of process.stdin) {
+        const bytes = Buffer.from(chunk);
+        size += bytes.length;
+        if (size > 4096)
+            throw new Error("Password input exceeds its limit.");
+        chunks.push(bytes);
+    }
+    const password = Buffer.concat(chunks)
+        .toString("utf8")
+        .replace(/\r?\n$/, "");
+    if (!password || /[\r\n]/.test(password))
+        throw new Error("Provide exactly one password on stdin.");
+    return password;
+}
+/** Shared entry for TUI and serve; it never changes Host/Hub authentication. */
+export async function runAccountCli(argv, deps = {}) {
+    const write = deps.write ?? ((text) => console.log(text));
+    if (!argv.length || argv.includes("--help") || argv.includes("-h")) {
+        write(ACCOUNT_HELP);
+        return;
+    }
+    const options = parseAccountArgs(argv);
+    const navigate = async (url) => {
+        write(url);
+        if (options.open)
+            await (deps.open ?? openBrowser)(url);
+    };
+    if (options.memory && (!(deps.interactive ?? process.stdin.isTTY) || options.passwordStdin))
+        throw new Error("--memory requires an interactive terminal and keeps the session open. Use OS storage for one-shot stdin login.");
+    const release = options.memory || options.action === "register"
+        ? undefined
+        : await (deps.acquireLock ?? acquireNativeAccountLock)(options.origin);
+    try {
+        const manager = deps.createManager?.(options, navigate) ??
+            new CloudAccountManager({
+                store: options.memory || options.action === "register"
+                    ? new MemoryAccountStore()
+                    : new NativeAccountStore(options.origin),
+                openExternal: navigate,
+                changed() { },
+            });
+        const register = async () => {
+            const capabilities = await manager.capabilities(options.origin);
+            if (!capabilities.registrationAllowed)
+                throw new Error("此账号服务暂未开放注册。");
+            await navigate(accountRegistrationUrl(options.origin));
+        };
+        const prompt = deps.prompt ?? question;
+        const display = async (action) => {
+            await manager.resume();
+            const status = manager.status();
+            if (action === "status") {
+                write(JSON.stringify(status, null, 2));
+                return;
+            }
+            const deployment = await manager.capabilities(options.origin);
+            const overview = status.state === "signed-in" && status.account && status.origin === options.origin
+                ? await manager.overview({ origin: options.origin, accountId: status.account.id })
+                : undefined;
+            const deploymentFeatures = readAccountFeatures(deployment);
+            const features = resolveAccountFeatures({
+                deployment: deploymentFeatures,
+                account: status.state === "signed-in" ? readAccountFeatures(overview) : undefined,
+                signedIn: status.state === "signed-in",
+                // This CLI currently implements account-owned Link listing only.
+                supported: deployment.linkManagementEnabled === true ? ["links.remote"] : [],
+            });
+            if (action === "links") {
+                if (features["links.remote"].state !== "ready" || !status.account)
+                    throw new Error(`Account Link list is ${features["links.remote"].state}. Sign in to a service with Link management enabled.`);
+                write(JSON.stringify(await manager.manageLinks({
+                    action: "list",
+                    origin: options.origin,
+                    accountId: status.account.id,
+                }), null, 2));
+            }
+            else
+                write(JSON.stringify({ ...status, features }, null, 2));
+        };
+        try {
+            if (options.action === "register") {
+                await register();
+                return;
+            }
+            if (options.action === "login") {
+                if (options.github)
+                    await manager.signInWithGitHub({ origin: options.origin, connectGitHub: false });
+                else
+                    await manager.signIn("login", {
+                        origin: options.origin,
+                        username: options.username ?? (await prompt("Username: ")),
+                        password: options.passwordStdin
+                            ? await (deps.readPassword ?? stdinPassword)()
+                            : await prompt("Password: ", true),
+                    });
+                const signedIn = manager.status();
+                write(JSON.stringify(signedIn, null, 2));
+                if (signedIn.state !== "signed-in")
+                    return;
+                try {
+                    await display("features");
+                }
+                catch {
+                    write("Signed in. Feature status could not be loaded; retry with account features.");
+                }
+                if (options.memory) {
+                    write("Temporary account session active. Commands: status, features, links, logout, register, exit.");
+                    while (true) {
+                        const command = (await prompt("account> ")).trim();
+                        if (command === "exit" || command === "logout")
+                            break;
+                        try {
+                            if (command === "status" || command === "features" || command === "links")
+                                await display(command);
+                            else if (command === "register")
+                                await register();
+                            else
+                                write("Commands: status, features, links, logout, register, exit");
+                        }
+                        catch {
+                            write("Account operation could not finish. Retry features, links, status, or exit.");
+                        }
+                    }
+                }
+            }
+            else if (options.action === "logout")
+                write(JSON.stringify(await manager.logout()));
+            else
+                await display(options.action);
+        }
+        finally {
+            try {
+                if (options.memory)
+                    await manager.logout();
+            }
+            finally {
+                manager.dispose();
+            }
+        }
+    }
+    finally {
+        await release?.();
+    }
+}

package/dist/account/cloud-contract.d.ts

@@ -0,0 +1,39 @@
+import type { CloudManagementRequest, CloudProject } from "./cloud-types.js";
+export declare const cloudToken: (value: unknown) => value is string;
+export declare function cloudObject(value: unknown): Record<string, unknown>;
+export declare function cloudId(value: unknown): string;
+export declare function cloudOrigin(value: unknown): string;
+export declare function cloudManagementRequest(value: unknown): CloudManagementRequest;
+export declare function cloudProject(value: unknown): CloudProject;
+export interface ManagedCloudGrant {
+    token: string;
+    session: {
+        id: string;
+        kind: "cloud-management";
+        audience: string;
+        installationId: string;
+        accountOrigin: string;
+        accountId: string;
+        managementEpoch: string;
+        expiresAt: number;
+    };
+}
+export interface CloudManagementTarget {
+    version: 2;
+    mode: "cloud-account";
+    cloudOrigin: string;
+    accountOrigin: string;
+    installationId: string;
+}
+export interface CloudManagementTicket {
+    ticket: string;
+    expiresAt: number;
+    cloudOrigin: string;
+    accountOrigin: string;
+    installationId: string;
+}
+export declare function cloudManagementTarget(value: unknown, input: CloudManagementRequest): CloudManagementTarget;
+export declare function cloudManagementTicket(value: unknown, target: Omit<CloudManagementTarget, "version" | "mode">, now: number): CloudManagementTicket;
+export declare function managedCloudGrant(value: unknown, input: CloudManagementRequest, now: number): ManagedCloudGrant;
+/** Include the grant incarnation so an old cleanup cannot erase a new login's cookie. */
+export declare function managedCloudPartition(grant: ManagedCloudGrant): string;

package/dist/account/cloud-contract.js

@@ -0,0 +1,134 @@
+import { createHash } from "node:crypto";
+import { isRelayOrigin } from "../remote-relay/protocol.js";
+const UUID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/;
+export const cloudToken = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{43}$/.test(value);
+const invalid = () => new Error("云端管理信息无效，请重新连接。");
+export function cloudObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalid();
+    return value;
+}
+export function cloudId(value) {
+    if (typeof value !== "string" || !UUID.test(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 time(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+        throw invalid();
+    return value;
+}
+export function cloudOrigin(value) {
+    if (!isRelayOrigin(value) || value.length > 2048)
+        throw invalid();
+    return value;
+}
+export function cloudManagementRequest(value) {
+    const input = cloudObject(value);
+    const identity = {
+        accountOrigin: cloudOrigin(input.accountOrigin),
+        accountId: cloudId(input.accountId),
+        cloudOrigin: cloudOrigin(input.cloudOrigin),
+    };
+    let fields = ["accountOrigin", "accountId", "cloudOrigin", "action"];
+    if (input.action === "create")
+        fields = [...fields, "name"];
+    else if (["start", "stop", "open"].includes(input.action))
+        fields = [...fields, "projectId"];
+    else if (input.action !== "list" && input.action !== "logout")
+        throw invalid();
+    if (Object.keys(input).length !== fields.length || fields.some((key) => !(key in input)))
+        throw invalid();
+    if (input.action === "create") {
+        const name = text(input.name, 80).trim();
+        if (!name)
+            throw invalid();
+        return { ...identity, action: "create", name };
+    }
+    if (input.action === "list" || input.action === "logout")
+        return { ...identity, action: input.action };
+    return {
+        ...identity,
+        action: input.action,
+        projectId: cloudId(input.projectId),
+    };
+}
+export function cloudProject(value) {
+    const row = cloudObject(value);
+    if (!["stopped", "starting", "running", "stopping", "error"].includes(row.status))
+        throw invalid();
+    return {
+        id: cloudId(row.id),
+        name: text(row.name, 80),
+        status: row.status,
+        generation: time(row.generation),
+        createdAt: time(row.createdAt),
+        updatedAt: time(row.updatedAt),
+        ...(row.error === undefined ? {} : { error: text(row.error, 2048) }),
+    };
+}
+export function cloudManagementTarget(value, input) {
+    const row = cloudObject(value);
+    if (row.version !== 2 ||
+        row.mode !== "cloud-account" ||
+        row.cloudOrigin !== input.cloudOrigin ||
+        row.accountOrigin !== input.accountOrigin)
+        throw invalid();
+    return {
+        version: 2,
+        mode: "cloud-account",
+        cloudOrigin: input.cloudOrigin,
+        accountOrigin: input.accountOrigin,
+        installationId: cloudId(row.installationId),
+    };
+}
+export function cloudManagementTicket(value, target, now) {
+    const row = cloudObject(value);
+    if (!cloudToken(row.ticket) ||
+        row.cloudOrigin !== target.cloudOrigin ||
+        row.accountOrigin !== target.accountOrigin ||
+        row.installationId !== target.installationId ||
+        time(row.expiresAt) <= now ||
+        row.expiresAt > now + 60_000)
+        throw invalid();
+    return { ticket: row.ticket, expiresAt: row.expiresAt, ...target };
+}
+export function managedCloudGrant(value, input, now) {
+    const row = cloudObject(value), s = cloudObject(row.session);
+    if (!cloudToken(row.token) ||
+        s.kind !== "cloud-management" ||
+        s.audience !== input.cloudOrigin ||
+        s.accountOrigin !== input.accountOrigin ||
+        s.accountId !== input.accountId ||
+        time(s.expiresAt) <= now ||
+        s.expiresAt > now + 600_000)
+        throw invalid();
+    return {
+        token: row.token,
+        session: {
+            id: cloudId(s.id),
+            kind: "cloud-management",
+            audience: input.cloudOrigin,
+            installationId: cloudId(s.installationId),
+            accountOrigin: input.accountOrigin,
+            accountId: input.accountId,
+            managementEpoch: cloudId(s.managementEpoch),
+            expiresAt: s.expiresAt,
+        },
+    };
+}
+/** Include the grant incarnation so an old cleanup cannot erase a new login's cookie. */
+export function managedCloudPartition(grant) {
+    const s = grant.session;
+    return `persist:codeshell-account-cloud-${createHash("sha256")
+        .update(JSON.stringify([s.audience, s.accountOrigin, s.accountId, s.managementEpoch, s.id]))
+        .digest("hex")}`;
+}

package/dist/account/cloud-types.d.ts

@@ -0,0 +1,47 @@
+/** Public Cloud management contract. All credentials and browser cookies remain in Main. */
+export interface CloudProject {
+    id: string;
+    name: string;
+    status: "stopped" | "starting" | "running" | "stopping" | "error";
+    generation: number;
+    createdAt: number;
+    updatedAt: number;
+    error?: string;
+}
+export type CloudManagementRequest = {
+    accountOrigin: string;
+    accountId: string;
+    cloudOrigin: string;
+} & ({
+    action: "list";
+} | {
+    action: "logout";
+} | {
+    action: "create";
+    name: string;
+} | {
+    action: "start" | "stop" | "open";
+    projectId: string;
+});
+export type CloudManagementResult = {
+    action: "list";
+    available: boolean;
+    error?: string;
+    projects: CloudProject[];
+} | {
+    action: "create" | "start" | "stop";
+    project: CloudProject;
+} | {
+    action: "open";
+    project: CloudProject;
+    address: string;
+} | {
+    action: "logout";
+    revoked: true;
+};
+export interface CloudWorkbenchApi {
+    (address: string): Promise<{
+        address: string;
+    }>;
+    (input: CloudManagementRequest): Promise<CloudManagementResult>;
+}

package/dist/account/cloud-types.js

@@ -0,0 +1 @@
+export {};

package/dist/account/feature-service.d.ts

@@ -0,0 +1,47 @@
+import { type AccountFeatureId, type AccountFeatureSnapshot, type ResolveAccountFeaturesInput } from "@cjhyy/code-shell-web/account";
+import { type CloudAccountStatus, type CloudAccountCapabilities, type CloudAccountOverview } from "./types.js";
+export interface AccountFeatureAuthority {
+    status(): CloudAccountStatus;
+    onStatus(listener: (status: CloudAccountStatus) => void): () => void;
+    capabilities(origin: string, signal?: AbortSignal): Promise<CloudAccountCapabilities>;
+    overview(identity: {
+        origin: string;
+        accountId: string;
+    }, authorized?: () => boolean, signal?: AbortSignal): Promise<CloudAccountOverview>;
+}
+/** Host-owned cache, bound to an account generation. Snapshot reads never perform I/O. */
+export declare class AccountFeatureService {
+    private readonly deps;
+    private origin;
+    private subject;
+    private generation;
+    private deployment?;
+    private account?;
+    private reachable;
+    private controller?;
+    private inFlight?;
+    private lastAttempt;
+    private timer?;
+    private disposed;
+    private readonly listeners;
+    private readonly unsubscribe;
+    constructor(deps: {
+        account: AccountFeatureAuthority;
+        origin?: string;
+        supported: readonly AccountFeatureId[];
+        local?: (status: CloudAccountStatus) => ResolveAccountFeaturesInput["local"];
+        now?: () => number;
+    });
+    private synchronize;
+    snapshot(): AccountFeatureSnapshot;
+    private resolve;
+    onChanged(listener: (snapshot: AccountFeatureSnapshot) => void): () => void;
+    private publish;
+    localChanged(): void;
+    /** Checks remote entitlement before a setup action, independent of its local prerequisite. */
+    requireEntitled(id: AccountFeatureId): void;
+    requireReady(id: AccountFeatureId): void;
+    private requireView;
+    refresh(origin?: string, minIntervalMs?: number): Promise<AccountFeatureSnapshot>;
+    dispose(): void;
+}