jerob 1.0.0

package/auth/env-writer.ts

@@ -0,0 +1,82 @@
+/**
+ * Writes/updates the project .env file from decrypted keys.
+ * Called after login — no user ever needs to manually create a .env file.
+ * Keys that are empty are omitted. Existing .env entries NOT in our key set are preserved.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+const ENV_PATH = path.resolve(process.cwd(), ".env");
+
+const MANAGED_KEYS = new Set([
+  "OPENROUTER_KEY",
+  "OPENROUTER_MODEL",
+  "OPENROUTER_TIER",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "GROQ_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "TELEGRAM_BOT_TOKEN",
+  "TELEGRAM_OWNER_ID",
+  "SUPABASE_URL",
+  "SUPABASE_SERVICE_ROLE_KEY",
+  "SUPABASE_ACCESS_TOKEN",
+  "GOOGLE_CLIENT_ID",
+  "GOOGLE_CLIENT_SECRET",
+  "FIRECRAWL_KEY",
+  "APIFY_API_KEY",
+  "BROWSERBASE_API_KEY",
+  "BROWSERBASE_PRODUCT_ID",
+  "PREFERRED_PROVIDERS",
+  "MODEL_OPENROUTER_PAID",
+  "MODEL_GEMINI",
+  "MODEL_CLAUDE",
+  "MODEL_OPENAI",
+  "MODEL_GROQ",
+  "PORT",
+]);
+
+export function writeEnvFile(keys: Record<string, string>): void {
+  // PORT is always 8787
+  keys["PORT"] = "8787";
+
+  let existingLines: string[] = [];
+  if (fs.existsSync(ENV_PATH)) {
+    existingLines = fs.readFileSync(ENV_PATH, "utf8").split("\n");
+  }
+
+  const written = new Set<string>();
+  const seenKeys = new Set<string>();
+
+  const updatedLines = existingLines
+    .map((line) => {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+      if (!match) return line; // comment or blank — keep as-is
+      const key = match[1]!;
+
+      // Drop duplicate occurrences of the same key
+      if (seenKeys.has(key)) return null;
+      seenKeys.add(key);
+
+      if (!MANAGED_KEYS.has(key)) return line; // not ours — keep as-is
+
+      written.add(key);
+      const value = keys[key];
+      // Always write a value for PORT; omit blank non-PORT managed keys
+      if (!value) return key === "PORT" ? `PORT=8787` : `${key}=`;
+      return `${key}=${value}`;
+    })
+    .filter((line): line is string => line !== null);
+
+  // Append managed keys not yet in the file
+  const newLines: string[] = [];
+  for (const [key, value] of Object.entries(keys)) {
+    if (MANAGED_KEYS.has(key) && !written.has(key) && value) {
+      newLines.push(`${key}=${value}`);
+    }
+  }
+
+  const final = [...updatedLines, ...newLines].join("\n").trimEnd() + "\n";
+  fs.writeFileSync(ENV_PATH, final, "utf8");
+}

package/bin/jerob.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+/**
+ * npm entry point for jerob.
+ * Requires Bun to be installed: https://bun.sh
+ * Shells out to Bun so the TypeScript source runs natively.
+ */
+const { execFileSync } = require("node:child_process");
+const path = require("node:path");
+
+// Check Bun is available
+try {
+  execFileSync("bun", ["--version"], { stdio: "ignore" });
+} catch {
+  console.error(
+    "\n[jerob] Bun is required but not installed.\n" +
+    "Install it from https://bun.sh and try again.\n" +
+    "  Windows: powershell -c \"irm bun.sh/install.ps1 | iex\"\n" +
+    "  macOS/Linux: curl -fsSL https://bun.sh/install | bash\n"
+  );
+  process.exit(1);
+}
+
+const entry = path.join(__dirname, "..", "index.ts");
+
+execFileSync("bun", [entry, ...process.argv.slice(2)], {
+  stdio: "inherit",
+  cwd: process.cwd(),
+});

package/config/ai.config.ts

