gaoding-cli 1.0.0-alpha.10

package/dist/src/features/editor/session.js

@@ -0,0 +1,193 @@
+import { createEditorBridgeClient } from "./bridge-client.js";
+import { startEditorBridgeProcess } from "./bridge-process.js";
+const DEFAULT_CREATE_URL = new URL("https://www.gaoding.art/editor/canvas?mode=create&type=board");
+const DEFAULT_WORK_URL = new URL("https://www.gaoding.art/editor/canvas");
+const DEFAULT_CONNECTION_TIMEOUT_MS = 60_000;
+const CONNECTION_POLL_INTERVAL_MS = 100;
+export class EditorTargetError extends Error {
+    code = "USAGE_ERROR";
+    constructor() {
+        super("Editor target 必须是作品 ID 或完整 HTTP(S) URL。");
+        this.name = "EditorTargetError";
+    }
+}
+export class EditorSessionNotFoundError extends Error {
+    code = "EDITOR_SESSION_NOT_FOUND";
+    constructor() {
+        super("当前没有 Editor 会话。");
+        this.name = "EditorSessionNotFoundError";
+    }
+}
+export class EditorNotReadyError extends Error {
+    code = "EDITOR_NOT_READY";
+    constructor() {
+        super("Editor 页面未在限定时间内就绪。");
+        this.name = "EditorNotReadyError";
+    }
+}
+export function resolveEditorTarget(value) {
+    return resolveTarget(value, DEFAULT_CREATE_URL, DEFAULT_WORK_URL).href;
+}
+export function createEditorSession(dependencies) {
+    const startProcess = dependencies.startProcess ?? startEditorBridgeProcess;
+    const createClient = dependencies.createClient ?? ((state) => createEditorBridgeClient({ state }));
+    const sleep = dependencies.sleep ?? abortableSleep;
+    const connectionTimeoutMs = Math.max(0, dependencies.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS);
+    return {
+        async connect(target, signal) {
+            signal.throwIfAborted();
+            const targetUrl = resolveTarget(target, dependencies.defaultCreateUrl, dependencies.workUrl);
+            await replaceCurrentSession(signal);
+            signal.throwIfAborted();
+            const state = await startProcess({
+                targetOrigin: targetUrl.origin,
+                ...(dependencies.homeDirectory === undefined
+                    ? {}
+                    : { homeDirectory: dependencies.homeDirectory }),
+                signal
+            });
+            const handoffUrl = buildHandoffUrl(targetUrl, state);
+            try {
+                signal.throwIfAborted();
+                await dependencies.browser.open(handoffUrl);
+                const client = createClient(state);
+                await waitForPage(client, signal);
+                await client.rpc("preflight", undefined, signal);
+            }
+            catch (cause) {
+                await cleanupFailedSession(state);
+                throw cause;
+            }
+            return { target: targetUrl.href };
+        },
+        async disconnect(signal) {
+            signal.throwIfAborted();
+            const state = await dependencies.store.read();
+            if (state === null)
+                return { disconnected: false };
+            const client = createClient(state);
+            try {
+                await client.health(signal);
+            }
+            catch (cause) {
+                signal.throwIfAborted();
+                await dependencies.store.removeIfOwned(state.token);
+                throw cause;
+            }
+            await client.disconnect(signal);
+            await dependencies.store.removeIfOwned(state.token);
+            return { disconnected: true };
+        },
+        async rpc(method, payload, signal) {
+            signal.throwIfAborted();
+            const state = await dependencies.store.read();
+            if (state === null)
+                throw new EditorSessionNotFoundError();
+            return createClient(state).rpc(method, payload, signal);
+        }
+    };
+    async function replaceCurrentSession(signal) {
+        const current = await dependencies.store.read();
+        if (current === null)
+            return;
+        const client = createClient(current);
+        try {
+            await client.health(signal);
+        }
+        catch (cause) {
+            signal.throwIfAborted();
+            await dependencies.store.removeIfOwned(current.token);
+            return;
+        }
+        await client.disconnect(signal);
+        await dependencies.store.removeIfOwned(current.token);
+    }
+    async function waitForPage(client, signal) {
+        const deadline = Date.now() + connectionTimeoutMs;
+        while (true) {
+            signal.throwIfAborted();
+            if ((await client.health(signal)).pageConnected)
+                return;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                throw new EditorNotReadyError();
+            await sleep(Math.min(CONNECTION_POLL_INTERVAL_MS, remaining), signal);
+        }
+    }
+    async function cleanupFailedSession(state) {
+        try {
+            const current = await dependencies.store.read();
+            if (current !== null && current.token !== state.token)
+                return;
+        }
+        catch {
+            // Continue best-effort cleanup without replacing the original failure.
+        }
+        try {
+            await createClient(state).disconnect(new AbortController().signal);
+        }
+        catch {
+            // The Bridge may already have stopped.
+        }
+        try {
+            const current = await dependencies.store.read();
+            if (current?.token === state.token) {
+                await dependencies.store.removeIfOwned(state.token);
+            }
+        }
+        catch {
+            // Preserve the browser, wait, or preflight failure.
+        }
+    }
+}
+function resolveTarget(value, createUrl, workUrl) {
+    if (value === undefined)
+        return new URL(createUrl.href);
+    if (/^\d+$/.test(value)) {
+        const url = new URL(workUrl.href);
+        url.search = new URLSearchParams({
+            type: "board",
+            mode: "user",
+            id: value
+        }).toString();
+        url.hash = "";
+        return url;
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new EditorTargetError();
+    }
+    if ((url.protocol !== "http:" && url.protocol !== "https:") ||
+        url.username !== "" ||
+        url.password !== "") {
+        throw new EditorTargetError();
+    }
+    return url;
+}
+function buildHandoffUrl(target, state) {
+    const url = new URL(target.href);
+    url.hash = new URLSearchParams({
+        "focused-editor-port": String(state.port),
+        "focused-editor-token": state.token
+    }).toString();
+    return url;
+}
+function abortableSleep(milliseconds, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(done, milliseconds);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        function done() {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }
+    });
+}

