macro-agent 0.2.5 → 0.2.6

package/src/adapters/inbox-adapter.ts

@@ -1,292 +0,0 @@
-/**
- * InboxAdapter — Wraps agent-inbox for macro-agent's messaging needs.
- *
- * Embeds agent-inbox in-process (hybrid model):
- * - macro-agent gets zero-latency event access via inbox.events
- * - Agent MCP subprocesses connect via IPC socket
- *
- * Owns adapter-side policy enforcement:
- * - Signal filtering (before delivery to handler)
- * - Emission validation (before forwarding to inbox)
- *
- * @module adapters/inbox-adapter
- */
-
-import {
-  createAgentInbox,
-  type AgentInbox,
-  type MessageContent,
-  type Message,
-  type Importance,
-} from "agent-inbox";
-import type {
-  InboxAdapter as IInboxAdapter,
-  InboxDeliveryEvent,
-  RegisterAgentOptions,
-  SendMessageOptions,
-  DeliveryHandler,
-  SignalFilterFn,
-  EmissionValidatorFn,
-} from "./types.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Configuration
-// ─────────────────────────────────────────────────────────────────
-
-export interface InboxAdapterConfig {
-  /** Path to SQLite database for inbox persistence. */
-  sqlitePath?: string;
-  /** IPC socket path for agent subprocesses. */
-  socketPath: string;
-  /** Default scope for standalone agents (default: "default"). */
-  defaultScope?: string;
-  /** Federation config for cross-instance communication. */
-  federation?: {
-    systemId?: string;
-    peers?: Array<{
-      systemId: string;
-      url?: string;
-      meshPeerId?: string;
-    }>;
-    trust?: {
-      allowedServers?: string[];
-    };
-  };
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Implementation
-// ─────────────────────────────────────────────────────────────────
-
-export class DefaultInboxAdapter implements IInboxAdapter {
-  private inbox: AgentInbox | null = null;
-  private handlers: Set<DeliveryHandler> = new Set();
-  private signalFilters = new Map<string, SignalFilterFn>();
-  private emissionValidators = new Map<string, EmissionValidatorFn>();
-  private readonly config: InboxAdapterConfig;
-  private readonly defaultScope: string;
-
-  constructor(config: InboxAdapterConfig) {
-    this.config = config;
-    this.defaultScope = config.defaultScope ?? "default";
-  }
-
-  /**
-   * Initialize the embedded agent-inbox instance.
-   * Must be called before any other methods.
-   */
-  async initialize(): Promise<void> {
-    this.inbox = await createAgentInbox({
-      sqlitePath: this.config.sqlitePath,
-      enableFederation: !!this.config.federation?.peers?.length,
-      config: {
-        socketPath: this.config.socketPath,
-        scope: this.defaultScope,
-        // Federation config is passed through with compatible types
-        ...(this.config.federation && {
-          federation: {
-            systemId: this.config.federation.systemId,
-            peers: this.config.federation.peers,
-            trust: this.config.federation.trust
-              ? { allowedServers: this.config.federation.trust.allowedServers ?? [] }
-              : undefined,
-          } as any,
-        }),
-      },
-    });
-
-    // Subscribe to delivery events from agent-inbox
-    this.inbox.events.on(
-      "inbox.message",
-      (event: InboxDeliveryEvent) => {
-        this.handleDeliveryEvent(event);
-      }
-    );
-  }
-
-  get socketPath(): string {
-    return this.config.socketPath;
-  }
-
-  // ── Agent Lifecycle ──────────────────────────────────────────
-
-  async registerAgent(
-    agentId: string,
-    opts: RegisterAgentOptions
-  ): Promise<void> {
-    const inbox = this.requireInbox();
-    inbox.storage.putAgent({
-      agent_id: agentId,
-      display_name: opts.name,
-      scope: opts.scope,
-      status: "active",
-      metadata: {
-        role: opts.role,
-        ...opts.metadata,
-      },
-      registered_at: new Date().toISOString(),
-      last_active_at: new Date().toISOString(),
-    });
-  }
-
-  async deregisterAgent(agentId: string): Promise<void> {
-    const inbox = this.requireInbox();
-    const agent = inbox.storage.getAgent(agentId);
-    if (agent) {
-      inbox.storage.putAgent({
-        ...agent,
-        status: "offline",
-        last_active_at: new Date().toISOString(),
-      });
-    }
-  }
-
-  // ── Messaging ────────────────────────────────────────────────
-
-  async send(
-    from: string,
-    to: string | string[],
-    content: MessageContent | string,
-    opts?: SendMessageOptions
-  ): Promise<string> {
-    const inbox = this.requireInbox();
-
-    // Normalize content
-    const normalizedContent: MessageContent =
-      typeof content === "string" ? { type: "text", text: content } : content;
-
-    // Build a partial message for validation
-    const validationMsg = {
-      content: normalizedContent,
-      metadata: {},
-    } as Message;
-
-    // Run emission validation (adapter-side) — first rejection wins
-    for (const validator of this.emissionValidators.values()) {
-      const rejection = validator(from, validationMsg);
-      if (rejection) {
-        throw new Error(`Emission rejected for ${from}: ${rejection}`);
-      }
-    }
-
-    // Route through agent-inbox
-    const message = await inbox.router.routeMessage({
-      from,
-      to,
-      payload: normalizedContent,
-      threadTag: opts?.threadTag,
-      importance: opts?.importance,
-      subject: opts?.subject,
-      inReplyTo: opts?.inReplyTo,
-      scope: opts?.scope,
-    });
-
-    return message.id;
-  }
-
-  // ── Delivery Subscription ────────────────────────────────────
-
-  onDelivery(handler: DeliveryHandler): void {
-    this.handlers.add(handler);
-  }
-
-  offDelivery(handler: DeliveryHandler): void {
-    this.handlers.delete(handler);
-  }
-
-  // ── Queries ──────────────────────────────────────────────────
-
-  async checkInbox(
-    agentId: string,
-    opts?: { unreadOnly?: boolean; limit?: number }
-  ): Promise<Message[]> {
-    const inbox = this.requireInbox();
-    return inbox.storage.getInbox(agentId, {
-      unreadOnly: opts?.unreadOnly,
-      limit: opts?.limit,
-    });
-  }
-
-  async readThread(threadTag: string, scope?: string): Promise<Message[]> {
-    const inbox = this.requireInbox();
-    return inbox.storage.getThread({
-      threadTag,
-      scope: scope ?? this.defaultScope,
-    });
-  }
-
-  // ── Policy Hooks ─────────────────────────────────────────────
-
-  setSignalFilter(filter: SignalFilterFn): void {
-    this.signalFilters.set("default", filter);
-  }
-
-  setEmissionValidator(validator: EmissionValidatorFn): void {
-    this.emissionValidators.set("default", validator);
-  }
-
-  // ── Multi-Team Policy Hooks ─────────────────────────────────
-
-  addSignalFilter(id: string, filter: SignalFilterFn): void {
-    this.signalFilters.set(id, filter);
-  }
-
-  removeSignalFilter(id: string): void {
-    this.signalFilters.delete(id);
-  }
-
-  addEmissionValidator(id: string, validator: EmissionValidatorFn): void {
-    this.emissionValidators.set(id, validator);
-  }
-
-  removeEmissionValidator(id: string): void {
-    this.emissionValidators.delete(id);
-  }
-
-  // ── Lifecycle ────────────────────────────────────────────────
-
-  async stop(): Promise<void> {
-    if (this.inbox) {
-      await this.inbox.stop();
-      this.inbox = null;
-    }
-    this.handlers.clear();
-  }
-
-  /** Get the underlying AgentInbox instance (for advanced use). */
-  getInbox(): AgentInbox {
-    return this.requireInbox();
-  }
-
-  // ── Private ──────────────────────────────────────────────────
-
-  private requireInbox(): AgentInbox {
-    if (!this.inbox) {
-      throw new Error(
-        "InboxAdapter not initialized. Call initialize() first."
-      );
-    }
-    return this.inbox;
-  }
-
-  private handleDeliveryEvent(event: InboxDeliveryEvent): void {
-    // Apply signal filters (adapter-side) — ALL must return true (AND logic)
-    for (const filter of this.signalFilters.values()) {
-      const allowed = filter(
-        event.message.sender_id,
-        event.agentId,
-        event.message
-      );
-      if (!allowed) return; // silently drop
-    }
-
-    // Dispatch to all registered handlers
-    for (const handler of this.handlers) {
-      try {
-        handler(event);
-      } catch {
-        // Handler errors should not break delivery to other handlers
-      }
-    }
-  }
-}

package/src/adapters/inbox-client-adapter.ts

@@ -1,173 +0,0 @@
-/**
- * InboxClientAdapter — Client-only inbox adapter for MCP subprocesses.
- *
- * Connects to the main process's agent-inbox via IPC socket (NDJSON).
- * Does NOT embed agent-inbox or start an IPC server.
- * Used by cli/mcp.ts where the main process already owns the inbox.
- *
- * @module adapters/inbox-client-adapter
- */
-
-import * as net from "node:net";
-import type {
-  InboxAdapter,
-  InboxDeliveryEvent,
-  RegisterAgentOptions,
-  SendMessageOptions,
-  DeliveryHandler,
-  SignalFilterFn,
-  EmissionValidatorFn,
-} from "./types.js";
-import type { Message, MessageContent } from "agent-inbox";
-
-export class InboxClientAdapter implements InboxAdapter {
-  private socket: net.Socket | null = null;
-  private buffer = "";
-  private pending: Map<number, (resp: any) => void> = new Map();
-  private seq = 0;
-  private _socketPath: string;
-
-  constructor(socketPath: string) {
-    this._socketPath = socketPath;
-  }
-
-  get socketPath(): string {
-    return this._socketPath;
-  }
-
-  async connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("Inbox IPC connect timeout")), 5000);
-
-      this.socket = net.createConnection(this._socketPath, () => {
-        clearTimeout(timer);
-        resolve();
-      });
-
-      this.socket.on("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-
-      this.socket.on("data", (data) => {
-        this.buffer += data.toString();
-        let idx: number;
-        while ((idx = this.buffer.indexOf("\n")) !== -1) {
-          const line = this.buffer.slice(0, idx).trim();
-          this.buffer = this.buffer.slice(idx + 1);
-          if (!line) continue;
-          try {
-            const resp = JSON.parse(line);
-            // Resolve oldest pending request
-            const oldest = this.pending.entries().next();
-            if (!oldest.done) {
-              oldest.value[1](resp);
-              this.pending.delete(oldest.value[0]);
-            }
-          } catch { /* ignore */ }
-        }
-      });
-    });
-  }
-
-  private async ipcCall(cmd: Record<string, unknown>): Promise<any> {
-    if (!this.socket) throw new Error("Inbox IPC not connected");
-
-    return new Promise((resolve, reject) => {
-      const id = this.seq++;
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error("Inbox IPC call timeout"));
-      }, 10000);
-
-      this.pending.set(id, (resp: any) => {
-        clearTimeout(timer);
-        if (resp.ok === false) {
-          reject(new Error(resp.error ?? "IPC error"));
-        } else {
-          resolve(resp);
-        }
-      });
-
-      this.socket!.write(JSON.stringify(cmd) + "\n");
-    });
-  }
-
-  // ── InboxAdapter interface ───────────────────────────────────
-
-  async registerAgent(agentId: string, opts: RegisterAgentOptions): Promise<void> {
-    // Registration is handled by the main process AgentManager
-    // Subprocess doesn't need to register
-  }
-
-  async deregisterAgent(agentId: string): Promise<void> {
-    // Handled by main process
-  }
-
-  async send(
-    from: string,
-    to: string | string[],
-    content: MessageContent | string,
-    opts?: SendMessageOptions
-  ): Promise<string> {
-    const normalizedContent = typeof content === "string" ? content : content;
-
-    const resp = await this.ipcCall({
-      action: "send",
-      from,
-      to,
-      payload: normalizedContent,
-      threadTag: opts?.threadTag,
-      importance: opts?.importance,
-      scope: opts?.scope,
-      subject: opts?.subject,
-      inReplyTo: opts?.inReplyTo,
-    });
-
-    return resp.messageId ?? "";
-  }
-
-  onDelivery(_handler: DeliveryHandler): void {
-    // Subprocess doesn't receive delivery events
-  }
-
-  offDelivery(_handler: DeliveryHandler): void {}
-
-  async checkInbox(
-    agentId: string,
-    opts?: { unreadOnly?: boolean; limit?: number }
-  ): Promise<Message[]> {
-    const resp = await this.ipcCall({
-      action: "check_inbox",
-      agentId,
-      unreadOnly: opts?.unreadOnly,
-      limit: opts?.limit,
-    });
-    return resp.messages ?? [];
-  }
-
-  async readThread(threadTag: string, scope?: string): Promise<Message[]> {
-    const resp = await this.ipcCall({
-      action: "read_thread",
-      threadTag,
-      scope,
-    });
-    return resp.messages ?? [];
-  }
-
-  setSignalFilter(_filter: SignalFilterFn): void {}
-  setEmissionValidator(_validator: EmissionValidatorFn): void {}
-
-  // Multi-team hooks — no-ops for subprocess
-  addSignalFilter(_id: string, _filter: SignalFilterFn): void {}
-  removeSignalFilter(_id: string): void {}
-  addEmissionValidator(_id: string, _validator: EmissionValidatorFn): void {}
-  removeEmissionValidator(_id: string): void {}
-
-  async stop(): Promise<void> {
-    if (this.socket) {
-      this.socket.destroy();
-      this.socket = null;
-    }
-  }
-}

package/src/adapters/index.ts

@@ -1,44 +0,0 @@
-/**
- * Adapter layer — the only touch points between macro-agent and subsystems.
- *
- * @module adapters
- */
-
-export type {
-  InboxAdapter,
-  TasksAdapter,
-  InboxDeliveryEvent,
-  SignalFilterFn,
-  EmissionValidatorFn,
-  RegisterAgentOptions,
-  SendMessageOptions,
-  DeliveryHandler,
-  TaskStatus,
-  TaskAction,
-  CreateTaskOptions,
-  TaskQueryOptions,
-  TaskRecord,
-} from "./types.js";
-
-export {
-  DefaultInboxAdapter,
-  type InboxAdapterConfig,
-} from "./inbox-adapter.js";
-
-export {
-  DefaultTasksAdapter,
-  type TasksAdapterConfig,
-} from "./tasks-adapter.js";
-
-export {
-  ensureOpentasksDaemon,
-  type DaemonHandle,
-  type EnsureDaemonOptions,
-} from "./opentasks-daemon.js";
-
-export {
-  setupFederation,
-  createRemoteSpawnHandler,
-  type FederationConfig,
-  type FederationPeer,
-} from "./federation.js";