grix-connector 3.15.2 → 3.15.4

package/openclaw-plugin/index.js

@@ -3200,6 +3200,212 @@ async function clearOpenClawGatewayProvider() {
   return true;
 }
 
+// src/openclaw/usage-parser.ts
+import { createReadStream, existsSync as existsSync2, readdirSync } from "node:fs";
+import { readdir, readFile as readFile2 } from "node:fs/promises";
+import { createInterface } from "node:readline";
+import { dirname as dirname3, join as join4 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+function warnUsage(message, err) {
+  const detail = err instanceof Error ? err.message : err != null ? String(err) : "";
+  console.warn(`[openclaw/usage] ${message}${detail ? `: ${detail}` : ""}`);
+}
+function zeroUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0
+  };
+}
+function addUsage(acc, delta) {
+  acc.inputTokens += delta.inputTokens;
+  acc.outputTokens += delta.outputTokens;
+  acc.cacheReadInputTokens += delta.cacheReadInputTokens;
+  acc.cacheCreationInputTokens += delta.cacheCreationInputTokens;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function resolveOpenClawStateDir() {
+  const explicit = process.env.OPENCLAW_STATE_DIR?.trim();
+  if (explicit) return explicit;
+  const cfg = process.env.OPENCLAW_CONFIG_PATH?.trim();
+  if (cfg) {
+    const resolved = cfg.startsWith("~") ? join4(homedir5(), cfg.slice(1)) : cfg;
+    return dirname3(resolved);
+  }
+  return join4(homedir5(), ".openclaw");
+}
+function grixTargetCandidates(grixSessionId) {
+  const id = grixSessionId.trim();
+  if (!id) return [];
+  return [`grix:${id}`, id];
+}
+function entryMatchesGrixSession(entry, grixSessionId) {
+  const needles = new Set(grixTargetCandidates(grixSessionId));
+  const haystacks = [
+    entry.deliveryContext?.to,
+    entry.origin?.to,
+    entry.lastTo,
+    entry.route?.target?.to
+  ];
+  for (const raw of haystacks) {
+    const value = String(raw ?? "").trim();
+    if (value && needles.has(value)) return true;
+  }
+  return false;
+}
+async function listSessionStorePaths(stateDir2) {
+  const agentsRoot = join4(stateDir2, "agents");
+  if (!existsSync2(agentsRoot)) return [];
+  let agentIds;
+  try {
+    agentIds = await readdir(agentsRoot);
+  } catch (err) {
+    warnUsage(`failed to list agents under ${agentsRoot}`, err);
+    return [];
+  }
+  const paths2 = [];
+  for (const agentId of agentIds) {
+    const storePath = join4(agentsRoot, agentId, "sessions", "sessions.json");
+    if (existsSync2(storePath)) paths2.push(storePath);
+  }
+  return paths2;
+}
+async function loadSessionStore(storePath) {
+  try {
+    const raw = JSON.parse(await readFile2(storePath, "utf8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      warnUsage(`sessions store is not a JSON object: ${storePath}`);
+      return null;
+    }
+    return raw;
+  } catch (err) {
+    warnUsage(`failed to read sessions store ${storePath}`, err);
+    return null;
+  }
+}
+function resolveTranscriptPaths(params) {
+  const { sessionsDir, entry } = params;
+  const familyIds = Array.isArray(entry.usageFamilySessionIds) ? entry.usageFamilySessionIds.filter((v) => typeof v === "string" && v.trim().length > 0) : [];
+  const currentId = typeof entry.sessionId === "string" ? entry.sessionId.trim() : "";
+  const ids = familyIds.length > 0 ? familyIds : currentId ? [currentId] : [];
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const coveredIds = /* @__PURE__ */ new Set();
+  const push = (filePath, sessionId) => {
+    if (!filePath || seen.has(filePath) || !existsSync2(filePath)) return false;
+    seen.add(filePath);
+    found.push(filePath);
+    if (sessionId) coveredIds.add(sessionId);
+    return true;
+  };
+  let dirEntries = [];
+  try {
+    dirEntries = readdirSync(sessionsDir);
+  } catch (err) {
+    warnUsage(`failed to list session transcripts in ${sessionsDir}`, err);
+    dirEntries = [];
+  }
+  if (typeof entry.sessionFile === "string" && entry.sessionFile.trim()) {
+    push(entry.sessionFile.trim(), currentId || void 0);
+  }
+  for (const id of ids) {
+    if (coveredIds.has(id)) continue;
+    const livePath = join4(sessionsDir, `${id}.jsonl`);
+    if (push(livePath, id)) continue;
+    const resetNames = dirEntries.filter((name) => name.startsWith(`${id}.jsonl.reset.`)).sort();
+    if (resetNames.length > 0) {
+      push(join4(sessionsDir, resetNames[resetNames.length - 1]), id);
+    }
+  }
+  return found;
+}
+function readUsageFromMessage(message) {
+  if (!message || typeof message !== "object") return null;
+  const usage = message.usage;
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+  const u = usage;
+  const inputTokens = asFiniteNumber(u.input ?? u.inputTokens ?? u.input_tokens);
+  const outputTokens = asFiniteNumber(u.output ?? u.outputTokens ?? u.output_tokens);
+  const cacheReadInputTokens = asFiniteNumber(
+    u.cacheRead ?? u.cacheReadInputTokens ?? u.cache_read_input_tokens
+  );
+  const cacheCreationInputTokens = asFiniteNumber(
+    u.cacheWrite ?? u.cacheCreationInputTokens ?? u.cache_creation_input_tokens
+  );
+  return { inputTokens, outputTokens, cacheReadInputTokens, cacheCreationInputTokens };
+}
+async function parseTranscriptFile(filePath, byModel, total) {
+  let turns = 0;
+  const rl = createInterface({ input: createReadStream(filePath, "utf8"), crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "message") continue;
+    const message = entry.message;
+    if (!message || message.role !== "assistant") continue;
+    const usage = readUsageFromMessage(message);
+    if (!usage) continue;
+    turns++;
+    addUsage(total, usage);
+    const model = typeof message.model === "string" && message.model.trim() || typeof message.modelId === "string" && message.modelId.trim() || "unknown";
+    let bucket = byModel.get(model);
+    if (!bucket) {
+      bucket = { turns: 0, usage: zeroUsage() };
+      byModel.set(model, bucket);
+    }
+    bucket.turns++;
+    addUsage(bucket.usage, usage);
+  }
+  return turns;
+}
+async function parseOpenClawSessionUsage(grixSessionId, stateDir2 = resolveOpenClawStateDir()) {
+  const sessionId = String(grixSessionId ?? "").trim();
+  if (!sessionId) return null;
+  const storePaths = await listSessionStorePaths(stateDir2);
+  for (const storePath of storePaths) {
+    const store = await loadSessionStore(storePath);
+    if (!store) continue;
+    for (const [sessionKey, entry] of Object.entries(store)) {
+      if (!entry || typeof entry !== "object") continue;
+      if (!entryMatchesGrixSession(entry, sessionId)) continue;
+      const sessionsDir = dirname3(storePath);
+      const files = resolveTranscriptPaths({ sessionsDir, entry });
+      if (files.length === 0) continue;
+      const byModel = /* @__PURE__ */ new Map();
+      const total = zeroUsage();
+      let turns = 0;
+      for (const file of files) {
+        turns += await parseTranscriptFile(file, byModel, total);
+      }
+      if (turns === 0) continue;
+      const openclawSessionId = typeof entry.sessionId === "string" && entry.sessionId.trim() || sessionKey;
+      return {
+        openclawSessionId,
+        sessionKey,
+        model: typeof entry.model === "string" ? entry.model : void 0,
+        provider: typeof entry.modelProvider === "string" ? entry.modelProvider : void 0,
+        contextTokens: typeof entry.contextTokens === "number" && Number.isFinite(entry.contextTokens) ? entry.contextTokens : void 0,
+        turns,
+        total,
+        models: [...byModel.entries()].map(([model, bucket]) => ({
+          model,
+          turns: bucket.turns,
+          total: bucket.usage
+        }))
+      };
+    }
+  }
+  return null;
+}
+
 // src/openclaw/local-actions.ts
 var STABLE_LOCAL_ACTION_TYPES = [
   "exec_approve",
@@ -3456,22 +3662,46 @@ async function handleCreateFolderLocalAction(payload) {
 async function handleGetSessionUsageLocalAction(payload) {
   const actionID = String(payload.action_id ?? "").trim() || "unknown";
   const params = payload.params ?? {};
-  const sessionId = typeof params.session_id === "string" ? params.session_id : "";
+  const sessionId = typeof params.session_id === "string" ? params.session_id.trim() : "";
+  if (!sessionId) {
+    return {
+      action_id: actionID,
+      status: "failed",
+      error_code: "session_id_required",
+      error_msg: "session_id is required for get_session_usage"
+    };
+  }
+  const parsed = await parseOpenClawSessionUsage(sessionId);
+  if (!parsed) {
+    return {
+      action_id: actionID,
+      status: "failed",
+      error_code: "usage_not_found",
+      error_msg: "No OpenClaw transcript usage found for this Grix session"
+    };
+  }
   return {
     action_id: actionID,
     status: "ok",
     result: {
-      session_id: sessionId,
-      provider: "openclaw",
-      message: "OpenClaw \u5F53\u524D\u65E0\u7528\u91CF\u8BA1\u91CF\u6570\u636E"
+      sessionId: parsed.openclawSessionId,
+      adapterType: "openclaw",
+      models: parsed.models,
+      total: parsed.total,
+      turns: parsed.turns,
+      sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...parsed.model ? { model: parsed.model } : {},
+      ...parsed.provider ? { provider: parsed.provider } : {},
+      ...parsed.contextTokens !== void 0 ? { contextTokens: parsed.contextTokens } : {},
+      ...parsed.sessionKey ? { sessionKey: parsed.sessionKey } : {}
     }
   };
 }
 
 // src/openclaw/exec-command.ts
-import { readdirSync, readFileSync, existsSync as existsSync2 } from "node:fs";
-import { join as join4, dirname as dirname3 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { readdirSync as readdirSync2, readFileSync, existsSync as existsSync3 } from "node:fs";
+import { join as join5, dirname as dirname4 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 import { fileURLToPath } from "node:url";
 function parseExecCommand(text) {
   const tokens = String(text ?? "").trim().split(/\s+/);
@@ -3499,13 +3729,13 @@ function parseSkillFrontmatter(content) {
   return { name, description };
 }
 function scanSkillDir(baseDir, source) {
-  if (!existsSync2(baseDir)) return [];
+  if (!existsSync3(baseDir)) return [];
   const results = [];
   try {
-    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+    for (const entry of readdirSync2(baseDir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const skillFile = join4(baseDir, entry.name, "SKILL.md");
-      if (!existsSync2(skillFile)) continue;
+      const skillFile = join5(baseDir, entry.name, "SKILL.md");
+      if (!existsSync3(skillFile)) continue;
       try {
         const parsed = parseSkillFrontmatter(readFileSync(skillFile, "utf-8"));
         if (parsed.name) results.push({ name: parsed.name, description: parsed.description, source });
@@ -3516,12 +3746,13 @@ function scanSkillDir(baseDir, source) {
   }
   return results;
 }
+function resolvePluginSkillsDir(moduleUrl = import.meta.url) {
+  return join5(dirname4(fileURLToPath(moduleUrl)), "skills");
+}
 function scanOpenClawSkills() {
   const results = [];
-  const thisDir = dirname3(fileURLToPath(import.meta.url));
-  const pluginSkills = join4(thisDir, "..", "skills");
-  results.push(...scanSkillDir(pluginSkills, "plugin"));
-  results.push(...scanSkillDir(join4(homedir5(), ".openclaw", "skills"), "global"));
+  results.push(...scanSkillDir(resolvePluginSkillsDir(), "plugin"));
+  results.push(...scanSkillDir(join5(homedir6(), ".openclaw", "skills"), "global"));
   return results;
 }
 function handleSkillsCommand() {
@@ -5702,13 +5933,13 @@ var grixExecApprovalAdapter = {
 // src/openclaw/log-rotation.ts
 import {
   appendFileSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync,
   renameSync,
   rmSync,
   statSync
 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 function rotationPath(filePath, index) {
   return `${filePath}.${index}`;
 }
@@ -5716,17 +5947,17 @@ function rotateLogFileIfNeededSync(filePath, incomingBytes, options) {
   if (options.maxBytes <= 0 || options.maxFiles <= 0) {
     return false;
   }
-  if (!existsSync3(filePath)) {
+  if (!existsSync4(filePath)) {
     return false;
   }
   const currentBytes = statSync(filePath).size;
   if (currentBytes + Math.max(0, incomingBytes) <= options.maxBytes) {
     return false;
   }
-  mkdirSync(dirname4(filePath), { recursive: true });
+  mkdirSync(dirname5(filePath), { recursive: true });
   for (let index = options.maxFiles; index >= 1; index -= 1) {
     const sourcePath = index === 1 ? filePath : rotationPath(filePath, index - 1);
-    if (!existsSync3(sourcePath)) {
+    if (!existsSync4(sourcePath)) {
       continue;
     }
     const targetPath = rotationPath(filePath, index);
@@ -5736,22 +5967,22 @@ function rotateLogFileIfNeededSync(filePath, incomingBytes, options) {
   return true;
 }
 function appendRotatedLogLineSync(filePath, line, options) {
-  mkdirSync(dirname4(filePath), { recursive: true });
+  mkdirSync(dirname5(filePath), { recursive: true });
   rotateLogFileIfNeededSync(filePath, Buffer.byteLength(line), options);
   appendFileSync(filePath, line, "utf8");
 }
 
 // src/openclaw/plugin-logger.ts
-import { homedir as homedir6 } from "node:os";
-import { join as join5, dirname as dirname5 } from "node:path";
-var BASE_DIR = process.env.GRIX_CONNECTOR_HOME ? process.env.GRIX_CONNECTOR_HOME : join5(homedir6(), ".grix");
+import { homedir as homedir7 } from "node:os";
+import { join as join6, dirname as dirname6 } from "node:path";
+var BASE_DIR = process.env.GRIX_CONNECTOR_HOME ? process.env.GRIX_CONNECTOR_HOME : join6(homedir7(), ".grix");
 var LOG_ROTATION = {
   maxBytes: 10 * 1024 * 1024,
   maxFiles: 5
 };
 var pendingConversationWrites = /* @__PURE__ */ new Map();
 function appendServiceLog(target, line) {
-  const filePath = join5(
+  const filePath = join6(
     BASE_DIR,
     "service",
     target === "out" ? "out.log" : "err.log"
@@ -5773,7 +6004,7 @@ function appendConversationLog(filePath, line) {
   const previous = pendingConversationWrites.get(filePath) ?? Promise.resolve();
   const next = previous.catch(() => {
   }).then(async () => {
-    await mkdir(dirname5(filePath), { recursive: true });
+    await mkdir(dirname6(filePath), { recursive: true });
     rotateLogFileIfNeededSync(filePath, Buffer.byteLength(line), LOG_ROTATION);
     await appendFile(filePath, line, "utf8");
   });
@@ -5786,7 +6017,7 @@ function appendConversationLog(filePath, line) {
   });
 }
 function logConversation(entry) {
-  const filePath = join5(
+  const filePath = join6(
     BASE_DIR,
     "log",
     "sessions",
@@ -6154,37 +6385,37 @@ function buildAibotTextSendPlan(params) {
 }
 
 // src/core/log/logger.ts
-import { createWriteStream, mkdirSync as mkdirSync2, existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2, unlinkSync } from "node:fs";
-import { join as join7 } from "node:path";
+import { createWriteStream, mkdirSync as mkdirSync2, existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync2, unlinkSync } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/core/config/paths.ts
-import { join as join6 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { join as join7 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 var GRIX_HOME_ENV = "GRIX_CONNECTOR_HOME";
-var DEFAULT_GRIX_HOME = join6(homedir7(), ".grix");
+var DEFAULT_GRIX_HOME = join7(homedir8(), ".grix");
 function resolveRuntimePaths(runtimeDir) {
   const rootDir = runtimeDir ? runtimeDir : process.env[GRIX_HOME_ENV] ? process.env[GRIX_HOME_ENV] : DEFAULT_GRIX_HOME;
   return {
     rootDir,
-    configDir: join6(rootDir, "config"),
-    logDir: join6(rootDir, "log"),
-    dataDir: join6(rootDir, "data"),
-    serviceDir: join6(rootDir, "service"),
-    skillsDir: join6(rootDir, "skills"),
-    stateFile: join6(rootDir, "service.json"),
-    pidFile: join6(rootDir, "grix-connector.pid"),
-    daemonLockFile: join6(rootDir, "daemon.lock.json"),
-    daemonStatusFile: join6(rootDir, "daemon-status.json"),
-    stdoutLogFile: join6(rootDir, "service", "daemon.out.log"),
-    stderrLogFile: join6(rootDir, "service", "daemon.err.log"),
-    contextsDir: join6(rootDir, "data", "session-contexts"),
-    hookSignalsPath: join6(rootDir, "data", "hook-signals.json"),
-    hookSignalsLogPath: join6(rootDir, "log", "hook-signals.log"),
-    elicitationRequestsDir: join6(rootDir, "data", "elicitation-requests"),
-    eventStatesDir: join6(rootDir, "data", "event-states"),
-    questionRequestsDir: join6(rootDir, "data", "question-requests"),
-    permissionRequestsDir: join6(rootDir, "data", "permission-requests"),
-    agentGlobalConfigsFile: join6(rootDir, "data", "agent-global-configs.json")
+    configDir: join7(rootDir, "config"),
+    logDir: join7(rootDir, "log"),
+    dataDir: join7(rootDir, "data"),
+    serviceDir: join7(rootDir, "service"),
+    skillsDir: join7(rootDir, "skills"),
+    stateFile: join7(rootDir, "service.json"),
+    pidFile: join7(rootDir, "grix-connector.pid"),
+    daemonLockFile: join7(rootDir, "daemon.lock.json"),
+    daemonStatusFile: join7(rootDir, "daemon-status.json"),
+    stdoutLogFile: join7(rootDir, "service", "daemon.out.log"),
+    stderrLogFile: join7(rootDir, "service", "daemon.err.log"),
+    contextsDir: join7(rootDir, "data", "session-contexts"),
+    hookSignalsPath: join7(rootDir, "data", "hook-signals.json"),
+    hookSignalsLogPath: join7(rootDir, "log", "hook-signals.log"),
+    elicitationRequestsDir: join7(rootDir, "data", "elicitation-requests"),
+    eventStatesDir: join7(rootDir, "data", "event-states"),
+    questionRequestsDir: join7(rootDir, "data", "question-requests"),
+    permissionRequestsDir: join7(rootDir, "data", "permission-requests"),
+    agentGlobalConfigsFile: join7(rootDir, "data", "agent-global-configs.json")
   };
 }
 
@@ -6245,13 +6476,13 @@ function cleanupOldLogs() {
   const cutoff = Date.now() - resolveRetentionDays() * 24 * 60 * 60 * 1e3;
   let entries2;
   try {
-    entries2 = readdirSync2(GRIX_PATHS.log);
+    entries2 = readdirSync3(GRIX_PATHS.log);
   } catch {
     return;
   }
   for (const name of entries2) {
     if (!name.startsWith("grix-connector-") || !name.includes(".log")) continue;
-    const full = join7(GRIX_PATHS.log, name);
+    const full = join8(GRIX_PATHS.log, name);
     try {
       if (statSync2(full).mtimeMs < cutoff) unlinkSync(full);
     } catch {
@@ -6263,7 +6494,7 @@ function openLogStream(date) {
     logStream?.end();
   } catch {
   }
-  const logFile = join7(GRIX_PATHS.log, `grix-connector-${date}.log`);
+  const logFile = join8(GRIX_PATHS.log, `grix-connector-${date}.log`);
   logStream = createWriteStream(logFile, { flags: "a" });
   currentLogDate = date;
   cleanupOldLogs();
@@ -10533,8 +10764,8 @@ function collectMissingParameters(request) {
 }
 
 // src/openclaw/egg/orchestrator.ts
-import { join as join10 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { join as join11 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 
 // src/openclaw/sdk-exec.ts
 function resolveOpenClawCliArgvPrefix2() {
@@ -10644,21 +10875,21 @@ async function downloadPackage(params) {
 
 // src/openclaw/egg/persona-installer.ts
 var import_extract_zip = __toESM(require_extract_zip(), 1);
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { tmpdir } from "node:os";
 var PERSONA_FILES = ["IDENTITY.md", "SOUL.md", "AGENTS.md"];
 var OPTIONAL_PERSONA_FILES = ["USER.md", "MEMORY.md"];
 var ALL_PERSONA_FILES = [...PERSONA_FILES, ...OPTIONAL_PERSONA_FILES];
 function getWorkspaceRoot(agentName, openclawHome) {
-  return join8(openclawHome, `workspace-${agentName}`);
+  return join9(openclawHome, `workspace-${agentName}`);
 }
 async function ensureWorkspaceDir(workspaceRoot) {
   await mkdir(workspaceRoot, { recursive: true });
 }
 async function extractZipToTemp(buffer) {
-  const tmpDir = join8(tmpdir(), `egg-extract-${Date.now()}`);
+  const tmpDir = join9(tmpdir(), `egg-extract-${Date.now()}`);
   await mkdir(tmpDir, { recursive: true });
-  const zipPath = join8(tmpDir, "package.zip");
+  const zipPath = join9(tmpDir, "package.zip");
   await writeFile(zipPath, buffer);
   await (0, import_extract_zip.default)(zipPath, { dir: tmpDir });
   return tmpDir;
@@ -10668,7 +10899,7 @@ async function findPersonaFilesInDir(dir, prefix = "") {
   const entries2 = await listEntries(dir, { withFileTypes: true });
   for (const entry of entries2) {
     if (entry.name === "package.zip") continue;
-    const fullPath = join8(dir, entry.name);
+    const fullPath = join9(dir, entry.name);
     const relativeName = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
       const nested = await findPersonaFilesInDir(fullPath, relativeName);
@@ -10691,7 +10922,7 @@ async function installPersonaFromZip(params) {
     const personaFiles = await findPersonaFilesInDir(tmpDir);
     for (const [fileName, sourcePath] of personaFiles) {
       const content = await loadFile(sourcePath, "utf-8");
-      await writeFile(join8(workspaceRoot, fileName), content, "utf-8");
+      await writeFile(join9(workspaceRoot, fileName), content, "utf-8");
       installedFiles.push(fileName);
     }
     await ensureMinimalPersonaFiles(workspaceRoot, installedFiles);
@@ -10706,13 +10937,13 @@ async function ensureMinimalPersonaFiles(workspaceRoot, existingFiles) {
     if (!existingFiles.includes(required)) {
       const content = `# ${required.replace(".md", "")}
 `;
-      await writeFile(join8(workspaceRoot, required), content, "utf-8");
+      await writeFile(join9(workspaceRoot, required), content, "utf-8");
     }
   }
 }
 
 // src/openclaw/egg/local-binding.ts
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var LocalBindingError = class extends Error {
   constructor(message) {
     super(`[egg:bind] ${message}`);
@@ -10813,8 +11044,8 @@ function buildAgentListEntry(params) {
 }
 async function runLocalBinding(params) {
   const { agentName, createdAgent, isMainAgent = false, openclawHome } = params;
-  const workspace = join9(openclawHome, `workspace-${agentName}`);
-  const agentDir = join9(openclawHome, "agents", agentName, "agent");
+  const workspace = join10(openclawHome, `workspace-${agentName}`);
+  const agentDir = join10(openclawHome, "agents", agentName, "agent");
   await mkdir(workspace, { recursive: true });
   await mkdir(agentDir, { recursive: true });
   const wsUrl = deriveWsUrl(createdAgent.api_endpoint);
@@ -10994,7 +11225,7 @@ function makeEmptySteps() {
   };
 }
 function resolveStateFilePath(installId) {
-  return join10(homedir8(), ".openclaw", "egg-installs", `${installId}.json`);
+  return join11(homedir9(), ".openclaw", "egg-installs", `${installId}.json`);
 }
 async function readStateFile(filePath) {
   try {
@@ -11005,7 +11236,7 @@ async function readStateFile(filePath) {
   }
 }
 async function writeStateFile(filePath, state) {
-  await mkdir(join10(homedir8(), ".openclaw", "egg-installs"), { recursive: true });
+  await mkdir(join11(homedir9(), ".openclaw", "egg-installs"), { recursive: true });
   state.updated_at = nowIso();
   await writeFile(filePath, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
@@ -11145,7 +11376,7 @@ async function writeSoulIfProvided(request, workspaceRoot) {
     content = await loadFile(soulFile, "utf-8");
   }
   if (!content) return;
-  await writeFile(join10(workspaceRoot, "SOUL.md"), content, "utf-8");
+  await writeFile(join11(workspaceRoot, "SOUL.md"), content, "utf-8");
 }
 function parseNumericId(value) {
   const normalized = cleanText2(value);
@@ -11526,8 +11757,8 @@ async function runEggOrchestrator(params) {
       errorCode: "create_agent_failed"
     });
   }
-  const openclawHome = join10(homedir8(), ".openclaw");
-  const workspaceRoot = join10(openclawHome, `workspace-${request.localAgentName}`);
+  const openclawHome = join11(homedir9(), ".openclaw");
+  const workspaceRoot = join11(openclawHome, `workspace-${request.localAgentName}`);
   let downloadedBuffer = null;
   if (state.steps.install.status !== "done") {
     try {
@@ -11873,10 +12104,10 @@ function createGrixRegisterTool(api, ctx) {
 
 // src/openclaw/skill-tools/grix-update-tool.ts
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 
 // src/openclaw/skill-tools/timed-file-lock.ts
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 function getErrorCode(err) {
   if (typeof err !== "object" || err === null || !("code" in err)) {
     return void 0;
@@ -11930,7 +12161,7 @@ async function readExistingLock(lockFilePath, ttlMs) {
 }
 async function tryAcquireTimedFileLock(options) {
   const now = options.now ?? Date.now;
-  await mkdir(dirname6(options.lockFilePath), { recursive: true });
+  await mkdir(dirname7(options.lockFilePath), { recursive: true });
   for (let attempt = 0; attempt < 4; attempt += 1) {
     const createdAt = now();
     const expiresAt = createdAt + options.ttlMs;
@@ -11984,7 +12215,7 @@ function normalizeNonEmptyString2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function resolveGrixUpdateLockFilePath(lockFilePath) {
-  return lockFilePath ?? join11(tmpdir2(), "grix-connector-update.lock");
+  return lockFilePath ?? join12(tmpdir2(), "grix-connector-update.lock");
 }
 function createGrixUpdateTool(api, ctx, options = {}) {
   const delegatedTool = createDelegatedSkillTool({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grix-connector",
-  "version": "3.15.2",
+  "version": "3.15.4",
   "description": "Connect local AI coding agents (Claude, Codex, Gemini, Qwen, DeepSeek, Cursor, OpenCode, Pi, OpenHuman, Reasonix) to the Grix scheduling platform. Also serves as an OpenClaw plugin for Grix channel transport.",
   "type": "module",
   "main": "dist/index.js",