@gaoding/cli 0.0.0 → 1.0.0

package/contracts/operations/tool.call/output.schema.json

@@ -0,0 +1,129 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "ToolCallOutput",
+  "description": "创作工具同步返回的最终内容与所选模型成本。",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "content",
+    "usage"
+  ],
+  "properties": {
+    "content": {
+      "type": "array",
+      "description": "创作工具最终产出的文本或资源链接。",
+      "items": {
+        "oneOf": [
+          {
+            "$ref": "#/$defs/TextContent"
+          },
+          {
+            "$ref": "#/$defs/ResourceLink"
+          }
+        ]
+      }
+    },
+    "usage": {
+      "$ref": "#/$defs/ToolUsage",
+      "description": "本次调用所选模型及 Model Catalog 声明的成本。"
+    }
+  },
+  "$defs": {
+    "CostRange": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "unit",
+        "minimum",
+        "maximum"
+      ],
+      "properties": {
+        "unit": {
+          "const": "gaodou",
+          "description": "稿豆计价单位。"
+        },
+        "minimum": {
+          "type": "number",
+          "minimum": 0,
+          "description": "当前可用配置中的最低稿豆消耗。"
+        },
+        "maximum": {
+          "type": "number",
+          "minimum": 0,
+          "description": "当前可用配置中的最高稿豆消耗。"
+        }
+      }
+    },
+    "ToolUsage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "model"
+      ],
+      "properties": {
+        "model": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": ".*\\S.*",
+          "description": "本次调用选择的模型机器标识。"
+        },
+        "cost": {
+          "$ref": "#/$defs/CostRange",
+          "description": "Model Catalog 声明的稿豆消耗区间。"
+        }
+      }
+    },
+    "TextContent": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type",
+        "text"
+      ],
+      "properties": {
+        "type": {
+          "const": "text",
+          "description": "文本内容的固定类型。"
+        },
+        "text": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": ".*\\S.*",
+          "description": "创作工具返回的文本。"
+        }
+      }
+    },
+    "ResourceLink": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type",
+        "uri",
+        "name"
+      ],
+      "properties": {
+        "type": {
+          "const": "resource_link",
+          "description": "资源链接的固定类型。"
+        },
+        "uri": {
+          "type": "string",
+          "format": "uri",
+          "description": "创作工具生成资源的 URI。"
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": ".*\\S.*",
+          "description": "资源的文件名。"
+        },
+        "mimeType": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": ".*\\S.*",
+          "description": "资源的 MIME type。"
+        }
+      }
+    }
+  }
+}

package/contracts/operations/tool.list/input.schema.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "ToolListInput",
+  "description": "列出当前可用产品创作工具的输入。",
+  "type": "object",
+  "additionalProperties": false
+}

package/contracts/operations/tool.list/output.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "ToolListResult",
+  "description": "当前可用的产品创作工具。",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "tools"
+  ],
+  "properties": {
+    "tools": {
+      "type": "array",
+      "description": "当前至少有一个可用模型的产品创作工具。",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "name",
+          "title",
+          "description"
+        ],
+        "properties": {
+          "name": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": ".*\\S.*",
+            "description": "调用创作工具时使用的机器标识。"
+          },
+          "title": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": ".*\\S.*",
+            "description": "创作工具的展示名称。"
+          },
+          "description": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": ".*\\S.*",
+            "description": "创作工具的用途说明。"
+          }
+        }
+      }
+    }
+  }
+}

