@creativeintelligence/abbie 0.1.0

package/dist/lib/resources.d.ts

@@ -0,0 +1,105 @@
+import { EventStore } from "./events.js";
+/**
+ * Resource lease information.
+ */
+export interface ResourceLease {
+    lease_id: string;
+    resource: string;
+    session_id: string;
+    agent: string;
+    acquired_at: string;
+    expires_at: string;
+    ttl_ms: number;
+}
+/**
+ * Resource configuration.
+ */
+export interface ResourceConfig {
+    max_concurrent: number;
+    default_ttl_ms?: number;
+}
+/**
+ * Resource semaphore manager for controlling concurrent access.
+ */
+export declare class ResourceManager {
+    private basePath;
+    private eventStore;
+    private config;
+    constructor(basePath?: string, config?: Record<string, ResourceConfig>, eventStore?: EventStore);
+    /**
+     * Load resource config from .loop.json or template.
+     */
+    loadConfig(configPath: string): void;
+    /**
+     * Get the lease directory for a resource.
+     */
+    private getLeaseDir;
+    /**
+     * Get all active leases for a resource.
+     */
+    private getActiveLeases;
+    /**
+     * Generate a unique lease ID.
+     */
+    private generateLeaseId;
+    /**
+     * Attempt to acquire a resource lease.
+     * Returns the lease if successful, undefined if resource is at capacity.
+     */
+    acquire(resource: string, sessionId: string, agent: string, ttlMs?: number): ResourceLease | undefined;
+    /**
+     * Create a new lease.
+     */
+    private createLease;
+    /**
+     * Renew an existing lease.
+     */
+    renewLease(resource: string, leaseId: string, ttlMs?: number): ResourceLease | undefined;
+    /**
+     * Release a lease.
+     */
+    release(resource: string, sessionId: string): boolean;
+    /**
+     * Release a specific lease by ID.
+     */
+    releaseLease(resource: string, leaseId: string): boolean;
+    /**
+     * Check current resource availability.
+     */
+    getAvailability(resource: string): {
+        available: number;
+        total: number;
+        leases: ResourceLease[];
+    };
+    /**
+     * Wait for resource availability with exponential backoff.
+     */
+    waitForResource(resource: string, sessionId: string, agent: string, options?: {
+        maxWaitMs?: number;
+        ttlMs?: number;
+    }): Promise<ResourceLease | undefined>;
+    /**
+     * Release all leases for a session.
+     */
+    releaseAllForSession(sessionId: string): number;
+    /**
+     * Get all resources with active leases.
+     */
+    listResources(): Array<{
+        resource: string;
+        availability: ReturnType<ResourceManager["getAvailability"]>;
+    }>;
+    /**
+     * Clean up all expired leases.
+     */
+    cleanup(): number;
+}
+/**
+ * Default resource configuration.
+ */
+export declare const DEFAULT_RESOURCES: Record<string, ResourceConfig>;
+/**
+ * Create a resource manager with default configuration.
+ */
+export declare function createResourceManager(basePath?: string, eventStore?: EventStore): ResourceManager;
+//# sourceMappingURL=resources.d.ts.map

package/dist/lib/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/lib/resources.ts"],"names":[],"mappings":"AAYA,OAAO,EAAe,UAAU,EAAE,MAAM,aAAa,CAAC;AAoDtD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,MAAM,CAAiC;gBAG7C,QAAQ,GAAE,MAA6B,EACvC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAM,EAC3C,UAAU,CAAC,EAAE,UAAU;IAWzB;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASpC;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAMvB;;;OAGG;IACH,OAAO,CACL,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,GACb,aAAa,GAAG,SAAS;IAuB5B;;OAEG;IACH,OAAO,CAAC,WAAW;IAmCnB;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAkBxF;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAcrD;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAoBxD;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,aAAa,EAAE,CAAA;KAAE;IAchG;;OAEG;IACG,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;QACP,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,CAAC;KACX,GACL,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;IAmBrC;;OAEG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAqB/C;;OAEG;IACH,aAAa,IAAI,KAAK,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,UAAU,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC,CAAC;KAC9D,CAAC;IAgBF;;OAEG;IACH,OAAO,IAAI,MAAM;CAoBlB;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAM5D,CAAC;AAEF;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,eAAe,CAEjG"}

