gologin-api-wrapper 0.0.1

package/README.md

@@ -0,0 +1,63 @@
+# gologin-api-wrapper (local GoLogin API wrapper)
+
+This is a small local companion you run on **your own machine** to launch GoLogin profiles locally.
+
+The hosted web app (e.g. Vercel) cannot launch local browsers, so it talks to this runner over `http://127.0.0.1`.
+
+## Prerequisites
+
+- Node.js **20.x** installed
+- A GoLogin API token
+
+## Setup
+
+## Install (recommended)
+
+```bash
+npm i -g gologin-api-wrapper
+```
+
+1) Create a `.env` file (or export env vars in your shell):
+
+```bash
+export GOLOGIN_TOKEN="..."
+```
+
+Optional (recommended): restrict which web origins can call the localhost API:
+
+```bash
+export ALLOWED_ORIGINS="https://app.flygen.in,http://localhost:3001"
+```
+
+2) Install deps and build:
+
+```bash
+npm install
+npm run build
+```
+
+## Run
+
+```bash
+gologin-api-wrapper start --port 17327
+```
+
+Health check:
+
+```bash
+curl http://127.0.0.1:17327/health
+```
+
+Open a GoLogin profile (launches a local headful Orbita):
+
+```bash
+curl -X POST http://127.0.0.1:17327/gologin/open \
+  -H 'Content-Type: application/json' \
+  -d '{"profileId":"YOUR_PROFILE_ID"}'
+```
+
+## API
+
+- `GET /health`
+- `POST /gologin/open` `{ profileId }` -> `{ profileId, wsEndpoint }`
+

package/bin/be-linkedbot-runner.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import "../dist/index.js"
+

package/dist/index.js

@@ -0,0 +1,140 @@
+import http from "node:http";
+import { URL } from "node:url";
+function parseArgs(argv) {
+    const cmd = argv[2] ?? "start";
+    let port = 17327;
+    let host = "127.0.0.1";
+    for (let i = 3; i < argv.length; i += 1) {
+        const a = argv[i];
+        if (a === "--port") {
+            const v = argv[i + 1];
+            if (v)
+                port = Number(v);
+            i += 1;
+            continue;
+        }
+        if (a === "--host") {
+            const v = argv[i + 1];
+            if (v)
+                host = v;
+            i += 1;
+            continue;
+        }
+    }
+    return { cmd, port, host };
+}
+function sendJson(res, status, body) {
+    const buf = Buffer.from(JSON.stringify(body));
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.setHeader("Content-Length", String(buf.length));
+    res.end(buf);
+}
+function applyCors(req, res) {
+    // With no-auth localhost API, we should at least avoid blindly enabling CORS in production.
+    // Configure a strict allowlist via ALLOWED_ORIGINS="https://app.example.com,http://localhost:3001"
+    const origin = req.headers.origin;
+    const allow = (process.env.ALLOWED_ORIGINS || "")
+        .split(",")
+        .map(s => s.trim())
+        .filter(Boolean);
+    if (!origin)
+        return true;
+    if (allow.length === 0) {
+        // Dev-friendly default: allow all origins if allowlist isn't set.
+        // Users can lock it down with ALLOWED_ORIGINS.
+        res.setHeader("Access-Control-Allow-Origin", origin);
+        res.setHeader("Vary", "Origin");
+    }
+    else if (allow.includes(origin)) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+        res.setHeader("Vary", "Origin");
+    }
+    else {
+        sendJson(res, 403, { message: "Origin not allowed" });
+        return false;
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    res.setHeader("Access-Control-Max-Age", "600");
+    return true;
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw)
+        return {};
+    return JSON.parse(raw);
+}
+async function main() {
+    // gologin@2.1.29 currently uses JSON import assertions syntax that breaks on Node 23+.
+    // In practice, this runner is expected to run on Node 20.x.
+    const major = Number(process.versions.node.split(".")[0] || "0");
+    if (major !== 20) {
+        console.error(`Unsupported Node.js version: ${process.versions.node}. ` +
+            "Please use Node 20.x to run gologin-api-wrapper.");
+        process.exit(1);
+    }
+    const { cmd, port, host } = parseArgs(process.argv);
+    if (cmd !== "start") {
+        console.error(`Unknown command: ${cmd}. Supported: start`);
+        process.exit(1);
+    }
+    const gologinToken = process.env.GOLOGIN_TOKEN;
+    if (!gologinToken) {
+        console.error("GOLOGIN_TOKEN is not set");
+        process.exit(1);
+    }
+    // Lazy-load gologin to ensure the Node version guard runs before the module is evaluated.
+    const { GologinApi: GL } = (await import("gologin"));
+    const server = http.createServer(async (req, res) => {
+        try {
+            if (!applyCors(req, res))
+                return;
+            if (req.method === "OPTIONS") {
+                res.statusCode = 204;
+                res.end();
+                return;
+            }
+            const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+            if (req.method === "GET" && url.pathname === "/health") {
+                sendJson(res, 200, { ok: true, name: "gologin-api-wrapper" });
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/gologin/open") {
+                const body = await readJsonBody(req).catch(() => ({}));
+                const profileId = (body.profileId || "").trim();
+                if (!profileId) {
+                    sendJson(res, 400, { message: "profileId is required" });
+                    return;
+                }
+                const gologin = GL({ token: gologinToken });
+                // gologin types model launch params as a union; for local launch we combine fields.
+                const { browser } = await gologin.launch({
+                    cloud: false,
+                    headless: false,
+                    profileId,
+                });
+                const wsEndpoint = browser.wsEndpoint();
+                const out = { profileId, wsEndpoint };
+                sendJson(res, 200, out);
+                return;
+            }
+            sendJson(res, 404, { message: "Not found" });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            sendJson(res, 500, { message });
+        }
+    });
+    server.listen(port, host, () => {
+        console.log(`gologin-api-wrapper listening on http://${host}:${port}`);
+    });
+}
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "gologin-api-wrapper",
+  "version": "0.0.1",
+  "description": "Local GoLogin API wrapper (launches GoLogin locally via a localhost API)",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "gologin-api-wrapper": "bin/be-linkedbot-runner.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": "20.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts start",
+    "build": "tsc",
+    "start": "node dist/index.js start",
+    "lint": "eslint src/**/*.ts",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "gologin": "^2.1.29"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.27.0",
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.33.0",
+    "@typescript-eslint/parser": "^8.33.0",
+    "eslint": "^9.27.0",
+    "globals": "^15.15.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.8.3"
+  }
+}
+