@gecho-ai/gecho-bridge 1.1.38-beta.0 → 1.1.38

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "@gecho-ai/gecho-bridge",
-  "version": "1.1.38-beta.0",
+  "version": "1.1.38",
   "description": "Browser research tools for OpenClaw via the Gecho Chrome Extension"
 }

package/README.md

@@ -281,6 +281,8 @@ If installation is successful, you should see `Status: loaded` and `MCP servers:
 ### 2. Note about the local background service
 - Gecho Bridge automatically starts a local service on demand so the MCP client can talk to the browser extension.
 - This service only listens on `127.0.0.1` and is expected to stay available while you use the plugin.
+- You can also manage it independently with `npm run server:start`, `npm run server:status`, and `npm run server:stop`.
+- To run it after user login, use `npx gecho-bridge-server install`; remove the startup entry with `npx gecho-bridge-server uninstall`.
 - If Chrome or the extension was restarted and requests start failing, first run `openclaw gateway restart`, then try again.
 
 ### 3. Error: Extension not connected
@@ -329,6 +331,8 @@ npm run server
 - **Client layer** (`mcp-client.js`): The standard MCP STDIO integration layer, responsible for communicating with clients such as OpenClaw, Hermes, and Trae, and declaring the Tools specification.
 - **Service layer** (`server.js`): The local resident service layer, responsible for communicating with the browser extension via WebSocket and executing the actual scraping and persistence. (Supports a Lazy Start mechanism and launches only when needed.)
 
+See [`docs/scheduled-flywheel-bridge.md`](docs/scheduled-flywheel-bridge.md) for scheduled flywheel APIs, standalone Bridge operation, and user-level login startup.
+
 ## License
 
 MIT

package/README.zh.md

@@ -286,6 +286,8 @@ openclaw plugins info @gecho-ai/gecho-bridge-bundle
 ### 2. 关于本地后台服务的说明
 - Gecho Bridge 会在需要时自动拉起本地服务，用来让 MCP 客户端和浏览器扩展通信。
 - 这个服务只监听 `127.0.0.1`，在你使用插件期间保持可用属于正常行为。
+- 也可以独立管理服务：`npm run server:start`、`npm run server:status`、`npm run server:stop`。
+- 如需用户登录后自动运行，可执行 `npx gecho-bridge-server install`；卸载启动项执行 `npx gecho-bridge-server uninstall`。
 - 如果你重启了 Chrome 或扩展，随后请求开始失败，先执行一次 `openclaw gateway restart`，再重试。
 
 ### 3. 报错：提示扩展未连接
@@ -334,6 +336,8 @@ npm run server
 - **Client 层** (`mcp-client.js`)：标准 MCP STDIO 接入层，负责与 OpenClaw/Hermes/Trae 等客户端通信，并声明 Tools 规范。
 - **Service 层** (`server.js`)：本地常驻服务层，负责与浏览器扩展通过 WebSocket 通信，执行实际抓取与落盘。（支持 Lazy Start 机制，仅在需要时自动拉起）。
 
+自动飞轮的定时任务接口、Bridge 独立运行和用户级开机启动说明见 [`docs/scheduled-flywheel-bridge.md`](docs/scheduled-flywheel-bridge.md)。
+
 ## License
 
 MIT

package/bridge-service.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const http = require("node:http");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+const packageJson = require("./package.json");
+const { getDefaultDataDir } = require("./data-dir");
+const {
+  getStartupStatus,
+  installStartup,
+  uninstallStartup
+} = require("./bridge-startup");
+
+const HTTP_PORT = Number(process.env.GECHO_HTTP_PORT || 18793);
+const SERVICE_BASE_URL = `http://127.0.0.1:${HTTP_PORT}`;
+const SERVICE_PATH = path.join(__dirname, "server.js");
+const SERVICE_PROTOCOL_VERSION = 2;
+const START_TIMEOUT_MS = Math.max(1000, Number(process.env.GECHO_SERVICE_START_TIMEOUT_MS || 10000));
+const POLL_INTERVAL_MS = 200;
+
+function requestJson(requestPath, method = "GET") {
+  return new Promise((resolve) => {
+    const request = http.request(`${SERVICE_BASE_URL}${requestPath}`, { method }, (response) => {
+      let body = "";
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => { body += chunk; });
+      response.on("end", () => {
+        let parsed = {};
+        try { parsed = JSON.parse(body || "{}"); } catch (_error) {}
+        resolve({
+          ok: response.statusCode >= 200 && response.statusCode < 300,
+          statusCode: response.statusCode || 0,
+          body: parsed
+        });
+      });
+    });
+    request.on("error", () => resolve({ ok: false, statusCode: 0, body: {} }));
+    request.setTimeout(800, () => {
+      request.destroy();
+      resolve({ ok: false, statusCode: 0, body: {} });
+    });
+    request.end();
+  });
+}
+
+function expectedDataDir() {
+  return path.resolve(process.env.GECHO_DATA_DIR || getDefaultDataDir());
+}
+
+function isCompatibleService(info) {
+  if (!info || info.status !== "ok") return false;
+  if (Number(info.serviceProtocolVersion || 0) !== SERVICE_PROTOCOL_VERSION) return false;
+  if (info.packageVersion && info.packageVersion !== packageJson.version) return false;
+  return !info.dataDir || path.resolve(String(info.dataDir)) === expectedDataDir();
+}
+
+async function getServiceInfo() {
+  const response = await requestJson("/ping");
+  return response.ok ? response.body : null;
+}
+
+async function waitForService({ running = true, timeoutMs = START_TIMEOUT_MS } = {}) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt <= timeoutMs) {
+    const info = await getServiceInfo();
+    if (running ? isCompatibleService(info) : !info) return info;
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return null;
+}
+
+async function stopService() {
+  const info = await getServiceInfo();
+  if (!info) return { status: "not running" };
+
+  await requestJson("/shutdown", "POST");
+  const stopped = await waitForService({ running: false });
+  if (stopped === null && Number.isInteger(Number(info.pid)) && Number(info.pid) > 0) {
+    try { process.kill(Number(info.pid), "SIGTERM"); } catch (_error) {}
+    await waitForService({ running: false, timeoutMs: 3000 });
+  }
+  return { status: "stopped", pid: info.pid || null };
+}
+
+async function startService() {
+  const current = await getServiceInfo();
+  if (isCompatibleService(current)) {
+    return { status: "already running", pid: current.pid || null };
+  }
+  if (current) await stopService();
+
+  const child = spawn(process.execPath, [SERVICE_PATH], {
+    cwd: __dirname,
+    env: process.env,
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  });
+  child.unref();
+  const started = await waitForService();
+  if (!started) {
+    const error = new Error("Bridge service did not become ready");
+    error.code = "BRIDGE_SERVICE_START_FAILED";
+    throw error;
+  }
+  return { status: "started", pid: started.pid || child.pid || null };
+}
+
+async function printStatus() {
+  const info = await getServiceInfo();
+  if (info) {
+    process.stdout.write(`${JSON.stringify(info)}\n`);
+    return true;
+  }
+  process.stdout.write(`${JSON.stringify({ status: "not running", url: SERVICE_BASE_URL })}\n`);
+  return false;
+}
+
+function printUsage() {
+  process.stdout.write([
+    "Usage: gecho-bridge-server <start|status|stop|restart|install|uninstall|startup-status>",
+    "",
+    "  start    Start the standalone local Bridge service",
+    "  status   Print Bridge health and scheduler status",
+    "  stop     Stop the local Bridge service",
+    "  restart  Restart the local Bridge service",
+    "  install  Install a user-level login startup entry",
+    "  uninstall Remove the user-level login startup entry",
+    "  startup-status  Print login startup configuration status",
+    ""
+  ].join("\n"));
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const command = String(argv[0] || "start").trim().toLowerCase();
+  if (command === "status") {
+    const running = await printStatus();
+    process.exitCode = running ? 0 : 1;
+    return;
+  }
+  if (command === "start") {
+    process.stdout.write(`${JSON.stringify(await startService())}\n`);
+    return;
+  }
+  if (command === "stop") {
+    process.stdout.write(`${JSON.stringify(await stopService())}\n`);
+    return;
+  }
+  if (command === "restart") {
+    await stopService();
+    process.stdout.write(`${JSON.stringify(await startService())}\n`);
+    return;
+  }
+  if (command === "install") {
+    process.stdout.write(`${JSON.stringify(installStartup())}\n`);
+    return;
+  }
+  if (command === "uninstall") {
+    process.stdout.write(`${JSON.stringify(uninstallStartup())}\n`);
+    return;
+  }
+  if (command === "startup-status") {
+    const status = getStartupStatus();
+    process.stdout.write(`${JSON.stringify(status)}\n`);
+    process.exitCode = status.configured ? 0 : 1;
+    return;
+  }
+  printUsage();
+  process.exitCode = 2;
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`gecho-bridge-server: ${error.message || error}`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  getServiceInfo,
+  isCompatibleService,
+  main,
+  startService,
+  stopService
+};

