bobs-workshop 0.3.3 → 3.1.0

package/src/tools/background-agent/manager.ts

@@ -0,0 +1,455 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type {
+  BackgroundTask,
+  LaunchInput,
+  ResumeInput,
+  BackgroundTaskStatus,
+} from "./types";
+import { ConcurrencyManager } from "./concurrency";
+
+const TASK_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const MIN_STABILITY_TIME_MS = 10 * 1000; // 10 seconds before stability detection
+
+type OpencodeClient = PluginInput["client"];
+
+export class BackgroundManager {
+  private tasks: Map<string, BackgroundTask>;
+  private client: OpencodeClient;
+  private directory: string;
+  private pollingInterval?: ReturnType<typeof setInterval>;
+  private concurrencyManager: ConcurrencyManager;
+  private shutdownTriggered = false;
+  private static instance: BackgroundManager | null = null;
+
+  static getInstance(ctx: PluginInput): BackgroundManager {
+    if (!BackgroundManager.instance) {
+      BackgroundManager.instance = new BackgroundManager(ctx);
+    }
+    return BackgroundManager.instance;
+  }
+
+  private constructor(ctx: PluginInput) {
+    this.tasks = new Map();
+    this.client = ctx.client;
+    this.directory = ctx.directory;
+    this.concurrencyManager = new ConcurrencyManager();
+  }
+
+  async launch(input: LaunchInput): Promise<BackgroundTask> {
+    console.log("[background-agent] Launching task:", {
+      agent: input.agent,
+      model: input.model,
+      description: input.description,
+    });
+
+    if (!input.agent || input.agent.trim() === "") {
+      throw new Error("Agent parameter is required");
+    }
+
+    const task: BackgroundTask = {
+      id: `bg_${crypto.randomUUID().slice(0, 8)}`,
+      status: "pending",
+      queuedAt: new Date(),
+      description: input.description,
+      prompt: input.prompt,
+      agent: input.agent,
+      parentSessionID: input.parentSessionID,
+      model: input.model,
+      skills: input.skills,
+    };
+
+    this.tasks.set(task.id, task);
+
+    // Trigger processing
+    this.startTask(task, input).catch((error) => {
+      console.error("[background-agent] Error starting task:", error);
+      task.status = "error";
+      task.error = error instanceof Error ? error.message : String(error);
+      task.completedAt = new Date();
+    });
+
+    return task;
+  }
+
+  private async startTask(task: BackgroundTask, input: LaunchInput): Promise<void> {
+    const concurrencyKey = input.model || input.agent;
+    await this.concurrencyManager.acquire(concurrencyKey);
+
+    try {
+      const createResult = await this.client.session.create({
+        body: {
+          parentID: input.parentSessionID,
+          title: `Background: ${input.description}`,
+        },
+        query: {
+          directory: this.directory,
+        },
+      });
+
+      if (createResult.error) {
+        throw new Error(`Failed to create background session: ${createResult.error}`);
+      }
+
+      const sessionID = (createResult.data as { id: string }).id;
+
+      task.status = "running";
+      task.startedAt = new Date();
+      task.sessionID = sessionID;
+      task.progress = {
+        toolCalls: 0,
+        lastUpdate: new Date(),
+      };
+
+      this.startPolling();
+
+      console.log("[background-agent] Launching task:", {
+        taskId: task.id,
+        sessionID,
+        agent: input.agent,
+      });
+
+      // Build skill content
+      let skillContent = input.skillContent || "";
+      if (input.skills && input.skills.length > 0) {
+        const { join } = await import("node:path");
+        const { readFileSync, existsSync } = await import("node:fs");
+        
+        for (const skillName of input.skills) {
+          const skillPath = join(this.directory, ".opencode", "skill", "bobs-workshop", skillName, "SKILL.md");
+          if (existsSync(skillPath)) {
+            const skillFile = readFileSync(skillPath, "utf8");
+            skillContent += `\n\n---\n## Skill: ${skillName}\n\n${skillFile}`;
+          }
+        }
+      }
+
+      // Add MANUAL content if provided
+      if (input.manual_path) {
+        const { existsSync, readFileSync } = await import("node:fs");
+        if (existsSync(input.manual_path)) {
+          const manualContent = readFileSync(input.manual_path, "utf8");
+          skillContent = skillContent 
+            ? `${skillContent}\n\n## MANUAL Context:\n${manualContent}`
+            : manualContent;
+        }
+      }
+
+      // Fire-and-forget prompt
+      this.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          agent: input.agent,
+          ...(input.model ? { model: input.model } : {}),
+          system: skillContent || undefined,
+          tools: {
+            task: false,
+            delegate_task: false,
+          },
+          parts: [{ type: "text", text: input.prompt }],
+        },
+      } as any).catch((error) => {
+        console.error("[background-agent] Prompt error:", error);
+        const existingTask = this.tasks.get(task.id);
+        if (existingTask && existingTask.status === "running") {
+          existingTask.status = "error";
+          existingTask.error = error instanceof Error ? error.message : String(error);
+          existingTask.completedAt = new Date();
+          if (concurrencyKey) {
+            this.concurrencyManager.release(concurrencyKey);
+          }
+        }
+      });
+    } catch (error) {
+      this.concurrencyManager.release(concurrencyKey);
+      throw error;
+    }
+  }
+
+  getTask(id: string): BackgroundTask | undefined {
+    return this.tasks.get(id);
+  }
+
+  getAllTasks(): BackgroundTask[] {
+    return Array.from(this.tasks.values());
+  }
+
+  getRunningTasks(): BackgroundTask[] {
+    return Array.from(this.tasks.values()).filter((t) => t.status === "running");
+  }
+
+  handleEvent(event: { type: string; properties?: Record<string, unknown> }): void {
+    if (event.type === "session.idle") {
+      const sessionID = event.properties?.sessionID as string | undefined;
+      if (!sessionID) return;
+
+      const task = Array.from(this.tasks.values()).find((t) => t.sessionID === sessionID);
+      if (!task || task.status !== "running") return;
+
+      const startedAt = task.startedAt;
+      if (!startedAt) return;
+
+      const elapsedMs = Date.now() - startedAt.getTime();
+      const MIN_IDLE_TIME_MS = 5000; // 5 seconds
+      
+      if (elapsedMs < MIN_IDLE_TIME_MS) {
+        console.log("[background-agent] Ignoring early session.idle");
+        return;
+      }
+
+      this.tryCompleteTask(task, "session.idle");
+    }
+
+    if (event.type === "session.deleted") {
+      const info = event.properties?.info as { id: string } | undefined;
+      if (!info?.id) return;
+
+      const task = Array.from(this.tasks.values()).find((t) => t.sessionID === info.id);
+      if (!task) return;
+
+      if (task.status === "running") {
+        task.status = "cancelled";
+        task.completedAt = new Date();
+        task.error = "Session deleted";
+      }
+
+      this.tasks.delete(task.id);
+    }
+  }
+
+  private async tryCompleteTask(task: BackgroundTask, source: string): Promise<boolean> {
+    if (task.status !== "running") {
+      return false;
+    }
+
+    // Validate session has output before completing
+    if (!task.sessionID) return false;
+    
+    const hasOutput = await this.validateSessionHasOutput(task.sessionID);
+    if (!hasOutput) {
+      console.log("[background-agent] No valid output yet, waiting");
+      return false;
+    }
+
+    task.status = "completed";
+    task.completedAt = new Date();
+
+    // Release concurrency
+    if (task.model) {
+      this.concurrencyManager.release(task.model);
+    } else {
+      this.concurrencyManager.release(task.agent);
+    }
+
+    console.log(`[background-agent] Task completed via ${source}:`, task.id);
+
+    // Auto-remove after 5 minutes
+    setTimeout(() => {
+      this.tasks.delete(task.id);
+      console.log("[background-agent] Removed completed task from memory:", task.id);
+    }, 5 * 60 * 1000);
+
+    return true;
+  }
+
+  private async validateSessionHasOutput(sessionID: string): Promise<boolean> {
+    try {
+      const response = await this.client.session.messages({
+        path: { id: sessionID },
+      });
+
+      const messages = (response.data ?? []) as Array<{
+        info?: { role?: string };
+        parts?: Array<{ type?: string; text?: string; tool?: string }>;
+      }>;
+
+      const hasAssistantOrToolMessage = messages.some(
+        (m) => m.info?.role === "assistant" || m.info?.role === "tool"
+      );
+
+      if (!hasAssistantOrToolMessage) return false;
+
+      const hasContent = messages.some((m) => {
+        if (m.info?.role !== "assistant" && m.info?.role !== "tool") return false;
+        const parts = m.parts ?? [];
+        return parts.some(
+          (p: any) =>
+            (p.type === "text" && p.text && p.text.trim().length > 0) ||
+            (p.type === "reasoning" && p.text && p.text.trim().length > 0) ||
+            p.type === "tool" ||
+            (p.type === "tool_result" && p.content !== undefined)
+        );
+      });
+
+      return hasContent;
+    } catch (error) {
+      console.error("[background-agent] Error validating session output:", error);
+      return true; // Allow completion on error
+    }
+  }
+
+  private startPolling(): void {
+    if (this.pollingInterval) return;
+
+    this.pollingInterval = setInterval(() => {
+      this.pollRunningTasks();
+    }, 2000);
+    this.pollingInterval.unref();
+  }
+
+  private stopPolling(): void {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = undefined;
+    }
+  }
+
+  private async pollRunningTasks(): Promise<void> {
+    const now = Date.now();
+
+    // Prune stale tasks
+    for (const [taskId, task] of this.tasks.entries()) {
+      const timestamp = task.status === "pending"
+        ? task.queuedAt?.getTime()
+        : task.startedAt?.getTime();
+
+      if (!timestamp) continue;
+
+      const age = now - timestamp;
+      if (age > TASK_TTL_MS) {
+        const errorMessage = task.status === "pending"
+          ? "Task timed out while queued (30 minutes)"
+          : "Task timed out after 30 minutes";
+
+        console.log("[background-agent] Pruning stale task:", { taskId, age });
+        task.status = "error";
+        task.error = errorMessage;
+        task.completedAt = new Date();
+        this.tasks.delete(taskId);
+      }
+    }
+
+    // Check running tasks
+    const statusResult = await this.client.session.status();
+    const allStatuses = (statusResult.data ?? {}) as Record<string, { type: string }>;
+
+    for (const task of this.tasks.values()) {
+      if (task.status !== "running") continue;
+
+      const sessionID = task.sessionID;
+      if (!sessionID) continue;
+
+      try {
+        const sessionStatus = allStatuses[sessionID];
+
+        if (sessionStatus?.type === "idle") {
+          const hasValidOutput = await this.validateSessionHasOutput(sessionID);
+          if (!hasValidOutput) {
+            continue;
+          }
+
+          // Re-check status after async operation
+          if (task.status !== "running") continue;
+
+          await this.tryCompleteTask(task, "polling (idle status)");
+          continue;
+        }
+
+        // Stability detection
+        const messagesResult = await this.client.session.messages({
+          path: { id: sessionID },
+        });
+
+        if (!messagesResult.error && messagesResult.data) {
+          const messages = messagesResult.data as Array<{
+            info?: { role?: string };
+            parts?: Array<{ type?: string; tool?: string; name?: string; text?: string }>;
+          }>;
+
+          const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
+
+          let toolCalls = 0;
+          let lastTool: string | undefined;
+
+          for (const msg of assistantMsgs) {
+            const parts = msg.parts ?? [];
+            for (const part of parts) {
+              if (part.type === "tool_use" || part.tool) {
+                toolCalls++;
+                lastTool = part.tool || part.name || "unknown";
+              }
+            }
+          }
+
+          if (!task.progress) {
+            task.progress = { toolCalls: 0, lastUpdate: new Date() };
+          }
+          task.progress.toolCalls = toolCalls;
+          task.progress.lastTool = lastTool;
+          task.progress.lastUpdate = new Date();
+
+          const currentMsgCount = messages.length;
+          const startedAt = task.startedAt;
+          if (!startedAt) continue;
+
+          const elapsedMs = Date.now() - startedAt.getTime();
+
+          if (elapsedMs >= MIN_STABILITY_TIME_MS) {
+            if (task.lastMsgCount === currentMsgCount) {
+              task.stablePolls = (task.stablePolls ?? 0) + 1;
+              if ((task.stablePolls ?? 0) >= 3) {
+                const recheckStatus = await this.client.session.status();
+                const recheckData = (recheckStatus.data ?? {}) as Record<string, { type: string }>;
+                const currentStatus = recheckData[sessionID];
+
+                if (currentStatus?.type !== "idle") {
+                  task.stablePolls = 0;
+                  continue;
+                }
+
+                const hasValidOutput = await this.validateSessionHasOutput(sessionID);
+                if (!hasValidOutput) {
+                  continue;
+                }
+
+                if (task.status !== "running") continue;
+
+                await this.tryCompleteTask(task, "stability detection");
+                continue;
+              }
+            } else {
+              task.stablePolls = 0;
+            }
+          }
+          task.lastMsgCount = currentMsgCount;
+        }
+      } catch (error) {
+        console.error("[background-agent] Poll error:", error);
+      }
+    }
+
+    // Stop polling if no running tasks
+    if (!this.getRunningTasks().length) {
+      this.stopPolling();
+    }
+  }
+
+  shutdown(): void {
+    if (this.shutdownTriggered) return;
+    this.shutdownTriggered = true;
+    console.log("[background-agent] Shutting down BackgroundManager");
+    this.stopPolling();
+
+    // Release concurrency for all running tasks
+    for (const task of this.tasks.values()) {
+      if (task.model) {
+        this.concurrencyManager.release(task.model);
+      } else {
+        this.concurrencyManager.release(task.agent);
+      }
+    }
+
+    this.concurrencyManager.clear();
+    this.tasks.clear();
+    console.log("[background-agent] Shutdown complete");
+  }
+}

