@vizamodo/modo-dispatcher 1.1.77

package/dist/gateway/session-waiter.js

@@ -0,0 +1,126 @@
+import { DispatchRejectedError, GatewayError, SessionTimeoutError, } from "../core/errors.js";
+import { waitForSessionDone } from "./session.js";
+import { finalizeResult } from "../artifacts/builders.js";
+import { extractSessionId, extractString, isObject, hasStringProperty, } from "../utils/type-guards.js";
+import { readArtifactString, normalizeAcceptedArtifacts } from "../artifacts/normalizer.js";
+/**
+ * Wait for the result of an accepted dispatch session.
+ *
+ * Routes through the GatewayDispatchAccepted action:
+ *   - "reject" / "idle" → throws or returns early
+ *   - "cancel" / "done" → returns immediately
+ *   - "dispatch" / "reuse" → connects WebSocket, waits, finalizes
+ */
+export async function waitResultFromAccepted(accepted, input) {
+    switch (accepted.action) {
+        case "reject": {
+            // Distinguish between runtime/business rejects (should be
+            // normalized into a runtime DispatchResult) and gateway-level
+            // rejects (transport/concurrency errors) which should continue
+            // to throw. Use the `type` field to decide.
+            if (accepted.type === "runtime") {
+                const artifacts = accepted.artifacts ?? {};
+                const sessionId = extractSessionId(artifacts) ?? "runtime";
+                // IMPORTANT:
+                // Runtime/gateway admission rejects are NOT github execution
+                // results, even when the original requested runType was
+                // "infra". No workflow execution happened.
+                //
+                // Always normalize runtime rejects as runtime results so
+                // semantic error payloads (reason/error.message) survive.
+                const conclusion = accepted.status;
+                return finalizeResult({
+                    sessionId,
+                    status: accepted.status,
+                    conclusion,
+                    runType: "runtime",
+                    artifacts: normalizeAcceptedArtifacts(accepted.artifacts, "runtime"),
+                });
+            }
+            throw new DispatchRejectedError("Dispatch rejected: another command is running");
+        }
+        case "idle": throw new DispatchRejectedError("No active session");
+        case "cancel":
+            {
+                const artifacts = accepted.artifacts ?? {};
+                const sessionId = readArtifactString(artifacts, "sessionId") ??
+                    readArtifactString(artifacts, "executionKey") ??
+                    "runtime";
+                const cancelStatus = accepted.status === "already_done" ? "already_done" : "cancelled";
+                return {
+                    kind: "cancel",
+                    status: cancelStatus,
+                    sessionId,
+                    ...(accepted.conclusion !== undefined ? { conclusion: accepted.conclusion } : {}),
+                };
+            }
+        case "done":
+            {
+                const artifacts = accepted.artifacts ?? {};
+                const sessionId = extractSessionId(artifacts) ?? "runtime";
+                // Special semantic:
+                // cancel request reached an execution that already completed.
+                // This is NOT a github artifact result.
+                // Preserve the informational payload so renderer can show it.
+                if (input.runType === "infra" &&
+                    accepted.status === "already_done") {
+                    return {
+                        kind: "cancel",
+                        status: "already_done",
+                        sessionId,
+                        ...(accepted.conclusion !== undefined
+                            ? { conclusion: accepted.conclusion }
+                            : {}),
+                        ...(isObject(artifacts) ? { data: artifacts } : {}),
+                    };
+                }
+                return finalizeResult({
+                    sessionId,
+                    status: accepted.status,
+                    conclusion: accepted.conclusion ?? accepted.status,
+                    runType: input.runType,
+                    artifacts: normalizeAcceptedArtifacts(accepted.artifacts, input.runType),
+                });
+            }
+        case "dispatch":
+        case "reuse": {
+            const artifacts = accepted.artifacts ?? {};
+            const wsToken = extractString(artifacts, "wsToken");
+            const wsUrl = extractString(artifacts, "wsUrl");
+            const acceptedSessionId = extractSessionId(artifacts) ?? "runtime";
+            if (!wsToken) {
+                throw new GatewayError("Missing wsToken for WebSocket Authorization", {
+                    details: { sessionId: acceptedSessionId, action: accepted.action }
+                });
+            }
+            if (!wsUrl) {
+                throw new GatewayError("Missing wsUrl for WebSocket session", {
+                    details: { sessionId: acceptedSessionId, action: accepted.action }
+                });
+            }
+            let rawDone;
+            try {
+                rawDone = await waitForSessionDone(wsUrl, { wsToken });
+            }
+            catch (err) {
+                const errorName = isObject(err) && hasStringProperty(err, "name") ? err.name : "";
+                if (errorName === "SessionTimeoutError")
+                    throw new SessionTimeoutError();
+                throw new GatewayError("Gateway session error", { cause: err });
+            }
+            const rawDoneSessionId = extractSessionId(rawDone.artifacts) ?? acceptedSessionId;
+            if (input.runType === "infra" && rawDoneSessionId !== acceptedSessionId) {
+                throw new GatewayError(`Gateway returned mismatched sessionId (expected ${acceptedSessionId}, got ${rawDoneSessionId})`);
+            }
+            return finalizeResult({
+                sessionId: rawDoneSessionId,
+                status: rawDone.status,
+                conclusion: rawDone.conclusion,
+                runType: input.runType,
+                artifacts: normalizeAcceptedArtifacts(rawDone.artifacts, input.runType),
+            });
+        }
+        default:
+            throw new DispatchRejectedError("Unsupported gateway action");
+    }
+}

