jerob 1.0.0

package/scheduler/orchestrator.ts

@@ -0,0 +1,438 @@
+import chalk from "chalk";
+import { select, text, confirm, isCancel } from "@clack/prompts";
+import { withSpinner } from "../tui/spinner";
+import {
+  getAllTasks,
+  getTaskById,
+  createTask,
+  updateTask,
+  deleteTask,
+  getRunsForTask,
+} from "./db";
+import { planScheduledTask, computeNextRun } from "./planner";
+import { printLLMError } from "../utils/llm-error";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * Accepts either:
+ *  - A plain time like "11:06" or "11.06" → converts to daily cron in UTC
+ *  - A full 5-field cron expression → used as-is (assumed UTC)
+ */
+function parseCronInput(input: string): string {
+  const trimmed = input.trim();
+
+  // Match HH:MM or HH.MM (12 or 24 hour, with optional AM/PM)
+  const timeMatch = trimmed.match(/^(\d{1,2})[:.h](\d{2})\s*(am|pm)?$/i);
+  if (timeMatch) {
+    let hours = parseInt(timeMatch[1]!, 10);
+    const minutes = parseInt(timeMatch[2]!, 10);
+    const meridiem = timeMatch[3]?.toLowerCase();
+
+    if (meridiem === "pm" && hours < 12) hours += 12;
+    if (meridiem === "am" && hours === 12) hours = 0;
+
+    // Convert local time → UTC
+    const localOffsetMinutes = new Date().getTimezoneOffset(); // e.g. -330 for IST
+    const totalLocalMinutes = hours * 60 + minutes;
+    const totalUtcMinutes = totalLocalMinutes + localOffsetMinutes; // getTimezoneOffset is negated
+
+    // Wrap around 24 hours
+    const utcMinutes = ((totalUtcMinutes % 1440) + 1440) % 1440;
+    const utcHour = Math.floor(utcMinutes / 60);
+    const utcMin = utcMinutes % 60;
+
+    const cron = `${utcMin} ${utcHour} * * *`;
+    console.log(chalk.dim(`  → Converted to UTC cron: ${cron} (runs daily at ${trimmed} local time)`));
+    return cron;
+  }
+
+  // Otherwise treat as raw cron expression
+  return trimmed;
+}
+
+function fmtDate(iso: string | null) {
+  if (!iso) return chalk.dim("never");
+  return new Date(iso).toLocaleString();
+}
+
+function fmtCron(cron: string) {
+  // Show UTC cron + local time equivalent if it's a daily schedule
+  const daily = cron.match(/^(\d+)\s+(\d+)\s+\*\s+\*\s+\*$/);
+  if (daily) {
+    const utcMin = parseInt(daily[1]!, 10);
+    const utcHour = parseInt(daily[2]!, 10);
+    const localDate = new Date();
+    localDate.setUTCHours(utcHour, utcMin, 0, 0);
+    return `${cron} ${chalk.dim(`(daily ${localDate.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })} local)`)}`;
+  }
+  return cron;
+}
+
+function fmtEnabled(v: boolean) {
+  return v ? chalk.green("enabled") : chalk.red("disabled");
+}
+
+// ── Sub-screens ───────────────────────────────────────────────────────────────
+
+async function listTasks() {
+  const tasks = await getAllTasks();
+  if (tasks.length === 0) {
+    console.log(chalk.yellow("\nNo scheduled tasks yet.\n"));
+    return;
+  }
+  console.log(chalk.bold(`\n${"#".padEnd(4)} ${"Name".padEnd(28)} ${"Cron".padEnd(16)} ${"Status".padEnd(10)} ${"Runs".padEnd(6)} Last Run`));
+  console.log("─".repeat(90));
+  tasks.forEach((t, i) => {
+    console.log(
+      `${String(i + 1).padEnd(4)} ${t.name.slice(0, 27).padEnd(28)} ${t.cron.padEnd(16)} ${fmtEnabled(t.enabled).padEnd(18)} ${String(t.run_count).padEnd(6)} ${fmtDate(t.last_run_at)}`
+    );  });
+  console.log();
+}
+
+async function addTask() {
+  const desc = await text({
+    message: "Describe the repetitive task (what should happen and how often):",
+    placeholder: "e.g. Every morning search top AI news and email me a summary",
+  });
+  if (isCancel(desc) || !desc?.trim()) return;
+
+  let plan;
+  try {
+    plan = await withSpinner("Planning task with AI…", () =>
+      planScheduledTask(desc.trim())
+    );
+  } catch (err) {
+    printLLMError(err, "Scheduler planner");
+    return;
+  }
+
+  console.log(chalk.bold(`\nTask name:  ${plan.name}`));
+  console.log(chalk.bold(`Cron:       ${plan.cron}`));
+  console.log(chalk.bold(`Steps (${plan.steps.length}):`));
+  plan.steps.forEach((s:any) => console.log(`  ${s.order}. [${s.type}] ${s.instruction}`));
+
+
+  // Only ask for email if there's an email_send step AND no email already in the instructions
+  const hasEmailStep = plan.steps.some((s: any) => s.type === "email_send");
+  const emailAlreadyInSteps = plan.steps.some(
+    (s: any) => s.type === "email_send" && /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/.test(s.instruction)
+  );
+  let recipientEmail: string | null = null;
+
+  if (hasEmailStep && !emailAlreadyInSteps) {
+    const emailPrompt = await text({
+      message: "📧 This task sends emails. Enter recipient email address:",
+      placeholder: "your@email.com",
+      validate: (v) => {
+        if (!v || !v.trim()) return "Email is required for email_send steps";
+        if (!v.includes("@")) return "Please enter a valid email";
+        return undefined;
+      },
+    });
+    if (isCancel(emailPrompt)) return;
+    recipientEmail = emailPrompt?.trim() || null;
+  }
+
+  const editCron = await text({
+    message: "Schedule — enter time like '11:06' (daily, your local time) or a full cron e.g. '0 9 * * 1':",
+    initialValue: plan.cron,
+  });
+  if (isCancel(editCron)) return;
+  const finalCron = parseCronInput(editCron?.trim() || plan.cron);
+
+  const emailInput = await text({
+    message: "Send summary email after each run? (leave blank to skip):",
+    placeholder: "you@example.com",
+  });
+  if (isCancel(emailInput)) return;
+  const summaryEmail = emailInput?.trim() || null;
+
+  // Replace USER_EMAIL placeholder AND update any email_send step instructions to include the actual email
+  const finalSteps = plan.steps.map((step:any) => {
+    if (step.type === "email_send" && recipientEmail) {
+      // If instruction has USER_EMAIL, replace it
+      if (step.instruction.includes("USER_EMAIL")) {
+        return {
+          ...step,
+          instruction: step.instruction.replace(/USER_EMAIL/g, recipientEmail),
+        };
+      }
+      // Otherwise, append the email to the instruction
+      return {
+        ...step,
+        instruction: `${step.instruction} to ${recipientEmail}`,
+      };
+    }
+    return step;
+  });
+
+  const ok = await confirm({ message: "Create this task?" });
+  if (isCancel(ok) || !ok) return;
+
+  const task = await createTask({
+    name: plan.name,
+    description: desc.trim(),
+    cron: finalCron,
+    enabled: true,
+    steps: finalSteps,
+    summary_email: summaryEmail,
+    next_run_at: computeNextRun(finalCron),
+  });
+
+  console.log(chalk.green(`\n✓ Task created: ${task.id}\n`));
+}
+
+async function manageTask() {
+  const tasks = await getAllTasks();
+  if (tasks.length === 0) {
+    console.log(chalk.yellow("\nNo tasks to manage.\n"));
+    return;
+  }
+
+  const choice = await select({
+    message: "Select a task:",
+    options: tasks.map((t) => ({
+      value: t.id,
+      label: `${t.name} [${fmtEnabled(t.enabled)}] — ${t.cron}`,
+    })),
+  });
+  if (isCancel(choice)) return;
+
+  const task = await getTaskById(choice as string);
+  if (!task) return;
+
+  while (true) {
+    console.log(chalk.bold(`\n── ${task.name} ──`));
+    console.log(`  ID:          ${task.id}`);
+    console.log(`  Cron:        ${fmtCron(task.cron)}`);
+    console.log(`  Status:      ${fmtEnabled(task.enabled)}`);
+    console.log(`  Runs:        ${task.run_count}`);
+    console.log(`  Last run:    ${fmtDate(task.last_run_at)}`);
+    console.log(`  Next run:    ${fmtDate(task.next_run_at)}`);
+    console.log(`  Summary to:  ${task.summary_email ?? chalk.dim("(none)")}`);
+    console.log(`  Steps:`);
+    task.steps.forEach((s) => console.log(`    ${s.order}. [${s.type}] ${s.instruction}`));
+    console.log();
+
+    const action = await select({
+      message: "Action:",
+      options: [
+        { value: "toggle", label: task.enabled ? "Disable task" : "Enable task" },
+        { value: "edit_cron", label: "Edit cron schedule" },
+        { value: "edit_email", label: "Edit summary email" },
+        { value: "run_now", label: "Run now (manual trigger)" },
+        { value: "history", label: "View run history" },
+        { value: "delete", label: chalk.red("Delete task") },
+        { value: "back", label: "Back" },
+      ],
+    });
+    if (isCancel(action) || action === "back") break;
+
+    if (action === "toggle") {
+      await updateTask(task.id, { enabled: !task.enabled });
+      task.enabled = !task.enabled;
+      console.log(chalk.green(`✓ Task ${task.enabled ? "enabled" : "disabled"}\n`));
+    }
+
+    if (action === "edit_cron") {
+      const newCron = await text({ message: "New schedule — time like '11:06' (daily, local) or full cron:", initialValue: task.cron });
+      if (!isCancel(newCron) && newCron?.trim()) {
+        const parsed = parseCronInput(newCron.trim());
+        await updateTask(task.id, { cron: parsed, next_run_at: computeNextRun(parsed) });
+        task.cron = parsed;
+        console.log(chalk.green(`✓ Schedule updated to: ${parsed}\n`));
+      }
+    }
+
+    if (action === "edit_email") {
+      const newEmail = await text({ message: "Summary email (blank to remove):", initialValue: task.summary_email ?? "" });
+      if (!isCancel(newEmail)) {
+        const val = newEmail?.trim() || null;
+        await updateTask(task.id, { summary_email: val });
+        task.summary_email = val;
+        console.log(chalk.green("✓ Email updated\n"));
+      }
+    }
+
+    if (action === "run_now") {
+      const confirmed = await confirm({ message: "Run this task now?" });
+      if (!isCancel(confirmed) && confirmed) {
+        let error: string | null = null;
+        let ranCount = 0;
+        let taskStatus = "unknown";
+
+        await withSpinner(`Running ${task.name}…`, async () => {
+          const url = process.env.SUPABASE_URL;
+          const key = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.SUPABASE_KEY;
+
+          if (!url || !key) {
+            error = "SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY not set in .env";
+            return;
+          }
+
+          // Set next_run_at far in the past so it's definitely "due"
+          await updateTask(task.id, {
+            next_run_at: new Date(Date.now() - 60000).toISOString(),
+          });
+
+          // Small delay to ensure DB write is committed
+          await new Promise((r) => setTimeout(r, 500));
+
+          const res = await fetch(`${url}/functions/v1/scheduler-tick`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${key}`,
+            },
+            body: JSON.stringify({}),
+          });
+
+          const body = await res.text();
+
+          if (!res.ok) {
+            error = `Edge Function returned ${res.status}: ${body}`;
+            return;
+          }
+
+          try {
+            const data = JSON.parse(body);
+            ranCount = data?.ran ?? 0;
+            const match = (data?.results ?? []).find((r: any) => r.taskId === task.id);
+            taskStatus = match?.status ?? (ranCount > 0 ? "success" : "not_picked_up");
+          } catch {
+            error = `Invalid response: ${body.slice(0, 100)}`;
+          }
+        });
+
+        if (error) {
+          console.log(chalk.red(`\n✖ ${error}\n`));
+        } else if (taskStatus === "not_picked_up") {
+          console.log(chalk.yellow("\n⚠ Edge Function ran but did not pick up this task."));
+          console.log(chalk.dim("This can happen if next_run_at wasn't updated in time. Try again.\n"));
+        } else {
+          const icon = taskStatus === "success" ? chalk.green("✓")
+            : taskStatus === "partial" ? chalk.yellow("⚠")
+            : chalk.red("✖");
+          console.log(`\n${icon} Done — status: ${chalk.bold(taskStatus)}`);
+          console.log(chalk.dim("View full results: Manage → View run history\n"));
+        }
+      }
+    }
+
+    if (action === "history") {
+      const runs = await getRunsForTask(task.id, 10);
+      if (runs.length === 0) {
+        console.log(chalk.yellow("\nNo runs yet.\n"));
+      } else {
+        console.log(chalk.bold("\nRun History (last 10):\n"));
+        runs.forEach((r, i) => {
+          const icon =
+            r.status === "success" ? chalk.green("✓") :
+            r.status === "failed"  ? chalk.red("✖") :
+            chalk.yellow("⟳");
+          console.log(`${i + 1}. ${icon} ${fmtDate(r.started_at)} — ${chalk.bold(r.status)}`);
+
+          // Show step-level results
+          if (Array.isArray(r.step_results) && r.step_results.length > 0) {
+            r.step_results.forEach((s: any) => {
+              const stepIcon = s.success ? chalk.green("  ✓") : chalk.red("  ✖");
+              console.log(`${stepIcon} Step ${s.order} [${s.type ?? "?"}]: ${String(s.output ?? "").slice(0, 180)}`);
+            });
+          }
+
+          // Top-level error — classify it for the user
+          if (r.error) {
+            const err = r.error;
+            let category = chalk.red("Error");
+            let hint = "";
+
+            if (/invalid.?api.?key|api key|unauthorized|401/i.test(err)) {
+              category = chalk.red("LLM API Key Error");
+              hint = "  → Run `jerob set-key` to update your API keys, then `jerob sync-credentials`";
+            } else if (/quota|rate.?limit|429|too many requests/i.test(err)) {
+              category = chalk.yellow("Rate Limit / Quota");
+              hint = "  → Your API key hit its limit. Try a different provider or wait.";
+            } else if (/no llm keys|no api key|all llm providers failed/i.test(err)) {
+              category = chalk.red("No LLM Keys Configured");
+              hint = "  → Run `jerob sync-credentials` to push your keys to Supabase.";
+            } else if (/gmail|refresh.?token|oauth/i.test(err)) {
+              category = chalk.red("Gmail Auth Error");
+              hint = "  → Re-authenticate Gmail: run `jerob jet` and use an email operation.";
+            } else if (/firecrawl|search failed|crawl failed/i.test(err)) {
+              category = chalk.yellow("Web Search/Crawl Error");
+              hint = "  → Check your FIRECRAWL_KEY or the target URL.";
+            } else if (/supabase|database|relation|table/i.test(err)) {
+              category = chalk.red("Database Error");
+              hint = "  → Run `jerob setup-db` to verify your schema is up to date.";
+            } else if (/fetch|network|ECONNREFUSED|timeout/i.test(err)) {
+              category = chalk.yellow("Network Error");
+              hint = "  → Transient network issue. The task will retry next scheduled run.";
+            }
+
+            console.log(chalk.red(`   ${category}: ${err.slice(0, 300)}`));
+            if (hint) console.log(chalk.dim(hint));
+          }
+
+          if (r.output && r.status !== "failed") {
+            console.log(chalk.dim(`   Output: ${r.output.slice(0, 200)}`));
+          }
+          console.log();
+        });
+      }
+    }
+
+    if (action === "delete") {
+      const sure = await confirm({ message: chalk.red(`Delete "${task.name}"? This cannot be undone.`) });
+      if (!isCancel(sure) && sure) {
+        await deleteTask(task.id);
+        console.log(chalk.green("✓ Task deleted\n"));
+        break;
+      }
+    }
+  }
+}
+
+// ── Main entry ────────────────────────────────────────────────────────────────
+
+function showDeployInstructions() {
+  console.log(chalk.bold("\n🚀 Serverless Deploy (Supabase Edge Function)\n"));
+  console.log("1. Install Supabase CLI:  npm i -g supabase");
+  console.log("2. Login:                 supabase login");
+  console.log("3. Link project:          supabase link --project-ref <YOUR_PROJECT_REF>");
+  console.log("4. Deploy + sync keys:    .\\supabase\\deploy.ps1");
+  console.log("5. Run setup SQL once:");
+  console.log(chalk.cyan("   Open scheduler/SETUP-READY.sql in Supabase SQL Editor and click RUN"));
+  console.log(chalk.green("\nAfter deploy, tasks run every minute in Supabase — no local process needed.\n"));
+}
+
+export async function runSchedulerMode() {
+  console.log(chalk.bold("\n⏰ Scheduler Mode\n"));
+  console.log(chalk.dim("Tip: run 'jimmy daemon' in a separate terminal to execute tasks autonomously.\n"));
+
+  while (true) {
+    const option = await select({
+      message: "Scheduler:",
+      options: [
+        { value: "list", label: "List all tasks" },
+        { value: "add", label: "Add new task (AI plans it)" },
+        { value: "manage", label: "Manage / edit / delete a task" },
+        { value: "deploy", label: "Show serverless deploy instructions" },
+        { value: "back", label: "Back" },
+      ],
+    });
+
+    if (isCancel(option) || option === "back") break;
+
+    try {
+      if (option === "list") await listTasks();
+      if (option === "add") await addTask();
+      if (option === "manage") await manageTask();
+      if (option === "deploy") showDeployInstructions();
+    } catch (err) {
+      // DB errors, network errors — print clearly
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk.red(`\n✖ ${msg}\n`));
+    }
+  }
+}

package/scheduler/planner.ts

@@ -0,0 +1,170 @@
+import { generateText } from "ai";
+import { getAgentModel, getAgentModel2, getAgentModel2Fallback } from "../config/ai.config";
+import type { TaskStep } from "./db";
+import { parseLLMError } from "../utils/llm-error";
+
+interface ParsedPlan {
+  steps: TaskStep[];
+  cron: string;
+  name: string;
+}
+
+function extractJson(text: string): string | null {
+  let s = text.trim();
+  if (s.startsWith("```json")) s = s.slice(7);
+  if (s.startsWith("```")) s = s.slice(3);
+  if (s.endsWith("```")) s = s.slice(0, -3);
+  s = s.trim();
+  const i = s.indexOf("{");
+  if (i === -1) return null;
+  let depth = 0;
+  for (let j = i; j < s.length; j++) {
+    if (s[j] === "{") depth++;
+    else if (s[j] === "}") {
+      depth--;
+      if (depth === 0) return s.slice(i, j + 1);
+    }
+  }
+  return null;
+}
+
+const SYSTEM_PROMPT = `You are a task automation planner. Given a user description of a repetitive task, produce a structured execution plan.
+
+Step types:
+- "web_search": search the web for information
+- "web_crawl": scrape a specific URL for content
+- "email_send": send an email with accumulated results
+- "custom": any other AI-driven text/data task
+
+IMPORTANT for email_send steps:
+- If the user includes one or more email addresses in their description, embed them directly in the instruction, e.g. "send summary to alice@gmail.com, bob@work.com with subject 'Daily Report'"
+- If the user says "email me" without specifying an address, use the placeholder USER_EMAIL so the system can ask for it
+- NEVER invent or guess email addresses
+
+You MUST respond with ONLY valid JSON — no markdown, no explanation, just the JSON object:
+{
+  "name": "short descriptive task name",
+  "cron": "standard 5-field cron expression e.g. 0 9 * * *",
+  "steps": [
+    { "order": 1, "type": "web_search", "instruction": "exact instruction for this step" },
+    { "order": 2, "type": "email_send", "instruction": "send results to alice@gmail.com with subject 'Results'" }
+  ]
+}`;
+
+const models = [
+  () => getAgentModel2(),          // Groq llama — most reliable for structured output
+  () => getAgentModel2Fallback(),  // OpenRouter fallback
+  () => getAgentModel(),           // Primary (may be filtered)
+];
+
+export async function planScheduledTask(description: string): Promise<ParsedPlan> {
+  let lastError: Error | null = null;
+
+  for (const getModel of models) {
+    let model;
+    try { model = getModel(); } catch { continue; }
+
+    for (let attempt = 0; attempt < 2; attempt++) {
+      let text = "";
+      try {
+        const res = await generateText({
+          model,
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: `Plan this task: ${description}` },
+          ],
+          temperature: attempt === 0 ? 0.3 : 0.1,
+        });
+        text = res.text?.trim() ?? "";
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+        const parsed = parseLLMError(e);
+        // Auth/quota errors won't be fixed by trying another model — bail immediately
+        if (parsed.type === "auth" || parsed.type === "quota") {
+          throw new Error(`Scheduler planner: ${parsed.message}`);
+        }
+        break; // try next model
+      }
+
+      // Detect safety refusals
+      const lower = text.toLowerCase();
+      if (
+        lower.includes("i'm sorry") ||
+        lower.includes("i cannot") ||
+        lower.includes("i can't") ||
+        lower.startsWith("user safety") ||
+        lower.includes("content policy") ||
+        text.length < 20
+      ) {
+        lastError = new Error(`Model refused: ${text.slice(0, 100)}`);
+        break; // try next model
+      }
+
+      const jsonStr = extractJson(text);
+      if (!jsonStr) {
+        lastError = new Error(`No JSON found in response: ${text.slice(0, 200)}`);
+        continue; // retry same model with lower temp
+      }
+
+      try {
+        const parsed = JSON.parse(jsonStr);
+        if (!Array.isArray(parsed.steps) || parsed.steps.length === 0) {
+          lastError = new Error("Plan missing steps");
+          continue;
+        }
+        return {
+          name: parsed.name ?? "Unnamed Task",
+          cron: parsed.cron ?? "0 9 * * *",
+          steps: parsed.steps as TaskStep[],
+        };
+      } catch (e) {
+        lastError = new Error(`JSON parse failed: ${e}`);
+        continue;
+      }
+    }
+  }
+
+  throw new Error(
+    `Failed to plan task after trying all models. Last error: ${lastError?.message ?? "unknown"}`
+  );
+}
+
+export function computeNextRun(cronExpr: string): string {
+  // Parse the 5-field cron expression and find the next matching UTC time
+  const [min, hour, dom, month, dow] = cronExpr.trim().split(/\s+/);
+
+  const matchField = (value: number, field: string): boolean => {
+    if (field === "*") return true;
+    if (field.includes("/")) {
+      const [base, step] = field.split("/");
+      const start = base === "*" ? 0 : parseInt(base as string, 10);
+      return (value - start) % parseInt(step!, 10) === 0 && value >= start;
+    }
+    if (field.includes(",")) return field.split(",").map(Number).includes(value);
+    if (field.includes("-")) {
+      const [lo, hi] = field.split("-").map(Number);
+      return value >= lo! && value <= hi!;
+    }
+    return parseInt(field, 10) === value;
+  };
+
+  // Scan forward from next minute in UTC (Supabase pg_cron runs in UTC)
+  const now = new Date();
+  now.setSeconds(0, 0);
+
+  for (let offset = 1; offset <= 60 * 24 * 7; offset++) {
+    const c = new Date(now.getTime() + offset * 60_000);
+    if (
+      matchField(c.getUTCMinutes(), min!) &&
+      matchField(c.getUTCHours(), hour!) &&
+      matchField(c.getUTCDate(), dom!) &&
+      matchField(c.getUTCMonth() + 1, month!) &&
+      matchField(c.getUTCDay(), dow!)
+    ) {
+      return c.toISOString();
+    }
+  }
+
+  // Fallback: 1 hour from now
+  return new Date(now.getTime() + 3_600_000).toISOString();
+}

package/scheduler/update-task-email.ts

@@ -0,0 +1,70 @@
+/**
+ * Update an existing task's email_send steps with correct recipient
+ * Usage: bun run scheduler/update-task-email.ts "task-id" "your@email.com"
+ */
+
+import { getTaskById, updateTask } from "./db";
+import chalk from "chalk";
+
+const taskId = process.argv[2];
+const email = process.argv[3];
+
+if (!taskId || !email) {
+  console.log(chalk.red("\n❌ Usage:\n"));
+  console.log(chalk.cyan('bun run scheduler/update-task-email.ts "task-id" "your@email.com"\n'));
+  console.log(chalk.dim("To find task IDs, run: jimmy jet → Scheduler → List all tasks\n"));
+  process.exit(1);
+}
+
+if (!email.includes("@")) {
+  console.log(chalk.red("\n❌ Invalid email address\n"));
+  process.exit(1);
+}
+
+async function updateTaskEmail() {
+  const task = await getTaskById(taskId as string);
+  
+  if (!task) {
+    console.log(chalk.red(`\n❌ Task not found: ${taskId}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold(`\nUpdating task: ${task.name}`));
+  console.log(chalk.dim(`Current steps:`));
+  task.steps.forEach((s) => console.log(`  ${s.order}. [${s.type}] ${s.instruction}`));
+
+  // Update all email_send steps
+  const updatedSteps = task.steps.map((step) => {
+    if (step.type === "email_send") {
+      // Replace any existing email or USER_EMAIL with the new one
+      let newInstruction = step.instruction
+        .replace(/USER_EMAIL/g, email as string)
+        .replace(/recipient@example\.com/g, email as string)
+        .replace(/to [^\s@]+@[^\s@]+/g, `to ${email}`);
+      
+      // If no "to X" pattern found, append it
+      if (!newInstruction.includes("to ") || !newInstruction.includes("@")) {
+        newInstruction = `${newInstruction} to ${email}`;
+      }
+      
+      return { ...step, instruction: newInstruction };
+    }
+    return step;
+  });
+
+  await updateTask(taskId as string, { steps: updatedSteps });
+
+  console.log(chalk.green(`\n✓ Updated email steps to send to: ${email}\n`));
+  console.log(chalk.dim("Updated steps:"));
+  updatedSteps.forEach((s) => {
+    if (s.type === "email_send") {
+      console.log(chalk.cyan(`  ${s.order}. [${s.type}] ${s.instruction}`));
+    }
+  });
+  console.log();
+}
+
+updateTaskEmail().catch((err) => {
+  console.error(chalk.red(`\n✖ ${err instanceof Error ? err.message : String(err)}\n`));
+  process.exit(1);
+});

package/supabase/.temp/cli-latest

@@ -0,0 +1 @@
+v2.105.0

package/supabase/.temp/gotrue-version

@@ -0,0 +1 @@
+v2.189.0

package/supabase/.temp/linked-project.json

@@ -0,0 +1 @@
+{"ref":"ebqpfhzeswycagvzgtik","name":"Jimmy AI","organization_id":"rqgvjmsbeivsipzjozzh","organization_slug":"rqgvjmsbeivsipzjozzh"}

package/supabase/.temp/pooler-url

@@ -0,0 +1 @@
+postgresql://postgres.ebqpfhzeswycagvzgtik@aws-1-ap-southeast-2.pooler.supabase.com:5432/postgres

package/supabase/.temp/postgres-version

@@ -0,0 +1 @@
+17.6.1.127