@fudrouter/fsrouter 0.6.92 → 0.6.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fudrouter/fsrouter",
-  "version": "0.6.92",
+  "version": "0.6.94",
   "private": false,
   "type": "module",
   "description": "9Router v2 — Express Backend (API, SSE, DB, Auth, MITM)",
@@ -9,8 +9,16 @@
     "fsrouter": "bin/cli.cjs"
   },
   "scripts": {
-    "start": "node dist/server.js"
+    "start": "node dist/server.js",
+    "postinstall": "node scripts/postinstall.cjs"
   },
+  "files": [
+    "dist",
+    "public",
+    "open-sse",
+    "bin",
+    "scripts"
+  ],
   "dependencies": {
     "bcryptjs": "^3.0.3",
     "better-sqlite3": "^12.11.1",

package/scripts/postinstall.cjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Post-install: wire automation symlinks so the signup scripts can find the
+ * Python venv, source tree and browser profiles regardless of the process cwd.
+ *
+ * The automation routes resolve paths relative to process.cwd()
+ * (e.g. .venv/bin/python, src/automation/*.py, profiles/<provider>). When the
+ * server runs under pm2 the cwd is the installed package directory
+ * (/usr/local/lib/node_modules/@fudrouter/fsrouter), NOT /root — so we create
+ * the symlinks in BOTH locations to be cwd-independent.
+ *
+ * Idempotent and non-fatal: never throws (npm install must succeed even if a
+ * symlink can't be created).
+ */
+const fs = require("fs");
+const path = require("path");
+
+function log(msg) {
+  // eslint-disable-next-line no-console
+  console.log(`[fsrouter:postinstall] ${msg}`);
+}
+
+function isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function symlinkIfMissing(linkPath, targetPath) {
+  try {
+    if (!fs.existsSync(targetPath)) {
+      // target missing — remove a dangling link if present, then skip
+      if (isSymlink(linkPath)) fs.unlinkSync(linkPath);
+      log(`skip ${linkPath} (target ${targetPath} not found)`);
+      return;
+    }
+    if (isSymlink(linkPath)) {
+      if (fs.readlinkSync(linkPath) === targetPath) {
+        log(`ok ${linkPath} -> ${targetPath}`);
+        return;
+      }
+      fs.unlinkSync(linkPath);
+    } else if (fs.existsSync(linkPath)) {
+      log(`skip ${linkPath} (exists and is not a symlink — leaving untouched)`);
+      return;
+    }
+    fs.symlinkSync(targetPath, linkPath, "dir");
+    log(`linked ${linkPath} -> ${targetPath}`);
+  } catch (e) {
+    log(`warn: could not link ${linkPath} -> ${targetPath}: ${e.message}`);
+  }
+}
+
+function main() {
+  // Real AMRouter checkout (where the venv + browser profiles live)
+  const candidates = ["/root/AMRouter", path.resolve(__dirname, "..", "..")];
+  let base = null;
+  for (const c of candidates) {
+    if (fs.existsSync(c)) {
+      base = c;
+      break;
+    }
+  }
+  if (!base) {
+    log("no AMRouter base found; skipping symlinks");
+    return;
+  }
+  log(`base=${base}`);
+
+  const venvTarget = path.join(base, ".venv");
+  const srcTarget = path.join(base, "backend", "src");
+  const profilesTarget = path.join(base, "backend", "profiles");
+
+  // Locations to symlink from (cwd-independent coverage)
+  const linkBases = ["/root", process.cwd()]; // /root + the dir npm ran install in (global package dir under pm2)
+
+  for (const lb of linkBases) {
+    symlinkIfMissing(path.join(lb, ".venv"), venvTarget);
+    // src only if it doesn't already exist as a real dir (package ships src/)
+    const srcLink = path.join(lb, "src");
+    if (!fs.existsSync(srcLink)) symlinkIfMissing(srcLink, srcTarget);
+    symlinkIfMissing(path.join(lb, "profiles"), profilesTarget);
+  }
+}
+
+try {
+  main();
+} catch (e) {
+  log(`unexpected error: ${e.message}`);
+}

package/src/automation/cf_token_via_session.py

@@ -1,158 +0,0 @@
-#!/usr/bin/env python3
-"""
-cf_token_via_session.py
-Login ke akun Cloudflare yang ada, buat Workers AI token via session cookie API.
-Usage:
-  python cf_token_via_session.py --email X --password Y --account-id Z
-"""
-import argparse, json, time, sys
-import requests
-from pathlib import Path
-
-def log(m): print(json.dumps({"step": m}), flush=True)
-def die(m): print(json.dumps({"status": "error", "error": m}), flush=True); sys.exit(1)
-
-
-def create_token_with_cookies(cookies: dict, account_id: str) -> str | None:
-    """POST /api/v4/user/tokens using browser session cookies."""
-    base = "https://dash.cloudflare.com"
-    sess = requests.Session()
-    sess.cookies.update(cookies)
-    sess.headers.update({
-        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120",
-        "Referer": f"{base}/profile/api-tokens/create",
-        "Origin": base,
-        "Accept": "application/json",
-    })
-
-    # A1: Get permission groups to find Workers AI ID
-    log("Fetching permission groups...")
-    r = sess.get(f"{base}/api/v4/user/tokens/permission_groups", timeout=15)
-    log(f"Permission groups status: {r.status_code}")
-    if r.status_code != 200:
-        log(f"Permission groups response: {r.text[:300]}")
-        return None
-
-    pg_data = r.json()
-    log(f"Total groups: {len(pg_data.get('result', []))}")
-
-    # Find Workers AI groups
-    workers_ai_ids = []
-    for pg in pg_data.get('result', []):
-        name = pg.get('name', '')
-        if 'Workers AI' in name:
-            log(f"Found: {name} -> {pg['id']}")
-            workers_ai_ids.append({'id': pg['id'], 'name': name})
-
-    if not workers_ai_ids:
-        log("No Workers AI permission groups found")
-        log(f"All groups: {[p['name'] for p in pg_data.get('result', [])][:20]}")
-        return None
-
-    # Prefer Workers AI:Read for safety, otherwise take first
-    target_id = workers_ai_ids[0]['id']
-    for pg in workers_ai_ids:
-        if 'Read' in pg['name']:
-            target_id = pg['id']
-            break
-
-    log(f"Using permission group ID: {target_id}")
-
-    # A2: Create token
-    payload = {
-        "name": "9router-workers-ai",
-        "policies": [{
-            "effect": "allow",
-            "resources": {f"com.cloudflare.api.account.{account_id}": "*"},
-            "permission_groups": [{"id": target_id}]
-        }]
-    }
-
-    log(f"Creating token with payload: {json.dumps(payload)}")
-    r2 = sess.post(f"{base}/api/v4/user/tokens", json=payload, timeout=15)
-    log(f"Create token status: {r2.status_code}")
-    resp2 = r2.json()
-    log(f"Response: {json.dumps(resp2)[:500]}")
-
-    if resp2.get('success'):
-        return resp2['result'].get('value', '')
-    return None
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--email", required=True)
-    parser.add_argument("--password", required=True)
-    parser.add_argument("--account-id", required=True, dest="account_id")
-    parser.add_argument("--headless", action="store_true")
-    args = parser.parse_args()
-
-    try:
-        from camoufox.sync_api import Camoufox
-    except ImportError:
-        die("Camoufox tidak terinstall")
-
-    log(f"Login ke CF sebagai {args.email}...")
-    with Camoufox(headless=args.headless, os="windows") as browser:
-        page = browser.new_page()
-
-        # Navigate to login
-        page.goto("https://dash.cloudflare.com/login", wait_until="domcontentloaded", timeout=30000)
-        time.sleep(3)
-
-        # Fill login form
-        try:
-            email_inp = page.locator("input[name='email'], input[type='email']").first
-            if email_inp.is_visible(timeout=5000):
-                email_inp.fill(args.email)
-                time.sleep(0.3)
-
-                pass_inp = page.locator("input[type='password']").first
-                if pass_inp.is_visible(timeout=3000):
-                    pass_inp.fill(args.password)
-                    time.sleep(0.3)
-
-                for sel in ["button[type='submit']", "button:has-text('Log in')", "button:has-text('Sign in')"]:
-                    try:
-                        btn = page.locator(sel).first
-                        if btn.is_visible(timeout=2000):
-                            btn.click()
-                            break
-                    except Exception:
-                        continue
-
-                log("Login submitted, waiting...")
-                time.sleep(6)
-        except Exception as e:
-            log(f"Login form error: {e}")
-
-        log(f"Current URL: {page.url}")
-        page.screenshot(path="/tmp/cf_login_state.png")
-
-        # Check if logged in
-        if "dash.cloudflare.com" not in page.url:
-            die(f"Login failed, URL: {page.url}")
-
-        # Extract cookies
-        cookies_list = page.context.cookies()
-        cookies = {c['name']: c['value'] for c in cookies_list}
-        log(f"Got {len(cookies)} cookies: {list(cookies.keys())[:10]}")
-
-        # Create token via API
-        token = create_token_with_cookies(cookies, args.account_id)
-
-        if token:
-            log(f"TOKEN BERHASIL: {token[:12]}...")
-            print(json.dumps({
-                "status": "success",
-                "workers_ai_token": token,
-                "account_id": args.account_id,
-                "email": args.email
-            }), flush=True)
-        else:
-            page.screenshot(path="/tmp/cf_session_debug.png")
-            die("Token creation via session failed")
-
-
-if __name__ == "__main__":
-    main()