@tomflow/proflow-dev-tunnel 0.1.14 → 0.1.16

package/dist/deployment/adapter.js

@@ -1,8 +1,8 @@
 import { readFileSync } from "node:fs";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { writeModuleSharedFacts, } from "@tomflow/proflow-module-contract";
-import { createDevTunnelRuntime } from "../src/resource-adapter.js";
+import { readModuleSharedFacts, writeModuleSharedFacts, } from "@tomflow/proflow-module-contract";
+import { createDevTunnelAutomation, createDevTunnelRuntime, verifyProvisionedPublicBaseUrl, } from "../src/resource-adapter.js";
 import { descriptor } from "./descriptor.js";
 const base = {
     contract: "deployment.result.v1",
@@ -11,77 +11,6 @@ const base = {
     moduleRef: descriptor.moduleRef,
     moduleVersion: descriptor.moduleVersion,
 };
-const setupPlan = {
-    steps: [
-        {
-            id: "STEP-DEV-TUNNEL-01",
-            title: "检查 Dev Tunnel CLI 与登录",
-            description: "确认 CLI 可用，必要时启动 Microsoft 登录。",
-            state: "TODO",
-            responsible: "USER",
-            execution: {
-                interactive: "pnpm exec -- proflow-dev-tunnel setup 01",
-                nonInteractive: "pnpm exec -- proflow-dev-tunnel setup 01",
-            },
-            requiredInputs: [],
-            verify: "devtunnel user show",
-            successCondition: "Microsoft 登录状态可被 CLI 观察",
-            humanAction: "若浏览器打开 Microsoft 登录页，完成账号登录。",
-        },
-        {
-            id: "STEP-DEV-TUNNEL-02",
-            title: "选择或创建持久 Tunnel",
-            description: "列出现有 Tunnel；不存在时由脚本创建。",
-            state: "TODO",
-            responsible: "USER",
-            execution: {
-                interactive: "pnpm exec -- proflow-dev-tunnel setup 02",
-                nonInteractive: "pnpm exec -- proflow-dev-tunnel setup 02 --tunnel-id <id>",
-            },
-            requiredInputs: [
-                { name: "tunnelId", description: "Tunnel ID", sensitive: false },
-            ],
-            verify: "devtunnel show <id>",
-            successCondition: "持久 Tunnel 可以被 devtunnel show 观察",
-        },
-        {
-            id: "STEP-DEV-TUNNEL-03",
-            title: "配置入口并保存公开 URL",
-            description: "为 Platform Host 建立映射，保存公开 HTTPS URL。",
-            state: "TODO",
-            responsible: "USER",
-            execution: {
-                interactive: "pnpm exec -- proflow-dev-tunnel setup 03",
-                nonInteractive: "pnpm exec -- proflow-dev-tunnel setup 03 --tunnel-id <id> --public-base-url <url>",
-            },
-            requiredInputs: [
-                { name: "tunnelId", description: "Tunnel ID", sensitive: false },
-                {
-                    name: "publicBaseUrl",
-                    description: "公开 HTTPS URL",
-                    sensitive: false,
-                },
-            ],
-            verify: "pnpm exec -- proflow-dev-tunnel verify",
-            successCondition: "公开 HTTPS URL 已保存并可验证",
-            humanAction: "确认 Dev Tunnel 门户或 CLI 显示的公开 HTTPS URL。",
-        },
-        {
-            id: "STEP-DEV-TUNNEL-04",
-            title: "验证 Dev Tunnel",
-            description: "检查登录、配置和公开入口。",
-            state: "TODO",
-            responsible: "AI",
-            execution: {
-                interactive: "pnpm exec -- proflow-dev-tunnel setup 04",
-                nonInteractive: "pnpm exec -- proflow-dev-tunnel verify",
-            },
-            requiredInputs: [],
-            verify: "pnpm exec -- proflow-dev-tunnel verify",
-            successCondition: "dev-tunnel.setupStatus=READY",
-        },
-    ],
-};
 const processEffect = "Manage the dev-tunnel public ingress process";
 const stateDir = (context) => join(resolve(context.workspaceRoot), ".proflow", "runtime", "external-resources", "dev-tunnel");
 const stateFile = (context) => join(stateDir(context), "setup.json");
@@ -110,20 +39,6 @@ async function writeState(context, state) {
 `, { encoding: "utf8", mode: 0o600 });
     await rename(tmp, stateFile(context));
 }
-function setupInput(context) {
-    if (typeof context.input !== "object" ||
-        context.input === null ||
-        Array.isArray(context.input))
-        return {};
-    const tunnelId = Reflect.get(context.input, "tunnelId");
-    const publicBaseUrl = Reflect.get(context.input, "publicBaseUrl");
-    return {
-        ...(typeof tunnelId === "string" && tunnelId ? { tunnelId } : {}),
-        ...(typeof publicBaseUrl === "string" && publicBaseUrl
-            ? { publicBaseUrl }
-            : {}),
-    };
-}
 function runtime(context, state) {
     return createDevTunnelRuntime({
         ...(state
@@ -132,7 +47,7 @@ function runtime(context, state) {
         processStateFile: processFile(context),
     });
 }
-export const behaviorAdapter = {
+const baseBehaviorAdapter = {
     install: async (context) => {
         await mkdir(stateDir(context), { recursive: true, mode: 0o700 });
         const state = await readState(context);
@@ -196,7 +111,7 @@ export const behaviorAdapter = {
                             {
                                 scope: "SETUP",
                                 code: "TUNNEL_SETUP_REQUIRED",
-                                message: "尚未选择或创建持久 Tunnel",
+                                message: "尚未完成持久 Tunnel 自动配置",
                                 relatedModuleRefs: [],
                                 nextCommand: "platform setup --module dev-tunnel",
                             },
@@ -206,10 +121,6 @@ export const behaviorAdapter = {
                 observedEffects: [],
             };
         }
-        await writeModuleSharedFacts(context, descriptor.moduleRef, {
-            tunnelId: state.tunnelId,
-            publicBaseUrl: state.publicBaseUrl,
-        });
         const rt = runtime(context, state);
         const login = await rt.loginStatus();
         const observed = await rt.status();
@@ -262,76 +173,6 @@ export const behaviorAdapter = {
             observedEffects: [],
         };
     },
-    setup: async (context) => {
-        await mkdir(stateDir(context), { recursive: true, mode: 0o700 });
-        const previous = await readState(context);
-        const supplied = setupInput(context);
-        const candidate = { ...(previous ?? {}), ...supplied };
-        const rt = runtime(context, previous);
-        const login = await rt.loginStatus();
-        if (login !== "LOGGED_IN")
-            return {
-                result: {
-                    ...base,
-                    ok: false,
-                    status: "ACTION_REQUIRED",
-                    data: setupPlan,
-                    actionRequired: {
-                        action: "complete-tunnel-login",
-                        description: `Run devtunnel user login, complete Microsoft authentication, then rerun platform setup --module dev-tunnel --workspace ${JSON.stringify(context.workspaceRoot)}.`,
-                    },
-                },
-                observedEffects: [],
-            };
-        if (typeof candidate.tunnelId !== "string" ||
-            typeof candidate.publicBaseUrl !== "string")
-            return {
-                result: {
-                    ...base,
-                    ok: false,
-                    status: "ACTION_REQUIRED",
-                    data: setupPlan,
-                    actionRequired: {
-                        action: "select-or-create-tunnel",
-                        description: "Create/select the persistent tunnel, then run proflow-dev-tunnel setup --tunnel-id <id> --public-base-url <url>.",
-                    },
-                },
-                observedEffects: [],
-            };
-        try {
-            const url = new URL(candidate.publicBaseUrl);
-            if (url.protocol !== "https:")
-                throw new TypeError("publicBaseUrl must be HTTPS");
-            const state = {
-                contract: "proflow.dev-tunnel-setup.v1",
-                tunnelId: candidate.tunnelId,
-                publicBaseUrl: url.href,
-            };
-            await writeState(context, state);
-            await writeModuleSharedFacts(context, descriptor.moduleRef, {
-                tunnelId: state.tunnelId,
-                publicBaseUrl: state.publicBaseUrl,
-            });
-            return { result: base, observedEffects: [] };
-        }
-        catch (error) {
-            return {
-                result: {
-                    ...base,
-                    ok: false,
-                    status: "ACTION_REQUIRED",
-                    data: setupPlan,
-                    actionRequired: {
-                        action: "correct-tunnel-facts",
-                        description: error instanceof Error
-                            ? error.message
-                            : "Tunnel setup facts are invalid",
-                    },
-                },
-                observedEffects: [],
-            };
-        }
-    },
     docs: async (_context) => ({
         result: {
             ...base,
@@ -452,3 +293,111 @@ export const behaviorAdapter = {
         }
     },
 };
+function gatewayPort(facts) {
+    const raw = facts?.localBaseUrl;
+    if (typeof raw !== "string")
+        throw new Error("agent-gateway localBaseUrl shared fact is unavailable");
+    const url = new URL(raw);
+    const port = Number(url.port);
+    if (url.protocol !== "http:" ||
+        url.hostname !== "127.0.0.1" ||
+        !Number.isInteger(port) ||
+        port < 1 ||
+        port > 65_535)
+        throw new Error("agent-gateway localBaseUrl shared fact is invalid");
+    return port;
+}
+const setupFailed = (error) => ({
+    result: {
+        ...base,
+        ok: false,
+        status: "FAILED",
+        error: {
+            code: "SETUP_FAILED",
+            message: error instanceof Error ? error.message : "Dev Tunnel setup failed",
+            retryable: true,
+        },
+    },
+    observedEffects: [],
+});
+export function createDevTunnelBehaviorAdapter(dependencies) {
+    const automation = dependencies?.automation ??
+        createDevTunnelAutomation({ command: "devtunnel" });
+    const createRuntime = dependencies?.createRuntime ?? createDevTunnelRuntime;
+    const verifyPublicBaseUrl = dependencies?.verifyPublicBaseUrl ?? verifyProvisionedPublicBaseUrl;
+    return {
+        ...baseBehaviorAdapter,
+        setup: async (context) => {
+            try {
+                await mkdir(stateDir(context), { recursive: true, mode: 0o700 });
+                const port = gatewayPort(await readModuleSharedFacts(context, "agent-gateway"));
+                await automation.ensureLogin();
+                const previous = await readState(context);
+                let tunnelId;
+                let safeToStartNewHost = false;
+                const createAndVerifyTunnel = async () => {
+                    const createdTunnelId = await automation.createTunnel();
+                    const created = await automation.inspectTunnel(createdTunnelId);
+                    if (created.state !== "EXISTS")
+                        throw new Error("new Dev Tunnel could not be verified by show --json");
+                    return createdTunnelId;
+                };
+                if (previous) {
+                    const inspected = await automation.inspectTunnel(previous.tunnelId);
+                    if (inspected.state === "UNKNOWN")
+                        throw new Error("workspace Tunnel remote state is UNKNOWN");
+                    if (inspected.state === "EXISTS") {
+                        tunnelId = previous.tunnelId;
+                        safeToStartNewHost = inspected.hostState === "STOPPED";
+                    }
+                    else {
+                        tunnelId = await createAndVerifyTunnel();
+                        safeToStartNewHost = true;
+                    }
+                }
+                else {
+                    tunnelId = await createAndVerifyTunnel();
+                    safeToStartNewHost = true;
+                }
+                await automation.ensurePort(tunnelId, port);
+                const host = createRuntime({
+                    tunnelId,
+                    processStateFile: processFile(context),
+                });
+                const observed = await host.status();
+                let started = false;
+                if (observed.state !== "RUNNING") {
+                    if (observed.state === "UNKNOWN" && !safeToStartNewHost)
+                        throw new Error("Tunnel host state is UNKNOWN; refusing to start a duplicate host");
+                    const launched = await host.start();
+                    if (launched.state !== "RUNNING")
+                        throw new Error("Dev Tunnel host did not reach RUNNING");
+                    started = true;
+                }
+                const publicBaseUrl = await automation.discoverPublicBaseUrl(tunnelId, port);
+                const url = new URL(publicBaseUrl);
+                if (url.protocol !== "https:")
+                    throw new Error("discovered publicBaseUrl must be HTTPS");
+                await verifyPublicBaseUrl(url.href);
+                const state = {
+                    contract: "proflow.dev-tunnel-setup.v1",
+                    tunnelId,
+                    publicBaseUrl: url.href,
+                };
+                await writeState(context, state);
+                await writeModuleSharedFacts(context, descriptor.moduleRef, {
+                    tunnelId,
+                    publicBaseUrl: state.publicBaseUrl,
+                });
+                return {
+                    result: { ...base, data: state },
+                    observedEffects: started ? [processEffect] : [],
+                };
+            }
+            catch (error) {
+                return setupFailed(error);
+            }
+        },
+    };
+}
+export const behaviorAdapter = createDevTunnelBehaviorAdapter();

package/dist/deployment/descriptor.d.ts

@@ -3,7 +3,7 @@ export declare const descriptor: {
     readonly contractVersion: "1.0.0";
     readonly moduleRef: "dev-tunnel";
     readonly packageName: "@tomflow/proflow-dev-tunnel";
-    readonly moduleVersion: "0.1.14";
+    readonly moduleVersion: "0.1.16";
     readonly kind: "external-resource";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";
@@ -21,7 +21,7 @@ export declare const descriptor: {
         readonly command: "devtunnel";
     }, {
         readonly kind: "human";
-        readonly action: "Complete Microsoft Dev Tunnel login when required";
+        readonly action: "Complete GitHub browser authorization when login is required";
     }];
     readonly configSlots: readonly [];
     readonly effects: readonly [{

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "dev-tunnel",
     packageName: "@tomflow/proflow-dev-tunnel",
-    moduleVersion: "0.1.14",
+    moduleVersion: "0.1.16",
     kind: "external-resource",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",
@@ -25,7 +25,7 @@ export const descriptor = {
         },
         {
             kind: "human",
-            action: "Complete Microsoft Dev Tunnel login when required",
+            action: "Complete GitHub browser authorization when login is required",
         },
     ],
     configSlots: [],

package/dist/deployment/requirements.d.ts

@@ -3,5 +3,5 @@ export declare const requirements: readonly [{
     readonly command: "devtunnel";
 }, {
     readonly kind: "human";
-    readonly action: "Complete Microsoft Dev Tunnel login when required";
+    readonly action: "Complete GitHub browser authorization when login is required";
 }];

package/dist/src/cli.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-import { spawnSync } from "node:child_process";
-import { createInterface } from "node:readline/promises";
 import { behaviorAdapter } from "../deployment/adapter.js";
 function reportFatal(error) {
     process.stderr.write(`✕ 配置失败\n  ${error instanceof Error ? error.message : String(error)}\n`);
@@ -12,136 +10,36 @@ function option(args, name) {
     const index = args.indexOf(name);
     return index >= 0 ? args[index + 1] : undefined;
 }
-function ensureCliAndLogin() {
-    const version = spawnSync("devtunnel", ["--version"], { stdio: "ignore" });
-    if (version.error || version.status !== 0)
-        throw new Error("未找到 devtunnel CLI，请先安装 Microsoft Dev Tunnels CLI");
-    process.stdout.write("✓ 已找到 devtunnel CLI\n");
-    let login = spawnSync("devtunnel", ["user", "show"], { stdio: "ignore" });
-    if (login.status !== 0) {
-        process.stdout.write("◆ 需要 Microsoft 登录，正在启动登录流程…\n");
-        login = spawnSync("devtunnel", ["user", "login"], { stdio: "inherit" });
-        if (login.status !== 0)
-            throw new Error("Microsoft 登录未完成");
-    }
-    process.stdout.write("✓ Microsoft 登录已就绪\n");
-}
-async function selectTunnel(args) {
-    ensureCliAndLogin();
-    let tunnelId = option(args, "--tunnel-id");
-    if (!tunnelId && !process.stdin.isTTY)
-        throw new Error("非交互环境必须提供 --tunnel-id");
-    process.stdout.write("\n现有持久 Tunnel：\n");
-    spawnSync("devtunnel", ["list"], { stdio: "inherit" });
-    const prompt = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    try {
-        tunnelId ||= await prompt.question("\n◆ 输入要使用的 Tunnel ID\n> ");
-        const existing = spawnSync("devtunnel", ["show", tunnelId], {
-            stdio: "ignore",
-        });
-        if (existing.status !== 0) {
-            if (process.stdin.isTTY) {
-                const answer = await prompt.question(`未找到 ${tunnelId}，现在创建？[Y/n] `);
-                if (answer.trim() && !/^y(es)?$/i.test(answer.trim()))
-                    throw new Error("尚未选择持久 Tunnel");
-            }
-            const created = spawnSync("devtunnel", ["create", tunnelId], {
-                stdio: "inherit",
-            });
-            if (created.status !== 0)
-                throw new Error("创建持久 Tunnel 失败");
-        }
-        process.stdout.write(`✓ 持久 Tunnel 已就绪：${tunnelId}\n`);
-        return tunnelId;
-    }
-    finally {
-        prompt.close();
-    }
-}
-async function inputs(args) {
-    let tunnelId = option(args, "--tunnel-id"), publicBaseUrl = option(args, "--public-base-url");
-    if ((!tunnelId || !publicBaseUrl) && !process.stdin.isTTY)
-        throw new Error("非交互环境必须提供 --tunnel-id 和 --public-base-url");
-    if (!tunnelId || !publicBaseUrl) {
-        const prompt = createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        try {
-            process.stdout.write("\nDev Tunnel 配置\n\n  脚本将检查 CLI、完成 Microsoft 登录，并协助选择或创建持久 Tunnel（隧道）。\n\n");
-            ensureCliAndLogin();
-            process.stdout.write("\n现有持久 Tunnel：\n");
-            spawnSync("devtunnel", ["list"], { stdio: "inherit" });
-            tunnelId ||= await prompt.question("\n◆ 输入要使用的 Tunnel ID（不存在时可创建）\n> ");
-            const existing = spawnSync("devtunnel", ["show", tunnelId], {
-                stdio: "ignore",
-            });
-            if (existing.status !== 0) {
-                const answer = await prompt.question(`未找到 ${tunnelId}，现在创建持久 Tunnel？[Y/n] `);
-                if (answer.trim() && !/^y(es)?$/i.test(answer.trim()))
-                    throw new Error("尚未选择可用的持久 Tunnel");
-                const created = spawnSync("devtunnel", ["create", tunnelId], {
-                    stdio: "inherit",
-                });
-                if (created.status !== 0)
-                    throw new Error("创建持久 Tunnel 失败");
-                process.stdout.write("✓ 持久 Tunnel 已创建\n");
-            }
-            else
-                process.stdout.write("✓ 已选择现有持久 Tunnel\n");
-            process.stdout.write("\n请为 Platform Host 的本地端口建立映射并启动 Tunnel；devtunnel 会显示公开 HTTPS 地址。\n");
-            publicBaseUrl ||= await prompt.question("◆ 粘贴公开 HTTPS URL\n> ");
-        }
-        finally {
-            prompt.close();
-        }
-    }
-    return { tunnelId, publicBaseUrl };
-}
-const args = process.argv.slice(2), command = args[0] ?? "setup", workspaceRoot = option(args, "--workspace") ?? process.cwd();
-if (args.includes("--json"))
-    throw new Error("不支持的选项 --json");
+const args = process.argv.slice(2);
+const command = args[0] ?? "setup";
+const workspaceRoot = option(args, "--workspace") ?? process.cwd();
+for (const forbidden of ["--tunnel-id", "--public-base-url", "--port"])
+    if (args.includes(forbidden))
+        throw new Error(`${forbidden} 已移除；Dev Tunnel setup 不接受用户配置`);
 if (command === "setup") {
     const step = args[1]?.startsWith("--") ? undefined : args[1];
-    if (step === "01") {
-        ensureCliAndLogin();
-        process.stdout.write("→ 下一步：setup 02（选择或创建持久 Tunnel）\n");
-        process.exit(0);
-    }
-    if (step === "02") {
-        await selectTunnel(args);
-        process.stdout.write("→ 下一步：setup 03（配置入口并保存公开 URL）\n");
-        process.exit(0);
+    if (step !== undefined)
+        throw new Error("分步 setup 01..04 已移除；请直接运行 setup");
+    process.stdout.write("正在自动准备 Microsoft Dev Tunnel；若登录失效，浏览器将打开 GitHub 授权页。\n");
+    const setup = await behaviorAdapter.setup({ workspaceRoot });
+    if (setup.result.status === "SUCCEEDED") {
+        process.stdout.write("✓ Dev Tunnel 已自动配置并发布公开入口\n");
     }
-    if (step === "04") {
-        const result = await behaviorAdapter.status({ workspaceRoot });
-        process.stdout.write(result.result.data.setupStatus === "READY"
-            ? "✓ Dev Tunnel 验证通过\n"
-            : "✕ Dev Tunnel 尚未就绪\n");
-        if (result.result.data.setupStatus !== "READY")
-            process.exitCode = 1;
-        process.exit();
+    else {
+        process.stderr.write(`✕ Dev Tunnel 自动配置失败\n  ${setup.result.error?.message ?? "unknown setup failure"}\n`);
+        process.exitCode = 1;
     }
-    if (step !== undefined && step !== "03")
-        throw new Error(`UNSUPPORTED_SETUP_STEP:${step}`);
-    const result = await behaviorAdapter.setup({
-        workspaceRoot,
-        input: await inputs(args),
-    });
-    process.stdout.write(result.result.status === "SUCCEEDED"
-        ? "\n✓ Tunnel 配置已保存\n✓ 登录与公开地址验证通过\n"
-        : `\n✕ Tunnel 尚未就绪\n  ${result.result.actionRequired.description}\n`);
 }
 else if (command === "verify") {
-    const result = await behaviorAdapter.status({ workspaceRoot });
-    process.stdout.write(result.result.data.setupStatus === "READY"
-        ? "验证通过。\n"
-        : "验证未通过：配置尚未就绪。\n");
-    if (result.result.data.setupStatus !== "READY")
+    const status = await behaviorAdapter.status({ workspaceRoot });
+    if (status.result.data.setupStatus === "READY") {
+        process.stdout.write("验证通过。\n");
+    }
+    else {
+        process.stderr.write("验证未通过：配置尚未就绪。\n");
         process.exitCode = 1;
+    }
+}
+else {
+    process.stdout.write("用法：proflow-dev-tunnel setup [--workspace <path>] | verify [--workspace <path>]\n");
 }
-else
-    process.stdout.write("用法：proflow-dev-tunnel setup [--tunnel-id <id> --public-base-url <url>]\n");

package/dist/src/resource-adapter.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 export type DevTunnelState = "STOPPED" | "RUNNING" | "UNKNOWN";
 export type DevTunnelLoginStatus = "LOGGED_IN" | "NOT_LOGGED_IN" | "UNKNOWN";
 export interface DevTunnelObservation {
@@ -12,7 +13,23 @@ export interface CommandResult {
 }
 export type CommandRunner = (command: string, args: string[], options?: {
     timeoutMs?: number;
+    interactive?: boolean;
 }) => Promise<CommandResult>;
+export type DevTunnelHostState = "STOPPED" | "RUNNING" | "UNKNOWN";
+export type DevTunnelInspection = {
+    state: "EXISTS";
+    hostState: DevTunnelHostState;
+} | {
+    state: "MISSING" | "UNKNOWN";
+    hostState: "UNKNOWN";
+};
+export interface DevTunnelAutomation {
+    ensureLogin(): Promise<"LOGGED_IN">;
+    inspectTunnel(tunnelId: string): Promise<DevTunnelInspection>;
+    createTunnel(): Promise<string>;
+    ensurePort(tunnelId: string, port: number): Promise<"REUSED" | "CREATED" | "UPDATED">;
+    discoverPublicBaseUrl(tunnelId: string, port: number): Promise<string>;
+}
 export interface DevTunnelRuntime {
     readonly command: string;
     status(): Promise<DevTunnelObservation>;
@@ -22,6 +39,21 @@ export interface DevTunnelRuntime {
     stop(): Promise<DevTunnelObservation>;
     restart(): Promise<DevTunnelObservation>;
 }
+declare const tunnelPortSchema: z.ZodObject<{
+    portNumber: z.ZodNumber;
+    protocol: z.ZodOptional<z.ZodString>;
+    portForwardingUris: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    portUri: z.ZodOptional<z.ZodString>;
+    clientConnections: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type DevTunnelPort = z.infer<typeof tunnelPortSchema>;
+export declare function parseDevTunnelLoginStatus(input: unknown): DevTunnelLoginStatus;
+export declare function discoverPublicBaseUrl(input: unknown, port: number): string;
+export declare function createDevTunnelAutomation(input?: {
+    command?: string;
+    runCommand?: CommandRunner;
+}): DevTunnelAutomation;
+export declare function verifyProvisionedPublicBaseUrl(publicBaseUrl: string, timeoutMs?: number): Promise<void>;
 export declare function createDevTunnelRuntime(input: {
     command?: string;
     tunnelId?: string;
@@ -56,3 +88,4 @@ export interface PublicIngressVerifyOptions {
 export declare function probeTlsProtocol(host: string, port: number, timeoutMs: number): Promise<string | undefined>;
 export declare function readResponseChars(response: Response, ceiling: number): Promise<number | undefined>;
 export declare function verifyPublicIngress(publicBaseUrl: string, options?: PublicIngressVerifyOptions): Promise<PublicIngressVerification>;
+export {};