autokap 1.0.6 → 1.0.8

package/dist/capture-viewport-lock.d.ts

@@ -0,0 +1,48 @@
+export interface CaptureViewport {
+    width: number;
+    height: number;
+}
+export interface ViewportLockBrowser {
+    resizeViewport(width: number, height: number): Promise<void>;
+    wait(ms: number): Promise<void>;
+    takeScreenshot(): Promise<Buffer>;
+    currentPage: {
+        viewportSize(): {
+            width: number;
+            height: number;
+        } | null;
+    };
+}
+export interface LockedViewportScreenshot {
+    buffer: Buffer;
+    actualViewport: {
+        width: number;
+        height: number;
+    } | null;
+    screenshotSize: {
+        width: number;
+        height: number;
+    };
+    expectedScreenshotSize: {
+        width: number;
+        height: number;
+    };
+    repaired: boolean;
+}
+interface ViewportLockOptions {
+    settleMs?: number;
+    maxAttempts?: number;
+}
+interface TakeViewportLockedScreenshotOptions extends ViewportLockOptions {
+    deviceScaleFactor: number;
+    maxScreenshotAttempts?: number;
+}
+export declare function lockCaptureViewport(browser: ViewportLockBrowser, viewport: CaptureViewport, options?: ViewportLockOptions): Promise<{
+    actualViewport: {
+        width: number;
+        height: number;
+    } | null;
+    repaired: boolean;
+}>;
+export declare function takeViewportLockedScreenshot(browser: ViewportLockBrowser, viewport: CaptureViewport, options: TakeViewportLockedScreenshotOptions): Promise<LockedViewportScreenshot>;
+export {};

package/dist/capture-viewport-lock.js

@@ -0,0 +1,74 @@
+import sharp from 'sharp';
+const DEFAULT_SETTLE_MS = 300;
+const DEFAULT_MAX_VIEWPORT_ATTEMPTS = 2;
+const DEFAULT_MAX_SCREENSHOT_ATTEMPTS = 2;
+function matchesDimension(actual, expected) {
+    return Math.abs(actual - expected) <= 1;
+}
+function matchesViewport(actual, expected) {
+    return !!actual
+        && matchesDimension(actual.width, expected.width)
+        && matchesDimension(actual.height, expected.height);
+}
+function formatViewport(value) {
+    if (!value)
+        return 'unknown';
+    return `${value.width}x${value.height}`;
+}
+export async function lockCaptureViewport(browser, viewport, options = {}) {
+    const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
+    const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_VIEWPORT_ATTEMPTS;
+    let repaired = false;
+    let actualViewport = browser.currentPage.viewportSize();
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        await browser.resizeViewport(viewport.width, viewport.height);
+        if (settleMs > 0) {
+            await browser.wait(settleMs);
+        }
+        actualViewport = browser.currentPage.viewportSize();
+        if (matchesViewport(actualViewport, viewport)) {
+            return {
+                actualViewport,
+                repaired,
+            };
+        }
+        repaired = true;
+    }
+    throw new Error(`Viewport lock failed: expected ${viewport.width}x${viewport.height}, got ${formatViewport(actualViewport)}.`);
+}
+export async function takeViewportLockedScreenshot(browser, viewport, options) {
+    const deviceScaleFactor = Math.max(0.5, Number(options.deviceScaleFactor) || 1);
+    const maxScreenshotAttempts = options.maxScreenshotAttempts ?? DEFAULT_MAX_SCREENSHOT_ATTEMPTS;
+    const expectedScreenshotSize = {
+        width: Math.round(viewport.width * deviceScaleFactor),
+        height: Math.round(viewport.height * deviceScaleFactor),
+    };
+    let repaired = false;
+    let lastViewport = null;
+    let lastScreenshotSize = null;
+    for (let attempt = 1; attempt <= maxScreenshotAttempts; attempt += 1) {
+        const viewportLock = await lockCaptureViewport(browser, viewport, options);
+        repaired ||= viewportLock.repaired;
+        lastViewport = viewportLock.actualViewport;
+        const buffer = await browser.takeScreenshot();
+        const metadata = await sharp(buffer).metadata();
+        const screenshotSize = {
+            width: metadata.width ?? 0,
+            height: metadata.height ?? 0,
+        };
+        lastScreenshotSize = screenshotSize;
+        if (matchesDimension(screenshotSize.width, expectedScreenshotSize.width)
+            && matchesDimension(screenshotSize.height, expectedScreenshotSize.height)) {
+            return {
+                buffer,
+                actualViewport: lastViewport,
+                screenshotSize,
+                expectedScreenshotSize,
+                repaired: repaired || attempt > 1,
+            };
+        }
+        repaired = true;
+    }
+    throw new Error(`Screenshot viewport mismatch: expected ${expectedScreenshotSize.width}x${expectedScreenshotSize.height}, got ${formatViewport(lastScreenshotSize)} (viewport ${formatViewport(lastViewport)}).`);
+}
+//# sourceMappingURL=capture-viewport-lock.js.map