package/dist/lib/resources.js

@@ -0,0 +1,321 @@
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { createEvent, EventStore } from "./events.js";
+/**
+ * Execute a function while holding an exclusive file lock.
+ * Uses O_CREAT|O_EXCL for atomic lock creation. Retries with backoff on contention.
+ */
+function withFileLock(lockPath, fn, maxRetries = 20, baseDelayMs = 50) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const fd = openSync(lockPath, "wx"); // O_CREAT | O_EXCL — fails if exists
+            try {
+                return fn();
+            }
+            finally {
+                closeSync(fd);
+                try {
+                    unlinkSync(lockPath);
+                }
+                catch {
+                    // best effort cleanup
+                }
+            }
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            // Stale lock detection: if lock file is older than 30s, remove it
+            try {
+                const lockStat = statSync(lockPath);
+                if (Date.now() - lockStat.mtimeMs > 30000) {
+                    try {
+                        unlinkSync(lockPath);
+                    }
+                    catch {
+                        // another process may have already removed it
+                    }
+                    continue; // retry immediately after removing stale lock
+                }
+            }
+            catch {
+                // lock file disappeared between EEXIST and stat — retry
+                continue;
+            }
+            if (attempt < maxRetries) {
+                // Exponential backoff with jitter
+                const delay = baseDelayMs * 2 ** Math.min(attempt, 8) * (0.5 + Math.random() * 0.5);
+                const start = Date.now();
+                while (Date.now() - start < delay) {
+                    // busy wait (synchronous context)
+                }
+            }
+        }
+    }
+    throw new Error(`Failed to acquire file lock after ${maxRetries} retries: ${lockPath}`);
+}
+/**
+ * Resource semaphore manager for controlling concurrent access.
+ */
+export class ResourceManager {
+    basePath;
+    eventStore;
+    config;
+    constructor(basePath = "~/.abbie/resources", config = {}, eventStore) {
+        this.basePath = basePath.replace("~", process.env.HOME || "");
+        this.config = config;
+        this.eventStore = eventStore || new EventStore();
+        if (!existsSync(this.basePath)) {
+            mkdirSync(this.basePath, { recursive: true });
+        }
+    }
+    /**
+     * Load resource config from .loop.json or template.
+     */
+    loadConfig(configPath) {
+        if (!existsSync(configPath))
+            return;
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (config.resources) {
+            this.config = { ...this.config, ...config.resources };
+        }
+    }
+    /**
+     * Get the lease directory for a resource.
+     */
+    getLeaseDir(resource) {
+        const dir = join(this.basePath, resource);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    }
+    /**
+     * Get all active leases for a resource.
+     */
+    getActiveLeases(resource) {
+        const dir = this.getLeaseDir(resource);
+        const now = Date.now();
+        return readdirSync(dir)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => {
+            const lease = JSON.parse(readFileSync(join(dir, f), "utf-8"));
+            return lease;
+        })
+            .filter((lease) => {
+            const expiresAt = new Date(lease.expires_at).getTime();
+            if (expiresAt < now) {
+                // Clean up expired lease
+                this.releaseLease(lease.resource, lease.lease_id);
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Generate a unique lease ID.
+     */
+    generateLeaseId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).slice(2, 8);
+        return `${timestamp}-${random}`;
+    }
+    /**
+     * Attempt to acquire a resource lease.
+     * Returns the lease if successful, undefined if resource is at capacity.
+     */
+    acquire(resource, sessionId, agent, ttlMs) {
+        const lockPath = join(this.getLeaseDir(resource), ".lock");
+        return withFileLock(lockPath, () => {
+            const config = this.config[resource];
+            if (!config) {
+                return this.createLease(resource, sessionId, agent, ttlMs || 300000);
+            }
+            const activeLeases = this.getActiveLeases(resource);
+            const existingLease = activeLeases.find((l) => l.session_id === sessionId);
+            if (existingLease) {
+                return this.renewLease(resource, existingLease.lease_id, ttlMs);
+            }
+            if (activeLeases.length >= config.max_concurrent) {
+                return undefined;
+            }
+            return this.createLease(resource, sessionId, agent, ttlMs || config.default_ttl_ms || 300000);
+        });
+    }
+    /**
+     * Create a new lease.
+     */
+    createLease(resource, sessionId, agent, ttlMs) {
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + ttlMs);
+        const leaseId = this.generateLeaseId();
+        const lease = {
+            lease_id: leaseId,
+            resource,
+            session_id: sessionId,
+            agent,
+            acquired_at: now.toISOString(),
+            expires_at: expiresAt.toISOString(),
+            ttl_ms: ttlMs,
+        };
+        const leasePath = join(this.getLeaseDir(resource), `${leaseId}.json`);
+        writeFileSync(leasePath, JSON.stringify(lease, null, 2));
+        // Log to event store
+        this.eventStore.append(createEvent.resourceAcquired(sessionId, agent, {
+            resource,
+            lease_id: leaseId,
+            expires_at: expiresAt.toISOString(),
+        }));
+        return lease;
+    }
+    /**
+     * Renew an existing lease.
+     */
+    renewLease(resource, leaseId, ttlMs) {
+        const leasePath = join(this.getLeaseDir(resource), `${leaseId}.json`);
+        if (!existsSync(leasePath)) {
+            return undefined;
+        }
+        const lease = JSON.parse(readFileSync(leasePath, "utf-8"));
+        const now = new Date();
+        const newTtl = ttlMs || lease.ttl_ms;
+        const expiresAt = new Date(now.getTime() + newTtl);
+        lease.expires_at = expiresAt.toISOString();
+        lease.ttl_ms = newTtl;
+        writeFileSync(leasePath, JSON.stringify(lease, null, 2));
+        return lease;
+    }
+    /**
+     * Release a lease.
+     */
+    release(resource, sessionId) {
+        const lockPath = join(this.getLeaseDir(resource), ".lock");
+        return withFileLock(lockPath, () => {
+            const activeLeases = this.getActiveLeases(resource);
+            const lease = activeLeases.find((l) => l.session_id === sessionId);
+            if (!lease) {
+                return false;
+            }
+            return this.releaseLease(resource, lease.lease_id);
+        });
+    }
+    /**
+     * Release a specific lease by ID.
+     */
+    releaseLease(resource, leaseId) {
+        const leasePath = join(this.getLeaseDir(resource), `${leaseId}.json`);
+        if (!existsSync(leasePath)) {
+            return false;
+        }
+        const lease = JSON.parse(readFileSync(leasePath, "utf-8"));
+        unlinkSync(leasePath);
+        // Log to event store
+        this.eventStore.append(createEvent.resourceReleased(lease.session_id, lease.agent, {
+            resource,
+            lease_id: leaseId,
+        }));
+        return true;
+    }
+    /**
+     * Check current resource availability.
+     */
+    getAvailability(resource) {
+        const config = this.config[resource];
+        const activeLeases = this.getActiveLeases(resource);
+        const total = config?.max_concurrent ?? Infinity;
+        const available = Math.max(0, total - activeLeases.length);
+        return {
+            available: available === Infinity ? -1 : available,
+            total: total === Infinity ? -1 : total,
+            leases: activeLeases,
+        };
+    }
+    /**
+     * Wait for resource availability with exponential backoff.
+     */
+    async waitForResource(resource, sessionId, agent, options = {}) {
+        const maxWait = options.maxWaitMs || 60000;
+        const startTime = Date.now();
+        let backoff = 1000;
+        while (Date.now() - startTime < maxWait) {
+            const lease = this.acquire(resource, sessionId, agent, options.ttlMs);
+            if (lease) {
+                return lease;
+            }
+            // Wait with exponential backoff
+            await new Promise((resolve) => setTimeout(resolve, backoff));
+            backoff = Math.min(backoff * 2, 10000);
+        }
+        return undefined;
+    }
+    /**
+     * Release all leases for a session.
+     */
+    releaseAllForSession(sessionId) {
+        let released = 0;
+        if (!existsSync(this.basePath)) {
+            return 0;
+        }
+        const resources = readdirSync(this.basePath).filter((name) => {
+            const path = join(this.basePath, name);
+            return statSync(path).isDirectory();
+        });
+        for (const resource of resources) {
+            if (this.release(resource, sessionId)) {
+                released++;
+            }
+        }
+        return released;
+    }
+    /**
+     * Get all resources with active leases.
+     */
+    listResources() {
+        if (!existsSync(this.basePath)) {
+            return [];
+        }
+        const resources = readdirSync(this.basePath).filter((name) => {
+            const path = join(this.basePath, name);
+            return statSync(path).isDirectory();
+        });
+        return resources.map((resource) => ({
+            resource,
+            availability: this.getAvailability(resource),
+        }));
+    }
+    /**
+     * Clean up all expired leases.
+     */
+    cleanup() {
+        const cleaned = 0;
+        if (!existsSync(this.basePath)) {
+            return 0;
+        }
+        const resources = readdirSync(this.basePath).filter((name) => {
+            const path = join(this.basePath, name);
+            return statSync(path).isDirectory();
+        });
+        for (const resource of resources) {
+            // getActiveLeases automatically cleans up expired leases
+            this.getActiveLeases(resource);
+            // Count the ones that were cleaned (hard to track, so we just trigger cleanup)
+        }
+        return cleaned;
+    }
+}
+/**
+ * Default resource configuration.
+ */
+export const DEFAULT_RESOURCES = {
+    codex_api: { max_concurrent: 3, default_ttl_ms: 1800000 }, // 30 min
+    cursor_agent: { max_concurrent: 5, default_ttl_ms: 600000 }, // 10 min
+    ngrok_tunnel: { max_concurrent: 3, default_ttl_ms: 3600000 }, // 1 hour
+    linear_api: { max_concurrent: 10, default_ttl_ms: 60000 }, // 1 min
+    slack_api: { max_concurrent: 10, default_ttl_ms: 60000 }, // 1 min
+};
+/**
+ * Create a resource manager with default configuration.
+ */
+export function createResourceManager(basePath, eventStore) {
+    return new ResourceManager(basePath, DEFAULT_RESOURCES, eventStore);
+}

