@creatornader/agent-bridge 0.2.0

package/clients/claude-code.json

@@ -0,0 +1,20 @@
+{
+  "schema": "agent-bridge.runtime-manifest.v1",
+  "runtime": "claude-code",
+  "transport": "stdio",
+  "command": "agent-bridge-mcp",
+  "identity": { "source": "env", "variable": "AGENT_BRIDGE_AGENT", "required": true },
+  "instance": { "source": "env", "variable": "AGENT_BRIDGE_INSTANCE", "required": true },
+  "backendConfig": { "source": "env", "variable": "AGENT_BRIDGE_CONFIG", "perClient": true },
+  "configLocations": ["~/.claude.json", "~/.agent-bridge/config"],
+  "install": {
+    "method": "native-cli",
+    "command": ["claude", "mcp", "add", "--scope", "user", "agent-bridge", "-e", "AGENT_BRIDGE_AGENT={{identity}}", "-e", "AGENT_BRIDGE_INSTANCE={{instance}}", "-e", "AGENT_BRIDGE_CONFIG={{backendConfig}}", "--", "agent-bridge-mcp"],
+    "identityValue": "operator-selected",
+    "instanceValue": "installer-generated",
+    "backendConfigValue": "installer-generated",
+    "restartRequired": true
+  },
+  "wakeModes": ["poll"],
+  "healthCommand": ["agent-bridge", "doctor", "--json"]
+}

package/clients/claude-desktop.json

@@ -0,0 +1,20 @@
+{
+  "schema": "agent-bridge.runtime-manifest.v1",
+  "runtime": "claude-desktop",
+  "transport": "stdio",
+  "command": "agent-bridge-mcp",
+  "identity": { "source": "env", "variable": "AGENT_BRIDGE_AGENT", "required": true },
+  "instance": { "source": "env", "variable": "AGENT_BRIDGE_INSTANCE", "required": true },
+  "backendConfig": { "source": "env", "variable": "AGENT_BRIDGE_CONFIG", "perClient": true },
+  "configLocations": ["~/Library/Application Support/Claude/claude_desktop_config.json", "%APPDATA%/Claude/claude_desktop_config.json", "~/.agent-bridge/config"],
+  "install": {
+    "method": "json-config",
+    "keyPath": "mcpServers.agent-bridge",
+    "identityValue": "operator-selected",
+    "instanceValue": "installer-generated",
+    "backendConfigValue": "installer-generated",
+    "restartRequired": true
+  },
+  "wakeModes": ["poll"],
+  "healthCommand": ["agent-bridge", "doctor", "--json"]
+}

package/clients/codex.json

@@ -0,0 +1,20 @@
+{
+  "schema": "agent-bridge.runtime-manifest.v1",
+  "runtime": "codex",
+  "transport": "stdio",
+  "command": "agent-bridge-mcp",
+  "identity": { "source": "env", "variable": "AGENT_BRIDGE_AGENT", "required": true },
+  "instance": { "source": "env", "variable": "AGENT_BRIDGE_INSTANCE", "required": true },
+  "backendConfig": { "source": "env", "variable": "AGENT_BRIDGE_CONFIG", "perClient": true },
+  "configLocations": ["~/.codex/config.toml", "~/.agent-bridge/config"],
+  "install": {
+    "method": "native-cli",
+    "command": ["codex", "mcp", "add", "agent-bridge", "--env", "AGENT_BRIDGE_AGENT={{identity}}", "--env", "AGENT_BRIDGE_INSTANCE={{instance}}", "--env", "AGENT_BRIDGE_CONFIG={{backendConfig}}", "--", "agent-bridge-mcp"],
+    "identityValue": "operator-selected",
+    "instanceValue": "installer-generated",
+    "backendConfigValue": "installer-generated",
+    "restartRequired": true
+  },
+  "wakeModes": ["poll"],
+  "healthCommand": ["agent-bridge", "doctor", "--json"]
+}

package/clients/generic-mcp.json

