@ynhcj/xiaoyi-channel 1.1.27 → 1.1.29

package/dist/src/channel.js

@@ -2,9 +2,15 @@ import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./conf
 import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
-import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { getCurrentSessionContext, registerSession } from "./tools/session-manager.js";
 import { createAllTools } from "./tools/create-all-tools.js";
 import { logger } from "./utils/logger.js";
+/**
+ * Prefix used for synthetic sessionIds created during cron-triggered tool
+ * execution.  `sendCommand()` checks this prefix to route commands through
+ * the push channel instead of the (non-existent) WebSocket session.
+ */
+const CRON_SESSION_PREFIX = "cron-";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -43,11 +49,59 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    agentTools: () => {
-        const ctx = getCurrentSessionContext();
+    /**
+     * Provide channel-specific agent tools.
+     *
+     * Two execution contexts are supported:
+     *
+     *  1. **Normal (WebSocket) session** – `getCurrentSessionContext()` returns
+     *     a context that was registered by bot.ts during message processing.
+     *     Tools send commands through the WebSocket and listen for responses.
+     *
+     *  2. **Cron / scheduled-task session** – openclaw's cron runner calls
+     *     `agentTools({ cfg })` without an active WebSocket session.  When no
+     *     session context exists but `cfg` is provided, we create a synthetic
+     *     "cron session" with `isCron: true` and a `cron-`-prefixed sessionId.
+     *     `sendCommand()` detects this prefix and routes commands through the
+     *     push channel.  Response listening (WebSocket events) works unchanged
+     *     because the gateway WebSocket connection is always active.
+     */
+    agentTools: (params) => {
+        let ctx = getCurrentSessionContext();
+        // ── Cron / non-session fallback ──────────────────────────────
+        // When no active xy WebSocket session exists but the openclaw cfg
+        // is provided (framework calls agentTools({ cfg })), create a
+        // synthetic "cron session".  This enables cron-triggered agent
+        // turns and cross-channel tool calls to use xiaoyi tools via the
+        // push channel.  sendCommand() detects the "cron-" sessionId
+        // prefix and routes commands through push instead of WebSocket.
+        if (!ctx && params?.cfg) {
+            try {
+                const config = resolveXYConfig(params.cfg);
+                const cronId = `${CRON_SESSION_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+                ctx = {
+                    config,
+                    sessionId: cronId,
+                    taskId: cronId,
+                    messageId: cronId,
+                    agentId: "default",
+                    isCron: true,
+                };
+                // Register so getCurrentSessionContext() fallback can find it
+                registerSession(`__cron__${cronId}`, ctx);
+                logger.log(`[CRON-TOOLS] Created cron session context: ${cronId}`);
+            }
+            catch (err) {
+                logger.error("[CRON-TOOLS] Failed to create cron context:", err);
+            }
+        }
+        if (!ctx) {
+            logger.log("[CREATE-ALL-TOOLS] no session context, returning empty tools list");
+            return [];
+        }
         const allTools = createAllTools(ctx);
-        const filtered = filterToolsByDevice(allTools, ctx?.deviceType);
-        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
+        const filtered = filterToolsByDevice(allTools, ctx.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {

package/dist/src/client.js

@@ -24,10 +24,10 @@ export function getXYWebSocketManager(config, runtime) {
         return cached;
     }
     // Create new manager
-    logger.log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
+    logger.log(`[WS-MANAGER-CACHE] Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
     cached = new XYWebSocketManager(config, runtime);
     wsManagerCache.set(cacheKey, cached);
-    logger.log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
+    logger.log(`[WS-MANAGER-CACHE] Total managers after creation: ${wsManagerCache.size}`);
     return cached;
 }
 /**
@@ -38,13 +38,13 @@ export function removeXYWebSocketManager(config) {
     const cacheKey = `${config.apiKey}-${config.agentId}`;
     const manager = wsManagerCache.get(cacheKey);
     if (manager) {
-        logger.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        logger.log(`[WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
         manager.disconnect();
         wsManagerCache.delete(cacheKey);
-        logger.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+        logger.log(`[WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
     }
     else {
-        logger.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+        logger.log(`[WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
     }
 }
 /**
@@ -68,35 +68,25 @@ export function getCachedManagerCount() {
  * Helps identify connection issues and orphan connections.
  */
 export function diagnoseAllManagers() {
-    logger.log(`Total cached managers: ${wsManagerCache.size}`);
+    logger.log(`[DIAG] Total cached managers: ${wsManagerCache.size}`);
     if (wsManagerCache.size === 0) {
-        logger.log("ℹ️  No managers in cache");
+        logger.log("[DIAG] No managers in cache");
         return;
     }
     let orphanCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
-        logger.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
-        // Connection
-        logger.log(`   🔌 Connection:`);
-        logger.log(`      - Exists: ${diag.connection.exists}`);
-        logger.log(`      - ReadyState: ${diag.connection.readyState}`);
-        logger.log(`      - State connected/ready: ${diag.connection.stateConnected}/${diag.connection.stateReady}`);
-        logger.log(`      - Reconnect attempts: ${diag.connection.reconnectAttempts}`);
-        logger.log(`      - Listeners on WebSocket: ${diag.connection.listenerCount}`);
-        logger.log(`      - Heartbeat active: ${diag.connection.heartbeatActive}`);
-        logger.log(`      - Has reconnect timer: ${diag.connection.hasReconnectTimer}`);
+        logger.log(`[DIAG] Manager ${key} — event listeners: ${diag.totalEventListeners} | Connection: exists=${diag.connection.exists}, readyState=${diag.connection.readyState}, stateConnected=${diag.connection.stateConnected}/${diag.connection.stateReady}, reconnectAttempts=${diag.connection.reconnectAttempts}, wsListeners=${diag.connection.listenerCount}, heartbeatActive=${diag.connection.heartbeatActive}, hasReconnectTimer=${diag.connection.hasReconnectTimer}`);
         if (diag.connection.isOrphan) {
-            logger.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            logger.log(`[DIAG] ORPHAN CONNECTION DETECTED on manager: ${key}`);
             orphanCount++;
         }
     });
     if (orphanCount > 0) {
-        logger.log(`⚠️  Total orphan connections found: ${orphanCount}`);
-        logger.log(`💡 Suggestion: These connections should be cleaned up`);
+        logger.log(`[DIAG] Total orphan connections found: ${orphanCount} — these connections should be cleaned up`);
     }
     else {
-        logger.log(`✅ No orphan connections found`);
+        logger.log("[DIAG] No orphan connections found");
     }
 }
 /**
@@ -108,13 +98,13 @@ export function cleanupOrphanConnections() {
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
         if (diag.connection.isOrphan) {
-            logger.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
+            logger.log(`[CLEANUP] Cleaning up orphan connections in manager: ${key}`);
             manager.disconnect();
             cleanedCount++;
         }
     });
     if (cleanedCount > 0) {
-        logger.log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
+        logger.log(`[CLEANUP] Cleaned up ${cleanedCount} manager(s) with orphan connections`);
     }
     return cleanedCount;
 }

package/dist/src/cron-query-handler.d.ts

@@ -1,17 +1,7 @@
-export type CronQueryAction = "list" | "status" | "runs" | "add" | "update" | "remove" | "run";
-export interface CronQueryEventContext {
-    action: CronQueryAction;
-    jobId?: string;
-    params?: Record<string, unknown>;
-    /** Original A2A message fields for routing the response. */
-    sessionId?: string;
-    taskId?: string;
-    messageId?: string;
-}
 /**
  * Handle a cron-query-event.
  *
  * Calls the Gateway cron RPC and sends the result back through sendCommand
  * as a System.CronQuery command with the full result object in payload.ans.
  */
