gaoding-cli 1.0.0-alpha.5

package/dist/src/api/direct-auth.d.ts

@@ -0,0 +1,3 @@
+export type DirectAuthMode = "aksk";
+export declare function resolveDirectAuthMode(): DirectAuthMode;
+export declare function readEnv(...keys: string[]): string | undefined;

package/dist/src/api/direct-auth.js

@@ -0,0 +1,11 @@
+export function resolveDirectAuthMode() {
+    return "aksk";
+}
+export function readEnv(...keys) {
+    for (const key of keys) {
+        const value = process.env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}

package/dist/src/api/direct-client.d.ts

@@ -0,0 +1,27 @@
+import { CredentialStoreV2 } from "../auth/credential-store-v2.js";
+type QueryValue = string | number | boolean | readonly (string | number | boolean)[] | undefined;
+export interface DirectRequestOptions {
+    query?: Record<string, QueryValue>;
+    headers?: Record<string, string>;
+    auth?: boolean;
+}
+export declare class DirectApiError extends Error {
+    statusCode: number;
+    body: unknown;
+    url: string;
+    constructor(statusCode: number, body: unknown, url: string);
+}
+export declare class DirectApiClient {
+    private baseUrl;
+    private storeV2;
+    constructor(baseUrl?: string, storeV2?: CredentialStoreV2);
+    get<T>(path: string, options?: DirectRequestOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: DirectRequestOptions): Promise<T>;
+    delete<T>(path: string, options?: DirectRequestOptions): Promise<T>;
+    private request;
+    private attachAuthHeaders;
+}
+export declare function unwrapEnvelope<T>(value: T | {
+    data: T;
+}): T;
+export {};

package/dist/src/api/direct-client.js

@@ -0,0 +1,151 @@
+import chalk from "chalk";
+import { CredentialStoreV2 } from "../auth/credential-store-v2.js";
+import { signApiRequest } from "../core/auth/signature.js";
+import { isCredentialsV2 } from "../core/auth/types.js";
+import { CLI_USER_AGENT, resolveApiBase, resolveEndpoints } from "../utils/config.js";
+import { readEnv } from "./direct-auth.js";
+import { redactSensitiveText } from "../utils/redact.js";
+export class DirectApiError extends Error {
+    statusCode;
+    body;
+    url;
+    constructor(statusCode, body, url) {
+        const extraHint = resolveAuthTypeHint(statusCode, body);
+        super(redactSensitiveText(`业务 API 请求失败 [${statusCode}] ${url}: ${formatErrorBody(body)}${extraHint}`));
+        this.statusCode = statusCode;
+        this.body = body;
+        this.url = url;
+        this.name = "DirectApiError";
+    }
+}
+export class DirectApiClient {
+    baseUrl;
+    storeV2;
+    constructor(baseUrl = resolveApiBase(), storeV2 = new CredentialStoreV2()) {
+        this.baseUrl = normalizeBaseUrl(baseUrl);
+        this.storeV2 = storeV2;
+    }
+    async get(path, options) {
+        return this.request("GET", path, undefined, options);
+    }
+    async post(path, body, options) {
+        return this.request("POST", path, body, options);
+    }
+    async delete(path, options) {
+        return this.request("DELETE", path, undefined, options);
+    }
+    async request(method, path, body, options = {}) {
+        const url = buildUrl(this.baseUrl, path, options.query);
+        const headers = new Headers({
+            Accept: "application/json",
+            "User-Agent": CLI_USER_AGENT,
+            ...defaultBusinessHeaders(this.baseUrl),
+            ...(options.headers ?? {}),
+        });
+        if (body !== undefined) {
+            headers.set("Content-Type", "application/json");
+        }
+        if (options.auth !== false) {
+            await this.attachAuthHeaders(headers, method, url);
+        }
+        const response = await fetch(url.toString(), {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const parsed = await parseResponse(response);
+        if (!response.ok) {
+            throw new DirectApiError(response.status, parsed, url.toString());
+        }
+        return parsed;
+    }
+    async attachAuthHeaders(headers, method, url) {
+        const v2 = this.storeV2.read();
+        if (v2 && isCredentialsV2(v2)) {
+            if (!v2.current_org?.id) {
+                throw new Error(chalk.yellow("当前未绑定组织：请先执行 gd-cli org switch\n"));
+            }
+            const { signature, timestamp } = signApiRequest(method, url.pathname, url.searchParams.toString(), v2.sk);
+            headers.set("X-AccessKey", v2.ak);
+            headers.set("X-Signature", signature);
+            headers.set("X-Timestamp", timestamp);
+            headers.set("X-Org-Id", v2.current_org.id);
+            return;
+        }
+        console.log("");
+        throw new Error(chalk.yellow("先登录并绑定组织：gd-cli auth login\n"));
+    }
+}
+export function unwrapEnvelope(value) {
+    if (value &&
+        typeof value === "object" &&
+        "data" in value &&
+        value.data !== undefined) {
+        return value.data;
+    }
+    return value;
+}
+function normalizeBaseUrl(value) {
+    return value.replace(/\/$/, "");
+}
+function buildUrl(baseUrl, path, query) {
+    const normalizedPath = path.replace(/^\//, "");
+    const url = new URL(`${baseUrl}/${normalizedPath}`);
+    for (const key of Object.keys(query ?? {}).sort()) {
+        const value = query?.[key];
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                url.searchParams.append(key, String(item));
+        }
+        else {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return url;
+}
+async function parseResponse(response) {
+    const text = await response.text();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function defaultBusinessHeaders(baseUrl) {
+    const endpoints = resolveEndpoints();
+    const origin = readEnv("GD_ORIGIN", "GAODING_ORIGIN") ??
+        endpoints.web_origin.value ??
+        originFromBaseUrl(baseUrl);
+    const referer = readEnv("GD_REFERER", "GAODING_REFERER") ?? `${origin}/`;
+    return Object.fromEntries(Object.entries({
+        Origin: origin,
+        Referer: referer,
+        "x-channel-id": readEnv("GD_CHANNEL_ID", "GAODING_CHANNEL_ID") ??
+            endpoints.channel_id.value,
+        "x-business-id": readEnv("GD_BUSINESS_ID", "GAODING_BUSINESS_ID") ??
+            endpoints.business_id.value,
+    }).filter(([, value]) => Boolean(value)));
+}
+function originFromBaseUrl(baseUrl) {
+    const parsed = new URL(baseUrl);
+    return `${parsed.protocol}//${parsed.host}`;
+}
+function formatErrorBody(body) {
+    if (typeof body === "string")
+        return body;
+    return JSON.stringify(body);
+}
+function resolveAuthTypeHint(statusCode, body) {
+    const text = typeof body === "string" ? body : body ? JSON.stringify(body) : "";
+    if (statusCode === 401 &&
+        /Unsupported Authorization Type/i.test(text)) {
+        return ("\n\n当前仅支持 AK/SK 签名鉴权。请重新登录并确认网关支持 X-AccessKey / X-Signature：\n" +
+            "  gd-cli auth login\n");
+    }
+    return "";
+}

package/dist/src/api/direct-tools.d.ts

@@ -0,0 +1,43 @@
+import { DirectApiClient } from "./direct-client.js";
+import type { TaskResult } from "./task-poller.js";
+interface InvokeOptions {
+    async?: boolean;
+    timeout?: number;
+}
+export declare class MediaResourceError extends Error {
+    url?: string | undefined;
+    code: string;
+    constructor(message: string, url?: string | undefined);
+}
+export declare class DirectToolInvoker {
+    private client;
+    private dam;
+    constructor(client?: DirectApiClient);
+    invoke(toolName: string, params: Record<string, unknown>, options?: InvokeOptions): Promise<TaskResult>;
+    private handlers;
+    private requireRemoteImage;
+    private optionalRemoteImage;
+    private remoteMedia;
+    private uploadPngBuffer;
+    private resolveMattingMode;
+    private prepareVideoReferenceImage;
+    private invokeModelOrderedAsyncTool;
+    private resolveDailyCachedModelOrder;
+    private resolveSceneCode;
+    private resolveToolIntent;
+    private callSyncTool;
+    private callAsyncTool;
+    private pollDifyTask;
+    private pollSuperResolution;
+}
+export interface ResolvedNumericContentId {
+    value: string;
+    generated: boolean;
+    requested?: string;
+}
+export declare function resolveNumericContentId(requested?: string): ResolvedNumericContentId;
+export declare function probeReferenceImageUrl(url: string): Promise<void>;
+export declare function isSignedDamReferenceUrl(url: string): boolean;
+export declare function isRiskyVideoReferenceUrl(url: string): boolean;
+export declare function normalizeMediaUrlArguments(args: Record<string, unknown>): Record<string, unknown>;
+export {};