codex-blocker 0.1.2 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # codex-blocker
 
-CLI tool and server for Codex Blocker — block distracting websites unless Codex is actively running.
+CLI tool and server for Codex Blocker -- block distracting websites unless Codex is actively running.
 
 ## Installation
 
@@ -41,18 +41,18 @@ npx codex-blocker --version
 
 ## How It Works
 
-1. **Codex sessions** — The server tails Codex session logs under `~/.codex/sessions`
-   to detect activity. It marks a session “working” on your prompt and on intermediate
+1. **Codex sessions** -- The server tails Codex session logs under `~/.codex/sessions`
+   to detect activity. It marks a session "working" on your prompt and on intermediate
    assistant/tool activity, marks `waiting_for_input` when Codex emits
-   `request_user_input`, and marks “idle” when it sees a terminal assistant reply
+   `request_user_input`, and marks "idle" when it sees a terminal assistant reply
    (`phase: "final_answer"`), with legacy fallback support for older Codex logs.
 
-2. **Server** — Runs on localhost and:
+2. **Server** -- Runs on localhost and:
    - Tracks active Codex sessions
    - Marks sessions "working" when new log lines arrive
    - Broadcasts state via WebSocket to the Chrome extension
 
-3. **Extension** — Connects to the server and:
+3. **Extension** -- Connects to the server and:
    - Blocks configured sites when no sessions are working, or when any session is waiting for user input
    - Shows a modal overlay (soft block, not network block)
    - Updates in real-time without page refresh