-export declare function handleCronQueryEvent(context: CronQueryEventContext, cfg?: unknown): Promise<void>;
+export declare function handleCronQueryEvent(context: any, cfg: any): Promise<void>;

package/dist/src/cron-query-handler.js

@@ -4,9 +4,12 @@
 // result back to the client via sendCommand as a System.CronQuery
 // command with the result in payload.ans.
 import { callGatewayTool } from "openclaw/plugin-sdk/agent-harness-runtime";
+import * as os from "os";
 import { sendCommand } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
 import { logger } from "./utils/logger.js";
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
 const GATEWAY_TIMEOUT_MS = 60_000;
 /**
  * Handle a cron-query-event.
@@ -16,7 +19,8 @@ const GATEWAY_TIMEOUT_MS = 60_000;
  */
 export async function handleCronQueryEvent(context, cfg) {
     const { action, jobId, params, sessionId, taskId, messageId } = context;
-    logger.log(`[CRON-QUERY] Received event: action=${action}, jobId=${jobId ?? "(none)"}`);
+    const log = logger.withContext(sessionId ?? "", taskId ?? "");
+    log.log(`[CRON-QUERY] Received event: action=${action}, jobId=${jobId ?? "(none)"}`);
     let result;
     let error;
     try {
@@ -54,19 +58,22 @@ export async function handleCronQueryEvent(context, cfg) {
                     ...params,
                 });
                 break;
+            case "queryTimeList":
+                result = await queryTimeListLocal();
+                break;
             default:
                 error = `Unknown action: ${context.action}`;
-                logger.error(`[CRON-QUERY] ${error}`);
+                log.error(`[CRON-QUERY] ${error}`);
                 result = { error };
         }
     }
     catch (err) {
         error = err instanceof Error ? err.message : String(err);
-        logger.error(`[CRON-QUERY] RPC call failed for action=${action}:`, err);
+        log.error(`[CRON-QUERY] RPC call failed for action=${action}:`, err);
         result = { error };
     }
     // Log the result
