jerob 1.0.0

package/email_ops/types.ts

@@ -0,0 +1,88 @@
+export type SendMailInput = {
+  to: string | string[];
+  cc?: string[];
+  bcc?: string[];
+  subject: string;
+  body: string;
+  html?: string;
+  attachments?: string[];
+};
+
+export type ReadMailInput = {
+  messageId: string;
+};
+
+export type SearchMailInput = {
+  query: string;       // Gmail search query e.g. "from:foo@bar.com is:unread"
+  maxResults?: number;
+};
+
+export type ReplyMailInput = {
+  messageId: string;   // original message to reply to
+  body: string;
+};
+
+export type DraftMailInput = {
+  to: string | string[];
+  cc?: string[];
+  bcc?: string[];
+  subject: string;
+  body: string;
+};
+
+export type DeleteMailInput = {
+  messageId: string;
+};
+
+export type ArchiveMailInput = {
+  messageId: string;
+};
+
+export type LabelMailInput = {
+  messageId: string;
+  labelIds: string[];       // Gmail label IDs to add
+  removeLabelIds?: string[]; // optional labels to remove
+};
+
+export type WatchInput = {
+  topicName: string;         // Google Cloud Pub/Sub topic
+  labelIds?: string[];
+};
+
+export type ClassifyInput = {
+  messageId: string;
+};
+
+export type ExtractTasksInput = {
+  messageId: string;
+};
+
+export type BulkActionInput = {
+  messageIds: string[];
+  action: "delete" | "archive" | "markRead" | "markUnread" | "label";
+  labelIds?: string[];
+};
+
+export type DigestInput = {
+  maxResults?: number;
+  query?: string;
+};
+
+export type ScheduleSendInput = SendMailInput & {
+  sendAt: Date; // when to send
+};
+
+export type ThreadInput = {
+  threadId: string;
+};
+
+export type EmailMessage = {
+  id: string;
+  threadId: string;
+  from: string;
+  to: string;
+  subject: string;
+  body: string;
+  date: string;
+  labelIds: string[];
+};

package/index.ts

