@rebasepro/server-core 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/src/auth/twitter-oauth.ts

@@ -0,0 +1,120 @@
+import type { OAuthProvider, OAuthProviderProfile } from "./interfaces";
+import { z } from "zod";
+
+/**
+ * Creates a Twitter/X OAuth 2.0 Provider integration.
+ *
+ * Uses OAuth 2.0 with PKCE (authorization code flow). The frontend must include
+ * the PKCE `code_verifier` when sending the authorization code.
+ *
+ * Twitter API v2 requires the "tweet.read" and "users.read" scopes at minimum,
+ * plus "offline.access" if refresh tokens are needed on Twitter's side.
+ */
+export function createTwitterProvider(config: { clientId: string; clientSecret: string }): OAuthProvider<{
+            code: string;
+            redirectUri: string;
+            codeVerifier: string;
+        }> {
+    return {
+        id: "twitter",
+        schema: z.object({
+            code: z.string().min(1, "Auth code is required"),
+            redirectUri: z.string().url("Valid redirect URI is required"),
+            codeVerifier: z.string().min(1, "PKCE code verifier is required")
+        }),
+        verify: async (payload: {
+            code: string;
+            redirectUri: string;
+            codeVerifier: string;
+        }): Promise<OAuthProviderProfile | null> => {
+            try {
+                // Twitter OAuth 2.0 uses Basic auth for the token endpoint
+                const basicAuth = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64");
+
+                // Exchange code for access token
+                const tokenResponse = await fetch("https://api.twitter.com/2/oauth2/token", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Authorization": `Basic ${basicAuth}`
+                    },
+                    body: new URLSearchParams({
+                        code: payload.code,
+                        grant_type: "authorization_code",
+                        redirect_uri: payload.redirectUri,
+                        code_verifier: payload.codeVerifier
+                    })
+                });
+
+                if (!tokenResponse.ok) {
+                    console.error("Failed to get Twitter access token:", await tokenResponse.text());
+                    return null;
+                }
+
+                const tokenData = await tokenResponse.json() as { access_token: string };
+                const accessToken = tokenData.access_token;
+
+                // Fetch user profile from Twitter API v2
+                const profileResponse = await fetch(
+                    "https://api.twitter.com/2/users/me?user.fields=id,name,username,profile_image_url",
+                    {
+                        headers: { "Authorization": `Bearer ${accessToken}` }
+                    }
+                );
+
+                if (!profileResponse.ok) {
+                    console.error("Failed to get Twitter user info:", await profileResponse.text());
+                    return null;
+                }
+
+                const profileResult = await profileResponse.json() as {
+                    data: {
+                        id: string;
+                        name: string;
+                        username: string;
+                        profile_image_url?: string;
+                    };
+                };
+
+                const profileData = profileResult.data;
+
+                // Twitter does NOT expose email via API v2 by default.
+                // It requires elevated access. If we can't get an email, we
+                // generate a placeholder email — the user can update it later.
+                // For apps with elevated access, fetch from v1.1 endpoint.
+                let email: string | null = null;
+                try {
+                    const emailResponse = await fetch(
+                        "https://api.twitter.com/1.1/account/verify_credentials.json?include_email=true",
+                        {
+                            headers: { "Authorization": `Bearer ${accessToken}` }
+                        }
+                    );
+                    if (emailResponse.ok) {
+                        const emailData = await emailResponse.json() as { email?: string };
+                        email = emailData.email || null;
+                    }
+                } catch {
+                    // Elevated access not available — fall through
+                }
+
+                if (!email) {
+                    // Construct a deterministic placeholder email from the Twitter user ID.
+                    // This allows the account to be created and linked; the user should
+                    // update their email through the profile settings.
+                    email = `${profileData.id}@twitter.placeholder.rebase`;
+                }
+
+                return {
+                    providerId: profileData.id,
+                    email,
+                    displayName: profileData.name || profileData.username || null,
+                    photoUrl: profileData.profile_image_url?.replace("_normal", "_400x400") || null
+                };
+            } catch (error) {
+                console.error("Twitter OAuth error:", error);
+                return null;
+            }
+        }
+    };
+}

package/src/collections/loader.ts

