niahere 0.3.2 → 0.3.4

package/src/channels/telegram.ts

@@ -1,4 +1,4 @@
-import { Bot, InputFile } from "grammy";
+import { Bot, type Context, InputFile } from "grammy";
 import { createHash } from "crypto";
 import { mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
@@ -26,6 +26,36 @@ class TelegramChannel implements Channel {
   name = "telegram" as const;
   private bot: Bot | null = null;
   private outboundChatId: number | null = null;
+  private isOpen = false;
+  private readonly chats = new Map<number, ChatState>();
+
+  async start(): Promise<void> {
+    const config = getConfig();
+    const token = config.channels.telegram.bot_token!;
+
+    await runMigrations();
+
+    this.outboundChatId = config.channels.telegram.chat_id;
+    this.isOpen = config.channels.telegram.open;
+
+    const bot = new Bot(token);
+    this.bot = bot;
+
+    bot.command("start", (ctx) => this.handleStart(ctx));
+    bot.command(["restart", "new"], (ctx) => this.handleRestart(ctx));
+    bot.on("message:text", (ctx) => this.handleText(ctx));
+    bot.on("message:photo", (ctx) => this.handlePhoto(ctx));
+    bot.on("message:document", (ctx) => this.handleDocument(ctx));
+
+    bot.start({ onStart: () => log.info("telegram bot polling started") });
+  }
+
+  async stop(): Promise<void> {
+    if (this.bot) {
+      this.bot.stop();
+      this.bot = null;
+    }
+  }
 
   async deliver(out: Outbound): Promise<void> {
     if (!this.bot) throw new Error("Telegram not started");
@@ -47,236 +77,211 @@ class TelegramChannel implements Channel {
     }
   }
 
-  private async downloadFile(fileId: string): Promise<Buffer> {
-    if (!this.bot) throw new Error("Telegram not started");
-    const file = await this.bot.api.getFile(fileId);
-    const token = getConfig().channels.telegram.bot_token!;
-    const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
-    const resp = await fetch(url);
-    if (!resp.ok) throw new Error(`Download failed: ${resp.status}`);
-    return Buffer.from(await resp.arrayBuffer());
+  // --- Inbound handlers ---
+
+  private async handleStart(ctx: Context): Promise<void> {
+    if (!ctx.chatId || !this.gate(ctx)) return;
+    this.registerOutbound(ctx.chatId);
+    const state = await this.getState(ctx.chatId);
+    this.withLock(ctx.chatId, () => this.processMessage(ctx, state, "hi"));
   }
 
-  private cacheAttachment(
-    chatId: number,
-    roomIndex: number,
-    data: Buffer,
-    mimeType: string,
-    filename?: string,
-  ): string {
-    const scope = `telegram-${chatId}-${roomIndex}`;
-    const dir = join(getNiaHome(), "tmp", "attachments", scope);
-    mkdirSync(dir, { recursive: true });
-    const ext = cacheExtension(filename, mimeType);
-    const hash = createHash("sha256").update(data).digest("hex").slice(0, 16);
-    const path = join(dir, `${hash}.${ext}`);
-    writeFileSync(path, data);
-    return path;
+  private async handleRestart(ctx: Context): Promise<void> {
+    if (!ctx.chatId || !this.gate(ctx)) return;
+    this.registerOutbound(ctx.chatId);
+    const state = await this.restartChat(ctx.chatId);
+    log.info({ chatId: ctx.chatId, room: `tg-${ctx.chatId}-${state.roomIndex}` }, "new telegram conversation");
+    await ctx.reply("New conversation started.");
   }
 
-  async start(): Promise<void> {
-    const config = getConfig();
-    const token = config.channels.telegram.bot_token!;
+  private async handleText(ctx: Context): Promise<void> {
+    if (!ctx.chatId || !ctx.message?.text || !this.gate(ctx)) return;
+    this.registerOutbound(ctx.chatId);
+    const state = await this.getState(ctx.chatId);
+    const text = ctx.message.text;
+    this.withLock(ctx.chatId, () => this.processMessage(ctx, state, text));
+  }
 
-    await runMigrations();
+  private async handlePhoto(ctx: Context): Promise<void> {
+    if (!ctx.chatId || !ctx.message?.photo || !this.gate(ctx)) return;
+    this.registerOutbound(ctx.chatId);
+    const state = await this.getState(ctx.chatId);
+    const chatId = ctx.chatId;
+    this.withLock(chatId, async () => {
+      try {
+        const photos = ctx.message!.photo!;
+        const largest = photos[photos.length - 1];
+        const raw = await this.downloadFile(largest.file_id);
+        const { data, mimeType } = await prepareImage(raw, "image/jpeg");
+        const attachment: Attachment = { type: "image", data, mimeType };
+        const caption = ctx.message!.caption || "What's in this image?";
+        await this.processMessage(ctx, state, caption, [attachment]);
+      } catch (err) {
+        log.error({ err, chatId }, "failed to process photo");
+        await ctx.reply("Failed to process image.").catch(() => {});
+      }
+    });
+  }
 
-    this.outboundChatId = config.channels.telegram.chat_id;
+  private async handleDocument(ctx: Context): Promise<void> {
+    if (!ctx.chatId || !ctx.message?.document || !this.gate(ctx)) return;
+    this.registerOutbound(ctx.chatId);
+    const state = await this.getState(ctx.chatId);
+    const chatId = ctx.chatId;
+    this.withLock(chatId, async () => {
+      try {
+        const doc = ctx.message!.document!;
+        const mime = doc.mime_type || "application/octet-stream";
+        const attType = classifyMime(mime) || "file";
+        let data = await this.downloadFile(doc.file_id);
+        const error = validateAttachment(data);
+        if (error) {
+          await ctx.reply(error);
+          return;
+        }
+        let finalMime = mime;
+        if (attType === "image") {
+          const prepared = await prepareImage(data, mime);
+          data = prepared.data;
+          finalMime = prepared.mimeType;
+        }
+        const sourcePath = this.cacheAttachment(chatId, state.roomIndex, data, finalMime, doc.file_name);
+        const attachment: Attachment = {
+          type: attType,
+          data,
+          mimeType: finalMime,
+          filename: doc.file_name,
+          sourcePath,
+        };
+        const caption = ctx.message!.caption || (attType === "image" ? "What's in this image?" : "Here's a file.");
+        await this.processMessage(ctx, state, caption, [attachment]);
+      } catch (err) {
+        log.error({ err, chatId }, "failed to process document");
+        await ctx.reply("Failed to process document.").catch(() => {});
+      }
+    });
+  }
 
-    const chats = new Map<number, ChatState>();
+  // --- Core message loop ---
 
-    function keyOf(chatId: number): string {
-      return `tg-${chatId}`;
-    }
+  private async processMessage(
+    ctx: Context,
+    state: ChatState,
+    text: string,
+    attachments?: Attachment[],
+  ): Promise<void> {
+    if (!this.bot) return;
+    const bot = this.bot;
+    const chatId = ctx.chatId!;
+    log.info({ chatId, text: text.slice(0, 100), attachments: attachments?.length || 0 }, "telegram message received");
 
-    async function getState(chatId: number): Promise<ChatState> {
-      let state = chats.get(chatId);
-      if (state) return state;
-      state = await openChatEngine(keyOf(chatId), () => ({ channel: "telegram", mcpServers: getMcpServers() }));
-      chats.set(chatId, state);
-      return state;
-    }
-
-    async function restartChat(chatId: number): Promise<ChatState> {
-      const state = await rotateRoom(keyOf(chatId), chats.get(chatId), () => ({
-        channel: "telegram",
-        mcpServers: getMcpServers(),
-      }));
-      chats.set(chatId, state);
-      return state;
-    }
+    const typingInterval = setInterval(() => {
+      bot.api.sendChatAction(chatId, "typing").catch(() => {});
+    }, 4000);
+    bot.api.sendChatAction(chatId, "typing").catch(() => {});
 
-    function withLock(chatId: number, fn: () => Promise<void>): void {
-      const state = chats.get(chatId);
-      if (!state) {
-        fn().catch((err) => log.error({ err, chatId }, "unhandled error in locked handler"));
-        return;
+    try {
+      const { result, messageId } = await state.engine.send(text, {}, attachments);
+      const reply = result.trim() || "(no response)";
+      try {
+        await bot.api.sendMessage(chatId, reply);
+        if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+        log.info({ chatId, chars: result.length }, "telegram reply sent");
+      } catch (sendErr) {
+        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+        throw sendErr;
       }
-      chainLock(state, fn);
-    }
-
-    const isOpen = config.channels.telegram.open;
-    const self = this;
-
-    function registerOutbound(chatId: number): void {
-      if (self.outboundChatId) return;
-      self.outboundChatId = chatId;
-      updateRawConfig({ channels: { telegram: { chat_id: chatId } } });
-      log.info({ chatId }, "auto-registered outbound chat ID");
+    } catch (err) {
+      const errText = err instanceof Error ? err.message : String(err);
+      log.error({ err, chatId }, "telegram message processing failed");
+      await bot.api.sendMessage(chatId, `[error] ${errText}`).catch(() => {});
+    } finally {
+      clearInterval(typingInterval);
     }
+  }
 
-    function isAllowed(chatId: number): boolean {
-      if (isOpen) return true;
-      if (!self.outboundChatId) return true; // first user always allowed (gets registered)
-      return chatId === self.outboundChatId;
-    }
+  // --- Session / state helpers ---
 
-    const bot = new Bot(token);
+  private async getState(chatId: number): Promise<ChatState> {
+    let state = this.chats.get(chatId);
+    if (state) return state;
+    state = await openChatEngine(this.keyOf(chatId), () => ({ channel: "telegram", mcpServers: getMcpServers() }));
+    this.chats.set(chatId, state);
+    return state;
+  }
 
-    async function processMessage(ctx: any, state: ChatState, text: string, attachments?: Attachment[]): Promise<void> {
-      const chatId = ctx.chatId;
-      log.info(
-        { chatId, text: text.slice(0, 100), attachments: attachments?.length || 0 },
-        "telegram message received",
-      );
-
-      // Show typing indicator throughout
-      const typingInterval = setInterval(() => {
-        bot.api.sendChatAction(chatId, "typing").catch(() => {});
-      }, 4000);
-      bot.api.sendChatAction(chatId, "typing").catch(() => {});
+  private async restartChat(chatId: number): Promise<ChatState> {
+    const state = await rotateRoom(this.keyOf(chatId), this.chats.get(chatId), () => ({
+      channel: "telegram",
+      mcpServers: getMcpServers(),
+    }));
+    this.chats.set(chatId, state);
+    return state;
+  }
 
-      try {
-        const { result, messageId } = await state.engine.send(text, {}, attachments);
-
-        const reply = result.trim() || "(no response)";
-        try {
-          try {
-            await bot.api.sendMessage(chatId, reply, { parse_mode: "MarkdownV2" });
-          } catch {
-            await bot.api.sendMessage(chatId, reply);
-          }
-          if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
-          log.info({ chatId, chars: result.length }, "telegram reply sent");
-        } catch (sendErr) {
-          if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
-          throw sendErr;
-        }
-      } catch (err) {
-        const errText = err instanceof Error ? err.message : String(err);
-        log.error({ err, chatId }, "telegram message processing failed");
-        await bot.api.sendMessage(chatId, `[error] ${errText}`).catch(() => {});
-      } finally {
-        clearInterval(typingInterval);
-      }
+  private withLock(chatId: number, fn: () => Promise<void>): void {
+    const state = this.chats.get(chatId);
+    if (!state) {
+      fn().catch((err) => log.error({ err, chatId }, "unhandled error in locked handler"));
+      return;
     }
+    chainLock(state, fn);
+  }
 
-    bot.command("start", async (ctx) => {
-      if (!isAllowed(ctx.chatId)) {
-        await ctx.reply("Unauthorized.");
-        return;
-      }
-      registerOutbound(ctx.chatId);
-      const state = await getState(ctx.chatId);
-      withLock(ctx.chatId, () => processMessage(ctx, state, "hi"));
-    });
+  private keyOf(chatId: number): string {
+    return `tg-${chatId}`;
+  }
 
-    bot.command(["restart", "new"], async (ctx) => {
-      if (!isAllowed(ctx.chatId)) {
-        await ctx.reply("Unauthorized.");
-        return;
-      }
-      registerOutbound(ctx.chatId);
-      const state = await restartChat(ctx.chatId);
-      log.info({ chatId: ctx.chatId, room: `tg-${ctx.chatId}-${state.roomIndex}` }, "new telegram conversation");
-      await ctx.reply("New conversation started.");
-    });
+  // --- Authorization / outbound binding ---
 
-    bot.on("message:text", async (ctx) => {
-      if (!isAllowed(ctx.chatId)) {
-        await ctx.reply("Unauthorized.");
-        return;
-      }
-      registerOutbound(ctx.chatId);
-      const state = await getState(ctx.chatId);
-      withLock(ctx.chatId, () => processMessage(ctx, state, ctx.message.text));
-    });
+  /** Authorization check + auto-reply with "Unauthorized." if not allowed. Returns true to continue. */
+  private gate(ctx: Context): boolean {
+    if (!ctx.chatId) return false;
+    if (this.isAllowed(ctx.chatId)) return true;
+    ctx.reply("Unauthorized.").catch(() => {});
+    return false;
+  }
 
-    bot.on("message:photo", async (ctx) => {
-      if (!isAllowed(ctx.chatId)) {
-        await ctx.reply("Unauthorized.");
-        return;
-      }
-      registerOutbound(ctx.chatId);
-      const state = await getState(ctx.chatId);
-      withLock(ctx.chatId, async () => {
-        try {
-          const photos = ctx.message.photo;
-          const largest = photos[photos.length - 1];
-          const raw = await self.downloadFile(largest.file_id);
-          const { data, mimeType } = await prepareImage(raw, "image/jpeg");
-          const attachment: Attachment = { type: "image", data, mimeType };
-          const caption = ctx.message.caption || "What's in this image?";
-          await processMessage(ctx, state, caption, [attachment]);
-        } catch (err) {
-          log.error({ err, chatId: ctx.chatId }, "failed to process photo");
-          await ctx.reply("Failed to process image.").catch(() => {});
-        }
-      });
-    });
+  private isAllowed(chatId: number): boolean {
+    if (this.isOpen) return true;
+    if (!this.outboundChatId) return true; // first user always allowed (gets registered)
+    return chatId === this.outboundChatId;
+  }
 
-    bot.on("message:document", async (ctx) => {
-      if (!isAllowed(ctx.chatId)) {
-        await ctx.reply("Unauthorized.");
-        return;
-      }
-      registerOutbound(ctx.chatId);
-      const state = await getState(ctx.chatId);
-      withLock(ctx.chatId, async () => {
-        try {
-          const doc = ctx.message.document;
-          const mime = doc.mime_type || "application/octet-stream";
-          const attType = classifyMime(mime) || "file";
-          let data = await self.downloadFile(doc.file_id);
-          const error = validateAttachment(data);
-          if (error) {
-            await ctx.reply(error);
-            return;
-          }
-          let finalMime = mime;
-          if (attType === "image") {
-            const prepared = await prepareImage(data, mime);
-            data = prepared.data;
-            finalMime = prepared.mimeType;
-          }
-          const sourcePath = self.cacheAttachment(ctx.chatId, state.roomIndex, data, finalMime, doc.file_name);
-          const attachment: Attachment = {
-            type: attType,
-            data,
-            mimeType: finalMime,
-            filename: doc.file_name,
-            sourcePath,
-          };
-          const caption = ctx.message.caption || (attType === "image" ? "What's in this image?" : "Here's a file.");
-          await processMessage(ctx, state, caption, [attachment]);
-        } catch (err) {
-          log.error({ err, chatId: ctx.chatId }, "failed to process document");
-          await ctx.reply("Failed to process document.").catch(() => {});
-        }
-      });
-    });
+  private registerOutbound(chatId: number): void {
+    if (this.outboundChatId) return;
+    this.outboundChatId = chatId;
+    updateRawConfig({ channels: { telegram: { chat_id: chatId } } });
+    log.info({ chatId }, "auto-registered outbound chat ID");
+  }
 
-    bot.start({
-      onStart: () => log.info("telegram bot polling started"),
-    });
+  // --- File helpers ---
 
-    this.bot = bot;
+  private async downloadFile(fileId: string): Promise<Buffer> {
+    if (!this.bot) throw new Error("Telegram not started");
+    const file = await this.bot.api.getFile(fileId);
+    const token = getConfig().channels.telegram.bot_token!;
+    const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+    const resp = await fetch(url, { signal: AbortSignal.timeout(30_000) });
+    if (!resp.ok) throw new Error(`Download failed: ${resp.status}`);
+    return Buffer.from(await resp.arrayBuffer());
   }
 
-  async stop(): Promise<void> {
-    if (this.bot) {
-      this.bot.stop();
-      this.bot = null;
-    }
+  private cacheAttachment(
+    chatId: number,
+    roomIndex: number,
+    data: Buffer,
+    mimeType: string,
+    filename?: string,
+  ): string {
+    const scope = `telegram-${chatId}-${roomIndex}`;
+    const dir = join(getNiaHome(), "tmp", "attachments", scope);
+    mkdirSync(dir, { recursive: true });
+    const ext = cacheExtension(filename, mimeType);
+    const hash = createHash("sha256").update(data).digest("hex").slice(0, 16);
+    const path = join(dir, `${hash}.${ext}`);
+    writeFileSync(path, data);
+    return path;
   }
 }
 

package/src/channels/twilio/rest.ts

@@ -33,6 +33,7 @@ async function twilioPost<T = unknown>(creds: TwilioCreds, suffix: string, body:
     method: "POST",
     headers: { Authorization: basicAuth(creds), "Content-Type": "application/x-www-form-urlencoded" },
     body: body.toString(),
+    signal: AbortSignal.timeout(15_000),
   });
   if (!resp.ok) {
     const text = await resp.text().catch(() => "");

package/src/core/alive.ts

@@ -107,6 +107,7 @@ async function notifyUser(message: string): Promise<void> {
         method: "POST",
         headers: { Authorization: `Bearer ${slToken}`, "Content-Type": "application/json" },
         body: JSON.stringify({ channel: slRecipient, text: message }),
+        signal: AbortSignal.timeout(10_000),
       });
       if (resp.ok) {
         log.info("alive: notified user via slack");

package/src/db/models/session.ts

@@ -98,7 +98,10 @@ export async function setSummary(id: string, summary: string): Promise<void> {
   await sql`UPDATE sessions SET summary = ${summary} WHERE id = ${id}`;
 }
 
-export async function getRecentSummaries(room: string, limit = 3): Promise<Array<{ summary: string; updatedAt: string }>> {
+export async function getRecentSummaries(
+  room: string,
+  limit = 3,
+): Promise<Array<{ summary: string; updatedAt: string }>> {
   const sql = getSql();
   // Match summaries from sessions in the same channel (e.g. slack-dm-U...-*)
   // by extracting the room prefix (everything before the last -N index)
@@ -171,17 +174,16 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
   `;
 }
 
+/** Max numeric suffix among rooms matching `${prefix}-N`. Used by rotateRoom() to allocate idx+1 without collisions. */
 export async function getLatestRoomIndex(prefix: string): Promise<number> {
   const sql = getSql();
   const pattern = `^${escapeRegex(prefix)}-\\d+$`;
-  const rows = await sql`
-    SELECT room FROM sessions
-    WHERE room ~ ${pattern}
-    ORDER BY updated_at DESC
-    LIMIT 1
-  `;
-  if (rows.length === 0) return 0;
-  const parts = rows[0].room.split("-");
-  const idx = parseInt(parts[parts.length - 1], 10);
-  return isNaN(idx) ? 0 : idx;
+  const rows = await sql`SELECT room FROM sessions WHERE room ~ ${pattern}`;
+  let max = 0;
+  for (const row of rows) {
+    const parts = (row.room as string).split("-");
+    const idx = parseInt(parts[parts.length - 1], 10);
+    if (!isNaN(idx) && idx > max) max = idx;
+  }
+  return max;
 }

package/src/mcp/tools/index.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP tool handler barrel. Domain modules live next to this file. Callers
+ * `import * as handlers from "./tools"` and get all of them.
+ */
+export * from "./jobs";
+export * from "./send";
+export * from "./messages";
+export * from "./watch";
+export * from "./misc";

package/src/mcp/tools/jobs.ts

@@ -0,0 +1,145 @@
+import { Job } from "../../db/models";
+import { computeInitialNextRun } from "../../core/scheduler";
+import { getConfig } from "../../utils/config";
+import { resolveJobPrompt } from "../../core/job-prompt";
+import type { ScheduleType } from "../../types";
+
+export async function listJobs(): Promise<string> {
+  const jobs = await Job.list();
+  if (jobs.length === 0) return "No jobs found.";
+  const withPromptSource = jobs.map((job) => {
+    const resolvedPrompt = resolveJobPrompt(job);
+    return {
+      ...job,
+      prompt: resolvedPrompt.prompt,
+      promptSource: resolvedPrompt.source,
+      promptPath: resolvedPrompt.filePath,
+    };
+  });
+  return JSON.stringify(withPromptSource, null, 2);
+}
+
+export async function addJob(args: {
+  name: string;
+  schedule: string;
+  prompt: string;
+  schedule_type?: ScheduleType;
+  always?: boolean;
+  agent?: string;
+  employee?: string;
+  model?: string;
+  stateless?: boolean;
+}): Promise<string> {
+  const scheduleType = args.schedule_type || "cron";
+  const always = args.always || false;
+  const stateless = args.stateless || false;
+  const config = getConfig();
+
+  const nextRunAt = computeInitialNextRun(scheduleType, args.schedule, config.timezone);
+  await Job.create(
+    args.name,
+    args.schedule,
+    args.prompt,
+    always,
+    scheduleType,
+    nextRunAt,
+    args.agent,
+    stateless,
+    args.model,
+    args.employee,
+  );
+  const agentNote = args.agent ? ` [agent: ${args.agent}]` : "";
+  const employeeNote = args.employee ? ` [employee: ${args.employee}]` : "";
+  const modelNote = args.model ? ` [model: ${args.model}]` : "";
+  return `Job "${args.name}" created (${scheduleType}: ${args.schedule})${agentNote}${employeeNote}${modelNote}. Next run: ${nextRunAt.toISOString()}`;
+}
+
+export async function updateJob(args: {
+  name: string;
+  schedule?: string;
+  prompt?: string;
+  always?: boolean;
+  agent?: string | null;
+  employee?: string | null;
+  model?: string | null;
+  stateless?: boolean;
+  schedule_type?: "cron" | "interval" | "once";
+}): Promise<string> {
+  const fields: Partial<{
+    schedule: string;
+    prompt: string;
+    always: boolean;
+    stateless: boolean;
+    model: string | null;
+    agent: string | null;
+    employee: 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.stateless !== undefined) fields.stateless = args.stateless;
+  if (args.model !== undefined) fields.model = args.model;
+  if (args.agent !== undefined) fields.agent = args.agent;
+  if (args.employee !== undefined) fields.employee = args.employee;
+  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, stateless, model, agent, employee, or schedule_type).";
+
+  const updated = await Job.update(args.name, fields);
+  if (!updated) return `Job "${args.name}" not found.`;
+  if (fields.prompt !== undefined) {
+    const job = await Job.get(args.name);
+    if (job) {
+      const resolvedPrompt = resolveJobPrompt(job);
+      if (resolvedPrompt.source === "file") {
+        return `Job "${args.name}" updated. Note: runtime prompt is still overridden by ${resolvedPrompt.filePath}.`;
+      }
+    }
+  }
+  return `Job "${args.name}" updated.`;
+}
+
+export async function removeJob(name: string): Promise<string> {
+  const removed = await Job.remove(name);
+  return removed ? `Job "${name}" removed.` : `Job "${name}" not found.`;
+}
+
+export async function enableJob(name: string): Promise<string> {
+  const updated = await Job.update(name, { status: "active" });
+  if (!updated) return `Job "${name}" not found.`;
+
+  const job = await Job.get(name);
+  if (job) {
+    const config = getConfig();
+    const nextRun = computeInitialNextRun(job.scheduleType, job.schedule, config.timezone);
+    const { getSql } = await import("../../db/connection");
+    await getSql()`UPDATE jobs SET next_run_at = ${nextRun} WHERE name = ${name}`;
+  }
+  return `Job "${name}" enabled.`;
+}
+
+export async function disableJob(name: string): Promise<string> {
+  const updated = await Job.update(name, { status: "disabled" });
+  return updated ? `Job "${name}" disabled.` : `Job "${name}" not found.`;
+}
+
+export async function archiveJob(name: string): Promise<string> {
+  const updated = await Job.update(name, { status: "archived" });
+  return updated ? `Job "${name}" archived.` : `Job "${name}" not found.`;
+}
+
+export async function unarchiveJob(name: string): Promise<string> {
+  const updated = await Job.update(name, { status: "disabled" });
+  return updated ? `Job "${name}" unarchived (disabled). Enable with enable_job.` : `Job "${name}" not found.`;
+}
+
+export async function runJobNow(name: string): Promise<string> {
+  const job = await Job.get(name);
+  if (!job) return `Job "${name}" not found.`;
+
+  const { getSql } = await import("../../db/connection");
+  await getSql()`UPDATE jobs SET next_run_at = NOW() WHERE name = ${name}`;
+  return `Job "${name}" queued for immediate execution.`;
+}