@@ -0,0 +1,176 @@
+#!/usr/bin/env bun
+import chalk from "chalk";
+import {program} from "commander";
+import { startArena } from "./tui/spinup";
+import { authenticate, getAllKeys, updateApiKey, resetAuth, switchModelFlow } from "./auth/auth";
+import { writeEnvFile } from "./auth/env-writer";
+import dotenv from "dotenv";
+dotenv.config({ path: "./.env" });
+
+program.name("jerob").description(" Your personal Assistant sits in your computer").version("0.1.0")
+
+program.command("jet")
+.description("agent spin up command")
+.action(
+    async()=>{
+        try {
+            const { config, password } = await authenticate();
+            const keys = getAllKeys(config, password);
+
+            // Write .env so subprocesses and tools that read it directly work too
+            writeEnvFile(keys);
+
+            // Apply all keys to process.env — set present values, clear stale ones
+            for (const [k, v] of Object.entries(keys)) {
+                if (v) {
+                    process.env[k] = v;
+                } else {
+                    delete process.env[k];
+                }
+            }
+            process.env.OPENROUTER_MODEL = process.env.OPENROUTER_MODEL || "openrouter/free";
+
+            // Auto-sync credentials to Supabase on every login — non-fatal
+            if (keys.SUPABASE_URL && keys.SUPABASE_SERVICE_ROLE_KEY) {
+                import("./scheduler/config-sync")
+                    .then(({ syncAllSecrets }) => syncAllSecrets())
+                    .catch(() => {}); // silent — don't block startup
+            }
+
+            await startArena()
+        } catch (error) {
+            if (error instanceof Error && error.message.includes("cancelled")) {
+                console.log(chalk.yellow("\n✓ Exited cleanly\n"));
+            } else {
+                console.log(chalk.red("Authentication failed"));
+                console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+            }
+            process.exit(0);
+        }
+    }
+)
+
+program.command("switch-model")
+.description("Switch the active model for any provider (OpenRouter, Gemini, Claude, OpenAI, Groq)")
+.action(async () => {
+    try {
+        const { config, password: pwd } = await authenticate();
+        await switchModelFlow(config, pwd);
+        // Rewrite .env with the updated model overrides
+        const keys = getAllKeys(config, pwd);
+        writeEnvFile(keys);
+        for (const [k, v] of Object.entries(keys)) {
+            if (v) {
+                process.env[k] = v;
+            } else {
+                delete process.env[k];
+            }
+        }
+    } catch (error) {
+        if (error instanceof Error && error.message.includes("cancelled")) {
+            console.log(chalk.yellow("\n✓ Cancelled\n"));
+        } else {
+            console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+        }
+        process.exit(0);
+    }
+});
+
+program.command("set-key")
+.description("Update stored API keys or model preferences")
+.action(async () => {
+    try {
+        await updateApiKey();
+    } catch (error) {
+        if (error instanceof Error && error.message.includes("cancelled")) {
+            console.log(chalk.yellow("\n✓ Update cancelled\n"));
+        } else {
+            console.log(chalk.red("Failed to update"));
+            console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+        }
+        process.exit(0);
+    }
+});
+
+program.command("reset-auth")
+.description("Remove stored auth config and API key")
+.action(async () => {
+    try {
+        resetAuth();
+        console.log(chalk.green("\n✓ Auth reset complete. Stored login and key removed.\n"));
+    } catch (error) {
+        console.log(chalk.red("Failed to reset auth"));
+        console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(0);
+    }
+});
+
+program.command("sync-credentials")
+.description("Sync API keys and credentials to Supabase user_config table")
+.action(async () => {
+    try {
+        const { syncAllSecrets } = await import("./scheduler/config-sync");
+        await syncAllSecrets();
+        console.log(chalk.green("\n✓ Credentials synced to Supabase user_config table\n"));
+    } catch (error) {
+        console.log(chalk.red("Sync failed"));
+        console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+});
+
+program.command("setup-db")
+.description("Run Supabase schema migrations (creates tables, RLS policies, pg_cron schedule)")
+.action(async () => {
+    try {
+        const { config, password } = await authenticate();
+        const keys = getAllKeys(config, password);
+        const url = keys.SUPABASE_URL;
+        const key = keys.SUPABASE_SERVICE_ROLE_KEY;
+        let token = keys.SUPABASE_ACCESS_TOKEN;
+
+        if (!url || !key) {
+            console.log(chalk.yellow("\n⚠ Supabase URL or service role key not configured."));
+            console.log(chalk.dim("  Run `jerob set-key` to add them first.\n"));
+            process.exit(1);
+        }
+
+        // If no stored token, prompt for it now
+        if (!token) {
+            const { text: promptText, isCancel } = await import("@clack/prompts");
+            console.log(chalk.dim("\n  Get your personal access token at: https://supabase.com/dashboard/account/tokens\n"));
+            const t = await promptText({
+                message: "Supabase personal access token:",
+                placeholder: "sbp_...",
+                validate: (v) => { if (!v?.trim()) return "Token required"; },
+            });
+            if (isCancel(t)) { console.log(chalk.yellow("\n✓ Cancelled\n")); return; }
+            token = String(t).trim();
+        }
+
+        const { runDbMigrations } = await import("./scheduler/db-migrate");
+        await runDbMigrations(url, key, token);
+    } catch (error) {
+        if (error instanceof Error && error.message.includes("cancelled")) {
+            console.log(chalk.yellow("\n✓ Cancelled\n"));
+        } else {
+            console.log(chalk.red("Migration failed"));
+            console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+        }
+        process.exit(1);
+    }
+});
+
+program.command("scheduler-debug")
+.description("Debug scheduler: check tasks, credentials, and test Edge Function")
+.action(async () => {
+    try {
+        await import("./scheduler/debug");
+    } catch (error) {
+        console.log(chalk.red("Scheduler debug failed"));
+        console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+});
+
+await program.parseAsync(process.argv)

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "jerob",
+  "version": "1.0.0",
+  "description": "Personal AI agent CLI — autonomous code agent, planner, browser automation, Q&A, and serverless scheduler",
+  "module": "index.ts",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "jerob": "./bin/jerob.js"
+  },
+  "files": [
+    "bin/",
+    "index.ts",
+    "agent/",
+    "ask/",
+    "auth/",
+    "CLI/",
+    "config/",
+    "email_ops/",
+    "plan/",
+    "scheduler/",
+    "supabase/",
+    "tui/",
+    "utils/",
+    "tsconfig.json",
+    "README.md",
+    "SETUP.md"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "llm",
+    "automation",
+    "browser-automation",
+    "scheduler",
+    "supabase",
+    "openrouter",
+    "gemini",
+    "claude",
+    "terminal"
+  ],
+  "author": "Abhishek Sharma",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ABHI-Theq/Jerob-Personal_AI_Operator.git"
+  },
+  "homepage": "https://github.com/ABHI-Theq/Jerob-Personal_AI_Operator#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.81",
+    "@ai-sdk/google": "^3.0.80",
+    "@ai-sdk/groq": "^3.0.39",
+    "@ai-sdk/openai": "^3.0.68",
+    "@browserbasehq/stagehand": "^3.4.0",
+    "@clack/core": "^1.4.0",
+    "@clack/prompts": "^1.5.0",
+    "@mendable/firecrawl-js": "^4.25.1",
+    "@openrouter/ai-sdk-provider": "^2.9.0",
+    "@supabase/supabase-js": "^2.107.0",
+    "@types/express": "^5.0.6",
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^25.9.1",
+    "ai": "^6.0.193",
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "crypto": "^1.0.1",
+    "diff": "^9.0.0",
+    "dotenv": "^17.4.2",
+    "express": "^5.2.1",
+    "figlet": "^1.11.0",
+    "googleapis": "^173.0.0",
+    "marked": "^18.0.4",
+    "marked-terminal": "^7.3.0",
+    "open": "^11.0.0",
+    "supabase": "^2.105.0",
+    "telegraf": "^4.16.3"
+  }
+}

