@dcrays/scheduled-task 0.1.0

package/plugin/index.js

@@ -0,0 +1,1799 @@
+import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
+
+// plugins/scheduled-task/dist-npm/plugin/index.js
+import path3 from "node:path";
+import { Service } from "@deepseek-ai/cordis";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import z from "@deepseek-ai/schemastery";
+
+// plugins/scheduled-task/dist-npm/src/cron.js
+var FIELD_COUNT = 5;
+var MAX_SEARCH_DAYS = 366 * 8;
+var GREGORIAN_CYCLE_DAYS = 146097;
+var MIN_CRON_INTERVAL_SECONDS = 600;
+var CronExpressionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CronExpressionError";
+  }
+};
+function validTimeZone(timeZone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseInteger(value, label) {
+  if (!/^\d+$/.test(value))
+    throw new CronExpressionError(`${label} contains a non-integer value`);
+  return Number(value);
+}
+function parseField(raw, min, max, label, normalize) {
+  const values = /* @__PURE__ */ new Set();
+  const wildcard = raw === "*" || raw.startsWith("*/");
+  if (raw.length === 0)
+    throw new CronExpressionError(`${label} is empty`);
+  for (const segment of raw.split(",")) {
+    if (segment.length === 0)
+      throw new CronExpressionError(`${label} contains an empty list item`);
+    const slash = segment.split("/");
+    if (slash.length > 2)
+      throw new CronExpressionError(`${label} contains an invalid step`);
+    const base = slash[0] ?? "";
+    const step = slash[1] === void 0 ? 1 : parseInteger(slash[1], label);
+    if (step < 1)
+      throw new CronExpressionError(`${label} step must be positive`);
+    let start;
+    let end;
+    if (base === "*") {
+      start = min;
+      end = max;
+    } else if (base.includes("-")) {
+      const range = base.split("-");
+      if (range.length !== 2)
+        throw new CronExpressionError(`${label} contains an invalid range`);
+      start = parseInteger(range[0] ?? "", label);
+      end = parseInteger(range[1] ?? "", label);
+    } else {
+      start = parseInteger(base, label);
+      end = slash[1] === void 0 ? start : max;
+    }
+    if (start < min || start > max || end < min || end > max || start > end) {
+      throw new CronExpressionError(`${label} must stay within ${min}-${max}`);
+    }
+    for (let value = start; value <= end; value += step)
+      values.add(normalize?.(value) ?? value);
+  }
+  if (values.size === 0)
+    throw new CronExpressionError(`${label} selects no values`);
+  return { values, wildcard };
+}
+function parseCronExpression(value) {
+  if (value.trim() !== value || value.length === 0)
+    throw new CronExpressionError("cron expression must not have surrounding whitespace");
+  const fields = value.split(/\s+/);
+  if (fields.length !== FIELD_COUNT)
+    throw new CronExpressionError("cron expression must contain exactly five fields");
+  return {
+    expression: fields.join(" "),
+    minutes: parseField(fields[0] ?? "", 0, 59, "minute"),
+    hours: parseField(fields[1] ?? "", 0, 23, "hour"),
+    daysOfMonth: parseField(fields[2] ?? "", 1, 31, "day-of-month"),
+    months: parseField(fields[3] ?? "", 1, 12, "month"),
+    daysOfWeek: parseField(fields[4] ?? "", 0, 7, "day-of-week", (day) => day === 7 ? 0 : day)
+  };
+}
+function formatter(timeZone) {
+  return new Intl.DateTimeFormat("en-CA-u-ca-iso8601-nu-latn", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23",
+    timeZoneName: "longOffset"
+  });
+}
+function projectedParts(format, epochMs) {
+  const values = Object.fromEntries(format.formatToParts(epochMs).map((part) => [part.type, part.value]));
+  const match = /^GMT(?:(?<sign>[+-])(?<hour>\d{2}):(?<minute>\d{2}))?$/.exec(values.timeZoneName ?? "");
+  if (!match?.groups)
+    throw new CronExpressionError("time zone did not expose a usable UTC offset");
+  const direction = match.groups.sign === "-" ? -1 : 1;
+  const offset = match.groups.sign === void 0 ? 0 : direction * (Number(match.groups.hour) * 60 + Number(match.groups.minute)) * 6e4;
+  return {
+    year: Number(values.year),
+    month: Number(values.month),
+    day: Number(values.day),
+    hour: Number(values.hour),
+    minute: Number(values.minute),
+    second: Number(values.second),
+    offset
+  };
+}
+function localToEpoch(parts, format) {
+  const localEpoch = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, 0);
+  const offsets = /* @__PURE__ */ new Set();
+  for (const delta of [-864e5, 0, 864e5])
+    offsets.add(projectedParts(format, localEpoch + delta).offset);
+  const candidates = [];
+  for (const offset of offsets) {
+    const candidate = localEpoch - offset;
+    const projected = projectedParts(format, candidate);
+    if (projected.year === parts.year && projected.month === parts.month && projected.day === parts.day && projected.hour === parts.hour && projected.minute === parts.minute) {
+      candidates.push(candidate);
+    }
+  }
+  return [...new Set(candidates)].sort((left, right) => left - right);
+}
+function dateMatches(parsed, year, month, day) {
+  if (!parsed.months.values.has(month))
+    return false;
+  const dayOfWeek = new Date(Date.UTC(year, month - 1, day)).getUTCDay();
+  const dom = parsed.daysOfMonth.values.has(day);
+  const dow = parsed.daysOfWeek.values.has(dayOfWeek);
+  if (parsed.daysOfMonth.wildcard && parsed.daysOfWeek.wildcard)
+    return true;
+  if (parsed.daysOfMonth.wildcard)
+    return dow;
+  if (parsed.daysOfWeek.wildcard)
+    return dom;
+  return dom || dow;
+}
+function canMatchConsecutiveDays(parsed) {
+  let date = Date.UTC(2e3, 0, 1);
+  let previousMatched = false;
+  for (let offset = 0; offset < GREGORIAN_CYCLE_DAYS; offset += 1) {
+    const calendar = new Date(date);
+    const matched = dateMatches(parsed, calendar.getUTCFullYear(), calendar.getUTCMonth() + 1, calendar.getUTCDate());
+    if (matched && previousMatched)
+      return true;
+    previousMatched = matched;
+    date += 864e5;
+  }
+  return false;
+}
+function assertMinimumCronInterval(cron, minimumSeconds = MIN_CRON_INTERVAL_SECONDS) {
+  const parsed = typeof cron === "string" ? parseCronExpression(cron) : cron;
+  const slots = [...parsed.hours.values].flatMap((hour) => [...parsed.minutes.values].map((minute) => hour * 60 + minute)).sort((left, right) => left - right);
+  const minimumMinutes = Math.ceil(minimumSeconds / 60);
+  for (let index = 1; index < slots.length; index += 1) {
+    if ((slots[index] ?? 0) - (slots[index - 1] ?? 0) < minimumMinutes) {
+      throw new CronExpressionError(`cron interval must be at least ${minimumSeconds} seconds (${minimumMinutes} minutes)`);
+    }
+  }
+  const first = slots[0];
+  const last = slots.at(-1);
+  if (first !== void 0 && last !== void 0 && first + 1440 - last < minimumMinutes && canMatchConsecutiveDays(parsed)) {
+    throw new CronExpressionError(`cron interval must be at least ${minimumSeconds} seconds (${minimumMinutes} minutes)`);
+  }
+  return parsed;
+}
+function nextCronOccurrence(afterEpochMs, cron, timeZone) {
+  if (!validTimeZone(timeZone))
+    throw new CronExpressionError("timezone must be a valid IANA time zone");
+  const parsed = typeof cron === "string" ? parseCronExpression(cron) : cron;
+  const format = formatter(timeZone);
+  const start = projectedParts(format, afterEpochMs);
+  const hours = [...parsed.hours.values].sort((left, right) => left - right);
+  const minutes = [...parsed.minutes.values].sort((left, right) => left - right);
+  let date = Date.UTC(start.year, start.month - 1, start.day);
+  for (let offset = 0; offset < MAX_SEARCH_DAYS; offset += 1) {
+    const calendar = new Date(date);
+    const year = calendar.getUTCFullYear();
+    const month = calendar.getUTCMonth() + 1;
+    const day = calendar.getUTCDate();
+    if (dateMatches(parsed, year, month, day)) {
+      let earliest;
+      for (const hour of hours) {
+        for (const minute of minutes) {
+          const candidates = localToEpoch({ year, month, day, hour, minute }, format);
+          for (const candidate of candidates) {
+            if (candidate > afterEpochMs && (earliest === void 0 || candidate < earliest))
+              earliest = candidate;
+          }
+        }
+      }
+      if (earliest !== void 0)
+        return earliest;
+    }
+    date = Date.UTC(year, month - 1, day + 1);
+  }
+  throw new CronExpressionError("cron expression has no occurrence within the next eight years");
+}
+
+// plugins/scheduled-task/dist-npm/src/manager.js
+import { createHash } from "node:crypto";
+
+// plugins/scheduled-task/dist-npm/src/protocol.js
+var CRON_CREATE_TYPE = "dsh/cron.create";
+var CRON_LIST_TYPE = "dsh/cron.list";
+var CronAutomationInputError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CronAutomationInputError";
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function decodeCronCreateEnvelope(value) {
+  if (!isRecord(value) || value.type !== CRON_CREATE_TYPE) {
+    throw new CronAutomationInputError("invalid_envelope", `type must be ${CRON_CREATE_TYPE}`);
+  }
+  if (!exactKeys(value, ["type", "requestId", "name", "prompt", "cron", "timezone"])) {
+    throw new CronAutomationInputError("invalid_envelope", "cron envelope contains unknown or missing fields");
+  }
+  if (typeof value.requestId !== "string" || value.requestId.trim() !== value.requestId || value.requestId.length < 1 || value.requestId.length > 128) {
+    throw new CronAutomationInputError("invalid_request_id", "requestId must contain 1-128 characters without surrounding whitespace");
+  }
+  if (typeof value.name !== "string" || value.name.trim() !== value.name || value.name.length < 1 || value.name.length > 120) {
+    throw new CronAutomationInputError("invalid_name", "name must contain 1-120 characters without surrounding whitespace");
+  }
+  if (typeof value.prompt !== "string" || value.prompt.trim() !== value.prompt || value.prompt.length === 0) {
+    throw new CronAutomationInputError("invalid_prompt", "prompt must be a non-empty string without surrounding whitespace");
+  }
+  if (typeof value.cron !== "string") {
+    throw new CronAutomationInputError("invalid_cron", "cron must be a standard five-field expression");
+  }
+  try {
+    assertMinimumCronInterval(value.cron);
+  } catch (error) {
+    if (error instanceof CronExpressionError) {
+      throw new CronAutomationInputError("invalid_cron", error.message);
+    }
+    throw error;
+  }
+  if (typeof value.timezone !== "string" || !validTimeZone(value.timezone)) {
+    throw new CronAutomationInputError("invalid_timezone", "timezone must be a valid IANA time zone");
+  }
+  return {
+    type: CRON_CREATE_TYPE,
+    requestId: value.requestId,
+    name: value.name,
+    prompt: value.prompt,
+    cron: value.cron,
+    timezone: value.timezone
+  };
+}
+function parseCronAutomationMessage(message) {
+  if (message.source.kind !== "user" || message.content.length !== 1)
+    return void 0;
+  const block = message.content[0];
+  if (block?.type !== "text")
+    return void 0;
+  const text = block.text.trim();
+  if (!text.startsWith("{"))
+    return void 0;
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(value) || value.type !== CRON_CREATE_TYPE)
+    return void 0;
+  return decodeCronCreateEnvelope(value);
+}
+function parseCronEditorRequest(message) {
+  if (message.source.kind !== "user" || message.content.length !== 1)
+    return void 0;
+  const block = message.content[0];
+  if (block?.type !== "text")
+    return void 0;
+  const text = block.text.trim();
+  const match = /^编辑定时任务[（(]\s*任务\s*ID\s+([^）)]+?)\s*[）)][：:]/u.exec(text);
+  const id = match?.[1]?.trim();
+  if (!id || id.length > 128 || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(id))
+    return void 0;
+  return { id, text };
+}
+
+// plugins/scheduled-task/dist-npm/src/repository.js
+import fs from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var STORE_KEY = "dsh-cron-automation";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finiteTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function decodeSchedule(value) {
+  if (!isRecord2(value) || typeof value.kind !== "string")
+    throw new Error("cron job has an invalid schedule");
+  if (value.kind === "cron") {
+    const expr = typeof value.expr === "string" ? value.expr : value.cron;
+    if (typeof expr !== "string")
+      throw new Error("cron job has an invalid cron expression");
+    parseCronExpression(expr);
+    if (value.tz !== void 0 && (typeof value.tz !== "string" || !validTimeZone(value.tz))) {
+      throw new Error("cron job has an invalid time zone");
+    }
+    const { cron: _legacyCron, ...rest } = value;
+    return { ...rest, kind: "cron", expr };
+  }
+  if (value.kind === "every") {
+    if (!finiteTimestamp(value.everyMs) || value.everyMs < 6e4) {
+      throw new Error("cron job has an invalid interval");
+    }
+    if (value.anchorMs !== void 0 && !finiteTimestamp(value.anchorMs)) {
+      throw new Error("cron job has an invalid interval anchor");
+    }
+    return value;
+  }
+  if (value.kind === "at") {
+    const atMs = finiteTimestamp(value.atMs) ? value.atMs : typeof value.at === "string" ? Date.parse(value.at) : Number.NaN;
+    if (!Number.isFinite(atMs))
+      throw new Error("cron job has an invalid one-shot time");
+    return value;
+  }
+  throw new Error("cron job uses an unsupported schedule kind");
+}
+function decodeJob(value) {
+  if (!isRecord2(value))
+    throw new Error("cron store contains a non-object job");
+  if (typeof value.id !== "string" || !value.id || typeof value.name !== "string" || !value.name) {
+    throw new Error("cron job has an invalid id or name");
+  }
+  if (!isRecord2(value.payload) || value.payload.kind !== "agentTurn" || typeof value.payload.message !== "string" || !value.payload.message) {
+    throw new Error("cron job has an invalid agentTurn payload");
+  }
+  const agentId = typeof value.agentId === "string" && value.agentId ? value.agentId : typeof value.sessionKey === "string" ? value.sessionKey.split(":").filter(Boolean).at(-2) ?? "main" : "main";
+  if (value.dshSessionId !== void 0 && (typeof value.dshSessionId !== "string" || !value.dshSessionId)) {
+    throw new Error("cron job has an invalid DSH session binding");
+  }
+  if (!finiteTimestamp(value.createdAtMs) || !finiteTimestamp(value.updatedAtMs)) {
+    throw new Error("cron job has invalid timestamps");
+  }
+  if (typeof value.enabled !== "boolean")
+    throw new Error("cron job has an invalid enabled flag");
+  if (value.sessionTarget !== void 0 && value.sessionTarget !== "isolated") {
+    throw new Error("agentTurn cron jobs must use an isolated session");
+  }
+  if (value.delivery !== void 0 && (!isRecord2(value.delivery) || !["announce", "none", "webhook"].includes(String(value.delivery.mode)))) {
+    throw new Error("cron job has invalid delivery settings");
+  }
+  const state = isRecord2(value.state) ? value.state : {};
+  for (const key of ["nextRunAtMs", "runningAtMs", "lastRunAtMs"]) {
+    if (state[key] !== void 0 && !finiteTimestamp(state[key]))
+      throw new Error(`cron job has invalid ${key}`);
+  }
+  return {
+    ...value,
+    id: value.id,
+    name: value.name,
+    enabled: value.enabled,
+    createdAtMs: value.createdAtMs,
+    updatedAtMs: value.updatedAtMs,
+    schedule: decodeSchedule(value.schedule),
+    payload: value.payload,
+    agentId,
+    sessionTarget: "isolated",
+    wakeMode: "now",
+    delivery: isRecord2(value.delivery) ? value.delivery : { mode: "none" },
+    state
+  };
+}
+function booleanInteger(value) {
+  return value === void 0 ? null : value ? 1 : 0;
+}
+function atValue(schedule) {
+  if (schedule.kind !== "at")
+    return null;
+  if (schedule.at)
+    return schedule.at;
+  return schedule.atMs === void 0 ? null : new Date(schedule.atMs).toISOString();
+}
+function uniqueJobs(jobs) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const job of jobs) {
+    const decoded = decodeJob(job);
+    if (unique.has(decoded.id))
+      throw new Error(`cron store contains duplicate job id: ${decoded.id}`);
+    unique.set(decoded.id, decoded);
+  }
+  return [...unique.values()];
+}
+var CronAutomationRepository = class {
+  file;
+  database;
+  insertJobStatement;
+  readOnly;
+  closed = false;
+  constructor(file, options = {}) {
+    this.file = file;
+    this.readOnly = options.readOnly === true;
+    if (!this.readOnly)
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+    this.database = new DatabaseSync(file, { readOnly: this.readOnly, timeout: 5e3 });
+    if (this.readOnly)
+      return;
+    this.database.exec("PRAGMA journal_mode = WAL");
+    this.database.exec("PRAGMA synchronous = FULL");
+    this.database.exec("PRAGMA busy_timeout = 5000");
+    this.database.exec(`
+      CREATE TABLE IF NOT EXISTS cron_jobs (
+        store_key TEXT NOT NULL,
+        job_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        enabled INTEGER NOT NULL,
+        delete_after_run INTEGER,
+        created_at_ms INTEGER NOT NULL,
+        agent_id TEXT,
+        session_key TEXT,
+        schedule_kind TEXT NOT NULL,
+        schedule_expr TEXT,
+        schedule_tz TEXT,
+        every_ms INTEGER,
+        anchor_ms INTEGER,
+        at TEXT,
+        stagger_ms INTEGER,
+        session_target TEXT NOT NULL,
+        wake_mode TEXT NOT NULL,
+        payload_kind TEXT NOT NULL,
+        payload_message TEXT,
+        payload_model TEXT,
+        payload_fallbacks_json TEXT,
+        payload_thinking TEXT,
+        payload_timeout_seconds INTEGER,
+        payload_allow_unsafe_external_content INTEGER,
+        payload_external_content_source_json TEXT,
+        payload_light_context INTEGER,
+        payload_tools_allow_json TEXT,
+        delivery_mode TEXT,
+        delivery_channel TEXT,
+        delivery_to TEXT,
+        delivery_thread_id TEXT,
+        delivery_account_id TEXT,
+        delivery_best_effort INTEGER,
+        delivery_completion_mode TEXT,
+        delivery_completion_to TEXT,
+        failure_delivery_mode TEXT,
+        failure_delivery_channel TEXT,
+        failure_delivery_to TEXT,
+        failure_delivery_account_id TEXT,
+        failure_alert_disabled INTEGER,
+        failure_alert_after INTEGER,
+        failure_alert_channel TEXT,
+        failure_alert_to TEXT,
+        failure_alert_cooldown_ms INTEGER,
+        failure_alert_include_skipped INTEGER,
+        failure_alert_mode TEXT,
+        failure_alert_account_id TEXT,
+        next_run_at_ms INTEGER,
+        running_at_ms INTEGER,
+        last_run_at_ms INTEGER,
+        last_run_status TEXT,
+        last_error TEXT,
+        last_duration_ms INTEGER,
+        consecutive_errors INTEGER,
+        consecutive_skipped INTEGER,
+        schedule_error_count INTEGER,
+        last_delivery_status TEXT,
+        last_delivery_error TEXT,
+        last_delivered INTEGER,
+        last_failure_alert_at_ms INTEGER,
+        job_json TEXT NOT NULL,
+        state_json TEXT NOT NULL DEFAULT '{}',
+        runtime_updated_at_ms INTEGER,
+        schedule_identity TEXT,
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (store_key, job_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_store_updated
+        ON cron_jobs(store_key, sort_order ASC, updated_at DESC, job_id);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_store_order
+        ON cron_jobs(store_key, sort_order ASC, updated_at ASC, job_id);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run
+        ON cron_jobs(store_key, enabled, next_run_at_ms, job_id)
+        WHERE next_run_at_ms IS NOT NULL;
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_agent_session
+        ON cron_jobs(agent_id, session_key, updated_at DESC, job_id)
+        WHERE agent_id IS NOT NULL OR session_key IS NOT NULL;
+
+      CREATE TABLE IF NOT EXISTS cron_imported_jobs (
+        source TEXT NOT NULL,
+        job_id TEXT NOT NULL,
+        imported_at INTEGER NOT NULL,
+        PRIMARY KEY (source, job_id)
+      );
+    `);
+    this.insertJobStatement = this.database.prepare(`
+      INSERT INTO cron_jobs (
+        store_key, job_id, name, description, enabled, delete_after_run,
+        created_at_ms, agent_id, session_key,
+        schedule_kind, schedule_expr, schedule_tz, every_ms, anchor_ms, at,
+        session_target, wake_mode,
+        payload_kind, payload_message, payload_timeout_seconds,
+        delivery_mode, delivery_channel, delivery_to, delivery_account_id, delivery_best_effort,
+        next_run_at_ms, running_at_ms, last_run_at_ms, last_run_status,
+        job_json, state_json, runtime_updated_at_ms, sort_order, updated_at
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?,
+        ?, ?, ?, ?, ?, ?,
+        ?, ?,
+        ?, ?, ?,
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?, ?, ?
+      )
+      ON CONFLICT(store_key, job_id) DO UPDATE SET
+        name = excluded.name,
+        description = excluded.description,
+        enabled = excluded.enabled,
+        delete_after_run = excluded.delete_after_run,
+        created_at_ms = excluded.created_at_ms,
+        agent_id = excluded.agent_id,
+        session_key = excluded.session_key,
+        schedule_kind = excluded.schedule_kind,
+        schedule_expr = excluded.schedule_expr,
+        schedule_tz = excluded.schedule_tz,
+        every_ms = excluded.every_ms,
+        anchor_ms = excluded.anchor_ms,
+        at = excluded.at,
+        session_target = excluded.session_target,
+        wake_mode = excluded.wake_mode,
+        payload_kind = excluded.payload_kind,
+        payload_message = excluded.payload_message,
+        payload_timeout_seconds = excluded.payload_timeout_seconds,
+        delivery_mode = excluded.delivery_mode,
+        delivery_channel = excluded.delivery_channel,
+        delivery_to = excluded.delivery_to,
+        delivery_account_id = excluded.delivery_account_id,
+        delivery_best_effort = excluded.delivery_best_effort,
+        next_run_at_ms = excluded.next_run_at_ms,
+        running_at_ms = excluded.running_at_ms,
+        last_run_at_ms = excluded.last_run_at_ms,
+        last_run_status = excluded.last_run_status,
+        job_json = excluded.job_json,
+        state_json = excluded.state_json,
+        runtime_updated_at_ms = excluded.runtime_updated_at_ms,
+        updated_at = excluded.updated_at
+    `);
+    try {
+      fs.chmodSync(file, 384);
+    } catch {
+    }
+  }
+  async load() {
+    this.assertOpen();
+    const rows = this.database.prepare(`
+      SELECT job_json
+      FROM cron_jobs
+      WHERE store_key = ?
+      ORDER BY sort_order ASC, updated_at ASC, job_id ASC
+    `).all(STORE_KEY);
+    return rows.map((row) => decodeJob(JSON.parse(row.job_json)));
+  }
+  async upsert(jobs) {
+    this.assertWritable();
+    const decoded = uniqueJobs(jobs);
+    if (decoded.length === 0)
+      return;
+    this.writeTransaction(() => {
+      const nextOrder = this.nextSortOrder();
+      decoded.forEach((job, index) => this.insertJob(job, nextOrder + index));
+    });
+  }
+  async delete(jobId) {
+    this.assertWritable();
+    const result = this.database.prepare("DELETE FROM cron_jobs WHERE store_key = ? AND job_id = ?").run(STORE_KEY, jobId);
+    return Number(result.changes) > 0;
+  }
+  async previewImport(source, incoming) {
+    this.assertOpen();
+    return this.planImport(source, uniqueJobs(incoming));
+  }
+  async import(source, incoming) {
+    this.assertWritable();
+    if (!source.trim())
+      throw new Error("cron import source must be non-empty");
+    const decoded = uniqueJobs(incoming);
+    return this.writeTransaction(() => {
+      const result = this.planImport(source, decoded);
+      const nextOrder = this.nextSortOrder();
+      result.added.forEach((job, index) => this.insertJob(job, nextOrder + index));
+      const mark = this.database.prepare(`
+        INSERT OR IGNORE INTO cron_imported_jobs (source, job_id, imported_at)
+        VALUES (?, ?, ?)
+      `);
+      const importedAt = Date.now();
+      for (const job of decoded)
+        mark.run(source, job.id, importedAt);
+      return result;
+    });
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.database.close();
+  }
+  planImport(source, incoming) {
+    const existing = new Set(this.database.prepare("SELECT job_id FROM cron_jobs WHERE store_key = ?").all(STORE_KEY).map((row) => row.job_id));
+    const imported = new Set(this.database.prepare("SELECT job_id FROM cron_imported_jobs WHERE source = ?").all(source).map((row) => row.job_id));
+    const added = [];
+    const skippedIds = [];
+    for (const job of incoming) {
+      if (existing.has(job.id) || imported.has(job.id)) {
+        skippedIds.push(job.id);
+        continue;
+      }
+      existing.add(job.id);
+      added.push(job);
+    }
+    return { added, skippedIds };
+  }
+  nextSortOrder() {
+    const row = this.database.prepare(`
+      SELECT COALESCE(MAX(sort_order), -1) + 1 AS next_order
+      FROM cron_jobs
+      WHERE store_key = ?
+    `).get(STORE_KEY);
+    return row.next_order;
+  }
+  insertJob(job, sortOrder) {
+    const statement = this.insertJobStatement;
+    if (!statement)
+      throw new Error("cron sqlite repository is read-only");
+    const schedule = job.schedule;
+    const state = job.state;
+    statement.run(STORE_KEY, job.id, job.name, job.description ?? null, booleanInteger(job.enabled), booleanInteger(job.deleteAfterRun), job.createdAtMs, job.agentId, job.sessionKey ?? null, schedule.kind, schedule.kind === "cron" ? schedule.expr : null, schedule.kind === "cron" ? schedule.tz ?? null : null, schedule.kind === "every" ? schedule.everyMs : null, schedule.kind === "every" ? schedule.anchorMs ?? null : null, atValue(schedule), job.sessionTarget, job.wakeMode, job.payload.kind, job.payload.message, typeof job.payload.timeoutSeconds === "number" ? job.payload.timeoutSeconds : null, job.delivery.mode, job.delivery.channel ?? null, job.delivery.to ?? null, job.delivery.accountId ?? null, booleanInteger(job.delivery.bestEffort), state.nextRunAtMs ?? null, state.runningAtMs ?? null, state.lastRunAtMs ?? null, state.lastRunStatus ?? null, JSON.stringify(job), JSON.stringify(state), job.updatedAtMs, sortOrder, job.updatedAtMs);
+  }
+  assertOpen() {
+    if (this.closed)
+      throw new Error("cron sqlite repository is closed");
+  }
+  assertWritable() {
+    this.assertOpen();
+    if (this.readOnly)
+      throw new Error("cron sqlite repository is read-only");
+  }
+  writeTransaction(operation) {
+    this.database.exec("BEGIN IMMEDIATE");
+    try {
+      const result = operation();
+      this.database.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+};
+
+// plugins/scheduled-task/dist-npm/src/manager.js
+var MAX_TIMER_DELAY_MS = 2147483647;
+function automationId(agentId, requestId) {
+  return `cron-${createHash("sha256").update(`${agentId}\0${requestId}`).digest("hex").slice(0, 24)}`;
+}
+function cloneJob(job) {
+  return structuredClone(job);
+}
+function dshAgentIdFor(job) {
+  return job.dshSessionId ?? job.agentId;
+}
+function timezoneFor(schedule) {
+  return schedule.tz ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+}
+function atTimestamp(schedule) {
+  if (typeof schedule.atMs === "number")
+    return schedule.atMs;
+  return typeof schedule.at === "string" ? Date.parse(schedule.at) : Number.NaN;
+}
+function assertMinimumScheduleInterval(schedule) {
+  if (schedule.kind === "at")
+    return;
+  if (schedule.kind === "every") {
+    if (schedule.everyMs < MIN_CRON_INTERVAL_SECONDS * 1e3) {
+      throw new CronAutomationInputError("invalid_cron", `schedule interval must be at least ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes)`);
+    }
+    return;
+  }
+  try {
+    assertMinimumCronInterval(schedule.expr);
+  } catch (error) {
+    throw new CronAutomationInputError("invalid_cron", error instanceof Error ? error.message : "invalid cron expression");
+  }
+}
+function disableIfTooFrequent(job) {
+  if (!job.enabled)
+    return false;
+  try {
+    assertMinimumScheduleInterval(job.schedule);
+    return false;
+  } catch (error) {
+    if (!(error instanceof CronAutomationInputError))
+      throw error;
+    job.enabled = false;
+    delete job.state.runningAtMs;
+    delete job.state.nextRunAtMs;
+    return true;
+  }
+}
+function nextOccurrence(afterEpochMs, schedule) {
+  if (schedule.kind === "at") {
+    const at = atTimestamp(schedule);
+    return Number.isFinite(at) && at > afterEpochMs ? at : void 0;
+  }
+  if (schedule.kind === "every") {
+    const anchor = schedule.anchorMs ?? afterEpochMs;
+    if (anchor > afterEpochMs)
+      return anchor;
+    return anchor + (Math.floor((afterEpochMs - anchor) / schedule.everyMs) + 1) * schedule.everyMs;
+  }
+  try {
+    return nextCronOccurrence(afterEpochMs, schedule.expr, timezoneFor(schedule));
+  } catch (error) {
+    if (error instanceof CronExpressionError)
+      throw new CronAutomationInputError("invalid_cron", error.message);
+    throw error;
+  }
+}
+function initialOccurrence(job, now) {
+  return job.schedule.kind === "at" ? atTimestamp(job.schedule) : nextOccurrence(now, job.schedule);
+}
+function setNextOccurrence(job, value) {
+  if (value === void 0)
+    delete job.state.nextRunAtMs;
+  else
+    job.state.nextRunAtMs = value;
+}
+function sameRequest(job, envelope) {
+  return job.name === envelope.name && job.payload.message === envelope.prompt && job.schedule.kind === "cron" && job.schedule.expr === envelope.cron && timezoneFor(job.schedule) === envelope.timezone;
+}
+var CronAutomationManager = class {
+  repository;
+  options;
+  jobs = /* @__PURE__ */ new Map();
+  blockedAgents = /* @__PURE__ */ new Set();
+  now;
+  started;
+  tail = Promise.resolve();
+  timer;
+  stopping = false;
+  constructor(repository, options) {
+    this.repository = repository;
+    this.options = options;
+    this.now = options.now ?? Date.now;
+  }
+  start() {
+    return this.started ??= this.initialize();
+  }
+  async initialize() {
+    const loaded = await this.repository.load();
+    const changed = [];
+    const now = this.now();
+    for (const job of loaded) {
+      let jobChanged = disableIfTooFrequent(job);
+      if (job.state.runningAtMs !== void 0) {
+        delete job.state.runningAtMs;
+        jobChanged = true;
+      }
+      if (job.enabled && job.state.nextRunAtMs === void 0) {
+        setNextOccurrence(job, initialOccurrence(job, now));
+        jobChanged = true;
+      }
+      if (jobChanged)
+        changed.push(job);
+      this.jobs.set(job.id, job);
+    }
+    await this.repository.upsert(changed);
+    this.arm();
+  }
+  async stop() {
+    this.stopping = true;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = void 0;
+    try {
+      await this.tail;
+    } finally {
+      this.repository.close();
+    }
+  }
+  async create(agentId, envelope) {
+    await this.start();
+    return this.enqueue(async () => {
+      if (this.stopping)
+        throw new Error("cron automation manager is stopping");
+      const id = automationId(agentId, envelope.requestId);
+      const existing = this.jobs.get(id);
+      if (existing) {
+        if (!sameRequest(existing, envelope)) {
+          throw new CronAutomationInputError("request_id_conflict", "requestId was already used for a different cron automation");
+        }
+        return cloneJob(existing);
+      }
+      if (envelope.prompt.length > this.options.maxPromptChars) {
+        throw new CronAutomationInputError("invalid_prompt", `prompt must not exceed ${this.options.maxPromptChars} characters`);
+      }
+      const now = this.now();
+      const schedule = { kind: "cron", expr: envelope.cron, tz: envelope.timezone };
+      assertMinimumScheduleInterval(schedule);
+      const nextRunAtMs = nextOccurrence(now, schedule);
+      const job = {
+        id,
+        name: envelope.name,
+        description: envelope.prompt,
+        enabled: true,
+        createdAtMs: now,
+        updatedAtMs: now,
+        schedule,
+        payload: { kind: "agentTurn", message: envelope.prompt, timeoutSeconds: 600 },
+        agentId,
+        dshSessionId: agentId,
+        sessionTarget: "isolated",
+        wakeMode: "now",
+        delivery: { mode: "announce", bestEffort: true },
+        state: { ...nextRunAtMs === void 0 ? {} : { nextRunAtMs } }
+      };
+      this.jobs.set(job.id, job);
+      try {
+        await this.repository.upsert([job]);
+      } catch (error) {
+        this.jobs.delete(job.id);
+        throw error;
+      }
+      this.options.onCreated?.(cloneJob(job));
+      this.arm();
+      return cloneJob(job);
+    });
+  }
+  async update(jobId, patch) {
+    await this.start();
+    return this.enqueue(async () => {
+      const current = this.jobs.get(jobId);
+      if (!current)
+        return void 0;
+      const patchKeys = Object.keys(patch);
+      if (patchKeys.length === 0)
+        throw new CronAutomationInputError("invalid_envelope", "at least one editable field is required");
+      if (patchKeys.length === 1 && patch.enabled === current.enabled)
+        return cloneJob(current);
+      const next = cloneJob(current);
+      if (patch.name !== void 0) {
+        if (patch.name.trim() !== patch.name || patch.name.length < 1 || patch.name.length > 120) {
+          throw new CronAutomationInputError("invalid_name", "name must contain 1-120 characters without surrounding whitespace");
+        }
+        next.name = patch.name;
+      }
+      if (patch.prompt !== void 0) {
+        if (patch.prompt.trim() !== patch.prompt || patch.prompt.length < 1 || patch.prompt.length > this.options.maxPromptChars) {
+          throw new CronAutomationInputError("invalid_prompt", `prompt must contain 1-${this.options.maxPromptChars} characters without surrounding whitespace`);
+        }
+        next.payload.message = patch.prompt;
+        next.description = patch.prompt;
+      }
+      if (patch.cron !== void 0) {
+        try {
+          assertMinimumCronInterval(patch.cron);
+        } catch (error) {
+          throw new CronAutomationInputError("invalid_cron", error instanceof Error ? error.message : "invalid cron expression");
+        }
+      }
+      if (patch.timezone !== void 0 && !validTimeZone(patch.timezone)) {
+        throw new CronAutomationInputError("invalid_timezone", "timezone must be a valid IANA time zone");
+      }
+      if (patch.sessionKey !== void 0) {
+        if (!patch.sessionKey.trim() || patch.sessionKey.trim() !== patch.sessionKey) {
+          throw new CronAutomationInputError("invalid_envelope", "sessionKey must be non-empty without surrounding whitespace");
+        }
+        next.sessionKey = patch.sessionKey;
+        next.delivery = {
+          ...next.delivery,
+          mode: "announce",
+          to: `dcg-cron:${patch.sessionKey}`,
+          channel: "dcgchat",
+          bestEffort: true
+        };
+      }
+      for (const key of ["agentId", "dshSessionId"]) {
+        if (patch[key] !== void 0) {
+          if (!patch[key]?.trim() || patch[key]?.trim() !== patch[key]) {
+            throw new CronAutomationInputError("invalid_envelope", `${key} must be non-empty without surrounding whitespace`);
+          }
+          next[key] = patch[key];
+        }
+      }
+      if (patch.cron !== void 0 || patch.timezone !== void 0) {
+        const currentCron = next.schedule.kind === "cron" ? next.schedule.expr : void 0;
+        const currentTimezone = next.schedule.kind === "cron" ? timezoneFor(next.schedule) : void 0;
+        if (!patch.cron && !currentCron)
+          throw new CronAutomationInputError("invalid_cron", "changing a non-cron schedule requires a cron expression");
+        next.schedule = {
+          kind: "cron",
+          expr: patch.cron ?? currentCron ?? "",
+          tz: patch.timezone ?? currentTimezone ?? "UTC"
+        };
+      }
+      const now = this.now();
+      if (patch.enabled !== void 0) {
+        next.enabled = patch.enabled;
+        delete next.state.runningAtMs;
+      }
+      if (next.enabled)
+        assertMinimumScheduleInterval(next.schedule);
+      if (patch.enabled === true) {
+        setNextOccurrence(next, initialOccurrence(next, now));
+      } else if (patch.cron !== void 0 || patch.timezone !== void 0) {
+        setNextOccurrence(next, nextOccurrence(now, next.schedule));
+      }
+      next.updatedAtMs = now;
+      this.jobs.set(jobId, next);
+      try {
+        await this.repository.upsert([next]);
+      } catch (error) {
+        this.jobs.set(jobId, current);
+        throw error;
+      }
+      if (patch.enabled || dshAgentIdFor(current) !== dshAgentIdFor(next)) {
+        this.blockedAgents.delete(dshAgentIdFor(current));
+        this.blockedAgents.delete(dshAgentIdFor(next));
+      }
+      this.options.onChanged?.(cloneJob(next));
+      this.arm();
+      return cloneJob(next);
+    });
+  }
+  async delete(jobId) {
+    await this.start();
+    return this.enqueue(async () => {
+      const job = this.jobs.get(jobId);
+      if (!job)
+        return false;
+      this.jobs.delete(jobId);
+      this.blockedAgents.delete(dshAgentIdFor(job));
+      try {
+        await this.repository.delete(jobId);
+      } catch (error) {
+        this.jobs.set(jobId, job);
+        throw error;
+      }
+      this.options.onChanged?.(cloneJob(job));
+      this.arm();
+      return true;
+    });
+  }
+  async runOnceStatus(jobId) {
+    await this.start();
+    return this.enqueue(async () => {
+      const job = this.jobs.get(jobId);
+      if (!job)
+        return "not_found";
+      if (job.state.runningAtMs !== void 0)
+        return "already_running";
+      const occurrenceAtMs = this.now();
+      job.state.runningAtMs = occurrenceAtMs;
+      job.updatedAtMs = occurrenceAtMs;
+      await this.repository.upsert([job]);
+      const delivered = await this.deliver(job, occurrenceAtMs);
+      delete job.state.runningAtMs;
+      job.state.lastRunAtMs = occurrenceAtMs;
+      job.state.lastRunStatus = delivered ? "ok" : "skipped";
+      job.updatedAtMs = this.now();
+      await this.repository.upsert([job]);
+      if (delivered) {
+        this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+        return "dispatched";
+      }
+      this.options.onChanged?.(cloneJob(job));
+      return "delivery_unavailable";
+    });
+  }
+  async runOnce(jobId) {
+    return await this.runOnceStatus(jobId) === "dispatched";
+  }
+  async list(agentId) {
+    await this.start();
+    await this.tail;
+    return [...this.jobs.values()].filter((job) => agentId === void 0 || dshAgentIdFor(job) === agentId).sort((left, right) => left.createdAtMs - right.createdAtMs || left.id.localeCompare(right.id)).map(cloneJob);
+  }
+  notifyAgentAvailable(agentId) {
+    if (!this.blockedAgents.delete(agentId))
+      return;
+    this.requestDispatch();
+  }
+  /** Import each source job once. Existing ids win so DSH bindings stay intact. */
+  async importFrom(source, incoming) {
+    await this.start();
+    return this.enqueue(async () => {
+      const prepared = [];
+      for (const job of incoming) {
+        const next = cloneJob(job);
+        delete next.state.runningAtMs;
+        disableIfTooFrequent(next);
+        if (next.enabled && next.state.nextRunAtMs === void 0) {
+          setNextOccurrence(next, initialOccurrence(next, this.now()));
+        }
+        prepared.push(next);
+      }
+      const { added } = await this.repository.import(source, prepared);
+      if (added.length === 0)
+        return added;
+      for (const job of added) {
+        this.jobs.set(job.id, cloneJob(job));
+        this.options.onCreated?.(cloneJob(job));
+      }
+      this.arm();
+      return added.map(cloneJob);
+    });
+  }
+  async deliver(job, occurrenceAtMs) {
+    try {
+      return await this.options.deliver(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+    } catch (error) {
+      this.options.onError?.(error);
+      return false;
+    }
+  }
+  enqueue(operation) {
+    const run = this.tail.then(operation);
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  requestDispatch() {
+    void this.enqueue(() => this.dispatchDue()).catch((error) => this.options.onError?.(error));
+  }
+  arm() {
+    if (this.stopping)
+      return;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = void 0;
+    const now = this.now();
+    const target = [...this.jobs.values()].filter((job) => job.enabled && job.state.runningAtMs === void 0 && !this.blockedAgents.has(dshAgentIdFor(job))).map((job) => job.state.nextRunAtMs).filter((value) => value !== void 0).reduce((earliest, candidate) => earliest === void 0 || candidate < earliest ? candidate : earliest, void 0);
+    if (target === void 0)
+      return;
+    const delay = Math.max(0, Math.min(target - now, MAX_TIMER_DELAY_MS));
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.requestDispatch();
+    }, delay);
+    this.timer.unref();
+  }
+  async dispatchDue() {
+    if (this.stopping)
+      return;
+    const now = this.now();
+    const due = [...this.jobs.values()].filter((job) => job.enabled && job.state.nextRunAtMs !== void 0 && job.state.nextRunAtMs <= now).sort((left, right) => (left.state.nextRunAtMs ?? 0) - (right.state.nextRunAtMs ?? 0) || left.createdAtMs - right.createdAtMs);
+    for (const job of due) {
+      const occurrenceAtMs = job.state.nextRunAtMs ?? now;
+      job.state.runningAtMs = now;
+      job.updatedAtMs = now;
+      await this.repository.upsert([job]);
+      const delivered = await this.deliver(job, occurrenceAtMs);
+      delete job.state.runningAtMs;
+      job.state.lastRunAtMs = now;
+      job.state.lastRunStatus = delivered ? "ok" : "skipped";
+      job.updatedAtMs = now;
+      if (!delivered) {
+        this.blockedAgents.add(dshAgentIdFor(job));
+        await this.repository.upsert([job]);
+        this.options.onChanged?.(cloneJob(job));
+        continue;
+      }
+      if (job.deleteAfterRun === true || job.schedule.kind === "at") {
+        this.jobs.delete(job.id);
+        await this.repository.delete(job.id);
+      } else {
+        setNextOccurrence(job, nextOccurrence(now, job.schedule));
+        await this.repository.upsert([job]);
+      }
+      this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+    }
+    this.arm();
+  }
+};
+
+// plugins/scheduled-task/dist-npm/src/openclaw-sqlite.js
+import { existsSync, realpathSync } from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+var DEFAULT_OPENCLAW_SQLITE = path2.join(os.homedir(), ".mobook", "state", "openclaw.sqlite");
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`OpenClaw ${label} is not valid JSON`);
+  }
+}
+function scheduleFromRow(row) {
+  if (row.schedule_kind === "every") {
+    return {
+      kind: "every",
+      everyMs: row.every_ms,
+      ...row.anchor_ms === null ? {} : { anchorMs: row.anchor_ms }
+    };
+  }
+  if (row.schedule_kind === "at") {
+    return { kind: "at", ...row.at === null ? {} : { at: row.at } };
+  }
+  return {
+    kind: "cron",
+    expr: row.schedule_expr,
+    ...row.schedule_tz === null ? {} : { tz: row.schedule_tz }
+  };
+}
+function jobFromColumns(row, state) {
+  return {
+    id: row.job_id,
+    name: row.name,
+    ...row.description ? { description: row.description } : {},
+    enabled: row.enabled === 1,
+    createdAtMs: row.created_at_ms,
+    updatedAtMs: row.updated_at,
+    schedule: scheduleFromRow(row),
+    payload: {
+      kind: row.payload_kind || "agentTurn",
+      message: row.payload_message ?? "",
+      ...row.payload_timeout_seconds === null ? {} : { timeoutSeconds: row.payload_timeout_seconds }
+    },
+    agentId: row.agent_id ?? "main",
+    ...row.session_key ? { sessionKey: row.session_key } : {},
+    sessionTarget: row.session_target || "isolated",
+    wakeMode: row.wake_mode || "now",
+    ...row.delete_after_run === 1 ? { deleteAfterRun: true } : {},
+    delivery: {
+      mode: row.delivery_mode ?? "announce",
+      ...row.delivery_channel ? { channel: row.delivery_channel } : {},
+      ...row.delivery_to ? { to: row.delivery_to } : {},
+      ...row.delivery_account_id ? { accountId: row.delivery_account_id } : {},
+      bestEffort: row.delivery_best_effort !== 0
+    },
+    state
+  };
+}
+function overlayState(row, jobState, tableState) {
+  const state = {
+    ...isRecord3(jobState) ? jobState : {},
+    ...isRecord3(tableState) ? tableState : {}
+  };
+  if (row.next_run_at_ms !== null)
+    state.nextRunAtMs = row.next_run_at_ms;
+  if (row.running_at_ms !== null)
+    state.runningAtMs = row.running_at_ms;
+  if (row.last_run_at_ms !== null)
+    state.lastRunAtMs = row.last_run_at_ms;
+  if (row.last_run_status)
+    state.lastRunStatus = row.last_run_status;
+  return state;
+}
+function jobFromOpenClawRow(row) {
+  const tableState = parseJson(row.state_json || "{}", "state_json");
+  try {
+    const parsed = parseJson(row.job_json, "job_json");
+    if (!isRecord3(parsed))
+      throw new Error("job_json must be an object");
+    return decodeJob({
+      ...parsed,
+      id: typeof parsed.id === "string" && parsed.id ? parsed.id : row.job_id,
+      updatedAtMs: typeof parsed.updatedAtMs === "number" ? parsed.updatedAtMs : row.updated_at,
+      createdAtMs: typeof parsed.createdAtMs === "number" ? parsed.createdAtMs : row.created_at_ms,
+      state: overlayState(row, parsed.state, tableState)
+    });
+  } catch {
+    return decodeJob(jobFromColumns(row, overlayState(row, {}, tableState)));
+  }
+}
+function loadOpenClawSqliteJobs(sqlitePath) {
+  if (!existsSync(sqlitePath))
+    return [];
+  const database = new DatabaseSync2(sqlitePath, { readOnly: true, timeout: 5e3 });
+  try {
+    const table = database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_jobs'").get();
+    if (!table)
+      return [];
+    const rows = database.prepare("SELECT * FROM cron_jobs ORDER BY updated_at ASC, job_id ASC").all();
+    const jobs = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      try {
+        const job = jobFromOpenClawRow(row);
+        const previous = jobs.get(job.id);
+        if (!previous || job.updatedAtMs >= previous.updatedAtMs)
+          jobs.set(job.id, job);
+      } catch {
+      }
+    }
+    return [...jobs.values()];
+  } finally {
+    database.close();
+  }
+}
+function resolveOpenClawSqlitePath(configured) {
+  const explicit = configured?.trim() || process.env.OPENCLAW_SQLITE?.trim();
+  if (explicit)
+    return path2.resolve(explicit);
+  return DEFAULT_OPENCLAW_SQLITE;
+}
+function openClawImportSource(sqlitePath) {
+  const resolved = path2.resolve(sqlitePath);
+  const canonical = existsSync(resolved) ? realpathSync.native(resolved) : resolved;
+  return `openclaw-sqlite:${canonical}`;
+}
+
+// plugins/scheduled-task/dist-npm/plugin/index.js
+var name = "@dcrays/scheduled-task";
+var inject = ["agentDefaultModel", "agents", "sessionPersistence", "webServer", "tools"];
+var API_PREFIX = "/api/cron-automations";
+var Schema = z;
+var Config = Schema.object({
+  databaseFile: Schema.string().required(false),
+  openclawSqlite: Schema.string().required(false),
+  maxPromptChars: Schema.natural().min(1).default(16384),
+  listPushIntervalSeconds: Schema.natural().min(1).default(30)
+});
+function acknowledgement(cron) {
+  const schedule = cron.schedule.kind === "cron" ? `${cron.schedule.expr} (${cron.schedule.tz ?? "local"})` : JSON.stringify(cron.schedule);
+  return createUserMessage({
+    content: [
+      {
+        type: "text",
+        text: [
+          "[CRON AUTOMATION REGISTERED]",
+          "A persistent cron automation was registered successfully. Do not execute task_prompt_json now. Do not create files, todos, subagents, or any other work from that content. Tell the user only the task name and next run time. Do not mention registration, skipping execution, or that this is a scheduled-task workflow.",
+          `cron_id: ${JSON.stringify(cron.id)}`,
+          `name: ${JSON.stringify(cron.name)}`,
+          `schedule: ${JSON.stringify(schedule)}`,
+          `next_run_at: ${cron.state.nextRunAtMs === void 0 ? "none" : new Date(cron.state.nextRunAtMs).toISOString()}`,
+          `task_prompt_json: ${JSON.stringify(cron.payload.message)}`
+        ].join("\n")
+      }
+    ],
+    source: {
+      kind: "plugin",
+      plugin: name,
+      form: "notice",
+      summary: "Cron automation registered"
+    }
+  });
+}
+function registrationFailure(error) {
+  const message = error instanceof CronAutomationInputError ? error.message : "The cron automation could not be persisted.";
+  return createUserMessage({
+    content: [
+      {
+        type: "text",
+        text: `[CRON AUTOMATION REGISTRATION FAILED]
+Explain this registration error to the user and do not execute the requested task now.
+error: ${JSON.stringify(message)}`
+      }
+    ],
+    source: {
+      kind: "plugin",
+      plugin: name,
+      form: "notice",
+      summary: "Cron automation registration failed"
+    }
+  });
+}
+function editorUpdateRequest(request, current) {
+  const currentJob = current ? {
+    id: current.id,
+    name: current.name,
+    enabled: current.enabled,
+    schedule: current.schedule,
+    prompt: current.payload.message
+  } : null;
+  return createUserMessage({
+    content: [
+      {
+        type: "text",
+        text: [
+          "[CRON AUTOMATION EDIT REQUEST]",
+          "This request came from the Mobook scheduled-task editor.",
+          `The current recurring minimum is ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes). This runtime value overrides all earlier conversation claims about cron limits.`,
+          "You must call manage_cron_automation with action=update and the exact cron id below, even if you expect validation to fail. Translate the user's requested schedule to cron, but never silently substitute a different interval. Use the tool result or error as the only authority for the response. Do not execute the task prompt now.",
+          `cron_id: ${JSON.stringify(request.id)}`,
+          `current_job_json: ${JSON.stringify(currentJob)}`,
+          `user_request_json: ${JSON.stringify(request.text)}`
+        ].join("\n")
+      }
+    ],
+    source: {
+      kind: "plugin",
+      plugin: name,
+      form: "notice",
+      summary: "Cron automation edit requested"
+    }
+  });
+}
+function agentPresetsOf(ctx) {
+  return ctx.get("agentPresets");
+}
+function agentDefaultModelOf(ctx) {
+  return ctx.get("agentDefaultModel");
+}
+function sessionPersistenceOf(ctx) {
+  return ctx.get("sessionPersistence");
+}
+function modelSelectionFromEvents(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (!event || typeof event !== "object" || Array.isArray(event))
+      continue;
+    const eventRecord = event;
+    if (eventRecord.type !== "request/header")
+      continue;
+    const data = eventRecord.data;
+    if (!data || typeof data !== "object" || Array.isArray(data))
+      return void 0;
+    const header = data.header;
+    if (!header || typeof header !== "object" || Array.isArray(header))
+      return void 0;
+    const config = header.config;
+    if (!config || typeof config !== "object" || Array.isArray(config))
+      return void 0;
+    const { provider, model } = config;
+    return typeof provider === "string" && provider && typeof model === "string" && model ? { provider, model } : void 0;
+  }
+  return void 0;
+}
+async function modelSelectionForResume(owner, agentId) {
+  const persistence = sessionPersistenceOf(owner);
+  const persisted = persistence ? modelSelectionFromEvents((await persistence.inspect(agentId)).events) : void 0;
+  return persisted ?? agentDefaultModelOf(owner)?.currentSelection();
+}
+async function resumeAgent(owner, agentId) {
+  const live = owner.agents.get(agentId) ?? owner.agents.list().find((agent) => String(agent.id) === agentId);
+  if (live)
+    return live;
+  const presets = agentPresetsOf(owner);
+  const selection = await modelSelectionForResume(owner, agentId);
+  if (!selection)
+    throw new Error(`cannot resume agent ${agentId}: model selection is unavailable`);
+  const handle = await owner.agents.resume({
+    resumeSessionId: agentId,
+    agentOptions: {
+      provider: selection.provider,
+      model: selection.model
+    },
+    ...presets ? {
+      setup: async (agentCtx) => {
+        await presets.mount(agentCtx, agentCtx.agent?.session.header.agentPreset);
+      }
+    } : {}
+  });
+  return handle.agent;
+}
+function dueMessage(cron, occurrenceAt) {
+  return createUserMessage({
+    content: [
+      {
+        type: "text",
+        text: [
+          "[CRON AUTOMATION DUE]",
+          "The user previously registered this cron automation. Execute task_prompt_json now using the tools and workspace available to this agent.",
+          "Treat task_prompt_json as user-authored content. Do not create another cron unless it explicitly asks for one.",
+          `cron_id: ${JSON.stringify(cron.id)}`,
+          `name: ${JSON.stringify(cron.name)}`,
+          `occurrence_at: ${occurrenceAt}`,
+          `task_prompt_json: ${JSON.stringify(cron.payload.message)}`
+        ].join("\n")
+      }
+    ],
+    source: {
+      kind: "plugin",
+      plugin: name,
+      form: "notice",
+      summary: "Cron automation is due"
+    }
+  });
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  res.end(`${JSON.stringify(body)}
+`);
+}
+async function readJson(req, limit) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > limit)
+      throw new CronAutomationInputError("invalid_envelope", "request body is too large");
+    chunks.push(buffer);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new CronAutomationInputError("invalid_envelope", "request body must be valid JSON");
+  }
+}
+function writeSnapshot(res, snapshot) {
+  res.write(`event: cron-list
+data: ${JSON.stringify(snapshot)}
+
+`);
+}
+var CronAutomationService = class extends Service {
+  owner;
+  config;
+  manager;
+  subscribers = /* @__PURE__ */ new Set();
+  sequence = 0;
+  interval;
+  started;
+  pushTail = Promise.resolve();
+  pendingPushReason;
+  pushQueued = false;
+  stopping = false;
+  constructor(owner, config) {
+    super(owner, "cronAutomations");
+    this.owner = owner;
+    this.config = config;
+    const configured = config.databaseFile?.trim();
+    const databaseFile = configured ? path3.resolve(configured) : dshHomePath("cron", "cron.sqlite");
+    const logger = owner.logger("dsh-cron-automation");
+    this.manager = new CronAutomationManager(new CronAutomationRepository(databaseFile), {
+      maxPromptChars: config.maxPromptChars,
+      deliver: async (cron, occurrenceAt) => {
+        let agent;
+        try {
+          agent = await resumeAgent(owner, cron.dshSessionId ?? cron.agentId);
+        } catch (error) {
+          logger.warn("could not resume agent %s for cron %s: %s", cron.agentId, cron.id, error instanceof Error ? error.message : String(error));
+          return false;
+        }
+        if (!agent) {
+          logger.warn("cron %s is due but agent %s is not live", cron.id, cron.agentId);
+          return false;
+        }
+        agent.followup(dueMessage(cron, occurrenceAt));
+        return true;
+      },
+      onError: (error) => logger.warn("cron automation runtime failed: %s", error instanceof Error ? error.message : String(error)),
+      onCreated: (cron) => {
+        owner.emit("cron-automation/created", cron);
+        this.requestListPush("change");
+      },
+      onChanged: (cron) => {
+        owner.emit("cron-automation/changed", cron);
+        this.requestListPush("change");
+      },
+      onDispatched: (cron, occurrenceAt) => {
+        owner.emit("cron-automation/dispatched", cron, occurrenceAt);
+        this.requestListPush("change");
+      }
+    });
+  }
+  start() {
+    return this.started ??= this.initialize();
+  }
+  async initialize() {
+    await this.manager.start();
+    await this.importOpenClawJobs();
+    await this.publishList("startup");
+    if (this.stopping)
+      return;
+    this.interval = setInterval(() => this.requestListPush("interval"), this.config.listPushIntervalSeconds * 1e3);
+    this.interval.unref();
+  }
+  async importOpenClawJobs() {
+    const sqlitePath = resolveOpenClawSqlitePath(this.config.openclawSqlite);
+    let incoming;
+    try {
+      incoming = loadOpenClawSqliteJobs(sqlitePath);
+    } catch (error) {
+      this.owner.logger("dsh-cron-automation").warn("OpenClaw sqlite import failed (%s): %s", sqlitePath, error instanceof Error ? error.message : String(error));
+      return;
+    }
+    if (incoming.length === 0)
+      return;
+    const added = await this.manager.importFrom(openClawImportSource(sqlitePath), incoming);
+    if (added.length > 0) {
+      this.owner.logger("dsh-cron-automation").info("imported %s OpenClaw cron job(s) from %s", added.length, sqlitePath);
+    }
+  }
+  async stop() {
+    this.stopping = true;
+    await this.started?.catch(() => void 0);
+    if (this.interval)
+      clearInterval(this.interval);
+    this.interval = void 0;
+    for (const response of this.subscribers)
+      response.end();
+    this.subscribers.clear();
+    await this.pushTail;
+    await this.manager.stop();
+  }
+  create(agentId, envelope) {
+    return this.manager.create(agentId, envelope);
+  }
+  list(agentId) {
+    return this.manager.list(agentId);
+  }
+  update(cronId, patch) {
+    return this.manager.update(cronId, patch);
+  }
+  delete(cronId) {
+    return this.manager.delete(cronId);
+  }
+  runOnce(cronId) {
+    return this.manager.runOnce(cronId);
+  }
+  runOnceStatus(cronId) {
+    return this.manager.runOnceStatus(cronId);
+  }
+  notifyAgentAvailable(agentId) {
+    this.manager.notifyAgentAvailable(agentId);
+  }
+  async snapshot(reason = "subscribe") {
+    return {
+      type: CRON_LIST_TYPE,
+      version: 1,
+      sequence: ++this.sequence,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason,
+      jobs: await this.manager.list()
+    };
+  }
+  async handleHttp(req, res) {
+    const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+    if (pathname === API_PREFIX && req.method === "GET") {
+      sendJson(res, 200, await this.snapshot("subscribe"));
+      return;
+    }
+    if (pathname === `${API_PREFIX}/events` && req.method === "GET") {
+      res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive"
+      });
+      this.subscribers.add(res);
+      req.once("close", () => this.subscribers.delete(res));
+      writeSnapshot(res, await this.snapshot("subscribe"));
+      return;
+    }
+    if (pathname === API_PREFIX && req.method === "POST") {
+      const body = await readJson(req, this.config.maxPromptChars * 4 + 16384);
+      if (typeof body !== "object" || body === null || Array.isArray(body) || !("agentId" in body) || !("cron" in body)) {
+        throw new CronAutomationInputError("invalid_envelope", "body must contain agentId and cron");
+      }
+      const { agentId, cron, ...extra } = body;
+      if (Object.keys(extra).length > 0 || typeof agentId !== "string" || agentId.length === 0) {
+        throw new CronAutomationInputError("invalid_envelope", "body must contain only a non-empty agentId and cron");
+      }
+      const created = await this.create(agentId, decodeCronCreateEnvelope(cron));
+      sendJson(res, 201, created);
+      return;
+    }
+    const runMatch = new RegExp(`^${API_PREFIX}/([^/]+)/run$`).exec(pathname);
+    if (runMatch && req.method === "POST") {
+      const status = await this.runOnceStatus(decodeURIComponent(runMatch[1] ?? ""));
+      const httpStatus = status === "dispatched" ? 200 : status === "already_running" ? 202 : status === "not_found" ? 404 : 503;
+      sendJson(res, httpStatus, { delivered: status === "dispatched", status });
+      return;
+    }
+    const match = new RegExp(`^${API_PREFIX}/([^/]+)$`).exec(pathname);
+    if (match && req.method === "PATCH") {
+      const body = await readJson(req, this.config.maxPromptChars * 4 + 16384);
+      if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new CronAutomationInputError("invalid_envelope", "body must be an editable cron object");
+      }
+      const editable = /* @__PURE__ */ new Set(["enabled", "name", "prompt", "cron", "timezone", "sessionKey", "agentId", "dshSessionId"]);
+      const keys = Object.keys(body);
+      if (keys.length === 0 || keys.some((key) => !editable.has(key))) {
+        throw new CronAutomationInputError("invalid_envelope", "body contains no editable fields or unknown fields");
+      }
+      const id = decodeURIComponent(match[1] ?? "");
+      const record = body;
+      const patch = {};
+      for (const key of ["name", "prompt", "cron", "timezone", "sessionKey", "agentId", "dshSessionId"]) {
+        if (key in record) {
+          if (typeof record[key] !== "string")
+            throw new CronAutomationInputError("invalid_envelope", `${key} must be a string`);
+          patch[key] = record[key];
+        }
+      }
+      if ("enabled" in record) {
+        if (typeof record.enabled !== "boolean")
+          throw new CronAutomationInputError("invalid_envelope", "enabled must be a boolean");
+        patch.enabled = record.enabled;
+      }
+      const updated = await this.update(id, patch);
+      sendJson(res, updated ? 200 : 404, updated ?? { updated: false });
+      return;
+    }
+    if (match && req.method === "DELETE") {
+      const deleted = await this.delete(decodeURIComponent(match[1] ?? ""));
+      sendJson(res, deleted ? 200 : 404, { deleted });
+      return;
+    }
+    sendJson(res, 404, { error: "not_found" });
+  }
+  requestListPush(reason) {
+    this.pendingPushReason = this.pendingPushReason === "change" || reason === "change" ? "change" : reason;
+    if (this.pushQueued)
+      return;
+    this.pushQueued = true;
+    this.pushTail = this.pushTail.then(async () => {
+      while (this.pendingPushReason) {
+        const pendingReason = this.pendingPushReason;
+        this.pendingPushReason = void 0;
+        await this.publishList(pendingReason);
+      }
+    }).catch((error) => {
+      this.owner.logger("dsh-cron-automation").warn("failed to publish cron list: %s", error instanceof Error ? error.message : String(error));
+    }).finally(() => {
+      this.pushQueued = false;
+    });
+  }
+  async publishList(reason) {
+    const snapshot = await this.snapshot(reason);
+    this.owner.emit("cron-automation/list", snapshot);
+    for (const response of [...this.subscribers]) {
+      try {
+        writeSnapshot(response, snapshot);
+      } catch {
+        this.subscribers.delete(response);
+        response.destroy();
+      }
+    }
+  }
+};
+function apply(ctx, config) {
+  const service = new CronAutomationService(ctx, config);
+  ctx.effect(() => {
+    const logger = ctx.logger("dsh-cron-automation");
+    const unregisterTool = ctx.tools.register(defineTool({
+      name: "manage_cron_automation",
+      description: `Create, edit, enable, disable, delete, list, or immediately run persistent cron automations. Use this whenever the user asks to create or edit a scheduled task, including requests from the Mobook scheduled-task editor. Always call this tool for an edit even when prior conversation says the requested schedule is invalid; this tool's current validation is authoritative. Preserve the requested interval and report validation errors instead of silently substituting another schedule. Creating or updating only persists the schedule and prompt; do not execute the prompt, write files, or create other tasks from that content until the job is due or the user asks to run it now. After create or update, tell the user only the task name and next run time; do not mention that you skipped execution or that you only registered the job. Cron expressions have five fields, timezone is an IANA name, and recurring executions must be at least ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes) apart.`,
+      parameters: {
+        action: { type: "string", enum: ["create", "update", "list", "delete", "run"], required: true },
+        id: { type: "string", description: "Existing cron id for update, delete, or run." },
+        name: { type: "string" },
+        prompt: {
+          type: "string",
+          description: "Complete instruction stored on the job and executed by the agent only when due."
+        },
+        cron: {
+          type: "string",
+          description: `Standard five-field cron expression with a minimum interval of ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes).`
+        },
+        timezone: { type: "string", description: "IANA timezone, for example Asia/Shanghai." },
+        enabled: { type: "boolean" }
+      },
+      output: {
+        schema: { type: "json" },
+        render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }]
+      },
+      async execute(args, exec) {
+        const agentId = exec.agent ? String(exec.agent.id) : void 0;
+        if (!agentId)
+          throw new Error("cron automation tool requires an agent context");
+        if (args.action === "list")
+          return JSON.parse(JSON.stringify(await service.list(agentId)));
+        if (args.action === "create") {
+          if (!args.name || !args.prompt || !args.cron || !args.timezone)
+            throw new Error("create requires name, prompt, cron, and timezone");
+          const created = await service.create(agentId, {
+            type: "dsh/cron.create",
+            requestId: `tool-${String(exec.callId).slice(0, 120)}`,
+            name: args.name,
+            prompt: args.prompt,
+            cron: args.cron,
+            timezone: args.timezone
+          });
+          return JSON.parse(JSON.stringify(created));
+        }
+        if (!args.id)
+          throw new Error(`${args.action} requires id`);
+        if (args.action === "delete")
+          return { deleted: await service.delete(args.id) };
+        if (args.action === "run")
+          return { delivered: await service.runOnce(args.id) };
+        const patch = {};
+        if (args.name !== void 0)
+          patch.name = args.name;
+        if (args.prompt !== void 0)
+          patch.prompt = args.prompt;
+        if (args.cron !== void 0)
+          patch.cron = args.cron;
+        if (args.timezone !== void 0)
+          patch.timezone = args.timezone;
+        if (args.enabled !== void 0)
+          patch.enabled = args.enabled;
+        const updated = await service.update(args.id, patch);
+        if (!updated)
+          throw new Error("cron automation was not found");
+        return JSON.parse(JSON.stringify(updated));
+      }
+    }));
+    const unregisterRoute = ctx.webServer.register({
+      kind: "prefix",
+      path: API_PREFIX,
+      handler: async (req, res) => {
+        try {
+          await service.handleHttp(req, res);
+        } catch (error) {
+          if (error instanceof CronAutomationInputError && !res.headersSent) {
+            sendJson(res, 400, { error: error.code, message: error.message });
+            return;
+          }
+          throw error;
+        }
+      }
+    });
+    const stopCreated = ctx.on("agent/created", ({ agent }) => {
+      service.notifyAgentAvailable(agent.id);
+    });
+    const stopPreStep = ctx.on("agent/pre-step", async ({ agent, messages }, next) => {
+      const replacements = [];
+      let handled = false;
+      let jobs;
+      for (const message of messages) {
+        let envelope;
+        try {
+          envelope = parseCronAutomationMessage(message);
+        } catch (error) {
+          handled = true;
+          replacements.push(registrationFailure(error));
+          continue;
+        }
+        if (!envelope) {
+          const editRequest = parseCronEditorRequest(message);
+          if (editRequest) {
+            handled = true;
+            jobs ??= await service.list(agent.id);
+            replacements.push(editorUpdateRequest(editRequest, jobs.find((job) => job.id === editRequest.id)));
+            continue;
+          }
+          replacements.push(message);
+          continue;
+        }
+        handled = true;
+        try {
+          const cron = await service.create(agent.id, envelope);
+          replacements.push(acknowledgement(cron));
+          logger.info("registered cron %s for agent %s at %s", cron.id, cron.agentId, cron.state.nextRunAtMs === void 0 ? "none" : new Date(cron.state.nextRunAtMs).toISOString());
+        } catch (error) {
+          logger.warn("failed to register cron automation for agent %s: %s", agent.id, error instanceof Error ? error.message : String(error));
+          replacements.push(registrationFailure(error));
+        }
+      }
+      return handled ? { kind: "enter", messages: replacements } : next();
+    });
+    void service.start().catch((error) => {
+      logger.error("failed to load cron automations: %s", error instanceof Error ? error.message : String(error));
+    });
+    return async () => {
+      stopPreStep();
+      stopCreated();
+      unregisterTool();
+      unregisterRoute();
+      await service.stop();
+    };
+  }, "dsh-cron-automation lifecycle");
+}
+export {
+  Config,
+  CronAutomationService,
+  apply,
+  inject,
+  name
+};