package/dist/circuit-breaker.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Capture Agent — Circuit Breaker
+ *
+ * Three-level circuit breaker to prevent infinite recovery loops:
+ * - Per-opcode: max failures before the opcode is abandoned
+ * - Per-page: max failures across all opcodes on the same page
+ * - Per-run: max total failures across the entire program
+ */
+import type { CircuitBreakerConfig } from './execution-types.js';
+export type BreakerTrip = 'opcode' | 'page' | 'run';
+export interface BreakerState {
+    tripped: boolean;
+    level?: BreakerTrip;
+    reason: string;
+    opcodeFailures: number;
+    pageFailures: number;
+    runFailures: number;
+}
+export declare class CircuitBreaker {
+    private config;
+    private opcodeFailures;
+    private pageFailures;
+    private runFailures;
+    private currentPageKey;
+    constructor(config?: CircuitBreakerConfig);
+    /** Set the current page context (URL-based key) */
+    setPage(url: string): void;
+    /** Record a failure for an opcode. Returns breaker state. */
+    recordFailure(opcodeIndex: number, maxPerOpcode?: number): BreakerState;
+    /** Record a success for an opcode (resets opcode-level counter) */
+    recordSuccess(opcodeIndex: number): void;
+    /** Check if the breaker is currently tripped at any level */
+    isTripped(): BreakerState;
+    /** Get summary of all failure counts */
+    getSummary(): {
+        opcodeFailures: Record<number, number>;
+        pageFailures: Record<string, number>;
+        runFailures: number;
+    };
+    /** Reset all counters */
+    reset(): void;
+}

package/dist/circuit-breaker.js

