cowork-os 0.3.21 → 0.3.25

package/resources/skills/scripts/generate_image.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Simple image generator wrapper (OpenAI Images API, stdlib only)."""
+
+import argparse
+import base64
+import datetime
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+OPENAI_URL = "https://api.openai.com/v1/images/generations"
+
+SIZE_MAP = {
+    "1K": "1024x1024",
+    "2K": "1536x1024",
+    "4K": "1536x1024",
+}
+
+
+def _require_api_key() -> str:
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        print("ERROR: OPENAI_API_KEY is not set", file=sys.stderr)
+        sys.exit(2)
+    return api_key
+
+
+def _post_json(payload: dict) -> dict:
+    api_key = _require_api_key()
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        OPENAI_URL,
+        data=data,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req) as resp:
+            return json.load(resp)
+    except urllib.error.HTTPError as err:
+        body = err.read().decode("utf-8", "ignore")
+        print(f"OpenAI API error: {err.code} {err.reason}\n{body}", file=sys.stderr)
+        sys.exit(3)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate a single image")
+    parser.add_argument("--prompt", required=True)
+    parser.add_argument("--filename", required=True)
+    parser.add_argument("--resolution", default="1K")
+    parser.add_argument("-i", dest="inputs", action="append", default=[])
+    args = parser.parse_args()
+
+    if args.inputs:
+        print("WARNING: edit/composition inputs are not supported in this build; ignoring -i", file=sys.stderr)
+
+    size = SIZE_MAP.get(args.resolution.upper(), "1024x1024")
+
+    payload = {
+        "model": "gpt-image-1",
+        "prompt": args.prompt,
+        "n": 1,
+        "size": size,
+        "response_format": "b64_json",
+        "quality": "high",
+    }
+
+    result = _post_json(payload)
+    data = result.get("data", [])
+    if not data or not data[0].get("b64_json"):
+        print("ERROR: No image data returned", file=sys.stderr)
+        sys.exit(4)
+
+    out_path = Path(args.filename).expanduser()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(out_path, "wb") as f:
+        f.write(base64.b64decode(data[0]["b64_json"]))
+
+    print(f"MEDIA: {out_path}")
+    print(f"Image saved as: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

package/src/electron/agent/custom-skill-loader.ts

@@ -390,7 +390,7 @@ export class CustomSkillLoader {
     skill: CustomSkill,
     parameterValues: Record<string, string | number | boolean>
   ): string {
-    let prompt = skill.prompt;
+    let prompt = this.expandBaseDir(skill.prompt, skill);
 
     // Replace {{param}} placeholders with values
     if (skill.parameters) {
@@ -407,6 +407,39 @@ export class CustomSkillLoader {
     return prompt.trim();
   }
 
+  /**
+   * Expand {baseDir} placeholders to the resolved skill base directory.
+   */
+  expandBaseDir(prompt: string, skill: CustomSkill): string {
+    if (!prompt.includes('{baseDir}')) {
+      return prompt;
+    }
+    const baseDir = this.resolveBaseDir(skill);
+    return prompt.replace(/\{baseDir\}/g, baseDir);
+  }
+
+  private resolveBaseDir(skill: CustomSkill): string {
+    const fileDir = skill.filePath ? path.dirname(skill.filePath) : this.bundledSkillsDir;
+    const candidates = [
+      fileDir,
+      this.bundledSkillsDir,
+      this.managedSkillsDir,
+      this.workspaceSkillsDir || '',
+    ].filter(Boolean) as string[];
+
+    for (const dir of candidates) {
+      try {
+        if (fs.existsSync(path.join(dir, 'scripts'))) {
+          return dir;
+        }
+      } catch {
+        // ignore and continue
+      }
+    }
+
+    return fileDir;
+  }
+
   /**
    * Get eligible skills (those that meet all requirements)
    */

package/src/electron/agent/daemon.ts

@@ -12,7 +12,10 @@ import {
   MemoryType,
 } from '../database/repositories';
 import { ActivityRepository } from '../activity/ActivityRepository';
-import { Task, TaskStatus, IPC_CHANNELS, QueueSettings, QueueStatus, Workspace, WorkspacePermissions, AgentConfig, AgentType, ActivityActorType, ActivityType, CreateActivityRequest } from '../../shared/types';
+import { AgentRoleRepository } from '../agents/AgentRoleRepository';
+import { MentionRepository } from '../agents/MentionRepository';
+import { buildAgentDispatchPrompt } from '../agents/agent-dispatch';
+import { Task, TaskStatus, IPC_CHANNELS, QueueSettings, QueueStatus, Workspace, WorkspacePermissions, AgentConfig, AgentType, ActivityActorType, ActivityType, CreateActivityRequest, Plan, BoardColumn, Activity, AgentMention } from '../../shared/types';
 import { TaskExecutor } from './executor';
 import { TaskQueueManager } from './queue-manager';
 import { approvalIdempotency, taskIdempotency, IdempotencyManager } from '../security/concurrency';
@@ -43,12 +46,18 @@ export class AgentDaemon extends EventEmitter {
   private approvalRepo: ApprovalRepository;
   private artifactRepo: ArtifactRepository;
   private activityRepo: ActivityRepository;
+  private agentRoleRepo: AgentRoleRepository;
+  private mentionRepo: MentionRepository;
   private activeTasks: Map<string, CachedExecutor> = new Map();
   private pendingApprovals: Map<string, { taskId: string; resolve: (value: boolean) => void; reject: (reason?: unknown) => void; resolved: boolean; timeoutHandle: ReturnType<typeof setTimeout> }> = new Map();
   private cleanupIntervalHandle?: ReturnType<typeof setInterval>;
   private queueManager: TaskQueueManager;
   // Activity throttle: Map<taskId:eventType, lastTimestamp>
   private activityThrottle: Map<string, number> = new Map();
+  private pendingRetries: Map<string, ReturnType<typeof setTimeout>> = new Map();
+  private retryCounts: Map<string, number> = new Map();
+  private readonly maxTaskRetries = 2;
+  private readonly retryDelayMs = 30 * 1000;
 
   constructor(private dbManager: DatabaseManager) {
     super();
@@ -59,6 +68,8 @@ export class AgentDaemon extends EventEmitter {
     this.approvalRepo = new ApprovalRepository(db);
     this.artifactRepo = new ArtifactRepository(db);
     this.activityRepo = new ActivityRepository(db);
+    this.agentRoleRepo = new AgentRoleRepository(db);
+    this.mentionRepo = new MentionRepository(db);
 
     // Initialize queue manager with callbacks
     this.queueManager = new TaskQueueManager({
@@ -177,6 +188,7 @@ export class AgentDaemon extends EventEmitter {
         error: error.message || 'Failed to initialize task executor',
         completedAt: Date.now(),
       });
+      this.clearRetryState(task.id);
       this.logEvent(task.id, 'error', { error: error.message });
       // Notify queue manager so it can start next task
       this.queueManager.onTaskFinished(task.id);
@@ -202,6 +214,7 @@ export class AgentDaemon extends EventEmitter {
         error: error.message,
         completedAt: Date.now(),
       });
+      this.clearRetryState(task.id);
       this.logEvent(task.id, 'error', { error: error.message });
       this.activeTasks.delete(task.id);
       // Notify queue manager so it can start next task
@@ -282,6 +295,136 @@ export class AgentDaemon extends EventEmitter {
     return task;
   }
 
+  private buildPlanSummary(plan?: Plan): string | undefined {
+    if (!plan) return undefined;
+    const lines: string[] = [];
+    if (plan.description) {
+      lines.push(`Plan: ${plan.description}`);
+    }
+    if (plan.steps && plan.steps.length > 0) {
+      lines.push('Steps:');
+      const stepLines = plan.steps
+        .slice(0, 7)
+        .map((step) => `- ${step.description}`);
+      lines.push(...stepLines);
+      if (plan.steps.length > 7) {
+        lines.push(`- …and ${plan.steps.length - 7} more steps`);
+      }
+    }
+    return lines.length > 0 ? lines.join('\n') : undefined;
+  }
+
+  private emitActivityEvent(activity: Activity): void {
+    const windows = BrowserWindow.getAllWindows();
+    windows.forEach(window => {
+      try {
+        if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
+          window.webContents.send(IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
+        }
+      } catch (error) {
+        console.error('[AgentDaemon] Error sending activity IPC:', error);
+      }
+    });
+  }
+
+  private emitMentionEvent(mention: AgentMention): void {
+    const windows = BrowserWindow.getAllWindows();
+    windows.forEach(window => {
+      try {
+        if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
+          window.webContents.send(IPC_CHANNELS.MENTION_EVENT, { type: 'created', mention });
+        }
+      } catch (error) {
+        console.error('[AgentDaemon] Error sending mention IPC:', error);
+      }
+    });
+  }
+
+  /**
+   * Dispatch mentioned agent roles after the main plan is created.
+   * This avoids starting sub-agents before the task is clearly defined.
+   */
+  async dispatchMentionedAgents(taskId: string, plan?: Plan): Promise<void> {
+    const task = this.taskRepo.findById(taskId);
+    if (!task || task.parentTaskId) return;
+
+    const mentionedRoleIds = (task.mentionedAgentRoleIds || []).filter(Boolean);
+    if (mentionedRoleIds.length === 0) return;
+
+    const activeRoles = this.agentRoleRepo.findAll(false).filter(role => role.isActive);
+    const mentionedRoles = activeRoles.filter(role => mentionedRoleIds.includes(role.id));
+    if (mentionedRoles.length === 0) return;
+
+    const existingChildren = this.taskRepo.findByParent(taskId);
+    const assignedRoleIds = new Set(
+      existingChildren
+        .map(child => child.assignedAgentRoleId)
+        .filter((id): id is string => typeof id === 'string' && id.length > 0)
+    );
+
+    const rolesToDispatch = mentionedRoles.filter(role => !assignedRoleIds.has(role.id));
+    if (rolesToDispatch.length === 0) return;
+
+    const planSummary = this.buildPlanSummary(plan);
+
+    for (const role of rolesToDispatch) {
+      const childPrompt = buildAgentDispatchPrompt(
+        role,
+        { title: task.title, prompt: task.prompt },
+        planSummary ? { planSummary } : undefined
+      );
+      const childTask = await this.createChildTask({
+        title: `@${role.displayName}: ${task.title}`,
+        prompt: childPrompt,
+        workspaceId: task.workspaceId,
+        parentTaskId: task.id,
+        agentType: 'sub',
+        agentConfig: {
+          ...(role.modelKey ? { modelKey: role.modelKey } : {}),
+          ...(role.personalityId ? { personalityId: role.personalityId } : {}),
+          retainMemory: false,
+        },
+      });
+
+      this.taskRepo.update(childTask.id, {
+        assignedAgentRoleId: role.id,
+        boardColumn: 'todo' as BoardColumn,
+      });
+
+      const dispatchActivity = this.activityRepo.create({
+        workspaceId: task.workspaceId,
+        taskId: task.id,
+        agentRoleId: role.id,
+        actorType: 'system',
+        activityType: 'agent_assigned',
+        title: `Dispatched to ${role.displayName}`,
+        description: childTask.title,
+      });
+      this.emitActivityEvent(dispatchActivity);
+
+      const mention = this.mentionRepo.create({
+        workspaceId: task.workspaceId,
+        taskId: task.id,
+        toAgentRoleId: role.id,
+        mentionType: 'request',
+        context: `New task: ${task.title}`,
+      });
+      this.emitMentionEvent(mention);
+
+      const mentionActivity = this.activityRepo.create({
+        workspaceId: task.workspaceId,
+        taskId: task.id,
+        agentRoleId: role.id,
+        actorType: 'user',
+        activityType: 'mention',
+        title: `@${role.displayName} mentioned`,
+        description: mention.context,
+        metadata: { mentionId: mention.id, mentionType: mention.mentionType },
+      });
+      this.emitActivityEvent(mentionActivity);
+    }
+  }
+
   /**
    * Cancel a running or queued task
    */
@@ -289,6 +432,7 @@ export class AgentDaemon extends EventEmitter {
     // Check if task is queued (not yet started)
     if (this.queueManager.cancelQueuedTask(taskId)) {
       this.taskRepo.update(taskId, { status: 'cancelled', completedAt: Date.now() });
+      this.clearRetryState(taskId);
       this.logEvent(taskId, 'task_cancelled', {
         message: 'Task removed from queue',
       });
@@ -307,11 +451,62 @@ export class AgentDaemon extends EventEmitter {
     this.queueManager.onTaskFinished(taskId);
 
     // Always emit cancelled event so UI updates
+    this.clearRetryState(taskId);
     this.logEvent(taskId, 'task_cancelled', {
       message: 'Task was stopped by user',
     });
   }
 
+  /**
+   * Handle transient provider errors by scheduling a retry instead of failing.
+   * Returns true if a retry was scheduled, false if retries are exhausted.
+   */
+  handleTransientTaskFailure(taskId: string, reason: string, delayMs: number = this.retryDelayMs): boolean {
+    const currentCount = this.retryCounts.get(taskId) ?? 0;
+    const nextCount = currentCount + 1;
+    if (nextCount > this.maxTaskRetries) {
+      return false;
+    }
+
+    this.retryCounts.set(taskId, nextCount);
+
+    if (this.pendingRetries.has(taskId)) {
+      return true;
+    }
+
+    // Mark as queued with a helpful message
+    this.taskRepo.update(taskId, {
+      status: 'queued',
+      error: `Transient provider error. Retry ${nextCount}/${this.maxTaskRetries} in ${Math.ceil(delayMs / 1000)}s.`,
+    });
+
+    this.logEvent(taskId, 'log', {
+      message: `Transient provider error detected. Scheduling retry ${nextCount}/${this.maxTaskRetries} in ${Math.ceil(delayMs / 1000)}s.`,
+      reason,
+    });
+
+    // Clear executor and free queue slot
+    this.activeTasks.delete(taskId);
+    this.queueManager.onTaskFinished(taskId);
+
+    const handle = setTimeout(async () => {
+      this.pendingRetries.delete(taskId);
+      const task = this.taskRepo.findById(taskId);
+      if (!task) {
+        this.retryCounts.delete(taskId);
+        return;
+      }
+      if (task.status !== 'queued') return;
+      if (this.activeTasks.has(taskId) || this.queueManager.isRunning(taskId) || this.queueManager.isQueued(taskId)) {
+        return;
+      }
+      await this.startTask(task);
+    }, delayMs);
+
+    this.pendingRetries.set(taskId, handle);
+    return true;
+  }
+
   /**
    * Pause a running task
    */
@@ -741,19 +936,6 @@ export class AgentDaemon extends EventEmitter {
     }
   }
 
-  private emitActivityEvent(activity: any): void {
-    const windows = BrowserWindow.getAllWindows();
-    windows.forEach(window => {
-      try {
-        if (!window.isDestroyed() && window.webContents && !window.webContents.isDestroyed()) {
-          window.webContents.send(IPC_CHANNELS.ACTIVITY_EVENT, { type: 'created', activity });
-        }
-      } catch (error) {
-        console.error('[AgentDaemon] Error sending activity IPC:', error);
-      }
-    });
-  }
-
   /**
    * Register an artifact (file created during task execution)
    * This allows files like screenshots to be sent back to the user
@@ -820,6 +1002,9 @@ export class AgentDaemon extends EventEmitter {
    */
   updateTaskStatus(taskId: string, status: Task['status']): void {
     this.taskRepo.update(taskId, { status });
+    if (status === 'completed' || status === 'failed' || status === 'cancelled') {
+      this.clearRetryState(taskId);
+    }
   }
 
   /**
@@ -871,6 +1056,15 @@ export class AgentDaemon extends EventEmitter {
     this.taskRepo.update(taskId, updates);
   }
 
+  private clearRetryState(taskId: string): void {
+    const pending = this.pendingRetries.get(taskId);
+    if (pending) {
+      clearTimeout(pending);
+      this.pendingRetries.delete(taskId);
+    }
+    this.retryCounts.delete(taskId);
+  }
+
   /**
    * Mark task as completed
    * Note: We keep the executor in memory for follow-up messages (with TTL-based cleanup)
@@ -880,6 +1074,7 @@ export class AgentDaemon extends EventEmitter {
       status: 'completed',
       completedAt: Date.now(),
     });
+    this.clearRetryState(taskId);
     // Mark executor as completed for TTL-based cleanup
     const cached = this.activeTasks.get(taskId);
     if (cached) {
@@ -1014,6 +1209,7 @@ export class AgentDaemon extends EventEmitter {
       status: 'failed',
       error: 'Task timed out - exceeded maximum allowed execution time',
     });
+    this.clearRetryState(taskId);
 
     // Emit timeout event
     this.logEvent(taskId, 'step_timeout', {