@stacknet/stacks 0.1.2 → 0.2.2

package/src/managers/task-manager.ts

@@ -1,310 +0,0 @@
-/**
- * TaskManager - Redis-backed task state management
- *
- * Manages task lifecycle for long-running operations with real-time updates
- */
-
-import type { TaskType, TaskStatus, TaskState } from '../types';
-import { TASK_PREFIX, CHAT_TASKS_PREFIX, TASK_TTL } from '../utils/constants';
-import { generateUUID } from '../utils/helpers';
-
-// Redis client type - we use a generic interface to avoid hard dependency
-export interface RedisClientLike {
-  hSet(key: string, value: Record<string, string>): Promise<number>;
-  hGetAll(key: string): Promise<Record<string, string>>;
-  expire(key: string, seconds: number): Promise<boolean>;
-  sAdd(key: string, ...members: string[]): Promise<number>;
-  sMembers(key: string): Promise<string[]>;
-  sRem(key: string, ...members: string[]): Promise<number>;
-  del(key: string): Promise<number>;
-  publish(channel: string, message: string): Promise<number>;
-  subscribe(channel: string, callback: (message: string) => void): Promise<void>;
-  unsubscribe(channel: string): Promise<void>;
-}
-
-export interface TaskManagerConfig {
-  redis?: RedisClientLike;
-  getRedisClient?: () => Promise<RedisClientLike>;
-  taskTTL?: number;
-}
-
-export class TaskManager {
-  private redis?: RedisClientLike;
-  private getRedisClient?: () => Promise<RedisClientLike>;
-  private taskTTL: number;
-
-  constructor(config: TaskManagerConfig = {}) {
-    this.redis = config.redis;
-    this.getRedisClient = config.getRedisClient;
-    this.taskTTL = config.taskTTL || TASK_TTL;
-  }
-
-  /**
-   * Get Redis client (lazily initialized)
-   */
-  private async getClient(): Promise<RedisClientLike> {
-    if (this.redis) return this.redis;
-    if (this.getRedisClient) {
-      this.redis = await this.getRedisClient();
-      return this.redis;
-    }
-    throw new Error('Redis client not configured. Provide redis or getRedisClient in config.');
-  }
-
-  /**
-   * Create a new task and return its ID
-   */
-  async createTask(
-    chatId: string,
-    messageId: string,
-    type: TaskType,
-    initialMessage: string = 'Starting...'
-  ): Promise<string> {
-    const redis = await this.getClient();
-    const taskId = generateUUID();
-    const now = Date.now();
-
-    const task: TaskState = {
-      id: taskId,
-      chatId,
-      messageId,
-      type,
-      status: 'pending',
-      progress: 0,
-      message: initialMessage,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    await redis.hSet(`${TASK_PREFIX}${taskId}`, this.taskToRedis(task));
-    await redis.expire(`${TASK_PREFIX}${taskId}`, this.taskTTL);
-
-    await redis.sAdd(`${CHAT_TASKS_PREFIX}${chatId}`, taskId);
-    await redis.expire(`${CHAT_TASKS_PREFIX}${chatId}`, this.taskTTL);
-
-    console.log(`[TaskManager] Created task ${taskId} for chat ${chatId} (${type})`);
-
-    return taskId;
-  }
-
-  /**
-   * Update task progress
-   */
-  async updateProgress(
-    taskId: string,
-    progress: number,
-    message: string
-  ): Promise<void> {
-    const redis = await this.getClient();
-
-    await redis.hSet(`${TASK_PREFIX}${taskId}`, {
-      status: 'generating',
-      progress: progress.toString(),
-      message,
-      updatedAt: Date.now().toString(),
-    });
-
-    await redis.publish(
-      `task:progress:${taskId}`,
-      JSON.stringify({
-        taskId,
-        progress,
-        message,
-        status: 'generating',
-      })
-    );
-
-    console.log(`[TaskManager] Task ${taskId} progress: ${progress}% - ${message}`);
-  }
-
-  /**
-   * Mark task as complete with result
-   */
-  async complete(taskId: string, result: unknown): Promise<void> {
-    const redis = await this.getClient();
-
-    await redis.hSet(`${TASK_PREFIX}${taskId}`, {
-      status: 'complete',
-      progress: '100',
-      message: 'Complete',
-      result: JSON.stringify(result),
-      updatedAt: Date.now().toString(),
-    });
-
-    await redis.publish(
-      `task:progress:${taskId}`,
-      JSON.stringify({
-        taskId,
-        progress: 100,
-        message: 'Complete',
-        status: 'complete',
-        result,
-      })
-    );
-
-    console.log(`[TaskManager] Task ${taskId} completed`);
-  }
-
-  /**
-   * Mark task as failed
-   */
-  async fail(taskId: string, error: string): Promise<void> {
-    const redis = await this.getClient();
-
-    await redis.hSet(`${TASK_PREFIX}${taskId}`, {
-      status: 'failed',
-      message: error,
-      error,
-      updatedAt: Date.now().toString(),
-    });
-
-    await redis.publish(
-      `task:progress:${taskId}`,
-      JSON.stringify({
-        taskId,
-        status: 'failed',
-        error,
-      })
-    );
-
-    console.log(`[TaskManager] Task ${taskId} failed: ${error}`);
-  }
-
-  /**
-   * Get task by ID
-   */
-  async getTask(taskId: string): Promise<TaskState | null> {
-    const redis = await this.getClient();
-    const data = await redis.hGetAll(`${TASK_PREFIX}${taskId}`);
-
-    if (!data || Object.keys(data).length === 0) {
-      return null;
-    }
-
-    return this.redisToTask(data);
-  }
-
-  /**
-   * Get all tasks for a chat
-   */
-  async getTasksForChat(chatId: string): Promise<TaskState[]> {
-    const redis = await this.getClient();
-    const taskIds = await redis.sMembers(`${CHAT_TASKS_PREFIX}${chatId}`);
-
-    if (!taskIds || taskIds.length === 0) {
-      return [];
-    }
-
-    const tasks: TaskState[] = [];
-    for (const taskId of taskIds) {
-      const task = await this.getTask(taskId);
-      if (task) {
-        tasks.push(task);
-      }
-    }
-
-    return tasks.sort((a, b) => b.createdAt - a.createdAt);
-  }
-
-  /**
-   * Get pending/generating tasks for a chat
-   */
-  async getPendingTasksForChat(chatId: string): Promise<TaskState[]> {
-    const tasks = await this.getTasksForChat(chatId);
-    return tasks.filter((t) => t.status === 'pending' || t.status === 'generating');
-  }
-
-  /**
-   * Delete a task
-   */
-  async deleteTask(taskId: string): Promise<void> {
-    const redis = await this.getClient();
-    const task = await this.getTask(taskId);
-
-    if (task) {
-      await redis.del(`${TASK_PREFIX}${taskId}`);
-      await redis.sRem(`${CHAT_TASKS_PREFIX}${task.chatId}`, taskId);
-      console.log(`[TaskManager] Deleted task ${taskId}`);
-    }
-  }
-
-  /**
-   * Clean up old completed/failed tasks for a chat
-   */
-  async cleanupOldTasks(chatId: string, maxAge: number = 86400000): Promise<void> {
-    const tasks = await this.getTasksForChat(chatId);
-    const now = Date.now();
-
-    for (const task of tasks) {
-      if (
-        (task.status === 'complete' || task.status === 'failed') &&
-        now - task.updatedAt > maxAge
-      ) {
-        await this.deleteTask(task.id);
-      }
-    }
-  }
-
-  /**
-   * Subscribe to task progress updates
-   */
-  async subscribeToTask(
-    taskId: string,
-    callback: (update: { taskId: string; status: TaskStatus; progress?: number; message?: string; result?: unknown; error?: string }) => void
-  ): Promise<() => Promise<void>> {
-    const redis = await this.getClient();
-    const channel = `task:progress:${taskId}`;
-
-    await redis.subscribe(channel, (message) => {
-      try {
-        const data = JSON.parse(message);
-        callback(data);
-      } catch {
-        // Ignore parse errors
-      }
-    });
-
-    return async () => {
-      await redis.unsubscribe(channel);
-    };
-  }
-
-  private taskToRedis(task: TaskState): Record<string, string> {
-    return {
-      id: task.id,
-      chatId: task.chatId,
-      messageId: task.messageId,
-      type: task.type,
-      status: task.status,
-      progress: task.progress.toString(),
-      message: task.message,
-      result: task.result || '',
-      error: task.error || '',
-      createdAt: task.createdAt.toString(),
-      updatedAt: task.updatedAt.toString(),
-    };
-  }
-
-  private redisToTask(data: Record<string, string>): TaskState {
-    return {
-      id: data.id,
-      chatId: data.chatId,
-      messageId: data.messageId,
-      type: data.type as TaskType,
-      status: data.status as TaskStatus,
-      progress: parseInt(data.progress, 10),
-      message: data.message,
-      result: data.result || undefined,
-      error: data.error || undefined,
-      createdAt: parseInt(data.createdAt, 10),
-      updatedAt: parseInt(data.updatedAt, 10),
-    };
-  }
-}
-
-/**
- * Factory function to create a TaskManager
- */
-export function createTaskManager(config?: TaskManagerConfig): TaskManager {
-  return new TaskManager(config);
-}

package/src/proxy/forwarder.ts

@@ -1,146 +0,0 @@
-/**
- * Generic request forwarding utilities
- */
-
-import { DEFAULT_TASK_NETWORK_URL } from '../utils/constants';
-
-export interface ForwarderConfig {
-  baseUrl?: string;
-  defaultHeaders?: Record<string, string>;
-  timeout?: number;
-}
-
-export interface RequestOptions {
-  method?: string;
-  headers?: Record<string, string>;
-  body?: unknown;
-  searchParams?: Record<string, string | undefined>;
-  stream?: boolean;
-}
-
-/**
- * Forward a request to a backend URL
- */
-export async function forwardRequest(
-  path: string,
-  options: RequestOptions = {},
-  config: ForwarderConfig = {}
-): Promise<Response> {
-  const baseUrl = config.baseUrl || DEFAULT_TASK_NETWORK_URL;
-  const { method = 'GET', headers = {}, body, searchParams, stream } = options;
-
-  // Build URL with search params
-  let url = `${baseUrl}${path}`;
-  if (searchParams) {
-    const params = new URLSearchParams();
-    Object.entries(searchParams).forEach(([key, value]) => {
-      if (value !== undefined) {
-        params.set(key, value);
-      }
-    });
-    const paramString = params.toString();
-    if (paramString) {
-      url += `?${paramString}`;
-    }
-  }
-
-  const fetchOptions: RequestInit = {
-    method,
-    headers: {
-      ...config.defaultHeaders,
-      ...headers,
-    },
-  };
-
-  if (body && method !== 'GET') {
-    fetchOptions.headers = {
-      ...fetchOptions.headers,
-      'Content-Type': 'application/json',
-    };
-    fetchOptions.body = JSON.stringify(body);
-  }
-
-  const response = await fetch(url, fetchOptions);
-
-  // For streaming responses, return directly
-  if (stream && response.body) {
-    return response;
-  }
-
-  return response;
-}
-
-/**
- * Forward and return JSON response
- */
-export async function forwardJSON<T = unknown>(
-  path: string,
-  options: RequestOptions = {},
-  config: ForwarderConfig = {}
-): Promise<{ data: T; status: number }> {
-  const response = await forwardRequest(path, options, config);
-  const data = await response.json();
-  return { data, status: response.status };
-}
-
-/**
- * Create a proxy handler that forwards requests
- */
-export function createProxyHandler(
-  path: string | ((req: Request) => string),
-  config: ForwarderConfig = {}
-) {
-  return async (request: Request): Promise<Response> => {
-    const url = new URL(request.url);
-    const targetPath = typeof path === 'function' ? path(request) : path;
-
-    // Forward search params
-    const searchParams: Record<string, string> = {};
-    url.searchParams.forEach((value, key) => {
-      searchParams[key] = value;
-    });
-
-    let body: unknown = undefined;
-    if (request.method !== 'GET' && request.method !== 'HEAD') {
-      try {
-        body = await request.json();
-      } catch {
-        // No body or not JSON
-      }
-    }
-
-    // Extract headers
-    const requestHeaders: Record<string, string> = {};
-    request.headers.forEach((value, key) => {
-      requestHeaders[key] = value;
-    });
-
-    const response = await forwardRequest(
-      targetPath,
-      {
-        method: request.method,
-        headers: requestHeaders,
-        body,
-        searchParams,
-      },
-      config
-    );
-
-    // Check if streaming response
-    const contentType = response.headers.get('content-type') || '';
-    if (contentType.includes('text/event-stream')) {
-      return new Response(response.body, {
-        status: response.status,
-        headers: {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          'Connection': 'keep-alive',
-        },
-      });
-    }
-
-    // Return JSON response
-    const data = await response.json();
-    return Response.json(data, { status: response.status });
-  };
-}

package/src/proxy/index.ts

@@ -1,32 +0,0 @@
-/**
- * @stacknet/stacks - Proxy utilities
- */
-
-export {
-  forwardRequest,
-  forwardJSON,
-  createProxyHandler,
-  type ForwarderConfig,
-  type RequestOptions,
-} from './forwarder';
-
-export {
-  createAgentRoutes,
-  createAgentDetailRoutes,
-  createAgentExecuteRoute,
-  createAgentToggleRoutes,
-  createSkillRoutes,
-  createSkillDetailRoutes,
-  createWidgetRoutes,
-  createWidgetDetailRoutes,
-  createImaginationRoutes,
-  // Stack management routes
-  createStackRoutes,
-  createStackDetailRoutes,
-  createStackKeysRoutes,
-  createStackMembersRoutes,
-  type RouteHandlerConfig,
-  type StackRouteHandlerConfig,
-  type RouteHandler,
-  type CRUDRouteHandlers,
-} from './route-handlers';