@agentvault/agentvault 0.13.7 → 0.13.9

package/dist/index.d.ts

@@ -5,5 +5,5 @@ export type { ResolvedAccount } from "./account-config.js";
 export { agentVaultPlugin, setOcRuntime, getActiveChannel } from "./openclaw-plugin.js";
 export { sendToOwner, checkGateway } from "./gateway-send.js";
 export type { GatewaySendOptions, GatewaySendResult, GatewayStatusResult, } from "./gateway-send.js";
-export declare const VERSION = "0.13.7";
+export declare const VERSION = "0.13.9";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -45447,10 +45447,12 @@ import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 var STATE_FILE = "agentvault.json";
 var LEGACY_STATE_FILE = "secure-channel.json";
+var DIR_MODE = 448;
+var FILE_MODE = 384;
 async function saveState(dataDir, state) {
-  await mkdir(dataDir, { recursive: true });
+  await mkdir(dataDir, { recursive: true, mode: DIR_MODE });
   const filePath = join(dataDir, STATE_FILE);
-  await writeFile(filePath, JSON.stringify(state, null, 2), "utf-8");
+  await writeFile(filePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: FILE_MODE });
   try {
     await rm(join(dataDir, LEGACY_STATE_FILE));
   } catch {
@@ -45467,8 +45469,8 @@ async function loadState(dataDir) {
   try {
     const raw = await readFile(legacyPath, "utf-8");
     const parsed = JSON.parse(raw);
-    await mkdir(dataDir, { recursive: true });
-    await writeFile(filePath, JSON.stringify(parsed, null, 2), "utf-8");
+    await mkdir(dataDir, { recursive: true, mode: DIR_MODE });
+    await writeFile(filePath, JSON.stringify(parsed, null, 2), { encoding: "utf-8", mode: FILE_MODE });
     await rm(legacyPath);
     return parsed;
   } catch {
@@ -45491,7 +45493,7 @@ async function backupState(dataDir) {
   const tmp = join(dataDir, `${STATE_FILE}.bak.tmp`);
   try {
     const data = await readFile(src, "utf-8");
-    await writeFile(tmp, data, "utf-8");
+    await writeFile(tmp, data, { encoding: "utf-8", mode: FILE_MODE });
     await rename(tmp, bak);
   } catch {
   }
@@ -45506,8 +45508,8 @@ async function restoreState(dataDir) {
     if (!parsed || !parsed.deviceId || !parsed.deviceJwt || !parsed.sessions || Object.keys(parsed.sessions).length === 0) {
       return false;
     }
-    await mkdir(dataDir, { recursive: true });
-    await writeFile(join(dataDir, STATE_FILE), data, "utf-8");
+    await mkdir(dataDir, { recursive: true, mode: DIR_MODE });
+    await writeFile(join(dataDir, STATE_FILE), data, { encoding: "utf-8", mode: FILE_MODE });
     return true;
   } catch {
     return false;
@@ -48246,13 +48248,39 @@ var agentVaultPlugin = {
     aliases: ["av", "agent-vault"]
   },
   capabilities: {
-    chatTypes: ["direct"]
+    chatTypes: ["direct", "room"]
   },
   config: {
     listAccountIds,
     resolveAccount
   },
   gateway: {
+    /** Health probe for `openclaw channels status --probe` */
+    probe: async (ctx) => {
+      const accountId = ctx?.accountId ?? "default";
+      const ch = _channels.get(accountId);
+      if (!ch) return { ok: false, status: "disconnected", error: "Channel not started" };
+      const state = ch.state;
+      return {
+        ok: state === "ready",
+        status: state,
+        deviceId: ch.deviceId ?? void 0,
+        sessions: ch.sessionCount
+      };
+    },
+    /** Status for `openclaw health --json` per-channel summary */
+    status: (ctx) => {
+      const accountId = ctx?.accountId ?? "default";
+      const ch = _channels.get(accountId);
+      if (!ch) return { connected: false, status: "not_started" };
+      return {
+        connected: ch.state === "ready",
+        status: ch.state,
+        deviceId: ch.deviceId ?? void 0,
+        sessions: ch.sessionCount,
+        encrypted: true
+      };
+    },
     startAccount: async (ctx) => {
       const { account, cfg, log, abortSignal } = ctx;
       if (!account.configured) {
@@ -48262,43 +48290,46 @@ var agentVaultPlugin = {
       }
       const dataDir = resolve(account.dataDir.replace(/^~/, process.env.HOME ?? "~"));
       log?.(`[AgentVault] starting channel (dataDir=${dataDir})`);
-      const channel = new SecureChannel({
-        // No invite token needed — resuming from persisted enrolled state
-        inviteToken: "",
-        dataDir,
-        apiUrl: account.apiUrl,
-        agentName: account.agentName,
-        onMessage: async (plaintext, metadata) => {
-          if (!_ocRuntime) {
-            log?.("[AgentVault] runtime not ready \u2014 dropping inbound message");
-            return;
-          }
-          try {
-            await _handleInbound({ plaintext, metadata, channel, account, cfg });
-          } catch (err) {
-            log?.(`[AgentVault] inbound dispatch error: ${String(err)}`);
+      await new Promise((resolvePromise, reject) => {
+        const channel = new SecureChannel({
+          inviteToken: "",
+          dataDir,
+          apiUrl: account.apiUrl,
+          agentName: account.agentName,
+          onMessage: async (plaintext, metadata) => {
+            if (!_ocRuntime) {
+              log?.("[AgentVault] runtime not ready \u2014 dropping inbound message");
+              return;
+            }
+            try {
+              await _handleInbound({ plaintext, metadata, channel, account, cfg });
+            } catch (err) {
+              log?.(`[AgentVault] inbound dispatch error: ${String(err)}`);
+            }
+          },
+          onStateChange: (state) => {
+            log?.(`[AgentVault] state \u2192 ${state}`);
+            if (state === "error") reject(new Error("AgentVault channel permanent error"));
           }
-        },
-        onStateChange: (state) => {
-          log?.(`[AgentVault] state \u2192 ${state}`);
-        }
-      });
-      _channels.set(account.accountId, channel);
-      const httpPort = account.httpPort;
-      channel.on("ready", () => {
-        channel.startHttpServer(httpPort);
-        log?.(`[AgentVault] HTTP send server listening on http://127.0.0.1:${httpPort}`);
-      });
-      abortSignal?.addEventListener("abort", () => {
-        _channels.delete(account.accountId);
-      });
-      await channel.start();
-      return {
-        stop: async () => {
+        });
+        _channels.set(account.accountId, channel);
+        channel.on("error", (err) => {
+          log?.(`[AgentVault] channel error (non-fatal): ${String(err)}`);
+        });
+        const httpPort = account.httpPort;
+        channel.on("ready", () => {
+          channel.startHttpServer(httpPort);
+          log?.(`[AgentVault] HTTP send server listening on http://127.0.0.1:${httpPort}`);
+        });
+        abortSignal?.addEventListener("abort", async () => {
           await channel.stop();
           _channels.delete(account.accountId);
-        }
-      };
+          resolvePromise();
+        });
+        channel.start().catch(reject);
+      });
+      return { stop: async () => {
+      } };
     }
   },
   outbound: {
@@ -48331,6 +48362,25 @@ var agentVaultPlugin = {
       } catch (err) {
         return { ok: false, error: String(err) };
       }
+    },
+    sendMedia: async ({
+      text,
+      mediaUrl,
+      accountId
+    }) => {
+      const resolvedId = accountId ?? "default";
+      const channel = _channels.get(resolvedId);
+      if (!channel) {
+        return { ok: false, error: "AgentVault channel is not connected" };
+      }
+      try {
+        const message = text ? `${text}
+${mediaUrl}` : mediaUrl;
+        await channel.send(message);
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, error: String(err) };
+      }
     }
   }
 };
@@ -48463,7 +48513,7 @@ async function checkGateway(options) {
 }
 
 // src/index.ts
-var VERSION = "0.13.7";
+var VERSION = "0.13.9";
 export {
   SecureChannel,
   VERSION,