@ynhcj/xiaoyi-channel 0.0.217-next → 0.0.219-next

package/dist/index.js

@@ -3,6 +3,7 @@ import { xiaoyiProvider } from "./src/provider.js";
 import { xiaoyiCompactionProvider } from "./src/compaction-provider.js";
 import { xyPlugin } from "./src/channel.js";
 import registerSentinelHook from "./src/cspl/sentinel_hook.js";
+import registerSkillScopeHook from "./src/cspl/skill_scope_hook.js";
 import { setXYRuntime } from "./src/runtime.js";
 import { markCronToolCall, clearCronToolCall, getCurrentSessionContext } from "./src/tools/session-manager.js";
 import { configManager } from "./src/utils/config-manager.js";
@@ -14,6 +15,7 @@ import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
 import { registerCLIHook } from "./src/tools/hmos-cli.js";
 import { recoverCronState } from "./src/cron-recovery.js";
 import { writeSkillUsage } from "./src/utils/skills-logger.js";
+import { markSubagentSpawned, markSubagentEnded, getCachedXYConfig, } from "./src/subagent-wait-state.js";
 import { logger } from "./src/utils/logger.js";
 /**
  * Parse a file path string to detect if it refers to a SKILL.md file within
@@ -274,7 +276,55 @@ function registerCronRecoveryHook(api) {
         logger.log(`${logTag} ═══════════════════════════════════════════`);
     });
 }
+function registerSubagentHooks(api) {
+    // subagent_spawned: fires after a subagent run is successfully registered.
+    // We increment the expected completion count so that onIdle knows to wait.
+    api.on("subagent_spawned", async (_event, ctx) => {
+        const requesterSessionKey = ctx?.requesterSessionKey;
+        if (!requesterSessionKey)
+            return;
+        const count = markSubagentSpawned(requesterSessionKey);
+        if (count > 0) {
+            logger.log(`[XY-SUBAGENT] spawned, requesterSessionKey=${requesterSessionKey.slice(0, 30)}, expected=${count}`);
+        }
+    });
+    // subagent_ended: fires when a subagent run terminates (complete/error/killed).
+    // This is the PRIMARY delivery tracking mechanism. When all expected
+    // subagents have ended and parent has settled, we finalize the A2A session.
+    api.on("subagent_ended", async (event, ctx) => {
+        try {
+            const requesterSessionKey = ctx?.requesterSessionKey;
+            if (!requesterSessionKey) {
+                logger.log(`[XY-SUBAGENT-END] no requesterSessionKey in ctx`);
+                return;
+            }
+            const transition = markSubagentEnded(requesterSessionKey);
+            logger.log(`[XY-SUBAGENT-END] ended, targetSessionKey=${event?.targetSessionKey?.slice(0, 30)}, outcome=${event?.outcome}, complete=${transition?.isComplete ?? false}, shouldFinalize=${transition?.shouldFinalize ?? false}, transition=${!!transition}`);
+            if (transition?.shouldFinalize) {
+                logger.log(`[XY-SUBAGENT-END] Starting finalization...`);
+                const config = getCachedXYConfig();
+                if (!config) {
+                    logger.error(`[XY-SUBAGENT-END] No cached XY config, cannot deliver final result`);
+                    return;
+                }
+                const { deliverSubagentFinalResult } = await import("./src/outbound.js");
+                logger.log(`[XY-SUBAGENT-END] Using cached XY config`);
+                await deliverSubagentFinalResult({
+                    config: config,
+                    state: transition.state,
+                    reason: "all-subagents-ended-after-parent-settled",
+                });
+                logger.log(`[XY-SUBAGENT-END] Finalized A2A session after all subagents ended`);
+            }
+        }
+        catch (err) {
+            logger.error(`[XY-SUBAGENT-END] Error in subagent_ended hook:`, err);
+        }
+    });
+}
 function registerFullHooks(api) {
+    // SUBAGENT HOOKS: track subagent spawn/end lifecycle for session keep-alive
+    registerSubagentHooks(api);
     // SKILL RETRIEVER HOOK: before_prompt_build hook
     const pluginConfig = api.pluginConfig || {};
     const skillRetrieverConfig = normalizeToolRetrieverConfig({
@@ -320,6 +370,8 @@ const plugin = definePluginEntry({
             registerFullHooks(api);
             // CSPL sentinel hook: before_tool_call + after_tool_call security scanning
             registerSentinelHook(api);
+            // CSPL skill scope hook: before_install security scanning
+            registerSkillScopeHook(api);
             // Cron detection hook: marks toolCallIds from cron sessions
             registerCronDetectionHook(api);
             // CLI exec hook: intercepts built-in exec for HarmonyOS CLI skill tools

package/dist/src/bot.js

@@ -17,6 +17,7 @@ import { toolCallNudgeManager } from "./utils/tool-call-nudge-manager.js";
 import { setCsplSteerContext } from "./cspl/steer-context.js";
 import { resolveActiveEmbeddedRunSessionId, queueAgentHarnessMessage, } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { registerTaskId, decrementTaskIdRef, hasActiveTask, } from "./task-manager.js";
+import { registerSessionKeyMapping, getWaitState, hasWaitState, markParentSettled, cacheXYConfig, } from "./subagent-wait-state.js";
 import { logger } from "./utils/logger.js";
 /**
  * Handle an incoming A2A message.
@@ -165,6 +166,7 @@ export async function handleXYMessage(params) {
         const runCrossTaskContext = extractRunCrossTaskContext(parsed.parts);
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
+        cacheXYConfig(config);
         // ✅ Resolve agent route (following feishu pattern)
         // accountId is "default" for XY (single account mode)
         // Use sessionId as peer.id to ensure all messages in the same session share context
@@ -178,6 +180,16 @@ export async function handleXYMessage(params) {
             },
         });
         log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
+        // Register sessionKey→A2A sessionId mapping for subagent hook translation.
+        // Hooks receive openclaw sessionKey (e.g. "agent:main:direct:xxx") but
+        // xy_channel operates on A2A sessionId. This bridge lets subagent_spawned/
+        // subagent_ended hooks find the correct wait state.
+        // IMPORTANT: Only register on the FIRST message. Steer messages have a
+        // different taskId — overwriting the mapping would break subagent wait
+        // state tracking for the original message's subagents.
+        if (!isUpdate) {
+            registerSessionKeyMapping(route.sessionKey, parsed.sessionId, parsed.taskId, parsed.messageId);
+        }
         // Check for ACP runtime binding on this A2A conversation
         const runtimeRoute = resolveRuntimeConversationBindingRoute({
             route,
@@ -242,20 +254,18 @@ export async function handleXYMessage(params) {
                     log.error(`[BOT] Failed to patch session model override:`, patchErr);
                 }
             }
-            // 🔑 发送初始状态更新（仅首条消息，steer 不重复发送）
-            if (!isUpdate) {
-                log.log(`[BOT] Sending initial status update`);
-                void sendStatusUpdate({
-                    config,
-                    sessionId: parsed.sessionId,
-                    taskId: parsed.taskId,
-                    messageId: parsed.messageId,
-                    text: "任务正在处理中，请稍候~",
-                    state: "working",
-                }).catch((err) => {
-                    log.error(`Failed to send initial status update:`, err);
-                });
-            }
+            // 🔑 发送初始状态更新
+            log.log(`[BOT] Sending initial status update`);
+            void sendStatusUpdate({
+                config,
+                sessionId: parsed.sessionId,
+                taskId: parsed.taskId,
+                messageId: parsed.messageId,
+                text: "任务正在处理中，请稍候~",
+                state: "working",
+            }).catch((err) => {
+                log.error(`Failed to send initial status update:`, err);
+            });
         }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
@@ -281,10 +291,8 @@ export async function handleXYMessage(params) {
             }
         }
         // ── Build message and dispatch via auto-reply pipeline ──────────
-        // OpenClaw's auto-reply pipeline (src/auto-reply/reply/agent-runner.ts)
-        // detects active runs and handles steer injection natively — the channel
-        // does not need its own steer detection or polling logic.
-        // File download
+        // 首条消息和 steer 回退都走此统一 dispatch 路径。
+        // File download — for both first message and steer fallthrough
         let mediaPayload = {};
         if (!skipReg || isUpdate) {
             const fileParts = extractFileParts(parsed.parts);
@@ -327,10 +335,8 @@ export async function handleXYMessage(params) {
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
-        let messageBody = textForAgent;
-        // Add speaker prefix for clarity
         const speaker = parsed.sessionId;
-        messageBody = `${speaker}: ${messageBody}`;
+        const messageBody = `${speaker}: ${textForAgent}`;
         // Format agent envelope (following feishu pattern)
         const body = core.channel.reply.formatAgentEnvelope({
             channel: "xiaoyi-channel",
@@ -378,20 +384,30 @@ export async function handleXYMessage(params) {
         // 🔑 创建dispatcher
         log.log(`[BOT-DISPATCHER] Creating reply dispatcher, isSteer=${isUpdate}, sessionKey=${route.sessionKey}`);
         // Cleanup: 必须在 onIdle 内部执行（参见 reply-dispatcher.ts 中 onIdleComplete 的注释）
-        // Steer dispatches must NOT decrement refCount because the steer injection
-        // uses skipRegistration (no increment). Only the original message's
-        // dispatcher owns the refCount lifecycle.
+        // CSPL steer injections (skipRegistration=true) do NOT call registerTaskId,
+        // so they must skip decrementTaskIdRef. All other paths (original message +
+        // WebSocket steer that fell through to the /steer fast path) DO increment
+        // refCount and must decrement here.
         let cleaned = false;
         const cleanup = () => {
             if (cleaned)
                 return;
             cleaned = true;
-            log.log(`[BOT] Cleanup started, steered=${steerState.steered}`);
-            if (!steerState.steered) {
+            log.log(`[BOT] Cleanup started, steered=${steerState.steered}, skipReg=${skipReg}`);
+            if (!skipReg) {
+                // Check for pending subagent wait on this session
+                const pendingWait = getWaitState(parsed.sessionId, parsed.taskId) ??
+                    (hasWaitState(parsed.sessionId) ? { deliveredCompletions: 0, expectedCompletions: 1 } : null);
+                if (pendingWait && pendingWait.deliveredCompletions < pendingWait.expectedCompletions) {
+                    // Subagent wait active — skip cleanup, session stays alive
+                    log.log(`[BOT] Cleanup suppressed — subagent wait active on session, taskId=${parsed.taskId}`);
+                    cleaned = false;
+                    return;
+                }
                 decrementTaskIdRef(parsed.sessionId);
             }
             else {
-                log.log(`[BOT] Steered cleanup, skipping decrementTaskIdRef`);
+                log.log(`[BOT] CSPL steer cleanup, skipping decrementTaskIdRef (never incremented)`);
             }
             log.log(`[BOT] Cleanup completed`);
         };
@@ -429,13 +445,34 @@ export async function handleXYMessage(params) {
         log.log(`[BOT-DISPATCH] withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
-            onSettled: () => {
+            onSettled: async () => {
                 log.log(`[BOT] onSettled, steered=${steerState.steered}`);
                 // 🔑 When steered, skip cleanup — the first message's dispatcher is still running
                 if (steerState.steered) {
                     log.log(`[BOT] Steered dispatch settled, skipping cleanup`);
                     return;
                 }
+                // Subagent wait state: if parent has pending subagents, mark settled
+                // and defer finalization. Cleanup is suppressed so the session stays alive.
+                const pendingWait = getWaitState(parsed.sessionId, parsed.taskId);
+                if (pendingWait && !pendingWait.parentSettled) {
+                    const transition = markParentSettled(parsed.sessionId, parsed.taskId);
+                    if (transition?.shouldFinalize) {
+                        // All completions arrived before parent settled → finalize now
+                        const { deliverSubagentFinalResult } = await import("./outbound.js");
+                        await deliverSubagentFinalResult({
+                            config,
+                            state: transition.state,
+                            reason: "all-subagent-results-delivered-before-parent-settled",
+                        });
+                        log.log(`[BOT] Subagent wait complete on parent settled; final response delivered`);
+                    }
+                    else {
+                        log.log(`[BOT] Subagent wait active, preserving session context for completion`);
+                    }
+                    dispatcherUpdaters.delete(parsed.sessionId);
+                    return;
+                }
                 // cleanup 已由 onIdleComplete 在 onIdle 的 finally 中执行。
                 // onSettled 不做任何清理（直接在这里清理会发生 race condition）。
                 dispatcherUpdaters.delete(parsed.sessionId);
@@ -449,7 +486,7 @@ export async function handleXYMessage(params) {
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
                     const isSteerDispatch = isUpdate && !skipReg;
                     log.log(`[ALS-PROOF] bot entered dispatch scope sessionId=${sessionContext.sessionId} taskId=${sessionContext.taskId} isSteer=${isSteerDispatch}`);
-                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}, isSteer=${isSteerDispatch}`);
+                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
                             ctx: ctxPayload,
@@ -457,13 +494,7 @@ export async function handleXYMessage(params) {
                             dispatcher,
                             replyOptions,
                         });
-                        // 区分 steer 成功（undefined）和 steer 失败/正常 run（有结果）
-                        if (result === undefined) {
-                            log.log(`[BOT-STEER] dispatchReplyFromConfig returned undefined — steer injected via fast path OK, sessionKey=${route.sessionKey}`);
-                        }
-                        else {
-                            log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, resultType=${typeof result}, isSteer=${isSteerDispatch}, steered=${steerState.steered}`);
-                        }
+                        log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, result=${JSON.stringify(result)}`);
                         return result;
                     }
                     catch (dispatchErr) {
@@ -514,19 +545,21 @@ export async function handleXYMessage(params) {
 function buildXYMediaPayload(mediaList) {
     const first = mediaList[0];
     const mediaPaths = mediaList.map((media) => media.path);
+    const mediaUrls = mediaList.map((media) => media.uri);
     const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
     return {
         MediaPath: first?.path,
         MediaType: first?.mimeType,
+        MediaUrl: first?.uri,
         MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
 // ─────────────────────────────────────────────────────────────
 // Dispatcher updaters (cross-chain taskId bridging)
 // ─────────────────────────────────────────────────────────────
-// Use globalThis to survive module deduplication — provider.ts may load a
-// different copy of bot.ts, so a plain module-level Map would be two objects.
+// Use globalThis to survive module deduplication
 const _g = globalThis;
 if (!_g.__xyDispatcherUpdaters)
     _g.__xyDispatcherUpdaters = new Map();

package/dist/src/channel.js

@@ -28,6 +28,7 @@ import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js"
 import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
 import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
 import { invokeTool } from "./tools/invoke.js";
+import { xiaoyiAppendReferenceTool } from "./tools/xiaoyi-append-reference.js";
 const ALL_TOOLS = [
     locationTool,
     discoverCrossDevicesTool,
@@ -52,6 +53,7 @@ const ALL_TOOLS = [
     agentAsSkillTool,
     checkPluginPrivilegeTool,
     invokeTool,
+    xiaoyiAppendReferenceTool,
 ];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.

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

@@ -1,2 +1,8 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
 import { ApiResponse } from './constants.js';
-export declare function callApi(questionText: string, api: any, sessionId: string, action: string): Promise<ApiResponse>;
+export interface CallApiPayload {
+    sceneID: string;
+    [key: string]: unknown;
+}
+export declare function callApi(payload: CallApiPayload, api: OpenClawPluginApi, sessionId: string): Promise<ApiResponse>;
+export declare function callSkillScanApi(url_suffix: string, payload: object, api: OpenClawPluginApi, sessionId: string): Promise<ApiResponse>;

package/dist/src/cspl/call_api.js

@@ -4,8 +4,13 @@
 import https from 'https';
 import http from 'http';
 import { URL } from 'url';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 import { getConfig } from './config.js';
-import { DEFAULT_HTTP_PORT, DEFAULT_HTTPS_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
+import { DEFAULT_HTTPS_PORT, DEFAULT_HTTP_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
 function buildHeadersForCelia(config, sessionId) {
     if (!config.uid || !config.apiKey || !config.skillId || !config.requestFrom) {
         throw new Error('[SENTINEL HOOK] Missing required configuration: uid, apiKey, skillId, or requestFrom is not defined');
@@ -21,15 +26,13 @@ function buildHeadersForCelia(config, sessionId) {
 }
 function buildRequestOptions(url, headers, timeout) {
     const urlObj = new URL(url);
-    const isHttps = urlObj.protocol === 'https:';
     return {
         hostname: urlObj.hostname,
-        port: urlObj.port || (isHttps ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT),
+        port: urlObj.port || (urlObj.protocol === 'https:' ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT),
         path: urlObj.pathname,
         method: "POST",
         headers: headers,
-        timeout: timeout,
-        rejectUnauthorized: false
+        timeout: timeout
     };
 }
 function checkHttpStatus(res) {
@@ -81,22 +84,17 @@ function handleResponse(res, resolve, reject) {
         }
     });
 }
-export async function callApi(questionText, api, sessionId, action) {
+export async function callApi(payload, api, sessionId) {
     const config = getConfig(api);
     const headersForCelia = buildHeadersForCelia(config, sessionId);
-    const payload = {
-        questionText: questionText,
-        textSource: config.textSource,
-        action: action,
-        extra: `${JSON.stringify({ userId: config.uid })}`
-    };
-    const httpBody = JSON.stringify(payload);
+    // 确保 uid 存在于消息体中（从 config 注入）
+    const payloadWithUid = { ...payload, uid: config.uid, action: payload.sceneID, packageName: "com.huawei.hmos.vassistant", ansDone: false, userId: config.uid };
+    const httpBody = JSON.stringify(payloadWithUid);
     const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
     return new Promise((resolve, reject) => {
         const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
-        const isHttps = new URL(apiUrl).protocol === 'https:';
-        const transport = isHttps ? https : http;
-        const req = transport.request(options, (res) => {
+        const protocol = apiUrl.startsWith('https://') ? https : http;
+        const req = protocol.request(options, (res) => {
             handleResponse(res, resolve, reject);
         });
         req.on('error', (error) => {
@@ -110,3 +108,45 @@ export async function callApi(questionText, api, sessionId, action) {
         req.end();
     });
 }
+export async function callSkillScanApi(url_suffix, payload, api, sessionId) {
+    const config = getConfig(api);
+    const headersForCelia = buildHeadersForCelia(config, sessionId);
+    // 确保 uid 存在于消息体中（从 config 注入）
+    const payloadWithUid = { ...payload, uid: config.uid, packageName: "com.huawei.hmos.vassistant", ansDone: false, userId: config.uid };
+    const httpBody = JSON.stringify(payloadWithUid);
+    console.log(`TOOL_input headersForCelia: ${JSON.stringify(headersForCelia)}`);
+    console.log(`TOOL_input httpBody: ${JSON.stringify(httpBody)}`);
+    // 将headersForCelia和httpBody写入当前目录的txt文件
+    const logFile = path.join(__dirname, 'api_request_log.txt');
+    const logContent = [
+        `==============================`,
+        `Timestamp: ${new Date().toISOString()}`,
+        `Session ID: ${sessionId}`,
+        ``,
+        `--- headersForCelia ---`,
+        JSON.stringify(headersForCelia, null, 2),
+        ``,
+        `--- httpBody ---`,
+        JSON.stringify(httpBody, null, 2),
+        `==============================`
+    ].join('\n');
+    fs.writeFileSync(logFile, logContent, 'utf8');
+    api.logger.info(`[ai-security-plugin][skill_scope_hook] Request log written to ${logFile}`);
+    return new Promise((resolve, reject) => {
+        const url = config.api.url + url_suffix;
+        const options = buildRequestOptions(url, headersForCelia, config.api.timeout);
+        const protocol = url.startsWith('https://') ? https : http;
+        const req = protocol.request(options, (res) => {
+            handleResponse(res, resolve, reject);
+        });
+        req.on('error', (error) => {
+            reject(error);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('[ai-security-plugin][skill_scope_hook] Request timeout'));
+        });
+        req.write(httpBody);
+        req.end();
+    });
+}

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

@@ -11,6 +11,5 @@ export interface Config {
     skillId: string;
     requestFrom: string;
     textSource: string;
-    action: string;
 }
 export declare function getConfig(api: any): Config;

package/dist/src/cspl/config.js

@@ -9,45 +9,44 @@ const __dirname = path.dirname(__filename);
 import { CONFIG_FILE_NAME, ENV_FILE_PATH, REQUIRED_ENV_VARS } from './constants.js';
 import { logger } from '../utils/logger.js';
 let cachedConfig = null;
-function readEnvFile() {
-    if (!fs.existsSync(ENV_FILE_PATH)) {
-        throw new Error(`Environment file not found.`);
-    }
-    let envData;
+function loadEnvContent() {
     try {
-        envData = fs.readFileSync(ENV_FILE_PATH, 'utf-8');
+        return fs.readFileSync(ENV_FILE_PATH, 'utf-8');
     }
     catch (error) {
         const err = error;
         throw new Error(`Failed to read environment file. Error: ${err.message}`);
     }
-    const env = {};
+}
+function parseEnvLine(line) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith('#')) {
+        return null;
+    }
+    const firstEqualIndex = trimmedLine.indexOf('=');
+    if (firstEqualIndex === -1) {
+        return null;
+    }
+    const key = trimmedLine.substring(0, firstEqualIndex).trim();
+    const value = trimmedLine.substring(firstEqualIndex + 1).trim();
+    return { key, value };
+}
+function readEnvFile() {
+    if (!fs.existsSync(ENV_FILE_PATH)) {
+        throw new Error(`Environment file not found.`);
+    }
+    const envData = loadEnvContent();
+    const envVars = {};
     const lines = envData.split('\n');
     for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (!trimmedLine || trimmedLine.startsWith('#')) {
-            continue;
-        }
-        const firstEqualIndex = trimmedLine.indexOf('=');
-        if (firstEqualIndex === -1) {
-            continue;
-        }
-        const key = trimmedLine.substring(0, firstEqualIndex).trim();
-        const value = trimmedLine.substring(firstEqualIndex + 1).trim();
-        if (key && REQUIRED_ENV_VARS.includes(key)) {
-            env[key] = value;
+        const parsed = parseEnvLine(line);
+        if (parsed && parsed.key && REQUIRED_ENV_VARS.includes(parsed.key)) {
+            envVars[parsed.key] = parsed.value;
         }
     }
-    return env;
+    return envVars;
 }
-export function getConfig(api) {
-    if (cachedConfig) {
-        return cachedConfig;
-    }
-    const configPath = path.join(__dirname, CONFIG_FILE_NAME);
-    if (!fs.existsSync(configPath)) {
-        throw new Error(`Config file not found: ${CONFIG_FILE_NAME}`);
-    }
+function loadConfigFile(configPath) {
     let configData;
     try {
         configData = fs.readFileSync(configPath, 'utf-8');
@@ -55,58 +54,65 @@ export function getConfig(api) {
     catch (error) {
         throw new Error(`Failed to read config file: ${CONFIG_FILE_NAME}.`);
     }
-    let parsedConfig;
     try {
-        parsedConfig = JSON.parse(configData);
+        return 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}`);
+}
+function validateConfigStructure(config) {
+    const validators = [
+        { field: 'api', check: () => !config.api || typeof config.api !== 'object' },
+        { field: 'api.timeout', check: () => !config.api?.timeout || typeof config.api.timeout !== 'number' },
+        { field: 'skillId', check: () => !config.skillId || typeof config.skillId !== 'string' },
+        { field: 'requestFrom', check: () => !config.requestFrom || typeof config.requestFrom !== 'string' },
+        { field: 'textSource', check: () => !config.textSource || typeof config.textSource !== 'string' },
+    ];
+    for (const { field, check } of validators) {
+        if (check()) {
+            throw new Error(`Invalid config: missing or invalid '${field}' in ${CONFIG_FILE_NAME}`);
+        }
     }
-    let env;
+}
+function validateEnvVars() {
+    let envVars;
     try {
-        env = readEnvFile();
+        envVars = 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'];
+    const personalApiKey = envVars['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'];
+    const personalUid = envVars['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'];
+    const serviceUrl = envVars.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();
+    return envVars;
+}
+export function getConfig(api) {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const configPath = path.join(__dirname, CONFIG_FILE_NAME);
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${CONFIG_FILE_NAME}`);
+    }
+    const parsedConfig = loadConfigFile(configPath);
+    const config = parsedConfig;
+    validateConfigStructure(config);
+    const envVars = validateEnvVars();
+    config.apiKey = envVars['PERSONAL-API-KEY'].trim();
+    config.uid = envVars['PERSONAL-UID'].trim();
+    config.api.url = envVars.SERVICE_URL.trim();
     cachedConfig = config;
     logger.log(`[SENTINEL HOOK] Config loaded successfully`);
     return cachedConfig;

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

@@ -11,7 +11,42 @@ export interface ApiPayload {
     questionText: string;
     textSource: string;
     action: string;
-    extra?: string;
+}
+export declare const RESULT_CODE_MAP: Record<number, string>;
+export interface NewRequestPayload {
+    taskID: string;
+    sessionID: string;
+    uid: string;
+    businessID: string;
+    sceneID: string;
+    checkPoint: number;
+    interActionID: number;
+    loginType?: string;
+    reqTime?: string;
+    message: object;
+}
+export interface NewApiResponse {
+    data: {
+        taskID: string;
+        resultCode: number;
+        resultMessage?: string;
+        securityResult: string;
+        riskLabels?: string[];
+        riskDegree?: Array<{
+            riskLabel: string;
+            score: number;
+        }>;
+        riskLabelCount?: Array<{
+            riskLabel: string;
+            count: number;
+        }>;
+        actionRiskResult?: {
+            riskScore: number;
+            riskTag: string[];
+        };
+    };
+    retCode?: string;
+    retMsg?: string;
 }
 export interface ApiResponse {
     [key: string]: any;