@phi-code-admin/camofox-browser 1.0.0

package/scripts/generate-openapi.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+/**
+ * Generate openapi.json from JSDoc annotations in server.js.
+ * Run: node scripts/generate-openapi.js
+ */
+
+import { writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import swaggerJsdoc from 'swagger-jsdoc';
+import { swaggerDefinition } from '../lib/openapi.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+
+const spec = swaggerJsdoc({
+  definition: swaggerDefinition,
+  apis: [join(root, 'server.js')],
+});
+
+const out = join(root, 'openapi.json');
+writeFileSync(out, JSON.stringify(spec, null, 2) + '\n');
+console.log(`Wrote ${Object.keys(spec.paths).length} paths to openapi.json`);

package/scripts/install-plugin-deps.sh

@@ -0,0 +1,63 @@
+#!/bin/sh
+# Install system packages declared by plugins listed in camofox.config.json.
+# Each plugin can have an apt.txt (one package per line) and a post-install.sh.
+# If no config file or no plugins key, installs deps for all plugins in plugins/.
+
+set -e
+
+CONFIG="/app/camofox.config.json"
+PLUGINS_DIR="/app/plugins"
+
+# Read plugin list from camofox.config.json, or fall back to all plugin dirs
+if [ -f "$CONFIG" ] && command -v node >/dev/null 2>&1; then
+  PLUGIN_LIST=$(node -e "
+    const c = JSON.parse(require('fs').readFileSync('$CONFIG','utf-8'));
+    if (Array.isArray(c.plugins)) {
+      console.log(c.plugins.join(' '));
+    } else if (c.plugins && typeof c.plugins === 'object') {
+      console.log(Object.entries(c.plugins)
+        .filter(([, v]) => v && v.enabled !== false)
+        .map(([k]) => k)
+        .join(' '));
+    }
+  " 2>/dev/null || echo "")
+fi
+
+if [ -z "$PLUGIN_LIST" ]; then
+  # No config or no plugins key -- use all plugin directories
+  PLUGIN_LIST=""
+  for d in "$PLUGINS_DIR"/*/; do
+    [ -d "$d" ] || continue
+    name=$(basename "$d")
+    case "$name" in _*|.*) continue ;; esac
+    PLUGIN_LIST="$PLUGIN_LIST $name"
+  done
+fi
+
+echo "[install-plugin-deps] Plugins:$PLUGIN_LIST"
+
+# Collect apt packages
+PKGS=""
+for name in $PLUGIN_LIST; do
+  f="$PLUGINS_DIR/$name/apt.txt"
+  [ -f "$f" ] || continue
+  while IFS= read -r line; do
+    case "$line" in \#*|"") continue ;; esac
+    PKGS="$PKGS $line"
+  done < "$f"
+done
+
+if [ -n "$PKGS" ]; then
+  echo "[install-plugin-deps] Installing:$PKGS"
+  apt-get update && apt-get install -y $PKGS && rm -rf /var/lib/apt/lists/*
+else
+  echo "[install-plugin-deps] No apt dependencies"
+fi
+
+# Run post-install hooks
+for name in $PLUGIN_LIST; do
+  hook="$PLUGINS_DIR/$name/post-install.sh"
+  [ -x "$hook" ] || continue
+  echo "[install-plugin-deps] Running post-install for $name"
+  "$hook"
+done

package/scripts/plugin.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+/**
+ * camofox plugin manager -- install, remove, and list plugins.
+ *
+ * Usage:
+ *   node scripts/plugin.js install <source>   Install a plugin from git URL or local path
+ *   node scripts/plugin.js remove <name>      Remove a plugin and its config entry
+ *   node scripts/plugin.js list               List installed plugins and their source
+ *
+ * Sources:
+ *   git:github.com/user/repo                  Git shorthand
+ *   https://github.com/user/repo              Git URL
+ *   /absolute/path/to/plugin-dir              Local directory (copied)
+ *   ./relative/path/to/plugin-dir             Local directory (copied)
+ *
+ * Plugin name is inferred from the repo/directory name. If the repo root has
+ * an index.js with register(), it's used directly. If it has a plugins/ subdir,
+ * each subdirectory is installed as a separate plugin.
+ *
+ * After install, the plugin is added to camofox.config.json plugins[] and
+ * npm dependencies are installed if the plugin has a package.json.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from './exec.js';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.join(__dirname, '..');
+const PLUGINS_DIR = path.join(ROOT, 'plugins');
+const CONFIG_PATH = path.join(ROOT, 'camofox.config.json');
+
+// -- Config helpers ----------------------------------------------------------
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    return { id: 'camofox-browser', name: 'Camofox Browser', version: '0.0.0', plugins: [] };
+  }
+}
+
+function writeConfig(config) {
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+}
+
+/**
+ * Get the set of enabled plugin names from config.
+ * Handles both array format ["youtube"] and object format { "youtube": { "enabled": true } }.
+ */
+function getEnabledPlugins(config) {
+  if (!config.plugins) return new Set();
+  if (Array.isArray(config.plugins)) return new Set(config.plugins);
+  if (typeof config.plugins === 'object') {
+    const enabled = new Set();
+    for (const [name, conf] of Object.entries(config.plugins)) {
+      if (conf === false || (typeof conf === 'object' && conf.enabled === false)) continue;
+      enabled.add(name);
+    }
+    return enabled;
+  }
+  return new Set();
+}
+
+function addToConfig(name) {
+  const config = readConfig();
+  if (Array.isArray(config.plugins)) {
+    if (!config.plugins.includes(name)) {
+      config.plugins.push(name);
+      writeConfig(config);
+    }
+  } else if (typeof config.plugins === 'object') {
+    if (!config.plugins[name] || config.plugins[name].enabled === false) {
+      config.plugins[name] = config.plugins[name] || {};
+      config.plugins[name].enabled = true;
+      writeConfig(config);
+    }
+  } else {
+    config.plugins = [name];
+    writeConfig(config);
+  }
+}
+
+function removeFromConfig(name) {
+  const config = readConfig();
+  if (Array.isArray(config.plugins)) {
+    config.plugins = config.plugins.filter(p => p !== name);
+    writeConfig(config);
+  } else if (typeof config.plugins === 'object' && config.plugins[name] !== undefined) {
+    delete config.plugins[name];
+    writeConfig(config);
+  }
+}
+
+// -- Source parsing ----------------------------------------------------------
+
+function parseSource(source) {
+  // Local path
+  if (source.startsWith('/') || source.startsWith('./') || source.startsWith('../')) {
+    const resolved = path.resolve(source);
+    if (!fs.existsSync(resolved)) {
+      fatal(`Local path not found: ${resolved}`);
+    }
+    if (!fs.statSync(resolved).isDirectory()) {
+      fatal(`Source must be a directory: ${resolved}`);
+    }
+    return { type: 'local', path: resolved, name: path.basename(resolved) };
+  }
+
+  // Git URL -- https://, ssh://, git@, git:
+  let gitUrl = source;
+  if (gitUrl.startsWith('git:')) {
+    gitUrl = gitUrl.slice(4);
+    // git:github.com/user/repo -> https://github.com/user/repo
+    if (!gitUrl.startsWith('http') && !gitUrl.startsWith('ssh://') && !gitUrl.startsWith('git@')) {
+      gitUrl = `https://${gitUrl}`;
+    }
+  }
+
+  // Strip trailing .git
+  gitUrl = gitUrl.replace(/\.git$/, '');
+
+  // Extract name from URL
+  const name = gitUrl.split('/').pop().replace(/[^a-zA-Z0-9_-]/g, '');
+  if (!name) fatal(`Cannot infer plugin name from: ${source}`);
+
+  // Re-add .git for clone
+  const cloneUrl = gitUrl.endsWith('.git') ? gitUrl : `${gitUrl}.git`;
+
+  return { type: 'git', url: cloneUrl, name };
+}
+
+// -- Install -----------------------------------------------------------------
+
+function isPluginDir(dir) {
+  const indexPath = path.join(dir, 'index.js');
+  if (!fs.existsSync(indexPath)) return false;
+  const content = fs.readFileSync(indexPath, 'utf-8');
+  return /\bregister\b/.test(content);
+}
+
+function installFromLocal(srcDir, name) {
+  const destDir = path.join(PLUGINS_DIR, name);
+  if (fs.existsSync(destDir)) {
+    fatal(`Plugin "${name}" already exists. Remove it first: node scripts/plugin.js remove ${name}`);
+  }
+  copyDirSync(srcDir, destDir);
+  return [name];
+}
+
+function installFromGit(url, name) {
+  const tmpDir = path.join(ROOT, '.tmp-plugin-clone');
+  try {
+    if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true });
+
+    console.log(`Cloning ${url}...`);
+    execSync(`git clone --depth 1 ${url} ${tmpDir}`, { stdio: 'pipe' });
+
+    // Case 1: Root is a plugin (has index.js with register)
+    if (isPluginDir(tmpDir)) {
+      return installFromLocal(tmpDir, name);
+    }
+
+    // Case 2: Has plugins/ subdir with plugin directories
+    const pluginsSubdir = path.join(tmpDir, 'plugins');
+    if (fs.existsSync(pluginsSubdir) && fs.statSync(pluginsSubdir).isDirectory()) {
+      const installed = [];
+      for (const entry of fs.readdirSync(pluginsSubdir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+        const subDir = path.join(pluginsSubdir, entry.name);
+        if (isPluginDir(subDir)) {
+          installFromLocal(subDir, entry.name);
+          installed.push(entry.name);
+        }
+      }
+      if (installed.length === 0) {
+        fatal(`No plugins found in ${url} -- expected index.js with register() at root or in plugins/*/`);
+      }
+      return installed;
+    }
+
+    fatal(`No plugins found in ${url} -- expected index.js with register() at root or plugins/*/ subdirs`);
+  } finally {
+    if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true });
+  }
+}
+
+function installPluginDeps(name) {
+  const pluginDir = path.join(PLUGINS_DIR, name);
+
+  // npm install if package.json exists
+  const pkgJson = path.join(pluginDir, 'package.json');
+  if (fs.existsSync(pkgJson)) {
+    console.log(`Installing npm dependencies for ${name}...`);
+    execSync('npm install --omit=dev', { cwd: pluginDir, stdio: 'inherit' });
+  }
+
+  // Check for apt.txt / post-install.sh (just warn -- can't run apt locally)
+  if (fs.existsSync(path.join(pluginDir, 'apt.txt'))) {
+    console.log(`WARNING  ${name} has apt.txt -- system packages need Docker build or manual install`);
+  }
+  if (fs.existsSync(path.join(pluginDir, 'post-install.sh'))) {
+    console.log(`WARNING  ${name} has post-install.sh -- run it manually or rebuild Docker image`);
+  }
+}
+
+// -- Remove ------------------------------------------------------------------
+
+function removePlugin(name) {
+  const pluginDir = path.join(PLUGINS_DIR, name);
+  if (!fs.existsSync(pluginDir)) {
+    fatal(`Plugin "${name}" not found in plugins/`);
+  }
+
+  fs.rmSync(pluginDir, { recursive: true });
+  removeFromConfig(name);
+  console.log(`[ok] Removed plugin "${name}"`);
+}
+
+// -- List --------------------------------------------------------------------
+
+function listPlugins() {
+  const config = readConfig();
+  const configPlugins = getEnabledPlugins(config);
+
+  if (!fs.existsSync(PLUGINS_DIR)) {
+    console.log('No plugins directory.');
+    return;
+  }
+
+  const entries = fs.readdirSync(PLUGINS_DIR, { withFileTypes: true });
+  const plugins = entries
+    .filter(e => e.isDirectory() && !e.name.startsWith('_') && !e.name.startsWith('.'))
+    .map(e => e.name);
+
+  if (plugins.length === 0) {
+    console.log('No plugins installed.');
+    return;
+  }
+
+  console.log('Installed plugins:\n');
+  for (const name of plugins.sort()) {
+    const enabled = configPlugins.size === 0 || configPlugins.has(name);
+    const status = enabled ? '[ok]' : 'o';
+    const hasTest = fs.existsSync(path.join(PLUGINS_DIR, name, `${name}.test.js`))
+      || fs.readdirSync(path.join(PLUGINS_DIR, name)).some(f => f.endsWith('.test.js'));
+    const hasDeps = fs.existsSync(path.join(PLUGINS_DIR, name, 'apt.txt'))
+      || fs.existsSync(path.join(PLUGINS_DIR, name, 'post-install.sh'));
+    const hasPkg = fs.existsSync(path.join(PLUGINS_DIR, name, 'package.json'));
+
+    const flags = [
+      hasTest ? 'tests' : null,
+      hasDeps ? 'sys-deps' : null,
+      hasPkg ? 'npm-deps' : null,
+    ].filter(Boolean).join(', ');
+
+    console.log(`  ${status} ${name}${flags ? `  (${flags})` : ''}`);
+  }
+
+  if (configPlugins.size > 0) {
+    console.log(`\n${configPlugins.size} plugin(s) enabled in camofox.config.json`);
+  } else {
+    console.log('\nNo plugins[] in config -- all plugins are loaded');
+  }
+}
+
+// -- Helpers -----------------------------------------------------------------
+
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    // Skip .git, node_modules
+    if (entry.name === '.git' || entry.name === 'node_modules') continue;
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function fatal(msg) {
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+}
+
+// -- CLI ---------------------------------------------------------------------
+
+const [,, action, ...args] = process.argv;
+
+switch (action) {
+  case 'install': {
+    const source = args[0];
+    if (!source) fatal('Usage: plugin install <git-url|local-path>');
+
+    const parsed = parseSource(source);
+    const installed = parsed.type === 'git'
+      ? installFromGit(parsed.url, parsed.name)
+      : installFromLocal(parsed.path, parsed.name);
+
+    for (const name of installed) {
+      addToConfig(name);
+      installPluginDeps(name);
+    }
+
+    console.log(`\n[ok] Installed: ${installed.join(', ')}`);
+    console.log('  Restart the server to load new plugin(s).');
+    break;
+  }
+
+  case 'remove': {
+    const name = args[0];
+    if (!name) fatal('Usage: plugin remove <name>');
+    removePlugin(name);
+    break;
+  }
+
+  case 'list':
+  case 'ls': {
+    listPlugins();
+    break;
+  }
+
+  default:
+    console.log(`camofox plugin manager
+
+Usage:
+  node scripts/plugin.js install <source>   Install from git URL or local path
+  node scripts/plugin.js remove <name>      Remove a plugin
+  node scripts/plugin.js list               List installed plugins
+
+Sources:
+  git:github.com/user/repo
+  https://github.com/user/repo
+  ./path/to/local/plugin`);
+    if (action) process.exit(1);
+}

