bobs-workshop 0.3.2 → 3.1.0

package/dist/tools/background-agent/manager.js

@@ -0,0 +1,377 @@
+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
+export class BackgroundManager {
+    tasks;
+    client;
+    directory;
+    pollingInterval;
+    concurrencyManager;
+    shutdownTriggered = false;
+    static instance = null;
+    static getInstance(ctx) {
+        if (!BackgroundManager.instance) {
+            BackgroundManager.instance = new BackgroundManager(ctx);
+        }
+        return BackgroundManager.instance;
+    }
+    constructor(ctx) {
+        this.tasks = new Map();
+        this.client = ctx.client;
+        this.directory = ctx.directory;
+        this.concurrencyManager = new ConcurrencyManager();
+    }
+    async launch(input) {
+        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 = {
+            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;
+    }
+    async startTask(task, input) {
+        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.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 }],
+                },
+            }).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) {
+        return this.tasks.get(id);
+    }
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    getRunningTasks() {
+        return Array.from(this.tasks.values()).filter((t) => t.status === "running");
+    }
+    handleEvent(event) {
+        if (event.type === "session.idle") {
+            const sessionID = event.properties?.sessionID;
+            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;
+            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);
+        }
+    }
+    async tryCompleteTask(task, source) {
+        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;
+    }
+    async validateSessionHasOutput(sessionID) {
+        try {
+            const response = await this.client.session.messages({
+                path: { id: sessionID },
+            });
+            const messages = (response.data ?? []);
+            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) => (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
+        }
+    }
+    startPolling() {
+        if (this.pollingInterval)
+            return;
+        this.pollingInterval = setInterval(() => {
+            this.pollRunningTasks();
+        }, 2000);
+        this.pollingInterval.unref();
+    }
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+        }
+    }
+    async pollRunningTasks() {
+        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 ?? {});
+        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;
+                    const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
+                    let toolCalls = 0;
+                    let lastTool;
+                    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 ?? {});
+                                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() {
+        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/dist/tools/background-agent/output.d.ts

@@ -0,0 +1,3 @@
+declare const BackgroundOutputTool: any;
+export default BackgroundOutputTool;
+//# sourceMappingURL=output.d.ts.map

package/dist/tools/background-agent/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../src/tools/background-agent/output.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,oBAAoB,EAAE,GAkD1B,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/dist/tools/background-agent/output.js

@@ -0,0 +1,41 @@
+import { tool } from "@opencode-ai/plugin";
+import { BackgroundManager } from "./manager.js";
+const BackgroundOutputTool = 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;
+        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;
+        const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
+        const output = assistantMessages
+            .map((m) => m.parts?.map((p) => p.text).join("\n"))
+            .join("\n\n---\n\n");
+        return `📥 Output from ${args.task_id}:\n\n${output}`;
+    },
+});
+export default BackgroundOutputTool;

package/dist/tools/background-agent/types.d.ts

@@ -0,0 +1,46 @@
+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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/background-agent/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tools/background-agent/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAC5B,SAAS,GACT,SAAS,GACT,WAAW,GACX,OAAO,GACP,WAAW,CAAC;AAEhB,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,IAAI,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,oBAAoB,CAAC;IAC7B,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB"}

package/dist/tools/background-agent/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/index.d.ts

@@ -0,0 +1,9 @@
+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";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,2BAA2B,CAAC;AACrE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC"}

package/dist/tools/index.js

@@ -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/dist/tools/manual/index.d.ts

@@ -0,0 +1,3 @@
+export { default as manual_update } from "./manual-update.js";
+export { default as verify_manual } from "./verify-manual.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/manual/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/manual/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/tools/manual/index.js

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

package/dist/tools/manual/manual-update.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+declare const ManualUpdateTool: ToolDefinition;
+export default ManualUpdateTool;
+//# sourceMappingURL=manual-update.d.ts.map

package/dist/tools/manual/manual-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manual-update.d.ts","sourceRoot":"","sources":["../../../src/tools/manual/manual-update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AA6IrE,QAAA,MAAM,gBAAgB,EAAE,cAqDtB,CAAC;AAEH,eAAe,gBAAgB,CAAC"}