jerob 1.0.0

package/scheduler/db-migrate.ts

@@ -0,0 +1,271 @@
+/**
+ * Runs the one-time Supabase schema setup automatically.
+ *
+ * SQL migrations + Edge Function deployment use the Supabase Management API
+ * which requires a PERSONAL ACCESS TOKEN (not the service role key).
+ * Get one at: https://supabase.com/dashboard/account/tokens
+ *
+ * The service role key is only used at runtime (stored in user_config / Edge Function secrets).
+ */
+
+import chalk from "chalk";
+
+// ─── SQL Migrations ───────────────────────────────────────────────────────────
+
+const MIGRATIONS: { label: string; sql: string }[] = [
+  {
+    label: "Enable pg_cron extension",
+    sql: `CREATE EXTENSION IF NOT EXISTS pg_cron; GRANT USAGE ON SCHEMA cron TO postgres;`,
+  },
+  {
+    label: "Create scheduler_tasks table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS scheduler_tasks (
+        id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name          TEXT NOT NULL,
+        description   TEXT NOT NULL DEFAULT '',
+        cron          TEXT NOT NULL,
+        enabled       BOOLEAN NOT NULL DEFAULT true,
+        steps         JSONB NOT NULL DEFAULT '[]',
+        summary_email TEXT,
+        created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        last_run_at   TIMESTAMPTZ,
+        next_run_at   TIMESTAMPTZ,
+        run_count     INTEGER NOT NULL DEFAULT 0
+      );`,
+  },
+  {
+    label: "Create scheduler_runs table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS scheduler_runs (
+        id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        task_id      UUID NOT NULL REFERENCES scheduler_tasks(id) ON DELETE CASCADE,
+        started_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        finished_at  TIMESTAMPTZ,
+        status       TEXT NOT NULL DEFAULT 'running' CHECK (status IN ('running','success','failed')),
+        output       TEXT,
+        error        TEXT,
+        step_results JSONB NOT NULL DEFAULT '[]'
+      );`,
+  },
+  {
+    label: "Create user_config table",
+    sql: `
+      CREATE TABLE IF NOT EXISTS user_config (
+        key        TEXT PRIMARY KEY,
+        value      TEXT NOT NULL,
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      );`,
+  },
+  {
+    label: "Enable Row Level Security",
+    sql: `
+      ALTER TABLE scheduler_tasks ENABLE ROW LEVEL SECURITY;
+      ALTER TABLE scheduler_runs  ENABLE ROW LEVEL SECURITY;
+      ALTER TABLE user_config     ENABLE ROW LEVEL SECURITY;`,
+  },
+  {
+    label: "Create RLS policies",
+    sql: `
+      DROP POLICY IF EXISTS "Service role full access" ON scheduler_tasks;
+      DROP POLICY IF EXISTS "Service role full access" ON scheduler_runs;
+      DROP POLICY IF EXISTS "Service role full access" ON user_config;
+      CREATE POLICY "Service role full access" ON scheduler_tasks FOR ALL USING (auth.role() = 'service_role');
+      CREATE POLICY "Service role full access" ON scheduler_runs  FOR ALL USING (auth.role() = 'service_role');
+      CREATE POLICY "Service role full access" ON user_config     FOR ALL USING (auth.role() = 'service_role');`,
+  },
+];
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+/** "https://abcdefgh.supabase.co" → "abcdefgh" */
+function extractProjectRef(supabaseUrl: string): string | null {
+  const match = supabaseUrl.match(/https:\/\/([^.]+)\.supabase\.co/);
+  return match?.[1] ?? null;
+}
+
+/** Execute raw SQL via the Supabase Management API (requires personal access token). */
+async function execSql(projectRef: string, accessToken: string, sql: string): Promise<void> {
+  const res = await fetch(
+    `https://api.supabase.com/v1/projects/${projectRef}/database/query`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: JSON.stringify({ query: sql }),
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`SQL failed (${res.status}): ${body}`);
+  }
+}
+
+// ─── pg_cron ──────────────────────────────────────────────────────────────────
+
+async function runCronSchedule(
+  projectRef: string,
+  accessToken: string,
+  serviceRoleKey: string
+): Promise<void> {
+  const sql = `
+    SELECT cron.unschedule('jerob-scheduler-tick')
+    WHERE EXISTS (SELECT 1 FROM cron.job WHERE jobname = 'jerob-scheduler-tick');
+
+    SELECT cron.schedule(
+      'jerob-scheduler-tick',
+      '* * * * *',
+      $sql$
+      SELECT net.http_post(
+        url     := 'https://${projectRef}.supabase.co/functions/v1/scheduler-tick',
+        headers := jsonb_build_object(
+          'Content-Type',  'application/json',
+          'Authorization', 'Bearer ${serviceRoleKey}'
+        ),
+        body    := '{}'::jsonb
+      );
+      $sql$
+    );
+  `;
+  await execSql(projectRef, accessToken, sql);
+}
+
+// ─── Edge Function deployment ─────────────────────────────────────────────────
+
+/**
+ * Deploys the Edge Function using the Supabase CLI if installed.
+ * The Management REST API cannot bundle Deno TypeScript — only the CLI can.
+ */
+async function deployEdgeFunction(projectRef: string, accessToken: string): Promise<void> {
+  // Check if supabase CLI is available
+  const { execSync } = await import("node:child_process");
+
+  try {
+    execSync("supabase --version", { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      "Supabase CLI not installed. Install it from https://supabase.com/docs/guides/cli then run `jerob setup-db` again, or deploy manually with: supabase functions deploy scheduler-tick"
+    );
+  }
+
+  // Login with access token non-interactively, then link project, then deploy
+  try {
+    execSync(`supabase login --token ${accessToken}`, { stdio: "pipe" });
+  } catch {
+    // login may fail if already logged in — continue
+  }
+
+  try {
+    execSync(`supabase link --project-ref ${projectRef}`, { stdio: "pipe" });
+  } catch {
+    // link may fail if already linked — continue
+  }
+
+  // Deploy — throws if it fails
+  execSync("supabase functions deploy scheduler-tick --no-verify-jwt", {
+    stdio: "pipe",
+    cwd: process.cwd(),
+  });
+}
+
+/**
+ * Sets secrets on the Edge Function.
+ * NOTE: Supabase blocks the "SUPABASE_" prefix — use APP_ prefix instead.
+ * The Edge Function reads APP_DB_URL and APP_SERVICE_KEY.
+ */
+async function setEdgeFunctionSecrets(
+  projectRef: string,
+  accessToken: string,
+  supabaseUrl: string,
+  serviceRoleKey: string
+): Promise<void> {
+  const res = await fetch(`https://api.supabase.com/v1/projects/${projectRef}/secrets`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`,
+    },
+    body: JSON.stringify([
+      { name: "APP_DB_URL", value: supabaseUrl },
+      { name: "APP_SERVICE_KEY", value: serviceRoleKey },
+    ]),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Secret upload failed (${res.status}): ${body}`);
+  }
+}
+
+// ─── Main entry point ─────────────────────────────────────────────────────────
+
+/**
+ * @param supabaseUrl    https://xxx.supabase.co
+ * @param serviceRoleKey Runtime service role key (stored in secrets/user_config)
+ * @param accessToken    Personal access token for Management API (setup only)
+ */
+export async function runDbMigrations(
+  supabaseUrl: string,
+  serviceRoleKey: string,
+  accessToken: string
+): Promise<void> {
+  const projectRef = extractProjectRef(supabaseUrl);
+  if (!projectRef) {
+    console.log(chalk.yellow("⚠ Could not parse project ref from Supabase URL — skipping."));
+    console.log(chalk.dim("  Expected format: https://YOUR_REF.supabase.co"));
+    return;
+  }
+
+  console.log(chalk.bold("\n🗄  Setting up Supabase...\n"));
+
+  // 1. SQL migrations
+  for (const migration of MIGRATIONS) {
+    process.stdout.write(chalk.dim(`  ${migration.label}... `));
+    try {
+      await execSql(projectRef, accessToken, migration.sql);
+      console.log(chalk.green("✓"));
+    } catch (err: any) {
+      const msg: string = err?.message ?? String(err);
+      if (msg.includes("already exists")) {
+        console.log(chalk.dim("already exists, skipped"));
+      } else {
+        console.log(chalk.red(`✗ ${msg}`));
+        console.log(chalk.yellow("  Run scheduler/SETUP-READY.sql manually if needed."));
+      }
+    }
+  }
+
+  // 2. Deploy Edge Function
+  process.stdout.write(chalk.dim(`  Deploy scheduler-tick Edge Function... `));
+  try {
+    await deployEdgeFunction(projectRef, accessToken);
+    console.log(chalk.green("✓"));
+  } catch (err: any) {
+    console.log(chalk.yellow(`⚠ ${err?.message ?? err}`));
+    console.log(chalk.dim("  Deploy manually: supabase functions deploy scheduler-tick"));
+  }
+
+  // 3. Set Edge Function secrets
+  process.stdout.write(chalk.dim(`  Set Edge Function secrets... `));
+  try {
+    await setEdgeFunctionSecrets(projectRef, accessToken, supabaseUrl, serviceRoleKey);
+    console.log(chalk.green("✓"));
+  } catch (err: any) {
+    console.log(chalk.yellow(`⚠ ${err?.message ?? err}`));
+  }
+
+  // 4. pg_cron schedule
+  process.stdout.write(chalk.dim(`  Schedule Edge Function via pg_cron... `));
+  try {
+    await runCronSchedule(projectRef, accessToken, serviceRoleKey);
+    console.log(chalk.green("✓"));
+  } catch (err: any) {
+    console.log(chalk.yellow(`⚠ pg_cron: ${err?.message ?? err}`));
+    console.log(chalk.dim("  Enable pg_cron: Supabase Dashboard → Database → Extensions"));
+  }
+
+  console.log(chalk.green.bold("\n✅ Supabase fully set up — scheduler is live!\n"));
+}

