@stacknet/stacks 0.1.2 → 0.2.2

package/src/clients/files.ts

@@ -1,86 +0,0 @@
-/**
- * Files Client
- * Client for file upload operations
- */
-
-import { DEFAULT_TASK_NETWORK_URL } from '../utils/constants';
-import { StacksSDKError } from '../utils/errors';
-import type {
-  FileUploadResponse,
-  FilesClientConfig,
-} from '../types/file';
-
-export type { FilesClientConfig } from '../types/file';
-
-export class FilesClient {
-  private baseUrl: string;
-
-  constructor(config: FilesClientConfig = {}) {
-    this.baseUrl = config.baseUrl || DEFAULT_TASK_NETWORK_URL;
-  }
-
-  private get filesUrl(): string {
-    return `${this.baseUrl}/files`;
-  }
-
-  /**
-   * Upload a file
-   */
-  async upload(file: File | Blob, filename?: string): Promise<FileUploadResponse> {
-    const formData = new FormData();
-    formData.append('file', file, filename);
-
-    const response = await fetch(`${this.filesUrl}/upload`, {
-      method: 'POST',
-      body: formData,
-    });
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to upload file: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Upload a file from URL
-   */
-  async uploadFromUrl(url: string): Promise<FileUploadResponse> {
-    const response = await fetch(`${this.filesUrl}/upload-url`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ url }),
-    });
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to upload file from URL: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Get file URL by CID
-   */
-  getFileUrl(cid: string): string {
-    return `${this.filesUrl}/${cid}`;
-  }
-}
-
-/**
- * Create a FilesClient instance
- */
-export function createFilesClient(config: FilesClientConfig = {}): FilesClient {
-  return new FilesClient(config);
-}
-
-/**
- * Default files client instance
- */
-export const filesClient = createFilesClient();

package/src/clients/index.ts

@@ -1,93 +0,0 @@
-/**
- * @stacknet/stacks - Clients
- */
-
-export {
-  TaskNetworkClient,
-  createTaskNetworkClient,
-  taskNetworkClient,
-  type TaskNetworkConfig,
-} from './task-network';
-
-export {
-  MagmaClient,
-  createMagmaClient,
-  magmaClient,
-  type MagmaClientConfig,
-} from './magma';
-
-export {
-  MCPClient,
-  createMCPClient,
-  mcpClient,
-} from './mcp';
-
-export {
-  SocialClient,
-  createSocialClient,
-  socialClient,
-  type SocialClientConfig,
-} from './social';
-
-export {
-  AgentsClient,
-  createAgentsClient,
-  agentsClient,
-  type AgentsClientConfig,
-} from './agents';
-
-export {
-  WidgetsClient,
-  createWidgetsClient,
-  widgetsClient,
-  type WidgetsClientConfig,
-} from './widgets';
-
-export {
-  UserClient,
-  createUserClient,
-  userClient,
-  type UserClientConfig,
-} from './user';
-
-export {
-  FilesClient,
-  createFilesClient,
-  filesClient,
-  type FilesClientConfig,
-} from './files';
-
-export {
-  SkillsClient,
-  createSkillsClient,
-  skillsClient,
-  type SkillsClientConfig,
-} from './skills';
-
-export {
-  PointsClient,
-  createPointsClient,
-  pointsClient,
-  type PointsClientConfig,
-} from './points';
-
-export {
-  StackManagementClient,
-  createStackManagementClient,
-  stackManagementClient,
-  type StackManagementClientConfig,
-} from './stack-management';
-
-export {
-  NetworkClient,
-  createNetworkClient,
-  networkClient,
-  type NetworkClientConfig,
-} from './network';
-
-export {
-  BillingClient,
-  createBillingClient,
-  billingClient,
-  type BillingClientConfig,
-} from './billing';

package/src/clients/magma.ts

