@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/resources.test.ts

@@ -1,132 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { EventStore } from "./events";
-import { ResourceManager } from "./resources";
-
-describe("ResourceManager", () => {
-  let tempDir: string;
-  let eventsDir: string;
-  let manager: ResourceManager;
-  let eventStore: 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/src/lib/resources.ts

@@ -1,429 +0,0 @@
-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<T>(lockPath: string, fn: () => T, maxRetries = 20, baseDelayMs = 50): T {
-  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: unknown) {
-      if ((err as NodeJS.ErrnoException).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 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 class ResourceManager {
-  private basePath: string;
-  private eventStore: EventStore;
-  private config: Record<string, ResourceConfig>;
-
-  constructor(
-    basePath: string = "~/.abbie/resources",
-    config: Record<string, ResourceConfig> = {},
-    eventStore?: 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: string): void {
-    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.
-   */
-  private getLeaseDir(resource: string): string {
-    const dir = join(this.basePath, resource);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    return dir;
-  }
-
-  /**
-   * Get all active leases for a resource.
-   */
-  private getActiveLeases(resource: string): ResourceLease[] {
-    const dir = this.getLeaseDir(resource);
-    const now = Date.now();
-
-    return readdirSync(dir)
-      .filter((f) => f.endsWith(".json"))
-      .map((f) => {
-        const lease: ResourceLease = 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.
-   */
-  private generateLeaseId(): string {
-    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: string,
-    sessionId: string,
-    agent: string,
-    ttlMs?: number,
-  ): ResourceLease | undefined {
-    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.
-   */
-  private createLease(
-    resource: string,
-    sessionId: string,
-    agent: string,
-    ttlMs: number,
-  ): ResourceLease {
-    const now = new Date();
-    const expiresAt = new Date(now.getTime() + ttlMs);
-    const leaseId = this.generateLeaseId();
-
-    const lease: ResourceLease = {
-      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: string, leaseId: string, ttlMs?: number): ResourceLease | undefined {
-    const leasePath = join(this.getLeaseDir(resource), `${leaseId}.json`);
-    if (!existsSync(leasePath)) {
-      return undefined;
-    }
-
-    const lease: ResourceLease = 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: string, sessionId: string): boolean {
-    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: string, leaseId: string): boolean {
-    const leasePath = join(this.getLeaseDir(resource), `${leaseId}.json`);
-    if (!existsSync(leasePath)) {
-      return false;
-    }
-
-    const lease: ResourceLease = 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: string): { available: number; total: number; leases: ResourceLease[] } {
-    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: string,
-    sessionId: string,
-    agent: string,
-    options: {
-      maxWaitMs?: number;
-      ttlMs?: number;
-    } = {},
-  ): Promise<ResourceLease | undefined> {
-    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: string): number {
-    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(): Array<{
-    resource: string;
-    availability: ReturnType<ResourceManager["getAvailability"]>;
-  }> {
-    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(): number {
-    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: Record<string, ResourceConfig> = {
-  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?: string, eventStore?: EventStore): ResourceManager {
-  return new ResourceManager(basePath, DEFAULT_RESOURCES, eventStore);
-}