package/dist/gateway/session.d.ts

@@ -0,0 +1,21 @@
+import { GatewaySessionDoneEvent } from "./types.js";
+export interface WaitForSessionOptions {
+    /**
+     * Maximum time to wait for session completion (ms)
+     * Default: 10 minutes
+     */
+    timeoutMs?: number;
+    /**
+     * Optional WebSocket bearer token. If provided, it will be sent as
+     * `Authorization: Bearer <token>` during the WebSocket handshake.
+     */
+    wsToken?: string;
+}
+/**
+ * Wait for session completion via WebSocket.
+ *
+ * Contract:
+ *  - Gateway sends exactly ONE message: { type: "done", ... }
+ *  - Connection is closed after that
+ */
+export declare function waitForSessionDone(wsUrl: string, options?: WaitForSessionOptions): Promise<GatewaySessionDoneEvent>;

package/dist/gateway/session.js

@@ -0,0 +1,74 @@
+import WebSocket from "ws";
+import { hasType } from "../utils/type-guards.js";
+import { DEFAULTS } from "../config/defaults.js";
+/**
+ * Wait for session completion via WebSocket.
+ *
+ * Contract:
+ *  - Gateway sends exactly ONE message: { type: "done", ... }
+ *  - Connection is closed after that
+ */
+export function waitForSessionDone(wsUrl, options = {}) {
+    const { timeoutMs = DEFAULTS.WEBSOCKET_TIMEOUT_MS, wsToken } = options;
+    if (!wsUrl.startsWith("wss://")) {
+        return Promise.reject(new Error(`Invalid WebSocket URL: ${wsUrl}`));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const headers = {};
+        if (wsToken) {
+            headers["Authorization"] = `Bearer ${wsToken}`;
+        }
+        const ws = Object.keys(headers).length > 0
+            ? new WebSocket(wsUrl, { headers })
+            : new WebSocket(wsUrl);
+        const timeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            ws.close();
+            reject(new Error("Session wait timed out"));
+        }, timeoutMs);
+        ws.on("message", (data) => {
+            if (settled)
+                return;
+            let dataParsed;
+            try {
+                dataParsed = JSON.parse(data.toString());
+            }
+            catch {
+                settled = true;
+                clearTimeout(timeout);
+                ws.close();
+                reject(new Error("Invalid JSON received from gateway"));
+                return;
+            }
+            if (!hasType(dataParsed, "done")) {
+                settled = true;
+                clearTimeout(timeout);
+                ws.close();
+                reject(new Error("Unexpected WebSocket message from gateway"));
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            ws.close();
+            resolve(dataParsed);
+        });
+        ws.on("error", (_err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            ws.close();
+            reject(new Error("WebSocket error while waiting for session"));
+        });
+        ws.on("close", (code, reason) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            reject(new Error(`WebSocket closed before session completion (code=${code}, reason=${reason.toString()})`));
+        });
+    });
+}

package/dist/gateway/types.d.ts

