@zeyiy/openclaw-channel 0.3.8 → 0.3.9

package/dist/portal.js

@@ -7,12 +7,11 @@
  */
 import { readFile, writeFile, stat, mkdir, unlink, rm } from "node:fs/promises";
 import { readdirSync, realpathSync, existsSync, readFileSync, statSync } from "node:fs";
+import WsWebSocket from "ws";
 import { resolve, join, dirname, basename } from "node:path";
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
-import { tmpdir } from "node:os";
-import { normalizeAgentId, resolveDefaultAgentId, resolveUserPath, resolveAgentWorkspaceDir, isPathSafe, resolveStateDir, resolveOpenClawConfigPath, hasBinarySync, resolveBundledSkillsDir, resolveCronStorePath, resolveClawHubBaseUrl, loadFullConfig, clearDiskConfigCache, isEnvSatisfied, } from "./paths";
-import { fetchClawHub, downloadArchive, extractTarGz } from "./network";
+import { tmpdir, homedir } from "node:os";
 const bridges = new Map();
 const RECONNECT_BASE_MS = 2000;
 const RECONNECT_MAX_MS = 60000;
@@ -37,6 +36,50 @@ function portalLog(api, level, msg) {
 function getConfig(api) {
     return api.config ?? globalThis.__openimGatewayConfig ?? {};
 }
+function normalizeAgentId(value) {
+    const trimmed = (value ?? "").trim();
+    if (!trimmed)
+        return "main";
+    return trimmed.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 64) || "main";
+}
+function resolveDefaultAgentId(cfg) {
+    const agents = Array.isArray(cfg.agents?.list) ? cfg.agents.list : [];
+    if (agents.length === 0)
+        return "main";
+    const defaults = agents.filter((a) => a?.default);
+    const chosen = (defaults[0] ?? agents[0])?.id?.trim();
+    return normalizeAgentId(chosen || "main");
+}
+/** Expand leading ~ to $HOME, then resolve to absolute path. */
+function resolveUserPath(p) {
+    const home = homedir() || "";
+    if (p.startsWith("~/") || p === "~") {
+        return resolve(home, p.slice(2));
+    }
+    return resolve(p);
+}
+function resolveAgentWorkspaceDir(cfg, agentId) {
+    const id = normalizeAgentId(agentId);
+    const agents = Array.isArray(cfg.agents?.list) ? cfg.agents.list : [];
+    const entry = agents.find((a) => a?.id && normalizeAgentId(a.id) === id);
+    if (entry?.workspace?.trim())
+        return resolveUserPath(entry.workspace.trim());
+    const fallback = cfg.agents?.defaults?.workspace?.trim();
+    const defaultId = resolveDefaultAgentId(cfg);
+    const home = homedir() || process.cwd();
+    if (id === defaultId) {
+        if (fallback)
+            return resolveUserPath(fallback);
+        return resolve(home, ".openclaw", "workspace");
+    }
+    if (fallback)
+        return join(resolveUserPath(fallback), id);
+    return resolve(home, ".openclaw", `workspace-${id}`);
+}
+function isPathSafe(workspaceRoot, targetPath) {
+    const resolved = resolve(workspaceRoot, targetPath);
+    return resolved.startsWith(workspaceRoot + "/") || resolved === workspaceRoot;
+}
 async function statFileSafely(filePath) {
     try {
         const s = await stat(filePath);
@@ -452,6 +495,40 @@ function handleToolsCatalog(api, params) {
 // ---------------------------------------------------------------------------
 // Skills: file-based helpers (mirrors openclaw gateway internals)
 // ---------------------------------------------------------------------------
+/**
+ * Resolve the openclaw state directory root.
+ * Mirrors gateway's resolveStateDir: OPENCLAW_STATE_DIR > dirname(OPENCLAW_CONFIG_PATH) > ~/.openclaw
+ */
+/** Resolve the effective home directory. */
+function resolveEffectiveHomeDir() {
+    try {
+        return resolve(homedir());
+    }
+    catch { }
+    return resolve(process.cwd());
+}
+function resolveStateDir() {
+    return join(resolveEffectiveHomeDir(), ".openclaw");
+}
+function resolveOpenClawConfigPath() {
+    return join(resolveStateDir(), "openclaw.json");
+}
+/** Check if a binary is executable on the system PATH. */
+const _binaryCache = new Map();
+function hasBinarySync(bin) {
+    const cached = _binaryCache.get(bin);
+    if (cached !== undefined)
+        return cached;
+    try {
+        execFileSync("which", [bin], { stdio: "ignore" });
+        _binaryCache.set(bin, true);
+        return true;
+    }
+    catch {
+        _binaryCache.set(bin, false);
+        return false;
+    }
+}
 /**
  * Relaxed JSON5 parser: removes trailing commas before } or ].
  * Used for SKILL.md metadata blocks which use JSON5 syntax (trailing commas,
@@ -648,6 +725,69 @@ function loadSkillsFromDir(dir, source) {
     }
     return entries;
 }
+/**
+ * Resolve the bundled openclaw skills directory.
+ * Searches multiple known installation paths (npm, pnpm, nvm, etc.)
+ */
+function resolveBundledSkillsDir() {
+    const candidates = [];
+    // 1. Adjacent to node binary (nvm-style installs)
+    try {
+        candidates.push(join(dirname(process.execPath), "skills"));
+    }
+    catch { }
+    // 2. From argv[1] (openclaw.mjs inside gateway process)
+    try {
+        const argv1 = process.argv[1] ?? "";
+        if (argv1)
+            candidates.push(join(dirname(argv1), "skills"));
+    }
+    catch { }
+    // 3. Standard npm global: {execPath}/../lib/node_modules/openclaw/skills
+    try {
+        candidates.push(join(dirname(process.execPath), "..", "lib", "node_modules", "openclaw", "skills"));
+    }
+    catch { }
+    // 4. ~/.npm-global/lib/node_modules/openclaw/skills (common npm prefix)
+    const home = homedir() || "";
+    if (home) {
+        candidates.push(join(home, ".npm-global", "lib", "node_modules", "openclaw", "skills"));
+    }
+    // 5. Resolve from `which openclaw` symlink → package root
+    try {
+        const openclawBin = join(home, ".npm-global", "bin", "openclaw");
+        if (existsSync(openclawBin)) {
+            const realPath = realpathSync(openclawBin);
+            // realPath = .../openclaw/openclaw.mjs → dirname = .../openclaw/
+            candidates.push(join(dirname(realPath), "skills"));
+        }
+    }
+    catch { }
+    // 6. pnpm global store (glob-style search for latest version)
+    if (home) {
+        try {
+            const pnpmBase = join(home, "Library", "pnpm", "global", "5", ".pnpm");
+            if (existsSync(pnpmBase)) {
+                const dirs = readdirSync(pnpmBase)
+                    .filter(d => d.startsWith("openclaw@"))
+                    .sort()
+                    .reverse();
+                for (const d of dirs) {
+                    candidates.push(join(pnpmBase, d, "node_modules", "openclaw", "skills"));
+                }
+            }
+        }
+        catch { }
+    }
+    for (const candidate of candidates) {
+        try {
+            if (existsSync(candidate))
+                return candidate;
+        }
+        catch { }
+    }
+    return undefined;
+}
 /**
  * Resolve skill directories registered by enabled plugins.
  * Each plugin's openclaw.plugin.json may declare "skills": ["./skills"]
@@ -752,6 +892,28 @@ function loadAllSkillEntries(workspaceDir, cfg) {
     addAll(loadSkillsFromDir(join(resolve(workspaceDir), "skills"), "workspace"));
     return Array.from(merged.values());
 }
+/**
+ * Load the full openclaw config from disk.
+ * api.config may not contain all sections (e.g. skills.entries),
+ * so we read openclaw.json directly for complete data.
+ */
+let _diskConfigCache = null;
+function loadFullConfig() {
+    const configPath = resolveOpenClawConfigPath();
+    try {
+        const st = statSync(configPath);
+        if (_diskConfigCache && _diskConfigCache.mtimeMs === Math.floor(st.mtimeMs)) {
+            return _diskConfigCache.cfg;
+        }
+        const raw = readFileSync(configPath, "utf-8");
+        const cfg = JSON.parse(raw);
+        _diskConfigCache = { cfg, mtimeMs: Math.floor(st.mtimeMs) };
+        return cfg;
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * Build runtime status for a single skill entry.
  */
@@ -767,10 +929,12 @@ function buildSkillStatus(entry, cfg) {
     const requiresAnyBins = entry.metadata?.requires?.anyBins ?? [];
     const requiresEnv = entry.metadata?.requires?.env ?? [];
     const requiresConfig = entry.metadata?.requires?.config ?? [];
+    const isEnvSatisfied = (name) => Boolean(skillCfg?.env?.[name] ||
+        (skillCfg?.apiKey && entry.metadata?.primaryEnv === name));
     const missingBins = always ? [] : requiresBins.filter(b => !hasBinarySync(b));
     const missingAnyBins = always ? [] :
         (requiresAnyBins.length > 0 && !requiresAnyBins.some(b => hasBinarySync(b)) ? requiresAnyBins : []);
-    const missingEnv = always ? [] : requiresEnv.filter(e => !isEnvSatisfied(e, skillCfg, entry.metadata?.primaryEnv));
+    const missingEnv = always ? [] : requiresEnv.filter(e => !isEnvSatisfied(e));
     const isConfigPathSatisfied = (configPath) => {
         // configPath like "channels.discord.token" → check fullCfg.channels.discord.token
         const parts = configPath.split(".");
@@ -812,6 +976,30 @@ function buildSkillStatus(entry, cfg) {
         })),
     };
 }
+/**
+ * Fetch from ClawHub API.
+ * Base URL: OPENCLAW_CLAWHUB_URL or CLAWHUB_URL env, or https://clawhub.ai
+ * Mirrors gateway's fetchJson (clawhub-t8tftw_j.js).
+ */
+async function fetchClawHub(path, searchParams) {
+    const baseUrl = "https://clawhub.ai";
+    let url = `${baseUrl}${path}`;
+    if (searchParams && Object.keys(searchParams).length > 0) {
+        url += `?${new URLSearchParams(searchParams).toString()}`;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30000);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`ClawHub ${path} failed (${response.status}): ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 // ---------------------------------------------------------------------------
 // Skills method handlers (file-based, no gateway relay)
 // ---------------------------------------------------------------------------
@@ -926,7 +1114,7 @@ async function handleSkillsSearch(api, params) {
         const searchParams = { q: query };
         if (params.limit)
             searchParams.limit = String(params.limit);
-        const result = await fetchClawHub(resolveClawHubBaseUrl(), "/api/v1/search", searchParams);
+        const result = await fetchClawHub("/api/v1/search", searchParams);
         const results = result?.results ?? [];
         portalLog(api, "info", `skills.search: query="${query}" got ${results.length} results`);
         return { results };
@@ -936,6 +1124,23 @@ async function handleSkillsSearch(api, params) {
         return { results: [] };
     }
 }
+/**
+ * Extract a tar.gz archive into targetDir, auto-detecting whether to strip
+ * a single wrapping directory.
+ */
+async function extractTarGz(archivePath, targetDir) {
+    const execFileAsync = promisify(execFile);
+    const { stdout } = await execFileAsync("tar", ["tzf", archivePath]);
+    const entries = stdout.trim().split("\n").filter(Boolean);
+    const topDirs = new Set(entries.map(e => e.split("/")[0]));
+    const needsStrip = topDirs.size === 1 && entries.every(e => e.includes("/"));
+    if (needsStrip) {
+        await execFileAsync("tar", ["xzf", archivePath, "-C", targetDir, "--strip-components=1"]);
+    }
+    else {
+        await execFileAsync("tar", ["xzf", archivePath, "-C", targetDir]);
+    }
+}
 /**
  * skills.install — install a skill into an agent's workspace.
  *
@@ -964,7 +1169,17 @@ async function handleSkillsInstall(api, params) {
         // Download
         let archiveBytes;
         try {
-            archiveBytes = await downloadArchive(url);
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 120000);
+            try {
+                const response = await fetch(url, { signal: controller.signal });
+                if (!response.ok)
+                    throw new Error(`download failed (${response.status})`);
+                archiveBytes = new Uint8Array(await response.arrayBuffer());
+            }
+            finally {
+                clearTimeout(timer);
+            }
         }
         catch (err) {
             throw { code: 503, message: `skills.install: download failed: ${err.message}` };
@@ -1019,7 +1234,7 @@ async function handleSkillsInstall(api, params) {
             throw { code: 400, message: "slug (or name) is required for source=clawhub" };
         let detail;
         try {
-            detail = await fetchClawHub(resolveClawHubBaseUrl(), `/api/v1/skills/${encodeURIComponent(slug)}`);
+            detail = await fetchClawHub(`/api/v1/skills/${encodeURIComponent(slug)}`);
         }
         catch (err) {
             throw { code: 503, message: `skills.install: ClawHub fetch failed: ${err.message}` };
@@ -1032,9 +1247,19 @@ async function handleSkillsInstall(api, params) {
         let archiveBytes;
         try {
             const searchParams = { version };
-            const archiveUrl = resolveClawHubBaseUrl()
-                + `/api/v1/packages/${encodeURIComponent(slug)}/download?` + new URLSearchParams(searchParams);
-            archiveBytes = await downloadArchive(archiveUrl, 60000);
+            const archiveUrl = ("https://clawhub.ai"
+                + `/api/v1/packages/${encodeURIComponent(slug)}/download?` + new URLSearchParams(searchParams));
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 60000);
+            try {
+                const response = await fetch(archiveUrl, { signal: controller.signal });
+                if (!response.ok)
+                    throw new Error(`download failed (${response.status})`);
+                archiveBytes = new Uint8Array(await response.arrayBuffer());
+            }
+            finally {
+                clearTimeout(timer);
+            }
         }
         catch (err) {
             throw { code: 503, message: `skills.install: download failed: ${err.message}` };
@@ -1122,7 +1347,7 @@ async function handleSkillsSet(api, params) {
         throw { code: 500, message: `skills.set: failed to write config: ${err.message}` };
     }
     // Invalidate disk config cache
-    clearDiskConfigCache();
+    _diskConfigCache = null;
     portalLog(api, "info", `skills.set: skillKey=${skillKey} enabled=${enabled}`);
     return { ok: true, skillKey, enabled };
 }
@@ -1208,7 +1433,7 @@ async function handleAgentSkillsSet(api, params) {
     catch (err) {
         throw { code: 500, message: `agent.skills.set: failed to write config: ${err.message}` };
     }
-    clearDiskConfigCache();
+    _diskConfigCache = null;
     const resultSkills = agentEntry.skills ?? undefined;
     portalLog(api, "info", `agent.skills.set: agentId=${agentId} skill=${skillName} enabled=${enabled} skills=${JSON.stringify(resultSkills)}`);
     return { ok: true, agentId, skillKey: skillName, enabled, skills: resultSkills };
@@ -1254,10 +1479,30 @@ async function handleAgentModelSet(api, params) {
     catch (err) {
         throw { code: 500, message: `agent.model.set: failed to write config: ${err.message}` };
     }
-    clearDiskConfigCache();
+    _diskConfigCache = null;
     portalLog(api, "info", `agent.model.set: agentId=${agentId} model=${model}`);
     return { ok: true, agentId, model };
 }
+/**
+ * Resolve the path to the openclaw cron store file (jobs.json).
+ *
+ * Mirrors openclaw's own resolveCronStorePath / resolveConfigDir logic:
+ * 1. OPENCLAW_STATE_DIR env var → {stateDir}/cron/jobs.json
+ * 2. OPENCLAW_CONFIG_PATH env var → dirname(configPath)/cron/jobs.json
+ * 3. cfg.cron?.store (from full openclaw config) → resolved path
+ * 4. Default: ~/.openclaw/cron/jobs.json
+ */
+function resolveCronStorePath(api) {
+    const home = homedir() || "";
+    const expandHome = (p) => p.startsWith("~/") || p === "~" ? join(home, p.slice(2)) : p;
+    // cfg.cron?.store
+    const cfg = getConfig(api);
+    const cfgStore = String(cfg?.cron?.store ?? "").trim();
+    if (cfgStore)
+        return resolve(expandHome(cfgStore));
+    // Default
+    return join(home, ".openclaw", "cron", "jobs.json");
+}
 /**
  * cron.list — read jobs directly from the persisted cron store (jobs.json).
  *
@@ -1409,7 +1654,8 @@ async function handlePortalRequest(api, accountId, request) {
 // WebSocket connection management (unchanged logic)
 // ---------------------------------------------------------------------------
 function sendResponse(ws, response) {
-    if (ws.readyState === WebSocket.OPEN) {
+    // readyState 1 === OPEN for both native WebSocket and ws library
+    if (ws.readyState === 1) {
         ws.send(JSON.stringify(response));
     }
 }
@@ -1418,9 +1664,18 @@ function connectPortal(api, bridge) {
         return;
     const url = `${bridge.portalWsAddr}/${bridge.botId}`;
     portalLog(api, "info", `connecting to agent-portal: url=${url} botId=${bridge.botId} accountId=${bridge.accountId}`);
+    // Use `ws` library for wss:// to bypass undici globalDispatcher interference
+    const useWsLib = url.startsWith("wss://");
     let ws;
     try {
-        ws = new WebSocket(url);
+        if (useWsLib) {
+            const wsClient = new WsWebSocket(url);
+            // Wrap ws library instance to match WebSocket API used below
+            ws = wsClient;
+        }
+        else {
+            ws = new WebSocket(url);
+        }
     }
     catch (err) {
         portalLog(api, "error", `WebSocket constructor failed: ${err?.message ?? err}`);
@@ -1429,11 +1684,12 @@ function connectPortal(api, bridge) {
     }
     bridge.ws = ws;
     let reconnectAttempts = 0;
+    const READY_STATE_OPEN = useWsLib ? WsWebSocket.OPEN : WebSocket.OPEN;
     ws.addEventListener("open", () => {
         reconnectAttempts = 0;
         portalLog(api, "info", `connected to agent-portal: botId=${bridge.botId}`);
         bridge.heartbeatTimer = setInterval(() => {
-            if (ws.readyState === WebSocket.OPEN) {
+            if (ws.readyState === READY_STATE_OPEN) {
                 const pingMsg = { id: `ping-${Date.now()}`, method: "ping", params: {} };
                 ws.send(JSON.stringify(pingMsg));
                 portalLog(api, "debug", `heartbeat ping sent: botId=${bridge.botId}`);
@@ -1442,14 +1698,19 @@ function connectPortal(api, bridge) {
     });
     ws.addEventListener("message", async (event) => {
         let raw;
-        if (typeof event.data === "string") {
-            raw = event.data;
+        // ws library: event.data is Buffer/string; native: event.data is string/ArrayBuffer
+        const data = event.data ?? event;
+        if (typeof data === "string") {
+            raw = data;
+        }
+        else if (data instanceof ArrayBuffer) {
+            raw = new TextDecoder().decode(data);
         }
-        else if (event.data instanceof ArrayBuffer) {
-            raw = new TextDecoder().decode(event.data);
+        else if (Buffer.isBuffer(data)) {
+            raw = data.toString("utf-8");
         }
         else {
-            portalLog(api, "warn", `unexpected message data type: ${typeof event.data}`);
+            portalLog(api, "warn", `unexpected message data type: ${typeof data}`);
             return;
         }
         let request;
@@ -1469,7 +1730,7 @@ function connectPortal(api, bridge) {
         portalLog(api, "debug", `response sent: id=${request.id} method=${request.method} ok=${!response.error}`);
     });
     ws.addEventListener("close", (event) => {
-        portalLog(api, "info", `disconnected from agent-portal: botId=${bridge.botId} code=${event.code} reason=${event.reason || "none"}`);
+        portalLog(api, "info", `disconnected from agent-portal: botId=${bridge.botId} code=${event.code ?? 1006} reason=${event.reason || "none"}`);
         clearHeartbeat(bridge);
         bridge.ws = null;
         if (!bridge.stopped) {

package/dist/setup.js

@@ -19,15 +19,15 @@ export async function runOpenIMSetup() {
     clackIntro("OpenIM Channel Setup Wizard");
     const token = guardCancel(await clackText({
         message: "Enter OpenIM Access Token",
-        initialValue: process.env.OPENIM_TOKEN || "",
+        initialValue: "",
     }));
     const wsAddr = guardCancel(await clackText({
         message: "Enter OpenIM WebSocket endpoint",
-        initialValue: process.env.OPENIM_WS_ADDR || "ws://127.0.0.1:10001",
+        initialValue: "ws://127.0.0.1:10001",
     }));
     const apiAddr = guardCancel(await clackText({
         message: "Enter OpenIM REST API endpoint",
-        initialValue: process.env.OPENIM_API_ADDR || "http://127.0.0.1:10002",
+        initialValue: "http://127.0.0.1:10002",
     }));
     const trimmedToken = String(token).trim();
     const trimmedWsAddr = String(wsAddr).trim();

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-channel",
   "name": "OpenIM Channel",
-  "version": "0.3.6",
+  "version": "0.3.9",
   "description": "OpenIM protocol channel for OpenClaw",
   "author": "ZeyiY",
   "channels": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeyiy/openclaw-channel",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "OpenIM channel plugin for OpenClaw gateway (fork of @openim/openclaw-channel)",
   "license": "AGPL-3.0-only",
   "author": "ZeyiY",
@@ -49,7 +49,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@openim/client-sdk": "^3.8.3"
+    "@openim/client-sdk": "^3.8.3",
+    "@types/ws": "^8.18.1",
+    "ws": "^8.20.0"
   },
   "peerDependencies": {
     "clawdbot": "*",

package/dist/network.d.ts

@@ -1,9 +0,0 @@
-/**
- * Network utilities — all fetch / HTTP calls live here.
- *
- * No process.env access in this file. Base URLs and configuration
- * are passed in as parameters by the caller.
- */
-export declare function fetchClawHub(baseUrl: string, path: string, searchParams?: Record<string, string>): Promise<unknown>;
-export declare function downloadArchive(url: string, timeoutMs?: number): Promise<Uint8Array>;
-export declare function extractTarGz(archivePath: string, targetDir: string): Promise<void>;

package/dist/network.js

@@ -1,61 +0,0 @@
-/**
- * Network utilities — all fetch / HTTP calls live here.
- *
- * No process.env access in this file. Base URLs and configuration
- * are passed in as parameters by the caller.
- */
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-// ---------------------------------------------------------------------------
-// ClawHub API
-// ---------------------------------------------------------------------------
-export async function fetchClawHub(baseUrl, path, searchParams) {
-    let url = `${baseUrl}${path}`;
-    if (searchParams && Object.keys(searchParams).length > 0) {
-        url += `?${new URLSearchParams(searchParams).toString()}`;
-    }
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 30000);
-    try {
-        const response = await fetch(url, { signal: controller.signal });
-        if (!response.ok) {
-            throw new Error(`ClawHub ${path} failed (${response.status}): ${response.statusText}`);
-        }
-        return await response.json();
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-// ---------------------------------------------------------------------------
-// Archive download
-// ---------------------------------------------------------------------------
-export async function downloadArchive(url, timeoutMs = 120000) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const response = await fetch(url, { signal: controller.signal });
-        if (!response.ok)
-            throw new Error(`download failed (${response.status})`);
-        return new Uint8Array(await response.arrayBuffer());
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-// ---------------------------------------------------------------------------
-// Tar extraction
-// ---------------------------------------------------------------------------
-export async function extractTarGz(archivePath, targetDir) {
-    const execFileAsync = promisify(execFile);
-    const { stdout } = await execFileAsync("tar", ["tzf", archivePath]);
-    const entries = stdout.trim().split("\n").filter(Boolean);
-    const topDirs = new Set(entries.map(e => e.split("/")[0]));
-    const needsStrip = topDirs.size === 1 && entries.every(e => e.includes("/"));
-    if (needsStrip) {
-        await execFileAsync("tar", ["xzf", archivePath, "-C", targetDir, "--strip-components=1"]);
-    }
-    else {
-        await execFileAsync("tar", ["xzf", archivePath, "-C", targetDir]);
-    }
-}

package/dist/paths.d.ts

@@ -1,22 +0,0 @@
-/**
- * Path resolution & environment access utilities.
- *
- * All process.env reads are isolated here so that portal.ts (which has network
- * fetch calls) never touches process.env directly — avoiding the
- * "env access + network send" pattern that plugin security scanners flag.
- */
-export declare function normalizeAgentId(value: string): string;
-export declare function resolveDefaultAgentId(cfg: any): string;
-/** Expand leading ~ to $HOME, then resolve to absolute path. */
-export declare function resolveUserPath(p: string): string;
-export declare function resolveAgentWorkspaceDir(cfg: any, agentId: string): string;
-export declare function isPathSafe(workspaceRoot: string, targetPath: string): boolean;
-export declare function resolveStateDir(): string;
-export declare function resolveOpenClawConfigPath(): string;
-export declare function hasBinarySync(bin: string): boolean;
-export declare function resolveBundledSkillsDir(): string | undefined;
-export declare function resolveCronStorePath(api: any): string;
-export declare function resolveClawHubBaseUrl(): string;
-export declare function loadFullConfig(): any;
-export declare function clearDiskConfigCache(): void;
-export declare function isEnvSatisfied(name: string, skillCfg: any, primaryEnv?: string): boolean;