@@ -0,0 +1,13 @@
+{
+  "schema": "agent-bridge.runtime-manifest.v1",
+  "runtime": "generic-mcp",
+  "transport": "stdio",
+  "command": "agent-bridge-mcp",
+  "identity": { "source": "env", "variable": "AGENT_BRIDGE_AGENT", "required": true },
+  "instance": { "source": "env", "variable": "AGENT_BRIDGE_INSTANCE", "required": true },
+  "backendConfig": { "source": "env", "variable": "AGENT_BRIDGE_CONFIG", "perClient": true },
+  "configLocations": ["~/.agent-bridge/config"],
+  "install": { "method": "operator-configured", "identityValue": "operator-selected", "instanceValue": "operator-selected", "backendConfigValue": "operator-selected", "restartRequired": true },
+  "wakeModes": ["poll"],
+  "healthCommand": ["agent-bridge", "doctor", "--json"]
+}

package/clients/openclaw.json

@@ -0,0 +1,13 @@
+{
+  "schema": "agent-bridge.runtime-manifest.v1",
+  "runtime": "openclaw",
+  "transport": "stdio",
+  "command": "agent-bridge-mcp",
+  "identity": { "source": "env", "variable": "AGENT_BRIDGE_AGENT", "required": true },
+  "instance": { "source": "env", "variable": "AGENT_BRIDGE_INSTANCE", "required": true },
+  "backendConfig": { "source": "env", "variable": "AGENT_BRIDGE_CONFIG", "perClient": true },
+  "configLocations": ["~/.openclaw/openclaw.json", "~/.agent-bridge/config"],
+  "install": { "method": "operator-configured", "identityValue": "operator-selected", "instanceValue": "operator-selected", "backendConfigValue": "operator-selected", "restartRequired": true },
+  "wakeModes": ["poll", "process"],
+  "healthCommand": ["agent-bridge", "doctor", "--json"]
+}

package/dist/bridge-domain-BcnBeHOn.d.ts

@@ -0,0 +1,97 @@
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type DeliveryState = "pending" | "claimed" | "acked" | "retrying" | "dead";
+type MessagePriority = "info" | "high" | "urgent";
+interface RetryPolicy {
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    jitterRatio: number;
+}
+interface BridgePrincipal {
+    workspace: string;
+    agent: string;
+    instance?: string;
+}
+interface MessageDraft {
+    id?: string;
+    type: string;
+    content: string;
+    contentType?: string;
+    data?: JsonValue;
+    targets?: string[];
+    threadId?: string;
+    replyToId?: string;
+    correlationId?: string;
+    causationId?: string;
+    priority?: MessagePriority;
+    expiresAt?: string;
+    idempotencyKey?: string;
+    atribReceiptId?: string;
+    informedBy?: string[];
+    metadata?: JsonValue;
+}
+interface BridgeMessage extends Required<Pick<MessageDraft, "id" | "type" | "content" | "contentType" | "targets" | "priority">> {
+    workspace: string;
+    source: string;
+    sequence: string;
+    createdAt: string;
+    data?: JsonValue;
+    threadId?: string;
+    replyToId?: string;
+    correlationId?: string;
+    causationId?: string;
+    expiresAt?: string;
+    idempotencyKey?: string;
+    atribReceiptId?: string;
+    informedBy?: string[];
+    metadata?: JsonValue;
+}
+interface BridgeDelivery {
+    id: string;
+    messageId: string;
+    workspace: string;
+    recipient: string;
+    state: DeliveryState;
+    attempt: number;
+    availableAt: string;
+    leaseToken?: string;
+    leaseOwner?: string;
+    leaseExpiresAt?: string;
+    lastError?: string;
+}
+interface BridgeDeliveryEvent {
+    sequence: string;
+    deliveryId: string;
+    messageId: string;
+    workspace: string;
+    recipient: string;
+    fromState?: DeliveryState;
+    toState: DeliveryState;
+    attempt: number;
+    leaseOwner?: string;
+    error?: string;
+    createdAt: string;
+}
+interface AgentPresence {
+    workspace: string;
+    agent: string;
+    instance: string;
+    runtimeType?: string;
+    capabilities: string[];
+    leaseExpiresAt: string;
+    lastSeenAt: string;
+}
+declare class BridgeValidationError extends Error {
+    readonly code = "invalid_input";
+}
+declare function uuidv7(now?: number): string;
+declare function validatePrincipal(value: BridgePrincipal): BridgePrincipal;
+declare function validateUuid(value: unknown, field: string): string;
+declare function validateRetryPolicy(input?: Partial<RetryPolicy> | null): RetryPolicy;
+declare function validateMessageDraft(input: MessageDraft): Omit<BridgeMessage, "workspace" | "source" | "sequence" | "createdAt">;
+declare function encodeCursor(sequence: string): string;
+declare function decodeCursor(cursor: string | undefined): string | undefined;
+
+export { type AgentPresence as A, type BridgeDelivery as B, type DeliveryState as D, type JsonValue as J, type MessageDraft as M, type RetryPolicy as R, type BridgeDeliveryEvent as a, type BridgeMessage as b, type BridgePrincipal as c, BridgeValidationError as d, type MessagePriority as e, decodeCursor as f, encodeCursor as g, validatePrincipal as h, validateRetryPolicy as i, validateUuid as j, uuidv7 as u, validateMessageDraft as v };