package/dist/bin/gd-cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+const controller = new AbortController();
+const interrupt = () => controller.abort(new Error("SIGINT"));
+process.once("SIGINT", interrupt);
+let runtime;
+let mapCliError;
+let redact;
+try {
+    // Register SIGINT before loading the CLI graph so a cold-start interrupt is
+    // converted into the same abort path as an interrupt during stdin reading.
+    const [cliModule, runtimeModule, errorsModule, redactModule] = await Promise.all([
+        import("../src/bootstrap/create-cli.js"),
+        import("../src/bootstrap/create-runtime.js"),
+        import("../src/cli/errors.js"),
+        import("../src/platform/redact.js")
+    ]);
+    const { createCli, executeCli } = cliModule;
+    const { createProductionRuntime } = runtimeModule;
+    mapCliError = errorsModule.mapCliError;
+    redact = redactModule.redact;
+    runtime = createProductionRuntime();
+    const program = createCli(runtime, { signal: controller.signal });
+    process.exitCode = await executeCli({
+        program,
+        argv: process.argv.slice(2),
+        presenter: runtime.presenter,
+        signal: controller.signal,
+        telemetry: runtime.telemetry,
+        telemetrySink: runtime.telemetrySink,
+        updateNotification: runtime.updateNotification
+    });
+}
+catch (error) {
+    // Dynamic module loading can fail before the error mapper is available.
+    // Keep that rare startup failure bounded and avoid an unhandled rejection.
+    if (mapCliError === undefined || redact === undefined) {
+        process.stderr.write("INTERNAL_ERROR: CLI 启动失败。\n");
+        process.exitCode = 1;
+    }
+    else {
+        const outcome = redact(mapCliError(error, { aborted: controller.signal.aborted }));
+        if (runtime) {
+            runtime.presenter.error(outcome, { json: process.argv.includes("--json") });
+        }
+        else if (outcome.kind === "interrupted") {
+            process.stderr.write("已取消。\n");
+        }
+        else if (process.argv.includes("--json")) {
+            process.stderr.write(`${JSON.stringify({ error: outcome.failure })}\n`);
+        }
+        else {
+            process.stderr.write(`${outcome.failure.code}: ${outcome.failure.message}\n`);
+        }
+        process.exitCode = outcome.exitCode;
+    }
+}
+finally {
+    process.removeListener("SIGINT", interrupt);
+}
+export {};

package/dist/bin/postinstall.js

@@ -0,0 +1,42 @@
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { loadBundledSkills } from "../src/features/skill/bundled-skills.js";
+import { syncBundledSkills } from "../src/features/skill/installer.js";
+export function isSupportedGlobalLifecycle(env) {
+    const userAgent = env.npm_config_user_agent ?? "";
+    if (env.npm_config_global === "true") {
+        return /^(?:npm|pnpm)\//u.test(userAgent);
+    }
+    const initialDirectory = (env.INIT_CWD ?? "").replace(/\\/gu, "/");
+    return userAgent.startsWith("pnpm/")
+        && env.npm_command === "add"
+        && env.npm_lifecycle_event === "postinstall"
+        && env.npm_package_name === "@gaoding/cli"
+        && /\/v\d+\/[0-9a-f]+-[0-9a-f]+-[0-9a-f]{16}$/u.test(initialDirectory);
+}
+export async function runPostinstall(options = {}) {
+    const env = options.env ?? process.env;
+    if (!isSupportedGlobalLifecycle(env))
+        return;
+    const writeError = options.writeError ?? ((text) => process.stderr.write(text));
+    try {
+        const skills = (options.loadSkills ?? loadBundledSkills)(options.startFile ?? fileURLToPath(import.meta.url));
+        await (options.syncSkills ?? syncBundledSkills)(skills, {
+            env,
+            ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {})
+        });
+    }
+    catch (error) {
+        writeError(`警告: ${oneLineMessage(error)}\n`);
+    }
+}
+function oneLineMessage(error) {
+    const value = error instanceof Error ? error.message : String(error);
+    return value.replace(/\s+/gu, " ").trim() || "Agent Skill 自动安装失败";
+}
+const entryPath = process.argv[1];
+const isDirectEntry = entryPath !== undefined
+    && resolve(entryPath) === fileURLToPath(import.meta.url);
+if (isDirectEntry || process.env.npm_lifecycle_event === "postinstall") {
+    void runPostinstall();
+}

package/dist/src/bootstrap/create-cli.js