@@ -17,19 +17,19 @@ export async function loadCollectionsFromDirectory(directory: string): Promise<E
         const files = fs.readdirSync(directory);
         for (const file of files) {
             // Only load .ts and .js files, ignore test files and declaration files
-            if ((file.endsWith('.ts') || file.endsWith('.js')) &&
-                !file.includes('.test.') &&
-                !file.endsWith('.d.ts') &&
-                file !== 'index.ts' && file !== 'index.js') {
+            if ((file.endsWith(".ts") || file.endsWith(".js")) &&
+                !file.includes(".test.") &&
+                !file.endsWith(".d.ts") &&
+                file !== "index.ts" && file !== "index.js") {
 
                 const filePath = path.join(directory, file);
                 try {
                     const fileUrl = pathToFileURL(filePath).href;
 
                     // Use new Function to compile dynamic import natively and bypass tsc converting import() to require()
-                    const dynamicImport = new Function('url', 'return import(url)');
+                    const dynamicImport = new Function("url", "return import(url)");
                     const module = await dynamicImport(fileUrl);
-                    
+
                     // Expect the collection to be the default export
                     if (module && module.default) {
                         collections.push(module.default);

package/src/cron/cron-loader.ts

@@ -0,0 +1,89 @@
+import * as fs from "fs";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import type { CronJobDefinition } from "@rebasepro/types";
+
+export interface LoadedCronJob {
+    /** Job ID derived from filename (e.g. "cleanup-sessions"). */
+    id: string;
+    /** The full definition. */
+    definition: CronJobDefinition;
+}
+
+/**
+ * Auto-discover cron job files from a directory.
+ *
+ * Each file should default-export a `CronJobDefinition`.
+ * The filename (without extension) becomes the job ID:
+ *   `crons/cleanup-sessions.ts` → id = "cleanup-sessions"
+ *
+ * Follows the same discovery pattern as `loadFunctionsFromDirectory`.
+ */
+export async function loadCronJobsFromDirectory(
+    directory: string
+): Promise<LoadedCronJob[]> {
+    const jobs: LoadedCronJob[] = [];
+
+    if (!fs.existsSync(directory)) {
+        return jobs;
+    }
+
+    const files = fs.readdirSync(directory);
+    for (const file of files) {
+        if (
+            (file.endsWith(".ts") || file.endsWith(".js")) &&
+            !file.includes(".test.") &&
+            !file.endsWith(".d.ts") &&
+            file !== "index.ts" &&
+            file !== "index.js"
+        ) {
+            const filePath = path.join(directory, file);
+            try {
+                const fileUrl = pathToFileURL(filePath).href;
+
+                // Native dynamic import — bypasses tsc down-compilation
+                const dynamicImport = new Function("url", "return import(url)");
+                const mod = await dynamicImport(fileUrl);
+
+                const exported: unknown = mod.default;
+
+                if (!exported || typeof exported !== "object") {
+                    console.warn(
+                        `[cron] ${file}: no valid default export. Skipping.`
+                    );
+                    continue;
+                }
+
+                const def = exported as Record<string, unknown>;
+                if (typeof def.schedule !== "string" || typeof def.handler !== "function") {
+                    console.warn(
+                        `[cron] ${file}: default export missing required 'schedule' or 'handler'. Skipping.`
+                    );
+                    continue;
+                }
+
+                const id = path.basename(file, path.extname(file));
+                const definition: CronJobDefinition = {
+                    schedule: def.schedule as string,
+                    name: (def.name as string) || id,
+                    description: def.description as string | undefined,
+                    enabled: def.enabled !== false,
+                    timeoutSeconds: (def.timeoutSeconds as number) || 300,
+                    handler: def.handler as CronJobDefinition["handler"]
+                };
+
+                jobs.push({ id,
+definition });
+                console.log(`⏰ Loaded cron job: ${id} (${definition.schedule})`);
+            } catch (err: unknown) {
+                const message =
+                    err instanceof Error ? err.message : String(err);
+                console.error(
+                    `[cron] Failed to load ${file}: ${message}`
+                );
+            }
+        }
+    }
+
+    return jobs;
+}

package/src/cron/cron-routes.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { Hono } from "hono";
+import { CronScheduler } from "./cron-scheduler";
+import { createCronRoutes } from "./cron-routes";
+import type { LoadedCronJob } from "./cron-loader";
+import type { CronJobDefinition } from "@rebasepro/types";
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function makeJob(
+    id: string,
+    overrides: Partial<CronJobDefinition> = {}
+): LoadedCronJob {
+    return {
+        id,
+        definition: {
+            schedule: "0 * * * *",
+            name: `Job ${id}`,
+            enabled: true,
+            timeoutSeconds: 5,
+            handler: async (ctx) => {
+                ctx.log("executed");
+                return { ran: true };
+            },
+            ...overrides
+        }
+    };
+}
+
+async function jsonBody(res: Response): Promise<Record<string, unknown>> {
+    return res.json() as Promise<Record<string, unknown>>;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe("cron-routes", () => {
+    let scheduler: CronScheduler;
+    let app: Hono;
+
+    beforeEach(() => {
+        scheduler = new CronScheduler();
+        scheduler.registerJobs([
+            makeJob("job-a", { name: "Job A",
+description: "First job" }),
+            makeJob("job-b", { name: "Job B" })
+        ]);
+
+        app = new Hono();
+        app.route("/cron", createCronRoutes(scheduler));
+    });
+
+    // ── GET / (list) ────────────────────────────────────────────────
+
+    describe("GET /cron", () => {
+        it("returns all registered jobs", async () => {
+            const res = await app.request("/cron");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const jobs = body.jobs as Array<Record<string, unknown>>;
+            expect(jobs).toHaveLength(2);
+            expect(jobs.map((j) => j.id).sort()).toEqual(["job-a", "job-b"]);
+        });
+
+        it("each job has the expected shape", async () => {
+            const res = await app.request("/cron");
+            const body = await jsonBody(res);
+            const jobs = body.jobs as Array<Record<string, unknown>>;
+            const jobA = jobs.find((j) => j.id === "job-a")!;
+
+            expect(jobA.name).toBe("Job A");
+            expect(jobA.description).toBe("First job");
+            expect(jobA.schedule).toBe("0 * * * *");
+            expect(jobA.enabled).toBe(true);
+            expect(jobA.state).toBe("idle");
+            expect(jobA.totalRuns).toBe(0);
+            expect(jobA.totalFailures).toBe(0);
+        });
+    });
+
+    // ── GET /:id (single) ───────────────────────────────────────────
+
+    describe("GET /cron/:id", () => {
+        it("returns a single job", async () => {
+            const res = await app.request("/cron/job-a");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const job = body.job as Record<string, unknown>;
+            expect(job.id).toBe("job-a");
+            expect(job.name).toBe("Job A");
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/nonexistent");
+            expect(res.status).toBe(404);
+
+            const body = await jsonBody(res);
+            expect((body.error as Record<string, unknown>).code).toBe("NOT_FOUND");
+        });
+    });
+
+    // ── POST /:id/trigger ───────────────────────────────────────────
+
+    describe("POST /cron/:id/trigger", () => {
+        it("triggers a job and returns log + updated status", async () => {
+            const res = await app.request("/cron/job-a/trigger", {
+                method: "POST"
+            });
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const log = body.log as Record<string, unknown>;
+            const job = body.job as Record<string, unknown>;
+
+            expect(log.jobId).toBe("job-a");
+            expect(log.success).toBe(true);
+            expect(log.manual).toBe(true);
+            expect((log.logs as string[])).toContain("executed");
+            expect(log.result).toEqual({ ran: true });
+
+            expect(job.totalRuns).toBe(1);
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/ghost/trigger", {
+                method: "POST"
+            });
+            expect(res.status).toBe(404);
+        });
+    });
+
+    // ── GET /:id/logs ───────────────────────────────────────────────
+
+    describe("GET /cron/:id/logs", () => {
+        it("returns empty logs before any execution", async () => {
+            const res = await app.request("/cron/job-a/logs");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            expect(body.logs).toEqual([]);
+        });
+
+        it("returns logs after trigger", async () => {
+            // Trigger first
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+
+            const res = await app.request("/cron/job-a/logs");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const logs = body.logs as Array<Record<string, unknown>>;
+            expect(logs).toHaveLength(1);
+            expect(logs[0].success).toBe(true);
+        });
+
+        it("respects limit query parameter", async () => {
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+
+            const res = await app.request("/cron/job-a/logs?limit=2");
+            const body = await jsonBody(res);
+            expect((body.logs as unknown[]).length).toBe(2);
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/ghost/logs");
+            expect(res.status).toBe(404);
+        });
+    });
+
+    // ── PUT /:id (enable/disable) ───────────────────────────────────
+
+    describe("PUT /cron/:id", () => {
+        it("disables a job", async () => {
+            const res = await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: false })
+            });
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const job = body.job as Record<string, unknown>;
+            expect(job.enabled).toBe(false);
+            expect(job.state).toBe("disabled");
+        });
+
+        it("re-enables a disabled job", async () => {
+            // Disable first
+            await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: false })
+            });
+
+            // Re-enable
+            const res = await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: true })
+            });
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            expect((body.job as Record<string, unknown>).enabled).toBe(true);
+        });
+
+        it("returns 400 if enabled is missing from body", async () => {
+            const res = await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ something: "else" })
+            });
+            expect(res.status).toBe(400);
+
+            const body = await jsonBody(res);
+            expect((body.error as Record<string, unknown>).code).toBe("BAD_REQUEST");
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/ghost", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: false })
+            });
+            expect(res.status).toBe(404);
+        });
+    });
+
+    // ── Edge cases ──────────────────────────────────────────────────
+
+    describe("edge cases", () => {
+        it("handles a failing job trigger gracefully", async () => {
+            scheduler.registerJobs([
+                makeJob("fail-job", {
+                    handler: async () => {
+                        throw new Error("kaboom");
+                    }
+                })
+            ]);
+
+            const res = await app.request("/cron/fail-job/trigger", {
+                method: "POST"
+            });
+            expect(res.status).toBe(200); // trigger still returns 200
+
+            const body = await jsonBody(res);
+            const log = body.log as Record<string, unknown>;
+            expect(log.success).toBe(false);
+            expect(log.error).toBe("kaboom");
+        });
+
+        it("handles URL-encoded job IDs", async () => {
+            scheduler.registerJobs([makeJob("has-dash", { name: "Dashed" })]);
+
+            const res = await app.request("/cron/has-dash");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            expect((body.job as Record<string, unknown>).id).toBe("has-dash");
+        });
+    });
+});

