moltlaunch 2.0.0 → 2.0.1

package/worker/src/profiles.ts

@@ -1,85 +0,0 @@
-// Profile & Gig CRUD — KV-stored agent profiles and gig offerings
-
-import type { Env, AgentProfile, Gig } from './types';
-
-// --- Profile CRUD ---
-
-export async function getProfile(env: Env, agentId: string): Promise<AgentProfile | null> {
-  const raw = await env.TASKS_KV.get(`profile:${agentId}`);
-  if (!raw) return null;
-  return JSON.parse(raw) as AgentProfile;
-}
-
-export async function updateProfile(
-  env: Env,
-  agentId: string,
-  updates: Partial<Omit<AgentProfile, 'agentId' | 'updatedAt'>>,
-): Promise<AgentProfile> {
-  const existing = await getProfile(env, agentId);
-  const profile: AgentProfile = {
-    agentId,
-    ...(existing || {}),
-    ...updates,
-    updatedAt: Date.now(),
-  };
-  await env.TASKS_KV.put(`profile:${agentId}`, JSON.stringify(profile));
-  return profile;
-}
-
-// --- Gig CRUD ---
-
-export async function getGigs(env: Env, agentId: string): Promise<Gig[]> {
-  const raw = await env.TASKS_KV.get(`gigs:${agentId}`);
-  if (!raw) return [];
-  const gigs = JSON.parse(raw) as Gig[];
-  return gigs.filter((g) => g.active);
-}
-
-export async function getAllGigs(env: Env, agentId: string): Promise<Gig[]> {
-  const raw = await env.TASKS_KV.get(`gigs:${agentId}`);
-  if (!raw) return [];
-  return JSON.parse(raw) as Gig[];
-}
-
-export async function createGig(
-  env: Env,
-  agentId: string,
-  gig: Omit<Gig, 'id' | 'agentId' | 'active' | 'createdAt' | 'updatedAt'>,
-): Promise<Gig> {
-  const gigs = await getAllGigs(env, agentId);
-  const newGig: Gig = {
-    id: crypto.randomUUID(),
-    agentId,
-    ...gig,
-    active: true,
-    createdAt: Date.now(),
-    updatedAt: Date.now(),
-  };
-  gigs.push(newGig);
-  await env.TASKS_KV.put(`gigs:${agentId}`, JSON.stringify(gigs));
-  return newGig;
-}
-
-export async function updateGig(
-  env: Env,
-  agentId: string,
-  gigId: string,
-  updates: Partial<Pick<Gig, 'title' | 'description' | 'priceWei' | 'deliveryTime' | 'category' | 'active'>>,
-): Promise<Gig | null> {
-  const gigs = await getAllGigs(env, agentId);
-  const idx = gigs.findIndex((g) => g.id === gigId);
-  if (idx === -1) return null;
-  gigs[idx] = { ...gigs[idx], ...updates, updatedAt: Date.now() };
-  await env.TASKS_KV.put(`gigs:${agentId}`, JSON.stringify(gigs));
-  return gigs[idx];
-}
-
-export async function removeGig(env: Env, agentId: string, gigId: string): Promise<boolean> {
-  const gigs = await getAllGigs(env, agentId);
-  const idx = gigs.findIndex((g) => g.id === gigId);
-  if (idx === -1) return false;
-  gigs[idx].active = false;
-  gigs[idx].updatedAt = Date.now();
-  await env.TASKS_KV.put(`gigs:${agentId}`, JSON.stringify(gigs));
-  return true;
-}

package/worker/src/ratelimit.ts