@@ -0,0 +1,113 @@
+import type { Artifacts, LogArtifact, ResultArtifact, ArtifactRef, GatewayArtifactRef } from '../artifacts/types.js';
+export type { Artifacts, LogArtifact, ResultArtifact, ArtifactRef, GatewayArtifactRef };
+export interface EncryptedPayload {
+    alg: "x25519-hkdf-aes256gcm";
+    clientPub: string;
+    iv: string;
+    tag: string;
+    data: string;
+    created: number;
+    jti: string;
+}
+export interface GatewayDispatchRequest {
+    /**
+     * Intent identifier
+     * e.g. "deploy-base-worker", "publish-billing", "query-repo"
+     */
+    intent: string;
+    /**
+     * Execution routing hint from client.
+     * - "infra": route to GitHub Actions
+     * - "runtime": route to hub worker
+     */
+    runType?: "infra" | "runtime";
+    infraKey: string;
+    /**
+     * Maps to GitHub `repository_dispatch.event_type`
+     */
+    commandType: string;
+    /**
+     * Canonical allowlist of GitHub teams permitted to execute this command.
+     *
+     * SECURITY-CRITICAL:
+     * Gateway/server authorization MUST verify that the authenticated
+     * identity extracted from JWT/session intersects with this allowlist.
+     *
+     * This field MUST be forwarded unchanged end-to-end.
+     */
+    allowedTeams: string[];
+    /**
+     * Optional runner label hint for execution environment.
+     * Gateway treats this as an opaque hint and forwards it downstream.
+     * If omitted, execution layer may apply a default (e.g. "selfhosted").
+     */
+    runnerLabel?: string;
+    /**
+     * If true, do NOT delete source workflow logs/runs.
+     * Useful for debugging and audits.
+     * Default behavior is to allow the control-plane to delete logs for hygiene.
+     */
+    keepLog?: boolean;
+    /**
+     * Flow gates controlling which workflow setup steps are enabled.
+     * Best-effort, client-decided. May be wrong.
+     * Gateway MUST treat this as opaque data and forward it unchanged.
+     */
+    flowGates?: {
+        secrets?: boolean;
+    };
+    /**
+     * Payload is ALWAYS encrypted.
+     * Gateway must decrypt before forwarding.
+     */
+    payload: EncryptedPayload | null;
+    /**
+     * Optional resource identity for concurrency control.
+     * This is an infra-level field and MUST NOT be derived from encrypted payload.
+     * Gateway uses this as a hint and may validate or override it.
+     */
+    resourceId: string;
+}
+export type GatewayArtifacts = {
+    log?: {
+        path: string;
+        downloadUrl?: string;
+    };
+    result?: {
+        path: string;
+        downloadUrl?: string;
+        contentType?: string;
+    };
+};
+export type GatewayDispatchAccepted = {
+    action: "dispatch" | "reuse" | "done" | "reject" | "cancel" | "idle";
+    type: "runtime" | "infra";
+    status: string;
+    conclusion?: string;
+    artifacts: Record<string, unknown>;
+};
+export interface GatewayDispatchRejected {
+    ok: false;
+    /**
+     * Stable error code for client handling
+     */
+    error: string;
+    /**
+     * Human-readable explanation (for CLI display)
+     */
+    message?: string;
+}
+export type GatewayDispatchResponse = GatewayDispatchAccepted | GatewayDispatchRejected;
+export interface GatewaySessionDoneEvent {
+    type: "done";
+    /**
+     * Final execution status
+     */
+    status: string;
+    conclusion: string;
+    /**
+     * Artifacts generated by the workflow
+     * These are presigned URLs (read-only)
+     */
+    artifacts: Record<string, unknown>;
+}

package/dist/gateway/types.js