package/src/cron/cron-routes.ts

@@ -0,0 +1,85 @@
+import { Hono } from "hono";
+import type { HonoEnv } from "../api/types";
+import type { CronScheduler } from "./cron-scheduler";
+
+/**
+ * Create admin REST routes for managing cron jobs.
+ *
+ * Routes:
+ *   GET    /          → list all cron jobs
+ *   GET    /:id       → get a single job's status
+ *   POST   /:id/trigger → manually trigger a job
+ *   GET    /:id/logs  → get execution logs for a job
+ *   PUT    /:id       → update job (enable/disable)
+ */
+export function createCronRoutes(scheduler: CronScheduler): Hono<HonoEnv> {
+    const router = new Hono<HonoEnv>();
+
+    // List all jobs
+    router.get("/", (c) => {
+        const jobs = scheduler.listJobs();
+        return c.json({ jobs });
+    });
+
+    // Get single job
+    router.get("/:id", (c) => {
+        const id = c.req.param("id");
+        const job = scheduler.getJob(id);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+        return c.json({ job });
+    });
+
+    // Trigger a job manually
+    router.post("/:id/trigger", async (c) => {
+        const id = c.req.param("id");
+        const job = scheduler.getJob(id);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+
+        const log = await scheduler.triggerJob(id);
+        return c.json({ log,
+job: scheduler.getJob(id) });
+    });
+
+    // Get job logs
+    router.get("/:id/logs", async (c) => {
+        const id = c.req.param("id");
+        const limitStr = c.req.query("limit");
+        const limit = limitStr ? parseInt(limitStr, 10) : undefined;
+
+        const job = scheduler.getJob(id);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+
+        const logs = await scheduler.getJobLogsFromDb(id, limit);
+        return c.json({ logs });
+    });
+
+    // Enable/disable a job
+    router.put("/:id", async (c) => {
+        const id = c.req.param("id");
+        const body = await c.req.json().catch(() => ({})) as { enabled: boolean };
+
+        if (typeof body.enabled !== "boolean") {
+            return c.json({ error: { message: "Missing 'enabled' boolean in body",
+code: "BAD_REQUEST" } }, 400);
+        }
+
+        const job = scheduler.setJobEnabled(id, body.enabled);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+
+        return c.json({ job });
+    });
+
+    return router;
+}