@skaile/forge-agent-runtime 0.0.0-stage → 1.1.0

package/dist/index.mjs

@@ -0,0 +1,357 @@
+import { P as ProcessManagerAdapter, A as AgentProcessManager } from './shared/forge-agent-runtime.B1LZr0Sl.mjs';
+import { EventEmitter } from 'node:events';
+import { mkdir, appendFile, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { SessionDispatcher } from '@skaile/workspaces/sdk/session';
+import 'node:child_process';
+import 'node:fs';
+import 'node:net';
+import 'node:url';
+import 'consola';
+import 'picocolors';
+import '@skaile/workspaces/sdk/client';
+import '@skaile/workspaces/sdk/transport/ws/client';
+import '@skaile/forge-settings/server';
+
+const registry = /* @__PURE__ */ new Map();
+registry.set("omp", () => new ProcessManagerAdapter());
+registry.set("claude-sdk", () => new ProcessManagerAdapter());
+function createAdapterForHarness(harness) {
+  const factory = registry.get(harness) ?? registry.get("omp");
+  return factory();
+}
+function registerHarness(name, factory) {
+  registry.set(name, factory);
+}
+function listRegisteredHarnesses() {
+  return Array.from(registry.keys());
+}
+
+class EventEmitterSubscriberTransport {
+  emitter = new EventEmitter();
+  /**
+   * Push an event to all listeners registered for this subscriber ID.
+   *
+   * Part of the `SubscriberTransport` interface — called by `SessionDispatcher`
+   * when the agent emits an event.
+   *
+   * @param subscriberId - ID of the subscriber connection to notify.
+   * @param event - Agent event to broadcast.
+   */
+  send(subscriberId, event) {
+    this.emitter.emit(subscriberId, event);
+  }
+  /**
+   * Remove all listeners for a subscriber ID.
+   *
+   * Part of the `SubscriberTransport` interface — called by `SessionDispatcher`
+   * when a subscriber disconnects or the session ends.
+   *
+   * @param subscriberId - ID of the subscriber whose listeners should be cleared.
+   */
+  remove(subscriberId) {
+    this.emitter.removeAllListeners(subscriberId);
+  }
+  /**
+   * Register a per-connection event handler and return an unsubscribe function.
+   *
+   * Not part of the `SubscriberTransport` interface — used directly by SSE route handlers.
+   *
+   * @param subscriberId - Unique identifier for this SSE connection.
+   * @param handler - Called for each agent event broadcast to this subscriber.
+   * @returns Cleanup function — call when the SSE connection closes.
+   */
+  listen(subscriberId, handler) {
+    this.emitter.on(subscriberId, handler);
+    return () => this.emitter.off(subscriberId, handler);
+  }
+}
+
+class JsonlMessageStore {
+  /**
+   * @param dir - Directory where per-session `.jsonl` files are stored.
+   *   The directory is created on first write if it does not exist.
+   */
+  constructor(dir) {
+    this.dir = dir;
+  }
+  /** Tail of this instance's serialised append chain; never rejects. */
+  tail = Promise.resolve();
+  filePath(sessionId) {
+    return join(this.dir, `${sessionId}.jsonl`);
+  }
+  /**
+   * Append a message to the session's JSONL file.
+   *
+   * Creates the file (and parent directory) if absent.
+   *
+   * Appends are chained on a per-instance tail promise, so overlapping calls are
+   * written in the order they were issued rather than racing each other's
+   * open/write/close. A failed write is neutralised for the chain but still
+   * rejected to its own caller, so one bad append does not poison the ones after it.
+   *
+   * @param message - Message to persist. `message.sessionId` determines the target file.
+   */
+  async append(message) {
+    const mine = this.tail.then(async () => {
+      await mkdir(this.dir, { recursive: true });
+      await appendFile(this.filePath(message.sessionId), `${JSON.stringify(message)}
+`);
+    });
+    this.tail = mine.catch(() => {
+    });
+    return mine;
+  }
+  /**
+   * Read messages for a session with optional pagination.
+   *
+   * Reads the full file on every call — acceptable for forge's short-lived sessions.
+   *
+   * @param sessionId - Session whose messages to retrieve.
+   * @param opts.before - Return only messages with `seq` less than this value.
+   * @param opts.limit - Return at most this many messages (tail semantics — most recent).
+   * @returns Ordered array of messages (oldest first within the result window).
+   */
+  async getMessages(sessionId, opts) {
+    let content;
+    try {
+      content = await readFile(this.filePath(sessionId), "utf-8");
+    } catch {
+      return [];
+    }
+    const parsed = [];
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        parsed.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    let messages = parsed;
+    if (opts?.before !== void 0) {
+      messages = messages.filter((m) => m.seq < opts.before);
+    }
+    if (opts?.limit !== void 0) {
+      messages = messages.slice(-opts.limit);
+    }
+    return messages;
+  }
+  /**
+   * Return the sequence number of the most recent message in the session.
+   *
+   * Reads the whole JSONL file and takes its last non-empty line — see the
+   * class note on why re-reading is acceptable here.
+   *
+   * @param sessionId - Session to inspect.
+   * @returns `seq` of the last appended message, or `0` if the session has no
+   *   messages (or its last line is unreadable).
+   */
+  async getLatestSeq(sessionId) {
+    let content;
+    try {
+      content = await readFile(this.filePath(sessionId), "utf-8");
+    } catch {
+      return 0;
+    }
+    const lines = content.split("\n").filter((l) => l.trim());
+    if (lines.length === 0) return 0;
+    const lastLine = lines[lines.length - 1];
+    try {
+      const last = JSON.parse(lastLine ?? "");
+      return last.seq ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+}
+
+class BaseAgentManager extends EventEmitter {
+  processManager = new AgentProcessManager();
+  constructor() {
+    super();
+    this.setMaxListeners(50);
+  }
+  // ── Core session creation ─────────────────────────────────────────────
+  /**
+   * Create a new ManagedSession: spawn subprocess, wire dispatcher, register event handler.
+   *
+   * This is the canonical "extract" from the `_createSession` methods in each app.
+   * The event handler below is the common core — apps extend via `onEvent()`.
+   *
+   * @param sessionId - The UUID for this session (resolved by the app).
+   */
+  async createManagedSession(sessionId) {
+    const config = await this.buildAdapterConfig(sessionId);
+    const processKey = this.buildProcessKey(sessionId);
+    await this.processManager.create(processKey, {
+      projectDir: config.projectDir,
+      harness: config.harness,
+      registry: config.registry,
+      providers: config.providers,
+      credentialEnv: config.credentialEnv,
+      model: config.model,
+      env: config.env,
+      systemPrompt: config.systemPrompt,
+      maxTurns: config.maxTurns,
+      agentDir: config.agentDir,
+      harnessSessionId: config.harnessSessionId,
+      host: config.host,
+      wsAuthToken: config.wsAuthToken
+    });
+    const messageStore = new JsonlMessageStore(this.getMessagesDir(sessionId));
+    const subscriberTransport = new EventEmitterSubscriberTransport();
+    const client = this.processManager.createAgentClient(processKey);
+    const session = {
+      sessionId,
+      dispatcher: new SessionDispatcher({
+        sessionId,
+        client,
+        store: messageStore,
+        transport: subscriberTransport
+      }),
+      subscriberTransport,
+      isStreaming: false,
+      error: null
+    };
+    await session.dispatcher.init();
+    const eventHandler = async (event) => {
+      if (event.type === "status") {
+        const phase = event.phase;
+        if (phase === "thinking" || phase === "working") {
+          session.isStreaming = true;
+        } else if (phase === "idle") {
+          session.isStreaming = false;
+        }
+      }
+      if (event.type === "finished" || event.type === "turn_end" || event.type === "agent_end") {
+        session.isStreaming = false;
+      }
+      if (event.type === "message_start" && event.message?.role === "assistant") {
+        session.isStreaming = true;
+      }
+      if (event.type === "error") {
+        session.error = event.error || event.message || String(event);
+        session.isStreaming = false;
+      }
+      const suppress = await this.onEvent(event, session, processKey);
+      if (suppress) return;
+      this.emit("event", event);
+    };
+    this.processManager.on(`event:${processKey}`, eventHandler);
+    session.removeEventHandler = () => this.processManager.off(`event:${processKey}`, eventHandler);
+    this.processManager.on(`error:${processKey}`, (err) => {
+      session.error = err.error || String(err);
+      session.isStreaming = false;
+      this.emit("event", {
+        type: "error",
+        error: session.error
+      });
+    });
+    await this.onSessionCreated(session);
+    return session;
+  }
+  /**
+   * App-specific event hook. Called for every agent event after common
+   * streaming/error tracking but before SSE fan-out.
+   *
+   * Return `true` to suppress the default `this.emit('event', event)` call.
+   * Default implementation: no-op, returns false.
+   *
+   * @example Override in forge-workspace to handle `capability_invoked`
+   * @example Override in forge-assistant to trigger consolidation on `finished`
+   */
+  async onEvent(_event, _session, _processKey) {
+    return false;
+  }
+  // ── Session teardown helpers ──────────────────────────────────────────
+  /**
+   * Tear down a session: unregister event handler, disconnect dispatcher.
+   */
+  teardownSession(session) {
+    session.removeEventHandler?.();
+    session.dispatcher.disconnect().catch(() => {
+    });
+  }
+  // ── Observable state helpers ──────────────────────────────────────────
+  /**
+   * Whether the given session is currently streaming.
+   * Returns false if the session does not exist.
+   * Override in subclasses that cache their session.
+   */
+  isSessionStreaming(_sessionId) {
+    return false;
+  }
+  /**
+   * Last error for the given session, or null.
+   * Override in subclasses that cache their session.
+   */
+  getSessionError(_sessionId) {
+    return null;
+  }
+}
+
+class FanoutSubscriberTransport {
+  emitter = new EventEmitter();
+  FANOUT_CHANNEL = "__fanout__";
+  constructor(maxListeners = 200) {
+    this.emitter.setMaxListeners(maxListeners);
+  }
+  /**
+   * Called by SessionDispatcher. Broadcasts to ALL subscribers (ignores subscriberId).
+   */
+  send(_subscriberId, event) {
+    this.emitter.emit(this.FANOUT_CHANNEL, event);
+  }
+  /**
+   * Called by SessionDispatcher on disconnect. No-op for fanout — subscribers
+   * manage their own cleanup via the unsubscribe function returned by subscribe().
+   */
+  remove(_subscriberId) {
+  }
+  /**
+   * Internal: register a handler for all broadcasted events.
+   * Returns an unsubscribe function.
+   */
+  _listen(handler) {
+    this.emitter.on(this.FANOUT_CHANNEL, handler);
+    return () => this.emitter.off(this.FANOUT_CHANNEL, handler);
+  }
+  /**
+   * Current count of listeners on the fanout channel.
+   */
+  get listenerCount() {
+    return this.emitter.listenerCount(this.FANOUT_CHANNEL);
+  }
+}
+class FanoutTransport {
+  /**
+   * The inner transport passed to SessionDispatcher.
+   * SessionDispatcher calls transport.send(subscriberId, event) for each
+   * registered subscriber. FanoutTransport overrides send() to broadcast
+   * to ALL connected subscribers, ignoring the subscriberId argument.
+   */
+  transport;
+  constructor() {
+    this.transport = new FanoutSubscriberTransport();
+  }
+  /**
+   * Register a new SSE connection.
+   *
+   * @param connectionId - Unique identifier for this browser connection (e.g. randomUUID()).
+   *   Used only for diagnostics — the fanout ignores it for routing.
+   * @param handler - Called for each agent event broadcast to all subscribers.
+   * @returns Unsubscribe function — call when the SSE connection closes.
+   */
+  subscribe(_connectionId, handler) {
+    return this.transport._listen(handler);
+  }
+  /**
+   * Returns the current count of active subscribers.
+   * Useful for diagnostics and health checks.
+   */
+  get subscriberCount() {
+    return this.transport.listenerCount;
+  }
+}
+
+export { AgentProcessManager, BaseAgentManager, EventEmitterSubscriberTransport, FanoutTransport, JsonlMessageStore, ProcessManagerAdapter, createAdapterForHarness, listRegisteredHarnesses, registerHarness };