@@ -82,7 +82,7 @@ Connect to `ws://localhost:8765/ws` to receive real-time state updates:
 ## Programmatic Usage
 
 ```typescript
-import { startServer } from 'codex-blocker';
+import { startServer } from "codex-blocker";
 
 // Start on default port (8765)
 startServer();

package/dist/bin.js

@@ -2,7 +2,7 @@
 import {
   DEFAULT_PORT,
   startServer
-} from "./chunk-KNFNSOAX.js";
+} from "./chunk-OIDV724O.js";
 
 // src/bin.ts
 import { createRequire } from "module";
@@ -39,10 +39,452 @@ function removeCodexSetup() {
   console.log("No Codex hooks to remove.");
 }
 
+// src/mobile-network.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var WSL_POWERSHELL_PATH = "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe";
+var IPV4_MATCH = /\b((?:25[0-5]|2[0-4]\d|1?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3})\b/;
+var ROUTE_SRC_IPV4_MATCH = /\bsrc\s+((?:25[0-5]|2[0-4]\d|1?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3})\b/;
+function parseFirstIpv4Candidate(raw) {
+  const match = raw.match(IPV4_MATCH);
+  return match ? match[1] : null;
+}
+function parseRouteSourceIpv4(raw) {
+  const match = raw.match(ROUTE_SRC_IPV4_MATCH);
+  return match ? match[1] : null;
+}
+function detectWsl() {
+  if (process.platform !== "linux") return false;
+  return Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+}
+function getPowerShellExecutable() {
+  if (process.platform === "win32") {
+    return "powershell.exe";
+  }
+  if (detectWsl() && existsSync2(WSL_POWERSHELL_PATH)) {
+    return WSL_POWERSHELL_PATH;
+  }
+  return null;
+}
+async function runCommand(command, args2) {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args2, {
+      maxBuffer: 1024 * 1024
+    });
+    return {
+      code: 0,
+      stdout,
+      stderr
+    };
+  } catch (error) {
+    const failure = error;
+    return {
+      code: typeof failure.code === "number" ? failure.code : 1,
+      stdout: failure.stdout ?? "",
+      stderr: failure.stderr ?? failure.message
+    };
+  }
+}
+async function checkDiscovery(url) {
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!response.ok) {
+      return {
+        ok: false,
+        details: `${response.status} ${response.statusText}`
+      };
+    }
+    return {
+      ok: true,
+      details: "reachable"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      details: message
+    };
+  }
+}
+async function resolvePortProxyConnectAddress() {
+  if (!detectWsl()) {
+    return "127.0.0.1";
+  }
+  const routeProbe = await runCommand("sh", [
+    "-lc",
+    "ip -4 route get 1.1.1.1 2>/dev/null || ip -4 route get 8.8.8.8 2>/dev/null"
+  ]);
+  if (routeProbe.code === 0) {
+    const routeSrc = parseRouteSourceIpv4(routeProbe.stdout);
+    if (routeSrc) {
+      return routeSrc;
+    }
+  }
+  const probe = await runCommand("sh", ["-lc", "hostname -I"]);
+  if (probe.code !== 0) {
+    return "127.0.0.1";
+  }
+  const ip = parseFirstIpv4Candidate(probe.stdout);
+  return ip ?? "127.0.0.1";
+}
+function parseWindowsDiagnostics(rawJson) {
+  try {
+    const data = JSON.parse(rawJson);
+    return {
+      profileName: typeof data.profileName === "string" ? data.profileName : null,
+      interfaceAlias: typeof data.interfaceAlias === "string" ? data.interfaceAlias : null,
+      networkCategory: data.networkCategory === "Public" || data.networkCategory === "Private" || data.networkCategory === "DomainAuthenticated" ? data.networkCategory : "Unknown",
+      wifiIp: typeof data.wifiIp === "string" ? data.wifiIp : null,
+      hasPortProxy: Boolean(data.hasPortProxy),
+      portProxyTarget: typeof data.portProxyTarget === "string" ? data.portProxyTarget : null,
+      hasPrivateRule: Boolean(data.hasPrivateRule),
+      hasPublicRule: Boolean(data.hasPublicRule),
+      localhostReachable: Boolean(data.localhostReachable),
+      lanReachable: Boolean(data.lanReachable)
+    };
+  } catch {
+    return null;
+  }
+}
+function toPowerShellEncodedCommand(script) {
+  return Buffer.from(script, "utf16le").toString("base64");
+}
+function buildWindowsDoctorScript(port) {
+  return `
+$ErrorActionPreference = 'SilentlyContinue'
+$port = ${port}
+
+$profile = Get-NetConnectionProfile | Where-Object { $_.IPv4Connectivity -ne 'Disconnected' } | Select-Object -First 1
+$wifiIp = $null
+if ($profile) {
+  $wifiIp = Get-NetIPAddress -AddressFamily IPv4 |
+    Where-Object { $_.InterfaceAlias -eq $profile.InterfaceAlias -and $_.IPAddress -notlike '169.254*' } |
+    Select-Object -First 1 -ExpandProperty IPAddress
+}
+
+$proxyTable = netsh interface portproxy show v4tov4 | Out-String
+$proxyLine = ($proxyTable -split "\\r?\\n") |
+  Where-Object { $_ -match ("^\\s*0\\.0\\.0\\.0\\s+" + $port + "\\s+") } |
+  Select-Object -First 1
+$hasPortProxy = $false
+$portProxyTarget = $null
+if ($proxyLine) {
+  $parts = ($proxyLine -split "\\s+") | Where-Object { $_ -ne "" }
+  if ($parts.Count -ge 4 -and [string]$parts[3] -eq [string]$port) {
+    $hasPortProxy = $true
+    $portProxyTarget = [string]$parts[2]
+  }
+}
+
+$privateRule = Get-NetFirewallRule -DisplayName "Codex Blocker $port Private LocalSubnet" -ErrorAction SilentlyContinue
+$publicRule = Get-NetFirewallRule -DisplayName "Codex Blocker $port Public LocalSubnet" -ErrorAction SilentlyContinue
+
+$localhostReachable = $false
+try {
+  Invoke-RestMethod -Uri ("http://127.0.0.1:" + $port + "/mobile/discovery") -Method Get -TimeoutSec 2 | Out-Null
+  $localhostReachable = $true
+} catch {}
+
+$lanReachable = $false
+if ($wifiIp) {
+  try {
+    Invoke-RestMethod -Uri ("http://" + $wifiIp + ":" + $port + "/mobile/discovery") -Method Get -TimeoutSec 2 | Out-Null
+    $lanReachable = $true
+  } catch {}
+}
+
+[pscustomobject]@{
+  profileName = if ($profile) { $profile.Name } else { $null }
+  interfaceAlias = if ($profile) { $profile.InterfaceAlias } else { $null }
+  networkCategory = if ($profile) { [string]$profile.NetworkCategory } else { "Unknown" }
+  wifiIp = $wifiIp
+  hasPortProxy = [bool]$hasPortProxy
+  portProxyTarget = $portProxyTarget
+  hasPrivateRule = [bool]$privateRule
+  hasPublicRule = [bool]$publicRule
+  localhostReachable = $localhostReachable
+  lanReachable = $lanReachable
+} | ConvertTo-Json -Compress
+`.trim();
+}
+function buildWindowsFixScript(port, allowPublicFirewallRule, connectAddress) {
+  const allowPublicLiteral = allowPublicFirewallRule ? "$true" : "$false";
+  const elevatedCommands = `
+$ErrorActionPreference = 'Stop'
+$port = ${port}
+$allowPublic = ${allowPublicLiteral}
+$connectAddress = "${connectAddress}"
+
+netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=$port 2>$null | Out-Null
+netsh interface portproxy delete v4tov4 listenaddress=127.0.0.1 listenport=$port 2>$null | Out-Null
+netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=$port connectaddress=$connectAddress connectport=$port
+
+if (-not $allowPublic) {
+  Remove-NetFirewallRule -DisplayName "Codex Blocker $port Public LocalSubnet" -ErrorAction SilentlyContinue | Out-Null
+}
+
+$profiles = @('Private')
+if ($allowPublic) {
+  $profiles += 'Public'
+}
+
+foreach ($profile in $profiles) {
+  $ruleName = "Codex Blocker $port $profile LocalSubnet"
+  if (Get-NetFirewallRule -DisplayName $ruleName -ErrorAction SilentlyContinue) {
+    Remove-NetFirewallRule -DisplayName $ruleName | Out-Null
+  }
+
+  New-NetFirewallRule -DisplayName $ruleName -Direction Inbound -Action Allow -Protocol TCP -LocalPort $port -Profile $profile -RemoteAddress LocalSubnet | Out-Null
+}
+
+Write-Output "Configured portproxy + firewall for port $port (allowPublic=$allowPublic, connectAddress=$connectAddress)"
+netsh interface portproxy show v4tov4
+`.trim();
+  return buildWindowsElevatedScript(elevatedCommands);
+}
+function buildWindowsRemoveScript(port) {
+  const elevatedCommands = `
+$ErrorActionPreference = 'SilentlyContinue'
+$port = ${port}
+
+netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=$port 2>$null | Out-Null
+netsh interface portproxy delete v4tov4 listenaddress=127.0.0.1 listenport=$port 2>$null | Out-Null
+netsh interface portproxy delete v4tov4 listenaddress=:: listenport=$port 2>$null | Out-Null
+
+Remove-NetFirewallRule -DisplayName "Codex Blocker $port Private LocalSubnet" -ErrorAction SilentlyContinue | Out-Null
+Remove-NetFirewallRule -DisplayName "Codex Blocker $port Public LocalSubnet" -ErrorAction SilentlyContinue | Out-Null
+Remove-NetFirewallRule -DisplayName "Codex Blocker $port" -ErrorAction SilentlyContinue | Out-Null
+
+Write-Output "Removed Codex Blocker networking setup for port $port"
+netsh interface portproxy show v4tov4
+`.trim();
+  return buildWindowsElevatedScript(elevatedCommands);
+}
+function buildWindowsElevatedScript(elevatedCommands) {
+  const encoded = toPowerShellEncodedCommand(elevatedCommands);
+  return `
+$ErrorActionPreference = 'Stop'
+$isAdmin = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+
+if (-not $isAdmin) {
+  $proc = Start-Process -FilePath "powershell.exe" -Verb RunAs -ArgumentList "-NoProfile -ExecutionPolicy Bypass -EncodedCommand ${encoded}" -Wait -PassThru
+  exit $proc.ExitCode
+}
+
+${elevatedCommands}
+`.trim();
+}
+async function runPowerShellScript(powershellExe, script) {
+  return runCommand(powershellExe, [
+    "-NoProfile",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    script
+  ]);
+}
+function assessWindowsDiagnostics(diagnostics, port, options) {
+  const allowPublicFirewallRule = options?.allowPublicFirewallRule ?? false;
+  const checks = [];
+  checks.push({
+    name: "Port proxy (0.0.0.0 -> target)",
+    ok: diagnostics.hasPortProxy,
+    details: diagnostics.hasPortProxy ? `configured for TCP ${port} -> ${diagnostics.portProxyTarget ?? "unknown"}` : `missing for TCP ${port}`
+  });
+  const category = diagnostics.networkCategory;
+  let profileRuleOk = false;
+  let profileDetails = `private=${diagnostics.hasPrivateRule}, public=${diagnostics.hasPublicRule}`;
+  if (category === "Public") {
+    profileRuleOk = allowPublicFirewallRule ? diagnostics.hasPublicRule : false;
+    profileDetails = allowPublicFirewallRule ? `private=${diagnostics.hasPrivateRule}, public=${diagnostics.hasPublicRule}` : "public profile is locked down by default; pass --allow-public if you need LAN access on public Wi-Fi";
+  } else if (category === "Private") {
+    profileRuleOk = diagnostics.hasPrivateRule;
+  } else {
+    profileRuleOk = diagnostics.hasPrivateRule || diagnostics.hasPublicRule;
+  }
+  checks.push({
+    name: `Firewall rule for ${category} profile`,
+    ok: profileRuleOk,
+    details: profileDetails
+  });
+  checks.push({
+    name: "Windows loopback access",
+    ok: diagnostics.localhostReachable,
+    details: diagnostics.localhostReachable ? "http://127.0.0.1 reachable" : "http://127.0.0.1 unreachable"
+  });
+  checks.push({
+    name: "Windows LAN access",
+    ok: diagnostics.lanReachable,
+    details: diagnostics.wifiIp ? diagnostics.lanReachable ? `http://${diagnostics.wifiIp}:${port} reachable` : `http://${diagnostics.wifiIp}:${port} unreachable` : "Wi-Fi IPv4 not detected"
+  });
+  const recommendations = [];
+  const fixCommand = allowPublicFirewallRule ? `Run: npx codex-blocker mobile:fix --port ${port} --allow-public` : `Run: npx codex-blocker mobile:fix --port ${port}`;
+  if (!diagnostics.hasPortProxy || !profileRuleOk) {
+    recommendations.push(
+      category === "Public" && !allowPublicFirewallRule ? `Run: npx codex-blocker mobile:fix --port ${port} --allow-public` : fixCommand
+    );
+  }
+  if (category === "Public" && !allowPublicFirewallRule) {
+    recommendations.push(
+      "Public Wi-Fi profile detected. Either switch this network to Private or use --allow-public for mobile LAN access."
+    );
+  }
+  if (diagnostics.localhostReachable && diagnostics.hasPortProxy && profileRuleOk && !diagnostics.lanReachable) {
+    recommendations.push(
+      "Check router/client isolation or guest Wi-Fi settings (phone may be blocked from peer LAN devices)."
+    );
+  }
+  const ok = checks.every((check) => check.ok);
+  return {
+    checks,
+    recommendations,
+    ok
+  };
+}
+async function runMobileDoctor(port, options) {
+  const allowPublicFirewallRule = options?.allowPublicFirewallRule ?? false;
+  const report = {
+    ok: true,
+    checks: [],
+    recommendations: []
+  };
+  const localCheck = await checkDiscovery(`http://127.0.0.1:${port}/mobile/discovery`);
+  report.checks.push({
+    name: "Local server from current shell",
+    ok: localCheck.ok,
+    details: localCheck.details
+  });
+  if (!localCheck.ok) {
+    report.recommendations.push("Start the server: npx codex-blocker");
+  }
+  const powershellExe = getPowerShellExecutable();
+  if (!powershellExe) {
+    report.recommendations.push(
+      "PowerShell not found. Windows-specific diagnostics are unavailable in this environment."
+    );
+  } else {
+    const doctorScript = buildWindowsDoctorScript(port);
+    const doctorResult = await runPowerShellScript(powershellExe, doctorScript);
+    if (doctorResult.code !== 0) {
+      report.checks.push({
+        name: "Windows diagnostics execution",
+        ok: false,
+        details: doctorResult.stderr.trim() || "failed"
+      });
+      report.recommendations.push(
+        "Failed to query Windows networking state. Try running mobile:doctor from a Windows terminal."
+      );
+    } else {
+      const diagnostics = parseWindowsDiagnostics(doctorResult.stdout);
+      if (!diagnostics) {
+        report.checks.push({
+          name: "Windows diagnostics parsing",
+          ok: false,
+          details: "Unexpected PowerShell output"
+        });
+        report.recommendations.push(
+          "Unable to parse Windows diagnostics output. Re-run with a clean shell."
+        );
+      } else {
+        const windowsAssessment = assessWindowsDiagnostics(diagnostics, port, {
+          allowPublicFirewallRule
+        });
+        for (const check of windowsAssessment.checks) {
+          report.checks.push(check);
+        }
+        report.recommendations.push(...windowsAssessment.recommendations);
+        if (localCheck.ok && !diagnostics.localhostReachable) {
+          report.recommendations.push(
+            "Windows cannot reach the forwarded localhost port. Re-run mobile:fix so portproxy can target the current WSL IP."
+          );
+        }
+      }
+    }
+  }
+  report.ok = report.checks.every((check) => check.ok);
+  console.log("\nCodex Blocker Mobile Doctor");
+  console.log(`Port: ${port}`);
+  if (detectWsl()) {
+    console.log("Environment: WSL");
+  }
+  console.log("");
+  for (const check of report.checks) {
+    const icon = check.ok ? "[OK]" : "[FAIL]";
+    console.log(`${icon} ${check.name} - ${check.details}`);
+  }
+  console.log("");
+  if (report.recommendations.length > 0) {
+    console.log("Recommendations:");
+    for (const recommendation of report.recommendations) {
+      console.log(`- ${recommendation}`);
+    }
+  } else {
+    console.log("No issues detected.");
+  }
+  console.log("");
+  return report.ok;
+}
+async function runMobileFix(port, options) {
+  return runMobileFixWithOptions(port, options);
+}
+async function runMobileFixWithOptions(port, options) {
+  const allowPublicFirewallRule = options?.allowPublicFirewallRule ?? false;
+  const powershellExe = getPowerShellExecutable();
+  if (!powershellExe) {
+    console.error("PowerShell is required for mobile:fix but was not found.");
+    return false;
+  }
+  const connectAddress = await resolvePortProxyConnectAddress();
+  const script = buildWindowsFixScript(port, allowPublicFirewallRule, connectAddress);
+  const result = await runPowerShellScript(powershellExe, script);
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim() || "unknown error";
+    console.error(`mobile:fix failed: ${stderr}`);
+    return false;
+  }
+  const stdout = result.stdout.trim();
+  if (stdout) {
+    console.log(stdout);
+  }
+  console.log("\nRunning doctor after fix...\n");
+  return runMobileDoctor(port, { allowPublicFirewallRule });
+}
+async function runMobileRemove(port) {
+  const powershellExe = getPowerShellExecutable();
+  if (!powershellExe) {
+    console.error("PowerShell is required for mobile:remove but was not found.");
+    return false;
+  }
+  const script = buildWindowsRemoveScript(port);
+  const result = await runPowerShellScript(powershellExe, script);
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim() || "unknown error";
+    console.error(`mobile:remove failed: ${stderr}`);
+    return false;
+  }
+  const stdout = result.stdout.trim();
+  if (stdout) {
+    console.log(stdout);
+  }
+  console.log("\nRunning doctor after remove...\n");
+  await runMobileDoctor(port);
+  return true;
+}
+
 // src/bin.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var args = process.argv.slice(2);
