gaoding-cli 1.0.0-alpha.5

package/dist/src/utils/config.d.ts

@@ -0,0 +1,16 @@
+export { CREDENTIALS_FILE, DEFAULT_GD_DIR, GD_DIR, REGISTRY_CACHE_FILE, SETTINGS_FILE, hasCustomGdHome, resolveGdHome, } from "./gd-home.js";
+export { resolveApiBase, resolveApiBaseInfo, resolveSsoBase, resolveAuthPageOrigin, resolveEndpoints, resolveActiveEnv, buildDeviceAuthPageUrls, AUTH_PAGE_PATH, } from "./endpoints.js";
+export declare const PROD_API_BASE = "https://gdcli.gaoding.com/api";
+/** @deprecated Use GD_DIR */
+export declare const GDHUB_DIR: string;
+/** Migrate credentials from the early internal storage directory when present. */
+export declare function migrateCredentialsIfNeeded(): void;
+export declare const CLI_VERSION = "1.0.0-alpha.5";
+export declare const CLI_PACKAGE_NAME = "gaoding-cli";
+export declare const CLI_USER_AGENT = "gd-cli/1.0.0-alpha.5";
+export declare const GDHUB_CLI_CLIENT_ID = "gdhub-cli";
+export declare const DEFAULT_SCOPE: readonly ["scene-executor", "run:scene-app", "use:tools", "export", "read:public"];
+export declare const CACHE_TTL_MS: number;
+export declare const WEB_ORIGIN = "https://gaoding.art";
+export declare function isVerbose(): boolean;
+export declare function isDebug(): boolean;

package/dist/src/utils/config.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import { ensureCredentialDir, ensureCredentialFile } from "./credential-permissions.js";
+import { CREDENTIALS_FILE, GD_DIR, REGISTRY_CACHE_FILE, hasCustomGdHome, } from "./gd-home.js";
+export { CREDENTIALS_FILE, DEFAULT_GD_DIR, GD_DIR, REGISTRY_CACHE_FILE, SETTINGS_FILE, hasCustomGdHome, resolveGdHome, } from "./gd-home.js";
+export { resolveApiBase, resolveApiBaseInfo, resolveSsoBase, resolveAuthPageOrigin, resolveEndpoints, resolveActiveEnv, buildDeviceAuthPageUrls, AUTH_PAGE_PATH, } from "./endpoints.js";
+export const PROD_API_BASE = "https://gdcli.gaoding.com/api";
+/** @deprecated Use GD_DIR */
+export const GDHUB_DIR = GD_DIR;
+const LEGACY_DIR = path.join(os.homedir(), ".gdhub");
+/** Migrate credentials from the early internal storage directory when present. */
+export function migrateCredentialsIfNeeded() {
+    if (hasCustomGdHome())
+        return;
+    if (fs.existsSync(GD_DIR))
+        return;
+    if (!fs.existsSync(LEGACY_DIR))
+        return;
+    ensureCredentialDir(GD_DIR);
+    const legacyCreds = path.join(LEGACY_DIR, "credentials.json");
+    if (fs.existsSync(legacyCreds)) {
+        fs.copyFileSync(legacyCreds, CREDENTIALS_FILE);
+        ensureCredentialFile(CREDENTIALS_FILE);
+    }
+    const legacyCache = path.join(LEGACY_DIR, "registry-cache.json");
+    if (fs.existsSync(legacyCache)) {
+        fs.copyFileSync(legacyCache, REGISTRY_CACHE_FILE);
+        ensureCredentialFile(REGISTRY_CACHE_FILE);
+    }
+}
+function readEnv(key, legacyKey) {
+    return process.env[key] ?? process.env[legacyKey];
+}
+export const CLI_VERSION = "1.0.0-alpha.5";
+export const CLI_PACKAGE_NAME = "gaoding-cli";
+export const CLI_USER_AGENT = `gd-cli/${CLI_VERSION}`;
+export const GDHUB_CLI_CLIENT_ID = "gdhub-cli";
+export const DEFAULT_SCOPE = [
+    "scene-executor",
+    "run:scene-app",
+    "use:tools",
+    "export",
+    "read:public",
+];
+export const CACHE_TTL_MS = Number(readEnv("GD_CACHE_TTL", "GDHUB_CACHE_TTL") ?? 86400) * 1000;
+export const WEB_ORIGIN = "https://gaoding.art";
+export function isVerbose() {
+    return readEnv("GD_VERBOSE", "GDHUB_VERBOSE") === "1" || process.argv.includes("--verbose");
+}
+export function isDebug() {
+    const d = process.env.DEBUG ?? "";
+    return d.includes("gd") || d.includes("gdhub");
+}