@@ -0,0 +1,119 @@
+/**
+ * Capture Agent — Circuit Breaker
+ *
+ * Three-level circuit breaker to prevent infinite recovery loops:
+ * - Per-opcode: max failures before the opcode is abandoned
+ * - Per-page: max failures across all opcodes on the same page
+ * - Per-run: max total failures across the entire program
+ */
+import { DEFAULT_CIRCUIT_BREAKER } from './execution-types.js';
+export class CircuitBreaker {
+    config;
+    opcodeFailures = new Map();
+    pageFailures = new Map();
+    runFailures = 0;
+    currentPageKey = null;
+    constructor(config = DEFAULT_CIRCUIT_BREAKER) {
+        this.config = config;
+    }
+    /** Set the current page context (URL-based key) */
+    setPage(url) {
+        this.currentPageKey = new URL(url).pathname;
+    }
+    /** Record a failure for an opcode. Returns breaker state. */
+    recordFailure(opcodeIndex, maxPerOpcode = this.config.maxPerOpcode) {
+        // Opcode level
+        const opcodeFails = (this.opcodeFailures.get(opcodeIndex) ?? 0) + 1;
+        this.opcodeFailures.set(opcodeIndex, opcodeFails);
+        // Page level
+        const pageKey = this.currentPageKey ?? 'unknown';
+        const pageFails = (this.pageFailures.get(pageKey) ?? 0) + 1;
+        this.pageFailures.set(pageKey, pageFails);
+        // Run level
+        this.runFailures++;
+        // Check breakers from most specific to least
+        if (opcodeFails >= maxPerOpcode) {
+            return {
+                tripped: true,
+                level: 'opcode',
+                reason: `opcode ${opcodeIndex} reached ${opcodeFails}/${maxPerOpcode} failures`,
+                opcodeFailures: opcodeFails,
+                pageFailures: pageFails,
+                runFailures: this.runFailures,
+            };
+        }
+        if (pageFails >= this.config.maxPerPage) {
+            return {
+                tripped: true,
+                level: 'page',
+                reason: `page "${pageKey}" reached ${pageFails}/${this.config.maxPerPage} failures`,
+                opcodeFailures: opcodeFails,
+                pageFailures: pageFails,
+                runFailures: this.runFailures,
+            };
+        }
+        if (this.runFailures >= this.config.maxPerRun) {
+            return {
+                tripped: true,
+                level: 'run',
+                reason: `run reached ${this.runFailures}/${this.config.maxPerRun} total failures`,
+                opcodeFailures: opcodeFails,
+                pageFailures: pageFails,
+                runFailures: this.runFailures,
+            };
+        }
+        return {
+            tripped: false,
+            reason: `opcode ${opcodeIndex}: ${opcodeFails}/${maxPerOpcode}, page: ${pageFails}/${this.config.maxPerPage}, run: ${this.runFailures}/${this.config.maxPerRun}`,
+            opcodeFailures: opcodeFails,
+            pageFailures: pageFails,
+            runFailures: this.runFailures,
+        };
+    }
+    /** Record a success for an opcode (resets opcode-level counter) */
+    recordSuccess(opcodeIndex) {
+        this.opcodeFailures.delete(opcodeIndex);
+    }
+    /** Check if the breaker is currently tripped at any level */
+    isTripped() {
+        if (this.runFailures >= this.config.maxPerRun) {
+            return {
+                tripped: true,
+                level: 'run',
+                reason: `run limit reached: ${this.runFailures}/${this.config.maxPerRun}`,
+                opcodeFailures: 0,
+                pageFailures: 0,
+                runFailures: this.runFailures,
+            };
+        }
+        const pageKey = this.currentPageKey ?? 'unknown';
+        const pageFails = this.pageFailures.get(pageKey) ?? 0;
+        if (pageFails >= this.config.maxPerPage) {
+            return {
+                tripped: true,
+                level: 'page',
+                reason: `page limit reached: ${pageFails}/${this.config.maxPerPage}`,
+                opcodeFailures: 0,
+                pageFailures: pageFails,
+                runFailures: this.runFailures,
+            };
+        }
+        return { tripped: false, reason: 'ok', opcodeFailures: 0, pageFailures: pageFails, runFailures: this.runFailures };
+    }
+    /** Get summary of all failure counts */
+    getSummary() {
+        return {
+            opcodeFailures: Object.fromEntries(this.opcodeFailures),
+            pageFailures: Object.fromEntries(this.pageFailures),
+            runFailures: this.runFailures,
+        };
+    }
+    /** Reset all counters */
+    reset() {
+        this.opcodeFailures.clear();
+        this.pageFailures.clear();
+        this.runFailures = 0;
+        this.currentPageKey = null;
+    }
+}
+//# sourceMappingURL=circuit-breaker.js.map

package/dist/cli-config.d.ts

@@ -5,9 +5,16 @@ export interface AutokapConfig {
 }
 declare const DEFAULT_API_BASE_URL = "https://autokap.app";
 declare const DEFAULT_WS_URL = "wss://autokap.app/ws";
+declare const LOCAL_API_BASE_URL = "http://localhost:3000";
+declare const LOCAL_WS_URL = "ws://localhost:3000/ws";
+declare const API_BASE_URL_ENV_VAR = "AUTOKAP_API_BASE_URL";
+declare const WS_URL_ENV_VAR = "AUTOKAP_WS_URL";
 export declare function getConfigDir(): string;
 export declare function getConfigPath(): string;
+export declare function getDefaultApiBaseUrl(): string;
+export declare function getDefaultWsUrl(apiBaseUrl?: string): string;
 export declare function readConfig(): Promise<AutokapConfig | null>;
 export declare function writeConfig(config: AutokapConfig): Promise<void>;