package/src/tools/background-agent/output.ts

@@ -0,0 +1,57 @@
+import { tool } from "@opencode-ai/plugin";
+import type { PluginInput } from "@opencode-ai/plugin";
+import { BackgroundManager } from "./manager.js";
+
+const BackgroundOutputTool: any = tool({
+  description: "Collect output from a specific background agent session",
+  args: {
+    task_id: tool.schema.string().describe("Background task ID to retrieve output from"),
+  },
+  async execute(args, context) {
+    const ctx = context as unknown as PluginInput & { sessionID: string };
+    const manager = BackgroundManager.getInstance(ctx);
+
+    const task = manager.getTask(args.task_id);
+
+    if (!task) {
+      return `❌ Task ${args.task_id} not found`;
+    }
+
+    if (task.status === "pending") {
+      return `⏳ Task ${args.task_id} is still queued...`;
+    }
+
+    if (task.status === "running") {
+      return `🔄 Task ${args.task_id} still running...`;
+    }
+
+    if (task.status === "error") {
+      return `❌ Task ${args.task_id} failed: ${task.error}`;
+    }
+
+    if (!task.sessionID) {
+      return `❌ Task ${args.task_id} has no session`;
+    }
+
+    const messagesResult = await ctx.client.session.messages({
+      path: { id: task.sessionID },
+    });
+
+    if (messagesResult.error) {
+      return `❌ Failed to retrieve output: ${messagesResult.error}`;
+    }
+
+    const messages = messagesResult.data as any[];
+    const assistantMessages = messages.filter(
+      (m) => m.info?.role === "assistant"
+    );
+
+    const output = assistantMessages
+      .map((m) => m.parts?.map((p: any) => p.text).join("\n"))
+      .join("\n\n---\n\n");
+
+    return `📥 Output from ${args.task_id}:\n\n${output}`;
+  },
+});
+
+export default BackgroundOutputTool;