package/dist/src/utils/credential-permissions.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureCredentialDir(dir: string): void;
+export declare function ensureCredentialFile(file: string): void;

package/dist/src/utils/credential-permissions.js

@@ -0,0 +1,22 @@
+import fs from "node:fs";
+export function ensureCredentialDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    chmodIfPosix(dir, 0o700);
+}
+export function ensureCredentialFile(file) {
+    if (fs.existsSync(file)) {
+        chmodIfPosix(file, 0o600);
+    }
+}
+function chmodIfPosix(target, mode) {
+    if (process.platform === "win32")
+        return;
+    try {
+        fs.chmodSync(target, mode);
+    }
+    catch {
+        /* Ignore filesystems that do not support POSIX modes. */
+    }
+}

package/dist/src/utils/ecommerce-input-guidance.d.ts

@@ -0,0 +1,15 @@
+export interface EcommerceInputGuidance {
+    required_fields: string[];
+    missing_required_fields: string[];
+    recommended_fields: string[];
+    missing_recommended_fields: string[];
+    assumed_defaults: string[];
+    clarification_required: boolean;
+    clarification_recommended: boolean;
+    questions: string[];
+}
+export declare function buildEcommerceInputGuidance(input: {
+    appId?: string;
+    brief?: unknown;
+    hasReferenceImage: boolean;
+}): EcommerceInputGuidance;

package/dist/src/utils/ecommerce-input-guidance.js

