@hivemind-os/collective-daemon 0.2.0

package/dist/portal/server.d.ts

@@ -0,0 +1,72 @@
+import { AuthProvider, ZkLoginPendingSession, StoredZkLoginSession, OAuthConfig } from '@hivemind-os/collective-core';
+import { D as DaemonFullConfig } from '../config-SuloXL2_.js';
+import { D as DaemonAuthStatus } from '../session-monitor-P9hNAFw4.js';
+import { DaemonState } from '../state.js';
+import 'node:fs';
+import '@hivemind-os/collective-types';
+import '@mysten/sui/cryptography';
+import '@mysten/sui/keypairs/ed25519';
+
+interface PortalAuthProvider extends AuthProvider {
+    createAuthorizationRequest(params: {
+        redirectUri: string;
+        state: string;
+        codeChallenge: string;
+        scopes?: string[];
+    }): Promise<{
+        authorizationUrl: string;
+        pendingSession: ZkLoginPendingSession;
+    }>;
+    exchangeAuthorizationCode(code: string, codeVerifier: string, redirectUri: string): Promise<{
+        jwt: string;
+        refreshToken?: string;
+    }>;
+    authenticateWithJwt(jwt: string, params: {
+        pendingSession: ZkLoginPendingSession;
+        refreshToken?: string;
+    }): Promise<StoredZkLoginSession>;
+    getSession(): StoredZkLoginSession | null;
+    getOAuthConfig(): OAuthConfig;
+    setOAuthConfig(oauth: OAuthConfig): void;
+}
+interface PortalLogger {
+    info(bindings: Record<string, unknown>, message: string): void;
+    warn(bindings: Record<string, unknown>, message: string): void;
+}
+interface PortalServerOptions {
+    config: DaemonFullConfig;
+    configPath: string;
+    authProvider: PortalAuthProvider;
+    state?: DaemonState;
+    logger?: PortalLogger;
+    getAuthStatus?: () => DaemonAuthStatus | null;
+    onAuthenticated?: (session: StoredZkLoginSession) => Promise<void> | void;
+    onSettingsSaved?: (config: DaemonFullConfig) => Promise<void> | void;
+}
+declare class PortalServer {
+    private readonly options;
+    private readonly server;
+    private readonly pendingAuth;
+    private baseUrl;
+    private setupComplete;
+    private completionPromise;
+    private resolveCompletion;
+    constructor(options: PortalServerOptions);
+    start(): Promise<string>;
+    stop(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    getUrl(): string;
+    getReauthUrl(): string;
+    private registerRoutes;
+    private startAuthFlow;
+    private handleOAuthCallback;
+    private authenticateGoogleCallback;
+    private authenticateAppleCallback;
+    private pruneExpiredPendingAuth;
+    private setActiveOAuthConfig;
+    private getRedirectUri;
+    private getAuthStatus;
+    private renderPage;
+}
+
+export { type PortalAuthProvider, type PortalLogger, PortalServer, type PortalServerOptions };

package/dist/portal/server.js

@@ -0,0 +1,10 @@
+import {
+  PortalServer
+} from "../chunk-VHECO532.js";
+import "../chunk-CJHYQ7RR.js";
+import "../chunk-Q3V4V7UR.js";
+import "../chunk-NXIFS427.js";
+export {
+  PortalServer
+};
+//# sourceMappingURL=server.js.map

package/dist/portal/server.js.map

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

package/dist/provider/index.d.ts

@@ -0,0 +1,202 @@
+import { CreateMessageRequest, CreateMessageResult } from '@modelcontextprotocol/sdk/types.js';
+import { D as DaemonFullConfig } from '../config-SuloXL2_.js';
+import { RelayClientConfig, RelayClient } from '../relay/index.js';
+import { DaemonState } from '../state.js';
+import 'node:fs';
+import '@hivemind-os/collective-types';
+import '@hivemind-os/collective-core';
+import '@hivemind-os/collective-relay';
+import '@mysten/sui/cryptography';
+import '@mysten/sui/keypairs/ed25519';
+
+interface ExecutionAdapter {
+    readonly name: string;
+    execute(params: {
+        taskId: string;
+        capability: string;
+        inputData: Uint8Array;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        resultData: Uint8Array;
+        metadata?: Record<string, string>;
+    }>;
+}
+
+declare class EchoAdapter implements ExecutionAdapter {
+    readonly name = "echo";
+    execute(params: {
+        taskId: string;
+        capability: string;
+        inputData: Uint8Array;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        resultData: Uint8Array;
+        metadata?: Record<string, string>;
+    }>;
+}
+
+type LocalFunction = (input: Uint8Array, metadata?: Record<string, string>) => Promise<Uint8Array>;
+declare class LocalFunctionAdapter implements ExecutionAdapter {
+    private readonly fn;
+    readonly name = "local-function";
+    constructor(fn: LocalFunction);
+    execute(params: {
+        taskId: string;
+        capability: string;
+        inputData: Uint8Array;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        resultData: Uint8Array;
+        metadata?: Record<string, string>;
+    }>;
+}
+
+/**
+ * Narrow interface for MCP sampling. The provider runtime supplies an implementation
+ * that looks up the correct connected MCP client and sends the sampling request.
+ * This avoids exposing the full MCP Server to adapter code.
+ */
+type McpSamplingFn = (appName: string, params: CreateMessageRequest['params']) => Promise<CreateMessageResult>;
+interface McpSamplingAdapterConfig {
+    appName: string;
+    systemPrompt: string;
+    maxTokens?: number;
+    modelHint?: string;
+}
+declare class McpSamplingAdapter implements ExecutionAdapter {
+    private readonly sample;
+    readonly name = "mcp-sampling";
+    private readonly appName;
+    private readonly systemPrompt;
+    private readonly maxTokens;
+    private readonly modelHint;
+    constructor(config: McpSamplingAdapterConfig, sample: McpSamplingFn);
+    execute(params: {
+        taskId: string;
+        capability: string;
+        inputData: Uint8Array;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        resultData: Uint8Array;
+        metadata?: Record<string, string>;
+    }>;
+}
+
+interface SubprocessAdapterConfig {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+}
+declare class SubprocessAdapter implements ExecutionAdapter {
+    readonly name = "subprocess";
+    private readonly command;
+    private readonly args;
+    private readonly cwd;
+    private readonly env;
+    private readonly timeoutMs;
+    private readonly maxOutputBytes;
+    constructor(config: SubprocessAdapterConfig);
+    execute(params: {
+        taskId: string;
+        capability: string;
+        inputData: Uint8Array;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        resultData: Uint8Array;
+        metadata?: Record<string, string>;
+    }>;
+}
+
+interface WebhookAdapterConfig {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+}
+declare class WebhookAdapter implements ExecutionAdapter {
+    readonly name = "webhook";
+    private readonly url;
+    private readonly method;
+    private readonly headers;
+    private readonly timeoutMs;
+    private readonly maxResponseBytes;
+    constructor(config: WebhookAdapterConfig);
+    execute(params: {
+        taskId: string;
+        capability: string;
+        inputData: Uint8Array;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        resultData: Uint8Array;
+        metadata?: Record<string, string>;
+    }>;
+}
+
+interface ProviderCapabilityConfig {
+    name: string;
+    description: string;
+    version: string;
+    priceMist: number;
+    currency?: string;
+    adapter: string;
+    adapterConfig?: Record<string, unknown>;
+}
+interface ProviderConfig {
+    enabled: boolean;
+    capabilities: ProviderCapabilityConfig[];
+    maxConcurrency: number;
+    autoRegister: boolean;
+}
+declare function loadProviderConfig(config: DaemonFullConfig): ProviderConfig | null;
+
+declare class ProviderRuntime {
+    private readonly params;
+    private subscription?;
+    private cursorStore?;
+    private readonly taskQueue;
+    private readonly adapters;
+    private readonly capabilityConfigs;
+    private readonly relayClients;
+    private registeredCapabilities;
+    private chainOperations;
+    private ownAgentCardId?;
+    constructor(params: {
+        state: DaemonState;
+        providerConfig: ProviderConfig;
+        cursorDbPath: string;
+        relayConfig?: DaemonFullConfig['relay'];
+        relayClientFactory?: (config: RelayClientConfig, identity: DaemonState['relayAuthProvider']) => RelayClient;
+        mcpSamplingFn?: McpSamplingFn;
+        broadcastNotification?: (method: string, params?: unknown) => void;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private connectRelays;
+    private handleRawEvent;
+    private handleTaskPosted;
+    private processTask;
+    private executeLocalTask;
+    private runChainOperation;
+    private initializeAdapters;
+    private registerAgentCard;
+    private resolveOwnAgentCardId;
+    private get hasRelaySupport();
+    private get relayMetadata();
+    private get registrationEndpoint();
+}
+
+declare class TaskQueue {
+    private readonly maxConcurrency;
+    private readonly running;
+    constructor(maxConcurrency?: number);
+    enqueue(taskId: string, work: () => Promise<void>): Promise<boolean>;
+    get activeCount(): number;
+    get isFull(): boolean;
+    drain(): Promise<void>;
+}
+
+export { EchoAdapter, type ExecutionAdapter, type LocalFunction, LocalFunctionAdapter, McpSamplingAdapter, type McpSamplingAdapterConfig, type McpSamplingFn, type ProviderCapabilityConfig, type ProviderConfig, ProviderRuntime, SubprocessAdapter, type SubprocessAdapterConfig, TaskQueue, WebhookAdapter, type WebhookAdapterConfig, loadProviderConfig };

package/dist/provider/index.js

@@ -0,0 +1,22 @@
+import {
+  EchoAdapter,
+  LocalFunctionAdapter,
+  McpSamplingAdapter,
+  ProviderRuntime,
+  SubprocessAdapter,
+  TaskQueue,
+  WebhookAdapter,
+  loadProviderConfig
+} from "../chunk-57QD6553.js";
+import "../chunk-BJW47ZD5.js";
+export {
+  EchoAdapter,
+  LocalFunctionAdapter,
+  McpSamplingAdapter,
+  ProviderRuntime,
+  SubprocessAdapter,
+  TaskQueue,
+  WebhookAdapter,
+  loadProviderConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/provider/index.js.map

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

package/dist/relay/index.d.ts

@@ -0,0 +1,55 @@
+import { AuthProvider } from '@hivemind-os/collective-core';
+import { TaskRequest, TaskResponse } from '@hivemind-os/collective-relay';
+
+interface RelayClientConfig {
+    relayUrl: string;
+    relayDid?: string;
+    reconnectIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+}
+declare class RelayClient {
+    private readonly config;
+    private readonly identity;
+    private ws;
+    private reconnectTimer?;
+    private heartbeatTimer?;
+    private heartbeatAckTimer?;
+    private pendingConnection;
+    private taskHandler?;
+    private registeredCapabilities;
+    private reconnectAttempt;
+    private outboundSequence;
+    private inboundSequence;
+    private disconnecting;
+    private _sessionId;
+    constructor(config: RelayClientConfig, identity: AuthProvider);
+    get isConnected(): boolean;
+    get sessionId(): string | null;
+    connect(capabilities: string[]): Promise<void>;
+    disconnect(): Promise<void>;
+    onTaskRequest(handler: (request: TaskRequest) => Promise<TaskResponse>): void;
+    sendResult(taskId: string, result: unknown): Promise<void>;
+    sendProgress(taskId: string, progress: number, message?: string): Promise<void>;
+    sendChunk(taskId: string, data: string): Promise<void>;
+    sendError(taskId: string, error: {
+        code: string;
+        message: string;
+    }): Promise<void>;
+    private openConnection;
+    private authenticate;
+    private handleMessage;
+    private handleTaskRequest;
+    private sendTaskMessage;
+    private nextSequence;
+    private startHeartbeat;
+    private handleClose;
+    private scheduleReconnect;
+    private reconnect;
+    private resolvePendingConnection;
+    private rejectPendingConnection;
+    private clearReconnectTimer;
+    private clearHeartbeatAckTimer;
+    private clearHeartbeatTimers;
+}
+
+export { RelayClient, type RelayClientConfig };

package/dist/relay/index.js

@@ -0,0 +1,7 @@
+import {
+  RelayClient
+} from "../chunk-BJW47ZD5.js";
+export {
+  RelayClient
+};
+//# sourceMappingURL=index.js.map

package/dist/relay/index.js.map

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

package/dist/session-monitor-P9hNAFw4.d.ts

@@ -0,0 +1,16 @@
+import { AuthMode } from '@hivemind-os/collective-core';
+
+type DaemonAuthState = 'authenticated' | 'expiring' | 'expired' | 'reauth_required';
+interface DaemonAuthStatus {
+    authMode: AuthMode;
+    authenticated: boolean;
+    state: DaemonAuthState;
+    address: string | null;
+    expiresAt: number | null;
+    expiresInMs: number | null;
+    refreshAvailable: boolean;
+    lastError: string | null;
+    updatedAt: number;
+}
+
+export type { DaemonAuthStatus as D };

package/dist/state.d.ts

@@ -0,0 +1,59 @@
+import { AuthProvider, MeshSuiClient, RegistryClient, TaskClient, AgentCache, BlobStore, X25519KeyPair, SpendingPolicyEngine, EvmWallet, X402Client, OAuthProvider, OAuthConfig } from '@hivemind-os/collective-core';
+import { DID } from '@hivemind-os/collective-types';
+import { Signer } from '@mysten/sui/cryptography';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { D as DaemonFullConfig } from './config-SuloXL2_.js';
+import 'node:fs';
+
+interface DaemonStatusBase {
+    did: DID;
+    address: string;
+    evmAddress?: string;
+    uptime: number;
+    spendingToday: string;
+    providerRunning: boolean;
+    authMode: AuthProvider['mode'];
+    authenticated: boolean;
+}
+interface DaemonIdentityContext {
+    authProvider: AuthProvider;
+    did: DID;
+    identityKeypair: Ed25519Keypair;
+    identitySecretKey: Uint8Array;
+}
+declare class DaemonState {
+    readonly keypair: Signer;
+    readonly identityKeypair: Ed25519Keypair;
+    readonly authProvider: AuthProvider;
+    readonly relayAuthProvider: AuthProvider;
+    readonly did: DID;
+    readonly suiClient: MeshSuiClient;
+    readonly registryClient: RegistryClient;
+    readonly taskClient: TaskClient;
+    readonly agentCache: AgentCache;
+    readonly blobStore: BlobStore;
+    readonly encryptionKeyPair: X25519KeyPair;
+    readonly encryption: {
+        enabled: boolean;
+        requireEncryption: boolean;
+        publicKey?: string;
+    };
+    readonly spendingPolicy: SpendingPolicyEngine;
+    readonly evmWallet?: EvmWallet;
+    readonly x402Client?: X402Client;
+    readonly network: DaemonFullConfig['network'];
+    readonly startedAt: number;
+    readonly address: string;
+    private readonly cursorStore;
+    private readonly subscriptions;
+    private providerRunning;
+    private constructor();
+    static create(config: DaemonFullConfig, identityContext?: DaemonIdentityContext): Promise<DaemonState>;
+    setProviderRunning(providerRunning: boolean): void;
+    getStatusBase(): DaemonStatusBase;
+    shutdown(): Promise<void>;
+}
+declare function createDaemonIdentityContext(config: DaemonFullConfig): Promise<DaemonIdentityContext>;
+declare function buildOAuthConfig(config: DaemonFullConfig, redirectUri?: string, preferredProvider?: OAuthProvider): OAuthConfig;
+
+export { type DaemonIdentityContext, DaemonState, type DaemonStatusBase, buildOAuthConfig, createDaemonIdentityContext };

package/dist/state.js

@@ -0,0 +1,11 @@
+import {
+  DaemonState,
+  buildOAuthConfig,
+  createDaemonIdentityContext
+} from "./chunk-Q3V4V7UR.js";
+export {
+  DaemonState,
+  buildOAuthConfig,
+  createDaemonIdentityContext
+};
+//# sourceMappingURL=state.js.map

package/dist/state.js.map

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

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@hivemind-os/collective-daemon",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
+    },
+    "./state": {
+      "types": "./dist/state.d.ts",
+      "import": "./dist/state.js"
+    },
+    "./provider": {
+      "types": "./dist/provider/index.d.ts",
+      "import": "./dist/provider/index.js"
+    },
+    "./ipc/server": {
+      "types": "./dist/ipc/server.d.ts",
+      "import": "./dist/ipc/server.js"
+    },
+    "./portal/server": {
+      "types": "./dist/portal/server.d.ts",
+      "import": "./dist/portal/server.js"
+    },
+    "./relay": {
+      "types": "./dist/relay/index.d.ts",
+      "import": "./dist/relay/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "collective-daemon": "./dist/index.js"
+  },
+  "dependencies": {
+    "@fastify/cors": "^11.2.0",
+    "@fastify/static": "^9.1.3",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@mysten/sui": "^1.30.0",
+    "fastify": "^5.8.5",
+    "js-yaml": "^4.1.0",
+    "open": "^11.0.0",
+    "pino": "^9.0.0",
+    "pino-pretty": "^13.0.0",
+    "ws": "^8.0.0",
+    "@hivemind-os/collective-core": "0.2.0",
+    "@hivemind-os/collective-mcp-server": "0.2.0",
+    "@hivemind-os/collective-relay": "0.2.0",
+    "@hivemind-os/collective-types": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.0",
+    "@types/ws": "^8.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest",
+    "lint": "eslint src/ tests/ vitest.config.ts tsup.config.ts",
+    "start": "node dist/index.js"
+  }
+}