cloak22 2.2.0

package/dist/output.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHeading = formatHeading;
+exports.formatSuccess = formatSuccess;
+exports.formatWarning = formatWarning;
+exports.formatError = formatError;
+exports.formatInfo = formatInfo;
+const chalk_1 = __importDefault(require("chalk"));
+function formatHeading(text) {
+    return chalk_1.default.bold.cyan(text);
+}
+function formatSuccess(text) {
+    return chalk_1.default.green(text);
+}
+function formatWarning(text) {
+    return chalk_1.default.yellow(text);
+}
+function formatError(text) {
+    return chalk_1.default.red(text);
+}
+function formatInfo(text) {
+    return chalk_1.default.cyan(text);
+}

package/dist/state-db.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloakStateDb = void 0;
+function loadDatabaseConstructor() {
+    const sqlite = require("node:sqlite");
+    return sqlite.DatabaseSync;
+}
+function openDatabase(dbPath) {
+    const DatabaseSync = loadDatabaseConstructor();
+    return new DatabaseSync(dbPath);
+}
+function normalizeCookieUrls(urls) {
+    return [...new Set(urls)].sort((left, right) => left.localeCompare(right));
+}
+function initializeSchema(database) {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS profile_cookie_urls (
+      profile TEXT NOT NULL,
+      url TEXT NOT NULL,
+      PRIMARY KEY (profile, url)
+    );
+
+    CREATE TABLE IF NOT EXISTS daemon_state (
+      slot INTEGER PRIMARY KEY CHECK (slot = 1),
+      pid INTEGER NOT NULL,
+      profile TEXT,
+      cookie_urls TEXT NOT NULL,
+      cookie_file TEXT,
+      headless INTEGER NOT NULL,
+      started_at TEXT NOT NULL,
+      log_path TEXT NOT NULL
+    );
+  `);
+    const daemonStateColumns = database
+        .prepare("PRAGMA table_info(daemon_state)")
+        .all()
+        .map((row) => row.name)
+        .filter((value) => typeof value === "string");
+    if (!daemonStateColumns.includes("cookie_file")) {
+        database.exec("ALTER TABLE daemon_state ADD COLUMN cookie_file TEXT;");
+    }
+}
+function readJson(value) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+class CloakStateDb {
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    withDatabase(operation) {
+        const database = openDatabase(this.dbPath);
+        initializeSchema(database);
+        try {
+            return operation(database);
+        }
+        finally {
+            database.close();
+        }
+    }
+    getDefaultProfile() {
+        return this.withDatabase((database) => {
+            const row = database
+                .prepare("SELECT value FROM settings WHERE key = ?")
+                .get("default_profile");
+            return typeof row?.value === "string" ? row.value : undefined;
+        });
+    }
+    setDefaultProfile(profile) {
+        this.withDatabase((database) => {
+            database
+                .prepare([
+                "INSERT INTO settings (key, value)",
+                "VALUES (?, ?)",
+                "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+            ].join(" "))
+                .run("default_profile", profile);
+        });
+    }
+    getRememberedCookieUrls(profile) {
+        return this.withDatabase((database) => {
+            const rows = database
+                .prepare([
+                "SELECT url",
+                "FROM profile_cookie_urls",
+                "WHERE profile = ?",
+                "ORDER BY url COLLATE NOCASE",
+            ].join(" "))
+                .all(profile);
+            return rows
+                .map((row) => row.url)
+                .filter((value) => typeof value === "string");
+        });
+    }
+    rememberCookieUrls(profile, urls) {
+        const normalized = normalizeCookieUrls(urls);
+        this.withDatabase((database) => {
+            const statement = database.prepare([
+                "INSERT INTO profile_cookie_urls (profile, url)",
+                "VALUES (?, ?)",
+                "ON CONFLICT(profile, url) DO NOTHING",
+            ].join(" "));
+            for (const url of normalized) {
+                statement.run(profile, url);
+            }
+        });
+        return this.getRememberedCookieUrls(profile);
+    }
+    replaceRememberedCookieUrls(profile, urls) {
+        const normalized = normalizeCookieUrls(urls);
+        this.withDatabase((database) => {
+            database
+                .prepare("DELETE FROM profile_cookie_urls WHERE profile = ?")
+                .run(profile);
+            const insert = database.prepare("INSERT INTO profile_cookie_urls (profile, url) VALUES (?, ?)");
+            for (const url of normalized) {
+                insert.run(profile, url);
+            }
+        });
+        return normalized;
+    }
+    getDaemonState() {
+        return this.withDatabase((database) => {
+            const row = database
+                .prepare([
+                "SELECT pid, profile, cookie_urls, cookie_file, headless, started_at, log_path",
+                "FROM daemon_state",
+                "WHERE slot = 1",
+            ].join(" "))
+                .get();
+            if (!row) {
+                return undefined;
+            }
+            const cookieUrls = readJson(typeof row.cookie_urls === "string" ? row.cookie_urls : undefined);
+            if (typeof row.pid !== "number" || !Array.isArray(cookieUrls)) {
+                return undefined;
+            }
+            return {
+                pid: row.pid,
+                profile: typeof row.profile === "string" ? row.profile : undefined,
+                cookieUrls,
+                cookieFile: typeof row.cookie_file === "string" ? row.cookie_file : undefined,
+                headless: row.headless === 1,
+                startedAt: typeof row.started_at === "string"
+                    ? row.started_at
+                    : new Date(0).toISOString(),
+                logPath: typeof row.log_path === "string" ? row.log_path : "",
+            };
+        });
+    }
+    setDaemonState(state) {
+        this.withDatabase((database) => {
+            database
+                .prepare([
+                "INSERT INTO daemon_state",
+                "(slot, pid, profile, cookie_urls, cookie_file, headless, started_at, log_path)",
+                "VALUES (1, ?, ?, ?, ?, ?, ?, ?)",
+                "ON CONFLICT(slot) DO UPDATE SET",
+                "pid = excluded.pid,",
+                "profile = excluded.profile,",
+                "cookie_urls = excluded.cookie_urls,",
+                "cookie_file = excluded.cookie_file,",
+                "headless = excluded.headless,",
+                "started_at = excluded.started_at,",
+                "log_path = excluded.log_path",
+            ].join(" "))
+                .run(state.pid, state.profile ?? null, JSON.stringify(normalizeCookieUrls(state.cookieUrls)), state.cookieFile ?? null, state.headless ? 1 : 0, state.startedAt, state.logPath);
+        });
+    }
+    clearDaemonState(pid) {
+        this.withDatabase((database) => {
+            if (typeof pid === "number") {
+                database
+                    .prepare("DELETE FROM daemon_state WHERE slot = 1 AND pid = ?")
+                    .run(pid);
+                return;
+            }
+            database.prepare("DELETE FROM daemon_state WHERE slot = 1").run();
+        });
+    }
+    getLastDaemonCommand() {
+        return this.withDatabase((database) => {
+            const row = database
+                .prepare("SELECT value FROM settings WHERE key = ?")
+                .get("last_daemon_command");
+            const command = readJson(typeof row?.value === "string" ? row.value : undefined);
+            if (!command ||
+                !Array.isArray(command.cookieUrls) ||
+                (command.cookieFile !== undefined &&
+                    typeof command.cookieFile !== "string")) {
+                return undefined;
+            }
+            return {
+                headless: Boolean(command.headless),
+                profile: command.profile,
+                cookieUrls: normalizeCookieUrls(command.cookieUrls),
+                cookieFile: command.cookieFile,
+            };
+        });
+    }
+    setLastDaemonCommand(command) {
+        const normalized = {
+            headless: Boolean(command.headless),
+            profile: command.profile,
+            cookieUrls: normalizeCookieUrls(command.cookieUrls),
+            cookieFile: command.cookieFile,
+        };
+        this.withDatabase((database) => {
+            database
+                .prepare([
+                "INSERT INTO settings (key, value)",
+                "VALUES (?, ?)",
+                "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+            ].join(" "))
+                .run("last_daemon_command", JSON.stringify(normalized));
+        });
+    }
+}
+exports.CloakStateDb = CloakStateDb;

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "cloak22",
+  "version": "2.2.0",
+  "description": "Chrome sidecar for OpenCLI with daemonized Patchright startup and remembered cookie URLs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lmist/cloak.git"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "bin": {
+    "cloak": "bin/cloak.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    ".githooks/pre-commit",
+    ".githooks/pre-push",
+    "scripts/postinstall.cjs",
+    "scripts/render-readme.cjs",
+    "scripts/setup-git-hooks.cjs",
+    "docs/assets/cloak-logo-readme-centered.png",
+    "src/app-paths.ts",
+    "src/chrome-cookies.ts",
+    "src/chrome-profile-sites.ts",
+    "src/chrome-profiles.ts",
+    "src/cli.ts",
+    "src/cookies.ts",
+    "src/daemon.ts",
+    "src/extension.ts",
+    "src/install-extension.ts",
+    "src/main.ts",
+    "src/output.ts",
+    "src/state-db.ts",
+    "README.md",
+    "README.org"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.cjs",
+    "build": "node scripts/build.cjs",
+    "render-readme": "node scripts/render-readme.cjs",
+    "check-readme": "node scripts/render-readme.cjs --check",
+    "prepack": "npm run build",
+    "typecheck": "node ./node_modules/typescript/bin/tsc --noEmit",
+    "start": "node --import tsx src/main.ts",
+    "test": "node --import tsx --test src/**/*.test.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "chalk": "^4.1.2",
+    "patchright": "^1.58.2",
+    "tsx": "^4.21.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/node": "^20.0.0",
+    "@types/yargs": "^17.0.33",
+    "typescript": "^5.3.0"
+  }
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const { existsSync } = require("node:fs");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const rootDir = path.resolve(__dirname, "..");
+const distEntrypoint = path.join(rootDir, "dist", "install-extension.js");
+const sourceEntrypoint = path.join(rootDir, "src", "install-extension.ts");
+const tsxEntrypoint = path.join(rootDir, "node_modules", "tsx", "dist", "loader.mjs");
+const patchrightCliEntrypoint = path.join(rootDir, "node_modules", "patchright", "cli.js");
+const setupHooksEntrypoint = path.join(rootDir, "scripts", "setup-git-hooks.cjs");
+
+const command = process.execPath;
+const args = existsSync(sourceEntrypoint) && existsSync(tsxEntrypoint)
+  ? ["--import", "tsx", sourceEntrypoint]
+  : [distEntrypoint];
+
+function runPostinstallStep(stepArgs) {
+  execFileSync(command, stepArgs, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+}
+
+try {
+  runPostinstallStep(args);
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(
+    `[cloak] Warning: failed to warm the OpenCLI extension cache during postinstall. cloak will retry at runtime. (${message})`
+  );
+}
+
+if (existsSync(patchrightCliEntrypoint)) {
+  try {
+    runPostinstallStep([patchrightCliEntrypoint, "install", "chromium"]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(
+      `[cloak] Warning: failed to install the Patchright Chromium browser during postinstall. You can retry with 'npx patchright install chromium'. (${message})`
+    );
+  }
+}
+
+if (existsSync(setupHooksEntrypoint)) {
+  try {
+    runPostinstallStep([setupHooksEntrypoint]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(
+      `[cloak] Warning: failed to configure local git hooks. You can retry with 'node scripts/setup-git-hooks.cjs'. (${message})`
+    );
+  }
+}

package/scripts/render-readme.cjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const rootDir = path.resolve(__dirname, "..");
+const sourcePath = path.join(rootDir, "README.org");
+const targetPath = path.join(rootDir, "README.md");
+const generatedBanner =
+  "<!-- Generated from README.org by scripts/render-readme.cjs. Do not edit README.md directly. -->";
+
+function renderReadme() {
+  const rendered = execFileSync(
+    "pandoc",
+    ["-f", "org", "-t", "gfm", "--wrap=none", sourcePath],
+    {
+      cwd: rootDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "inherit"],
+    }
+  );
+
+  const lines = rendered.split(/\r?\n/);
+  if (
+    lines[0] ===
+    '<span class="spurious-link" target="docs/assets/cloak-logo-readme-centered.png">*docs/assets/cloak-logo-readme-centered.png*</span>'
+  ) {
+    lines[0] = "![cloak logo](docs/assets/cloak-logo-readme-centered.png)";
+  }
+
+  return `${generatedBanner}\n\n${lines.join("\n").trimEnd()}\n`;
+}
+
+function main() {
+  const checkOnly = process.argv.includes("--check");
+  const content = renderReadme();
+  const current = fs.existsSync(targetPath) ? fs.readFileSync(targetPath, "utf8") : "";
+
+  if (checkOnly) {
+    if (current !== content) {
+      console.error("README.md is out of date. Run `node scripts/render-readme.cjs`.");
+      process.exit(1);
+    }
+
+    return;
+  }
+
+  if (current !== content) {
+    fs.writeFileSync(targetPath, content);
+  }
+}
+
+main();

package/scripts/setup-git-hooks.cjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const rootDir = path.resolve(__dirname, "..");
+const gitDir = path.join(rootDir, ".git");
+
+if (!fs.existsSync(gitDir)) {
+  process.exit(0);
+}
+
+try {
+  execFileSync("git", ["config", "core.hooksPath", ".githooks"], {
+    cwd: rootDir,
+    stdio: "ignore",
+  });
+} catch {
+  process.exit(0);
+}

package/src/app-paths.ts

@@ -0,0 +1,39 @@
+import os from "node:os";
+import path from "node:path";
+
+export type AppPaths = {
+  extensionsDir: string;
+  configDir: string;
+  stateDbPath: string;
+  daemonLogPath: string;
+};
+
+export function defaultAppRootDir(
+  dependencies: {
+    homedir?: () => string;
+  } = {}
+): string {
+  const homedir = dependencies.homedir ?? os.homedir;
+  return path.join(homedir(), ".cache", "cloak");
+}
+
+export function defaultConfigRootDir(
+  dependencies: {
+    homedir?: () => string;
+  } = {}
+): string {
+  const homedir = dependencies.homedir ?? os.homedir;
+  return path.join(homedir(), ".config", "cloak");
+}
+
+export function resolveAppPaths(
+  rootDir: string = defaultAppRootDir(),
+  configDir: string = defaultConfigRootDir()
+): AppPaths {
+  return {
+    extensionsDir: rootDir,
+    configDir,
+    stateDbPath: path.join(configDir, "state.sqlite"),
+    daemonLogPath: path.join(rootDir, "daemon.log"),
+  };
+}