omoclaw 2.4.0 → 3.0.0

package/dist/index.js

@@ -1,8 +1,8 @@
 // @bun
 // src/index.ts
-import fs3 from "fs";
-import os2 from "os";
-import path2 from "path";
+import fs5 from "fs";
+import os3 from "os";
+import path4 from "path";
 
 // src/config.ts
 import fs from "fs";
@@ -238,6 +238,344 @@ function handleSessionStatusEvent(event, dedup, state, timers, webhookFn, debugL
   }
 }
 
+// src/project-config.ts
+import fs2 from "fs";
+import path2 from "path";
+var PROJECT_CONFIG_FILE = ".omoclaw.local.json";
+function asObject2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  return value;
+}
+function asString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function parseSessionKey(sessionKey) {
+  const parts = sessionKey.split(":");
+  if (parts.length < 5 || parts[0] !== "agent") {
+    return { agentId: "", channelId: "" };
+  }
+  return {
+    agentId: parts[1] ?? "",
+    channelId: parts.slice(4).join(":")
+  };
+}
+function buildSessionKeyFromConfig(config) {
+  const webhook = config.webhook;
+  if (!webhook.channel) {
+    return "";
+  }
+  return `agent:${webhook.agentId}:${webhook.channelType}:${webhook.chatType}:${webhook.channel}`;
+}
+function loadProjectConfig(cwd = process.cwd()) {
+  const filePath = path2.join(cwd, PROJECT_CONFIG_FILE);
+  try {
+    const stats = fs2.statSync(filePath);
+    const mode = stats.mode & 511;
+    if (mode !== 384) {
+      try {
+        fs2.chmodSync(filePath, 384);
+      } catch {}
+    }
+    const raw = fs2.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const root = asObject2(parsed);
+    if (!root) {
+      return { sessionKey: "", tmuxSession: "" };
+    }
+    return {
+      sessionKey: asString(root.sessionKey),
+      tmuxSession: asString(root.tmuxSession)
+    };
+  } catch {
+    return { sessionKey: "", tmuxSession: "" };
+  }
+}
+function resolveSessionRouting(config, projectConfig) {
+  const envSessionKey = asString(process.env.OPENCLAW_SESSION_KEY);
+  if (envSessionKey) {
+    const parsed = parseSessionKey(envSessionKey);
+    return {
+      sessionKey: envSessionKey,
+      source: "env",
+      agentId: parsed.agentId || config.webhook.agentId,
+      channelId: parsed.channelId || config.webhook.channel
+    };
+  }
+  if (projectConfig.sessionKey) {
+    const parsed = parseSessionKey(projectConfig.sessionKey);
+    return {
+      sessionKey: projectConfig.sessionKey,
+      source: "project",
+      agentId: parsed.agentId || config.webhook.agentId,
+      channelId: parsed.channelId || config.webhook.channel
+    };
+  }
+  if (config.webhook.sessionKey) {
+    const parsed = parseSessionKey(config.webhook.sessionKey);
+    return {
+      sessionKey: config.webhook.sessionKey,
+      source: "config",
+      agentId: parsed.agentId || config.webhook.agentId,
+      channelId: parsed.channelId || config.webhook.channel
+    };
+  }
+  const derivedSessionKey = buildSessionKeyFromConfig(config);
+  if (derivedSessionKey) {
+    return {
+      sessionKey: derivedSessionKey,
+      source: "derived",
+      agentId: config.webhook.agentId,
+      channelId: config.webhook.channel
+    };
+  }
+  return {
+    sessionKey: "",
+    source: "none",
+    agentId: config.webhook.agentId,
+    channelId: config.webhook.channel
+  };
+}
+
+// src/registry.ts
+import { createHash, randomUUID } from "crypto";
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+var REGISTRY_VERSION = 1;
+var DEFAULT_TTL_MS = 60000;
+var DEFAULT_HEARTBEAT_MS = 20000;
+var REGISTRY_DIR_PATH = path3.join(os2.homedir(), ".local", "state", "omoclaw");
+var REGISTRY_FILE_PATH = path3.join(REGISTRY_DIR_PATH, "registry.json");
+function asObject3(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  return value;
+}
+function asString2(value) {
+  return typeof value === "string" ? value : "";
+}
+function errorToString(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+function parseRegistryEntry(value) {
+  const entry = asObject3(value);
+  if (!entry) {
+    return;
+  }
+  const pid = typeof entry.pid === "number" ? entry.pid : Number.NaN;
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return;
+  }
+  const parsed = {
+    instanceId: asString2(entry.instanceId),
+    hostname: asString2(entry.hostname),
+    hostLabel: asString2(entry.hostLabel),
+    pid,
+    startedAt: asString2(entry.startedAt),
+    leaseExpiresAt: asString2(entry.leaseExpiresAt),
+    project: asString2(entry.project),
+    projectId: asString2(entry.projectId),
+    workspaceRoot: asString2(entry.workspaceRoot),
+    tmuxSession: asString2(entry.tmuxSession),
+    openclawSessionKey: asString2(entry.openclawSessionKey),
+    agentId: asString2(entry.agentId),
+    channelId: asString2(entry.channelId)
+  };
+  if (!parsed.instanceId || !parsed.hostname || !parsed.hostLabel || !parsed.startedAt || !parsed.leaseExpiresAt || !parsed.project || !parsed.projectId || !parsed.workspaceRoot) {
+    return;
+  }
+  return parsed;
+}
+
+class Registry {
+  instanceId = randomUUID();
+  hostname = os2.hostname();
+  workspaceRoot;
+  project;
+  projectId;
+  ttlMs;
+  heartbeatMs;
+  debugLog;
+  heartbeatTimer;
+  hooksInstalled = false;
+  entryTemplate;
+  stopOnProcessExit = () => {
+    this.stop();
+  };
+  constructor(options = {}) {
+    this.workspaceRoot = options.workspaceRoot ?? process.cwd();
+    this.project = path3.basename(this.workspaceRoot);
+    this.projectId = createHash("sha256").update(this.workspaceRoot).digest("hex");
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+    this.debugLog = options.debugLog;
+  }
+  start(input) {
+    const startedAt = new Date().toISOString();
+    this.entryTemplate = {
+      instanceId: this.instanceId,
+      hostname: this.hostname,
+      hostLabel: input.hostLabel,
+      pid: process.pid,
+      startedAt,
+      project: this.project,
+      projectId: this.projectId,
+      workspaceRoot: this.workspaceRoot,
+      tmuxSession: input.tmuxSession,
+      openclawSessionKey: input.openclawSessionKey,
+      agentId: input.agentId,
+      channelId: input.channelId
+    };
+    this.upsert();
+    this.installProcessHooks();
+    this.startHeartbeat();
+  }
+  stop() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = undefined;
+    }
+    this.remove();
+  }
+  readSessions() {
+    const registry = this.readAndGc();
+    return registry.sessions;
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setInterval(() => {
+      this.upsert();
+    }, this.heartbeatMs);
+    this.heartbeatTimer.unref?.();
+  }
+  installProcessHooks() {
+    if (this.hooksInstalled) {
+      return;
+    }
+    this.hooksInstalled = true;
+    process.once("beforeExit", this.stopOnProcessExit);
+    process.once("exit", this.stopOnProcessExit);
+  }
+  upsert() {
+    if (!this.entryTemplate) {
+      return;
+    }
+    const leaseExpiresAt = new Date(Date.now() + this.ttlMs).toISOString();
+    const entry = {
+      ...this.entryTemplate,
+      leaseExpiresAt
+    };
+    this.updateSessions((sessions) => {
+      const existingIndex = sessions.findIndex((session) => session.instanceId === this.instanceId);
+      if (existingIndex === -1) {
+        return [...sessions, entry];
+      }
+      const next = [...sessions];
+      next[existingIndex] = entry;
+      return next;
+    });
+  }
+  remove() {
+    this.updateSessions((sessions) => {
+      return sessions.filter((session) => session.instanceId !== this.instanceId);
+    });
+  }
+  updateSessions(updater) {
+    try {
+      const current = this.readAndGc();
+      const updatedSessions = updater(current.sessions);
+      this.writeRegistryFile({
+        version: REGISTRY_VERSION,
+        sessions: updatedSessions
+      });
+    } catch (error) {
+      this.debugLog?.(`registry update failed: ${errorToString(error)}`);
+    }
+  }
+  readAndGc() {
+    const registry = this.readRegistryFile();
+    const now = Date.now();
+    const sessions = registry.sessions.filter((session) => {
+      const expiresAtMs = Date.parse(session.leaseExpiresAt);
+      if (!Number.isFinite(expiresAtMs) || expiresAtMs <= now) {
+        return false;
+      }
+      return this.isPidAlive(session.pid);
+    });
+    if (sessions.length !== registry.sessions.length) {
+      this.writeRegistryFile({
+        version: REGISTRY_VERSION,
+        sessions
+      });
+    }
+    return {
+      version: REGISTRY_VERSION,
+      sessions
+    };
+  }
+  readRegistryFile() {
+    this.ensureRegistryDir();
+    try {
+      const raw = fs3.readFileSync(REGISTRY_FILE_PATH, "utf8");
+      const parsed = JSON.parse(raw);
+      const root = asObject3(parsed);
+      const items = Array.isArray(root?.sessions) ? root.sessions : [];
+      const sessions = items.map((item) => parseRegistryEntry(item)).filter((item) => item !== undefined);
+      return {
+        version: REGISTRY_VERSION,
+        sessions
+      };
+    } catch {
+      return {
+        version: REGISTRY_VERSION,
+        sessions: []
+      };
+    }
+  }
+  writeRegistryFile(registry) {
+    this.ensureRegistryDir();
+    const payload = JSON.stringify({
+      version: REGISTRY_VERSION,
+      sessions: registry.sessions
+    }, null, 2);
+    const tmpPath = `${REGISTRY_FILE_PATH}.${process.pid}.${Date.now()}.tmp`;
+    fs3.writeFileSync(tmpPath, payload, { mode: 384 });
+    fs3.renameSync(tmpPath, REGISTRY_FILE_PATH);
+    try {
+      fs3.chmodSync(REGISTRY_FILE_PATH, 384);
+    } catch {}
+  }
+  ensureRegistryDir() {
+    fs3.mkdirSync(REGISTRY_DIR_PATH, { recursive: true, mode: 448 });
+    try {
+      fs3.chmodSync(REGISTRY_DIR_PATH, 448);
+    } catch {}
+  }
+  isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      return false;
+    }
+    if (pid === process.pid) {
+      return true;
+    }
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      const code = error.code;
+      return code === "EPERM";
+    }
+  }
+}
+
 // src/state.ts
 class SessionStateTracker {
   states = new Map;
@@ -403,26 +741,54 @@ class TimerManager {
 }
 
 // src/webhook.ts
-import fs2 from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import fs4 from "fs";
 var LOG_PATH = "/tmp/opencode-monitor-debug.log";
 function wlog(msg) {
   try {
-    fs2.appendFileSync(LOG_PATH, `[${new Date().toISOString()}] WEBHOOK_IO: ${msg}
+    fs4.appendFileSync(LOG_PATH, `[${new Date().toISOString()}] WEBHOOK_IO: ${msg}
 `);
   } catch {}
 }
-function sendWebhook(config, text) {
-  const { webhook } = config;
-  const body = { text, mode: "now" };
+function resolveFallbackSessionKey(config) {
   const envSessionKey = process.env.OPENCLAW_SESSION_KEY;
   if (envSessionKey) {
-    body.sessionKey = envSessionKey;
-  } else if (webhook.sessionKey) {
-    body.sessionKey = webhook.sessionKey;
-  } else if (webhook.channel) {
-    body.sessionKey = `agent:${webhook.agentId}:${webhook.channelType}:${webhook.chatType}:${webhook.channel}`;
+    return envSessionKey;
+  }
+  if (config.webhook.sessionKey) {
+    return config.webhook.sessionKey;
+  }
+  if (config.webhook.channel) {
+    return `agent:${config.webhook.agentId}:${config.webhook.channelType}:${config.webhook.chatType}:${config.webhook.channel}`;
+  }
+  return "";
+}
+function buildCorrelationId(text, provided) {
+  if (provided && provided.trim()) {
+    return provided.trim();
   }
-  wlog(`Sending /hooks/wake to ${webhook.url} (session: ${body.sessionKey ?? "main"}): ${text}`);
+  const sessionMatch = text.match(/\((ses_[A-Za-z0-9_-]+)\)/);
+  if (sessionMatch?.[1]) {
+    return `${sessionMatch[1]}:${Date.now()}`;
+  }
+  return randomUUID2();
+}
+function sendWebhook(config, text, options = {}) {
+  const { webhook } = config;
+  const envSessionKey = process.env.OPENCLAW_SESSION_KEY?.trim();
+  const sessionKey = envSessionKey || options.sessionKey?.trim() || resolveFallbackSessionKey(config);
+  const correlationId = buildCorrelationId(text, options.correlationId);
+  const body = {
+    text,
+    mode: "now",
+    metadata: {
+      correlationId
+    }
+  };
+  if (sessionKey) {
+    body.sessionKey = sessionKey;
+  }
+  wlog(`Sending /hooks/wake to ${webhook.url} (session: ${sessionKey || "main"}, correlationId: ${correlationId}): ${text}`);
   fetch(webhook.url, {
     method: "POST",
     headers: {
@@ -442,26 +808,37 @@ function sendWebhook(config, text) {
 // src/index.ts
 var DEBUG_LOG_PATH = "/tmp/opencode-monitor-debug.log";
 function buildPrefix(config) {
-  const host = config.hostLabel || os2.hostname();
-  const project = path2.basename(process.cwd());
+  const host = config.hostLabel || os3.hostname();
+  const project = path4.basename(process.cwd());
   return `[OpenCode@${host}:${project}]`;
 }
 var SessionMonitorPlugin = async (_ctx) => {
   const config = loadConfig();
+  const projectConfig = loadProjectConfig();
+  const sessionRouting = resolveSessionRouting(config, projectConfig);
   const prefix = buildPrefix(config);
   const debugLog = config.debug ? (msg) => {
     const line = `[${new Date().toISOString()}] ${msg}
 `;
     try {
-      fs3.appendFileSync(DEBUG_LOG_PATH, line);
+      fs5.appendFileSync(DEBUG_LOG_PATH, line);
     } catch {}
   } : undefined;
   debugLog?.("Plugin initializing...");
   debugLog?.(`Config loaded: enabled=${config.enabled}, url=${config.webhook.url}`);
+  debugLog?.(`Routing session source=${sessionRouting.source}`);
   if (!config.enabled) {
     debugLog?.("Plugin disabled, exiting.");
     return {};
   }
+  const registry = new Registry({ debugLog });
+  registry.start({
+    hostLabel: config.hostLabel || os3.hostname(),
+    tmuxSession: projectConfig.tmuxSession,
+    openclawSessionKey: sessionRouting.sessionKey,
+    agentId: sessionRouting.agentId,
+    channelId: sessionRouting.channelId
+  });
   if (!config.webhook.url || !config.webhook.token) {
     console.log("[monitor] Webhook not configured. Set webhook.url and webhook.token in ~/.config/opencode/opencode-monitor.json");
     return {};
@@ -471,7 +848,9 @@ var SessionMonitorPlugin = async (_ctx) => {
   const webhookFn = (text) => {
     const tagged = text.startsWith("[OpenCode]") ? prefix + text.slice("[OpenCode]".length) : `${prefix} ${text}`;
     debugLog?.(`WEBHOOK: ${tagged}`);
-    sendWebhook(config, tagged);
+    sendWebhook(config, tagged, {
+      sessionKey: sessionRouting.sessionKey
+    });
   };
   const timers = new TimerManager(config, webhookFn);
   debugLog?.("Plugin loaded successfully. Waiting for events...");

package/dist/project-config.d.ts

@@ -0,0 +1,13 @@
+import type { MonitorConfig } from "./config";
+export interface ProjectConfig {
+    sessionKey: string;
+    tmuxSession: string;
+}
+export interface SessionRouting {
+    sessionKey: string;
+    source: "env" | "project" | "config" | "derived" | "none";
+    agentId: string;
+    channelId: string;
+}
+export declare function loadProjectConfig(cwd?: string): ProjectConfig;
+export declare function resolveSessionRouting(config: MonitorConfig, projectConfig: ProjectConfig): SessionRouting;

package/dist/registry.d.ts

@@ -0,0 +1,57 @@
+export declare const REGISTRY_FILE_PATH: string;
+export interface RegistryEntry {
+    instanceId: string;
+    hostname: string;
+    hostLabel: string;
+    pid: number;
+    startedAt: string;
+    leaseExpiresAt: string;
+    project: string;
+    projectId: string;
+    workspaceRoot: string;
+    tmuxSession: string;
+    openclawSessionKey: string;
+    agentId: string;
+    channelId: string;
+}
+export interface RegistryStartInput {
+    hostLabel: string;
+    tmuxSession: string;
+    openclawSessionKey: string;
+    agentId: string;
+    channelId: string;
+}
+export interface RegistryOptions {
+    workspaceRoot?: string;
+    ttlMs?: number;
+    heartbeatMs?: number;
+    debugLog?: (msg: string) => void;
+}
+export declare class Registry {
+    private readonly instanceId;
+    private readonly hostname;
+    private readonly workspaceRoot;
+    private readonly project;
+    private readonly projectId;
+    private readonly ttlMs;
+    private readonly heartbeatMs;
+    private readonly debugLog;
+    private heartbeatTimer;
+    private hooksInstalled;
+    private entryTemplate;
+    private readonly stopOnProcessExit;
+    constructor(options?: RegistryOptions);
+    start(input: RegistryStartInput): void;
+    stop(): void;
+    readSessions(): RegistryEntry[];
+    private startHeartbeat;
+    private installProcessHooks;
+    private upsert;
+    private remove;
+    private updateSessions;
+    private readAndGc;
+    private readRegistryFile;
+    private writeRegistryFile;
+    private ensureRegistryDir;
+    private isPidAlive;
+}

package/dist/webhook.d.ts

@@ -1,2 +1,7 @@
 import type { MonitorConfig } from "./config";
-export declare function sendWebhook(config: MonitorConfig, text: string): void;
+interface SendWebhookOptions {
+    sessionKey?: string;
+    correlationId?: string;
+}
+export declare function sendWebhook(config: MonitorConfig, text: string, options?: SendWebhookOptions): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omoclaw",
-  "version": "2.4.0",
+  "version": "3.0.0",
   "description": "OpenCode session monitor plugin \u2014 native event-driven webhook notifications for session state changes",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",