@@ -0,0 +1,19 @@
+/* ============================================================
+ * Gateway ⇄ Dispatcher Contract (Encryption-Only)
+ * ============================================================
+ * Notes:
+ * - Gateway MUST NOT stream logs
+ * - Logs are fetched later via presigned artifact URLs
+ * - WebSocket is used ONLY for final status notification
+ * ============================================================
+ */
+export {};
+/* ---------------------------
+ * Artifact Reference
+ * ---------------------------
+ *
+ * NOTE: ArtifactRef is now defined in artifacts/types.ts (SSOT)
+ * and re-exported from this file for backward compatibility.
+ *
+ * See: ArtifactRef in '../artifacts/types.js'
+ */ 

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { dispatcherDispatch } from "./core/dispatcher.js";
+export { executeDispatchLifecycle } from "./core/runtime-orchestrator.js";
+export { normalizeDispatcherError } from "./core/errors.js";
+export { DispatcherError, DispatchRejectedError, SessionTimeoutError, } from "./core/errors.js";
+export { initAuthRuntime, getAuthRuntime } from "./core/runtime.js";
+export { GatewayBootstrapConfig, GatewayBootstrapMap, readLocalGatewayConfig, writeLocalGatewayConfig, persistBootstrapMap, refreshBootstrapFromGateway, loadGatewayBootstrapConfig, bootstrapGatewayConfig, } from "./core/bootstrap.js";
+export type { LoadGatewayBootstrapConfigOptions } from "./core/bootstrap.js";
+export { ensureBootstrapped } from "./core/ensure-bootstrap.js";
+export { exchangeGithubCodeForTokens } from "./auth/oauth/github.js";
+export type { ExchangeResult } from "./auth/oauth/github.js";
+export { performInteractiveLogin } from "./auth/session/login.js";
+export type { LoginResult } from "./auth/session/login.js";
+export { logoutSession } from "./auth/session/logout.js";
+export { rotateTokens as persistTokenPair } from "./auth/session/rotate.js";
+export type { DispatchInput, DispatchOptions, DispatchResult, DispatchHandle, DispatchMode, InteractivePromptHooks, } from "./types/dispatcher.js";
+export type { RuntimeEnv } from "./types/runtime-env.js";
+export type { TokenPair, TokenClaims, SessionAuthOptions, } from "./auth/session/types.js";
+export type { LoginOptions, LoginDeps, } from "./auth/session/login.js";
+export type { Artifacts, LogArtifact, ResultArtifact, } from "./artifacts/types.js";
+export type { GatewayDispatchRequest } from "./gateway/types.js";
+export { getConfig, createConfig, resetConfig, DEFAULTS } from "./config/defaults.js";
+export type { DispatcherConfig } from "./config/defaults.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+// ── Public API ─────────────────────────────────────────────────────────────
+// Only symbols intended for external consumers (CLI, tooling).
+// Internal utilities, auth internals, and type guards are not re‑exported.
+export { dispatcherDispatch } from "./core/dispatcher.js";
+export { executeDispatchLifecycle } from "./core/runtime-orchestrator.js";
+export { normalizeDispatcherError } from "./core/errors.js";
+// Errors (for exit‑code mapping & error handling)
+export { DispatcherError, DispatchRejectedError, SessionTimeoutError, } from "./core/errors.js";
+// Auth runtime (init / get)
+export { initAuthRuntime, getAuthRuntime } from "./core/runtime.js";
+// Bootstrap
+export { readLocalGatewayConfig, writeLocalGatewayConfig, persistBootstrapMap, refreshBootstrapFromGateway, loadGatewayBootstrapConfig, bootstrapGatewayConfig, } from "./core/bootstrap.js";
+export { ensureBootstrapped } from "./core/ensure-bootstrap.js";
+// OAuth (GitHub)
+export { exchangeGithubCodeForTokens } from "./auth/oauth/github.js";
+// Session management
+export { performInteractiveLogin } from "./auth/session/login.js";
+export { logoutSession } from "./auth/session/logout.js";
+export { rotateTokens as persistTokenPair } from "./auth/session/rotate.js";
+// Configuration
+export { getConfig, createConfig, resetConfig, DEFAULTS } from "./config/defaults.js";

package/dist/runtime/runtime-context.d.ts

@@ -0,0 +1,6 @@
+import { TokenClaims } from "../auth/session/types.js";
+export interface RuntimeContext {
+    teams: string[];
+    accessToken: string;
+    claims: TokenClaims;
+}

package/dist/runtime/runtime-context.js

@@ -0,0 +1 @@
+export {};

package/dist/types/dispatcher.d.ts