@@ -0,0 +1,163 @@
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { createGroq } from "@ai-sdk/groq";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import type { LanguageModel } from "ai";
+
+// ── Defaults — used when no MODEL_* override is set ──────────────────────────
+export const DEFAULT_MODELS = {
+  openrouter_free: "openrouter/free",
+  openrouter_paid: "anthropic/claude-3.5-sonnet",
+  gemini:  "gemini-3.1-flash-lite-preview",
+  claude:  "claude-3-5-sonnet-20241022",
+  openai:  "gpt-4o-mini",
+  groq:    "llama-3.3-70b-versatile",
+} as const;
+
+// ── Active model per provider ─────────────────────────────────────────────────
+// MODEL_* env vars are written by auth/env-writer.ts from stored modelOverrides.
+function activeModel(provider: keyof typeof DEFAULT_MODELS): string {
+  const key = `MODEL_${provider.toUpperCase().replace("-", "_")}`;
+  return process.env[key]?.trim() || DEFAULT_MODELS[provider];
+}
+
+// ── Provider builders ─────────────────────────────────────────────────────────
+
+function openrouterModel(modelId: string): LanguageModel | null {
+  const key = process.env.OPENROUTER_KEY?.trim();
+  if (!key || !key.startsWith("sk-or-v1-")) return null;
+  return createOpenRouter({ apiKey: key })(modelId);
+}
+
+function geminiModel(modelId?: string): LanguageModel | null {
+  const key = process.env.GOOGLE_GENERATIVE_AI_API_KEY?.trim();
+  if (!key) return null;
+  return createGoogleGenerativeAI({ apiKey: key })(modelId ?? activeModel("gemini"));
+}
+
+function claudeModel(modelId?: string): LanguageModel | null {
+  const key = process.env.ANTHROPIC_API_KEY?.trim();
+  if (!key) return null;
+  return createAnthropic({ apiKey: key })(modelId ?? activeModel("claude"));
+}
+
+function openaiModel(modelId?: string): LanguageModel | null {
+  const key = process.env.OPENAI_API_KEY?.trim();
+  if (!key) return null;
+  return createOpenAI({ apiKey: key })(modelId ?? activeModel("openai"));
+}
+
+function groqModel(modelId?: string): LanguageModel | null {
+  const key = process.env.GROQ_API_KEY?.trim();
+  if (!key) return null;
+  return createGroq({ apiKey: key })(modelId ?? activeModel("groq"));
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * Returns providers in the exact order the user chose during setup:
+ * [primary, ...optionalFallbacks, groq]
+ * Written to PREFERRED_PROVIDERS by auth/env-writer.ts.
+ */
+function preferredProviders(): string[] {
+  const raw = process.env.PREFERRED_PROVIDERS;
+  if (raw) return raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return ["groq"];
+}
+
+function modelForProvider(provider: string): LanguageModel | null {
+  switch (provider) {
+    case "gemini": return geminiModel();
+    case "claude": return claudeModel();
+    case "openai": return openaiModel();
+    case "groq":   return groqModel();
+    default:       return null;
+  }
+}
+
+function firstAvailable(
+  candidates: Array<() => LanguageModel | null>,
+  name: string
+): LanguageModel {
+  for (const build of candidates) {
+    const m = build();
+    if (m) return m;
+  }
+  throw new Error(
+    `No AI model available for ${name}. ` +
+    `Run \`jerob set-key\` to add API keys or switch models.`
+  );
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Primary model — Agent, Plan, Ask modes.
+ *
+ * Order:
+ *   1. OpenRouter (paid model or free slug, if key present)
+ *   2. User's chosen providers in their selected order (PREFERRED_PROVIDERS)
+ *      — primary first, optional fallbacks after, groq always last
+ */
+export function getAgentModel(): LanguageModel {
+  const tier  = process.env.OPENROUTER_TIER ?? "free";
+  const orKey = process.env.OPENROUTER_KEY?.trim();
+
+  const candidates: Array<() => LanguageModel | null> = [];
+
+  if (orKey) {
+    candidates.push(
+      tier === "paid"
+        ? () => openrouterModel(activeModel("openrouter_paid"))
+        : () => openrouterModel(DEFAULT_MODELS.openrouter_free)
+    );
+  }
+
+  // Respect user's chosen order exactly
+  for (const p of preferredProviders()) {
+    candidates.push(() => modelForProvider(p));
+  }
+
+  return firstAvailable(candidates, "Agent");
+}
+
+/**
+ * Secondary model — Scheduler planner, Browser Agent evaluator.
+ * Skips OpenRouter to avoid content refusals on structured prompts.
+ * Uses the same user-defined provider order as the primary model.
+ */
+export function getAgentModel2(): LanguageModel {
+  const providers = preferredProviders();
+  const candidates = providers.map((p) => () => modelForProvider(p));
+  // Groq is already last in preferredProviders from setup, but ensure it's there
+  if (!providers.includes("groq")) {
+    candidates.push(() => groqModel());
+  }
+  return firstAvailable(candidates, "Model2");
+}
+
+/**
+ * Fallback model — when primary refuses or hits rate limits.
+ * Uses user's provider order, then falls back to openrouter/free → groq.
+ */
+export function getAgentModel2Fallback(): LanguageModel {
+  const providers = preferredProviders();
+  const candidates: Array<() => LanguageModel | null> = providers.map(
+    (p) => () => modelForProvider(p)
+  );
+  // Final safety nets
+  candidates.push(() => openrouterModel(DEFAULT_MODELS.openrouter_free));
+  if (!providers.includes("groq")) candidates.push(() => groqModel());
+  return firstAvailable(candidates, "Fallback");
+}
+
+/**
+ * Explicit named model — for Stagehand/browser executor.
+ */
+export function getNamedModel(
+  provider: "gemini" | "claude" | "openai" | "groq"
+): LanguageModel {
+  return firstAvailable([() => modelForProvider(provider)], provider);
+}

package/email_ops/email-tools.ts

@@ -0,0 +1,178 @@
+import { tool } from "ai";
+import { z } from "zod";
+import {
+  sendMail,
+  readMail,
+  searchMail,
+  summarizeMail,
+  replyMail,
+  draftMail,
+  deleteMail,
+  archiveMail,
+  labelMail,
+  classifyMail,
+  extractTasks,
+  bulkAction,
+  digest,
+  scheduleSend,
+  sendDraft,
+  getThread,
+} from "./email_functions";
+
+export function createEmailTools() {
+  return {
+    email_send: tool({
+      description: "Send an email to one or more recipients.",
+      inputSchema: z.object({
+        to: z.union([z.string(), z.array(z.string())]).describe("Recipient email(s)"),
+        subject: z.string(),
+        body: z.string().describe("Plain text body"),
+        cc: z.array(z.string()).optional(),
+        bcc: z.array(z.string()).optional(),
+      }),
+      execute: async (input) => sendMail(input),
+    }),
+
+    email_read: tool({
+      description: "Read a single email by its message ID.",
+      inputSchema: z.object({
+        messageId: z.string(),
+      }),
+      execute: async ({ messageId }) => readMail({ messageId }),
+    }),
+
+    email_search: tool({
+      description:
+        'Search emails using Gmail query syntax (e.g. "from:foo@bar.com is:unread").',
+      inputSchema: z.object({
+        query: z.string(),
+        maxResults: z.number().optional().default(10),
+      }),
+      execute: async ({ query, maxResults }) => searchMail({ query, maxResults }),
+    }),
+
+    email_summarize: tool({
+      description: "Summarize an email using AI.",
+      inputSchema: z.object({
+        messageId: z.string(),
+      }),
+      execute: async ({ messageId }) => summarizeMail({ messageId }),
+    }),
+
+    email_reply: tool({
+      description: "Reply to an existing email, keeping the same thread.",
+      inputSchema: z.object({
+        messageId: z.string().describe("ID of the message to reply to"),
+        body: z.string().describe("Reply body text"),
+      }),
+      execute: async ({ messageId, body }) => replyMail({ messageId, body }),
+    }),
+
+    email_draft: tool({
+      description: "Save an email as a draft without sending.",
+      inputSchema: z.object({
+        to: z.union([z.string(), z.array(z.string())]),
+        subject: z.string(),
+        body: z.string(),
+        cc: z.array(z.string()).optional(),
+        bcc: z.array(z.string()).optional(),
+      }),
+      execute: async (input) => draftMail(input),
+    }),
+
+    email_delete: tool({
+      description: "Permanently delete an email by message ID.",
+      inputSchema: z.object({
+        messageId: z.string(),
+      }),
+      execute: async ({ messageId }) => deleteMail({ messageId }),
+    }),
+
+    email_archive: tool({
+      description: "Archive an email (removes it from Inbox).",
+      inputSchema: z.object({
+        messageId: z.string(),
+      }),
+      execute: async ({ messageId }) => archiveMail({ messageId }),
+    }),
+
+    email_label: tool({
+      description: "Add or remove labels on an email.",
+      inputSchema: z.object({
+        messageId: z.string(),
+        labelIds: z.array(z.string()).describe("Label IDs to add"),
+        removeLabelIds: z.array(z.string()).optional().describe("Label IDs to remove"),
+      }),
+      execute: async ({ messageId, labelIds, removeLabelIds }) =>
+        labelMail({ messageId, labelIds, removeLabelIds }),
+    }),
+
+    email_classify: tool({
+      description:
+        "Classify an email into a category (work, personal, newsletter, spam, finance, travel, support, social, other).",
+      inputSchema: z.object({
+        messageId: z.string(),
+      }),
+      execute: async ({ messageId }) => classifyMail({ messageId }),
+    }),
+
+    email_extract_tasks: tool({
+      description: "Extract action items and tasks from an email using AI.",
+      inputSchema: z.object({
+        messageId: z.string(),
+      }),
+      execute: async ({ messageId }) => extractTasks({ messageId }),
+    }),
+
+    email_bulk_action: tool({
+      description: "Perform an action on multiple emails at once.",
+      inputSchema: z.object({
+        messageIds: z.array(z.string()),
+        action: z.enum(["delete", "archive", "markRead", "markUnread", "label"]),
+        labelIds: z.array(z.string()).optional(),
+      }),
+      execute: async ({ messageIds, action, labelIds }) =>
+        bulkAction({ messageIds, action, labelIds }),
+    }),
+
+    email_digest: tool({
+      description: "Generate an AI digest summary of recent or filtered emails.",
+      inputSchema: z.object({
+        query: z.string().optional().default("is:unread in:inbox"),
+        maxResults: z.number().optional().default(10),
+      }),
+      execute: async ({ query, maxResults }) => digest({ query, maxResults }),
+    }),
+
+    email_schedule_send: tool({
+      description:
+        "Save an email as a draft scheduled for a future time. Returns draftId to send later.",
+      inputSchema: z.object({
+        to: z.union([z.string(), z.array(z.string())]),
+        subject: z.string(),
+        body: z.string(),
+        sendAt: z.string().describe("ISO 8601 datetime string for when to send"),
+        cc: z.array(z.string()).optional(),
+        bcc: z.array(z.string()).optional(),
+      }),
+      execute: async ({ sendAt, ...rest }) =>
+        scheduleSend({ ...rest, sendAt: new Date(sendAt) }),
+    }),
+
+    email_send_draft: tool({
+      description: "Send a previously saved draft by its draft ID.",
+      inputSchema: z.object({
+        draftId: z.string(),
+      }),
+      execute: async ({ draftId }) => sendDraft(draftId),
+    }),
+
+    email_thread: tool({
+      description: "Get all messages in an email thread.",
+      inputSchema: z.object({
+        threadId: z.string(),
+      }),
+      execute: async ({ threadId }) => getThread({ threadId }),
+    }),
+  };
+}