package/dist/lib/resources.test.d.ts

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

package/dist/lib/resources.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { ResourceManager } from './resources';
+import { EventStore } from './events';
+describe('ResourceManager', () => {
+    let tempDir;
+    let eventsDir;
+    let manager;
+    let eventStore;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), 'agents-resources-test-'));
+        eventsDir = mkdtempSync(join(tmpdir(), 'agents-events-test-'));
+        eventStore = new EventStore(eventsDir);
+        manager = new ResourceManager(tempDir, {
+            'test-resource': { max_concurrent: 2, default_ttl_ms: 1000 }
+        }, eventStore);
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+        rmSync(eventsDir, { recursive: true, force: true });
+    });
+    it('acquires a resource', () => {
+        const lease = manager.acquire('test-resource', 'session-1', 'claude');
+        expect(lease).toBeDefined();
+        expect(lease.resource).toBe('test-resource');
+        expect(lease.session_id).toBe('session-1');
+        expect(lease.lease_id).toBeDefined();
+        // Check file exists
+        const leasePath = join(tempDir, 'test-resource', `${lease.lease_id}.json`);
+        expect(existsSync(leasePath)).toBe(true);
+    });
+    it('enforces concurrency limits', () => {
+        // Acquire 2 (limit is 2)
+        expect(manager.acquire('test-resource', 'session-1', 'claude')).toBeDefined();
+        expect(manager.acquire('test-resource', 'session-2', 'claude')).toBeDefined();
+        // 3rd should fail
+        expect(manager.acquire('test-resource', 'session-3', 'claude')).toBeUndefined();
+    });
+    it('allows same session to renew/reacquire', () => {
+        const lease1 = manager.acquire('test-resource', 'session-1', 'claude');
+        expect(lease1).toBeDefined();
+        const lease2 = manager.acquire('test-resource', 'session-1', 'claude');
+        expect(lease2).toBeDefined();
+        expect(lease2.lease_id).toBe(lease1.lease_id); // Should update existing lease
+    });
+    it('releases a resource', () => {
+        const lease = manager.acquire('test-resource', 'session-1', 'claude');
+        const result = manager.release('test-resource', 'session-1');
+        expect(result).toBe(true);
+        const leasePath = join(tempDir, 'test-resource', `${lease.lease_id}.json`);
+        expect(existsSync(leasePath)).toBe(false);
+        // Should be able to acquire again
+        expect(manager.acquire('test-resource', 'session-1', 'claude')).toBeDefined();
+    });
+    it('cleans up expired leases on access', async () => {
+        manager = new ResourceManager(tempDir, {
+            'fast-expire': { max_concurrent: 1, default_ttl_ms: 100 }
+        }, eventStore);
+        manager.acquire('fast-expire', 'session-1', 'claude');
+        // Wait for expiry
+        await new Promise(resolve => setTimeout(resolve, 150));
+        // Should be able to acquire (old one cleaned up)
+        const lease = manager.acquire('fast-expire', 'session-2', 'claude');
+        expect(lease).toBeDefined();
+        expect(lease.session_id).toBe('session-2');
+    });
+    it('waits for resource', async () => {
+        // Create a manager with max_concurrent: 1 and short TTL for the wait test
+        const waitManager = new ResourceManager(tempDir, {
+            'wait-resource': { max_concurrent: 1, default_ttl_ms: 100 }
+        }, eventStore);
+        // Acquire the single slot - it will expire in 100ms
+        waitManager.acquire('wait-resource', 'session-1', 'claude');
+        const start = Date.now();
+        // waitForResource uses exponential backoff (1s, 2s, 4s...)
+        // The lease expires in 100ms, so after first backoff (1s) it should acquire
+        const lease = await waitManager.waitForResource('wait-resource', 'session-2', 'claude', {
+            maxWaitMs: 3000
+        });
+        expect(lease).toBeDefined();
+        expect(lease.session_id).toBe('session-2');
+        // Should wait at least 1 backoff interval (~1000ms)
+        expect(Date.now() - start).toBeGreaterThanOrEqual(900);
+    });
+    it('releases all leases for session', () => {
+        manager.acquire('res-1', 'session-1', 'claude');
+        manager.acquire('res-2', 'session-1', 'claude');
+        const released = manager.releaseAllForSession('session-1');
+        expect(released).toBe(2);
+        expect(manager.acquire('res-1', 'session-2', 'claude')).toBeDefined();
+    });
+});

