@chrysb/alphaclaw 0.5.5 → 0.5.7-beta.0

package/lib/server/constants.js

@@ -20,7 +20,6 @@ const GATEWAY_TOKEN = process.env.OPENCLAW_GATEWAY_TOKEN || "";
 const ENV_FILE_PATH = path.join(kRootDir, ".env");
 const WORKSPACE_DIR = path.join(OPENCLAW_DIR, "workspace");
 const kOnboardingMarkerPath = path.join(ALPHACLAW_DIR, "onboarded.json");
-const kControlUiSkillPath = path.join(OPENCLAW_DIR, "skills", "control-ui", "SKILL.md");
 const AUTH_PROFILES_PATH = path.join(
   OPENCLAW_DIR,
   "agents",
@@ -364,6 +363,8 @@ const SETUP_API_PREFIXES = [
   "/api/gmail",
   "/api/watchdog",
   "/api/usage",
+  "/api/agents",
+  "/api/channels",
 ];
 
 module.exports = {
@@ -381,7 +382,6 @@ module.exports = {
   ENV_FILE_PATH,
   WORKSPACE_DIR,
   kOnboardingMarkerPath,
-  kControlUiSkillPath,
   AUTH_PROFILES_PATH,
   CODEX_PROFILE_ID,
   CODEX_OAUTH_CLIENT_ID,

package/lib/server/env.js

@@ -64,7 +64,9 @@ const reloadEnv = () => {
 const startEnvWatcher = () => {
   try {
     fs.watchFile(ENV_FILE_PATH, { interval: 2000 }, () => {
-      console.log(`[alphaclaw] ${ENV_FILE_PATH} changed externally, reloading...`);
+      console.log(
+        `[alphaclaw] ${ENV_FILE_PATH} changed externally, reloading...`,
+      );
       reloadEnv();
     });
   } catch {}

package/lib/server/gateway.js

@@ -7,7 +7,6 @@ const {
   OPENCLAW_DIR,
   GATEWAY_HOST,
   kDefaultGatewayPort,
-  kControlUiSkillPath,
   kChannelDefs,
   kOnboardingMarkerPath,
   kRootDir,
@@ -65,9 +64,13 @@ const writeOnboardingMarker = (reason) => {
   );
 };
 
+// Legacy backfill: older deployments may only have the control-ui skill as
+// proof of onboarding (before the dedicated marker file existed).
+const kLegacyControlUiSkillPath = path.join(OPENCLAW_DIR, "skills", "control-ui", "SKILL.md");
+
 const isOnboarded = () => {
   if (fs.existsSync(kOnboardingMarkerPath)) return true;
-  if (fs.existsSync(kControlUiSkillPath)) {
+  if (fs.existsSync(kLegacyControlUiSkillPath)) {
     writeOnboardingMarker("legacy_artifact_backfill");
     return true;
   }
@@ -88,6 +91,18 @@ const getGatewayPort = () => {
 
 const getGatewayUrl = () => `http://${GATEWAY_HOST}:${getGatewayPort()}`;
 
+const normalizeChannelAccountId = (value) => String(value || "").trim() || "default";
+
+const resolveCredentialPairingAccountId = ({ channel, fileName }) => {
+  const prefix = `${String(channel || "").trim()}-`;
+  const suffix = "-allowFrom.json";
+  if (!String(fileName || "").startsWith(prefix) || !String(fileName || "").endsWith(suffix)) {
+    return "";
+  }
+  const rawAccountId = String(fileName || "").slice(prefix.length, -suffix.length);
+  return normalizeChannelAccountId(rawAccountId);
+};
+
 const isGatewayRunning = () =>
   new Promise((resolve) => {
     const sock = net.createConnection(getGatewayPort(), GATEWAY_HOST);
@@ -136,17 +151,26 @@ const launchGatewayProcess = () => {
     stdio: ["pipe", "pipe", "pipe"],
   });
   gatewayChild = child;
-  if (gatewayLaunchHandler) {
-    try {
-      gatewayLaunchHandler({
-        pid: child.pid,
-        startedAt: Date.now(),
-      });
-    } catch (err) {
-      console.error(`[alphaclaw] Gateway launch handler error: ${err.message}`);
+  let didSignalGatewayReady = false;
+  child.stdout.on("data", (d) => {
+    const text = Buffer.isBuffer(d) ? d.toString("utf8") : String(d ?? "");
+    if (
+      !didSignalGatewayReady &&
+      gatewayLaunchHandler &&
+      text.toLowerCase().includes("listening on")
+    ) {
+      didSignalGatewayReady = true;
+      try {
+        gatewayLaunchHandler({
+          pid: child.pid,
+          startedAt: Date.now(),
+        });
+      } catch (err) {
+        console.error(`[alphaclaw] Gateway launch handler error: ${err.message}`);
+      }
     }
-  }
-  child.stdout.on("data", (d) => process.stdout.write(`[gateway] ${d}`));
+    process.stdout.write(`[gateway] ${d}`);
+  });
   child.stderr.on("data", (d) => {
     appendStderrTail(d);
     process.stderr.write(`[gateway] ${d}`);
@@ -206,6 +230,12 @@ const restartGateway = (reloadEnv) => {
   runGatewayCmd("--force");
 };
 
+const restartGatewayLight = (reloadEnv) => {
+  reloadEnv();
+  markManagedGatewayExitExpected();
+  runGatewayCmd("restart");
+};
+
 const attachGatewaySignalHandlers = () => {
   process.on("SIGTERM", () => {
     runGatewayCmd("stop");
@@ -324,10 +354,36 @@ const getChannelStatus = () => {
     const channels = {};
 
     for (const ch of ["telegram", "discord"]) {
-      if (!config.channels?.[ch]?.enabled) continue;
-      if (!process.env[kChannelDefs[ch].envKey]) continue;
+      const channelConfig =
+        config.channels?.[ch] && typeof config.channels[ch] === "object"
+          ? config.channels[ch]
+          : null;
+      if (!channelConfig?.enabled) continue;
 
-      let paired = 0;
+      const rawAccounts =
+        channelConfig.accounts && typeof channelConfig.accounts === "object"
+          ? channelConfig.accounts
+          : {};
+      const accountEntries = Object.keys(rawAccounts).length > 0
+        ? Object.entries(rawAccounts)
+        : [["default", channelConfig]];
+      const configuredAccountIds = new Set(
+        accountEntries.map(([accountId]) => normalizeChannelAccountId(accountId)),
+      );
+      const hasConfiguredToken = accountEntries.some(([accountId, accountConfig]) => {
+        const normalizedAccountId = normalizeChannelAccountId(accountId);
+        const envKey = normalizedAccountId === "default"
+          ? kChannelDefs[ch].envKey
+          : `${kChannelDefs[ch].envKey}_${normalizedAccountId.replace(/-/g, "_").toUpperCase()}`;
+        return !!process.env[envKey]
+          || !!accountConfig?.botToken
+          || !!accountConfig?.token;
+      });
+      if (!hasConfiguredToken) continue;
+
+      const pairedByAccount = new Map(
+        Array.from(configuredAccountIds).map((accountId) => [accountId, 0]),
+      );
       try {
         const files = fs
           .readdirSync(credDir)
@@ -335,16 +391,43 @@ const getChannelStatus = () => {
             (f) => f.startsWith(`${ch}-`) && f.endsWith("-allowFrom.json"),
           );
         for (const file of files) {
+          const accountId = resolveCredentialPairingAccountId({
+            channel: ch,
+            fileName: file,
+          });
+          if (!accountId || !configuredAccountIds.has(accountId)) continue;
           const data = JSON.parse(
             fs.readFileSync(`${credDir}/${file}`, "utf8"),
           );
-          paired += (data.allowFrom || []).length;
+          const nextCount =
+            Number(pairedByAccount.get(accountId) || 0)
+            + (Array.isArray(data.allowFrom) ? data.allowFrom.length : 0);
+          pairedByAccount.set(accountId, nextCount);
         }
       } catch {}
-      const inlineAllowFrom = config.channels[ch]?.allowFrom;
-      if (Array.isArray(inlineAllowFrom)) paired += inlineAllowFrom.length;
-
-      channels[ch] = { status: paired > 0 ? "paired" : "configured", paired };
+      for (const [accountId, accountConfig] of accountEntries) {
+        const inlineAllowFrom = accountConfig?.allowFrom;
+        if (!Array.isArray(inlineAllowFrom)) continue;
+        const normalizedAccountId = normalizeChannelAccountId(accountId);
+        const nextCount =
+          Number(pairedByAccount.get(normalizedAccountId) || 0) + inlineAllowFrom.length;
+        pairedByAccount.set(normalizedAccountId, nextCount);
+      }
+      const accounts = Object.fromEntries(
+        Array.from(pairedByAccount.entries()).map(([accountId, paired]) => [
+          accountId,
+          { status: paired > 0 ? "paired" : "configured", paired },
+        ]),
+      );
+      const paired = Array.from(pairedByAccount.values()).reduce(
+        (total, count) => total + Number(count || 0),
+        0,
+      );
+      channels[ch] = {
+        status: paired > 0 ? "paired" : "configured",
+        paired,
+        accounts,
+      };
     }
 
     return channels;
@@ -365,6 +448,7 @@ module.exports = {
   runGatewayCmd,
   startGateway,
   restartGateway,
+  restartGatewayLight,
   attachGatewaySignalHandlers,
   ensureGatewayProxyConfig,
   syncChannelConfig,

package/lib/server/gmail-serve.js

@@ -124,18 +124,8 @@ const createGmailServeManager = ({
       stdio: ["ignore", "pipe", "pipe"],
     });
 
-    child.stdout.on("data", (chunk) => {
-      const line = String(chunk || "").trim();
-      if (line) {
-        console.log(`[alphaclaw] gmail watch serve (${email}): ${line}`);
-      }
-    });
-    child.stderr.on("data", (chunk) => {
-      const line = String(chunk || "").trim();
-      if (line) {
-        console.log(`[alphaclaw] gmail watch serve stderr (${email}): ${line}`);
-      }
-    });
+    child.stdout.on("data", () => {});
+    child.stderr.on("data", () => {});
 
     const nextEntry = {
       accountId,

package/lib/server/gmail-watch.js

@@ -16,6 +16,7 @@ const {
 const { createGmailServeManager } = require("./gmail-serve");
 const { parseJsonObjectFromNoisyOutput, parseJsonSafe } = require("./utils/json");
 const { createWebhook } = require("./webhooks");
+const { readOpenclawConfig } = require("./openclaw-config");
 const { quoteShellArg } = require("./utils/shell");
 
 const parseExpirationFromOutput = (raw) => {
@@ -65,11 +66,16 @@ const normalizeDestination = (destination = null) => {
   if (!destination || typeof destination !== "object") return null;
   const channel = String(destination?.channel || "").trim();
   const to = String(destination?.to || "").trim();
-  if (!channel && !to) return null;
+  const agentId = String(destination?.agentId || "").trim();
+  if (!channel && !to && !agentId) return null;
   if (!channel || !to) {
     throw new Error("destination.channel and destination.to are required");
   }
-  return { channel, to };
+  return {
+    channel,
+    to,
+    ...(agentId ? { agentId } : {}),
+  };
 };
 
 const buildGmailTransformSource = (destination = null) => {
@@ -91,6 +97,9 @@ const buildGmailTransformSource = (destination = null) => {
       ? [
           `    channel: ${JSON.stringify(normalizedDestination.channel)},`,
           `    to: ${JSON.stringify(normalizedDestination.to)},`,
+          ...(normalizedDestination.agentId
+            ? [`    agentId: ${JSON.stringify(normalizedDestination.agentId)},`]
+            : []),
         ]
       : []),
     "  };",
@@ -99,6 +108,18 @@ const buildGmailTransformSource = (destination = null) => {
   ].join("\n");
 };
 
+const hasGmailWebhookMapping = ({ fs, openclawDir }) => {
+  const cfg = readOpenclawConfig({
+    fsModule: fs,
+    openclawDir,
+    fallback: {},
+  });
+  const mappings = Array.isArray(cfg?.hooks?.mappings) ? cfg.hooks.mappings : [];
+  return mappings.some(
+    (mapping) => String(mapping?.match?.path || "").trim().toLowerCase() === "gmail",
+  );
+};
+
 const getGmailTransformAbsolutePath = (constants) =>
   path.join(constants.OPENCLAW_DIR, "hooks/transforms/gmail/gmail-transform.mjs");
 
@@ -295,6 +316,7 @@ const createGmailWatchService = ({
         transform: { module: gmailTransformModulePath },
       },
       transformSource: buildGmailTransformSource(destination),
+      overwriteTransform: true,
     });
     const webhookAfter = fs.readFileSync(configPath, "utf8");
     if (webhookBefore !== webhookAfter) {
@@ -367,6 +389,10 @@ const createGmailWatchService = ({
       String(push.token || ""),
     )}`;
     const transformExists = fs.existsSync(getGmailTransformAbsolutePath(constants));
+    const webhookExists = hasGmailWebhookMapping({
+      fs,
+      openclawDir: constants.OPENCLAW_DIR,
+    });
     const commands =
       projectId && push.token
         ? {
@@ -385,6 +411,7 @@ const createGmailWatchService = ({
       pushEndpoint,
       commands,
       transformExists,
+      webhookExists,
       configured: Boolean(topicPath && push.token && projectId),
     };
   };

package/lib/server/onboarding/import/import-applier.js

@@ -22,7 +22,6 @@ const kReplaceableBootstrapPaths = [
   ".alphaclaw",
   "gogcli",
   path.join("workspace", "hooks", "bootstrap"),
-  path.join("skills", "control-ui"),
   path.join("skills", "gog-cli"),
 ];
 

package/lib/server/onboarding/index.js

@@ -17,7 +17,6 @@ const {
 } = require("./openclaw");
 const {
   ensureOpenclawRuntimeArtifacts,
-  installControlUiSkill,
   syncBootstrapPromptFiles,
 } = require("./workspace");
 const {
@@ -498,11 +497,6 @@ const createOnboardingService = ({
     authProfiles?.syncConfigAuthReferencesForAgent?.();
     ensureGatewayProxyConfig(getBaseUrl(req));
 
-    installControlUiSkill({
-      fs,
-      openclawDir: OPENCLAW_DIR,
-      baseUrl: getBaseUrl(req),
-    });
     installGogCliSkill({ fs, openclawDir: OPENCLAW_DIR });
 
     installHourlyGitSyncScript({ fs, openclawDir: OPENCLAW_DIR });

package/lib/server/onboarding/workspace.js

@@ -32,7 +32,17 @@ const isTelegramWorkspaceEnabled = (fs) => {
   try {
     const configPath = `${OPENCLAW_DIR}/openclaw.json`;
     const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
-    return Object.keys(cfg.channels?.telegram?.groups || {}).length > 0;
+    const telegramConfig = cfg.channels?.telegram || {};
+    const topLevelGroupCount = Object.keys(telegramConfig.groups || {}).length;
+    if (topLevelGroupCount > 0) return true;
+    const accounts =
+      telegramConfig.accounts && typeof telegramConfig.accounts === "object"
+        ? telegramConfig.accounts
+        : {};
+    for (const accountConfig of Object.values(accounts)) {
+      if (Object.keys(accountConfig?.groups || {}).length > 0) return true;
+    }
+    return false;
   } catch {
     return false;
   }
@@ -73,59 +83,85 @@ const renderGoogleAccountsMarkdown = (fs) => {
   }
 };
 
+const resolveAllAgentWorkspaces = (fs) => {
+  try {
+    const configPath = path.join(OPENCLAW_DIR, "openclaw.json");
+    const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    const list = Array.isArray(cfg.agents?.list) ? cfg.agents.list : [];
+    return list
+      .map((entry) => {
+        const agentId = String(entry.id || "").trim();
+        const workspace = String(entry.workspace || "").trim();
+        if (!agentId || !workspace) return null;
+        return {
+          agentId,
+          workspace,
+        };
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+};
+
 const syncBootstrapPromptFiles = ({ fs, workspaceDir, baseUrl }) => {
   try {
     const setupUiUrl = resolveSetupUiUrl(baseUrl);
-    const bootstrapDir = path.join(workspaceDir, "hooks", "bootstrap");
-    fs.mkdirSync(bootstrapDir, { recursive: true });
-
-    // AlphaClaw-managed files are always overwritten (even during import)
-    fs.copyFileSync(
-      path.join(kSetupDir, "core-prompts", "AGENTS.md"),
-      path.join(bootstrapDir, "AGENTS.md"),
-    );
 
     const toolsTemplate = fs.readFileSync(
       path.join(kSetupDir, "core-prompts", "TOOLS.md"),
       "utf8",
     );
-    let toolsContent = toolsTemplate.replace(
-      /\{\{SETUP_UI_URL\}\}/g,
-      setupUiUrl,
-    );
-
-    const topicSection = renderTopicRegistryMarkdown({
-      includeSyncGuidance: isTelegramWorkspaceEnabled(fs),
-    });
-    if (topicSection) {
-      toolsContent += topicSection;
-    }
+    const includeSyncGuidance = isTelegramWorkspaceEnabled(fs);
     const googleAccountsSection = renderGoogleAccountsMarkdown(fs);
-    if (googleAccountsSection) {
-      toolsContent += googleAccountsSection;
+    const buildToolsContent = ({ agentId = "" } = {}) => {
+      let toolsContent = toolsTemplate.replace(/\{\{SETUP_UI_URL\}\}/g, setupUiUrl);
+      const topicSection = renderTopicRegistryMarkdown({
+        includeSyncGuidance,
+        agentId,
+      });
+      if (topicSection) {
+        toolsContent += topicSection;
+      }
+      if (googleAccountsSection) {
+        toolsContent += googleAccountsSection;
+      }
+      return toolsContent;
+    };
+
+    const agentsSourcePath = path.join(kSetupDir, "core-prompts", "AGENTS.md");
+
+    const writeToWorkspace = (targetDir, toolsContent) => {
+      const bootstrapDir = path.join(targetDir, "hooks", "bootstrap");
+      fs.mkdirSync(bootstrapDir, { recursive: true });
+      fs.copyFileSync(agentsSourcePath, path.join(bootstrapDir, "AGENTS.md"));
+      fs.writeFileSync(path.join(bootstrapDir, "TOOLS.md"), toolsContent);
+    };
+
+    writeToWorkspace(workspaceDir, buildToolsContent());
+
+    const otherWorkspaces = resolveAllAgentWorkspaces(fs).filter(
+      (entry) => path.resolve(entry.workspace) !== path.resolve(workspaceDir),
+    );
+    for (const entry of otherWorkspaces) {
+      try {
+        writeToWorkspace(
+          entry.workspace,
+          buildToolsContent({ agentId: entry.agentId }),
+        );
+      } catch (e) {
+        console.error(
+          `[onboard] Bootstrap sync skipped for ${entry.workspace}: ${e.message}`,
+        );
+      }
     }
 
-    fs.writeFileSync(path.join(bootstrapDir, "TOOLS.md"), toolsContent);
     console.log("[onboard] Bootstrap prompt files synced");
   } catch (e) {
     console.error("[onboard] Bootstrap prompt sync error:", e.message);
   }
 };
 
-const installControlUiSkill = ({ fs, openclawDir, baseUrl }) => {
-  try {
-    const setupUiUrl = resolveSetupUiUrl(baseUrl);
-    const skillDir = `${openclawDir}/skills/control-ui`;
-    fs.mkdirSync(skillDir, { recursive: true });
-    const skillTemplate = fs.readFileSync(path.join(kSetupDir, "skills", "control-ui", "SKILL.md"), "utf8");
-    const skillContent = skillTemplate.replace(/\{\{BASE_URL\}\}/g, setupUiUrl);
-    fs.writeFileSync(`${skillDir}/SKILL.md`, skillContent);
-    console.log(`[onboard] Control UI skill installed (${setupUiUrl})`);
-  } catch (e) {
-    console.error("[onboard] Skill install error:", e.message);
-  }
-};
-
 const ensureOpenclawRuntimeArtifacts = ({
   fs,
   openclawDir,
@@ -153,6 +189,6 @@ const ensureOpenclawRuntimeArtifacts = ({
 
 module.exports = {
   ensureOpenclawRuntimeArtifacts,
-  installControlUiSkill,
+  resolveSetupUiUrl,
   syncBootstrapPromptFiles,
 };

package/lib/server/openclaw-config.js

@@ -0,0 +1,23 @@
+const fs = require("fs");
+const path = require("path");
+
+const resolveOpenclawConfigPath = ({ openclawDir }) =>
+  path.join(openclawDir, "openclaw.json");
+
+const readOpenclawConfig = ({
+  fsModule = fs,
+  openclawDir,
+  fallback = {},
+} = {}) => {
+  const configPath = resolveOpenclawConfigPath({ openclawDir });
+  try {
+    return JSON.parse(fsModule.readFileSync(configPath, "utf8"));
+  } catch {
+    return fallback;
+  }
+};
+
+module.exports = {
+  resolveOpenclawConfigPath,
+  readOpenclawConfig,
+};

package/lib/server/operation-events.js

@@ -0,0 +1,141 @@
+const crypto = require("crypto");
+
+const kDefaultTtlMs = 5 * 60 * 1000;
+const kMaxEventsPerOperation = 200;
+
+const formatSseEvent = ({ id, event, data }) => {
+  const lines = [];
+  if (id) lines.push(`id: ${id}`);
+  if (event) lines.push(`event: ${event}`);
+  const payload = JSON.stringify(data === undefined ? {} : data);
+  for (const line of payload.split("\n")) {
+    lines.push(`data: ${line}`);
+  }
+  return `${lines.join("\n")}\n\n`;
+};
+
+const createOperationEventsService = ({ ttlMs = kDefaultTtlMs } = {}) => {
+  const operations = new Map();
+  let sweepTimer = null;
+
+  const ensureSweeper = () => {
+    if (sweepTimer) return;
+    sweepTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [operationId, state] of operations.entries()) {
+        if (state.expiresAt <= now && state.subscribers.size === 0) {
+          operations.delete(operationId);
+        }
+      }
+    }, 30_000);
+    sweepTimer.unref();
+  };
+
+  const getOperation = (operationId) => {
+    const normalized = String(operationId || "").trim();
+    if (!normalized) return null;
+    return operations.get(normalized) || null;
+  };
+
+  const createOperation = ({ type = "operation" } = {}) => {
+    const operationId = crypto.randomUUID();
+    operations.set(operationId, {
+      id: operationId,
+      type: String(type || "operation").trim() || "operation",
+      createdAt: Date.now(),
+      expiresAt: Date.now() + ttlMs,
+      status: "pending",
+      nextEventId: 1,
+      events: [],
+      subscribers: new Set(),
+    });
+    ensureSweeper();
+    return { operationId };
+  };
+
+  const publish = (operationId, { event = "message", data = {} } = {}) => {
+    const state = getOperation(operationId);
+    if (!state) return false;
+    const entry = {
+      id: String(state.nextEventId++),
+      event: String(event || "message").trim() || "message",
+      data: data === undefined ? {} : data,
+      ts: Date.now(),
+    };
+    state.events.push(entry);
+    if (state.events.length > kMaxEventsPerOperation) {
+      state.events = state.events.slice(-kMaxEventsPerOperation);
+    }
+    for (const res of state.subscribers) {
+      try {
+        res.write(formatSseEvent(entry));
+      } catch {}
+    }
+    return true;
+  };
+
+  const complete = (operationId, payload = {}) => {
+    const state = getOperation(operationId);
+    if (!state) return false;
+    state.status = "completed";
+    state.expiresAt = Date.now() + ttlMs;
+    publish(operationId, {
+      event: "done",
+      data: payload,
+    });
+    return true;
+  };
+
+  const fail = (operationId, error) => {
+    const state = getOperation(operationId);
+    if (!state) return false;
+    state.status = "failed";
+    state.expiresAt = Date.now() + ttlMs;
+    publish(operationId, {
+      event: "error",
+      data: {
+        error: String(error?.message || error || "Operation failed"),
+      },
+    });
+    return true;
+  };
+
+  const subscribe = ({ operationId, req, res }) => {
+    const state = getOperation(operationId);
+    if (!state) {
+      return false;
+    }
+    res.status(200);
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders?.();
+    res.write(": connected\n\n");
+    for (const event of state.events) {
+      res.write(formatSseEvent(event));
+    }
+    state.subscribers.add(res);
+    const close = () => {
+      state.subscribers.delete(res);
+      if (state.expiresAt <= Date.now() && state.subscribers.size === 0) {
+        operations.delete(state.id);
+      }
+    };
+    req.on("close", close);
+    return true;
+  };
+
+  return {
+    createOperation,
+    publish,
+    complete,
+    fail,
+    subscribe,
+    getOperation,
+  };
+};
+
+module.exports = {
+  createOperationEventsService,
+};