package/plan/browser-agent/README.md

@@ -0,0 +1,118 @@
+# Browser Agent
+
+Autonomous browser automation using Stagehand's agent API with an iterative Plan → Execute → Evaluate loop (up to 5 cycles).
+
+## Architecture
+
+```
+User Query
+    │
+    ▼
+┌─────────────────────────────────────┐
+│  ITERATION LOOP (max 5)             │
+│                                     │
+│  1. PLANNER                         │
+│     LLM generates automation plan  │
+│     (with feedback on retry)        │
+│             │                       │
+│             ▼                       │
+│  2. EXECUTOR                        │
+│     Stagehand agent() runs the task │
+│     autonomously via DOM mode       │
+│             │                       │
+│             ▼                       │
+│  3. EVALUATOR                       │
+│     Scores result 0-100             │
+│     Checks completeness & accuracy  │
+│             │                       │
+│             ▼                       │
+│  4. DECISION                        │
+│     score ≥ 80  → done              │
+│     max iters   → return best       │
+│     otherwise   → feedback → retry  │
+└─────────────────────────────────────┘
+    │
+    ▼
+Final Result (console + optional JSON/MD save)
+```
+
+## Files
+
+| File | Role |
+|------|------|
+| `orchestrator.ts` | Entry point, manages iteration loop, renders report |
+| `planner.ts` | LLM generates a `BrowserPlan` (steps + goal + reasoning) |
+| `executor.ts` | Runs plan via Stagehand `agent()` in DOM mode, parses messages |
+| `evaluator.ts` | Scores execution, extracts feedback for next iteration |
+| `types.ts` | Shared TypeScript types |
+| `index.ts` | Re-exports all public API |
+
+## Browser Setup
+
+Uses Brave browser with a persistent profile for sites that require login (e.g. LinkedIn):
+
+```ts
+localBrowserLaunchOptions: {
+  executablePath: "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
+  args: [
+    '--user-data-dir=C:\\Users\\YOUR_USERNAME\\AppData\\Local\\BraveSoftware\\Brave-Browser\\User Data',
+    '--profile-directory=Default',
+  ],
+  headless: false,
+}
+```
+
+## Configuration
+
+In `orchestrator.ts`:
+
+```ts
+{
+  maxIterations: 5,
+  timeout: 120000,
+  model: "google/gemini-3.1-flash-lite-preview",
+  evaluationThreshold: 80   // score out of 100 to mark as satisfied
+}
+```
+
+## Environment Variables
+
+```
+GOOGLE_GENERATIVE_AI_API_KEY=...
+```
+
+## Usage
+
+```bash
+jimmy jet
+# Select "Browser Agent" from the menu
+# Enter your query
+```
+
+Example queries:
+```
+Find top 5 AI jobs on LinkedIn with full descriptions
+Get transcript of a YouTube video
+Extract product prices from a homepage
+Search flights NYC to LA under $300
+```
+
+## Supported Step Actions (Planner)
+
+`navigate` · `click` · `type` · `extract` · `observe` · `wait` · `scroll`
+
+> The executor doesn't run these step-by-step — it passes the plan goal directly to Stagehand's `agent()` which handles navigation autonomously.
+
+## Output
+
+After each run you can optionally save:
+- JSON file with full iteration log + extracted data
+- Markdown report with scores and agent output
+
+## Dependencies
+
+- `@browserbasehq/stagehand` — browser automation
+- `ai` + `@openrouter/ai-sdk-provider` — LLM calls
+- `@clack/prompts` — CLI prompts
+- `chalk` — terminal colors
+- `zod` — schema validation