package/dist/lib/runner.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Runner/Supervisor process for agent sessions.
+ *
+ * This module implements the "runner" pattern:
+ * - Runner owns the agent child process
+ * - Captures stdout/stderr to log files
+ * - Updates session status on process exit
+ * - Writes canonical *-result.json envelope
+ * - Writes legacy exit/output files for compatibility
+ *
+ * This avoids the broken pattern of:
+ * - detached + unref (CLI exits, close handler dies)
+ * - bun -e inline watcher scripts (syntax issues)
+ */
+import type { AgentType } from "./active-sessions.js";
+/**
+ * Runner configuration passed via environment.
+ */
+export interface RunnerConfig {
+    sessionId: string;
+    sessionPath: string;
+    promptPath: string;
+    outputPath: string;
+    resultPath: string;
+    stdoutPath: string;
+    stderrPath: string;
+    agent: AgentType;
+    model?: string;
+}
+/**
+ * Exit info written to exit.json.
+ */
+export interface ExitInfo {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    endedAt: string;
+}
+/**
+ * Parse runner config from environment.
+ */
+export declare function parseRunnerConfig(env?: NodeJS.ProcessEnv): RunnerConfig | null;
+/**
+ * Run the agent as a supervised child process.
+ * This function is called by the runner process.
+ */
+export declare function runAgent(config: RunnerConfig): Promise<number>;
+/**
+ * Main entry point for runner process.
+ * Called by `abbie session run <sessionId>`.
+ *
+ * Returns the exit code. The caller (CLI command) should set process.exitCode
+ * rather than calling process.exit() directly, to allow streams to flush.
+ */
+export declare function runnerMain(): Promise<number>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/lib/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/lib/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAmBH,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIrE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB;AAoLD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,YAAY,GAAG,IAAI,CA4B3F;AAkXD;;;GAGG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAgjBpE;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAUlD"}