package/dist/bridge-service-CfqMcMAn.d.ts

@@ -0,0 +1,28 @@
+import { c as BridgePrincipal, M as MessageDraft, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-BcnBeHOn.js';
+import { a as BridgeStore, I as InsertMessageResult, b as MessageQuery, M as MessagePage } from './bridge-store-BuGjxTn4.js';
+
+declare class BridgeService {
+    private readonly store;
+    constructor(store: BridgeStore);
+    publish(principalInput: BridgePrincipal, draftInput: MessageDraft): Promise<InsertMessageResult>;
+    history(principalInput: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
+    acknowledge(principalInput: BridgePrincipal, messageIds: string[]): Promise<number>;
+    claim(principalInput: BridgePrincipal, options?: {
+        leaseMs?: number;
+        maxAttempts?: number;
+    }): Promise<{
+        delivery: BridgeDelivery;
+        leaseToken: string;
+    } | null>;
+    extend(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs?: number): Promise<BridgeDelivery | null>;
+    ack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string): Promise<BridgeDelivery | null>;
+    nack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, error: string, dead?: boolean, retryPolicy?: Partial<RetryPolicy>): Promise<BridgeDelivery | null>;
+    heartbeat(principalInput: BridgePrincipal, options?: {
+        leaseMs?: number;
+        runtimeType?: string;
+        capabilities?: string[];
+    }): Promise<AgentPresence>;
+    presence(principalInput: BridgePrincipal): Promise<AgentPresence[]>;
+}
+
+export { BridgeService as B };

package/dist/bridge-store-BuGjxTn4.d.ts

@@ -0,0 +1,61 @@
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, D as DeliveryState, R as RetryPolicy, A as AgentPresence, a as BridgeDeliveryEvent } from './bridge-domain-BcnBeHOn.js';
+
+interface InsertMessageResult {
+    message: BridgeMessage;
+    created: boolean;
+}
+interface MessageQuery {
+    cursor?: string;
+    limit?: number;
+    types?: string[];
+    includeExpired?: boolean;
+    source?: string;
+    since?: string;
+    unacknowledgedBy?: string;
+    threadId?: string;
+    latest?: boolean;
+}
+interface MessagePage {
+    messages: BridgeMessage[];
+    cursor?: string;
+}
+interface BridgeDiagnostics {
+    schemaVersion: "local-v2" | "postgres-v2" | "legacy-v1";
+    deliverySupported: boolean;
+    pending: number | null;
+    claimed: number | null;
+    retrying: number | null;
+    dead: number | null;
+    oldestAvailableAt?: string;
+    principal?: {
+        workspace: string;
+        agent: string;
+    };
+}
+interface ClaimOptions {
+    leaseMs: number;
+    maxAttempts?: number;
+    now?: Date;
+}
+interface BridgeStore {
+    initialize(): Promise<void>;
+    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
+    recordReceipt(workspace: string, messageIds: string[], principal: string, readAt?: Date): Promise<number>;
+    recordLegacyReceipt?(legacyIds: string[], principal: string): Promise<number>;
+    claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    renewDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs: number): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, state: Extract<DeliveryState, "acked" | "retrying" | "dead">, error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    diagnostics?(principal: BridgePrincipal): Promise<BridgeDiagnostics>;
+    heartbeat?(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
+    listPresence?(principal: BridgePrincipal): Promise<AgentPresence[]>;
+    listDeliveryEvents?(deliveryId: string): Promise<BridgeDeliveryEvent[]>;
+    sync?(options?: {
+        maxPush?: number;
+        maxPages?: number;
+    }): Promise<unknown>;
+    verifyRemote?(): Promise<void>;
+    close?(): Promise<void>;
+}
+
+export type { BridgeDiagnostics as B, ClaimOptions as C, InsertMessageResult as I, MessagePage as M, BridgeStore as a, MessageQuery as b };