@@ -0,0 +1,112 @@
+import { Command, CommanderError } from "commander";
+import { assertAllLeafCommandsBound, configureActionEnvironment } from "../cli/action-binding.js";
+import { registerAgentCommands } from "../cli/agent-commands.js";
+import { registerAuthCommands } from "../cli/auth-commands.js";
+import { classifyTelemetryError, isHelpOutcome, mapCliError } from "../cli/errors.js";
+import { registerOrgCommands } from "../cli/org-commands.js";
+import { registerToolCommands } from "../cli/tool-commands.js";
+import { registerModelCommands } from "../cli/model-commands.js";
+import { registerEditorCommands } from "../cli/editor-commands.js";
+import { registerDamCommands } from "../cli/dam-commands.js";
+import { registerUpdateCommand } from "../cli/update-command.js";
+import { redact } from "../platform/redact.js";
+export { assertAllLeafCommandsBound, bindAction } from "../cli/action-binding.js";
+export function createCli(runtime, options) {
+    const program = new Command()
+        .name("gd-cli")
+        .description("稿定命令行工具")
+        .version(runtime.version)
+        .helpCommand(false)
+        .showHelpAfterError(false)
+        .showSuggestionAfterError(false)
+        .allowExcessArguments(false)
+        .exitOverride()
+        .configureOutput({
+        writeOut: runtime.io.writeOut,
+        writeErr: () => undefined
+    });
+    configureActionEnvironment(program, {
+        policies: runtime.accessPolicies,
+        signal: options.signal,
+        telemetry: runtime.telemetry,
+        updateNotification: runtime.updateNotification
+    });
+    registerAuthCommands(program, runtime);
+    registerOrgCommands(program, runtime);
+    registerAgentCommands(program, runtime);
+    registerToolCommands(program, runtime);
+    registerModelCommands(program, runtime);
+    registerEditorCommands(program, runtime);
+    registerDamCommands(program, runtime);
+    registerUpdateCommand(program, runtime);
+    assertAllLeafCommandsBound(program);
+    return program;
+}
+export async function executeCli(options) {
+    try {
+        await options.program.parseAsync(options.argv, { from: "user" });
+        await sendFinished(options, { outcome: "success" });
+        return 0;
+    }
+    catch (error) {
+        if (isHelpOutcome(error)) {
+            if (options.argv[0] !== "update") {
+                await checkUpdateNotification(options.updateNotification, options.signal);
+            }
+            if (options.signal.aborted) {
+                options.presenter.error({ kind: "interrupted", exitCode: 130 }, { json: options.argv.includes("--json") });
+                await sendFinished(options, { outcome: "interrupted" });
+                return 130;
+            }
+            return 0;
+        }
+        if (options.telemetry.selected && error instanceof CommanderError) {
+            try {
+                await options.telemetry.stage("input", () => { throw error; });
+            }
+            catch {
+                // The original Commander error is mapped and presented below.
+            }
+        }
+        const outcome = redact(mapCliError(error, { aborted: options.signal.aborted }));
+        const telemetryError = classifyTelemetryError(error);
+        const traceId = options.telemetry.selected
+            ? options.telemetry.traceId
+            : undefined;
+        options.presenter.error(outcome, {
+            json: options.argv.includes("--json"),
+            ...(traceId ? { traceId } : {})
+        });
+        await sendFinished(options, outcome.kind === "interrupted"
+            ? { outcome: "interrupted", error }
+            : {
+                outcome: "failure",
+                error,
+                errorCode: outcome.failure.code,
+                errorMessage: outcome.failure.message,
+                ...(telemetryError.httpStatus === undefined
+                    ? {}
+                    : { httpStatus: telemetryError.httpStatus }),
+                ...(telemetryError.remoteErrorCode === undefined
+                    ? {}
+                    : { remoteErrorCode: telemetryError.remoteErrorCode }),
+                ...(telemetryError.remoteErrorBody === undefined
+                    ? {}
+                    : { remoteErrorBody: telemetryError.remoteErrorBody })
+            });
+        return outcome.exitCode;
+    }
+}
+async function checkUpdateNotification(updateNotification, signal) {
+    try {
+        await updateNotification.check(signal);
+    }
+    catch {
+        // Version availability must never change the requested command outcome.
+    }
+}
+async function sendFinished(options, completion) {
+    const events = options.telemetry.finish(completion);
+    if (events.length > 0)
+        await options.telemetrySink.send(events);
+}