@@ -0,0 +1,85 @@
+export function buildEcommerceInputGuidance(input) {
+    const brief = typeof input.brief === "string" ? input.brief.trim() : "";
+    const missingRequired = [
+        ...(input.hasReferenceImage ? [] : ["商品参考图"]),
+        ...(brief ? [] : ["商品 brief"]),
+    ];
+    const missingRecommended = recommendedMissingFields(brief);
+    return {
+        required_fields: ["商品参考图", "商品 brief"],
+        missing_required_fields: missingRequired,
+        recommended_fields: ["商品品类/名称", "核心卖点", "使用场景/目标人群", "目标平台或渠道", "必须出现的短文案"],
+        missing_recommended_fields: missingRecommended,
+        assumed_defaults: assumedDefaults(input.appId, missingRecommended),
+        clarification_required: missingRequired.length > 0,
+        clarification_recommended: missingRecommended.length > 0,
+        questions: buildQuestions(missingRequired, missingRecommended),
+    };
+}
+function recommendedMissingFields(brief) {
+    if (!brief)
+        return ["商品品类/名称", "核心卖点", "使用场景/目标人群", "目标平台或渠道", "必须出现的短文案"];
+    const missing = [];
+    if (!hasProductIdentity(brief))
+        missing.push("商品品类/名称");
+    if (!hasSellingPoint(brief))
+        missing.push("核心卖点");
+    if (!hasUsageContext(brief))
+        missing.push("使用场景/目标人群");
+    if (!hasPlatformContext(brief))
+        missing.push("目标平台或渠道");
+    if (!hasCopyRequirement(brief))
+        missing.push("必须出现的短文案");
+    return missing;
+}
+function assumedDefaults(appId, missing) {
+    const defaults = [];
+    if (missing.includes("核心卖点")) {
+        defaults.push("从商品品类推断 1-2 个常见购买利益点，画面用材质、结构、动作或场景证明。");
+    }
+    if (missing.includes("使用场景/目标人群")) {
+        defaults.push("按商品品类选择可信默认场景，例如桌面办公、通勤户外、梳妆台、厨房餐桌或居家空间。");
+    }
+    if (missing.includes("目标平台或渠道")) {
+        defaults.push(defaultPlatformForApp(appId));
+    }
+    if (missing.includes("必须出现的短文案")) {
+        defaults.push("自动从标题和首个卖点生成短文案；用户明确 no-text / layout-copy 时只输出后期排版文案。");
+    }
+    return defaults;
+}
+function defaultPlatformForApp(appId) {
+    if (appId === "social-seeding-pack")
+        return "默认按小红书封面和正文配图组织。";
+    if (appId === "campaign-kv-pack")
+        return "默认按官网横版、社媒方图和电商竖图组织。";
+    if (appId === "pdp-a-plus")
+        return "默认按详情页/A+模块组织购买说服顺序。";
+    return "默认按电商 Listing 图库组织主图、卖点图、细节图和生活方式图。";
+}
+function buildQuestions(required, recommended) {
+    if (required.length > 0) {
+        return required.map((field) => `请补充${field}。`);
+    }
+    return recommended.slice(0, 3).map((field) => `如需更准结果，可补充${field}；未补充时将按品类默认生成。`);
+}
+function hasProductIdentity(brief) {
+    return /[\u4e00-\u9fa5A-Za-z0-9]{2,}(?:衣|鞋|包|灯|耳机|茶|饮|精华|面霜|收纳|桌|椅|机|器|瓶|杯|盒|套装|夹克|台灯|背包|跑鞋)/i
+        .test(brief);
+}
+function hasSellingPoint(brief) {
+    return /轻薄|透气|防晒|缓震|柔和|护眼|折叠|节省|收纳|清爽|低糖|复古|静音|可更换|防泼水|大容量|高辨识|材质|结构|卖点|利益点|核心/i
+        .test(brief);
+}
+function hasUsageContext(brief) {
+    return /适合|面向|人群|通勤|户外|办公|学习|阅读|桌面|居家|卧室|厨房|露营|旅行|学生|白领|小红书|场景|使用/i
+        .test(brief);
+}
+function hasPlatformContext(brief) {
+    return /淘宝|天猫|京东|亚马逊|Amazon|Shopify|小红书|抖音|官网|社媒|电商|Listing|详情页|A\+|PDP|Campaign|KV|投放|渠道/i
+        .test(brief);
+}
+function hasCopyRequirement(brief) {
+    return /标题|文案|短文案|字幕|带字|文字|无字|无文字|no[-\s]?text|render[-\s]?text|layout[-\s]?copy/i
+        .test(brief);
+}

package/dist/src/utils/endpoints.d.ts

@@ -0,0 +1,52 @@
+import { type GdEnvName, type GdSettings } from "./settings-store.js";
+export type { GdEnvName };
+export declare const AUTH_PAGE_PATH = "/cli/device-authorization";
+export interface EnvPreset {
+    hub_api_base: string;
+    /** SSO API root, for example https://gaoding.com/api/sso. */
+    sso_api_base: string;
+    /** Authorization page origin. It may differ from the SSO API host. */
+    auth_page_origin: string;
+    /** Web Origin / Referer used by business APIs. */
+    web_origin: string;
+    /** Default business channel id. */
+    channel_id: string;
+    /** Default business id. */
+    business_id: string;
+}
+export interface ResolvedEndpoint {
+    value: string;
+    source: string;
+}
+export interface ResolvedEndpoints {
+    active_env: GdEnvName;
+    hub_api_base: ResolvedEndpoint;
+    sso_api_base: ResolvedEndpoint;
+    auth_page_origin: ResolvedEndpoint;
+    web_origin: ResolvedEndpoint;
+    channel_id: ResolvedEndpoint;
+    business_id: ResolvedEndpoint;
+}
+export declare function parseEnvName(name?: string): GdEnvName | null;
+export declare function resolveActiveEnv(): GdEnvName;
+export declare function resolveEndpoints(): ResolvedEndpoints;
+export declare function resolveApiBase(): string;
+export declare function resolveApiBaseInfo(): {
+    url: string;
+    source: string;
+};
+export declare function resolveSsoBase(): string;
+export declare function resolveAuthPageOrigin(): string;
+export declare function resolveWebOrigin(): string;
+/** 由 authorize_code 生成本地约定的授权页链接（不依赖 SSO 返回的 verification_uri host） */
+export declare function buildDeviceAuthPageUrls(authorizeCode: string): {
+    verification_uri: string;
+    verification_uri_complete: string;
+};
+export declare function getEnvPreset(name: GdEnvName): EnvPreset;
+export declare function listEnvNames(): GdEnvName[];
+export declare function applyEnvUse(env: GdEnvName, opts?: {
+    auth_page_origin?: string;
+}): GdSettings;
+export declare function setEnvOverride(key: keyof NonNullable<GdSettings["overrides"]>, value: string): GdSettings;
+export declare function clearEnvOverrides(keys?: Array<keyof NonNullable<GdSettings["overrides"]>>): GdSettings;