-    logger.log(`[CRON-QUERY] RPC result for action=${action}: ${JSON.stringify(result, null, 2)}`);
+    log.log(`[CRON-QUERY] RPC result for action=${action}: ${JSON.stringify(result, null, 2)}`);
     // Send result back via sendCommand as System.CronQuery with payload.ans
     if (cfg && sessionId && taskId && messageId) {
         try {
@@ -87,15 +94,96 @@ export async function handleCronQueryEvent(context, cfg) {
                 taskId,
                 messageId,
                 command,
-                final: true,
+                final: sessionId.toLowerCase().endsWith("cronquery"),
             });
-            logger.log(`[CRON-QUERY] Sent response via sendCommand, action=${action}`);
+            log.log(`[CRON-QUERY] Sent response via sendCommand, action=${action}`);
         }
         catch (sendErr) {
-            logger.error(`[CRON-QUERY] Failed to send response via sendCommand:`, sendErr);
+            log.error(`[CRON-QUERY] Failed to send response via sendCommand:`, sendErr);
         }
     }
     else {
-        logger.warn(`[CRON-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
+        log.warn(`[CRON-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
+    }
+}
+/**
+ * Read local cron folder directly (bypassing openclaw RPC) and return
+ * run records from the last 7 days, grouped by date and sorted by time.
+ *
+ * Data sources:
+ *   - state/cron/jobs.json   → job id → name mapping
+ *   - state/cron/runs/*.jsonl → run records (one JSON per line)
+ *
+ * Return format:
+ *   [ { "YYYY-MM-DD": [ { run record with .name }, ... ] }, ... ]
+ */
+async function queryTimeListLocal() {
+    const cronDir = join(os.homedir(), ".openclaw", "cron");
+    const jobsPath = join(cronDir, "jobs.json");
+    const runsDir = join(cronDir, "runs");
+    // 1. Build jobId → name map from jobs.json
+    const jobNameMap = {};
+    try {
+        const jobsRaw = readFileSync(jobsPath, "utf-8");
+        const jobsData = JSON.parse(jobsRaw);
+        for (const job of jobsData.jobs || []) {
+            jobNameMap[job.id] = job.name || job.id;
+        }
+    }
+    catch (err) {
+        logger.error(`[CRON-QUERY] Failed to read jobs.json: ${err.message}`);
+    }
+    // 2. Read all run files, collect runs within last 7 days
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const allRuns = [];
+    let files = [];
+    try {
+        files = readdirSync(runsDir);
+    }
+    catch {
+        files = [];
+    }
+    for (const file of files) {
+        if (!file.endsWith(".jsonl"))
+            continue;
+        try {
+            const content = readFileSync(join(runsDir, file), "utf-8");
+            const lines = content.trim().split("\n");
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const run = JSON.parse(line);
+                    if (run.ts && run.ts >= sevenDaysAgo) {
+                        run.name = jobNameMap[run.jobId] || run.jobId || "";
+                        allRuns.push(run);
+                    }
+                }
+                catch {
+                    // skip malformed line
+                }
+            }
+        }
+        catch (err) {
+            logger.error(`[CRON-QUERY] Failed to read run file ${file}: ${err.message}`);
+        }
+    }
+    // 3. Sort by ts ascending
+    allRuns.sort((a, b) => a.ts - b.ts);
+    // 4. Group by date (YYYY-MM-DD in local time)
+    const grouped = new Map();
+    for (const run of allRuns) {
+        const d = new Date(run.ts);
+        const label = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+        if (!grouped.has(label)) {
+            grouped.set(label, []);
+        }
+        grouped.get(label).push(run);
+    }
+    // 5. Convert to ordered array of single-key objects
+    const result = [];
+    for (const [date, runs] of grouped) {
+        result.push({ [date]: runs });
     }
+    return result;
 }

package/dist/src/cspl/call_api.d.ts

@@ -1,2 +1,2 @@
 import { ApiResponse } from './constants.js';
-export declare function callApi(questionText: string, api: any, sessionId: string): Promise<ApiResponse>;
+export declare function callApi(questionText: string, api: any, sessionId: string, action: string): Promise<ApiResponse>;