@@ -1,299 +0,0 @@
-/**
- * MagmaClient - File storage and imagination management
- *
- * Interfaces with the MetaChain P2P network for distributed file storage
- */
-
-import type { MagmaFile, ImaginationMetadata, WorkflowData } from '../types';
-import { DEFAULT_MAGMA_RPC_URL, DEFAULT_TASK_NETWORK_URL } from '../utils/constants';
-import { generateCID } from '../utils/helpers';
-
-export interface MagmaClientConfig {
-  baseUrl?: string;
-  localServerUrl?: string;
-}
-
-export class MagmaClient {
-  private baseUrl: string;
-  private localServerUrl: string;
-
-  constructor(config: MagmaClientConfig = {}) {
-    this.baseUrl = config.baseUrl || DEFAULT_MAGMA_RPC_URL;
-    this.localServerUrl = config.localServerUrl || DEFAULT_TASK_NETWORK_URL;
-  }
-
-  /**
-   * Upload a file and get its CID
-   */
-  async uploadFile(file: File): Promise<MagmaFile> {
-    const arrayBuffer = await file.arrayBuffer();
-    const cid = await generateCID(arrayBuffer);
-
-    // Convert to base64 for storage
-    const base64Data = this.arrayBufferToBase64(arrayBuffer);
-
-    // Store in localStorage (browser) or return for server storage
-    if (typeof localStorage !== 'undefined') {
-      localStorage.setItem(
-        `file:${cid}`,
-        JSON.stringify({
-          cid,
-          name: file.name,
-          type: file.type,
-          size: file.size,
-          data: base64Data,
-        })
-      );
-    }
-
-    return {
-      cid,
-      name: file.name,
-      size: file.size,
-      type: file.type,
-      url: `data:${file.type};base64,${base64Data}`,
-    };
-  }
-
-  /**
-   * Upload text content and get its CID
-   */
-  async uploadText(text: string, name: string): Promise<MagmaFile> {
-    const blob = new Blob([text], { type: 'text/plain' });
-    const file = new File([blob], name, { type: 'text/plain' });
-    return this.uploadFile(file);
-  }
-
-  /**
-   * Store imagination metadata in P2P network
-   */
-  async storeImagination(
-    imagination: ImaginationMetadata & { is_public?: boolean }
-  ): Promise<string> {
-    const creatorMid = imagination.createdBy || 'anonymous';
-
-    // Check if imagination already exists
-    const existingResponse = await fetch(
-      `${this.localServerUrl}/imaginations/${imagination.id}`
-    );
-    const isUpdate = existingResponse.ok;
-
-    const payload = {
-      id: imagination.id,
-      title: imagination.title,
-      sources: imagination.sources,
-      summary: imagination.summary,
-      character: imagination.character,
-      workflow: imagination.workflow,
-      is_public: imagination.is_public || false,
-      creator_mid: creatorMid,
-    };
-
-    if (isUpdate) {
-      const response = await fetch(
-        `${this.localServerUrl}/imaginations/${imagination.id}`,
-        {
-          method: 'PUT',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(payload),
-        }
-      );
-
-      if (!response.ok) {
-        throw new Error(`Failed to update imagination: ${response.statusText}`);
-      }
-
-      // Cache locally
-      if (typeof localStorage !== 'undefined') {
-        localStorage.setItem(`imagination:${imagination.id}`, imagination.id);
-      }
-
-      return imagination.id;
-    } else {
-      const response = await fetch(`${this.localServerUrl}/imaginations`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
-      });
-
-      if (!response.ok) {
-        throw new Error(`Failed to store imagination: ${response.statusText}`);
-      }
-
-      const result = await response.json();
-      const id = result.imagination?.id || imagination.id;
-
-      // Cache locally
-      if (typeof localStorage !== 'undefined') {
-        localStorage.setItem(`imagination:${id}`, id);
-      }
-
-      return id;
-    }
-  }
-
-  /**
-   * Retrieve imagination from P2P network by ID
-   */
-  async getImagination(id: string): Promise<ImaginationMetadata | null> {
-    try {
-      const response = await fetch(`${this.localServerUrl}/imaginations/${id}`);
-      if (!response.ok) {
-        return null;
-      }
-
-      const result = await response.json();
-      if (!result.imagination) {
-        return null;
-      }
-
-      return {
-        id: result.imagination.id,
-        title: result.imagination.title,
-        createdAt: new Date(result.imagination.created_at).toISOString(),
-        createdBy: result.imagination.creator_mid,
-        sources: result.imagination.sources,
-        summary: result.imagination.summary,
-        character: result.imagination.character,
-        workflow: result.imagination.workflow,
-        is_public: result.imagination.is_public,
-      };
-    } catch (error) {
-      console.error('Failed to retrieve imagination:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Get imagination by CID
-   */
-  async getImaginationByCID(cid: string): Promise<ImaginationMetadata | null> {
-    try {
-      const response = await fetch(`${this.baseUrl}/files/${cid}`);
-      if (!response.ok) {
-        return null;
-      }
-
-      const imagination: ImaginationMetadata = await response.json();
-
-      // Cache locally
-      if (typeof localStorage !== 'undefined') {
-        localStorage.setItem(`imagination:${imagination.id}`, cid);
-      }
-
-      return imagination;
-    } catch (error) {
-      console.error('Failed to retrieve imagination by CID:', error);
-      return null;
-    }
-  }
-
-  /**
-   * List all imaginations for a user
-   */
-  async listImaginations(creatorMid?: string): Promise<ImaginationMetadata[]> {
-    try {
-      const userMid = creatorMid || 'anonymous';
-      const response = await fetch(
-        `${this.localServerUrl}/imaginations?creator_mid=${encodeURIComponent(userMid)}`
-      );
-
-      if (!response.ok) {
-        console.warn('Failed to fetch imaginations from P2P, falling back to localStorage');
-        return this.listImaginationsFromLocalStorage();
-      }
-
-      const result = await response.json();
-
-      const imaginations: ImaginationMetadata[] = result.imaginations.map(
-        (img: Record<string, unknown>) => ({
-          id: img.id as string,
-          title: img.title as string,
-          createdAt: new Date(img.created_at as string).toISOString(),
-          createdBy: img.creator_mid as string,
-          sources: img.sources as ImaginationMetadata['sources'],
-          summary: img.summary as string | undefined,
-          character: img.character as ImaginationMetadata['character'],
-          workflow: img.workflow as WorkflowData | undefined,
-          is_public: img.is_public as boolean | undefined,
-        })
-      );
-
-      // Cache locally
-      if (typeof localStorage !== 'undefined') {
-        imaginations.forEach((img) => {
-          localStorage.setItem(`imagination:${img.id}`, img.id);
-        });
-      }
-
-      return imaginations;
-    } catch (error) {
-      console.error('Failed to list imaginations:', error);
-      return this.listImaginationsFromLocalStorage();
-    }
-  }
-
-  /**
-   * Fallback method to list imaginations from localStorage
-   */
-  private async listImaginationsFromLocalStorage(): Promise<ImaginationMetadata[]> {
-    if (typeof localStorage === 'undefined') {
-      return [];
-    }
-
-    const imaginations: ImaginationMetadata[] = [];
-
-    for (let i = 0; i < localStorage.length; i++) {
-      const key = localStorage.key(i);
-      if (key && key.startsWith('imagination:')) {
-        const id = key.replace('imagination:', '');
-        const imagination = await this.getImagination(id);
-        if (imagination) {
-          imaginations.push(imagination);
-        }
-      }
-    }
-
-    return imaginations;
-  }
-
-  /**
-   * Retrieve file from Magma network
-   */
-  async getFile(cid: string): Promise<Blob | null> {
-    try {
-      const response = await fetch(`${this.baseUrl}/files/${cid}`);
-      if (!response.ok) {
-        return null;
-      }
-      return await response.blob();
-    } catch (error) {
-      console.error('Failed to retrieve file:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Helper to convert ArrayBuffer to base64
-   */
-  private arrayBufferToBase64(buffer: ArrayBuffer): string {
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
-    for (let i = 0; i < bytes.length; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-}
-
-/**
- * Factory function to create a client
- */
-export function createMagmaClient(config?: MagmaClientConfig): MagmaClient {
-  return new MagmaClient(config);
-}
-
-/**
- * Default singleton instance
- */
-export const magmaClient = createMagmaClient();

package/src/clients/mcp.ts

@@ -1,208 +0,0 @@
-/**
- * MCPClient - Model Context Protocol client
- *
- * Simple MCP client for communicating with magmanode MCP services
- */
-
-import type { MCPSession, MCPSessionConfig, MCPToolResult } from '../types';
-
-export class MCPClient {
-  private baseUrl: string;
-  private timeout: number;
-  private sessions: Map<string, MCPSession> = new Map();
-
-  constructor(config: MCPSessionConfig = {}) {
-    this.baseUrl = config.baseUrl || 'http://localhost:3006';
-    this.timeout = config.timeout || 30000;
-  }
-
-  /**
-   * Create a new MCP session
-   */
-  async createSession(agentId: string = 'default'): Promise<MCPSession> {
-    const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
-    try {
-      const session: MCPSession = {
-        id: sessionId,
-        agentId,
-        status: 'active',
-        createdAt: new Date(),
-      };
-
-      this.sessions.set(sessionId, session);
-
-      // Try to create session on server
-      try {
-        await fetch(`${this.baseUrl}/mcp/sessions`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            sessionId,
-            agentId,
-            clientInfo: {
-              name: 'stacknet-sdk',
-              version: '0.1.0',
-            },
-          }),
-        });
-      } catch {
-        // Server may not be available, continue with local session
-      }
-
-      return session;
-    } catch (error) {
-      throw new Error(`Failed to create MCP session: ${error}`);
-    }
-  }
-
-  /**
-   * Get session by ID
-   */
-  getSession(sessionId: string): MCPSession | undefined {
-    return this.sessions.get(sessionId);
-  }
-
-  /**
-   * Close a session
-   */
-  async closeSession(sessionId: string): Promise<void> {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.status = 'closed';
-
-      try {
-        await fetch(`${this.baseUrl}/mcp/sessions/${sessionId}`, {
-          method: 'DELETE',
-        });
-      } catch {
-        // Ignore errors on close
-      }
-
-      this.sessions.delete(sessionId);
-    }
-  }
-
-  /**
-   * Send a message to an MCP session
-   */
-  async sendMessage(sessionId: string, message: string): Promise<unknown> {
-    const session = this.sessions.get(sessionId);
-    if (!session || session.status !== 'active') {
-      throw new Error('Invalid or inactive session');
-    }
-
-    try {
-      const response = await fetch(
-        `${this.baseUrl}/mcp/sessions/${sessionId}/messages`,
-        {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            messages: [
-              {
-                role: 'user',
-                content: { type: 'text', text: message },
-              },
-            ],
-          }),
-        }
-      );
-
-      if (!response.ok) {
-        throw new Error(`MCP request failed: ${response.statusText}`);
-      }
-
-      return response.json();
-    } catch (error) {
-      throw new Error(`Failed to send message: ${error}`);
-    }
-  }
-
-  /**
-   * Call an MCP tool
-   */
-  async callTool(
-    sessionId: string,
-    toolName: string,
-    args: Record<string, unknown> = {}
-  ): Promise<MCPToolResult> {
-    const session = this.sessions.get(sessionId);
-    if (!session || session.status !== 'active') {
-      throw new Error('Invalid or inactive session');
-    }
-
-    try {
-      const response = await fetch(
-        `${this.baseUrl}/mcp/sessions/${sessionId}/tools/${toolName}`,
-        {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(args),
-        }
-      );
-
-      if (!response.ok) {
-        throw new Error(`Tool call failed: ${response.statusText}`);
-      }
-
-      return response.json();
-    } catch (error) {
-      throw new Error(`Failed to call tool: ${error}`);
-    }
-  }
-
-  /**
-   * List available tools for a session
-   */
-  async listTools(sessionId: string): Promise<string[]> {
-    const session = this.sessions.get(sessionId);
-    if (!session || session.status !== 'active') {
-      throw new Error('Invalid or inactive session');
-    }
-
-    try {
-      const response = await fetch(
-        `${this.baseUrl}/mcp/sessions/${sessionId}/tools`
-      );
-
-      if (!response.ok) {
-        return [];
-      }
-
-      const data = await response.json();
-      return data.tools || [];
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Get all active sessions
-   */
-  getActiveSessions(): MCPSession[] {
-    return Array.from(this.sessions.values()).filter(
-      (s) => s.status === 'active'
-    );
-  }
-
-  /**
-   * Close all sessions
-   */
-  async closeAllSessions(): Promise<void> {
-    const sessions = Array.from(this.sessions.keys());
-    await Promise.all(sessions.map((id) => this.closeSession(id)));
-  }
-}
-
-/**
- * Factory function to create a client
- */
-export function createMCPClient(config?: MCPSessionConfig): MCPClient {
-  return new MCPClient(config);
-}
-
-/**
- * Default singleton instance
- */
-export const mcpClient = createMCPClient();