package/dist/src/utils/endpoints.js

@@ -0,0 +1,258 @@
+import { readSettings } from "./settings-store.js";
+export const AUTH_PAGE_PATH = "/cli/device-authorization";
+const PRODUCTION_PRESET = {
+    hub_api_base: "https://gdcli.gaoding.com/api",
+    sso_api_base: "https://www.gaoding.com/api/sso",
+    auth_page_origin: "https://www.gaoding.com",
+    web_origin: "https://gdcli.gaoding.com",
+    channel_id: "32",
+    business_id: "13",
+};
+const VALID_ENVS = new Set(["prod", "fat", "stage", "local"]);
+function readEnv(key, legacyKey) {
+    const v = process.env[key];
+    if (v)
+        return v;
+    const gaodingKey = key.replace(/^GD_/, "GAODING_");
+    const gaodingValue = process.env[gaodingKey];
+    if (gaodingValue)
+        return gaodingValue;
+    if (legacyKey)
+        return process.env[legacyKey];
+    return undefined;
+}
+function normalizeBase(url) {
+    return url.replace(/\/$/, "");
+}
+function normalizeOrigin(url) {
+    const u = normalizeBase(url.trim());
+    try {
+        const parsed = new URL(u);
+        return `${parsed.protocol}//${parsed.host}`;
+    }
+    catch {
+        return u;
+    }
+}
+export function parseEnvName(name) {
+    const n = name?.toLowerCase()?.trim();
+    if (!n)
+        return null;
+    if (n === "production" || n === "remote")
+        return "prod";
+    if (n === "dev")
+        return "local";
+    if (VALID_ENVS.has(n))
+        return n;
+    return null;
+}
+export function resolveActiveEnv() {
+    const fromEnv = parseEnvName(readEnv("GD_ENV", "GDHUB_ENV"));
+    if (fromEnv)
+        return fromEnv;
+    const s = readSettings();
+    if (s.active_env && VALID_ENVS.has(s.active_env)) {
+        return s.active_env;
+    }
+    if (readEnv("GD_LOCAL_SERVER", "GDHUB_LOCAL_SERVER") === "1" ||
+        readEnv("GD_LOCAL_SERVER", "GDHUB_LOCAL_SERVER") === "true" ||
+        s.use_local_server === true) {
+        return "local";
+    }
+    return "prod";
+}
+function presetFor(env) {
+    if (env === "prod")
+        return { ...PRODUCTION_PRESET };
+    return {
+        ...PRODUCTION_PRESET,
+        hub_api_base: "",
+        sso_api_base: "",
+        auth_page_origin: "",
+        web_origin: "",
+    };
+}
+export function resolveEndpoints() {
+    const active_env = resolveActiveEnv();
+    const preset = presetFor(active_env);
+    const settings = readSettings();
+    const overrides = settings.overrides ?? {};
+    return {
+        active_env,
+        hub_api_base: resolveHubEndpoint(active_env, preset, settings, overrides),
+        sso_api_base: resolveSimpleEndpoint({
+            key: "sso_api_base",
+            presetValue: preset.sso_api_base,
+            envKeys: ["GD_SSO_BASE", "GDHUB_SSO_BASE"],
+            settingsOverride: overrides.sso_api_base,
+            active_env,
+        }),
+        auth_page_origin: resolveSimpleEndpoint({
+            key: "auth_page_origin",
+            presetValue: preset.auth_page_origin,
+            envKeys: ["GD_AUTH_PAGE_ORIGIN", "GDHUB_AUTH_PAGE_ORIGIN"],
+            settingsOverride: overrides.auth_page_origin,
+            active_env,
+            normalizeAsOrigin: true,
+        }),
+        web_origin: resolveSimpleEndpoint({
+            key: "web_origin",
+            presetValue: preset.web_origin,
+            envKeys: ["GD_WEB_ORIGIN", "GD_ORIGIN"],
+            settingsOverride: overrides.web_origin,
+            active_env,
+            normalizeAsOrigin: true,
+        }),
+        channel_id: resolveSimpleEndpoint({
+            key: "channel_id",
+            presetValue: preset.channel_id,
+            envKeys: ["GD_CHANNEL_ID"],
+            settingsOverride: overrides.channel_id,
+            active_env,
+        }),
+        business_id: resolveSimpleEndpoint({
+            key: "business_id",
+            presetValue: preset.business_id,
+            envKeys: ["GD_BUSINESS_ID"],
+            settingsOverride: overrides.business_id,
+            active_env,
+        }),
+    };
+}
+function resolveHubEndpoint(active_env, preset, settings, overrides) {
+    const apiBase = readEnv("GD_API_BASE", "GDHUB_API_BASE");
+    if (apiBase?.trim()) {
+        return { value: normalizeBase(apiBase), source: "环境变量 GD_API_BASE" };
+    }
+    if (overrides.hub_api_base?.trim()) {
+        return {
+            value: normalizeBase(overrides.hub_api_base),
+            source: "settings.json overrides.hub_api_base",
+        };
+    }
+    if (settings.api_base?.trim()) {
+        return {
+            value: normalizeBase(settings.api_base),
+            source: "settings.json api_base（兼容）",
+        };
+    }
+    if (!preset.hub_api_base.trim()) {
+        throw missingEndpointError(active_env, "hub_api_base", [
+            "GD_API_BASE",
+            "GAODING_API_BASE",
+        ]);
+    }
+    return {
+        value: normalizeBase(preset.hub_api_base),
+        source: `预设 ${active_env}.hub_api_base`,
+    };
+}
+function resolveSimpleEndpoint(opts) {
+    for (const k of opts.envKeys) {
+        if (!k)
+            continue;
+        const v = readEnv(k);
+        if (v?.trim()) {
+            const val = opts.normalizeAsOrigin ? normalizeOrigin(v) : normalizeBase(v);
+            return { value: val, source: `环境变量 ${k}` };
+        }
+    }
+    if (opts.settingsOverride?.trim()) {
+        const val = opts.normalizeAsOrigin
+            ? normalizeOrigin(opts.settingsOverride)
+            : normalizeBase(opts.settingsOverride);
+        return {
+            value: val,
+            source: `settings.json overrides.${opts.key}`,
+        };
+    }
+    if (!opts.presetValue.trim()) {
+        throw missingEndpointError(opts.active_env, opts.key, opts.envKeys);
+    }
+    const val = opts.normalizeAsOrigin
+        ? normalizeOrigin(opts.presetValue)
+        : normalizeBase(opts.presetValue);
+    return {
+        value: val,
+        source: `预设 ${opts.active_env}.${opts.key}`,
+    };
+}
+function missingEndpointError(env, key, envKeys) {
+    const readableKeys = envKeys
+        .filter(Boolean)
+        .map((item) => item.replace(/^GAODING_/, "GD_"))
+        .filter((item, index, arr) => arr.indexOf(item) === index)
+        .join(" / ");
+    return new Error(`缺少 ${env}.${key} 端点配置。请使用环境变量 ${readableKeys} 显式配置。`);
+}
+export function resolveApiBase() {
+    return resolveEndpoints().hub_api_base.value;
+}
+export function resolveApiBaseInfo() {
+    const e = resolveEndpoints().hub_api_base;
+    return { url: e.value, source: e.source };
+}
+export function resolveSsoBase() {
+    return resolveEndpoints().sso_api_base.value;
+}
+export function resolveAuthPageOrigin() {
+    return resolveEndpoints().auth_page_origin.value;
+}
+export function resolveWebOrigin() {
+    return resolveEndpoints().web_origin.value;
+}
+/** 由 authorize_code 生成本地约定的授权页链接（不依赖 SSO 返回的 verification_uri host） */
+export function buildDeviceAuthPageUrls(authorizeCode) {
+    const origin = normalizeOrigin(resolveAuthPageOrigin());
+    const verification_uri = `${origin}${AUTH_PAGE_PATH}`;
+    const verification_uri_complete = `${origin}${AUTH_PAGE_PATH}?code=${encodeURIComponent(authorizeCode)}`;
+    return { verification_uri, verification_uri_complete };
+}
+export function getEnvPreset(name) {
+    return presetFor(name);
+}
+export function listEnvNames() {
+    return ["prod", "fat", "stage", "local"];
+}
+export function applyEnvUse(env, opts) {
+    const cur = readSettings();
+    const overrides = {
+        ...cur.overrides,
+    };
+    if (opts?.auth_page_origin) {
+        overrides.auth_page_origin = normalizeOrigin(opts.auth_page_origin);
+    }
+    else if (env !== cur.active_env) {
+        delete overrides.auth_page_origin;
+    }
+    const next = {
+        ...cur,
+        active_env: env,
+        overrides: Object.keys(overrides).length ? overrides : undefined,
+    };
+    delete next.use_local_server;
+    delete next.api_base;
+    return next;
+}
+export function setEnvOverride(key, value) {
+    const cur = readSettings();
+    const overrides = { ...cur.overrides, [key]: normalizeBase(value.trim()) };
+    if (key === "auth_page_origin" || key === "web_origin") {
+        overrides[key] = normalizeOrigin(value);
+    }
+    return { ...cur, overrides };
+}
+export function clearEnvOverrides(keys) {
+    const cur = readSettings();
+    if (!keys?.length) {
+        const { overrides: _o, ...rest } = cur;
+        return rest;
+    }
+    const overrides = { ...cur.overrides };
+    for (const k of keys)
+        delete overrides[k];
+    return {
+        ...cur,
+        overrides: Object.keys(overrides).length ? overrides : undefined,
+    };
+}