package/bridge-startup.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const DEFAULT_LABEL = "ai.gecho.bridge";
+const DEFAULT_UNIT_NAME = "gecho-bridge.service";
+const DEFAULT_TASK_NAME = "Gecho Bridge";
+
+function xmlEscape(value) {
+  return String(value ?? "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function systemdQuote(value) {
+  return `"${String(value ?? "")
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, "\\$")}`;
+}
+
+function windowsQuote(value) {
+  return `"${String(value ?? "").replace(/"/g, '\\"')}"`;
+}
+
+function normalizedPort(value, fallback) {
+  const port = Number(value || fallback);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
+}
+
+function defaultDataDirForPlatform(platform, homeDir) {
+  if (platform === "darwin") {
+    return path.join(homeDir, "Library", "Application Support", "Gecho", "Bridge");
+  }
+  if (platform === "win32") {
+    return path.join(process.env.LOCALAPPDATA || path.join(homeDir, "AppData", "Local"), "Gecho", "Bridge");
+  }
+  return path.join(process.env.XDG_STATE_HOME || path.join(homeDir, ".local", "state"), "gecho", "bridge");
+}
+
+function resolveOptions(options = {}) {
+  const platform = options.platform || process.platform;
+  const homeDir = path.resolve(options.homeDir || os.homedir());
+  const dataDir = path.resolve(options.dataDir || process.env.GECHO_DATA_DIR || defaultDataDirForPlatform(platform, homeDir));
+  const servicePath = path.resolve(options.servicePath || path.join(__dirname, "server.js"));
+  return {
+    ...options,
+    platform,
+    homeDir,
+    nodePath: path.resolve(options.nodePath || process.execPath),
+    servicePath,
+    workingDirectory: path.resolve(options.workingDirectory || path.dirname(servicePath)),
+    dataDir,
+    httpPort: normalizedPort(options.httpPort || process.env.GECHO_HTTP_PORT, 18793),
+    wsPort: normalizedPort(options.wsPort || process.env.GECHO_WS_PORT, 18792),
+    websiteUrl: String(options.websiteUrl || process.env.GECHO_WEBSITE_URL || "https://gecho.ai/").trim(),
+    allowedOrigins: String(options.allowedOrigins ?? process.env.GECHO_SCHEDULED_ALLOWED_ORIGINS ?? "").trim(),
+    allowLocalhost: String(options.allowLocalhost ?? process.env.GECHO_SCHEDULED_ALLOW_LOCALHOST ?? "").trim(),
+    browser: String(options.browser || process.env.GECHO_BROWSER || "").trim(),
+    autoLaunchBrowser: String(options.autoLaunchBrowser ?? process.env.GECHO_AUTO_LAUNCH_BROWSER ?? "").trim(),
+    autoOpenOnboarding: String(options.autoOpenOnboarding ?? process.env.GECHO_AUTO_OPEN_ONBOARDING_ON_FIRST_START ?? "").trim(),
+    autoCloseBrowser: String(options.autoCloseBrowser ?? process.env.GECHO_AUTO_CLOSE_LAUNCHED_BROWSER ?? "").trim(),
+    label: String(options.label || DEFAULT_LABEL).trim(),
+    unitName: String(options.unitName || DEFAULT_UNIT_NAME).trim(),
+    taskName: String(options.taskName || DEFAULT_TASK_NAME).trim()
+  };
+}
+
+function buildStartupDescriptor(options = {}) {
+  const resolved = resolveOptions(options);
+  if (resolved.platform === "darwin") {
+    return {
+      kind: "launch_agent",
+      scope: "user",
+      label: resolved.label,
+      path: path.join(resolved.homeDir, "Library", "LaunchAgents", `${resolved.label}.plist`)
+    };
+  }
+  if (resolved.platform === "linux") {
+    return {
+      kind: "systemd_user",
+      scope: "user",
+      unitName: resolved.unitName,
+      path: path.join(resolved.homeDir, ".config", "systemd", "user", resolved.unitName)
+    };
+  }
+  if (resolved.platform === "win32") {
+    return {
+      kind: "windows_task",
+      scope: "user",
+      taskName: resolved.taskName
+    };
+  }
+  return { kind: "unsupported", scope: "user" };
+}
+
+function safeEnvironmentEntries(options = {}) {
+  const resolved = resolveOptions(options);
+  const entries = [
+    ["GECHO_DATA_DIR", resolved.dataDir],
+    ["GECHO_HTTP_PORT", String(resolved.httpPort)],
+    ["GECHO_WS_PORT", String(resolved.wsPort)],
+    ["GECHO_WEBSITE_URL", resolved.websiteUrl],
+    ["GECHO_SCHEDULED_ALLOWED_ORIGINS", resolved.allowedOrigins],
+    ["GECHO_SCHEDULED_ALLOW_LOCALHOST", resolved.allowLocalhost],
+    ["GECHO_BROWSER", resolved.browser],
+    ["GECHO_AUTO_LAUNCH_BROWSER", resolved.autoLaunchBrowser],
+    ["GECHO_AUTO_OPEN_ONBOARDING_ON_FIRST_START", resolved.autoOpenOnboarding],
+    ["GECHO_AUTO_CLOSE_LAUNCHED_BROWSER", resolved.autoCloseBrowser]
+  ];
+  return entries.filter(([, value]) => String(value || "").trim() !== "");
+}
+
+function createMacLaunchAgentPlist(options = {}) {
+  const resolved = resolveOptions({ ...options, platform: "darwin" });
+  const descriptor = buildStartupDescriptor(resolved);
+  if (descriptor.kind !== "launch_agent") {
+    throw new Error("macOS LaunchAgent configuration requires platform=darwin");
+  }
+  const programArguments = [resolved.nodePath, resolved.servicePath];
+  const environmentEntries = safeEnvironmentEntries(resolved);
+  const xmlArray = (values) => values.map((value) => `    <string>${xmlEscape(value)}</string>`).join("\n");
+  const xmlEnvironment = environmentEntries.length
+    ? `\n  <key>EnvironmentVariables</key>\n  <dict>\n${environmentEntries.map(([key, value]) => `    <key>${xmlEscape(key)}</key>\n    <string>${xmlEscape(value)}</string>`).join("\n")}\n  </dict>`
+    : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlEscape(resolved.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${xmlArray(programArguments)}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(resolved.workingDirectory)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>ThrottleInterval</key>
+  <integer>3</integer>${xmlEnvironment}
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(path.join(resolved.dataDir, "bridge-service.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(path.join(resolved.dataDir, "bridge-service.error.log"))}</string>
+</dict>
+</plist>
+`;
+}
+
+function createSystemdUserUnit(options = {}) {
+  const resolved = resolveOptions({ ...options, platform: "linux" });
+  const descriptor = buildStartupDescriptor(resolved);
+  if (descriptor.kind !== "systemd_user") {
+    throw new Error("systemd user configuration requires platform=linux");
+  }
+  const environmentLines = safeEnvironmentEntries(resolved)
+    .map(([key, value]) => `Environment=${systemdQuote(`${key}=${value}`)}`)
+    .join("\n");
+  return `[Unit]
+Description=Gecho Bridge local service
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${systemdQuote(resolved.nodePath)} ${systemdQuote(resolved.servicePath)}
+WorkingDirectory=${systemdQuote(resolved.workingDirectory)}
+${environmentLines}
+Restart=on-failure
+RestartSec=3
+StandardOutput=${systemdQuote(`append:${path.join(resolved.dataDir, "bridge-service.log")}`)}
+StandardError=${systemdQuote(`append:${path.join(resolved.dataDir, "bridge-service.error.log")}`)}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function createWindowsTaskArgs(options = {}) {
+  const resolved = resolveOptions({ ...options, platform: "win32" });
+  return [
+    "/Create",
+    "/TN",
+    resolved.taskName,
+    "/TR",
+    `${windowsQuote(resolved.nodePath)} ${windowsQuote(resolved.servicePath)}`,
+    "/SC",
+    "ONLOGON",
+    "/RL",
+    "LIMITED",
+    "/F"
+  ];
+}
+
+function writeStartupConfig(options = {}) {
+  const resolved = resolveOptions(options);
+  const descriptor = buildStartupDescriptor(resolved);
+  if (descriptor.kind === "unsupported") {
+    const error = new Error(`Unsupported platform: ${resolved.platform}`);
+    error.code = "STARTUP_PLATFORM_UNSUPPORTED";
+    throw error;
+  }
+  if (descriptor.kind === "windows_task") return descriptor;
+
+  fs.mkdirSync(path.dirname(descriptor.path), { recursive: true, mode: 0o700 });
+  fs.mkdirSync(resolved.dataDir, { recursive: true, mode: 0o700 });
+  const contents = descriptor.kind === "launch_agent"
+    ? createMacLaunchAgentPlist(resolved)
+    : createSystemdUserUnit(resolved);
+  fs.writeFileSync(descriptor.path, contents, { encoding: "utf8", mode: 0o600 });
+  fs.chmodSync(descriptor.path, 0o600);
+  return descriptor;
+}
+
+function runCommand(command, args, options = {}) {
+  const runner = options.runCommand || spawnSync;
+  const result = runner(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result?.error) throw result.error;
+  if (result?.status !== 0) {
+    const detail = String(result?.stderr || result?.stdout || "").trim();
+    const error = new Error(`${command} failed${detail ? `: ${detail}` : ""}`);
+    error.code = "STARTUP_COMMAND_FAILED";
+    error.status = result?.status;
+    throw error;
+  }
+  return result;
+}
+
+function runCommandBestEffort(command, args, options = {}) {
+  try {
+    return { ok: true, result: runCommand(command, args, options) };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+
+function currentGuiTarget() {
+  if (typeof process.getuid !== "function") {
+    const error = new Error("Current user id is unavailable");
+    error.code = "STARTUP_USER_ID_UNAVAILABLE";
+    throw error;
+  }
+  return `gui/${process.getuid()}`;
+}
+
+function installStartup(options = {}) {
+  const resolved = resolveOptions(options);
+  const descriptor = writeStartupConfig(resolved);
+  if (descriptor.kind === "launch_agent") {
+    const target = currentGuiTarget();
+    runCommandBestEffort("launchctl", ["bootout", target, descriptor.path], resolved);
+    runCommand("launchctl", ["bootstrap", target, descriptor.path], resolved);
+    return { status: "installed", descriptor, active: true };
+  }
+  if (descriptor.kind === "systemd_user") {
+    runCommand("systemctl", ["--user", "daemon-reload"], resolved);
+    runCommand("systemctl", ["--user", "enable", "--now", descriptor.unitName], resolved);
+    return { status: "installed", descriptor, active: true };
+  }
+  if (descriptor.kind === "windows_task") {
+    runCommand("schtasks.exe", createWindowsTaskArgs(resolved), resolved);
+    return { status: "installed", descriptor, active: true };
+  }
+  const error = new Error(`Unsupported platform: ${resolved.platform}`);
+  error.code = "STARTUP_PLATFORM_UNSUPPORTED";
+  throw error;
+}
+
+function uninstallStartup(options = {}) {
+  const resolved = resolveOptions(options);
+  const descriptor = buildStartupDescriptor(resolved);
+  if (descriptor.kind === "launch_agent") {
+    runCommandBestEffort("launchctl", ["bootout", currentGuiTarget(), descriptor.path], resolved);
+    fs.rmSync(descriptor.path, { force: true });
+    return { status: "uninstalled", descriptor, active: false };
+  }
+  if (descriptor.kind === "systemd_user") {
+    runCommandBestEffort("systemctl", ["--user", "disable", "--now", descriptor.unitName], resolved);
+    fs.rmSync(descriptor.path, { force: true });
+    runCommandBestEffort("systemctl", ["--user", "daemon-reload"], resolved);
+    return { status: "uninstalled", descriptor, active: false };
+  }
+  if (descriptor.kind === "windows_task") {
+    runCommandBestEffort("schtasks.exe", ["/Delete", "/TN", descriptor.taskName, "/F"], resolved);
+    return { status: "uninstalled", descriptor, active: false };
+  }
+  const error = new Error(`Unsupported platform: ${resolved.platform}`);
+  error.code = "STARTUP_PLATFORM_UNSUPPORTED";
+  throw error;
+}
+
+function getStartupStatus(options = {}) {
+  const resolved = resolveOptions(options);
+  const descriptor = buildStartupDescriptor(resolved);
+  if (descriptor.kind === "unsupported") return { status: "unsupported", descriptor, configured: false, active: false };
+
+  if (descriptor.kind === "launch_agent") {
+    const configured = fs.existsSync(descriptor.path);
+    const active = configured && runCommandBestEffort("launchctl", ["print", `${currentGuiTarget()}/${descriptor.label}`], resolved).ok;
+    return { status: configured ? "configured" : "not configured", descriptor, configured, active };
+  }
+  if (descriptor.kind === "systemd_user") {
+    const configured = fs.existsSync(descriptor.path);
+    const enabled = runCommandBestEffort("systemctl", ["--user", "is-enabled", descriptor.unitName], resolved).ok;
+    const active = runCommandBestEffort("systemctl", ["--user", "is-active", descriptor.unitName], resolved).ok;
+    return { status: configured ? "configured" : "not configured", descriptor, configured, enabled, active };
+  }
+  const queried = runCommandBestEffort("schtasks.exe", ["/Query", "/TN", descriptor.taskName], resolved);
+  return { status: queried.ok ? "configured" : "not configured", descriptor, configured: queried.ok, active: queried.ok };
+}
+
+module.exports = {
+  buildStartupDescriptor,
+  createMacLaunchAgentPlist,
+  createSystemdUserUnit,
+  createWindowsTaskArgs,
+  getStartupStatus,
+  installStartup,
+  uninstallStartup,
+  writeStartupConfig
+};