package/scheduler/db.ts

@@ -0,0 +1,162 @@
+import { createClient, type SupabaseClient } from "@supabase/supabase-js";
+
+// Lazy init — don't crash at import time if env vars are missing.
+// getDb() is called at the first actual DB operation, giving .env time to load.
+let _db: SupabaseClient | null = null;
+
+export function getDb(): SupabaseClient {
+  if (_db) return _db;
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.SUPABASE_KEY;
+  if (!url || !key) {
+    throw new Error(
+      "Supabase is not configured. Add SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY to your .env file."
+    );
+  }
+  _db = createClient(url, key);
+  return _db;
+}
+
+// ── Types mirroring the DB schema ─────────────────────────────────────────────
+
+export interface SchedulerTask {
+  id: string;
+  name: string;
+  description: string;
+  cron: string;
+  enabled: boolean;
+  steps: TaskStep[];
+  summary_email: string | null;
+  created_at: string;
+  updated_at: string;
+  last_run_at: string | null;
+  next_run_at: string | null;
+  run_count: number;
+}
+
+export interface TaskStep {
+  order: number;
+  type: "web_search" | "web_crawl" | "email_send" | "custom";
+  instruction: string;
+}
+
+export interface SchedulerRun {
+  id: string;
+  task_id: string;
+  started_at: string;
+  finished_at: string | null;
+  status: "running" | "success" | "failed";
+  output: string | null;
+  error: string | null;
+  step_results: StepResult[];
+}
+
+export interface StepResult {
+  order: number;
+  instruction: string;
+  output: string;
+  success: boolean;
+}
+
+// Convenience typed query builder — avoids repeating `as any` everywhere.
+// The untyped Supabase client infers `never` for table columns without a
+// generated schema, so we go through `any` at the `.from()` boundary only.
+function table(name: string) {
+  return getDb().from(name) as any;
+}
+
+// ── DB helpers ────────────────────────────────────────────────────────────────
+
+export async function createTask(
+  data: Omit<SchedulerTask, "id" | "created_at" | "updated_at" | "last_run_at" | "run_count">
+): Promise<SchedulerTask> {
+  const { data: row, error } = await table("scheduler_tasks")
+    .insert({ ...data, next_run_at: data.next_run_at ?? null })
+    .select()
+    .single();
+  if (error) throw new Error(`Failed to create task: ${error.message}`);
+  return row as SchedulerTask;
+}
+
+export async function getAllTasks(): Promise<SchedulerTask[]> {
+  const { data, error } = await table("scheduler_tasks")
+    .select("*")
+    .order("created_at", { ascending: false });
+  if (error) throw new Error(`Failed to fetch tasks: ${error.message}`);
+  return (data ?? []) as SchedulerTask[];
+}
+
+export async function getTaskById(id: string): Promise<SchedulerTask | null> {
+  const { data, error } = await table("scheduler_tasks")
+    .select("*")
+    .eq("id", id)
+    .single();
+  if (error) return null;
+  return data as SchedulerTask;
+}
+
+export async function updateTask(
+  id: string,
+  patch: Partial<Omit<SchedulerTask, "id" | "created_at">>
+): Promise<SchedulerTask> {
+  const { data, error } = await table("scheduler_tasks")
+    .update({ ...patch, updated_at: new Date().toISOString() })
+    .eq("id", id)
+    .select()
+    .single();
+  if (error) throw new Error(`Failed to update task: ${error.message}`);
+  return data as SchedulerTask;
+}
+
+export async function deleteTask(id: string): Promise<void> {
+  const { error } = await table("scheduler_tasks").delete().eq("id", id);
+  if (error) throw new Error(`Failed to delete task: ${error.message}`);
+}
+
+export async function getEnabledDueTasks(): Promise<SchedulerTask[]> {
+  const now = new Date().toISOString();
+  const { data, error } = await table("scheduler_tasks")
+    .select("*")
+    .eq("enabled", true)
+    .lte("next_run_at", now);
+  if (error) throw new Error(`Failed to fetch due tasks: ${error.message}`);
+  return (data ?? []) as SchedulerTask[];
+}
+
+export async function createRun(taskId: string): Promise<SchedulerRun> {
+  const { data, error } = await table("scheduler_runs")
+    .insert({ task_id: taskId, status: "running", step_results: [] })
+    .select()
+    .single();
+  if (error) throw new Error(`Failed to create run record: ${error.message}`);
+  return data as SchedulerRun;
+}
+
+export async function finishRun(
+  runId: string,
+  status: "success" | "failed",
+  output: string,
+  stepResults: StepResult[],
+  errorMsg?: string
+): Promise<void> {
+  const { error } = await table("scheduler_runs")
+    .update({
+      status,
+      output,
+      error: errorMsg ?? null,
+      step_results: stepResults,
+      finished_at: new Date().toISOString(),
+    })
+    .eq("id", runId);
+  if (error) throw new Error(`Failed to finish run record: ${error.message}`);
+}
+
+export async function getRunsForTask(taskId: string, limit = 10): Promise<SchedulerRun[]> {
+  const { data, error } = await table("scheduler_runs")
+    .select("*")
+    .eq("task_id", taskId)
+    .order("started_at", { ascending: false })
+    .limit(limit);
+  if (error) throw new Error(`Failed to fetch runs: ${error.message}`);
+  return (data ?? []) as SchedulerRun[];
+}