@@ -1,45 +0,0 @@
-// IP-based rate limiting using KV sliding window counters
-// Separate limits for reads (GET) and writes (POST)
-
-import type { Env } from './types';
-
-const READ_LIMIT = 60;  // per minute
-const WRITE_LIMIT = 20; // per minute
-const WINDOW_SECONDS = 60;
-
-interface RateLimitResult {
-  allowed: boolean;
-  remaining: number;
-  resetAt: number;
-}
-
-/** Check rate limit for an IP + method combination */
-export async function checkRateLimit(
-  env: Env,
-  ip: string,
-  method: string,
-): Promise<RateLimitResult> {
-  const isWrite = method === 'POST' || method === 'PUT' || method === 'DELETE';
-  const limit = isWrite ? WRITE_LIMIT : READ_LIMIT;
-  const bucket = isWrite ? 'w' : 'r';
-
-  // Key: ratelimit:<ip>:<bucket>:<window>
-  const now = Math.floor(Date.now() / 1000);
-  const window = Math.floor(now / WINDOW_SECONDS);
-  const key = `ratelimit:${ip}:${bucket}:${window}`;
-  const resetAt = (window + 1) * WINDOW_SECONDS;
-
-  const raw = await env.TASKS_KV.get(key);
-  const count = raw ? parseInt(raw, 10) : 0;
-
-  if (count >= limit) {
-    return { allowed: false, remaining: 0, resetAt };
-  }
-
-  // Increment counter with TTL matching window expiry
-  await env.TASKS_KV.put(key, String(count + 1), {
-    expirationTtl: WINDOW_SECONDS * 2,
-  });
-
-  return { allowed: true, remaining: limit - count - 1, resetAt };
-}

package/worker/src/tasks.ts

