opencode-task 0.1.0 → 0.1.3

package/dist/index.js

@@ -12329,22 +12329,453 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// utils.ts
+import { appendFile } from "node:fs/promises";
+class Semaphore {
+  maxConcurrent;
+  permits;
+  waiting = [];
+  acquired = 0;
+  draining = false;
+  constructor(maxConcurrent) {
+    this.maxConcurrent = maxConcurrent;
+    this.permits = maxConcurrent;
+  }
+  async acquire() {
+    if (this.draining)
+      throw new Error("Semaphore is draining");
+    if (this.permits > 0) {
+      this.permits--;
+      this.acquired++;
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.waiting.push({ resolve, reject });
+    });
+  }
+  release() {
+    this.acquired--;
+    const next = this.waiting.shift();
+    if (next) {
+      this.acquired++;
+      next.resolve();
+    } else {
+      this.permits++;
+    }
+  }
+  drain() {
+    this.draining = true;
+    for (const waiter of this.waiting) {
+      waiter.reject(new Error("Semaphore drained"));
+    }
+    this.waiting = [];
+  }
+  get activeCount() {
+    return this.acquired;
+  }
+  get waitingCount() {
+    return this.waiting.length;
+  }
+}
+function createTask(id, command, cwd, timeout, sessionID, metadata) {
+  let resolveCompletion;
+  const completionPromise = new Promise((r) => {
+    resolveCompletion = r;
+  });
+  return {
+    id,
+    sessionID,
+    command,
+    cwd,
+    status: "pending",
+    stdout: `/tmp/${id}-stdout`,
+    stderr: `/tmp/${id}-stderr`,
+    metadata,
+    createdAt: Date.now(),
+    timeout,
+    abortController: new AbortController,
+    completionPromise,
+    resolveCompletion
+  };
+}
+function matchMetadata(taskMeta, filter) {
+  if (!taskMeta)
+    return false;
+  for (const [key, value] of Object.entries(filter)) {
+    if (taskMeta[key] !== value)
+      return false;
+  }
+  return true;
+}
+
+class TaskHistory {
+  capacity;
+  buffer;
+  head = 0;
+  count = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  push(entry) {
+    this.buffer[this.head] = entry;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity)
+      this.count++;
+  }
+  entries(statusFilter, metadataFilter) {
+    const result = [];
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0;i < this.count; i++) {
+      const idx = (start + i) % this.capacity;
+      const entry = this.buffer[idx];
+      if (!entry)
+        continue;
+      if (statusFilter && entry.status !== statusFilter)
+        continue;
+      if (metadataFilter && !matchMetadata(entry.metadata, metadataFilter))
+        continue;
+      result.push({ ...entry });
+    }
+    return result;
+  }
+  get length() {
+    return this.count;
+  }
+  clear() {
+    this.buffer = new Array(this.capacity);
+    this.head = 0;
+    this.count = 0;
+  }
+}
+
+class TaskRegistry {
+  tasks = new Map;
+  semaphore;
+  nextId = 0;
+  evictionTimers = new Map;
+  accepting = true;
+  options;
+  client;
+  taskHistory;
+  constructor(options = {}) {
+    this.options = {
+      maxConcurrent: options.maxConcurrent ?? 50,
+      taskTTL: options.taskTTL ?? 30000,
+      maxOutputSize: options.maxOutputSize ?? 5 * 1024 * 1024,
+      maxHistory: options.maxHistory ?? 200
+    };
+    this.client = options.client;
+    this.semaphore = new Semaphore(this.options.maxConcurrent);
+    this.taskHistory = new TaskHistory(this.options.maxHistory);
+  }
+  async spawn(command, options = {}) {
+    if (!this.accepting) {
+      throw new Error("Registry is shutting down");
+    }
+    const id = `task-${this.nextId++}`;
+    const cwd = options.cwd ?? process.cwd();
+    const task = createTask(id, command, cwd, options.timeout, options.sessionID, options.metadata);
+    this.tasks.set(id, task);
+    this.executeTask(task);
+    return id;
+  }
+  async executeTask(task) {
+    try {
+      await this.semaphore.acquire();
+    } catch (e) {
+      task.status = "cancelled";
+      task.error = String(e);
+      task.resolveCompletion();
+      return;
+    }
+    try {
+      task.status = "running";
+      task.startedAt = Date.now();
+      const timeoutId = task.timeout ? setTimeout(() => task.abortController.abort(), task.timeout) : null;
+      try {
+        const proc = Bun.spawn(["sh", "-c", task.command], {
+          cwd: task.cwd,
+          stdout: Bun.file(task.stdout),
+          stderr: Bun.file(task.stderr)
+        });
+        task.proc = proc;
+        task.abortController.signal.addEventListener("abort", () => {
+          proc.kill();
+        });
+        const exitCode = await proc.exited;
+        task.exitCode = exitCode;
+        if (task.abortController.signal.aborted) {
+          task.status = "cancelled";
+        } else {
+          task.status = exitCode === 0 ? "completed" : "failed";
+        }
+      } catch (error45) {
+        const errorMsg = `
+[Task execution error: ${String(error45)}]
+`;
+        await appendFile(task.stderr, errorMsg);
+        if (task.abortController.signal.aborted) {
+          task.status = "cancelled";
+        } else {
+          task.status = "failed";
+          task.error = String(error45);
+        }
+      } finally {
+        if (timeoutId)
+          clearTimeout(timeoutId);
+        task.completedAt = Date.now();
+      }
+    } finally {
+      this.semaphore.release();
+      task.resolveCompletion();
+      this.scheduleEviction(task.id);
+      this.notifyCompletion(task);
+    }
+  }
+  notifyCompletion(task) {
+    if (!this.client || !task.sessionID)
+      return;
+    this.client.session.promptAsync({
+      path: { id: task.sessionID },
+      body: {
+        parts: [
+          {
+            type: "text",
+            text: `<task-notification>
+<task-id>${task.id}</task-id>
+<status>${task.status}</status>
+<exit-code>${task.exitCode ?? "N/A"}</exit-code>
+<stdout-path>${task.stdout}</stdout-path>
+<stderr-path>${task.stderr}</stderr-path>
+</task-notification>`
+          }
+        ]
+      }
+    });
+  }
+  scheduleEviction(id) {
+    const existing = this.evictionTimers.get(id);
+    if (existing)
+      clearTimeout(existing);
+    const timer = setTimeout(() => {
+      const task = this.tasks.get(id);
+      if (task) {
+        this.taskHistory.push({
+          id: task.id,
+          command: task.command.slice(0, 200),
+          status: task.status,
+          exitCode: task.exitCode,
+          metadata: task.metadata,
+          stdout: task.stdout,
+          stderr: task.stderr,
+          createdAt: task.createdAt,
+          startedAt: task.startedAt,
+          completedAt: task.completedAt
+        });
+      }
+      this.tasks.delete(id);
+      this.evictionTimers.delete(id);
+    }, this.options.taskTTL);
+    this.evictionTimers.set(id, timer);
+  }
+  get(id) {
+    const task = this.tasks.get(id);
+    if (task?.completedAt) {
+      this.scheduleEviction(id);
+    }
+    return task;
+  }
+  async wait(id, timeoutMs = 30000) {
+    const task = this.tasks.get(id);
+    if (!task)
+      throw new Error(`Task ${id} not found`);
+    if (task.status !== "pending" && task.status !== "running") {
+      return task;
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Task ${id} wait timed out`)), timeoutMs);
+    });
+    await Promise.race([task.completionPromise, timeoutPromise]);
+    return task;
+  }
+  stop(id, signal) {
+    const task = this.tasks.get(id);
+    if (!task)
+      return false;
+    if (task.status === "running" && task.proc) {
+      if (signal === "SIGKILL") {
+        task.proc.kill(9);
+      } else {
+        task.proc.kill();
+      }
+      task.abortController.abort();
+      return true;
+    }
+    if (task.status === "pending") {
+      task.abortController.abort();
+      task.status = "cancelled";
+      task.resolveCompletion();
+      return true;
+    }
+    return false;
+  }
+  list(statusFilter, metadataFilter) {
+    let tasks = Array.from(this.tasks.values());
+    if (statusFilter && statusFilter !== "all") {
+      tasks = tasks.filter((t) => t.status === statusFilter);
+    }
+    if (metadataFilter) {
+      tasks = tasks.filter((t) => matchMetadata(t.metadata, metadataFilter));
+    }
+    return tasks;
+  }
+  async shutdown(gracePeriodMs = 3000) {
+    this.accepting = false;
+    this.semaphore.drain();
+    for (const timer of this.evictionTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.evictionTimers.clear();
+    const runningTasks = [];
+    for (const task of this.tasks.values()) {
+      if (task.status === "running" && task.proc) {
+        task.proc.kill();
+        task.abortController.abort();
+        runningTasks.push(task);
+      }
+    }
+    if (runningTasks.length === 0)
+      return;
+    const graceDeadline = Date.now() + gracePeriodMs;
+    for (const task of runningTasks) {
+      const remaining = graceDeadline - Date.now();
+      if (remaining > 0) {
+        try {
+          await Promise.race([
+            task.completionPromise,
+            new Promise((r) => setTimeout(r, remaining))
+          ]);
+        } catch {}
+      }
+      if (task.status === "running" && task.proc) {
+        task.proc.kill(9);
+      }
+    }
+  }
+  get size() {
+    return this.tasks.size;
+  }
+  get activeCount() {
+    return this.semaphore.activeCount;
+  }
+  get waitingCount() {
+    return this.semaphore.waitingCount;
+  }
+  history(statusFilter, metadataFilter) {
+    return this.taskHistory.entries(statusFilter, metadataFilter);
+  }
+  clear() {
+    for (const timer of this.evictionTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.evictionTimers.clear();
+    this.tasks.clear();
+    this.taskHistory.clear();
+  }
+}
+
 // index.ts
-var CustomToolPlugin = async () => {
+var CustomToolPlugin = async (input) => {
+  const registry2 = new TaskRegistry({
+    maxConcurrent: 50,
+    client: input.client
+  });
   return {
     tool: {
-      DemoTool: tool({
-        description: "A demo tool",
+      Task: tool({
+        description: `Spawn background task.
+
+Returns:
+- taskId: unique identifier
+- stdout/stderr: file paths (LIVE - readable during execution, not just after)
+
+You will receive a notification when it completes.`,
+        args: {
+          command: tool.schema.string().describe("Shell command to execute"),
+          cwd: tool.schema.string().optional().describe("Working directory"),
+          timeout: tool.schema.number().optional().describe("Timeout in milliseconds"),
+          metadata: tool.schema.record(tool.schema.string(), tool.schema.string()).optional().describe("Key-value metadata tags for filtering")
+        },
+        async execute(args, context) {
+          const id = await registry2.spawn(args.command, {
+            cwd: args.cwd,
+            timeout: args.timeout,
+            sessionID: context.sessionID,
+            metadata: args.metadata
+          });
+          const task = registry2.get(id);
+          return JSON.stringify({
+            taskId: id,
+            stdout: task?.stdout,
+            stderr: task?.stderr,
+            message: `Task ${id} spawned. You will receive a notification when complete.`
+          });
+        }
+      }),
+      TaskStop: tool({
+        description: "Stop/cancel a running background task",
+        args: {
+          taskId: tool.schema.string().describe("Task ID to stop"),
+          signal: tool.schema.enum(["SIGTERM", "SIGKILL"]).optional().describe("Signal to send (default SIGTERM)")
+        },
+        async execute(args) {
+          const stopped = registry2.stop(args.taskId, args.signal);
+          return JSON.stringify({ success: stopped, taskId: args.taskId });
+        }
+      }),
+      TaskList: tool({
+        description: "List background tasks with status, output paths, and metadata. Supports filtering by status and metadata. Use includeHistory to see evicted tasks.",
         args: {
-          input: tool.schema.string().describe("Input to process")
+          status: tool.schema.enum([
+            "all",
+            "running",
+            "completed",
+            "failed",
+            "pending",
+            "cancelled"
+          ]).optional().describe("Filter by status"),
+          metadata: tool.schema.record(tool.schema.string(), tool.schema.string()).optional().describe("Filter by metadata key-value pairs (all must match)"),
+          includeHistory: tool.schema.boolean().optional().describe("Include evicted tasks from history buffer (default false)")
         },
         async execute(args) {
-          return `Processed: ${args.input}`;
+          const tasks = registry2.list(args.status, args.metadata);
+          const result = {
+            count: tasks.length,
+            tasks: tasks.map((t) => ({
+              id: t.id,
+              status: t.status,
+              command: t.command.slice(0, 100),
+              stdout: t.stdout,
+              stderr: t.stderr,
+              metadata: t.metadata,
+              createdAt: t.createdAt,
+              duration: t.completedAt && t.startedAt ? t.completedAt - t.startedAt : undefined
+            }))
+          };
+          if (args.includeHistory) {
+            const history = registry2.history(args.status, args.metadata);
+            result.history = history;
+            result.historyCount = history.length;
+          }
+          return JSON.stringify(result);
         }
       })
     }
   };
 };
+var opencode_task_default = CustomToolPlugin;
 export {
+  opencode_task_default as default,
   CustomToolPlugin
 };

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "opencode-task",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "type": "module",
   "main": "dist/index.js",
   "files": ["dist"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cs50victor/opencode-task"
+  },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
@@ -13,6 +17,7 @@
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",
     "@opencode-ai/plugin": "latest",
+    "@types/bun": "latest",
     "typescript": "^5.0.0"
   }
 }