package/dist/bridge.d.ts

@@ -0,0 +1,102 @@
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-BcnBeHOn.js';
+export { a as BridgeDeliveryEvent, d as BridgeValidationError, D as DeliveryState, J as JsonValue, M as MessageDraft, e as MessagePriority, f as decodeCursor, g as encodeCursor, u as uuidv7, v as validateMessageDraft, h as validatePrincipal, i as validateRetryPolicy, j as validateUuid } from './bridge-domain-BcnBeHOn.js';
+import { a as BridgeStore, I as InsertMessageResult, b as MessageQuery, M as MessagePage, C as ClaimOptions, B as BridgeDiagnostics } from './bridge-store-BuGjxTn4.js';
+export { B as BridgeService } from './bridge-service-CfqMcMAn.js';
+import { P as PgQueryable } from './gateway-BULozv3K.js';
+export { A as AuthenticatedCredential, C as CredentialResolver, G as GatewayOptions, a as PostgresBridgeStore, b as PostgresCredentialResolver, c as bearerToken, d as createGateway, h as hashCredential, s as safeTokenHashEqual } from './gateway-BULozv3K.js';
+export { CachedMessagePage, EdgeConflictError, EdgeEnqueueResult, EdgeOutboxRecord, EdgeScope, EdgeStats, PendingMessage, SQLiteBridgeStore, SQLiteEdgeStore, SyncDiagnostics, SyncInsertResult, SyncReport, SyncingBridgeStore, SyncingBridgeStoreOptions, edgeMessageFingerprint, edgeScopeKey, isRetryableSyncError, stableIdempotency } from './sqlite.js';
+import 'node:http';
+
+declare class LegacySupabaseError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string);
+}
+declare class LegacySupabaseRestStore implements BridgeStore {
+    private readonly url;
+    private readonly key;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    private readonly legacyIds;
+    private initialized;
+    constructor(url: string, key: string, fetchImpl?: typeof fetch, timeoutMs?: number);
+    initialize(): Promise<void>;
+    private request;
+    insertMessage(input: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
+    recordReceipt(_workspace: string, ids: string[], principal: string): Promise<number>;
+    recordLegacyReceipt(ids: string[], principal: string): Promise<number>;
+    claimDelivery(_principal: BridgePrincipal, _options: ClaimOptions): Promise<BridgeDelivery | null>;
+    renewDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _leaseMs: number): Promise<BridgeDelivery | null>;
+    settleDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _state: "acked" | "retrying" | "dead", _error: string | undefined, _retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    diagnostics(_principal: BridgePrincipal): Promise<BridgeDiagnostics>;
+}
+
+interface HttpBridgeStoreOptions {
+    baseUrl: string;
+    token: string;
+    principal: BridgePrincipal;
+    timeoutMs?: number;
+    allowInsecureRemoteHttp?: boolean;
+    fetch?: typeof fetch;
+}
+declare class BridgeHttpError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string);
+}
+declare class HttpBridgeStore implements BridgeStore {
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(options: HttpBridgeStoreOptions);
+    initialize(): Promise<void>;
+    private assertBoundPrincipal;
+    private request;
+    private assertPrincipal;
+    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
+    recordReceipt(workspace: string, ids: string[], principal: string): Promise<number>;
+    diagnostics(principal: BridgePrincipal): Promise<BridgeDiagnostics>;
+    claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    renewDelivery(principal: BridgePrincipal, id: string, token: string, leaseMs: number): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    heartbeat(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
+    listPresence(principal: BridgePrincipal): Promise<AgentPresence[]>;
+}
+
+interface AppliedMigration {
+    version: number;
+    name: string;
+    checksum: string;
+}
+interface MigrationPlanEntry extends AppliedMigration {
+    source: string;
+}
+declare const REQUIRED_MIGRATIONS: readonly [{
+    readonly version: 1;
+    readonly name: "schema_state";
+}, {
+    readonly version: 2;
+    readonly name: "workspaces_agents_credentials";
+}, {
+    readonly version: 3;
+    readonly name: "messages_receipts_deliveries";
+}, {
+    readonly version: 4;
+    readonly name: "message_query_indexes";
+}, {
+    readonly version: 5;
+    readonly name: "delivery_events_presence";
+}, {
+    readonly version: 6;
+    readonly name: "legacy_shared_context_import";
+}, {
+    readonly version: 7;
+    readonly name: "runtime_role";
+}];
+declare function loadMigrationPlan(directory: string): Promise<MigrationPlanEntry[]>;
+declare function migrationsReady(db: PgQueryable, expected: ReadonlyArray<Pick<MigrationPlanEntry, "version" | "name" | "checksum">>): Promise<boolean>;
+declare function runtimeSchemaReady(db: PgQueryable): Promise<boolean>;
+declare function runMigrations(db: PgQueryable, directory: string): Promise<AppliedMigration[]>;
+
+export { AgentPresence, type AppliedMigration, BridgeDelivery, BridgeDiagnostics, BridgeHttpError, BridgeMessage, BridgePrincipal, BridgeStore, ClaimOptions, HttpBridgeStore, type HttpBridgeStoreOptions, InsertMessageResult, LegacySupabaseError, LegacySupabaseRestStore, MessagePage, MessageQuery, type MigrationPlanEntry, PgQueryable, REQUIRED_MIGRATIONS, RetryPolicy, loadMigrationPlan, migrationsReady, runMigrations, runtimeSchemaReady };

package/dist/bridge.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import {
+  PostgresBridgeStore
+} from "./chunk-O26W5QHS.js";
+import {
+  REQUIRED_MIGRATIONS,
+  loadMigrationPlan,
+  migrationsReady,
+  runMigrations,
+  runtimeSchemaReady
+} from "./chunk-6MAZ6YLZ.js";
+import {
+  PostgresCredentialResolver,
+  bearerToken,
+  createGateway,
+  hashCredential,
+  safeTokenHashEqual
+} from "./chunk-JOUBDRYX.js";
+import {
+  BridgeHttpError,
+  HttpBridgeStore,
+  LegacySupabaseError,
+  LegacySupabaseRestStore
+} from "./chunk-AXL2I7FH.js";
+import {
+  EdgeConflictError,
+  SQLiteBridgeStore,
+  SQLiteEdgeStore,
+  SyncingBridgeStore,
+  edgeMessageFingerprint,
+  edgeScopeKey,
+  isRetryableSyncError,
+  stableIdempotency
+} from "./chunk-WEULPMUY.js";
+import "./chunk-YD6YJATN.js";
+import {
+  BridgeService
+} from "./chunk-CKSKUBDQ.js";
+import {
+  BridgeValidationError,
+  decodeCursor,
+  encodeCursor,
+  uuidv7,
+  validateMessageDraft,
+  validatePrincipal,
+  validateRetryPolicy,
+  validateUuid
+} from "./chunk-BV6W4AJK.js";
+export {
+  BridgeHttpError,
+  BridgeService,
+  BridgeValidationError,
+  EdgeConflictError,
+  HttpBridgeStore,
+  LegacySupabaseError,
+  LegacySupabaseRestStore,
+  PostgresBridgeStore,
+  PostgresCredentialResolver,
+  REQUIRED_MIGRATIONS,
+  SQLiteBridgeStore,
+  SQLiteEdgeStore,
+  SyncingBridgeStore,
+  bearerToken,
+  createGateway,
+  decodeCursor,
+  edgeMessageFingerprint,
+  edgeScopeKey,
+  encodeCursor,
+  hashCredential,
+  isRetryableSyncError,
+  loadMigrationPlan,
+  migrationsReady,
+  runMigrations,
+  runtimeSchemaReady,
+  safeTokenHashEqual,
+  stableIdempotency,
+  uuidv7,
+  validateMessageDraft,
+  validatePrincipal,
+  validateRetryPolicy,
+  validateUuid
+};
+//# sourceMappingURL=bridge.js.map

package/dist/bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}