package/dist/src/features/editor/use-cases.js

@@ -0,0 +1,61 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { OutputContractError } from "../../bootstrap/validators.js";
+const PNG_DATA_URL_PREFIX = "data:image/png;base64,";
+const STRICT_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+export function createEditorUseCases(dependencies) {
+    const validate = dependencies.validate;
+    const temporaryDirectory = resolve(dependencies.temporaryDirectory ?? tmpdir());
+    return {
+        async connect({ input, signal }) {
+            const result = await dependencies.session.connect(input.target, signal);
+            validate.connect(result);
+            return result;
+        },
+        async disconnect({ signal }) {
+            const result = await dependencies.session.disconnect(signal);
+            validate.disconnect(result);
+            return result;
+        },
+        async snapshot({ signal }) {
+            const result = await dependencies.session.rpc("snapshot", undefined, signal);
+            validate.snapshot(result);
+            return result;
+        },
+        async apply({ input, signal }) {
+            await dependencies.session.rpc("apply", input, signal);
+            const result = { appliedCount: input.length };
+            validate.apply(result);
+            return result;
+        },
+        async screenshot({ signal }) {
+            const data = await dependencies.session.rpc("screenshot", undefined, signal);
+            const bytes = decodePngDataUrl(data);
+            signal.throwIfAborted();
+            const directory = await mkdtemp(join(temporaryDirectory, "gd-cli-editor-"));
+            const result = { path: join(directory, "screenshot.png") };
+            await writeFile(result.path, bytes);
+            validate.screenshot(result);
+            return result;
+        },
+        async save({ signal }) {
+            const result = await dependencies.session.rpc("save", undefined, signal);
+            validate.save(result);
+            return result;
+        }
+    };
+}
+function decodePngDataUrl(value) {
+    if (typeof value !== "string" || !value.startsWith(PNG_DATA_URL_PREFIX)) {
+        throw new OutputContractError();
+    }
+    const encoded = value.slice(PNG_DATA_URL_PREFIX.length);
+    if (encoded.length === 0 || !STRICT_BASE64.test(encoded)) {
+        throw new OutputContractError();
+    }
+    const bytes = Buffer.from(encoded, "base64");
+    if (bytes.toString("base64") !== encoded)
+        throw new OutputContractError();
+    return bytes;
+}

package/dist/src/features/org/org-service.js