+function isWindowsOrWslRuntime() {
+  if (process.platform === "win32") return true;
+  return Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+}
 function prompt(question) {
   const rl = createInterface({
     input: process.stdin,
@@ -61,19 +503,42 @@ Codex Blocker - Block distracting sites when Codex isn't working
 
 Usage:
   npx codex-blocker [options]
+  npx codex-blocker mobile:doctor [options]
+  npx codex-blocker mobile:fix [options]
+  npx codex-blocker mobile:remove [options]
 
 Options:
-  --setup     Show Codex setup info
-  --remove    Remove Codex setup (no-op)
-  --port      Server port (default: ${DEFAULT_PORT})
-  --version   Show version
-  --help      Show this help message
+  --setup           Show Codex setup info
+  --remove          Remove Codex setup (no-op)
+  --port            Server port (default: ${DEFAULT_PORT})
+  --bind            Server bind host
+  --extension-only  Disable mobile LAN discovery and pairing endpoints
+  --mobile-name     Mobile discovery name
+  --allow-public    Allow Public-profile firewall access for mobile:fix
+  --version         Show version
+  --help            Show this help message
 
 Examples:
   npx codex-blocker            # Start the server
   npx codex-blocker --port 9000
+  npx codex-blocker --extension-only
+  npx codex-blocker mobile:doctor
 `);
 }
+function readOption(name) {
+  const index = args.indexOf(name);
+  return index === -1 ? void 0 : args[index + 1];
+}
+function readPort() {
+  const rawPort = readOption("--port");
+  if (!rawPort) return DEFAULT_PORT;
+  const parsed = parseInt(rawPort, 10);
+  if (!isNaN(parsed) && parsed > 0 && parsed < 65536) {
+    return parsed;
+  }
+  console.error("Invalid port number");
+  process.exit(1);
+}
 async function main() {
   if (args.includes("--help") || args.includes("-h")) {
     printHelp();
@@ -91,16 +556,20 @@ async function main() {
     removeCodexSetup();
     process.exit(0);
   }
-  let port = DEFAULT_PORT;
-  const portIndex = args.indexOf("--port");
-  if (portIndex !== -1 && args[portIndex + 1]) {
-    const parsed = parseInt(args[portIndex + 1], 10);
-    if (!isNaN(parsed) && parsed > 0 && parsed < 65536) {
-      port = parsed;
-    } else {
-      console.error("Invalid port number");
-      process.exit(1);
-    }
+  const port = readPort();
+  const command = args[0];
+  if (command === "mobile:doctor") {
+    process.exit(await runMobileDoctor(port, {
+      allowPublicFirewallRule: args.includes("--allow-public")
+    }) ? 0 : 1);
+  }
+  if (command === "mobile:fix") {
+    process.exit(await runMobileFix(port, {
+      allowPublicFirewallRule: args.includes("--allow-public")
+    }) ? 0 : 1);
+  }
+  if (command === "mobile:remove") {
+    process.exit(await runMobileRemove(port) ? 0 : 1);
   }
   if (!isCodexAvailable()) {
     console.log("Codex sessions directory not found yet.");
@@ -109,6 +578,13 @@ async function main() {
       console.log("");
     }
   }
-  startServer(port);
+  const extensionOnly = args.includes("--extension-only");
+  const bindHost = readOption("--bind") ?? (extensionOnly ? "127.0.0.1" : isWindowsOrWslRuntime() ? "0.0.0.0" : "127.0.0.1");
+  startServer(port, {
+    mobile: !extensionOnly,
+    bindHost,
+    mobileServiceName: readOption("--mobile-name"),
+    mobileQrOutput: !extensionOnly
+  });
 }
 main();