@@ -1,498 +0,0 @@
-// MANDATE Task Queue
-// Quote-based flow: request → quote → accept → submit → complete
-
-import type { Env, Task, TaskFile, TaskMessage, AgentStats } from './types';
-
-const TASK_PREFIX = 'task:';
-const AGENT_INBOX_PREFIX = 'inbox:';
-const CLIENT_TASKS_PREFIX = 'client:';
-const RECENT_TASKS_KEY = 'recent:tasks';
-const STATS_PREFIX = 'stats:';
-const RECENT_TASKS_MAX = 200;
-const TASK_TTL = 60 * 60 * 24 * 7; // 7 days
-
-interface RecentTaskEntry {
-  id: string;
-  agentId: string;
-  status: Task['status'];
-  createdAt: number;
-  updatedAt: number;
-}
-
-/** Update the global recent tasks index */
-async function updateRecentIndex(env: Env, task: Task): Promise<void> {
-  const raw = await env.TASKS_KV.get(RECENT_TASKS_KEY);
-  const entries: RecentTaskEntry[] = raw ? JSON.parse(raw) : [];
-
-  const existing = entries.findIndex((e) => e.id === task.id);
-  const entry: RecentTaskEntry = {
-    id: task.id,
-    agentId: task.agentId,
-    status: task.status,
-    createdAt: task.createdAt,
-    updatedAt: Date.now(),
-  };
-
-  if (existing >= 0) {
-    entries.splice(existing, 1);
-  }
-  entries.unshift(entry);
-  const trimmed = entries.slice(0, RECENT_TASKS_MAX);
-
-  await env.TASKS_KV.put(RECENT_TASKS_KEY, JSON.stringify(trimmed), { expirationTtl: TASK_TTL });
-}
-
-/** Generate a unique task ID */
-function generateTaskId(): string {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).slice(2, 8);
-  return `${timestamp}-${random}`;
-}
-
-/** Get a task by ID */
-export async function getTask(env: Env, taskId: string): Promise<Task | null> {
-  const data = await env.TASKS_KV.get(`${TASK_PREFIX}${taskId}`);
-  if (!data) return null;
-  return JSON.parse(data) as Task;
-}
-
-/** Save a task */
-async function saveTask(env: Env, task: Task): Promise<void> {
-  await env.TASKS_KV.put(
-    `${TASK_PREFIX}${task.id}`,
-    JSON.stringify(task),
-    { expirationTtl: TASK_TTL }
-  );
-}
-
-/** Add task ID to an agent's inbox */
-async function addToInbox(env: Env, agentId: string, taskId: string): Promise<void> {
-  const key = `${AGENT_INBOX_PREFIX}${agentId}`;
-  const existing = await env.TASKS_KV.get(key);
-  const inbox: string[] = existing ? JSON.parse(existing) : [];
-
-  inbox.unshift(taskId);
-  const trimmed = inbox.slice(0, 100);
-
-  await env.TASKS_KV.put(key, JSON.stringify(trimmed), { expirationTtl: TASK_TTL });
-}
-
-/** Add task ID to a client's task list */
-async function addToClientTasks(env: Env, clientAddress: string, taskId: string): Promise<void> {
-  const key = `${CLIENT_TASKS_PREFIX}${clientAddress.toLowerCase()}`;
-  const existing = await env.TASKS_KV.get(key);
-  const tasks: string[] = existing ? JSON.parse(existing) : [];
-
-  tasks.unshift(taskId);
-  const trimmed = tasks.slice(0, 100);
-
-  await env.TASKS_KV.put(key, JSON.stringify(trimmed), { expirationTtl: TASK_TTL });
-}
-
-/** Get agent stats from KV */
-export async function getAgentStats(env: Env, agentId: string): Promise<AgentStats> {
-  const raw = await env.TASKS_KV.get(`${STATS_PREFIX}${agentId}`);
-  if (raw) {
-    const stats = JSON.parse(raw) as AgentStats;
-    // Backfill for stats created before rating fields existed
-    if (stats.ratingSum === undefined) stats.ratingSum = 0;
-    if (stats.ratingCount === undefined) stats.ratingCount = 0;
-    return stats;
-  }
-  return {
-    completedTasks: 0,
-    totalEarningsWei: '0',
-    declinedTasks: 0,
-    totalResponseMs: 0,
-    taskCount: 0,
-    ratingSum: 0,
-    ratingCount: 0,
-  };
-}
-
-/** Save agent stats to KV */
-async function saveAgentStats(env: Env, agentId: string, stats: AgentStats): Promise<void> {
-  await env.TASKS_KV.put(`${STATS_PREFIX}${agentId}`, JSON.stringify(stats));
-}
-
-/** Create a new task request (no price - agent will quote) */
-export async function createTask(
-  env: Env,
-  agentId: string,
-  clientAddress: string,
-  taskDescription: string,
-): Promise<Task> {
-  const task: Task = {
-    id: generateTaskId(),
-    agentId,
-    clientAddress: clientAddress.toLowerCase(),
-    task: taskDescription,
-    status: 'requested',
-    createdAt: Date.now(),
-  };
-
-  await saveTask(env, task);
-  await addToInbox(env, agentId, task.id);
-  await addToClientTasks(env, clientAddress, task.id);
-  await updateRecentIndex(env, task);
-
-  // Update stats: increment task count
-  const stats = await getAgentStats(env, agentId);
-  stats.taskCount++;
-  await saveAgentStats(env, agentId, stats);
-
-  return task;
-}
-
-/** Get tasks for an agent (requests + accepted work) */
-export async function getAgentInbox(env: Env, agentId: string): Promise<Task[]> {
-  const key = `${AGENT_INBOX_PREFIX}${agentId}`;
-  const inboxData = await env.TASKS_KV.get(key);
-  if (!inboxData) return [];
-
-  const taskIds: string[] = JSON.parse(inboxData);
-  const tasks: Task[] = [];
-
-  for (const id of taskIds) {
-    const task = await getTask(env, id);
-    if (task && ['requested', 'quoted', 'accepted', 'revision', 'submitted', 'disputed'].includes(task.status)) {
-      tasks.push(task);
-    }
-  }
-
-  return tasks;
-}
-
-/** Get all tasks for an agent (full history) */
-export async function getAgentTasks(env: Env, agentId: string): Promise<Task[]> {
-  const key = `${AGENT_INBOX_PREFIX}${agentId}`;
-  const inboxData = await env.TASKS_KV.get(key);
-  if (!inboxData) return [];
-
-  const taskIds: string[] = JSON.parse(inboxData);
-  const tasks: Task[] = [];
-
-  for (const id of taskIds) {
-    const task = await getTask(env, id);
-    if (task) tasks.push(task);
-  }
-
-  // Sort by most recent first
-  return tasks.sort((a, b) => (b.completedAt || b.createdAt) - (a.completedAt || a.createdAt));
-}
-
-/** Get all tasks for a client */
-export async function getClientTasks(env: Env, clientAddress: string): Promise<Task[]> {
-  const key = `${CLIENT_TASKS_PREFIX}${clientAddress.toLowerCase()}`;
-  const tasksData = await env.TASKS_KV.get(key);
-  if (!tasksData) return [];
-
-  const taskIds: string[] = JSON.parse(tasksData);
-  const tasks: Task[] = [];
-
-  for (const id of taskIds) {
-    const task = await getTask(env, id);
-    if (task) tasks.push(task);
-  }
-
-  return tasks;
-}
-
-/** Agent quotes a price for a task */
-export async function quoteTask(
-  env: Env,
-  taskId: string,
-  priceWei: string,
-  message?: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'requested' && task.status !== 'quoted') return { error: `Task is ${task.status}, cannot quote` };
-
-  task.status = 'quoted';
-  task.quotedPriceWei = priceWei;
-  task.quotedAt = Date.now();
-  if (message) task.quotedMessage = message;
-
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-
-  // Update stats: track response time
-  const stats = await getAgentStats(env, task.agentId);
-  stats.totalResponseMs += (task.quotedAt - task.createdAt);
-  await saveAgentStats(env, task.agentId, stats);
-
-  return task;
-}
-
-/** Agent declines a task */
-export async function declineTask(
-  env: Env,
-  taskId: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (!['requested', 'quoted'].includes(task.status)) {
-    return { error: `Task is ${task.status}, cannot decline` };
-  }
-
-  task.status = 'declined';
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-
-  // Update stats: increment declined count
-  const stats = await getAgentStats(env, task.agentId);
-  stats.declinedTasks++;
-  await saveAgentStats(env, task.agentId, stats);
-
-  return task;
-}
-
-/** Client accepts a quote (agent starts work) */
-export async function acceptQuote(
-  env: Env,
-  taskId: string,
-  clientAddress: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'quoted') return { error: `Task is ${task.status}, cannot accept` };
-  if (task.clientAddress.toLowerCase() !== clientAddress.toLowerCase()) {
-    return { error: 'Only the client can accept the quote' };
-  }
-
-  task.status = 'accepted';
-  task.acceptedAt = Date.now();
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-  return task;
-}
-
-/** Agent submits work result (from accepted or revision) */
-export async function submitTask(
-  env: Env,
-  taskId: string,
-  result: string,
-  files?: TaskFile[],
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'accepted' && task.status !== 'revision') {
-    return { error: `Task is ${task.status}, cannot submit` };
-  }
-
-  task.status = 'submitted';
-  task.submittedAt = Date.now();
-  task.result = result;
-  if (files && files.length > 0) {
-    task.files = files;
-  }
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-  return task;
-}
-
-/** Append a file to a task's files array in KV */
-export async function addFileToTask(
-  env: Env,
-  taskId: string,
-  file: TaskFile,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-
-  if (!task.files) task.files = [];
-  task.files.push(file);
-  await saveTask(env, task);
-  return task;
-}
-
-/** Get recent tasks across all agents */
-export async function getRecentTasks(env: Env, limit = 10): Promise<{ tasks: Task[]; total: number }> {
-  const raw = await env.TASKS_KV.get(RECENT_TASKS_KEY);
-  if (!raw) return { tasks: [], total: 0 };
-
-  const entries: RecentTaskEntry[] = JSON.parse(raw);
-  const sliced = entries.slice(0, Math.min(limit, RECENT_TASKS_MAX));
-
-  const tasks: Task[] = [];
-  for (const entry of sliced) {
-    const task = await getTask(env, entry.id);
-    if (task) tasks.push(task);
-  }
-
-  return { tasks, total: entries.length };
-}
-
-/** Mark task as rated (after on-chain feedback) */
-export async function rateTask(
-  env: Env,
-  taskId: string,
-  txHash: string,
-  score?: number,
-  comment?: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'completed') return { error: `Task is ${task.status}, cannot rate` };
-  if (task.ratedAt) return { error: 'Task already rated' };
-
-  task.ratedAt = Date.now();
-  task.ratedTxHash = txHash;
-  if (score !== undefined) task.ratedScore = score;
-  if (comment) task.ratedComment = comment;
-  await saveTask(env, task);
-
-  // Update verified reputation stats
-  if (score !== undefined) {
-    const stats = await getAgentStats(env, task.agentId);
-    stats.ratingSum = (stats.ratingSum || 0) + score;
-    stats.ratingCount = (stats.ratingCount || 0) + 1;
-    await saveAgentStats(env, task.agentId, stats);
-  }
-
-  return task;
-}
-
-/** Client requests revision — moves task from submitted back for rework */
-export async function requestRevision(
-  env: Env,
-  taskId: string,
-  reason: string,
-  senderAddress: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'submitted') return { error: `Task is ${task.status}, cannot request revision` };
-
-  task.status = 'revision';
-  task.revisionCount = (task.revisionCount || 0) + 1;
-
-  // Add revision reason as a message
-  if (!task.messages) task.messages = [];
-  task.messages.push({
-    sender: senderAddress.toLowerCase(),
-    role: 'client',
-    content: reason,
-    timestamp: Date.now(),
-  });
-
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-  return task;
-}
-
-/** Add a message to a task (either party, task must be active) */
-export async function addMessage(
-  env: Env,
-  taskId: string,
-  senderAddress: string,
-  role: 'client' | 'agent',
-  content: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-
-  const terminalStatuses = ['completed', 'declined', 'expired', 'resolved'];
-  if (terminalStatuses.includes(task.status)) {
-    return { error: `Task is ${task.status}, cannot send messages` };
-  }
-
-  if (!task.messages) task.messages = [];
-  task.messages.push({
-    sender: senderAddress.toLowerCase(),
-    role,
-    content,
-    timestamp: Date.now(),
-  });
-
-  await saveTask(env, task);
-  return task;
-}
-
-/** Client disputes submitted work — freezes timeout */
-export async function disputeTask(
-  env: Env,
-  taskId: string,
-  txHash: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'submitted') return { error: `Task is ${task.status}, cannot dispute` };
-
-  task.status = 'disputed';
-  task.disputedAt = Date.now();
-  task.disputeTxHash = txHash;
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-  return task;
-}
-
-/** Admin resolves a dispute */
-export async function resolveTask(
-  env: Env,
-  taskId: string,
-  resolution: 'client' | 'agent',
-  txHash: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'disputed') return { error: `Task is ${task.status}, cannot resolve` };
-
-  task.status = 'resolved';
-  task.resolvedAt = Date.now();
-  task.resolveTxHash = txHash;
-  task.disputeResolution = resolution;
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-  return task;
-}
-
-/** Mark task as refunded (client cancelled before agent submitted) */
-export async function refundTask(
-  env: Env,
-  taskId: string,
-  txHash: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (!['quoted', 'accepted'].includes(task.status)) {
-    return { error: `Task is ${task.status}, cannot refund` };
-  }
-
-  task.status = 'expired';
-  task.completedAt = Date.now();
-  task.txHash = txHash;
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-  return task;
-}
-
-/** Mark task as completed (after payment) */
-export async function completeTask(
-  env: Env,
-  taskId: string,
-  txHash: string,
-): Promise<Task | { error: string }> {
-  const task = await getTask(env, taskId);
-  if (!task) return { error: 'Task not found' };
-  if (task.status !== 'submitted') return { error: `Task is ${task.status}, cannot complete` };
-
-  task.status = 'completed';
-  task.completedAt = Date.now();
-  task.txHash = txHash;
-  await saveTask(env, task);
-  await updateRecentIndex(env, task);
-
-  // Update stats: increment completed, add earnings
-  const stats = await getAgentStats(env, task.agentId);
-  stats.completedTasks++;
-  if (task.quotedPriceWei) {
-    const current = BigInt(stats.totalEarningsWei || '0');
-    const added = BigInt(task.quotedPriceWei);
-    stats.totalEarningsWei = (current + added).toString();
-  }
-  await saveAgentStats(env, task.agentId, stats);
-
-  return task;
-}