notebooklm-api-client 0.1.0

package/.dockerignore

@@ -0,0 +1,7 @@
+node_modules
+dist
+.wrangler
+*.md
+*.toml
+tsconfig.json
+src

package/Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.12-slim
+
+RUN pip install --no-cache-dir notebooklm-py fastapi uvicorn
+
+WORKDIR /app
+COPY container/server.py /app/server.py
+
+EXPOSE 8080
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8080"]

package/container/server.py

@@ -0,0 +1,123 @@
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from fastapi import FastAPI, HTTPException, Request
+from pydantic import BaseModel
+
+app = FastAPI()
+
+AUTH_FILE = Path("/app/.auth.json")
+AUTH_JSON = os.environ.get("NOTEBOOKLM_AUTH_JSON", "")
+
+if AUTH_JSON and not AUTH_FILE.exists():
+    AUTH_FILE.write_text(AUTH_JSON)
+
+
+class Job(BaseModel):
+    action: str
+    notebookId: str | None = None
+    sourceUrls: list[str] | None = None
+    title: str | None = None
+    prompt: str | None = None
+
+
+def run_cmd(args: list[str], cwd: str) -> str:
+    env = os.environ.copy()
+    env["NOTEBOOKLM_AUTH_JSON"] = AUTH_JSON
+    result = subprocess.run(
+        args,
+        env=env,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    if result.returncode != 0:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Command failed: {result.stderr.strip()}",
+        )
+    return result.stdout.strip()
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.post("/store-auth")
+async def store_auth(request: Request):
+    body = await request.json()
+    AUTH_FILE.write_text(json.dumps(body, indent=2))
+    global AUTH_JSON
+    AUTH_JSON = json.dumps(body)
+    return {"stored": True}
+
+
+@app.post("/run")
+def run(job: Job):
+    with tempfile.TemporaryDirectory() as td:
+        if job.action == "list":
+            out = run_cmd(["notebooklm", "list", "--json"], td)
+            return json.loads(out)
+
+        if job.action == "create":
+            title = job.title or "Untitled"
+            out = run_cmd(["notebooklm", "create", title, "--json"], td)
+            result = json.loads(out)
+
+            if job.sourceUrls:
+                notebook_id = result.get("id", result.get("notebook_id"))
+                if notebook_id:
+                    run_cmd(["notebooklm", "use", notebook_id], td)
+                    for url in job.sourceUrls:
+                        run_cmd(["notebooklm", "source", "add", url], td)
+                    out = run_cmd(["notebooklm", "source", "list", "--json"], td)
+                    result["sources"] = json.loads(out)
+
+            return result
+
+        if job.action == "ask":
+            if not job.notebookId or not job.prompt:
+                raise HTTPException(
+                    status_code=400,
+                    detail="ask requires notebookId and prompt",
+                )
+            run_cmd(["notebooklm", "use", job.notebookId], td)
+            out = run_cmd(["notebooklm", "ask", job.prompt, "--json"], td)
+            return json.loads(out)
+
+        if job.action == "summarize":
+            if not job.sourceUrls or not job.prompt:
+                raise HTTPException(
+                    status_code=400,
+                    detail="summarize requires sourceUrls and prompt",
+                )
+            title = job.title or "Summary Job"
+            out = run_cmd(["notebooklm", "create", title, "--json"], td)
+            result = json.loads(out)
+            notebook_id = result.get("id", result.get("notebook_id"))
+
+            if notebook_id:
+                run_cmd(["notebooklm", "use", notebook_id], td)
+                for url in job.sourceUrls:
+                    run_cmd(["notebooklm", "source", "add", url], td)
+                out = run_cmd(["notebooklm", "ask", job.prompt, "--json"], td)
+                return json.loads(out)
+
+            raise HTTPException(status_code=500, detail="Failed to create notebook")
+
+        if job.action == "delete":
+            if not job.notebookId:
+                raise HTTPException(
+                    status_code=400,
+                    detail="delete requires notebookId",
+                )
+            out = run_cmd(
+                ["notebooklm", "delete", job.notebookId, "--json"], td
+            )
+            return json.loads(out) if out else {"deleted": True}
+
+        raise HTTPException(status_code=400, detail=f"Unknown action: {job.action}")

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "notebooklm-api-client",
+  "version": "0.1.0",
+  "description": "NotebookLM API via Cloudflare Containers — on-demand Python sandbox that sleeps when idle",
+  "author": "vtempest <grokthiscontact@gmail.com>",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OpenSourceAGI/qwksearch-research-agent.git",
+    "directory": "packages/notebooklm-api"
+  },
+  "type": "module",
+  "main": "./src/index.ts",
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "types": "wrangler types"
+  },
+  "dependencies": {
+    "@cloudflare/puppeteer": "^1.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20241127.0",
+    "typescript": "^5.9.3",
+    "wrangler": "^4.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,98 @@
+# notebooklm-api
+
+NotebookLM API powered by Cloudflare Containers. The Python sandbox runs on demand and sleeps after 5 minutes of inactivity to conserve costs.
+
+## Architecture
+
+```
+Request → Worker (auth + routing) → Container (notebooklm-py) → Response
+                                         ↕
+                                    sleeps when idle
+```
+
+- **Worker** validates auth and routes requests to the container
+- **Container** runs `notebooklm-py` CLI in a Python 3.12 sandbox
+- Container auto-sleeps after `sleepAfter` (5m) — billing stops until next request
+- Container wakes transparently on next incoming request
+
+## API
+
+All endpoints require `Authorization: Bearer <API_TOKEN>` header.
+
+### POST /
+
+```json
+{ "action": "list" }
+```
+
+```json
+{ "action": "create", "title": "My Notebook", "sourceUrls": ["https://..."] }
+```
+
+```json
+{ "action": "ask", "notebookId": "abc123", "prompt": "Summarize the key points" }
+```
+
+```json
+{ "action": "summarize", "sourceUrls": ["https://..."], "prompt": "What are the main findings?" }
+```
+
+```json
+{ "action": "delete", "notebookId": "abc123" }
+```
+
+## Login via Browser Automation
+
+The Worker uses Cloudflare Browser Rendering (Puppeteer) to automate Google login — no manual cookie export needed.
+
+```bash
+# First call — enters email + password, triggers 2FA
+curl -X POST https://notebooklm-api.<you>.workers.dev \
+  -H "Authorization: Bearer $API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"action": "login"}'
+
+# If 2FA is required — pass the security code
+curl -X POST https://notebooklm-api.<you>.workers.dev \
+  -H "Authorization: Bearer $API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"action": "login", "securityCode": "123456"}'
+```
+
+Auth cookies are stored in the container's Durable Object storage and injected on container start.
+
+## Setup
+
+1. Set secrets:
+   ```bash
+   wrangler secret put API_TOKEN
+   wrangler secret put GOOGLE_EMAIL
+   wrangler secret put GOOGLE_PASSWORD
+   ```
+
+2. Deploy:
+   ```bash
+   cd packages/notebooklm-api
+   wrangler deploy
+   ```
+
+3. Trigger login:
+   ```bash
+   curl -X POST https://notebooklm-api.<you>.workers.dev \
+     -H "Authorization: Bearer $TOKEN" \
+     -d '{"action": "login"}'
+   ```
+
+## Development
+
+```bash
+bun install
+wrangler dev
+```
+
+## Cost
+
+- Container only bills while awake (per 10ms granularity)
+- `basic` instance: 1/4 vCPU, 1 GiB RAM — ~$0.000005/sec when active
+- Idle = $0
+- `max_instances = 3` caps concurrent cost

package/src/index.ts

@@ -0,0 +1,195 @@
+import { Container } from "cloudflare:workers";
+import puppeteer from "@cloudflare/puppeteer";
+
+export interface Env {
+  NOTEBOOK_RUNNER: DurableObjectNamespace<NotebookRunner>;
+  BROWSER: Fetcher;
+  API_TOKEN: string;
+  GOOGLE_EMAIL: string;
+  GOOGLE_PASSWORD: string;
+}
+
+export interface NotebookJob {
+  action: "create" | "ask" | "summarize" | "list" | "delete" | "login";
+  notebookId?: string;
+  sourceUrls?: string[];
+  title?: string;
+  prompt?: string;
+  securityCode?: string;
+}
+
+export class NotebookRunner extends Container {
+  defaultPort = 8080;
+  sleepAfter = "5m";
+
+  override async onStart() {
+    this.ctx.container.start({
+      env: {
+        NOTEBOOKLM_AUTH_JSON: (await this.ctx.storage.get<string>("auth")) ?? "",
+      },
+      enableInternet: true,
+    });
+  }
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        headers: {
+          "access-control-allow-origin": "*",
+          "access-control-allow-methods": "POST, OPTIONS",
+          "access-control-allow-headers": "content-type, authorization",
+        },
+      });
+    }
+
+    if (request.method !== "POST") {
+      return json({ error: "Method not allowed" }, 405);
+    }
+
+    const authHeader = request.headers.get("authorization");
+    if (authHeader !== `Bearer ${env.API_TOKEN}`) {
+      return json({ error: "Unauthorized" }, 401);
+    }
+
+    let body: NotebookJob;
+    try {
+      body = await request.json();
+    } catch {
+      return json({ error: "Invalid JSON body" }, 400);
+    }
+
+    if (!body.action) {
+      return json({ error: "Missing action field" }, 400);
+    }
+
+    if (body.action === "login") {
+      return handleLogin(env, body.securityCode);
+    }
+
+    const id = env.NOTEBOOK_RUNNER.idFromName("default");
+    const stub = env.NOTEBOOK_RUNNER.get(id);
+
+    const containerResp = await stub.fetch("http://container/run", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    const result = await containerResp.text();
+    return new Response(result, {
+      status: containerResp.status,
+      headers: {
+        "content-type": "application/json",
+        "access-control-allow-origin": "*",
+      },
+    });
+  },
+};
+
+async function handleLogin(env: Env, securityCode?: string): Promise<Response> {
+  const browser = await puppeteer.launch(env.BROWSER);
+
+  try {
+    const page = await browser.newPage();
+    await page.setUserAgent(
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+    );
+
+    await page.goto("https://notebooklm.google.com", {
+      waitUntil: "networkidle0",
+    });
+
+    // Google sign-in: enter email
+    await page.waitForSelector('input[type="email"]', { timeout: 15000 });
+    await page.type('input[type="email"]', env.GOOGLE_EMAIL, { delay: 50 });
+    await page.click("#identifierNext");
+    await page.waitForNavigation({ waitUntil: "networkidle0" }).catch(() => {});
+
+    // Enter password
+    await page.waitForSelector('input[type="password"]', {
+      visible: true,
+      timeout: 15000,
+    });
+    await delay(1000);
+    await page.type('input[type="password"]', env.GOOGLE_PASSWORD, {
+      delay: 50,
+    });
+    await page.click("#passwordNext");
+    await page.waitForNavigation({ waitUntil: "networkidle0" }).catch(() => {});
+
+    // Handle security code / 2FA if provided
+    if (securityCode) {
+      await delay(2000);
+      const codeInput = await page.$(
+        'input[type="tel"], input[name="totpPin"], input[id="idvPin"]'
+      );
+      if (codeInput) {
+        await codeInput.type(securityCode, { delay: 50 });
+        const nextBtn = await page.$(
+          'button[data-idom-class*="next"], #idvPreregisteredPhoneNext, button[jsname="LgbsSe"]'
+        );
+        if (nextBtn) await nextBtn.click();
+        await page
+          .waitForNavigation({ waitUntil: "networkidle0", timeout: 15000 })
+          .catch(() => {});
+      }
+    }
+
+    // Wait for NotebookLM to load (confirms successful login)
+    await page.waitForSelector("body", { timeout: 10000 });
+    await delay(3000);
+
+    // Extract cookies and local storage auth
+    const cookies = await page.cookies();
+    const localStorage = await page.evaluate(() => {
+      const data: Record<string, string> = {};
+      for (let i = 0; i < window.localStorage.length; i++) {
+        const key = window.localStorage.key(i)!;
+        data[key] = window.localStorage.getItem(key)!;
+      }
+      return data;
+    });
+
+    const authData = JSON.stringify({
+      cookies,
+      localStorage,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Store auth in the container's Durable Object storage
+    const id = env.NOTEBOOK_RUNNER.idFromName("default");
+    const stub = env.NOTEBOOK_RUNNER.get(id);
+    await stub.fetch("http://container/store-auth", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: authData,
+    });
+
+    return json({
+      success: true,
+      message: "Login complete, auth stored for container",
+      cookieCount: cookies.length,
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return json({ error: "Login failed", detail: message }, 500);
+  } finally {
+    await browser.close();
+  }
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function json(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "content-type": "application/json",
+      "access-control-allow-origin": "*",
+    },
+  });
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}