opencode-scheduled-tasks 0.1.0

package/dist/plugin.js

@@ -0,0 +1,882 @@
+// src/plugin.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/lib/db.ts
+import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+
+// src/lib/sqlite.ts
+import { createRequire } from "module";
+var isBun = typeof globalThis.Bun !== "undefined";
+var require2 = createRequire(import.meta.url);
+function openDatabase(path) {
+  if (isBun) {
+    return openBunDatabase(path);
+  }
+  return openNodeDatabase(path);
+}
+function openBunDatabase(path) {
+  const { Database: BunDatabase } = require2("bun:sqlite");
+  const db = new BunDatabase(path);
+  return {
+    exec(sql) {
+      db.exec(sql);
+    },
+    prepare(sql) {
+      const stmt = db.prepare(sql);
+      return {
+        run(...params) {
+          const result = stmt.run(...params);
+          return { changes: result.changes ?? 0 };
+        },
+        get(...params) {
+          return stmt.get(...params);
+        },
+        all(...params) {
+          return stmt.all(...params);
+        }
+      };
+    },
+    pragma(pragma) {
+      return db.exec(`PRAGMA ${pragma}`);
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+function openNodeDatabase(path) {
+  const BetterSqlite3 = require2("better-sqlite3");
+  const db = new BetterSqlite3(path);
+  return {
+    exec(sql) {
+      db.exec(sql);
+    },
+    prepare(sql) {
+      const stmt = db.prepare(sql);
+      return {
+        run(...params) {
+          const result = stmt.run(...params);
+          return { changes: result.changes ?? 0 };
+        },
+        get(...params) {
+          return stmt.get(...params);
+        },
+        all(...params) {
+          return stmt.all(...params);
+        }
+      };
+    },
+    pragma(pragma) {
+      return db.pragma(pragma);
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+
+// src/lib/db.ts
+var SCHEMA_VERSION = 2;
+var SCHEMA_V1 = `
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY
+);
+
+CREATE TABLE IF NOT EXISTS oneoff_tasks (
+  id TEXT PRIMARY KEY,
+  description TEXT NOT NULL,
+  prompt TEXT NOT NULL,
+  cwd TEXT NOT NULL,
+  scheduled_at TEXT NOT NULL,
+  session_mode TEXT NOT NULL DEFAULT 'new',
+  session_name TEXT,
+  model TEXT,
+  agent TEXT,
+  permission TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  executed_at TEXT,
+  session_id TEXT,
+  error TEXT,
+  created_by_session TEXT
+);
+
+CREATE TABLE IF NOT EXISTS task_runs (
+  id TEXT PRIMARY KEY,
+  task_name TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  status TEXT NOT NULL DEFAULT 'running',
+  session_id TEXT,
+  error TEXT
+);
+
+CREATE TABLE IF NOT EXISTS session_map (
+  session_name TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  task_name TEXT,
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+var MIGRATION_V2 = `
+ALTER TABLE task_runs ADD COLUMN pid INTEGER;
+ALTER TABLE oneoff_tasks ADD COLUMN pid INTEGER;
+`;
+var TaskDatabase = class {
+  db;
+  constructor(dbPath) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    this.db = openDatabase(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.initialize();
+  }
+  initialize() {
+    const versionExists = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'"
+    ).get();
+    if (!versionExists) {
+      this.db.exec(SCHEMA_V1);
+      this.db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(1);
+    }
+    const row = this.db.prepare("SELECT MAX(version) as version FROM schema_version").get();
+    const currentVersion = row?.version ?? 0;
+    if (currentVersion < SCHEMA_VERSION) {
+      this.migrate(currentVersion);
+    }
+  }
+  migrate(fromVersion) {
+    if (fromVersion < 2) {
+      const statements = MIGRATION_V2.trim().split(";").filter(Boolean);
+      for (const stmt of statements) {
+        try {
+          this.db.exec(stmt.trim() + ";");
+        } catch {
+        }
+      }
+      this.db.prepare(
+        "INSERT OR REPLACE INTO schema_version (version) VALUES (?)"
+      ).run(2);
+    }
+  }
+  // --- One-off tasks ---
+  createOneoffTask(task) {
+    const id = randomUUID();
+    this.db.prepare(
+      `INSERT INTO oneoff_tasks (id, description, prompt, cwd, scheduled_at, session_name, model, agent, permission, created_by_session)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      task.description,
+      task.prompt,
+      task.cwd,
+      task.scheduledAt,
+      task.sessionName ?? null,
+      task.model ?? null,
+      task.agent ?? null,
+      task.permission ? JSON.stringify(task.permission) : null,
+      task.createdBySession ?? null
+    );
+    return this.getOneoffTask(id);
+  }
+  getOneoffTask(id) {
+    const row = this.db.prepare("SELECT * FROM oneoff_tasks WHERE id = ?").get(id);
+    return row ? this.mapOneoffRow(row) : void 0;
+  }
+  listOneoffTasks(options) {
+    const status = options?.status ?? "all";
+    let rows;
+    if (status === "all") {
+      rows = this.db.prepare("SELECT * FROM oneoff_tasks ORDER BY scheduled_at ASC").all();
+    } else {
+      rows = this.db.prepare(
+        "SELECT * FROM oneoff_tasks WHERE status = ? ORDER BY scheduled_at ASC"
+      ).all(status);
+    }
+    return rows.map((r) => this.mapOneoffRow(r));
+  }
+  getDueOneoffTasks() {
+    return this.db.prepare(
+      "SELECT * FROM oneoff_tasks WHERE status = 'pending' AND scheduled_at <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now') ORDER BY scheduled_at ASC"
+    ).all().map((r) => this.mapOneoffRow(r));
+  }
+  updateOneoffTaskStatus(id, status, extra) {
+    const executedAt = status === "running" ? (/* @__PURE__ */ new Date()).toISOString() : void 0;
+    this.db.prepare(
+      `UPDATE oneoff_tasks SET status = ?, executed_at = COALESCE(?, executed_at), session_id = COALESCE(?, session_id), error = ?, pid = COALESCE(?, pid) WHERE id = ?`
+    ).run(
+      status,
+      executedAt ?? null,
+      extra?.sessionId ?? null,
+      extra?.error ?? null,
+      extra?.pid ?? null,
+      id
+    );
+  }
+  setTaskRunPid(id, pid) {
+    this.db.prepare("UPDATE task_runs SET pid = ? WHERE id = ?").run(pid, id);
+  }
+  cancelOneoffTask(id) {
+    const result = this.db.prepare(
+      "UPDATE oneoff_tasks SET status = 'cancelled' WHERE id = ? AND status = 'pending'"
+    ).run(id);
+    return result.changes > 0;
+  }
+  // --- Task runs (recurring) ---
+  createTaskRun(taskName, pid) {
+    const id = randomUUID();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      "INSERT INTO task_runs (id, task_name, started_at, pid) VALUES (?, ?, ?, ?)"
+    ).run(id, taskName, startedAt, pid ?? null);
+    return { id, taskName, startedAt, status: "running", pid };
+  }
+  completeTaskRun(id, status, extra) {
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `UPDATE task_runs SET status = ?, completed_at = ?, session_id = COALESCE(?, session_id), error = ? WHERE id = ?`
+    ).run(
+      status,
+      completedAt,
+      extra?.sessionId ?? null,
+      extra?.error ?? null,
+      id
+    );
+  }
+  getLastTaskRun(taskName) {
+    const row = this.db.prepare(
+      "SELECT * FROM task_runs WHERE task_name = ? ORDER BY started_at DESC LIMIT 1"
+    ).get(taskName);
+    return row ? this.mapTaskRunRow(row) : void 0;
+  }
+  getLastSuccessfulTaskRun(taskName) {
+    const row = this.db.prepare(
+      "SELECT * FROM task_runs WHERE task_name = ? AND status = 'completed' ORDER BY started_at DESC LIMIT 1"
+    ).get(taskName);
+    return row ? this.mapTaskRunRow(row) : void 0;
+  }
+  getTaskRunHistory(taskName, limit = 10) {
+    return this.db.prepare(
+      "SELECT * FROM task_runs WHERE task_name = ? ORDER BY started_at DESC LIMIT ?"
+    ).all(taskName, limit).map((r) => this.mapTaskRunRow(r));
+  }
+  hasRunningTask(taskName) {
+    const row = this.db.prepare(
+      "SELECT id FROM task_runs WHERE task_name = ? AND status = 'running' LIMIT 1"
+    ).get(taskName);
+    return !!row;
+  }
+  hasRunningOneoffTask(id) {
+    const row = this.db.prepare(
+      "SELECT id FROM oneoff_tasks WHERE id = ? AND status = 'running' LIMIT 1"
+    ).get(id);
+    return !!row;
+  }
+  /**
+   * Get all running task runs (for PID-based reaping).
+   */
+  getRunningTaskRuns() {
+    return this.db.prepare("SELECT * FROM task_runs WHERE status = 'running'").all().map((r) => this.mapTaskRunRow(r));
+  }
+  /**
+   * Get all running one-off tasks (for PID-based reaping).
+   */
+  getRunningOneoffTasks() {
+    return this.db.prepare("SELECT * FROM oneoff_tasks WHERE status = 'running'").all().map((r) => this.mapOneoffRow(r));
+  }
+  /**
+   * Mark stale running records as failed.
+   * A record is stale if it has a PID set and that process is no longer alive,
+   * or if it has no PID and is older than maxAgeMs (fallback for records
+   * created before async execution was added).
+   */
+  cleanupStaleRuns(maxAgeMs = 2 * 60 * 60 * 1e3) {
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    const taskRunResult = this.db.prepare(
+      "UPDATE task_runs SET status = 'failed', completed_at = datetime('now'), error = 'Timed out (stale running record)' WHERE status = 'running' AND pid IS NULL AND started_at < ?"
+    ).run(cutoff);
+    const oneoffResult = this.db.prepare(
+      "UPDATE oneoff_tasks SET status = 'failed', error = 'Timed out (stale running record)' WHERE status = 'running' AND pid IS NULL AND executed_at < ?"
+    ).run(cutoff);
+    return taskRunResult.changes + oneoffResult.changes;
+  }
+  // --- Session map ---
+  getSessionMapping(sessionName) {
+    const row = this.db.prepare("SELECT * FROM session_map WHERE session_name = ?").get(sessionName);
+    return row ? this.mapSessionMapRow(row) : void 0;
+  }
+  upsertSessionMapping(sessionName, sessionId, taskName) {
+    this.db.prepare(
+      `INSERT INTO session_map (session_name, session_id, task_name, updated_at)
+         VALUES (?, ?, ?, datetime('now'))
+         ON CONFLICT(session_name) DO UPDATE SET
+           session_id = excluded.session_id,
+           task_name = COALESCE(excluded.task_name, session_map.task_name),
+           updated_at = datetime('now')`
+    ).run(sessionName, sessionId, taskName ?? null);
+  }
+  // --- Row mappers ---
+  mapOneoffRow(row) {
+    return {
+      id: row.id,
+      description: row.description,
+      prompt: row.prompt,
+      cwd: row.cwd,
+      scheduledAt: row.scheduled_at,
+      sessionName: row.session_name ?? void 0,
+      model: row.model ?? void 0,
+      agent: row.agent ?? void 0,
+      permission: row.permission ? JSON.parse(row.permission) : void 0,
+      status: row.status,
+      createdAt: row.created_at,
+      executedAt: row.executed_at ?? void 0,
+      sessionId: row.session_id ?? void 0,
+      error: row.error ?? void 0,
+      createdBySession: row.created_by_session ?? void 0,
+      pid: row.pid ?? void 0
+    };
+  }
+  mapTaskRunRow(row) {
+    return {
+      id: row.id,
+      taskName: row.task_name,
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? void 0,
+      status: row.status,
+      sessionId: row.session_id ?? void 0,
+      error: row.error ?? void 0,
+      pid: row.pid ?? void 0
+    };
+  }
+  mapSessionMapRow(row) {
+    return {
+      sessionName: row.session_name,
+      sessionId: row.session_id,
+      taskName: row.task_name ?? void 0,
+      updatedAt: row.updated_at
+    };
+  }
+  close() {
+    this.db.close();
+  }
+};
+function getDefaultDbPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return `${home}/.config/opencode/.tasks.db`;
+}
+
+// src/lib/tasks.ts
+import matter from "gray-matter";
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { join, basename } from "path";
+function getTasksDir() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return join(home, ".config", "opencode", "tasks");
+}
+function expandPath(p) {
+  if (p.startsWith("~/") || p === "~") {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    return join(home, p.slice(2));
+  }
+  return p;
+}
+function validateFrontmatter(data, fileName) {
+  const errors = [];
+  if (data.description !== void 0 && typeof data.description !== "string") {
+    errors.push("Invalid 'description' field (must be a string)");
+  }
+  if (!data.schedule || typeof data.schedule !== "string") {
+    errors.push("Missing or invalid 'schedule' field");
+  }
+  if (!data.cwd || typeof data.cwd !== "string") {
+    errors.push("Missing or invalid 'cwd' field");
+  }
+  if (data.session_name !== void 0 && typeof data.session_name !== "string") {
+    errors.push("Invalid 'session_name' field (must be a string)");
+  }
+  if (data.model !== void 0 && typeof data.model !== "string") {
+    errors.push("Invalid 'model' field (must be a string)");
+  }
+  if (data.agent !== void 0 && typeof data.agent !== "string") {
+    errors.push("Invalid 'agent' field (must be a string)");
+  }
+  if (data.enabled !== void 0 && typeof data.enabled !== "boolean") {
+    errors.push("Invalid 'enabled' field (must be a boolean)");
+  }
+  return errors;
+}
+function parseTaskFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  const fileName = basename(filePath);
+  const { data, content: body } = matter(content);
+  const fm = data;
+  const errors = validateFrontmatter(data, fileName);
+  if (errors.length > 0) {
+    throw new Error(
+      `Invalid task file "${fileName}":
+  - ${errors.join("\n  - ")}`
+    );
+  }
+  const name = fileName.replace(/\.md$/, "");
+  return {
+    name,
+    description: fm.description,
+    schedule: fm.schedule,
+    cwd: fm.cwd,
+    sessionName: fm.session_name,
+    model: fm.model,
+    agent: fm.agent,
+    permission: fm.permission,
+    enabled: fm.enabled ?? true,
+    prompt: body.trim(),
+    filePath
+  };
+}
+function readAllTasks(tasksDir) {
+  const dir = tasksDir ?? getTasksDir();
+  const tasks = [];
+  const errors = [];
+  if (!existsSync(dir)) {
+    return { tasks, errors };
+  }
+  const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  for (const file of files) {
+    const filePath = join(dir, file);
+    try {
+      const task = parseTaskFile(filePath);
+      tasks.push(task);
+    } catch (err) {
+      errors.push({ file, error: err.message });
+    }
+  }
+  return { tasks, errors };
+}
+function setTaskEnabled(filePath, enabled) {
+  const content = readFileSync(filePath, "utf-8");
+  const { data, content: body } = matter(content);
+  data.enabled = enabled;
+  const updated = matter.stringify(body, data);
+  writeFileSync(filePath, updated);
+}
+
+// src/lib/cron.ts
+import cronParser from "cron-parser";
+var CronExpressionParser = cronParser.CronExpressionParser ?? cronParser;
+function getNextRunTime(expression, after) {
+  const expr = CronExpressionParser.parse(expression, {
+    currentDate: after ?? /* @__PURE__ */ new Date()
+  });
+  const next = expr.next().toISOString();
+  if (!next) throw new Error(`No next run time for expression "${expression}"`);
+  return next;
+}
+
+// src/lib/installer.ts
+import { execFileSync } from "child_process";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename as basename2, dirname as dirname2, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+var LAUNCHD_LABEL = "ai.opencode.scheduled-tasks";
+var SYSTEMD_TIMER = "opencode-scheduler.timer";
+function detectPlatform() {
+  if (process.platform === "darwin") return "macos-launchd";
+  if (process.platform === "linux") {
+    try {
+      execFileSync("systemctl", ["--version"], { stdio: "ignore" });
+      return "linux-systemd";
+    } catch {
+    }
+  }
+  return "unsupported";
+}
+function getHome() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "";
+}
+function getLaunchdPlistPath() {
+  return join2(
+    getHome(),
+    "Library",
+    "LaunchAgents",
+    `${LAUNCHD_LABEL}.plist`
+  );
+}
+function isLaunchdInstalled() {
+  return existsSync2(getLaunchdPlistPath());
+}
+function getSystemdDir() {
+  return join2(getHome(), ".config", "systemd", "user");
+}
+function isSystemdInstalled() {
+  const systemdDir = getSystemdDir();
+  return existsSync2(join2(systemdDir, SYSTEMD_TIMER));
+}
+function isInstalled() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos-launchd":
+      return isLaunchdInstalled();
+    case "linux-systemd":
+      return isSystemdInstalled();
+    default:
+      return false;
+  }
+}
+
+// src/plugin.ts
+function getDb() {
+  return new TaskDatabase(getDefaultDbPath());
+}
+function schedulerWarning() {
+  if (!isInstalled()) {
+    return "\n\nNote: The opencode-scheduler daemon is not installed. Tasks will only execute when the scheduler is run manually. Install it with: npx opencode-scheduler --install";
+  }
+  return "";
+}
+var ScheduledTasksPlugin = async (ctx) => {
+  return {
+    tool: {
+      schedule_task: tool({
+        description: "Schedule a one-off task to run at a specific time. The task will execute an opencode prompt in the specified working directory. Requires the opencode-scheduler daemon to be installed for reliable execution.",
+        args: {
+          prompt: tool.schema.string(
+            "The prompt to send to opencode when the task runs"
+          ),
+          description: tool.schema.string(
+            "Human-readable description of what this task does"
+          ),
+          cwd: tool.schema.string(
+            "Working directory for the task (absolute path or ~ for home)"
+          ),
+          scheduled_at: tool.schema.string(
+            "ISO 8601 timestamp for when to run (e.g. '2026-03-31T09:00:00')"
+          ),
+          session_name: tool.schema.string().optional().describe("Session name. If set, reuses the same session across runs. If omitted, creates a fresh session each run."),
+          model: tool.schema.string().optional().describe("Model in provider/model format"),
+          agent: tool.schema.string().optional().describe("Agent to use for execution"),
+          permission: tool.schema.string().optional().describe(
+            `Permission config as a JSON string (same schema as opencode.json permissions). Example: '{"bash":{"*":"allow"},"edit":"allow"}'`
+          )
+        },
+        async execute(args) {
+          const scheduledDate = new Date(args.scheduled_at);
+          if (isNaN(scheduledDate.getTime())) {
+            return `Error: Invalid date format "${args.scheduled_at}". Use ISO 8601 format (e.g. '2026-03-31T09:00:00').`;
+          }
+          if (scheduledDate <= /* @__PURE__ */ new Date()) {
+            return `Error: Scheduled time "${args.scheduled_at}" is in the past.`;
+          }
+          const cwd = expandPath(args.cwd);
+          let permission;
+          if (args.permission) {
+            try {
+              permission = JSON.parse(args.permission);
+            } catch {
+              return `Error: Invalid permission JSON: ${args.permission}`;
+            }
+          }
+          const db = getDb();
+          try {
+            const task = db.createOneoffTask({
+              description: args.description,
+              prompt: args.prompt,
+              cwd,
+              scheduledAt: scheduledDate.toISOString(),
+              sessionName: args.session_name,
+              model: args.model,
+              agent: args.agent,
+              permission
+            });
+            return `Task scheduled successfully!
+  ID: ${task.id}
+  Description: ${task.description}
+  Scheduled for: ${task.scheduledAt}
+  Working directory: ${task.cwd}
+  Session: ${task.sessionName ? `named (${task.sessionName})` : "new (fresh each run)"}` + schedulerWarning();
+          } finally {
+            db.close();
+          }
+        }
+      }),
+      list_tasks: tool({
+        description: "List all scheduled tasks. Shows recurring tasks from markdown files and pending one-off tasks. Includes next run time for recurring tasks and scheduled time for one-offs.",
+        args: {
+          status: tool.schema.enum(["all", "pending", "completed", "failed"]).optional().describe("Filter by status (default: all)"),
+          type: tool.schema.enum(["all", "recurring", "oneoff"]).optional().describe("Filter by type (default: all)")
+        },
+        async execute(args) {
+          const status = args.status ?? "all";
+          const type = args.type ?? "all";
+          const db = getDb();
+          const lines = [];
+          try {
+            if (type === "all" || type === "recurring") {
+              const { tasks, errors } = readAllTasks();
+              if (tasks.length > 0) {
+                lines.push("## Recurring Tasks\n");
+                for (const task of tasks) {
+                  const lastRun = db.getLastTaskRun(task.name);
+                  const statusStr = task.enabled ? "enabled" : "disabled";
+                  let nextStr = "N/A";
+                  if (task.enabled) {
+                    try {
+                      nextStr = getNextRunTime(task.schedule);
+                    } catch {
+                      nextStr = "invalid cron expression";
+                    }
+                  }
+                  lines.push(`- **${task.name}** (${statusStr})`);
+                  lines.push(`  Schedule: \`${task.schedule}\``);
+                  lines.push(`  CWD: ${task.cwd}`);
+                  lines.push(`  Next run: ${nextStr}`);
+                  if (lastRun) {
+                    lines.push(
+                      `  Last run: ${lastRun.status} at ${lastRun.startedAt}`
+                    );
+                  } else {
+                    lines.push(`  Last run: never`);
+                  }
+                  lines.push("");
+                }
+              } else {
+                lines.push("No recurring tasks found.\n");
+              }
+              if (errors.length > 0) {
+                lines.push("### Task file errors:\n");
+                for (const { file, error } of errors) {
+                  lines.push(`- ${file}: ${error}`);
+                }
+                lines.push("");
+              }
+            }
+            if (type === "all" || type === "oneoff") {
+              const oneoffs = db.listOneoffTasks({
+                status: status === "all" ? "all" : status
+              });
+              if (oneoffs.length > 0) {
+                lines.push("## One-off Tasks\n");
+                for (const task of oneoffs) {
+                  lines.push(`- **${task.description}** [${task.status}]`);
+                  lines.push(`  ID: ${task.id}`);
+                  lines.push(`  Scheduled: ${task.scheduledAt}`);
+                  lines.push(`  CWD: ${task.cwd}`);
+                  if (task.sessionId) {
+                    lines.push(`  Session: ${task.sessionId}`);
+                  }
+                  if (task.error) {
+                    lines.push(`  Error: ${task.error}`);
+                  }
+                  lines.push("");
+                }
+              } else {
+                lines.push(
+                  `No one-off tasks found${status !== "all" ? ` with status "${status}"` : ""}.
+`
+                );
+              }
+            }
+            return lines.join("\n") + schedulerWarning();
+          } finally {
+            db.close();
+          }
+        }
+      }),
+      cancel_task: tool({
+        description: "Cancel a pending one-off task by ID, or disable a recurring task by name.",
+        args: {
+          id: tool.schema.string(
+            "Task ID (for one-off, a UUID) or task name (for recurring)"
+          )
+        },
+        async execute(args) {
+          const db = getDb();
+          try {
+            if (args.id.includes("-")) {
+              const task = db.getOneoffTask(args.id);
+              if (task) {
+                if (task.status !== "pending") {
+                  return `Cannot cancel task: status is "${task.status}" (must be "pending")`;
+                }
+                db.cancelOneoffTask(args.id);
+                return `Cancelled one-off task: ${task.description} (${task.id})`;
+              }
+            }
+            const { tasks } = readAllTasks();
+            const recurringTask = tasks.find((t) => t.name === args.id);
+            if (recurringTask) {
+              setTaskEnabled(recurringTask.filePath, false);
+              return `Disabled recurring task: ${recurringTask.name}
+File updated: ${recurringTask.filePath}`;
+            }
+            return `No task found with ID or name "${args.id}"`;
+          } finally {
+            db.close();
+          }
+        }
+      }),
+      task_history: tool({
+        description: "Get the execution history for a scheduled task. Shows recent runs with status, timing, and any errors.",
+        args: {
+          task_name: tool.schema.string(
+            "Task name (for recurring) or task ID (for one-off)"
+          ),
+          limit: tool.schema.number().optional().describe("Maximum number of history entries to show (default: 10)")
+        },
+        async execute(args) {
+          const limit = args.limit ?? 10;
+          const db = getDb();
+          try {
+            if (args.task_name.includes("-")) {
+              const task = db.getOneoffTask(args.task_name);
+              if (task) {
+                const lines2 = [
+                  `## One-off Task: ${task.description}
+`,
+                  `- ID: ${task.id}`,
+                  `- Status: ${task.status}`,
+                  `- Scheduled: ${task.scheduledAt}`,
+                  `- Created: ${task.createdAt}`,
+                  `- CWD: ${task.cwd}`
+                ];
+                if (task.executedAt) lines2.push(`- Executed: ${task.executedAt}`);
+                if (task.sessionId) lines2.push(`- Session: ${task.sessionId}`);
+                if (task.error) lines2.push(`- Error: ${task.error}`);
+                return lines2.join("\n");
+              }
+            }
+            const runs = db.getTaskRunHistory(args.task_name, limit);
+            if (runs.length === 0) {
+              return `No history found for task "${args.task_name}"`;
+            }
+            const lines = [`## History for "${args.task_name}"
+`];
+            for (const run of runs) {
+              lines.push(`- **${run.status}** at ${run.startedAt}`);
+              if (run.completedAt) {
+                const duration = new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime();
+                lines.push(`  Duration: ${Math.round(duration / 1e3)}s`);
+              }
+              if (run.sessionId) lines.push(`  Session: ${run.sessionId}`);
+              if (run.error) lines.push(`  Error: ${run.error}`);
+            }
+            return lines.join("\n");
+          } finally {
+            db.close();
+          }
+        }
+      }),
+      get_task_instructions: tool({
+        description: "Get instructions and the frontmatter format for creating or editing recurring scheduled task markdown files. Use this when the user wants to set up a new recurring task or modify an existing one. After getting instructions, use file tools to create/edit the task file.",
+        args: {},
+        async execute() {
+          const tasksDir = getTasksDir();
+          return `## Creating a Recurring Scheduled Task
+
+Recurring tasks are defined as markdown files in:
+  ${tasksDir}
+
+The filename (without \`.md\`) is used as the task name. Each file contains YAML frontmatter followed by the prompt.
+
+### Frontmatter Format
+
+\`\`\`yaml
+---
+description: Clean up old branches  # Optional. Human-readable description
+schedule: "0 9 * * *"        # Required. 5-field cron expression
+cwd: ~/projects/my-app       # Required. Working directory (~ is expanded)
+session_name: daily-cleanup   # Optional. Reuses the same session across runs. Omit for fresh session each run.
+model: anthropic/claude-sonnet-4-6  # Optional. Model to use
+agent: build                  # Optional. Agent to use
+permission:                   # Optional. Same format as opencode.json permissions
+  bash:
+    "*": "allow"
+    "rm -rf *": "deny"
+  edit: "allow"
+  external_directory:          # IMPORTANT for accessing files outside cwd
+    "/tmp/*": "allow"
+enabled: true                 # Optional. Default: true
+---
+
+The prompt goes here. This is what will be sent to the opencode agent when the task runs.
+\`\`\`
+
+### Permissions - IMPORTANT
+
+Since scheduled tasks run in the background with no user present, any permission set to \`"ask"\` will effectively be **denied**. You must explicitly allow any operations the task needs.
+
+**Most commonly missed: \`external_directory\`** - This defaults to \`"ask"\` and controls access to files outside the task's \`cwd\`. If your task writes to \`/tmp\`, reads from another project, or accesses any path outside \`cwd\`, you MUST add an \`external_directory\` rule:
+
+\`\`\`yaml
+permission:
+  external_directory:
+    "/tmp/*": "allow"
+    "~/other-project/*": "allow"
+\`\`\`
+
+Other permissions like \`bash\` and \`edit\` default to \`"allow"\` and usually don't need explicit rules unless you want to restrict them.
+
+### Cron Expression Reference
+
+\`\`\`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 minute (0-59)
+\u2502 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 hour (0-23)
+\u2502 \u2502 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 day of month (1-31)
+\u2502 \u2502 \u2502 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 month (1-12)
+\u2502 \u2502 \u2502 \u2502 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 day of week (0-7, 0 and 7 are Sunday)
+\u2502 \u2502 \u2502 \u2502 \u2502
+* * * * *
+\`\`\`
+
+Common examples:
+- \`0 9 * * *\` - Every day at 9:00 AM
+- \`0 9 * * 1-5\` - Every weekday at 9:00 AM
+- \`*/30 * * * *\` - Every 30 minutes
+- \`0 0 * * 0\` - Every Sunday at midnight
+- \`0 9 1 * *\` - First day of every month at 9:00 AM
+
+### Notes
+
+- The scheduler daemon must be installed for tasks to run automatically:
+  \`npx opencode-scheduler --install\`
+- Tasks use your system's local timezone
+- Tasks with \`session_name\` set will reuse the same session across runs
+- Use \`enabled: false\` to temporarily disable a task without deleting it${schedulerWarning()}`;
+        }
+      })
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        try {
+          const db = getDb();
+          try {
+            const overdueTasks = db.getDueOneoffTasks();
+            if (overdueTasks.length > 0 && !isInstalled()) {
+              await ctx.client.app.log({
+                body: {
+                  service: "opencode-scheduled-tasks",
+                  level: "warn",
+                  message: `${overdueTasks.length} overdue task(s) found but scheduler daemon is not installed. Run: npx opencode-scheduler --install`
+                }
+              });
+            }
+          } finally {
+            db.close();
+          }
+        } catch {
+        }
+      }
+    }
+  };
+};
+var plugin_default = ScheduledTasksPlugin;
+export {
+  ScheduledTasksPlugin,
+  plugin_default as default
+};
+//# sourceMappingURL=plugin.js.map