package/dist/src/bootstrap/create-runtime.js

@@ -0,0 +1,290 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { dirname } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { createAccessPolicies } from "../features/auth/access-policy.js";
+import { createLocalCredentialStore } from "../features/auth/credential-store.js";
+import { createAuthUseCases } from "../features/auth/use-cases.js";
+import { createSsoService } from "../features/auth/sso-service.js";
+import { createCreativeAgentAdapter } from "../features/agent/creative-agent-adapter.js";
+import { createDamApiAdapter } from "../features/dam/dam-api-adapter.js";
+import { createDamFileDownloader } from "../features/dam/file-downloader.js";
+import { createDamOperationExecutor } from "../features/dam/operation-executor.js";
+import { createDamRepositoryCatalog } from "../features/dam/repository-catalog.js";
+import { createDamRegisteredUploader } from "../features/dam/registered-uploader.js";
+import { createDamTransientUploader } from "../features/dam/transient-uploader.js";
+import { createDamStorageUploader } from "../features/dam/storage-upload.js";
+import { createDamUseCases } from "../features/dam/use-cases.js";
+import { createEditorSession } from "../features/editor/session.js";
+import { createEditorSessionStateStore } from "../features/editor/session-state.js";
+import { createEditorUseCases } from "../features/editor/use-cases.js";
+import { createObjectStorageUploader } from "../features/dam/object-storage.js";
+import { createAgentUseCases } from "../features/agent/use-cases.js";
+import { createMnsCatalogAdapter } from "../features/tool/mns-catalog-adapter.js";
+import { createToolApiAdapter } from "../features/tool/tool-api-adapter.js";
+import { createToolUseCases } from "../features/tool/use-cases.js";
+import { createOrgUseCases } from "../features/org/use-cases.js";
+import { createOrgService } from "../features/org/org-service.js";
+import { createBrowserOpener } from "../platform/open-browser.js";
+import { createSignedHttpTransport } from "../platform/signed-http-transport.js";
+import { createJsonInputReader } from "../platform/json-input.js";
+import { createOrganizationPrompt } from "../cli/prompt.js";
+import { createPresenter } from "../cli/presenter.js";
+import { createContractValidators } from "./validators.js";
+import { loadBundledSkills } from "../features/skill/bundled-skills.js";
+import { createUpdateService } from "../features/update/update-service.js";
+import { createUpdateNotificationService } from "../features/update/update-notification.js";
+import { classifyTelemetryError } from "../cli/errors.js";
+import { createTelemetryInvocation } from "../telemetry/invocation.js";
+import { createSlsTelemetrySink } from "../telemetry/sls-sink.js";
+const productionEndpoints = {
+    orgApi: new URL("https://gdcli.gaoding.com/api"),
+    agentApi: new URL("https://gdcli.gaoding.com/api"),
+    mnsApi: new URL("https://gdcli.gaoding.com/api"),
+    toolApi: new URL("https://gdcli.gaoding.com/api"),
+    damApi: new URL("https://gdcli.gaoding.com/api"),
+    ssoApi: new URL("https://www.gaoding.com/api/sso"),
+    authPageOrigin: new URL("https://www.gaoding.art")
+};
+export function createProductionRuntime(options = {}) {
+    const bundledSkills = loadBundledSkills(fileURLToPath(import.meta.url));
+    const primarySkill = bundledSkills.find((skill) => skill.skill === "gd-cli");
+    if (!primarySkill)
+        throw new Error("Bundled gd-cli Skill is missing.");
+    const endpoints = options.endpoints ?? productionEndpoints;
+    const fetch = options.fetch ?? globalThis.fetch;
+    const now = options.now ?? (() => new Date());
+    const telemetry = createTelemetryInvocation({
+        cliVersion: primarySkill.version,
+        now: () => now().getTime(),
+        traceIdFactory: () => randomBytes(16).toString("hex"),
+        spanIdFactory: () => randomBytes(8).toString("hex"),
+        runtime: {
+            os: process.platform,
+            arch: process.arch,
+            nodeMajor: Number.parseInt(process.versions.node, 10)
+        },
+        classifyError: classifyTelemetryError
+    });
+    const telemetrySink = createSlsTelemetrySink({ fetch });
+    const rawIo = options.io ?? {
+        input: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        inputTerminal: process.stdin.isTTY === true,
+        stderrTerminal: process.stderr.isTTY === true
+    };
+    const io = {
+        writeOut: (text) => { rawIo.stdout.write(text); },
+        writeError: (text) => { rawIo.stderr.write(text); },
+        inputTerminal: rawIo.inputTerminal ?? hasTerminal(rawIo.input),
+        stderrTerminal: rawIo.stderrTerminal ?? hasTerminal(rawIo.stderr)
+    };
+    const store = createLocalCredentialStore({
+        ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {})
+    });
+    const orgTransport = createSignedHttpTransport({
+        baseUrl: endpoints.orgApi,
+        fetch,
+        now,
+        traceparent: () => telemetry.traceparent()
+    });
+    const agentTransport = createSignedHttpTransport({
+        baseUrl: endpoints.agentApi,
+        fetch,
+        now,
+        traceparent: () => telemetry.traceparent()
+    });
+    const mnsTransport = createSignedHttpTransport({
+        baseUrl: endpoints.mnsApi,
+        fetch,
+        now,
+        traceparent: () => telemetry.traceparent()
+    });
+    const toolTransport = createSignedHttpTransport({
+        baseUrl: endpoints.toolApi,
+        fetch,
+        now,
+        traceparent: () => telemetry.traceparent()
+    });
+    const damTransport = createSignedHttpTransport({
+        baseUrl: endpoints.damApi,
+        fetch,
+        now,
+        channelId: "32",
+        traceparent: () => telemetry.traceparent()
+    });
+    const sso = createSsoService({
+        ssoApi: endpoints.ssoApi,
+        fetch,
+        now
+    });
+    const org = createOrgUseCases({
+        store,
+        org: createOrgService({ transport: orgTransport }),
+        sso,
+        telemetry
+    });
+    const auth = createAuthUseCases({
+        store,
+        sso,
+        organizationBinder: org,
+        authPageOrigin: endpoints.authPageOrigin,
+        now,
+        telemetry,
+        sleep: async (milliseconds, signal) => {
+            await delay(milliseconds, undefined, { signal });
+        }
+    });
+    const storage = options.objectStorage ?? createObjectStorageUploader({ fetch, now });
+    const storageUpload = createDamStorageUploader({
+        transport: damTransport,
+        storage
+    });
+    const transientUploader = createDamTransientUploader({ storageUpload });
+    const presenter = createPresenter({
+        writeOut: io.writeOut,
+        writeError: io.writeError
+    });
+    const browser = createBrowserOpener();
+    const validators = createContractValidators();
+    const modelCatalog = createMnsCatalogAdapter({ transport: mnsTransport });
+    const damApi = createDamApiAdapter({ transport: damTransport });
+    const damRepositories = createDamRepositoryCatalog({ transport: damTransport });
+    const damOperations = createDamOperationExecutor({
+        now: () => now().getTime(),
+        sleep: async (milliseconds, signal) => {
+            await delay(milliseconds, undefined, { signal });
+        },
+        annotate: (context) => { telemetry.annotate(context); }
+    });
+    const dam = createDamUseCases({
+        api: damApi,
+        repositories: damRepositories,
+        storage: storageUpload,
+        uploader: createDamRegisteredUploader({
+            api: damApi,
+            storage: storageUpload,
+            warn: (message) => { presenter.warning(message); },
+            now,
+            telemetry
+        }),
+        downloader: createDamFileDownloader({ fetch }),
+        operations: damOperations,
+        sleep: async (milliseconds, signal) => {
+            await delay(milliseconds, undefined, { signal });
+        },
+        validate: {
+            repositoryList: validators.damRepositoryListOutput,
+            list: validators.damListOutput,
+            search: validators.damSearchOutput,
+            folderList: validators.damFolderListOutput,
+            tagList: validators.damTagListOutput,
+            download: validators.damDownloadOutput,
+            rename: validators.damRenameOutput,
+            move: validators.damMoveOutput,
+            copy: validators.damCopyOutput,
+            get: validators.damGetOutput,
+            upload: validators.damUploadOutput,
+            delete: validators.damDeleteOutput
+        },
+        telemetry
+    });
+    const agent = createAgentUseCases({
+        catalog: modelCatalog,
+        uploader: transientUploader,
+        completion: createCreativeAgentAdapter({
+            transport: agentTransport,
+            idFactory: randomUUID,
+            telemetry
+        }),
+        warn: (message) => { presenter.warning(message); },
+        telemetry
+    });
+    const tool = createToolUseCases({
+        catalog: modelCatalog,
+        execution: createToolApiAdapter({ transport: toolTransport, telemetry }),
+        uploader: transientUploader,
+        warn: (message) => { presenter.warning(message); },
+        telemetry
+    });
+    const editor = createEditorUseCases({
+        session: createEditorSession({
+            store: createEditorSessionStateStore({
+                ...(options.homeDirectory === undefined
+                    ? {}
+                    : { homeDirectory: options.homeDirectory })
+            }),
+            browser,
+            defaultCreateUrl: new URL("https://www.gaoding.art/editor/canvas?mode=create&type=board"),
+            workUrl: new URL("https://www.gaoding.art/editor/canvas"),
+            ...(options.homeDirectory === undefined
+                ? {}
+                : { homeDirectory: options.homeDirectory })
+        }),
+        validate: {
+            connect: validators.editorConnectOutput,
+            disconnect: validators.editorDisconnectOutput,
+            snapshot: validators.editorSnapshotOutput,
+            apply: validators.editorApplyOutput,
+            screenshot: validators.editorScreenshotOutput,
+            save: validators.editorSaveOutput
+        }
+    });
+    const update = {
+        run(signal) {
+            const packageRoot = dirname(dirname(primarySkill.sourceDirectory));
+            return createUpdateService({
+                currentVersion: primarySkill.version,
+                packageRoot,
+                bundledSkills,
+                fetch,
+                telemetry,
+                ...(process.argv[1] ? { binaryPath: process.argv[1] } : {}),
+                ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {})
+            }).run(signal);
+        }
+    };
+    const updateNotification = createUpdateNotificationService({
+        currentVersion: primarySkill.version,
+        fetch,
+        now,
+        ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {}),
+        ...(options.env ? { env: options.env } : {}),
+        notify: (message) => { presenter.notice(message); }
+    });
+    return {
+        version: primarySkill.version,
+        telemetry,
+        telemetrySink,
+        accessPolicies: createAccessPolicies({
+            store,
+            now,
+            refreshCurrentOrganization: org.refreshCurrentOrganization
+        }),
+        auth,
+        org,
+        agent,
+        editor,
+        dam,
+        tool,
+        update,
+        updateNotification,
+        jsonInput: createJsonInputReader({
+            cwd: process.cwd(),
+            stdin: rawIo.input
+        }),
+        validators,
+        presenter,
+        prompt: createOrganizationPrompt({
+            input: rawIo.input,
+            output: rawIo.stderr
+        }),
+        browser,
+        now,
+        io
+    };
+}
+function hasTerminal(value) {
+    return "isTTY" in value && value.isTTY === true;
+}