opencode-scheduled-tasks 0.1.0

package/dist/cli.js

@@ -0,0 +1,1225 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+
+// 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 };
+}
+
+// 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;
+}
+function getPreviousRunTime(expression, before) {
+  const expr = CronExpressionParser.parse(expression, {
+    currentDate: before ?? /* @__PURE__ */ new Date()
+  });
+  const prev = expr.prev().toISOString();
+  if (!prev) throw new Error(`No previous run time for expression "${expression}"`);
+  return prev;
+}
+function isDue(expression, lastRunTime) {
+  if (!lastRunTime) {
+    const prevTrigger2 = new Date(getPreviousRunTime(expression));
+    const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3);
+    return prevTrigger2 >= twentyFourHoursAgo;
+  }
+  const prevTrigger = new Date(getPreviousRunTime(expression));
+  const lastRun = new Date(lastRunTime);
+  return prevTrigger > lastRun;
+}
+
+// src/lib/runner.ts
+import { spawn } from "child_process";
+function parseSessionIdFromJsonOutput(output) {
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event.properties?.info?.id?.startsWith("ses_")) {
+        return event.properties.info.id;
+      }
+      if (event.sessionID?.startsWith("ses_")) {
+        return event.sessionID;
+      }
+      if (event.properties?.sessionID?.startsWith("ses_")) {
+        return event.properties.sessionID;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildTaskCommand(task, db) {
+  const sessionArgs = [];
+  if (task.sessionName) {
+    const mapping = db.getSessionMapping(task.sessionName);
+    if (mapping) {
+      sessionArgs.push("--session", mapping.sessionId);
+    } else {
+      sessionArgs.push("--title", task.sessionName);
+    }
+  } else {
+    sessionArgs.push(
+      "--title",
+      `${task.name} - ${(/* @__PURE__ */ new Date()).toISOString()}`
+    );
+  }
+  const args = ["run", ...sessionArgs, "--format", "json"];
+  if (task.model) args.push("--model", task.model);
+  if (task.agent) args.push("--agent", task.agent);
+  args.push(task.prompt);
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v !== void 0) env[k] = v;
+  }
+  if (task.permission) {
+    env.OPENCODE_PERMISSION = JSON.stringify(task.permission);
+  }
+  return { args, env, cwd: expandPath(task.cwd) };
+}
+function spawnWorker(schedulerPath, runId, isOneoff) {
+  const args = ["--exec-task", runId];
+  if (isOneoff) args.push("--oneoff");
+  const child = spawn(process.execPath, [schedulerPath, ...args], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  if (!child.pid) {
+    throw new Error("Failed to spawn worker process");
+  }
+  return child.pid;
+}
+async function execTaskAndUpdateDb(task, runId, isOneoff, db) {
+  const { args, env, cwd } = buildTaskCommand(task, db);
+  const { stdout, stderr, exitCode } = await new Promise((resolve2) => {
+    const child = spawn("opencode", args, {
+      cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout2 = "";
+    let stderr2 = "";
+    child.stdout.on("data", (data) => {
+      stdout2 += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr2 += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve2({ stdout: stdout2, stderr: stderr2, exitCode: code ?? 1 });
+    });
+    child.on("error", (err) => {
+      resolve2({ stdout: stdout2, stderr: err.message, exitCode: 1 });
+    });
+  });
+  const success = exitCode === 0;
+  const sessionId = parseSessionIdFromJsonOutput(stdout);
+  if (task.sessionName && sessionId) {
+    db.upsertSessionMapping(task.sessionName, sessionId, task.name);
+  }
+  if (isOneoff) {
+    db.updateOneoffTaskStatus(runId, success ? "completed" : "failed", {
+      sessionId,
+      error: success ? void 0 : stderr.slice(0, 4096)
+    });
+  } else {
+    db.completeTaskRun(runId, success ? "completed" : "failed", {
+      sessionId,
+      error: success ? void 0 : stderr.slice(0, 4096)
+    });
+  }
+}
+
+// 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_SERVICE = "opencode-scheduler.service";
+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 resolveSchedulerPath() {
+  const thisFile = fileURLToPath(import.meta.url);
+  if (basename2(thisFile) === "cli.js") {
+    return resolve(thisFile);
+  }
+  const candidates = [
+    join2(dirname2(dirname2(thisFile)), "..", "dist", "cli.js"),
+    // from src/lib/
+    join2(dirname2(thisFile), "..", "dist", "cli.js"),
+    // from src/
+    join2(dirname2(dirname2(thisFile)), "cli.js")
+    // from dist/lib/ (if unbundled)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      return resolve(candidate);
+    }
+  }
+  try {
+    const result = execFileSync("which", ["opencode-scheduler"], {
+      encoding: "utf-8"
+    }).trim();
+    if (result) return resolve(result);
+  } catch {
+  }
+  throw new Error(
+    "Could not find the opencode-scheduler script. Make sure the package is properly installed."
+  );
+}
+function getHome() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "";
+}
+function getLogDir() {
+  const dir = join2(getHome(), ".local", "share", "opencode");
+  mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+function getLaunchdPlistPath() {
+  return join2(
+    getHome(),
+    "Library",
+    "LaunchAgents",
+    `${LAUNCHD_LABEL}.plist`
+  );
+}
+function generateLaunchdPlist(nodePath, schedulerPath) {
+  const logDir = getLogDir();
+  const currentPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${schedulerPath}</string>
+    <string>--run-once</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>60</integer>
+  <key>StandardOutPath</key>
+  <string>${join2(logDir, "scheduler.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join2(logDir, "scheduler.err")}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${currentPath}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+async function installLaunchd() {
+  const nodePath = process.execPath;
+  const schedulerPath = resolveSchedulerPath();
+  const plistPath = getLaunchdPlistPath();
+  mkdirSync2(dirname2(plistPath), { recursive: true });
+  try {
+    execFileSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+  } catch {
+  }
+  const plist = generateLaunchdPlist(nodePath, schedulerPath);
+  writeFileSync2(plistPath, plist);
+  execFileSync("launchctl", ["load", plistPath]);
+  console.log("Scheduler installed (macOS launchd)");
+  console.log(`  Plist: ${plistPath}`);
+  console.log(`  Node:  ${nodePath}`);
+  console.log(`  Script: ${schedulerPath}`);
+  console.log(`  Interval: every 60 seconds`);
+  console.log(`  Logs: ${getLogDir()}/scheduler.{log,err}`);
+}
+async function uninstallLaunchd() {
+  const plistPath = getLaunchdPlistPath();
+  if (!existsSync2(plistPath)) {
+    console.log("Scheduler is not installed (no launchd plist found)");
+    return;
+  }
+  try {
+    execFileSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+  } catch {
+  }
+  unlinkSync(plistPath);
+  console.log("Scheduler uninstalled (macOS launchd)");
+  console.log(`  Removed: ${plistPath}`);
+}
+function isLaunchdInstalled() {
+  return existsSync2(getLaunchdPlistPath());
+}
+function getSystemdDir() {
+  return join2(getHome(), ".config", "systemd", "user");
+}
+function generateSystemdService(nodePath, schedulerPath) {
+  const currentPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+  return `[Unit]
+Description=OpenCode Scheduled Tasks Runner
+
+[Service]
+Type=oneshot
+ExecStart=${nodePath} ${schedulerPath} --run-once
+Environment=PATH=${currentPath}
+`;
+}
+function generateSystemdTimer() {
+  return `[Unit]
+Description=OpenCode Scheduled Tasks Timer
+
+[Timer]
+OnBootSec=60
+OnUnitActiveSec=60
+AccuracySec=1s
+
+[Install]
+WantedBy=timers.target
+`;
+}
+async function installSystemd() {
+  const nodePath = process.execPath;
+  const schedulerPath = resolveSchedulerPath();
+  const systemdDir = getSystemdDir();
+  mkdirSync2(systemdDir, { recursive: true });
+  const servicePath = join2(systemdDir, SYSTEMD_SERVICE);
+  const timerPath = join2(systemdDir, SYSTEMD_TIMER);
+  try {
+    execFileSync("systemctl", ["--user", "stop", SYSTEMD_TIMER], {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  writeFileSync2(servicePath, generateSystemdService(nodePath, schedulerPath));
+  writeFileSync2(timerPath, generateSystemdTimer());
+  execFileSync("systemctl", ["--user", "daemon-reload"]);
+  execFileSync("systemctl", ["--user", "enable", SYSTEMD_TIMER]);
+  execFileSync("systemctl", ["--user", "start", SYSTEMD_TIMER]);
+  console.log("Scheduler installed (Linux systemd)");
+  console.log(`  Service: ${servicePath}`);
+  console.log(`  Timer:   ${timerPath}`);
+  console.log(`  Node:    ${nodePath}`);
+  console.log(`  Script:  ${schedulerPath}`);
+  console.log(`  Interval: every 60 seconds`);
+}
+async function uninstallSystemd() {
+  const systemdDir = getSystemdDir();
+  const servicePath = join2(systemdDir, SYSTEMD_SERVICE);
+  const timerPath = join2(systemdDir, SYSTEMD_TIMER);
+  if (!existsSync2(timerPath) && !existsSync2(servicePath)) {
+    console.log("Scheduler is not installed (no systemd units found)");
+    return;
+  }
+  try {
+    execFileSync("systemctl", ["--user", "stop", SYSTEMD_TIMER], {
+      stdio: "ignore"
+    });
+    execFileSync("systemctl", ["--user", "disable", SYSTEMD_TIMER], {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  if (existsSync2(servicePath)) unlinkSync(servicePath);
+  if (existsSync2(timerPath)) unlinkSync(timerPath);
+  try {
+    execFileSync("systemctl", ["--user", "daemon-reload"]);
+  } catch {
+  }
+  console.log("Scheduler uninstalled (Linux systemd)");
+  console.log(`  Removed: ${servicePath}`);
+  console.log(`  Removed: ${timerPath}`);
+}
+function isSystemdInstalled() {
+  const systemdDir = getSystemdDir();
+  return existsSync2(join2(systemdDir, SYSTEMD_TIMER));
+}
+async function install() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos-launchd":
+      await installLaunchd();
+      break;
+    case "linux-systemd":
+      await installSystemd();
+      break;
+    case "unsupported":
+      console.error(
+        "Unsupported platform. Supported: macOS (launchd), Linux (systemd)."
+      );
+      console.error("You can still run the scheduler manually:");
+      console.error("  npx opencode-scheduler --run-once");
+      process.exit(1);
+  }
+}
+async function uninstall() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos-launchd":
+      await uninstallLaunchd();
+      break;
+    case "linux-systemd":
+      await uninstallSystemd();
+      break;
+    case "unsupported":
+      console.error("No supported init system found.");
+      process.exit(1);
+  }
+}
+function isInstalled() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos-launchd":
+      return isLaunchdInstalled();
+    case "linux-systemd":
+      return isSystemdInstalled();
+    default:
+      return false;
+  }
+}
+function getInstallInfo() {
+  const platform = detectPlatform();
+  const installed = isInstalled();
+  let details;
+  if (installed) {
+    switch (platform) {
+      case "macos-launchd":
+        details = `Plist: ${getLaunchdPlistPath()}`;
+        break;
+      case "linux-systemd":
+        details = `Timer: ${join2(getSystemdDir(), SYSTEMD_TIMER)}`;
+        break;
+    }
+  }
+  return { installed, platform, details };
+}
+
+// src/cli.ts
+var SCHEDULER_PATH = fileURLToPath2(import.meta.url);
+function reapWorkers(db) {
+  for (const run of db.getRunningTaskRuns()) {
+    if (!run.pid) continue;
+    if (!isProcessAlive(run.pid)) {
+      db.completeTaskRun(run.id, "failed", {
+        error: `Worker process (PID ${run.pid}) exited unexpectedly`
+      });
+      log(
+        `Reaped crashed worker for "${run.taskName}" (PID ${run.pid})`,
+        "error"
+      );
+    }
+  }
+  for (const task of db.getRunningOneoffTasks()) {
+    if (!task.pid) continue;
+    if (!isProcessAlive(task.pid)) {
+      db.updateOneoffTaskStatus(task.id, "failed", {
+        error: `Worker process (PID ${task.pid}) exited unexpectedly`
+      });
+      log(
+        `Reaped crashed worker for one-off "${task.description}" (PID ${task.pid})`,
+        "error"
+      );
+    }
+  }
+}
+function runTick() {
+  const db = new TaskDatabase(getDefaultDbPath());
+  try {
+    const staleCount = db.cleanupStaleRuns();
+    if (staleCount > 0) {
+      log(`Cleaned up ${staleCount} stale running record(s)`);
+    }
+    reapWorkers(db);
+    const { tasks, errors } = readAllTasks();
+    for (const { file, error } of errors) {
+      log(`Error parsing task file "${file}": ${error}`, "error");
+    }
+    for (const task of tasks) {
+      if (!task.enabled) continue;
+      if (db.hasRunningTask(task.name)) {
+        continue;
+      }
+      const lastRun = db.getLastSuccessfulTaskRun(task.name);
+      if (!isDue(task.schedule, lastRun?.startedAt)) {
+        continue;
+      }
+      log(`Spawning worker for recurring task: ${task.name}`);
+      const run = db.createTaskRun(task.name);
+      try {
+        const pid = spawnWorker(SCHEDULER_PATH, run.id, false);
+        db.setTaskRunPid(run.id, pid);
+        log(`  Worker spawned (PID ${pid}, run ${run.id})`);
+      } catch (err) {
+        db.completeTaskRun(run.id, "failed", {
+          error: `Failed to spawn worker: ${err.message}`
+        });
+        log(`  Failed to spawn worker: ${err.message}`, "error");
+      }
+    }
+    const dueTasks = db.getDueOneoffTasks();
+    for (const task of dueTasks) {
+      if (db.hasRunningOneoffTask(task.id)) {
+        continue;
+      }
+      log(`Spawning worker for one-off task: ${task.description} (${task.id})`);
+      db.updateOneoffTaskStatus(task.id, "running");
+      try {
+        const pid = spawnWorker(SCHEDULER_PATH, task.id, true);
+        db.updateOneoffTaskStatus(task.id, "running", { pid });
+        log(`  Worker spawned (PID ${pid})`);
+      } catch (err) {
+        db.updateOneoffTaskStatus(task.id, "failed", {
+          error: `Failed to spawn worker: ${err.message}`
+        });
+        log(`  Failed to spawn worker: ${err.message}`, "error");
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+async function execTask(runId, isOneoff) {
+  const db = new TaskDatabase(getDefaultDbPath());
+  try {
+    let config;
+    if (isOneoff) {
+      const task = db.getOneoffTask(runId);
+      if (!task) {
+        throw new Error(`One-off task not found: ${runId}`);
+      }
+      config = {
+        name: `oneoff-${task.id.slice(0, 8)}`,
+        prompt: task.prompt,
+        cwd: task.cwd,
+        sessionName: task.sessionName,
+        model: task.model,
+        agent: task.agent,
+        permission: task.permission
+      };
+    } else {
+      const runs = db.getTaskRunHistory(runId, 1);
+      const allRuns = db.getRunningTaskRuns();
+      const run = allRuns.find((r) => r.id === runId);
+      if (!run) {
+        throw new Error(`Task run not found: ${runId}`);
+      }
+      const { tasks } = readAllTasks();
+      const task = tasks.find((t) => t.name === run.taskName);
+      if (!task) {
+        throw new Error(`Task file not found for: ${run.taskName}`);
+      }
+      config = {
+        name: task.name,
+        prompt: task.prompt,
+        cwd: task.cwd,
+        sessionName: task.sessionName,
+        model: task.model,
+        agent: task.agent,
+        permission: task.permission
+      };
+    }
+    await execTaskAndUpdateDb(config, runId, isOneoff, db);
+  } finally {
+    db.close();
+  }
+}
+function listTasks() {
+  const db = new TaskDatabase(getDefaultDbPath());
+  try {
+    const { tasks, errors } = readAllTasks();
+    if (errors.length > 0) {
+      for (const { file, error } of errors) {
+        console.error(`Error in "${file}": ${error}`);
+      }
+    }
+    if (tasks.length > 0) {
+      console.log("Recurring tasks:");
+      console.log("");
+      for (const task of tasks) {
+        const lastRun = db.getLastTaskRun(task.name);
+        const statusStr = task.enabled ? "enabled" : "disabled";
+        let nextStr = "";
+        let lastStr = "never";
+        if (task.enabled) {
+          try {
+            nextStr = `next: ${getNextRunTime(task.schedule)}`;
+          } catch {
+            nextStr = "next: invalid cron";
+          }
+        }
+        if (lastRun) {
+          lastStr = `${lastRun.status} ${lastRun.startedAt}`;
+        }
+        console.log(
+          `  ${task.name.padEnd(24)} ${statusStr.padEnd(10)} ${nextStr.padEnd(40)} last: ${lastStr}`
+        );
+      }
+    } else {
+      console.log("No recurring tasks found.");
+    }
+    const oneoffs = db.listOneoffTasks({ status: "pending" });
+    if (oneoffs.length > 0) {
+      console.log("");
+      console.log("Pending one-off tasks:");
+      console.log("");
+      for (const task of oneoffs) {
+        console.log(
+          `  ${task.id.slice(0, 12)}...  "${task.description}"  scheduled: ${task.scheduledAt}`
+        );
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+function showStatus() {
+  const info = getInstallInfo();
+  const platform = info.platform === "unsupported" ? "unknown" : info.platform;
+  if (info.installed) {
+    console.log(`Scheduler: installed (${platform})`);
+    if (info.details) {
+      console.log(`  ${info.details}`);
+    }
+  } else {
+    console.log(`Scheduler: not installed (detected platform: ${platform})`);
+    console.log("  Run: npx opencode-scheduler --install");
+  }
+  console.log("");
+  const db = new TaskDatabase(getDefaultDbPath());
+  try {
+    const { tasks, errors } = readAllTasks();
+    const enabled = tasks.filter((t) => t.enabled);
+    const disabled = tasks.filter((t) => !t.enabled);
+    console.log(
+      `Recurring tasks: ${tasks.length} (${enabled.length} enabled, ${disabled.length} disabled)`
+    );
+    for (const task of tasks) {
+      const lastRun = db.getLastTaskRun(task.name);
+      if (!task.enabled) {
+        console.log(`  ${task.name.padEnd(24)} disabled`);
+        continue;
+      }
+      let nextStr = "";
+      try {
+        nextStr = `next: ${getNextRunTime(task.schedule)}`;
+      } catch {
+        nextStr = "next: invalid cron";
+      }
+      let lastStr = "never run";
+      if (lastRun) {
+        lastStr = `${lastRun.status} ${lastRun.startedAt}`;
+      }
+      console.log(
+        `  ${task.name.padEnd(24)} ${nextStr.padEnd(44)} last: ${lastStr}`
+      );
+    }
+    if (errors.length > 0) {
+      console.log("");
+      console.log(`Task file errors: ${errors.length}`);
+      for (const { file, error } of errors) {
+        console.log(`  ${file}: ${error}`);
+      }
+    }
+    const pendingOneoffs = db.listOneoffTasks({ status: "pending" });
+    if (pendingOneoffs.length > 0) {
+      console.log("");
+      console.log(`One-off tasks: ${pendingOneoffs.length} pending`);
+      for (const task of pendingOneoffs) {
+        console.log(
+          `  ${task.id.slice(0, 12)}...  "${task.description}"  scheduled: ${task.scheduledAt}`
+        );
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+function log(message, level = "info") {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const prefix = `[${timestamp}]`;
+  if (level === "error") {
+    console.error(`${prefix} ERROR: ${message}`);
+  } else {
+    console.log(`${prefix} ${message}`);
+  }
+}
+function installSkill() {
+  const cliPath = fileURLToPath2(import.meta.url);
+  const packageRoot = dirname3(dirname3(cliPath));
+  const skillSrc = join3(packageRoot, "skill", "SKILL.md");
+  if (!existsSync3(skillSrc)) {
+    const altSrc = join3(dirname3(dirname3(cliPath)), "skill", "SKILL.md");
+    if (!existsSync3(altSrc)) {
+      console.error("Could not find SKILL.md in the package.");
+      console.error("Looked at:", skillSrc, "and", altSrc);
+      process.exit(1);
+    }
+    doInstallSkill(altSrc);
+    return;
+  }
+  doInstallSkill(skillSrc);
+}
+function doInstallSkill(srcPath) {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const destDir = join3(home, ".config", "opencode", "skills", "scheduled-tasks");
+  const destPath = join3(destDir, "SKILL.md");
+  mkdirSync3(destDir, { recursive: true });
+  copyFileSync(srcPath, destPath);
+  console.log("Skill installed successfully!");
+  console.log(`  Source: ${srcPath}`);
+  console.log(`  Installed to: ${destPath}`);
+  console.log("");
+  console.log("The 'scheduled-tasks' skill is now available to OpenCode agents.");
+  console.log("Agents will automatically discover it and can load it when relevant.");
+}
+function printUsage() {
+  console.log(`opencode-scheduler - CLI for OpenCode scheduled tasks
+
+Usage:
+  opencode-scheduler --run-once     Run one scheduler tick
+  opencode-scheduler --install      Install the system scheduler (launchd/systemd)
+  opencode-scheduler --uninstall    Remove the system scheduler
+  opencode-scheduler --install-skill  Install the scheduled-tasks agent skill
+  opencode-scheduler --status       Show scheduler and task status
+  opencode-scheduler --list         List all tasks with next run times
+  opencode-scheduler --help         Show this help message
+
+Internal (used by spawned workers):
+  opencode-scheduler --exec-task <runId> [--oneoff]
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "--install":
+      await install();
+      break;
+    case "--uninstall":
+      await uninstall();
+      break;
+    case "--install-skill":
+      installSkill();
+      break;
+    case "--status":
+      showStatus();
+      break;
+    case "--list":
+      listTasks();
+      break;
+    case "--help":
+    case "-h":
+      printUsage();
+      break;
+    case "--exec-task": {
+      const runId = args[1];
+      if (!runId) {
+        console.error("--exec-task requires a run ID");
+        process.exit(1);
+      }
+      const isOneoff = args.includes("--oneoff");
+      await execTask(runId, isOneoff);
+      break;
+    }
+    case "--run-once":
+      runTick();
+      break;
+    case void 0:
+      printUsage();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printUsage();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err.message ?? err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map