@noosphere/agent-core 0.1.0-alpha.0 → 0.1.0-alpha.10

package/README.md

@@ -0,0 +1,143 @@
+# @noosphere/agent-core
+
+Core modules for building Noosphere compute agents.
+
+## Installation
+
+```bash
+npm install @noosphere/agent-core
+```
+
+For alpha version:
+```bash
+npm install @noosphere/agent-core@alpha
+```
+
+## Components
+
+### NoosphereAgent
+
+Main agent class that orchestrates compute request handling.
+
+```typescript
+import { NoosphereAgent } from '@noosphere/agent-core';
+
+const agent = new NoosphereAgent({
+  rpcUrl: 'https://sepolia.hpp.io',
+  wsUrl: 'wss://sepolia.hpp.io',
+  routerAddress: '0x89c76ee71E9cC8D57BEE3d414478B630AE41fF43',
+  coordinatorAddress: '0x244D87a7CAe0D557C223C13a90Ae845e56430A50',
+  keystore,
+  containers: [
+    {
+      containerId: 'hello-world',
+      imageName: 'noosphere/hello-world:latest',
+    },
+  ],
+});
+
+// Event handlers
+agent.on('requestStarted', (event) => {
+  console.log('Request started:', event.requestId);
+});
+
+agent.on('computeDelivered', (event) => {
+  console.log('Compute delivered:', event.requestId);
+});
+
+// Start agent
+await agent.start();
+```
+
+### EventMonitor
+
+WebSocket-based blockchain event monitor with automatic reconnection.
+
+```typescript
+import { EventMonitor } from '@noosphere/agent-core';
+
+const monitor = new EventMonitor(
+  {
+    rpcUrl: 'https://sepolia.hpp.io',
+    wsUrl: 'wss://sepolia.hpp.io',
+    routerAddress: '0x89c76ee71E9cC8D57BEE3d414478B630AE41fF43',
+    coordinatorAddress: '0x244D87a7CAe0D557C223C13a90Ae845e56430A50',
+  },
+  routerAbi,
+  coordinatorAbi,
+  { enableHeartbeat: true }
+);
+
+monitor.on('RequestStarted', (event) => {
+  console.log('New request:', event);
+});
+
+await monitor.start();
+```
+
+### ContainerManager
+
+Docker container lifecycle management.
+
+```typescript
+import { ContainerManager } from '@noosphere/agent-core';
+
+const manager = new ContainerManager();
+
+// Run container
+const result = await manager.runContainer({
+  imageName: 'noosphere/hello-world:latest',
+  input: { message: 'Hello' },
+  timeout: 30000,
+});
+
+console.log('Output:', result.output);
+```
+
+### SchedulerService
+
+Subscription scheduling and interval management.
+
+```typescript
+import { SchedulerService } from '@noosphere/agent-core';
+
+const scheduler = new SchedulerService(
+  coordinatorContract,
+  walletManager,
+  { intervalCheckMs: 60000 }
+);
+
+scheduler.on('intervalPrepared', (event) => {
+  console.log('Interval prepared:', event);
+});
+
+await scheduler.start(subscriptions);
+```
+
+## Re-exports
+
+For convenience, this package re-exports from other Noosphere packages:
+
+```typescript
+// From @noosphere/crypto
+import { KeystoreManager, WalletManager } from '@noosphere/agent-core';
+
+// From @noosphere/registry
+import { RegistryManager } from '@noosphere/agent-core';
+```
+
+## Types
+
+```typescript
+import type {
+  NoosphereAgentConfig,
+  ContainerConfig,
+  CheckpointData,
+  ComputeDeliveredEvent,
+  RequestStartedCallbackEvent,
+} from '@noosphere/agent-core';
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -308,7 +308,8 @@ var ContainerManager = class {
     const startTime = Date.now();
     try {
       const port = container.port ? parseInt(container.port) : 8081;
-      const url = `http://localhost:${port}/computation`;
+      const containerHost = process.env.DOCKER_NETWORK ? `noosphere-${container.name}` : "localhost";
+      const url = `http://${containerHost}:${port}/computation`;
       let requestBody;
       try {
         const parsedInput = JSON.parse(input);
@@ -494,14 +495,19 @@ var ContainerManager = class {
     console.log(`
 \u{1F680} Preparing ${containers.size} containers...`);
     const pullAndStartPromises = Array.from(containers.entries()).map(async ([id, container]) => {
+      const imageTag = `${container.image}:${container.tag || "latest"}`;
       try {
-        const imageTag = `${container.image}:${container.tag || "latest"}`;
         console.log(`  Pulling ${imageTag}...`);
         await this.pullImage(container.image, container.tag || "latest");
         console.log(`  \u2713 ${imageTag} ready`);
+      } catch (error) {
+        console.error(`  \u274C Failed to pull ${imageTag}:`, error.message);
+        return;
+      }
+      try {
         await this.startPersistentContainer(id, container);
       } catch (error) {
-        console.error(`  \u274C Failed to prepare ${container.image}:`, error.message);
+        console.error(`  \u274C Failed to start ${container.name || container.image}:`, error.message);
       }
     });
     await Promise.all(pullAndStartPromises);
@@ -511,26 +517,29 @@ var ContainerManager = class {
    * Start a persistent container that stays running
    */
   async startPersistentContainer(containerId, metadata) {
-    const containerName = `noosphere-${containerId}`;
+    const containerName = `noosphere-${metadata.name}`;
     const imageTag = `${metadata.image}:${metadata.tag || "latest"}`;
+    const existingContainer = this.docker.getContainer(containerName);
     try {
-      const existingContainer = this.docker.getContainer(containerName);
-      try {
-        const inspect = await existingContainer.inspect();
-        if (inspect.State.Running) {
-          console.log(`  \u2713 Container ${containerName} already running`);
-          this.persistentContainers.set(containerId, existingContainer);
-          return;
-        } else {
+      const inspect = await existingContainer.inspect();
+      if (inspect.State.Running) {
+        console.log(`  \u2713 Container ${containerName} already running`);
+        this.persistentContainers.set(containerId, existingContainer);
+        return;
+      } else {
+        try {
           await existingContainer.start();
           console.log(`  \u2713 Started existing container ${containerName}`);
           this.persistentContainers.set(containerId, existingContainer);
           return;
+        } catch (startErr) {
+          console.log(`  Removing stopped container ${containerName} to recreate...`);
+          await existingContainer.remove({ force: true });
         }
-      } catch (err) {
       }
     } catch (err) {
     }
+    const dockerNetwork = process.env.DOCKER_NETWORK;
     const createOptions = {
       name: containerName,
       Image: imageTag,
@@ -541,9 +550,12 @@ var ContainerManager = class {
       HostConfig: {
         AutoRemove: false,
         // Keep container for reuse
-        PortBindings: metadata.port ? {
+        // Only bind ports to host when not using Docker network (local dev)
+        PortBindings: metadata.port && !dockerNetwork ? {
           [`${metadata.port}/tcp`]: [{ HostPort: metadata.port }]
-        } : void 0
+        } : void 0,
+        // Join the specified Docker network for DinD communication
+        NetworkMode: dockerNetwork || void 0
       },
       Env: metadata.env ? Object.entries(metadata.env).map(([k, v]) => `${k}=${v}`) : void 0
     };
@@ -1615,8 +1627,30 @@ var NoosphereAgent = class _NoosphereAgent {
       verified: registryContainer.verified
     };
   }
+  /**
+   * Get container metadata from available sources
+   * Returns undefined if container is not supported by this agent
+   *
+   * NOTE: Only checks config-defined sources (callback and containers map).
+   * Registry is NOT used here - we only process containers explicitly configured.
+   */
+  getContainerMetadata(containerId) {
+    if (this.getContainer) {
+      const container = this.getContainer(containerId);
+      if (container) return container;
+    }
+    if (this.containers) {
+      const container = this.containers.get(containerId);
+      if (container) return container;
+    }
+    return void 0;
+  }
   async handleRequest(event) {
     const requestIdShort = event.requestId.slice(0, 10);
+    const container = this.getContainerMetadata(event.containerId);
+    if (!container) {
+      return;
+    }
     if (this.processingRequests.has(event.requestId)) {
       console.log(`  \u23ED\uFE0F  Request ${requestIdShort}... already being processed, skipping duplicate`);
       return;
@@ -1631,6 +1665,7 @@ var NoosphereAgent = class _NoosphereAgent {
     console.log(`  SubscriptionId: ${event.subscriptionId}`);
     console.log(`  Interval: ${event.interval}`);
     console.log(`  ContainerId: ${event.containerId.slice(0, 10)}...`);
+    console.log(`  \u{1F4E6} Container: ${container.name} (${container.image}:${container.tag || "latest"})`);
     if (this.options.onRequestStarted) {
       this.options.onRequestStarted({
         requestId: event.requestId,
@@ -1661,6 +1696,7 @@ var NoosphereAgent = class _NoosphereAgent {
       console.warn(`  Could not verify interval currency:`, error.message);
     }
     this.scheduler.markIntervalCommitted(BigInt(event.subscriptionId), BigInt(event.interval));
+    let sentTxHash;
     try {
       await this.waitForPriority(event);
       if (this.options.onRequestProcessing) {
@@ -1675,37 +1711,6 @@ var NoosphereAgent = class _NoosphereAgent {
         this.processingRequests.delete(event.requestId);
         return;
       }
-      let container;
-      if (this.getContainer) {
-        container = this.getContainer(event.containerId);
-        if (container) {
-          console.log(`  \u{1F4E6} Container found via callback: ${container.name}`);
-        }
-      }
-      if (!container) {
-        const registryContainer = this.registryManager.getContainer(event.containerId);
-        if (registryContainer) {
-          console.log(`  \u{1F4CB} Container found in registry: ${registryContainer.name}`);
-          container = this.convertRegistryContainer(registryContainer);
-        }
-      }
-      if (!container && this.containers) {
-        container = this.containers.get(event.containerId);
-        if (container) {
-          console.log(`  \u{1F4E6} Container found in config: ${container.name}`);
-        }
-      }
-      if (!container) {
-        console.error(`  \u274C Container not found: ${event.containerId}`);
-        console.error(`  \u{1F4A1} Try adding it to the registry or config file`);
-        if (this.options.onRequestSkipped) {
-          this.options.onRequestSkipped(event.requestId, `Container not found: ${event.containerId}`);
-        }
-        return;
-      }
-      console.log(
-        `  \u{1F4E6} Using container: ${container.name} (${container.image}:${container.tag || "latest"})`
-      );
       const subscription = await this.router.getComputeSubscription(event.subscriptionId);
       const clientAddress = subscription.client;
       if (!clientAddress || clientAddress === "0x0000000000000000000000000000000000000000") {
@@ -1773,6 +1778,7 @@ var NoosphereAgent = class _NoosphereAgent {
         commitmentData,
         nodeWallet
       );
+      sentTxHash = tx.hash;
       console.log(`  \u{1F4E4} Transaction sent: ${tx.hash}`);
       const receipt = await tx.wait();
       if (receipt.status === 1) {
@@ -1807,7 +1813,7 @@ var NoosphereAgent = class _NoosphereAgent {
       }
       console.error(`  \u274C Error processing request:`, error);
       if (this.options.onRequestFailed) {
-        this.options.onRequestFailed(event.requestId, errorMessage);
+        this.options.onRequestFailed(event.requestId, errorMessage, sentTxHash);
       }
     } finally {
       this.processingRequests.delete(event.requestId);