package/scripts/postinstall.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// PHI-VENDOR: original upstream postinstall is preserved at
+// `scripts/postinstall.upstream.js` for reference. The Camoufox binary
+// is now provided by the @phi-code-admin/camoufox-bin-<platform>-<arch>
+// npm package via @phi-code-admin/camoufox-js#optionalDependencies, so
+// this postinstall is a deliberate no-op.
+//
+// Rationale (per uglyswap/phi-code vendoring spec, Phase 4):
+//   * No network calls during `npm install` — works behind firewalls.
+//   * No fetch from `daijro/camoufox` releases — no dependency on third
+//     parties at install time.
+//   * Always exits 0 to avoid breaking the user's install when this is a
+//     transitive dependency.
+//
+// To re-enable the upstream fetcher (e.g. for development against a newer
+// daijro/camoufox release that hasn't been re-vendored yet), set
+// `CAMOUFOX_ALLOW_GITHUB_FETCH=1` and run
+// `npx @phi-code-admin/camoufox-js fetch` manually.
+
+process.exit(0);

package/scripts/sync-version.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * Sync openclaw.plugin.json version with package.json.
+ * Run via: npm run version:sync
+ * Auto-runs on npm version via the "version" lifecycle script.
+ */
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+
+const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+const pluginPath = join(root, 'openclaw.plugin.json');
+const plugin = JSON.parse(await readFile(pluginPath, 'utf8'));
+
+if (plugin.version !== pkg.version) {
+  plugin.version = pkg.version;
+  await writeFile(pluginPath, JSON.stringify(plugin, null, 2) + '\n');
+  console.log(`openclaw.plugin.json version synced to ${pkg.version}`);
+} else {
+  console.log(`openclaw.plugin.json already at ${pkg.version}`);
+}