@opentag/cli 0.2.0

package/dist/config.d.ts

@@ -0,0 +1,638 @@
+import { type OpenTagDaemonConfig } from "@opentag/local-runtime";
+import { z } from "zod";
+import type { ExecutorId } from "./catalogs/executors.js";
+import type { CliLanguage } from "./catalogs/languages.js";
+import type { PlatformId } from "./catalogs/platforms.js";
+export declare const OpenTagCliConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    state: z.ZodObject<{
+        directory: z.ZodString;
+        databasePath: z.ZodString;
+        worktreeRoot: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        worktreeRoot: string;
+        directory: string;
+        databasePath: string;
+    }, {
+        worktreeRoot: string;
+        directory: string;
+        databasePath: string;
+    }>;
+    preferences: z.ZodOptional<z.ZodObject<{
+        language: z.ZodOptional<z.ZodEnum<["en", "zh-CN"]>>;
+        lastSetup: z.ZodOptional<z.ZodObject<{
+            platforms: z.ZodOptional<z.ZodArray<z.ZodEnum<["lark", "slack", "github", "telegram"]>, "many">>;
+            executor: z.ZodOptional<z.ZodEnum<["echo", "codex", "claude-code"]>>;
+            projectPath: z.ZodOptional<z.ZodString>;
+            larkSetupMethod: z.ZodOptional<z.ZodEnum<["saved", "scan", "manual"]>>;
+            larkDomain: z.ZodOptional<z.ZodEnum<["lark", "feishu"]>>;
+            bindingMethod: z.ZodOptional<z.ZodEnum<["default_project", "bind_later"]>>;
+            slackMode: z.ZodOptional<z.ZodEnum<["socket_mode", "events_api"]>>;
+            slackTeamId: z.ZodOptional<z.ZodString>;
+            slackChannelId: z.ZodOptional<z.ZodString>;
+            slackPort: z.ZodOptional<z.ZodNumber>;
+            githubOwner: z.ZodOptional<z.ZodString>;
+            githubRepo: z.ZodOptional<z.ZodString>;
+            githubPort: z.ZodOptional<z.ZodNumber>;
+            githubAutoCreatePullRequest: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            platforms?: ("lark" | "slack" | "github" | "telegram")[] | undefined;
+            executor?: "echo" | "codex" | "claude-code" | undefined;
+            projectPath?: string | undefined;
+            larkSetupMethod?: "saved" | "scan" | "manual" | undefined;
+            larkDomain?: "lark" | "feishu" | undefined;
+            bindingMethod?: "default_project" | "bind_later" | undefined;
+            slackMode?: "socket_mode" | "events_api" | undefined;
+            slackTeamId?: string | undefined;
+            slackChannelId?: string | undefined;
+            slackPort?: number | undefined;
+            githubOwner?: string | undefined;
+            githubRepo?: string | undefined;
+            githubPort?: number | undefined;
+            githubAutoCreatePullRequest?: boolean | undefined;
+        }, {
+            platforms?: ("lark" | "slack" | "github" | "telegram")[] | undefined;
+            executor?: "echo" | "codex" | "claude-code" | undefined;
+            projectPath?: string | undefined;
+            larkSetupMethod?: "saved" | "scan" | "manual" | undefined;
+            larkDomain?: "lark" | "feishu" | undefined;
+            bindingMethod?: "default_project" | "bind_later" | undefined;
+            slackMode?: "socket_mode" | "events_api" | undefined;
+            slackTeamId?: string | undefined;
+            slackChannelId?: string | undefined;
+            slackPort?: number | undefined;
+            githubOwner?: string | undefined;
+            githubRepo?: string | undefined;
+            githubPort?: number | undefined;
+            githubAutoCreatePullRequest?: boolean | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        language?: "en" | "zh-CN" | undefined;
+        lastSetup?: {
+            platforms?: ("lark" | "slack" | "github" | "telegram")[] | undefined;
+            executor?: "echo" | "codex" | "claude-code" | undefined;
+            projectPath?: string | undefined;
+            larkSetupMethod?: "saved" | "scan" | "manual" | undefined;
+            larkDomain?: "lark" | "feishu" | undefined;
+            bindingMethod?: "default_project" | "bind_later" | undefined;
+            slackMode?: "socket_mode" | "events_api" | undefined;
+            slackTeamId?: string | undefined;
+            slackChannelId?: string | undefined;
+            slackPort?: number | undefined;
+            githubOwner?: string | undefined;
+            githubRepo?: string | undefined;
+            githubPort?: number | undefined;
+            githubAutoCreatePullRequest?: boolean | undefined;
+        } | undefined;
+    }, {
+        language?: "en" | "zh-CN" | undefined;
+        lastSetup?: {
+            platforms?: ("lark" | "slack" | "github" | "telegram")[] | undefined;
+            executor?: "echo" | "codex" | "claude-code" | undefined;
+            projectPath?: string | undefined;
+            larkSetupMethod?: "saved" | "scan" | "manual" | undefined;
+            larkDomain?: "lark" | "feishu" | undefined;
+            bindingMethod?: "default_project" | "bind_later" | undefined;
+            slackMode?: "socket_mode" | "events_api" | undefined;
+            slackTeamId?: string | undefined;
+            slackChannelId?: string | undefined;
+            slackPort?: number | undefined;
+            githubOwner?: string | undefined;
+            githubRepo?: string | undefined;
+            githubPort?: number | undefined;
+            githubAutoCreatePullRequest?: boolean | undefined;
+        } | undefined;
+    }>>;
+    daemon: z.ZodObject<{
+        runnerId: z.ZodString;
+        dispatcherUrl: z.ZodString;
+        repositories: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            owner: z.ZodString;
+            repo: z.ZodString;
+            checkoutPath: z.ZodString;
+            defaultExecutor: z.ZodEnum<["echo", "codex", "claude-code"]>;
+            baseBranch: z.ZodString;
+            pushRemote: z.ZodString;
+            worktreeRoot: z.ZodString;
+            keepWorktree: z.ZodEnum<["always", "on_failure", "never"]>;
+        }, "strict", z.ZodTypeAny, {
+            provider: string;
+            owner: string;
+            repo: string;
+            checkoutPath: string;
+            defaultExecutor: "echo" | "codex" | "claude-code";
+            baseBranch: string;
+            pushRemote: string;
+            worktreeRoot: string;
+            keepWorktree: "always" | "on_failure" | "never";
+        }, {
+            provider: string;
+            owner: string;
+            repo: string;
+            checkoutPath: string;
+            defaultExecutor: "echo" | "codex" | "claude-code";
+            baseBranch: string;
+            pushRemote: string;
+            worktreeRoot: string;
+            keepWorktree: "always" | "on_failure" | "never";
+        }>, "many">;
+        channelBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            accountId: z.ZodString;
+            conversationId: z.ZodString;
+            repoProvider: z.ZodString;
+            owner: z.ZodString;
+            repo: z.ZodString;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strict", z.ZodTypeAny, {
+            provider: string;
+            owner: string;
+            repo: string;
+            accountId: string;
+            conversationId: string;
+            repoProvider: string;
+            metadata?: Record<string, unknown> | undefined;
+        }, {
+            provider: string;
+            owner: string;
+            repo: string;
+            accountId: string;
+            conversationId: string;
+            repoProvider: string;
+            metadata?: Record<string, unknown> | undefined;
+        }>, "many">>;
+        claudeCode: z.ZodOptional<z.ZodObject<{
+            command: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            permissionMode: z.ZodOptional<z.ZodEnum<["acceptEdits", "auto", "bypassPermissions", "default", "plan"]>>;
+            dangerouslySkipPermissions: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            command?: string | undefined;
+            model?: string | undefined;
+            permissionMode?: "acceptEdits" | "auto" | "bypassPermissions" | "default" | "plan" | undefined;
+            dangerouslySkipPermissions?: boolean | undefined;
+        }, {
+            command?: string | undefined;
+            model?: string | undefined;
+            permissionMode?: "acceptEdits" | "auto" | "bypassPermissions" | "default" | "plan" | undefined;
+            dangerouslySkipPermissions?: boolean | undefined;
+        }>>;
+        security: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<["enforce", "audit", "off"]>>;
+            allowedWorkspaceRoot: z.ZodOptional<z.ZodString>;
+            allowUnsafePrompts: z.ZodOptional<z.ZodBoolean>;
+            extraSafeEnv: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            mode?: "enforce" | "audit" | "off" | undefined;
+            allowedWorkspaceRoot?: string | undefined;
+            allowUnsafePrompts?: boolean | undefined;
+            extraSafeEnv?: string[] | undefined;
+        }, {
+            mode?: "enforce" | "audit" | "off" | undefined;
+            allowedWorkspaceRoot?: string | undefined;
+            allowUnsafePrompts?: boolean | undefined;
+            extraSafeEnv?: string[] | undefined;
+        }>>;
+        githubToken: z.ZodOptional<z.ZodString>;
+        preparePullRequestBranch: z.ZodOptional<z.ZodBoolean>;
+        allowAutoCreatePullRequest: z.ZodOptional<z.ZodBoolean>;
+        pairingToken: z.ZodString;
+        pollIntervalMs: z.ZodNumber;
+        heartbeatIntervalMs: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        runnerId: string;
+        dispatcherUrl: string;
+        repositories: {
+            provider: string;
+            owner: string;
+            repo: string;
+            checkoutPath: string;
+            defaultExecutor: "echo" | "codex" | "claude-code";
+            baseBranch: string;
+            pushRemote: string;
+            worktreeRoot: string;
+            keepWorktree: "always" | "on_failure" | "never";
+        }[];
+        pairingToken: string;
+        pollIntervalMs: number;
+        heartbeatIntervalMs: number;
+        channelBindings?: {
+            provider: string;
+            owner: string;
+            repo: string;
+            accountId: string;
+            conversationId: string;
+            repoProvider: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        claudeCode?: {
+            command?: string | undefined;
+            model?: string | undefined;
+            permissionMode?: "acceptEdits" | "auto" | "bypassPermissions" | "default" | "plan" | undefined;
+            dangerouslySkipPermissions?: boolean | undefined;
+        } | undefined;
+        security?: {
+            mode?: "enforce" | "audit" | "off" | undefined;
+            allowedWorkspaceRoot?: string | undefined;
+            allowUnsafePrompts?: boolean | undefined;
+            extraSafeEnv?: string[] | undefined;
+        } | undefined;
+        githubToken?: string | undefined;
+        preparePullRequestBranch?: boolean | undefined;
+        allowAutoCreatePullRequest?: boolean | undefined;
+    }, {
+        runnerId: string;
+        dispatcherUrl: string;
+        repositories: {
+            provider: string;
+            owner: string;
+            repo: string;
+            checkoutPath: string;
+            defaultExecutor: "echo" | "codex" | "claude-code";
+            baseBranch: string;
+            pushRemote: string;
+            worktreeRoot: string;
+            keepWorktree: "always" | "on_failure" | "never";
+        }[];
+        pairingToken: string;
+        pollIntervalMs: number;
+        heartbeatIntervalMs: number;
+        channelBindings?: {
+            provider: string;
+            owner: string;
+            repo: string;
+            accountId: string;
+            conversationId: string;
+            repoProvider: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        claudeCode?: {
+            command?: string | undefined;
+            model?: string | undefined;
+            permissionMode?: "acceptEdits" | "auto" | "bypassPermissions" | "default" | "plan" | undefined;
+            dangerouslySkipPermissions?: boolean | undefined;
+        } | undefined;
+        security?: {
+            mode?: "enforce" | "audit" | "off" | undefined;
+            allowedWorkspaceRoot?: string | undefined;
+            allowUnsafePrompts?: boolean | undefined;
+            extraSafeEnv?: string[] | undefined;
+        } | undefined;
+        githubToken?: string | undefined;
+        preparePullRequestBranch?: boolean | undefined;
+        allowAutoCreatePullRequest?: boolean | undefined;
+    }>;
+    platforms: z.ZodObject<{
+        lark: z.ZodOptional<z.ZodObject<{
+            appId: z.ZodString;
+            appSecret: z.ZodString;
+            domain: z.ZodEnum<["lark", "feishu"]>;
+            botOpenId: z.ZodOptional<z.ZodString>;
+            defaultProjectBinding: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            appId: string;
+            appSecret: string;
+            domain: "lark" | "feishu";
+            botOpenId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+        }, {
+            appId: string;
+            appSecret: string;
+            domain: "lark" | "feishu";
+            botOpenId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+        }>>;
+        slack: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<["socket_mode", "events_api"]>>;
+            appToken: z.ZodOptional<z.ZodString>;
+            signingSecret: z.ZodOptional<z.ZodString>;
+            botToken: z.ZodString;
+            teamId: z.ZodString;
+            channelId: z.ZodString;
+            appId: z.ZodOptional<z.ZodString>;
+            defaultProjectBinding: z.ZodOptional<z.ZodBoolean>;
+            port: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        }, {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        }>, {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        }, {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        }>>;
+        github: z.ZodOptional<z.ZodObject<{
+            webhookSecret: z.ZodString;
+            owner: z.ZodString;
+            repo: z.ZodString;
+            webhookPath: z.ZodOptional<z.ZodString>;
+            port: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            owner: string;
+            repo: string;
+            webhookSecret: string;
+            port?: number | undefined;
+            webhookPath?: string | undefined;
+        }, {
+            owner: string;
+            repo: string;
+            webhookSecret: string;
+            port?: number | undefined;
+            webhookPath?: string | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        lark?: {
+            appId: string;
+            appSecret: string;
+            domain: "lark" | "feishu";
+            botOpenId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+        } | undefined;
+        slack?: {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        } | undefined;
+        github?: {
+            owner: string;
+            repo: string;
+            webhookSecret: string;
+            port?: number | undefined;
+            webhookPath?: string | undefined;
+        } | undefined;
+    }, {
+        lark?: {
+            appId: string;
+            appSecret: string;
+            domain: "lark" | "feishu";
+            botOpenId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+        } | undefined;
+        slack?: {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        } | undefined;
+        github?: {
+            owner: string;
+            repo: string;
+            webhookSecret: string;
+            port?: number | undefined;
+            webhookPath?: string | undefined;
+        } | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    platforms: {
+        lark?: {
+            appId: string;
+            appSecret: string;
+            domain: "lark" | "feishu";
+            botOpenId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+        } | undefined;
+        slack?: {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        } | undefined;
+        github?: {
+            owner: string;
+            repo: string;
+            webhookSecret: string;
+            port?: number | undefined;
+            webhookPath?: string | undefined;
+        } | undefined;
+    };
+    schemaVersion: 1;
+    state: {
+        worktreeRoot: string;
+        directory: string;
+        databasePath: string;
+    };
+    daemon: {
+        runnerId: string;
+        dispatcherUrl: string;
+        repositories: {
+            provider: string;
+            owner: string;
+            repo: string;
+            checkoutPath: string;
+            defaultExecutor: "echo" | "codex" | "claude-code";
+            baseBranch: string;
+            pushRemote: string;
+            worktreeRoot: string;
+            keepWorktree: "always" | "on_failure" | "never";
+        }[];
+        pairingToken: string;
+        pollIntervalMs: number;
+        heartbeatIntervalMs: number;
+        channelBindings?: {
+            provider: string;
+            owner: string;
+            repo: string;
+            accountId: string;
+            conversationId: string;
+            repoProvider: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        claudeCode?: {
+            command?: string | undefined;
+            model?: string | undefined;
+            permissionMode?: "acceptEdits" | "auto" | "bypassPermissions" | "default" | "plan" | undefined;
+            dangerouslySkipPermissions?: boolean | undefined;
+        } | undefined;
+        security?: {
+            mode?: "enforce" | "audit" | "off" | undefined;
+            allowedWorkspaceRoot?: string | undefined;
+            allowUnsafePrompts?: boolean | undefined;
+            extraSafeEnv?: string[] | undefined;
+        } | undefined;
+        githubToken?: string | undefined;
+        preparePullRequestBranch?: boolean | undefined;
+        allowAutoCreatePullRequest?: boolean | undefined;
+    };
+    preferences?: {
+        language?: "en" | "zh-CN" | undefined;
+        lastSetup?: {
+            platforms?: ("lark" | "slack" | "github" | "telegram")[] | undefined;
+            executor?: "echo" | "codex" | "claude-code" | undefined;
+            projectPath?: string | undefined;
+            larkSetupMethod?: "saved" | "scan" | "manual" | undefined;
+            larkDomain?: "lark" | "feishu" | undefined;
+            bindingMethod?: "default_project" | "bind_later" | undefined;
+            slackMode?: "socket_mode" | "events_api" | undefined;
+            slackTeamId?: string | undefined;
+            slackChannelId?: string | undefined;
+            slackPort?: number | undefined;
+            githubOwner?: string | undefined;
+            githubRepo?: string | undefined;
+            githubPort?: number | undefined;
+            githubAutoCreatePullRequest?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    platforms: {
+        lark?: {
+            appId: string;
+            appSecret: string;
+            domain: "lark" | "feishu";
+            botOpenId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+        } | undefined;
+        slack?: {
+            botToken: string;
+            teamId: string;
+            channelId: string;
+            mode?: "socket_mode" | "events_api" | undefined;
+            appId?: string | undefined;
+            defaultProjectBinding?: boolean | undefined;
+            appToken?: string | undefined;
+            signingSecret?: string | undefined;
+            port?: number | undefined;
+        } | undefined;
+        github?: {
+            owner: string;
+            repo: string;
+            webhookSecret: string;
+            port?: number | undefined;
+            webhookPath?: string | undefined;
+        } | undefined;
+    };
+    schemaVersion: 1;
+    state: {
+        worktreeRoot: string;
+        directory: string;
+        databasePath: string;
+    };
+    daemon: {
+        runnerId: string;
+        dispatcherUrl: string;
+        repositories: {
+            provider: string;
+            owner: string;
+            repo: string;
+            checkoutPath: string;
+            defaultExecutor: "echo" | "codex" | "claude-code";
+            baseBranch: string;
+            pushRemote: string;
+            worktreeRoot: string;
+            keepWorktree: "always" | "on_failure" | "never";
+        }[];
+        pairingToken: string;
+        pollIntervalMs: number;
+        heartbeatIntervalMs: number;
+        channelBindings?: {
+            provider: string;
+            owner: string;
+            repo: string;
+            accountId: string;
+            conversationId: string;
+            repoProvider: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[] | undefined;
+        claudeCode?: {
+            command?: string | undefined;
+            model?: string | undefined;
+            permissionMode?: "acceptEdits" | "auto" | "bypassPermissions" | "default" | "plan" | undefined;
+            dangerouslySkipPermissions?: boolean | undefined;
+        } | undefined;
+        security?: {
+            mode?: "enforce" | "audit" | "off" | undefined;
+            allowedWorkspaceRoot?: string | undefined;
+            allowUnsafePrompts?: boolean | undefined;
+            extraSafeEnv?: string[] | undefined;
+        } | undefined;
+        githubToken?: string | undefined;
+        preparePullRequestBranch?: boolean | undefined;
+        allowAutoCreatePullRequest?: boolean | undefined;
+    };
+    preferences?: {
+        language?: "en" | "zh-CN" | undefined;
+        lastSetup?: {
+            platforms?: ("lark" | "slack" | "github" | "telegram")[] | undefined;
+            executor?: "echo" | "codex" | "claude-code" | undefined;
+            projectPath?: string | undefined;
+            larkSetupMethod?: "saved" | "scan" | "manual" | undefined;
+            larkDomain?: "lark" | "feishu" | undefined;
+            bindingMethod?: "default_project" | "bind_later" | undefined;
+            slackMode?: "socket_mode" | "events_api" | undefined;
+            slackTeamId?: string | undefined;
+            slackChannelId?: string | undefined;
+            slackPort?: number | undefined;
+            githubOwner?: string | undefined;
+            githubRepo?: string | undefined;
+            githubPort?: number | undefined;
+            githubAutoCreatePullRequest?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+export type OpenTagCliConfig = Omit<z.infer<typeof OpenTagCliConfigSchema>, "daemon"> & {
+    daemon: OpenTagDaemonConfig;
+};
+export type OpenTagCliPreferences = NonNullable<OpenTagCliConfig["preferences"]>;
+export type OpenTagCliLastSetup = NonNullable<OpenTagCliPreferences["lastSetup"]>;
+export type OpenTagCliLanguage = CliLanguage;
+export type OpenTagCliPlatform = PlatformId;
+export type OpenTagCliExecutor = ExecutorId;
+export type PathEnvironment = Partial<Record<"OPENTAG_CONFIG_PATH" | "OPENTAG_CONFIG_HOME" | "OPENTAG_STATE_DIR" | "XDG_CONFIG_HOME" | "XDG_STATE_HOME", string>>;
+export declare function defaultConfigPath(env?: PathEnvironment, home?: string): string;
+export declare function defaultStateDirectory(env?: PathEnvironment, home?: string): string;
+export declare function formatCliConfigError(error: unknown): string;
+export declare function parseCliConfig(value: unknown): OpenTagCliConfig;
+export declare function readCliConfig(path?: string): OpenTagCliConfig;
+export declare function ensurePrivateDirectory(path: string): void;
+export declare function writeCliConfigAtomic(path: string, config: OpenTagCliConfig): void;
+export declare function assertPrivateConfigFile(path: string): void;
+export declare function redactedCliConfig(config: OpenTagCliConfig): unknown;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmE,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACnI,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAqJ1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBxB,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,EAAE,QAAQ,CAAC,GAAG;IACtF,MAAM,EAAE,mBAAmB,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;AACjF,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC,CAAC;AAClF,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC;AAC7C,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC;AAC5C,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG,OAAO,CACnC,MAAM,CAAC,qBAAqB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,iBAAiB,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAC3H,CAAC;AAQF,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,eAA6B,EAAE,IAAI,SAAY,GAAG,MAAM,CAG9F;AAED,wBAAgB,qBAAqB,CAAC,GAAG,GAAE,eAA6B,EAAE,IAAI,SAAY,GAAG,MAAM,CAIlG;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAK3D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAM/D;AAED,wBAAgB,aAAa,CAAC,IAAI,SAAsB,GAAG,gBAAgB,CAG1E;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAKzD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAYjF;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAM1D;AAeD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAEnE"}

package/dist/doctor.d.ts

@@ -0,0 +1,5 @@
+export type DoctorCommandOptions = {
+    config?: string;
+};
+export declare function runDoctorCommand(options: DoctorCommandOptions): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../src/doctor.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAUnF"}

package/dist/health.d.ts

@@ -0,0 +1,11 @@
+export declare function fetchWithTimeout(input: {
+    url: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs: number;
+}): Promise<Response>;
+export declare function probeDispatcherHealth(input: {
+    dispatcherUrl: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs: number;
+}): Promise<boolean>;
+//# sourceMappingURL=health.d.ts.map

package/dist/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../src/health.ts"],"names":[],"mappings":"AAAA,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,QAAQ,CAAC,CASpB;AAED,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,OAAO,CAAC,CAYnB"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}