package/dist/src/utils/enrich-upload-params.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Upload parameter normalization hook.
+ * The current runtime accepts local file paths directly and uploads them when needed,
+ * so this hook intentionally leaves the input unchanged.
+ */
+export declare function enrichUploadParamsIfNeeded(toolName: string, opts: Record<string, unknown>, maxBytes?: number): Record<string, unknown>;

package/dist/src/utils/enrich-upload-params.js

@@ -0,0 +1,11 @@
+const DEFAULT_MAX = 25 * 1024 * 1024;
+/**
+ * Upload parameter normalization hook.
+ * The current runtime accepts local file paths directly and uploads them when needed,
+ * so this hook intentionally leaves the input unchanged.
+ */
+export function enrichUploadParamsIfNeeded(toolName, opts, maxBytes = DEFAULT_MAX) {
+    void toolName;
+    void maxBytes;
+    return opts;
+}

package/dist/src/utils/entitlement.d.ts

@@ -0,0 +1,17 @@
+import type { CliErrorBody } from "../core/output/envelope.js";
+export declare const ENTITLEMENT_PRICING_URL = "https://www.gaoding.com/pricing";
+export interface EntitlementIssue {
+    code: "ENTITLEMENT_INSUFFICIENT";
+    message: string;
+    hint: string;
+    pricing_url: string;
+    diagnostic_context?: Record<string, unknown>;
+}
+export declare function detectEntitlementIssue(input: {
+    code?: string;
+    errorName?: string;
+    message?: string;
+    detail?: unknown;
+}): EntitlementIssue | undefined;
+export declare function resolveEntitlementPricingUrl(): string;
+export declare function entitlementCliError(issue: EntitlementIssue, detail?: unknown): CliErrorBody;