@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/lunr-cron-YJ5UHYRD.js

@@ -0,0 +1,268 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  createDeliverValidator,
+  createJob,
+  currentOrigin,
+  executeJob,
+  getJob,
+  listJobs,
+  parseSchedule,
+  pauseJob,
+  removeJob,
+  resumeJob,
+  setCronDeliverValidator,
+  startScheduler,
+  updateJob
+} from "./chunk-ECD5L7YI.js";
+import {
+  loadGatewayConfig
+} from "./chunk-RQ5DNUNG.js";
+import {
+  beginCronFire,
+  endCronFire,
+  isCronFire
+} from "./chunk-CJECDQKP.js";
+import {
+  typebox_exports
+} from "./chunk-PL6JKXWI.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/lunr-cron.js
+var pendingRun = null, scheduler = null, lastCtx = null, DELIVERY_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/cron-delivery");
+function extractAssistantText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    let msg = messages[i];
+    if (msg?.role !== "assistant")
+      continue;
+    let text = (Array.isArray(msg.content) ? msg.content : []).filter((p) => p?.type === "text").map((p) => String(p.text ?? "")).join("").trim();
+    if (text)
+      return text;
+  }
+  return "";
+}
+function fmtTime(iso) {
+  if (!iso)
+    return "-";
+  let d = new Date(iso);
+  if (Number.isNaN(d.getTime()))
+    return "-";
+  let p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+function formatJobList() {
+  let jobs = listJobs();
+  if (jobs.length === 0)
+    return "No cron jobs. Create one with /cron create <schedule> <prompt>.";
+  let lines = jobs.map((j) => `${j.id}  ${j.state}${j.enabled ? "" : " (disabled)"}  ${j.scheduleDisplay}  next=${fmtTime(j.nextRunAt)}  last=${j.lastStatus ?? "-"}${j.lastError ? ` (${j.lastError})` : ""}  ${j.name}`);
+  return `Cron jobs (${jobs.length}):
+${lines.join(`
+`)}`;
+}
+function formatStatus() {
+  let jobs = listJobs(), count = (s) => jobs.filter((j) => j.state === s).length, next = jobs.filter((j) => j.enabled && j.state === "scheduled" && j.nextRunAt).sort((a, b) => String(a.nextRunAt).localeCompare(String(b.nextRunAt)))[0];
+  return `Cron: scheduler ${scheduler ? "running" : "stopped"}; ${jobs.length} job(s) \u2014 ${count("scheduled")} scheduled, ${count("paused")} paused, ${count("completed")} completed, ${count("error")} error.` + (next ? ` Next: '${next.name}' at ${fmtTime(next.nextRunAt)}.` : "");
+}
+function lunr_cron_default(pi) {
+  setCronDeliverValidator(createDeliverValidator(loadGatewayConfig())), globalThis[DELIVERY_BRIDGE_SYMBOL] = async (job, _content) => {
+    try {
+      return lastCtx?.ui.notify(`Cron job '${job.name}' finished`, "info"), null;
+    } catch (err) {
+      return String(err?.message ?? err);
+    }
+  };
+  let schedulerDeps = { runJob: (prompt, _job) => pendingRun ? Promise.reject(new Error("another cron job turn is already in flight")) : new Promise((resolve, reject) => {
+    beginCronFire(), pendingRun = { resolve, reject };
+    try {
+      pi.sendUserMessage(prompt);
+    } catch (err) {
+      pendingRun = null, endCronFire(), reject(err);
+    }
+  }), deliverResult: async (job, content) => {
+    let bridge = globalThis[DELIVERY_BRIDGE_SYMBOL];
+    if (!bridge)
+      throw new Error("no cron delivery bridge registered");
+    let err = await bridge(job, content);
+    if (err)
+      throw new Error(String(err));
+  } }, triggerRun = async (job, ctx) => {
+    if (ctx.isIdle())
+      try {
+        return await executeJob(getJob(job.id), schedulerDeps), `Cron job '${job.name}' (${job.id}) finished.`;
+      } catch (err) {
+        return `Cron job '${job.name}' (${job.id}) failed: ${String(err?.message ?? err)}`;
+      }
+    return await updateJob(job.id, { nextRunAt: (/* @__PURE__ */ new Date()).toISOString() }), `Cron job '${job.name}' (${job.id}) queued for the next scheduler tick.`;
+  };
+  pi.on("agent_end", (event) => {
+    if (!pendingRun)
+      return;
+    let pending = pendingRun;
+    pendingRun = null, endCronFire(), pending.resolve(extractAssistantText(event.messages ?? []));
+  }), pi.on("session_start", (_event, ctx) => {
+    lastCtx = ctx, ctx.mode === "tui" && (scheduler?.stop(), scheduler = startScheduler(schedulerDeps));
+  }), pi.on("session_shutdown", () => {
+    scheduler?.stop(), scheduler = null;
+  }), pi.registerCommand("cron", {
+    description: "Manage cron jobs: /cron list | create <schedule> <prompt> | pause|resume|run|remove <id-or-name> | status",
+    getArgumentCompletions: (prefix) => {
+      let subs = ["list", "create", "pause", "resume", "run", "remove", "status"], lower = prefix.toLowerCase();
+      return subs.filter((s) => s.startsWith(lower)).map((s) => ({ value: s, label: s, description: `/cron ${s}` }));
+    },
+    handler: async (args, ctx) => {
+      lastCtx = ctx;
+      let tokens = args.trim().split(/\s+/).filter(Boolean), sub = (tokens.shift() ?? "list").toLowerCase();
+      try {
+        switch (sub) {
+          case "list": {
+            ctx.ui.notify(formatJobList(), "info");
+            return;
+          }
+          case "status": {
+            ctx.ui.notify(formatStatus(), "info");
+            return;
+          }
+          case "create": {
+            let used = 0;
+            for (let k = 1; k <= Math.min(6, tokens.length); k++)
+              try {
+                parseSchedule(tokens.slice(0, k).join(" ")), used = k;
+                break;
+              } catch {
+              }
+            let prompt = tokens.slice(used).join(" ").trim();
+            if (!used || !prompt) {
+              ctx.ui.notify("Usage: /cron create <schedule> <prompt> \u2014 e.g. /cron create every 30m check the deploy", "error");
+              return;
+            }
+            let job = await createJob({ prompt, schedule: tokens.slice(0, used).join(" ") });
+            ctx.ui.notify(`Created cron job '${job.name}' (${job.id}) \u2014 ${job.scheduleDisplay}, next run ${fmtTime(job.nextRunAt)}.`, "info");
+            return;
+          }
+          case "pause":
+          case "resume":
+          case "remove":
+          case "run": {
+            let idOrName = tokens.join(" ").trim();
+            if (!idOrName) {
+              ctx.ui.notify(`Usage: /cron ${sub} <id-or-name>`, "error");
+              return;
+            }
+            if (sub === "pause") {
+              let job = await pauseJob(idOrName);
+              ctx.ui.notify(`Paused cron job '${job.name}' (${job.id}).`, "info");
+            } else if (sub === "resume") {
+              let job = await resumeJob(idOrName);
+              ctx.ui.notify(`Resumed cron job '${job.name}' (${job.id}) \u2014 next run ${fmtTime(job.nextRunAt)}.`, "info");
+            } else if (sub === "remove") {
+              let job = await removeJob(idOrName);
+              ctx.ui.notify(`Removed cron job '${job.name}' (${job.id}).`, "info");
+            } else {
+              let job = getJob(idOrName);
+              ctx.ui.notify(await triggerRun(job, ctx), "info");
+            }
+            return;
+          }
+          default:
+            ctx.ui.notify("Usage: /cron list | create <schedule> <prompt> | pause|resume|run|remove <id-or-name> | status", "error");
+        }
+      } catch (err) {
+        ctx.ui.notify(String(err?.message ?? err), "error");
+      }
+    }
+  }), pi.registerTool({
+    name: "cron",
+    label: "Cron",
+    description: [
+      "Manage scheduled cron jobs that run prompts unattended in this session.",
+      "Actions: create (needs prompt + schedule), list, update (id + fields), pause, resume, remove, run (trigger now).",
+      "Schedule formats: 'every 30m' / 'every 2h' / 'every 1d' (recurring), '30m'/'2h' or an ISO timestamp (one-shot), or a 5-field cron expression.",
+      "Job output is delivered automatically; the job's prompt can answer [SILENT] to suppress delivery."
+    ].join(`
+`),
+    parameters: typebox_exports.Object({
+      action: typebox_exports.Union([
+        typebox_exports.Literal("create"),
+        typebox_exports.Literal("list"),
+        typebox_exports.Literal("update"),
+        typebox_exports.Literal("pause"),
+        typebox_exports.Literal("resume"),
+        typebox_exports.Literal("remove"),
+        typebox_exports.Literal("run")
+      ]),
+      id: typebox_exports.Optional(typebox_exports.String({ description: "Job id or unique name (all actions except create/list)." })),
+      name: typebox_exports.Optional(typebox_exports.String({ description: "Display name (<=50 chars); derived from the prompt when omitted." })),
+      prompt: typebox_exports.Optional(typebox_exports.String({ description: "The prompt the job runs (create/update)." })),
+      schedule: typebox_exports.Optional(typebox_exports.String({ description: "Schedule input (create/update)." })),
+      deliver: typebox_exports.Optional(typebox_exports.String({
+        description: "Delivery target(s), comma-separated: 'local' (output file only), 'origin' (the chat that created the job), 'telegram'/'discord' (platform home channel), or 'telegram:<chatId>[:<threadId>]' / 'discord:<chatId>[:<threadId>]'. Defaults to 'origin' when created from a gateway chat, else 'local'."
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      let text = (t) => ({ content: [{ type: "text", text: t }] });
+      if (isCronFire())
+        return text("cron: unavailable while a cron-fired turn is running (cron jobs cannot schedule cron jobs).");
+      try {
+        switch (params.action) {
+          case "create": {
+            if (!params.prompt?.trim() || !params.schedule?.trim())
+              return text("cron create: prompt and schedule are required.");
+            let origin = currentOrigin(), job = await createJob({
+              prompt: params.prompt,
+              schedule: params.schedule,
+              name: params.name,
+              deliver: params.deliver ?? (origin ? "origin" : void 0),
+              origin: origin ? { ...origin } : void 0
+            });
+            return text(`Created cron job '${job.name}' (${job.id}) \u2014 ${job.scheduleDisplay}, next run ${fmtTime(job.nextRunAt)}.`);
+          }
+          case "list":
+            return text(formatJobList());
+          case "update": {
+            if (!params.id)
+              return text("cron update: id (or unique name) is required.");
+            let job = await updateJob(params.id, {
+              name: params.name,
+              prompt: params.prompt,
+              schedule: params.schedule,
+              deliver: params.deliver
+            });
+            return text(`Updated cron job '${job.name}' (${job.id}) \u2014 ${job.scheduleDisplay}, next run ${fmtTime(job.nextRunAt)}.`);
+          }
+          case "pause": {
+            if (!params.id)
+              return text("cron pause: id (or unique name) is required.");
+            let job = await pauseJob(params.id);
+            return text(`Paused cron job '${job.name}' (${job.id}).`);
+          }
+          case "resume": {
+            if (!params.id)
+              return text("cron resume: id (or unique name) is required.");
+            let job = await resumeJob(params.id);
+            return text(`Resumed cron job '${job.name}' (${job.id}) \u2014 next run ${fmtTime(job.nextRunAt)}.`);
+          }
+          case "remove": {
+            if (!params.id)
+              return text("cron remove: id (or unique name) is required.");
+            let job = await removeJob(params.id);
+            return text(`Removed cron job '${job.name}' (${job.id}).`);
+          }
+          case "run": {
+            if (!params.id)
+              return text("cron run: id (or unique name) is required.");
+            let job = getJob(params.id);
+            return text(await triggerRun(job, ctx));
+          }
+          default:
+            return text(`cron: unknown action "${String(params.action)}".`);
+        }
+      } catch (err) {
+        return text(`cron: ${String(err?.message ?? err)}`);
+      }
+    }
+  });
+}
+export {
+  lunr_cron_default as default
+};

package/dist/node-runtime/main.js

@@ -0,0 +1,54 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  main,
+  readPipedStdin
+} from "./chunk-N77MY65L.js";
+import "./chunk-PCGNAY2O.js";
+import "./chunk-IPA627GP.js";
+import "./chunk-2QKLKMKC.js";
+import "./chunk-EDBJNRSM.js";
+import "./chunk-WOVTOV5P.js";
+import "./chunk-TQNSPERU.js";
+import "./chunk-PGAJ5MO5.js";
+import "./chunk-OBMWP3I5.js";
+import "./chunk-DVGWF6A2.js";
+import "./chunk-QFWG2RVL.js";
+import "./chunk-CGBXPL3E.js";
+import "./chunk-ZKMFUD3Q.js";
+import "./chunk-AD6VXAO7.js";
+import "./chunk-LZAW4ZX3.js";
+import "./chunk-M3LZLQW2.js";
+import "./chunk-53YJI7JU.js";
+import "./chunk-GZQHMEWL.js";
+import "./chunk-ZCHMJ34K.js";
+import "./chunk-AJX357CL.js";
+import "./chunk-PBC2Y6GS.js";
+import "./chunk-FVDOXRUD.js";
+import "./chunk-AHSTJBIB.js";
+import "./chunk-W3CVH5RX.js";
+import "./chunk-YF63P5ZT.js";
+import "./chunk-PL6JKXWI.js";
+import "./chunk-RQ2Q5IYR.js";
+import "./chunk-JHYKXIMM.js";
+import "./chunk-H2EOZYMP.js";
+import "./chunk-PVCDKGR6.js";
+import "./chunk-OR4L3IB2.js";
+import "./chunk-HQCKFM2O.js";
+import "./chunk-AY6CAJSL.js";
+import "./chunk-DDGMHUOW.js";
+import "./chunk-CCZJ3PYY.js";
+import "./chunk-MJQDX3BA.js";
+import "./chunk-MGWCVY6Y.js";
+import "./chunk-I6R76AG7.js";
+import "./chunk-5P7PZMRU.js";
+import "./chunk-YSKSB3BJ.js";
+import "./chunk-3GHXVUAK.js";
+import "./chunk-C4O2RSQQ.js";
+import "./chunk-MX3GJNXJ.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  main,
+  readPipedStdin
+};

package/dist/node-runtime/mcp-auth-flow-QIXHW6QN.js

@@ -0,0 +1,32 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  authenticate,
+  completeAuth,
+  completeAuthFromInput,
+  extractOAuthConfig,
+  getAuthStatus,
+  getValidToken,
+  initializeOAuth,
+  parseAuthorizationCodeInput,
+  removeAuth,
+  shutdownOAuth,
+  startAuth,
+  supportsOAuth
+} from "./chunk-4TLO4PO2.js";
+import "./chunk-4HXHDDCF.js";
+import "./chunk-BI3DHYCN.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  authenticate,
+  completeAuth,
+  completeAuthFromInput,
+  extractOAuthConfig,
+  getAuthStatus,
+  getValidToken,
+  initializeOAuth,
+  parseAuthorizationCodeInput,
+  removeAuth,
+  shutdownOAuth,
+  startAuth,
+  supportsOAuth
+};