@@ -0,0 +1,275 @@
+import { LogArtifact } from "../artifacts/types.js";
+import { SessionAuthOptions } from "../auth/session/types.js";
+export interface EncryptOptions {
+    /**
+     * Server public key as RAW X25519 bytes encoded in base64.
+     *
+     * - Must decode to exactly 32 bytes.
+     * - Used to derive the shared secret via X25519.
+     *
+     * This is the canonical KISS format for viza gateway bootstrap.
+     */
+    serverPublicKeyRawB64: string;
+}
+/****
+ * Public types for cli-dispatcher.
+ * These types form the stable contract between viza-cli and cli-dispatcher.
+ */
+/**
+ * Input describing what to dispatch.
+ */
+export interface DispatchInput {
+    /**
+     * Intent name (e.g. "deploy-worker", "publish-app").
+     * Interpreted by the gateway.
+     */
+    intent: string;
+    /**
+     * Target infra allowlist key (e.g. "aws", "cloudflare", "github", "app", "core").
+     * Used by deploy hub to checkout the correct infra repo.
+     */
+    infraKey: string;
+    /**
+     * Execution type (infra | runtime).
+     * Determines routing behavior at the gateway.
+     * This field is REQUIRED to avoid implicit inference.
+     */
+    runType: "infra" | "runtime";
+    /**
+     * Canonical allowlist of GitHub teams permitted to execute this command.
+     *
+     * This field is SECURITY-CRITICAL.
+     * Dispatcher/gateway authorization MUST preserve this contract end-to-end.
+     *
+     * Example:
+     * ["viza-super", "viza-admin"]
+     */
+    allowedTeams: string[];
+    /**
+     * Plain business payload.
+     * Payload is ALWAYS encrypted before being sent to gateway.
+     * Plain payload never leaves dispatcher.
+     */
+    payload: unknown;
+    /**
+     * Optional resource identity for concurrency control.
+     * This is an infra-level hint and MUST NOT be part of business payload.
+     * Gateway may validate/derive and enforce concurrency using this value.
+     */
+    resourceId: string;
+    /**
+     * Maps to GitHub repository_dispatch.event_type.
+     */
+    commandType: string;
+    /**
+     * Optional runner label hint for execution environment.
+     * Gateway treats this as an opaque hint and forwards it downstream.
+     */
+    runnerLabel?: string;
+    /**
+     * If true, do NOT delete source workflow logs/runs.
+     * Useful for debugging and audits.
+     * Default behavior is to allow the control-plane to delete logs for hygiene.
+     */
+    keepLog?: boolean;
+    /**
+     * Flow gates controlling which workflow setup steps are enabled.
+     * Best-effort, client-decided. May be wrong.
+     * Dispatcher and gateway MUST treat this as opaque data.
+     */
+    flowGates?: {
+        secrets?: boolean;
+    };
+}
+/**
+ * Gateway-related options.
+ */
+export interface DispatchGatewayOptions {
+    /**
+     * Base HTTPS endpoint of the dispatch gateway.
+     * Example: https://dispatch.viza.io
+     */
+    endpoint: string;
+}
+/**
+ * UI-related toggles.
+ * NOTE: Dispatcher itself does NOT render UI.
+ * These flags are only passed through for caller coordination.
+ */
+export interface DispatchUIOptions {
+    /**
+     * Whether banner/spinner/logs are enabled.
+     * Dispatcher does not interpret these flags directly.
+     */
+    banner?: boolean;
+    spinner?: boolean;
+    showLog?: boolean;
+}
+/**
+ * Lifecycle hooks invoked by interactive dispatch flows when the dispatcher
+ * needs exclusive ownership of stdin/stdout (e.g. OTP entry).
+ *
+ * The CLI MUST suspend any active spinner / runtime renderer / async
+ * stdout writer while these hooks are active. The dispatcher guarantees:
+ *   - `onBeforePrompt` is called BEFORE any readline prompt is opened
+ *     and BEFORE any `console.log` is emitted within the interactive
+ *     section.
+ *   - `onAfterPrompt` is called AFTER the readline prompt has been closed
+ *     and after the interactive section has fully written its output.
+ *
+ * Hooks may be invoked multiple times (e.g. resend / retry loops). They
+ * MUST be idempotent.
+ */
+export interface InteractivePromptHooks {
+    /**
+     * Stop spinners / runtime renderers / async stdout writers.
+     * stdout MUST be quiet after this resolves.
+     */
+    onBeforePrompt?: () => void | Promise<void>;
+    /**
+     * Resume spinners / runtime renderers.
+     * Only called after the prompt section has fully released stdout.
+     */
+    onAfterPrompt?: () => void | Promise<void>;
+}
+/**
+ * Options controlling dispatch behavior.
+ */
+export interface DispatchOptions {
+    auth: SessionAuthOptions;
+    /**
+     * Full CLI command string used to trigger this dispatch.
+     * Passed from CLI for UX purposes (e.g., suggesting --status).
+     * Not used for routing or execution logic.
+     */
+    fullCommand?: string;
+    interactiveAuthFlow?: boolean;
+    /**
+     * Hooks invoked by interactive flows (e.g. email OTP) so the CLI can
+     * fully suspend its runtime renderer / spinner while readline owns
+     * stdout. Without these hooks the CLI's spinner WILL repaint on top
+     * of the OTP prompt.
+     */
+    interactivePromptHooks?: InteractivePromptHooks;
+    /**
+     * Whether to print the dispatch banner (e.g. "[user] is dispatching as team …").
+     * Default: true. Set to false for inner / recurring calls where the banner
+     * would clutter the terminal (e.g. OTP verify retry loops).
+     */
+    banner?: boolean;
+}
+export type DispatchMode = "dispatch" | "status" | "cancel";
+/**
+ * Structured result returned by hub-worker runtime commands.
+ * This is the canonical runtime execution contract.
+ */
+export interface RuntimeCommandResult<T = unknown> {
+    ok: boolean;
+    /**
+     * Correlation identifier of the runtime command.
+     * Usually equals the command name (e.g. "aws.login").
+     */
+    correlationId: string;
+    /**
+     * Structured step logs produced by the runtime logger.
+     */
+    log: unknown[];
+    /**
+     * Optional command-specific result payload.
+     * Each command may return a different shape.
+     */
+    result?: T;
+    /**
+     * Optional structured error returned when ok=false.
+     */
+    error?: {
+        message: string;
+        stack?: string;
+    };
+}
+type ExecutionResult = {
+    /**
+     * Business status returned by handler.
+     * Example: "sent" | "pending" | "verified" | "provisioned"
+     */
+    status: string;
+    /**
+     * Optional structured business data.
+     */
+    data?: {
+        email?: string;
+        alias?: string;
+        /**
+         * Indicates whether a new OTP was generated or an existing one is reused.
+         */
+        isNew?: boolean;
+        /**
+         * Number of attempts already used (from SOT).
+         */
+        attempts?: number;
+        /**
+         * Number of attempts remaining (from SOT).
+         */
+        retryAfter?: number;
+        attemptsLeft?: number;
+        maxAttempts?: number;
+        [key: string]: unknown;
+    };
+};
+export type DispatchResult = {
+    /**
+     * Execution via GitHub Actions control-plane.
+     */
+    kind: "github";
+    status: string;
+    conclusion: string;
+    /**
+     * Log artifact metadata (SSOT)
+     */
+    log?: LogArtifact;
+    /**
+     * Raw log archive buffer (zip), if downloaded.
+     */
+    logBuffer?: Buffer;
+    /**
+     * Raw workflow artifact buffer (optional), if downloaded.
+     */
+    resultBuffer?: Buffer;
+} | {
+    /**
+     * Immediate execution via hub-worker runtime.
+     *
+     * Runtime commands use the canonical RuntimeCommandResult contract.
+     */
+    kind: "runtime";
+    /**
+     * Transport/runtime execution status.
+     */
+    status: string;
+    /**
+     * Canonical orchestration conclusion.
+     */
+    conclusion: string;
+    /**
+     * Canonical runtime command payload.
+     */
+    data: RuntimeCommandResult;
+} | ({
+    /**
+     * Immediate execution via gateway (infra commands).
+     */
+    kind: "infra";
+} & ExecutionResult) | {
+    kind: "cancel";
+    status: "cancelled" | "already_done";
+    conclusion?: string;
+    sessionId: string;
+};
+export interface DispatchHandle {
+    sessionId: string;
+    wsUrl: string;
+    executionKey?: string;
+    currentUser: string;
+    wait(): Promise<DispatchResult>;
+}
+export {};