package/dist/src/cspl/call_api.js

@@ -78,13 +78,13 @@ function handleResponse(res, resolve, reject) {
         }
     });
 }
-export async function callApi(questionText, api, sessionId) {
+export async function callApi(questionText, api, sessionId, action) {
     const config = getConfig(api);
     const headersForCelia = buildHeadersForCelia(config, sessionId);
     const payload = {
         questionText: questionText,
         textSource: config.textSource,
-        action: config.action,
+        action: action,
         extra: `${JSON.stringify({ userId: config.uid })}`
     };
     const httpBody = JSON.stringify(payload);

package/dist/src/cspl/config.d.ts

@@ -1,11 +1,11 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import type { XYChannelConfig } from "../types.js";
+import { HttpHeaders } from './constants.js';
 export interface ApiConfig {
     url: string;
     timeout: number;
 }
-export interface CsplConfig {
+export interface Config {
     api: ApiConfig;
+    headers?: HttpHeaders;
     uid: string;
     apiKey: string;
     skillId: string;
@@ -13,17 +13,4 @@ export interface CsplConfig {
     textSource: string;
     action: string;
 }
-/**
- * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
- * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
- *
- * Accepts either ClawdbotConfig (legacy after_tool_call path) or
- * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
- * after the first successful call so subsequent calls can omit the arg.
- */
-export declare function getCsplConfig(cfg?: ClawdbotConfig): CsplConfig;
-/**
- * Initialize CSPL config from an already-resolved XYChannelConfig.
- * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
- */
-export declare function initCsplConfigFromXYConfig(xyConfig: XYChannelConfig): CsplConfig;
+export declare function getConfig(api: any): Config;

package/dist/src/cspl/config.js

@@ -1,80 +1,110 @@
-// CSPL Hook 配置管理
-// uid 和 apiKey 复用 XYChannelConfig，skillId 写死在常量中
-import { resolveXYConfig } from "../config.js";
-import { CSPL_STATIC_CONFIG, API_URL_SUFFIX, ENV_FILE_PATH } from "./constants.js";
-import fs from "node:fs";
-import { logger } from "../utils/logger.js";
+/*
+ * 版权所有 (c) 华为技术有限公司 2026-2026
+ */
+import fs from 'fs';
+import path from 'path';
+import { CONFIG_FILE_NAME, ENV_FILE_PATH, REQUIRED_ENV_VARS } from './constants.js';
+import { logger } from '../utils/logger.js';
 let cachedConfig = null;
-function readServiceUrl() {
+function readEnvFile() {
     if (!fs.existsSync(ENV_FILE_PATH)) {
-        throw new Error(`[SENTINEL HOOK] Environment file not found: ${ENV_FILE_PATH}`);
+        throw new Error(`Environment file not found.`);
+    }
+    let envData;
+    try {
+        envData = fs.readFileSync(ENV_FILE_PATH, 'utf-8');
     }
-    const envData = fs.readFileSync(ENV_FILE_PATH, "utf-8");
-    for (const line of envData.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#"))
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to read environment file. Error: ${err.message}`);
+    }
+    const env = {};
+    const lines = envData.split('\n');
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) {
             continue;
-        const eqIdx = trimmed.indexOf("=");
-        if (eqIdx === -1)
+        }
+        const firstEqualIndex = trimmedLine.indexOf('=');
+        if (firstEqualIndex === -1) {
             continue;
-        const key = trimmed.substring(0, eqIdx).trim();
-        const value = trimmed.substring(eqIdx + 1).trim();
-        if (key === "SERVICE_URL" && value)
-            return value;
+        }
+        const key = trimmedLine.substring(0, firstEqualIndex).trim();
+        const value = trimmedLine.substring(firstEqualIndex + 1).trim();
+        if (key && REQUIRED_ENV_VARS.includes(key)) {
+            env[key] = value;
+        }
     }
-    throw new Error("[SENTINEL HOOK] Missing SERVICE_URL in env file");
+    return env;
 }
-/**
- * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
- * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
- *
- * Accepts either ClawdbotConfig (legacy after_tool_call path) or
- * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
- * after the first successful call so subsequent calls can omit the arg.
- */
-export function getCsplConfig(cfg) {
-    if (cachedConfig)
+export function getConfig(api) {
+    if (cachedConfig) {
         return cachedConfig;
-    if (!cfg) {
-        throw new Error("[SENTINEL HOOK] CSPL config not initialized: pass ClawdbotConfig on first call");
-    }
-    const xyConfig = resolveXYConfig(cfg);
-    const serviceUrl = readServiceUrl();
-    cachedConfig = {
-        api: {
-            url: `${serviceUrl}${API_URL_SUFFIX}`,
-            timeout: CSPL_STATIC_CONFIG.api.timeout,
-        },
-        uid: xyConfig.uid,
-        apiKey: xyConfig.apiKey,
-        skillId: CSPL_STATIC_CONFIG.skillId,
-        requestFrom: CSPL_STATIC_CONFIG.requestFrom,
-        textSource: CSPL_STATIC_CONFIG.textSource,
-        action: CSPL_STATIC_CONFIG.action,
-    };
-    logger.log("[SENTINEL HOOK] Config loaded (uid/apiKey from XYChannelConfig)");
-    return cachedConfig;
-}
-/**
- * Initialize CSPL config from an already-resolved XYChannelConfig.
- * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
- */
-export function initCsplConfigFromXYConfig(xyConfig) {
-    if (cachedConfig)
-        return cachedConfig;
-    const serviceUrl = readServiceUrl();
-    cachedConfig = {
-        api: {
-            url: `${serviceUrl}${API_URL_SUFFIX}`,
-            timeout: CSPL_STATIC_CONFIG.api.timeout,
-        },
-        uid: xyConfig.uid,
-        apiKey: xyConfig.apiKey,
-        skillId: CSPL_STATIC_CONFIG.skillId,
-        requestFrom: CSPL_STATIC_CONFIG.requestFrom,
-        textSource: CSPL_STATIC_CONFIG.textSource,
-        action: CSPL_STATIC_CONFIG.action,
-    };
-    logger.log("[SENTINEL HOOK] Config loaded via XYChannelConfig");
+    }
+    const configPath = path.join(__dirname, CONFIG_FILE_NAME);
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${CONFIG_FILE_NAME}`);
+    }
+    let configData;
+    try {
+        configData = fs.readFileSync(configPath, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read config file: ${CONFIG_FILE_NAME}.`);
+    }
+    let parsedConfig;
+    try {
+        parsedConfig = JSON.parse(configData);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse config file: ${CONFIG_FILE_NAME}.`);
+    }
+    if (!parsedConfig || typeof parsedConfig !== 'object') {
+        throw new Error(`Invalid config structure: ${CONFIG_FILE_NAME}. Expected an object.`);
+    }
+    const config = parsedConfig;
+    if (!config.api || typeof config.api !== 'object') {
+        throw new Error(`Invalid config: missing or invalid 'api' section in ${CONFIG_FILE_NAME}`);
+    }
+    if (!config.api.timeout || typeof config.api.timeout !== 'number') {
+        throw new Error(`Invalid config: missing or invalid 'api.timeout' in ${CONFIG_FILE_NAME}`);
+    }
+    if (!config.skillId || typeof config.skillId !== 'string') {
+        throw new Error(`Invalid config: missing or invalid 'skillId' in ${CONFIG_FILE_NAME}`);
+    }
+    if (!config.requestFrom || typeof config.requestFrom !== 'string') {
+        throw new Error(`Invalid config: missing or invalid 'requestFrom' in ${CONFIG_FILE_NAME}`);
+    }
+    if (!config.textSource || typeof config.textSource !== 'string') {
+        throw new Error(`Invalid config: missing or invalid 'textSource' in ${CONFIG_FILE_NAME}`);
+    }
+    if (!config.action || typeof config.action !== 'string') {
+        throw new Error(`Invalid config: missing or invalid 'action' in ${CONFIG_FILE_NAME}`);
+    }
+    let env;
+    try {
+        env = readEnvFile();
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to load environment variables from env files: ${err.message}`);
+    }
+    const personalApiKey = env['PERSONAL-API-KEY'];
+    if (!personalApiKey || typeof personalApiKey !== 'string' || personalApiKey.trim() === '') {
+        throw new Error(`Missing or empty 'PERSONAL-API-KEY' in env files`);
+    }
+    const personalUid = env['PERSONAL-UID'];
+    if (!personalUid || typeof personalUid !== 'string' || personalUid.trim() === '') {
+        throw new Error(`Missing or empty 'PERSONAL-UID' in env files`);
+    }
+    const serviceUrl = env['SERVICE_URL'];
+    if (!serviceUrl || typeof serviceUrl !== 'string' || serviceUrl.trim() === '') {
+        throw new Error(`Missing or empty 'SERVICE_URL' in env files`);
+    }
+    config.apiKey = personalApiKey.trim();
+    config.uid = personalUid.trim();
+    config.api.url = serviceUrl.trim();
+    cachedConfig = config;
+    logger.log(`[SENTINEL HOOK] Config loaded successfully`);
     return cachedConfig;
 }