+export declare function deleteConfig(): Promise<void>;
 export declare function requireConfig(): Promise<AutokapConfig>;
-export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL };
+export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, };

package/dist/cli-config.js

@@ -4,22 +4,38 @@ import fs from 'node:fs/promises';
 import { logger } from './logger.js';
 const DEFAULT_API_BASE_URL = 'https://autokap.app';
 const DEFAULT_WS_URL = 'wss://autokap.app/ws';
+const LOCAL_API_BASE_URL = 'http://localhost:3000';
+const LOCAL_WS_URL = 'ws://localhost:3000/ws';
+const API_BASE_URL_ENV_VAR = 'AUTOKAP_API_BASE_URL';
+const WS_URL_ENV_VAR = 'AUTOKAP_WS_URL';
 export function getConfigDir() {
     return path.join(os.homedir(), '.autokap');
 }
 export function getConfigPath() {
     return path.join(getConfigDir(), 'config.json');
 }
+export function getDefaultApiBaseUrl() {
+    return normalizeUrl(process.env[API_BASE_URL_ENV_VAR]) ?? DEFAULT_API_BASE_URL;
+}
+export function getDefaultWsUrl(apiBaseUrl = getDefaultApiBaseUrl()) {
+    return normalizeUrl(process.env[WS_URL_ENV_VAR]) ?? deriveWsUrl(apiBaseUrl);
+}
 export async function readConfig() {
     try {
         const raw = await fs.readFile(getConfigPath(), 'utf-8');
         const parsed = JSON.parse(raw);
         if (!parsed.apiKey)
             return null;
+        const envApiBaseUrl = normalizeUrl(process.env[API_BASE_URL_ENV_VAR]);
+        const envWsUrl = normalizeUrl(process.env[WS_URL_ENV_VAR]);
+        const storedApiBaseUrl = normalizeUrl(parsed.apiBaseUrl) ?? DEFAULT_API_BASE_URL;
+        const apiBaseUrl = envApiBaseUrl ?? storedApiBaseUrl;
+        const wsUrl = envWsUrl
+            ?? (envApiBaseUrl ? deriveWsUrl(apiBaseUrl) : normalizeUrl(parsed.wsUrl) ?? deriveWsUrl(apiBaseUrl));
         return {
             apiKey: parsed.apiKey,
-            apiBaseUrl: parsed.apiBaseUrl ?? DEFAULT_API_BASE_URL,
-            wsUrl: parsed.wsUrl ?? DEFAULT_WS_URL,
+            apiBaseUrl,
+            wsUrl,
         };
     }
     catch {
@@ -27,16 +43,56 @@ export async function readConfig() {
     }
 }
 export async function writeConfig(config) {
-    await fs.mkdir(getConfigDir(), { recursive: true });
-    await fs.writeFile(getConfigPath(), JSON.stringify(config, null, 2), 'utf-8');
+    const dir = getConfigDir();
+    await fs.mkdir(dir, { recursive: true });
+    const configPath = getConfigPath();
+    const normalizedConfig = {
+        ...config,
+        apiBaseUrl: normalizeUrl(config.apiBaseUrl) ?? DEFAULT_API_BASE_URL,
+        wsUrl: normalizeUrl(config.wsUrl) ?? deriveWsUrl(config.apiBaseUrl),
+    };
+    await fs.writeFile(configPath, JSON.stringify(normalizedConfig, null, 2), 'utf-8');
+    // Restrict file permissions on Unix (NTFS ignores POSIX modes)
+    if (process.platform !== 'win32') {
+        await fs.chmod(dir, 0o700);
+        await fs.chmod(configPath, 0o600);
+    }
+}
+export async function deleteConfig() {
+    try {
+        await fs.rm(getConfigPath());
+    }
+    catch {
+        // config file doesn't exist, nothing to do
+    }
 }
 export async function requireConfig() {
     const config = await readConfig();
     if (!config) {
-        logger.error('Not authenticated. Run `autokap login <key>` first.');
+        logger.error('Not authenticated. Run `npx autokap@latest init --cli-key <key>` first.');
         process.exit(1);
     }
     return config;
 }
-export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL };
+function normalizeUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.replace(/\/+$/, '');
+}
+function deriveWsUrl(apiBaseUrl) {
+    try {
+        const url = new URL(apiBaseUrl);
+        url.protocol = url.protocol === 'https:' ? 'wss:' : url.protocol === 'http:' ? 'ws:' : url.protocol;
+        const pathname = url.pathname.replace(/\/+$/, '');
+        url.pathname = `${pathname || ''}/ws`;
+        url.search = '';
+        url.hash = '';
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return DEFAULT_WS_URL;
+    }
+}
+export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, };
 //# sourceMappingURL=cli-config.js.map