@@ -0,0 +1,76 @@
+export class OrganizationResponseError extends Error {
+    constructor() {
+        super("组织列表响应无效。");
+        this.name = "OrganizationResponseError";
+    }
+}
+export function createOrgService(dependencies) {
+    return {
+        async list(credential, signal) {
+            const raw = await dependencies.transport.getJson({
+                path: "/structure/user/orgs",
+                credential,
+                signal
+            });
+            if (!Array.isArray(raw))
+                throw new OrganizationResponseError();
+            const records = [];
+            const seen = new Set();
+            for (const item of raw) {
+                const record = normalizeOrganization(item);
+                if (!record || seen.has(record.id))
+                    continue;
+                seen.add(record.id);
+                records.push(record);
+            }
+            return records;
+        }
+    };
+}
+function normalizeOrganization(value) {
+    if (!isRecord(value))
+        return null;
+    const company = isRecord(value.company) ? value.company : undefined;
+    const product = isRecord(value.product) ? value.product : undefined;
+    const id = identifier(value.org_id) ?? identifier(company?.id);
+    if (!id)
+        return null;
+    const realName = optionalString(company?.name) ?? null;
+    const expiry = finiteNumber(value.expire_date) ?? finiteNumber(product?.expire_date);
+    return {
+        id,
+        publicName: realName ?? `组织 ${id}`,
+        realName,
+        ...optionalField("type", optionalString(company?.org_class)),
+        ...optionalField("status", optionalString(company?.status)),
+        ...optionalField("productName", optionalString(product?.product_name)),
+        ...optionalField("productType", optionalString(product?.product_type)),
+        ...optionalField("expiresAt", epochMilliseconds(expiry))
+    };
+}
+function optionalField(key, value) {
+    return value === undefined ? {} : { [key]: value };
+}
+function epochMilliseconds(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function identifier(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return optionalString(value);
+}
+function optionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const text = value.trim();
+    return text || undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/features/org/use-cases.js

@@ -0,0 +1,140 @@
+import { classifyBindOutcome, SsoRequestError } from "../auth/sso-service.js";
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { OrganizationResponseError } from "./org-service.js";
+export class OrgUsageError extends Error {
+    constructor() {
+        super("请通过 --org 指定组织，或在交互终端中选择组织。");
+        this.name = "OrgUsageError";
+    }
+}
+export class OrganizationInvalidError extends Error {
+    constructor() {
+        super("所选组织不可用，请执行 gd-cli org list 确认可用组织。");
+        this.name = "OrganizationInvalidError";
+    }
+}
+export class OrganizationBindFailedError extends Error {
+    constructor() {
+        super("选择组织失败，请稍后重试。");
+        this.name = "OrganizationBindFailedError";
+    }
+}
+export function createOrgUseCases(dependencies) {
+    async function bind(credential, record, signal) {
+        const response = await dependencies.sso.bindOrganization({
+            credential,
+            organizationId: record.id
+        }, signal);
+        const outcome = classifyBindOutcome(response);
+        if (outcome.status === "invalid")
+            throw new OrganizationInvalidError();
+        if (outcome.status === "failed")
+            throw new OrganizationBindFailedError();
+        return {
+            id: record.id,
+            name: record.publicName,
+            ...(outcome.bindExpiresAt ? { bindExpiresAt: outcome.bindExpiresAt } : {})
+        };
+    }
+    return {
+        async list(input) {
+            const records = await dependencies.org.list(input.state.credential, input.signal);
+            return {
+                orgs: records.map((record) => ({
+                    id: record.id,
+                    name: record.publicName,
+                    ...(record.type ? { type: record.type } : {}),
+                    ...(record.status ? { status: record.status } : {}),
+                    ...(record.productName ? { product_name: record.productName } : {}),
+                    ...(record.productType ? { product_type: record.productType } : {}),
+                    ...(record.expiresAt ? { expires_at: record.expiresAt } : {})
+                })),
+                current_org_id: input.state.organization?.id ?? null
+            };
+        },
+        async current() {
+            const state = await dependencies.store.read();
+            return {
+                organization: state?.organization
+                    ? { id: state.organization.id, name: state.organization.name }
+                    : null,
+                next_steps: state?.organization
+                    ? []
+                    : ["gd-cli org list", "gd-cli org switch"]
+            };
+        },
+        async switchOrganization(input) {
+            input.signal.throwIfAborted();
+            const records = await dependencies.org.list(input.state.credential, input.signal);
+            const selectedId = input.organizationId === undefined
+                ? await selectOrganization(records, input.select)
+                : requiredSelection(input.organizationId);
+            const record = records.find((candidate) => candidate.id === selectedId);
+            if (!record)
+                throw new OrganizationInvalidError();
+            const organization = await bind(input.state.credential, record, input.signal);
+            await dependencies.store.write({ ...input.state, organization });
+            return record;
+        },
+        async bindAuthorizedOrganization(input) {
+            input.signal.throwIfAborted();
+            const organizationId = input.organizationId.trim();
+            if (!organizationId)
+                return null;
+            try {
+                const records = await dependencies.org.list(input.credential, input.signal);
+                const record = records.find((candidate) => candidate.id === organizationId);
+                if (!record?.realName)
+                    return null;
+                const bound = await bind(input.credential, record, input.signal);
+                return {
+                    id: bound.id,
+                    name: record.realName,
+                    ...(bound.bindExpiresAt ? { bindExpiresAt: bound.bindExpiresAt } : {})
+                };
+            }
+            catch (error) {
+                if (input.signal.aborted)
+                    throw input.signal.reason;
+                if (isExpectedAuthorizationFailure(error))
+                    return null;
+                throw error;
+            }
+        },
+        async refreshCurrentOrganization(input) {
+            input.signal.throwIfAborted();
+            const response = await dependencies.sso.bindOrganization({
+                credential: input.state.credential,
+                organizationId: input.state.organization.id
+            }, input.signal);
+            const outcome = classifyBindOutcome(response);
+            if (outcome.status === "invalid")
+                throw new OrganizationInvalidError();
+            if (outcome.status === "failed")
+                throw new OrganizationBindFailedError();
+            return {
+                id: input.state.organization.id,
+                name: input.state.organization.name,
+                ...(outcome.bindExpiresAt ? { bindExpiresAt: outcome.bindExpiresAt } : {})
+            };
+        }
+    };
+}
+async function selectOrganization(records, select) {
+    if (!select)
+        throw new OrgUsageError();
+    return requiredSelection(await select(records));
+}
+function requiredSelection(value) {
+    const selected = value.trim();
+    if (!selected)
+        throw new OrgUsageError();
+    return selected;
+}
+function isExpectedAuthorizationFailure(error) {
+    return error instanceof RemoteRequestError
+        || error instanceof SsoRequestError
+        || error instanceof OrganizationResponseError
+        || error instanceof OrganizationInvalidError
+        || error instanceof OrganizationBindFailedError;
+}

package/dist/src/features/skill/bundled-skills.js

@@ -0,0 +1,55 @@
+import { lstatSync, readFileSync } from "node:fs";
+import { dirname, join, parse, resolve } from "node:path";
+import { SkillSyncError } from "./installer.js";
+export function loadBundledSkills(startFile) {
+    let directory = directoryFrom(startFile);
+    const root = parse(directory).root;
+    while (directory !== root) {
+        const packageFile = join(directory, "package.json");
+        if (isFile(packageFile)) {
+            let metadata;
+            try {
+                metadata = JSON.parse(readFileSync(packageFile, "utf8"));
+            }
+            catch (error) {
+                throw new SkillSyncError(`无法读取 gaoding-cli package metadata: ${message(error)}`, []);
+            }
+            if (metadata.name === "gaoding-cli") {
+                if (typeof metadata.version !== "string" || !metadata.version.trim()) {
+                    throw new SkillSyncError("gaoding-cli package version 无效。", []);
+                }
+                const sourceDirectory = join(directory, "skills", "gd-cli");
+                if (!isFile(join(sourceDirectory, "SKILL.md"))) {
+                    throw new SkillSyncError(`Agent Skill source 不存在: ${sourceDirectory}`, []);
+                }
+                return [{
+                        skill: "gd-cli",
+                        version: metadata.version,
+                        sourceDirectory
+                    }];
+            }
+        }
+        directory = dirname(directory);
+    }
+    throw new SkillSyncError("无法定位 gaoding-cli package root。", []);
+}
+function directoryFrom(path) {
+    const absolute = resolve(path);
+    try {
+        return lstatSync(absolute).isDirectory() ? absolute : dirname(absolute);
+    }
+    catch {
+        return dirname(absolute);
+    }
+}
+function isFile(path) {
+    try {
+        return lstatSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}