package/src/tools/background-agent/types.ts

@@ -0,0 +1,55 @@
+export type BackgroundTaskStatus =
+  | "pending"
+  | "running"
+  | "completed"
+  | "error"
+  | "cancelled";
+
+export interface TaskProgress {
+  toolCalls: number;
+  lastTool?: string;
+  lastUpdate: Date;
+  lastMessage?: string;
+  lastMessageAt?: Date;
+}
+
+export interface BackgroundTask {
+  id: string;
+  sessionID?: string;
+  parentSessionID: string;
+  description: string;
+  prompt: string;
+  agent: string;
+  status: BackgroundTaskStatus;
+  queuedAt?: Date;
+  startedAt?: Date;
+  completedAt?: Date;
+  error?: string;
+  progress?: TaskProgress;
+  model?: string;
+  skills?: string[];
+  lastMsgCount?: number;
+  stablePolls?: number;
+}
+
+export interface LaunchInput {
+  description: string;
+  prompt: string;
+  agent: string;
+  parentSessionID: string;
+  model?: string;
+  skills?: string[];
+  skillContent?: string;
+  manual_path?: string;
+}
+
+export interface ModelConfig {
+  providerID: string;
+  modelID: string;
+}
+
+export interface ResumeInput {
+  sessionId: string;
+  prompt: string;
+  parentSessionID: string;
+}

package/src/tools/index.ts

@@ -0,0 +1,8 @@
+export { default as background_agent } from "./background-agent/launch.js";
+export { default as list_background_tasks } from "./background-agent/list.js";
+export { default as background_output } from "./background-agent/output.js";
+export { default as background_cancel } from "./background-agent/cancel.js";
+export { default as manual_update } from "./manual/manual-update.js";
+export { default as verify_manual } from "./manual/verify-manual.js";
+export * from "./background-agent/index.js";
+export * from "./manual/index.js";

package/src/tools/manual/index.ts

@@ -0,0 +1,2 @@
+export { default as manual_update } from "./manual-update.js";
+export { default as verify_manual } from "./verify-manual.js";