package/dist/cli-contract.d.ts

@@ -0,0 +1,15 @@
+export interface CliPublicCommandDescriptor {
+    id: string;
+    command: string;
+    summary: string;
+    docsDescriptionKey?: string;
+}
+export declare const CLI_KEY_TERM = "CLI key";
+export declare const CLI_DEFAULT_INSTALL_COMMAND = "npm install -g autokap";
+export declare const CLI_DEFAULT_SETUP_COMMAND = "npx autokap@latest init --cli-key <your-cli-key>";
+export declare const CLI_ADVANCED_SKILL_COMMAND = "npx autokap@latest skill --agent <agent>";
+export declare const CLI_FALLBACK_PROGRAM_COMMAND = "autokap run <preset-id> --program <file>";
+export declare function buildCliRunCommand(presetId: string, options?: {
+    local?: boolean;
+}): string;
+export declare const CLI_PUBLIC_COMMANDS: CliPublicCommandDescriptor[];

package/dist/cli-contract.js

@@ -0,0 +1,167 @@
+export const CLI_KEY_TERM = "CLI key";
+export const CLI_DEFAULT_INSTALL_COMMAND = "npm install -g autokap";
+export const CLI_DEFAULT_SETUP_COMMAND = "npx autokap@latest init --cli-key <your-cli-key>";
+export const CLI_ADVANCED_SKILL_COMMAND = "npx autokap@latest skill --agent <agent>";
+export const CLI_FALLBACK_PROGRAM_COMMAND = "autokap run <preset-id> --program <file>";
+export function buildCliRunCommand(presetId, options = {}) {
+    return `autokap run${options.local ? " --local" : ""} ${presetId}`;
+}
+export const CLI_PUBLIC_COMMANDS = [
+    {
+        id: "init",
+        command: "autokap init",
+        summary: "Authenticate and install the AI skill in one step",
+        docsDescriptionKey: "cliCmdInit",
+    },
+    {
+        id: "login",
+        command: "autokap login <key>",
+        summary: "Authenticate with your CLI key",
+        docsDescriptionKey: "cliCmdLogin",
+    },
+    {
+        id: "logout",
+        command: "autokap logout",
+        summary: "Remove stored credentials",
+        docsDescriptionKey: "cliCmdLogout",
+    },
+    {
+        id: "whoami",
+        command: "autokap whoami",
+        summary: "Show the account linked to the current CLI key",
+        docsDescriptionKey: "cliCmdWhoami",
+    },
+    {
+        id: "ping",
+        command: "autokap ping",
+        summary: "Verify CLI connection and confirm the stored key is still valid",
+        docsDescriptionKey: "cliCmdPing",
+    },
+    {
+        id: "run",
+        command: "autokap run <preset-id>",
+        summary: "Run a preset capture using local Playwright",
+        docsDescriptionKey: "cliCmdRun",
+    },
+    {
+        id: "run-headed",
+        command: "autokap run <preset-id> --headed",
+        summary: "Show the browser window for debugging",
+        docsDescriptionKey: "cliCmdHeaded",
+    },
+    {
+        id: "project-list",
+        command: "autokap project list",
+        summary: "List accessible projects as JSON",
+        docsDescriptionKey: "cliCmdProjectList",
+    },
+    {
+        id: "project-get",
+        command: "autokap project get <project-id>",
+        summary: "Get a single project as JSON",
+        docsDescriptionKey: "cliCmdProjectGet",
+    },
+    {
+        id: "project-create",
+        command: "autokap project create --name <name> --url <url>",
+        summary: "Create a project and print its ID",
+        docsDescriptionKey: "cliCmdProjectCreate",
+    },
+    {
+        id: "preset-info",
+        command: "autokap preset info <preset-id>",
+        summary: "Get structured JSON with endpoints, variants, and URL parameters",
+        docsDescriptionKey: "cliCmdPresetInfo",
+    },
+    {
+        id: "capture-list",
+        command: "autokap capture list",
+        summary: "List captures as JSON",
+        docsDescriptionKey: "cliCmdCaptureList",
+    },
+    {
+        id: "usage",
+        command: "autokap usage",
+        summary: "Show the current billing-period usage as JSON",
+        docsDescriptionKey: "cliCmdUsage",
+    },
+    {
+        id: "endpoints-list",
+        command: "autokap endpoints list --preset <id>",
+        summary: "List dev link endpoints as JSON or table",
+        docsDescriptionKey: "cliCmdEndpointsList",
+    },
+    {
+        id: "endpoints-get",
+        command: "autokap endpoints get <endpoint-id>",
+        summary: "Get a single dev link endpoint as JSON",
+        docsDescriptionKey: "cliCmdEndpointsGet",
+    },
+    {
+        id: "endpoints-export",
+        command: "autokap endpoints export --preset <id>",
+        summary: "Export dev link endpoints as JSON or CSV",
+        docsDescriptionKey: "cliCmdEndpointsExport",
+    },
+    {
+        id: "auth-capture",
+        command: "autokap auth capture <project-id>",
+        summary: "Capture a browser session for a session account",
+        docsDescriptionKey: "cliCmdAuthCapture",
+    },
+    {
+        id: "auth-account-list",
+        command: "autokap auth account list <project-id>",
+        summary: "List project credential accounts as JSON",
+        docsDescriptionKey: "cliCmdAuthAccountList",
+    },
+    {
+        id: "auth-account-create",
+        command: "autokap auth account create <project-id> --name <name>",
+        summary: "Create a project credential account and print its ID",
+        docsDescriptionKey: "cliCmdAuthAccountCreate",
+    },
+    {
+        id: "auth-account-update",
+        command: "autokap auth account update <project-id> --account <name-or-id>",
+        summary: "Update a project credential account",
+        docsDescriptionKey: "cliCmdAuthAccountUpdate",
+    },
+    {
+        id: "auth-account-delete",
+        command: "autokap auth account delete <project-id> --account <name-or-id>",
+        summary: "Delete an unused project credential account",
+        docsDescriptionKey: "cliCmdAuthAccountDelete",
+    },
+    {
+        id: "auth-session-clear",
+        command: "autokap auth session clear <project-id> --account <name-or-id>",
+        summary: "Clear the stored browser session for a session account",
+        docsDescriptionKey: "cliCmdAuthSessionClear",
+    },
+    {
+        id: "proxy-register",
+        command: "autokap proxy register --project <id> --proxy-url <url>",
+        summary: "Register a user-side proxy for dev links",
+        docsDescriptionKey: "cliCmdProxyRegister",
+    },
+    {
+        id: "proxy-verify",
+        command: "autokap proxy verify --project <id>",
+        summary: "Verify the configured proxy for a project",
+        docsDescriptionKey: "cliCmdProxyVerify",
+    },
+    {
+        id: "skill",
+        command: "autokap skill",
+        summary: "Export the AI agent skill bundle",
+        docsDescriptionKey: "cliCmdSkill",
+    },
+    {
+        id: "version",
+        command: "autokap --version",
+        summary: "Show the installed version",
+        docsDescriptionKey: "cliCmdVersion",
+    },
+];
+//# sourceMappingURL=cli-contract.js.map

package/dist/cli-runner-local.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Capture Agent — CLI command wrapper
+ *
+ * `autokap run` stays local-first: Playwright runs on the user's machine.
+ * The server only provides the compiled program and persists artifacts/results.
+ */
+export declare function runLocal(presetId: string, opts: {
+    headed: boolean;
+    output?: string;
+    program?: string;
+    debug?: boolean;
+}): Promise<void>;