package/scheduler/debug.ts

@@ -0,0 +1,184 @@
+/**
+ * Scheduler Debug Helper
+ * Run: bun run scheduler/debug.ts
+ */
+
+import { getDb, getAllTasks, getRunsForTask } from "./db";
+import chalk from "chalk";
+
+async function checkCredentials() {
+  console.log(chalk.bold("\n🔑 Checking Credentials in user_config...\n"));
+  
+  const { data, error } = await getDb().from("user_config").select("key,updated_at");
+  
+  if (error) {
+    console.log(chalk.red(`❌ Error: ${error.message}`));
+    return;
+  }
+  
+  if (!data || data.length === 0) {
+    console.log(chalk.red("❌ No credentials found in user_config table!"));
+    console.log(chalk.yellow("\nRun this to sync: bun run index.ts sync-credentials\n"));
+    return;
+  }
+  
+  const keys = [
+    "openrouter_key",
+    "groq_api_key",
+    "firecrawl_key",
+    "google_client_id",
+    "google_client_secret",
+    "google_refresh_token",
+  ];
+  
+  console.log("Credential Status:");
+  for (const key of keys) {
+    const found = data.find((r: any) => r.key === key);
+    if (found) {
+      console.log(`  ${chalk.green("✓")} ${key} (updated: ${new Date((found as any).updated_at).toLocaleString()})`);
+    } else {
+      console.log(`  ${chalk.red("✖")} ${key} ${chalk.dim("(missing)")}`);
+    }
+  }
+  console.log();
+}
+
+async function checkTasks() {
+  console.log(chalk.bold("📋 Tasks:\n"));
+  
+  const tasks = await getAllTasks();
+  
+  if (tasks.length === 0) {
+    console.log(chalk.yellow("No tasks found.\n"));
+    return;
+  }
+  
+  for (const t of tasks) {
+    console.log(chalk.bold(`${t.name}`));
+    console.log(`  ID:         ${t.id}`);
+    console.log(`  Status:     ${t.enabled ? chalk.green("enabled") : chalk.red("disabled")}`);
+    console.log(`  Cron:       ${t.cron}`);
+    console.log(`  Next run:   ${t.next_run_at ? new Date(t.next_run_at).toLocaleString() : chalk.dim("not scheduled")}`);
+    console.log(`  Last run:   ${t.last_run_at ? new Date(t.last_run_at).toLocaleString() : chalk.dim("never")}`);
+    console.log(`  Run count:  ${t.run_count}`);
+    console.log(`  Steps:      ${t.steps.length}`);
+    t.steps.forEach((s) => console.log(`    ${s.order}. [${s.type}] ${s.instruction}`));
+    
+    // Check last 3 runs
+    const runs = await getRunsForTask(t.id, 3);
+    if (runs.length > 0) {
+      console.log(chalk.dim(`  Recent runs (${runs.length}):`));
+      runs.forEach((r, i) => {
+        const icon = r.status === "success" ? chalk.green("✓") : r.status === "failed" ? chalk.red("✖") : chalk.yellow("⟳");
+        console.log(`    ${icon} ${new Date(r.started_at).toLocaleString()} — ${r.status}`);
+        if (r.error) console.log(chalk.red(`       Error: ${r.error.slice(0, 100)}`));
+        if (r.output) console.log(chalk.dim(`       ${r.output.slice(0, 100)}`));
+      });
+    } else {
+      console.log(chalk.dim("  No runs yet"));
+    }
+    console.log();
+  }
+}
+
+async function checkCronStatus() {
+  console.log(chalk.bold("⏰ Checking pg_cron Status...\n"));
+  
+  try {
+    // Check if cron job exists
+    const { data: cronJobs, error: cronError } = await getDb().rpc("pg_cron_job_status" as any);
+    
+    if (cronError && cronError.message.includes("does not exist")) {
+      console.log(chalk.yellow("⚠️  Cannot check pg_cron status via RPC (normal for some Supabase setups)"));
+      console.log(chalk.dim("Run this SQL in Supabase SQL Editor to check:"));
+      console.log(chalk.cyan("  select * from cron.job;"));
+      console.log(chalk.cyan("  select * from cron.job_run_details where jobname = 'jimmy-scheduler-tick' order by start_time desc limit 5;"));
+      console.log();
+      return;
+    }
+    
+    if (cronError) {
+      console.log(chalk.red(`❌ Error: ${cronError.message}`));
+      return;
+    }
+    
+    console.log("Cron jobs:", cronJobs);
+  } catch (e) {
+    console.log(chalk.yellow("⚠️  Could not check cron status directly"));
+    console.log(chalk.dim("This is normal — check manually in Supabase SQL Editor"));
+  }
+  console.log();
+}
+
+async function testEdgeFunctionManually() {
+  console.log(chalk.bold("🧪 Manual Edge Function Trigger...\n"));
+  
+  const url = process.env.SUPABASE_URL;
+  const key = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.SUPABASE_KEY;
+  
+  if (!url || !key) {
+    console.log(chalk.red("❌ SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY not set in .env"));
+    return;
+  }
+  
+  const functionUrl = `${url}/functions/v1/scheduler-tick`;
+  console.log(`Calling: ${functionUrl}\n`);
+  
+  try {
+    const res = await fetch(functionUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
+      body: JSON.stringify({}),
+    });
+    
+    const text = await res.text();
+    
+    if (res.ok) {
+      console.log(chalk.green(`✓ Success (${res.status})`));
+      try {
+        const data = JSON.parse(text);
+        console.log(chalk.bold("\nResponse:"));
+        console.log(JSON.stringify(data, null, 2));
+      } catch {
+        console.log(text);
+      }
+    } else {
+      console.log(chalk.red(`✖ Failed (${res.status}): ${text}`));
+    }
+  } catch (err) {
+    console.log(chalk.red(`✖ Error: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  console.log();
+}
+
+async function main() {
+  console.log(chalk.bold.cyan("\n════════════════════════════════════════════════"));
+  console.log(chalk.bold.cyan("  Jimmy Scheduler Debug Tool"));
+  console.log(chalk.bold.cyan("════════════════════════════════════════════════"));
+  
+  await checkCredentials();
+  await checkTasks();
+  await checkCronStatus();
+  
+  console.log(chalk.bold("────────────────────────────────────────────────"));
+  console.log(chalk.bold("Manual Test (optional)"));
+  console.log(chalk.bold("────────────────────────────────────────────────\n"));
+  console.log("This will manually trigger the Edge Function to test if it works:");
+  console.log(chalk.dim("(Press Ctrl+C to skip, or wait 3 seconds...)\n"));
+  
+  await new Promise((r) => setTimeout(r, 3000));
+  
+  await testEdgeFunctionManually();
+  
+  console.log(chalk.bold.green("✓ Debug complete\n"));
+  console.log(chalk.dim("Next steps:"));
+  console.log("  • Check Edge Function logs: supabase functions logs scheduler-tick");
+  console.log("  • View runs in Supabase: select * from scheduler_runs order by started_at desc;");
+  console.log("  • Check cron job: select * from cron.job_run_details where jobname = 'jimmy-scheduler-tick';");
+  console.log();
+}
+
+main().catch((err) => {
+  console.error(chalk.red(`\n✖ Debug tool crashed: ${err instanceof Error ? err.message : String(err)}\n`));
+  process.exit(1);
+});