niahere 0.2.49 → 0.2.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.49",
+  "version": "0.2.51",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/src/cli/job.ts

@@ -144,26 +144,28 @@ export async function jobCommand(): Promise<void> {
     }
 
     case "update": {
-      const always = process.argv.includes("--always");
-      let cliArgs = process.argv.slice(4).filter((a) => a !== "--always");
+      const hasAlways = process.argv.includes("--always");
+      const hasNoAlways = process.argv.includes("--no-always");
+      let cliArgs = process.argv.slice(4).filter((a) => a !== "--always" && a !== "--no-always");
 
       const name = cliArgs[0];
       if (!name) {
-        console.log('Usage: nia job update <name> [--schedule <schedule>] [--prompt <prompt>] [--always]');
+        console.log('Usage: nia job update <name> [--schedule <schedule>] [--prompt <prompt>] [--always] [--no-always]');
         fail('Example: nia job update curator --schedule "4h" --prompt "New prompt"');
       }
 
       const scheduleIdx = cliArgs.indexOf("--schedule");
       const schedule = scheduleIdx !== -1 ? cliArgs[scheduleIdx + 1] : undefined;
       const promptIdx = cliArgs.indexOf("--prompt");
-      const prompt = promptIdx !== -1 ? cliArgs.slice(promptIdx + 1).filter((a) => a !== "--always" && a !== "--schedule" && a !== schedule).join(" ") : undefined;
+      const prompt = promptIdx !== -1 ? cliArgs.slice(promptIdx + 1).filter((a) => a !== "--schedule" && a !== schedule).join(" ") : undefined;
 
       try {
         await withDb(async () => {
           const fields: Partial<{ schedule: string; prompt: string; always: boolean }> = {};
           if (schedule) fields.schedule = schedule;
           if (prompt) fields.prompt = prompt;
-          if (always) fields.always = always;
+          if (hasAlways) fields.always = true;
+          if (hasNoAlways) fields.always = false;
 
           const updated = await Job.update(name, fields);
           if (!updated) fail(`Job not found: "${name}". Use \`nia job list\` to see available jobs.`);

package/src/core/scheduler.ts

@@ -79,10 +79,10 @@ async function tick(): Promise<void> {
 
   for (const job of dueJobs) {
     if (!job.always && !isWithinActiveHours()) {
-      const nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
-      if (nextRun) {
-        await Job.markRun(job.name, nextRun).catch(() => {});
-      }
+      try {
+        const nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
+        if (nextRun) await Job.markRun(job.name, nextRun).catch(() => {});
+      } catch {}
       log.info({ job: job.name }, "scheduler: skipping — outside active hours");
       continue;
     }
@@ -95,7 +95,14 @@ async function tick(): Promise<void> {
       log.error({ err, job: job.name }, "scheduler: job failed");
     });
 
-    const nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
+    let nextRun: Date | null = null;
+    try {
+      nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
+    } catch (err) {
+      log.error({ err, job: job.name, schedule: job.schedule }, "scheduler: invalid schedule, disabling job");
+      await Job.update(job.name, { enabled: false }).catch(() => {});
+      continue;
+    }
     await Job.markRun(job.name, nextRun).catch((err) => {
       log.error({ err, job: job.name }, "scheduler: failed to update next_run_at");
     });

package/src/db/models/job.ts

@@ -1,6 +1,35 @@
 import { getSql } from "../connection";
+import { CronExpressionParser } from "cron-parser";
+import { parseDuration } from "../../utils/duration";
 import type { ScheduleType } from "../../types";
 
+/** Validate that a schedule string matches its declared type. Throws on mismatch. */
+function validateSchedule(schedule: string, scheduleType: ScheduleType): void {
+  switch (scheduleType) {
+    case "cron":
+      try {
+        CronExpressionParser.parse(schedule);
+      } catch (err) {
+        throw new Error(`Invalid cron expression "${schedule}": ${err instanceof Error ? err.message : err}`);
+      }
+      break;
+    case "interval":
+      try {
+        parseDuration(schedule);
+      } catch (err) {
+        throw new Error(`Invalid interval "${schedule}": ${err instanceof Error ? err.message : err}`);
+      }
+      break;
+    case "once": {
+      const d = new Date(schedule);
+      if (isNaN(d.getTime())) {
+        throw new Error(`Invalid timestamp "${schedule}": expected ISO 8601 date`);
+      }
+      break;
+    }
+  }
+}
+
 export interface Job {
   name: string;
   schedule: string;
@@ -45,6 +74,7 @@ export async function create(
   nextRunAt?: Date,
   agent?: string,
 ): Promise<void> {
+  validateSchedule(schedule, scheduleType);
   const existing = await get(name);
   if (existing) {
     throw new Error(`Job "${name}" already exists. Use \`nia job remove ${name}\` first, or choose a different name.`);
@@ -71,21 +101,26 @@ export async function get(name: string): Promise<Job | null> {
 
 export async function update(
   name: string,
-  fields: Partial<{ schedule: string; prompt: string; enabled: boolean; always: boolean; agent: string | null }>,
+  fields: Partial<{ schedule: string; prompt: string; enabled: boolean; always: boolean; agent: string | null; scheduleType: ScheduleType }>,
 ): Promise<boolean> {
   const sql = getSql();
   const existing = await get(name);
   if (!existing) return false;
 
   const schedule = fields.schedule ?? existing.schedule;
+  const scheduleType = fields.scheduleType ?? existing.scheduleType;
   const prompt = fields.prompt ?? existing.prompt;
   const enabled = fields.enabled ?? existing.enabled;
   const always = fields.always ?? existing.always;
   const agent = fields.agent !== undefined ? fields.agent : existing.agent;
 
+  if (fields.schedule || fields.scheduleType) {
+    validateSchedule(schedule, scheduleType);
+  }
+
   await sql`
     UPDATE jobs
-    SET schedule = ${schedule}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, updated_at = NOW()
+    SET schedule = ${schedule}, schedule_type = ${scheduleType}, prompt = ${prompt}, enabled = ${enabled}, always = ${always}, agent = ${agent}, updated_at = NOW()
     WHERE name = ${name}
   `;
   await notifyChange();

package/src/mcp/server.ts

@@ -32,13 +32,14 @@ export function createNiaMcpServer() {
       ),
       tool(
         "update_job",
-        "Update an existing job's schedule, prompt, always flag, or agent. Only pass fields you want to change.",
+        "Update an existing job's schedule, prompt, always flag, agent, or schedule_type. Only pass fields you want to change.",
         {
           name: z.string().describe("Job name to update"),
           schedule: z.string().optional().describe("New schedule (cron expression, interval duration, or ISO timestamp)"),
           prompt: z.string().optional().describe("New prompt"),
           always: z.boolean().optional().describe("If true, runs 24/7 ignoring active hours"),
           agent: z.string().nullable().optional().describe("Agent name (set null to remove agent)"),
+          schedule_type: z.enum(["cron", "interval", "once"]).optional().describe("Schedule type (must match the schedule format)"),
         },
         async (args) => ({
           content: [{ type: "text" as const, text: await handlers.updateJob(args) }],

package/src/mcp/tools.ts

@@ -40,14 +40,16 @@ export async function updateJob(args: {
   prompt?: string;
   always?: boolean;
   agent?: string | null;
+  schedule_type?: "cron" | "interval" | "once";
 }): Promise<string> {
-  const fields: Partial<{ schedule: string; prompt: string; always: boolean; agent: string | null }> = {};
+  const fields: Partial<{ schedule: string; prompt: string; always: boolean; agent: string | null; scheduleType: "cron" | "interval" | "once" }> = {};
   if (args.schedule) fields.schedule = args.schedule;
   if (args.prompt) fields.prompt = args.prompt;
   if (args.always !== undefined) fields.always = args.always;
   if (args.agent !== undefined) fields.agent = args.agent;
+  if (args.schedule_type) fields.scheduleType = args.schedule_type;
 
-  if (Object.keys(fields).length === 0) return "Nothing to update. Pass at least one field (schedule, prompt, always, or agent).";
+  if (Object.keys(fields).length === 0) return "Nothing to update. Pass at least one field (schedule, prompt, always, agent, or schedule_type).";
 
   const updated = await Job.update(args.name, fields);
   if (!updated) return `Job "${args.name}" not found.`;