union-ark-web 1.0.1

package/ark-control/src/main/java/com/union/control/mapper/interceptor/AddressBookHandler.java

@@ -0,0 +1,105 @@
+package com.union.control.mapper.interceptor;
+
+import com.nucc.channel.ark.common.exception.CheckException;
+import com.union.control.service.sensitive.SensitiveRevealProcessor;
+import org.apache.ibatis.mapping.MappedStatement;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+import org.apache.ibatis.reflection.MetaObject;
+import org.apache.ibatis.reflection.SystemMetaObject;
+
+/** The only statement-specific branch: AddressBook migration and row visibility. */
+@Component
+final class AddressBookHandler {
+    private static final Pattern OLD_ADDRESS_BOOK =
+            Pattern.compile("(?<!\\S)t_m_announce_address_book(?!_)");
+
+    private final SensitiveRevealProcessor revealProcessor;
+    private final Set<String> plaintextRoles;
+
+    AddressBookHandler(SensitiveRevealProcessor revealProcessor,
+                       @Value("${sensitive.address-book.plaintext-roles:}") String configuredRoles) {
+        if (revealProcessor == null) throw new IllegalArgumentException("Reveal processor is required");
+        this.revealProcessor = revealProcessor;
+        this.plaintextRoles = parseRoles(configuredRoles);
+    }
+
+    MappedStatement prepare(MappedStatement statement, Object parameter) throws CheckException {
+        revealProcessor.encrypt(parameter);
+        return AESInterceptor.copy(statement, parameter,
+                OLD_ADDRESS_BOOK.matcher(statement.getBoundSql(parameter).getSql())
+                        .replaceAll("t_m_announce_address_book_new"));
+    }
+
+    void processResult(Object result, boolean revealEnabled, boolean strictMode) throws CheckException {
+        if (strictMode) {
+            revealProcessor.process(result);
+            return;
+        }
+        if (!revealEnabled) {
+            revealProcessor.decrypt(result);
+            return;
+        }
+
+        List<Object> plaintextRows = new ArrayList<>();
+        List<Object> protectedRows = new ArrayList<>();
+        for (Object row : rows(result)) {
+            if (allowPlaintext(row)) plaintextRows.add(row);
+            else protectedRows.add(row);
+        }
+        revealProcessor.decrypt(plaintextRows);
+        revealProcessor.process(protectedRows);
+    }
+
+    private static List<Object> rows(Object result) {
+        if (result == null) return Collections.emptyList();
+        List<Object> rows = new ArrayList<>();
+        if (result instanceof Iterable<?>) {
+            for (Object row : (Iterable<?>) result) rows.add(row);
+        } else if (result.getClass().isArray()) {
+            for (int i = 0; i < Array.getLength(result); i++) rows.add(Array.get(result, i));
+        } else {
+            rows.add(result);
+        }
+        return rows;
+    }
+
+    private boolean allowPlaintext(Object row) {
+        if (row == null) return false;
+        try {
+            Object value;
+            if (row instanceof Map<?, ?>) {
+                value = ((Map<?, ?>) row).get("role");
+            } else {
+                MetaObject metaObject = SystemMetaObject.forObject(row);
+                if (!metaObject.hasGetter("role")) return false;
+                value = metaObject.getValue("role");
+            }
+            return value != null && plaintextRoles.contains(value.toString().trim());
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    private static Set<String> parseRoles(String configuredRoles) {
+        Set<String> roles = new LinkedHashSet<>();
+        if (configuredRoles == null || configuredRoles.trim().isEmpty()) return roles;
+        for (String item : configuredRoles.split(",", -1)) {
+            String role = item.trim();
+            if (!role.matches("[A-Za-z0-9_-]{1,32}")) {
+                throw new IllegalArgumentException("Invalid AddressBook plaintext role");
+            }
+            roles.add(role);
+        }
+        return roles;
+    }
+}

package/ark-control/src/main/java/com/union/control/schedule/ScheduledExecutionToken.java

@@ -0,0 +1,55 @@
+package com.union.control.schedule;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Base64;
+
+/** One short-lived capability for one scheduled run. The database stores only its hash. */
+public final class ScheduledExecutionToken {
+    private static final SecureRandom RANDOM = new SecureRandom();
+    private final String value;
+
+    private ScheduledExecutionToken(String value) {
+        this.value = value;
+    }
+
+    public static ScheduledExecutionToken issue() {
+        byte[] bytes = new byte[32];
+        RANDOM.nextBytes(bytes);
+        return new ScheduledExecutionToken(
+                Base64.getUrlEncoder().withoutPadding().encodeToString(bytes));
+    }
+
+    public String authorizationHeader() {
+        return "Scheduled " + value;
+    }
+
+    public String hash() {
+        return hashSubmitted(value);
+    }
+
+    public static String hashSubmitted(String token) {
+        if (!valid(token)) throw new IllegalArgumentException("scheduled token 非法");
+        try {
+            byte[] digest = MessageDigest.getInstance("SHA-256")
+                    .digest(token.getBytes(StandardCharsets.UTF_8));
+            StringBuilder result = new StringBuilder(64);
+            for (byte item : digest) result.append(String.format("%02x", item & 0xff));
+            return result.toString();
+        } catch (NoSuchAlgorithmException impossible) {
+            throw new IllegalStateException(impossible);
+        }
+    }
+
+    public static boolean valid(String token) {
+        if (token == null || token.length() != 43
+                || !token.matches("[A-Za-z0-9_-]{43}")) return false;
+        try {
+            return Base64.getUrlDecoder().decode(token).length == 32;
+        } catch (IllegalArgumentException error) {
+            return false;
+        }
+    }
+}

package/ark-control/src/main/java/com/union/control/schedule/ScheduledTaskScheduler.java

@@ -0,0 +1,206 @@
+package com.union.control.schedule;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.union.control.service.AgentProxyService;
+import com.union.control.service.AgentResponse;
+import com.union.control.service.ScheduledTaskService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PreDestroy;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/** Claims and executes due tasks. Control is trusted and deliberately has no permission check. */
+@Component
+public class ScheduledTaskScheduler {
+    private static final Logger LOG = LoggerFactory.getLogger(ScheduledTaskScheduler.class);
+    private static final int SCAN_BATCH_SIZE = 20;
+    private static final int WORKER_QUEUE_SIZE = 32;
+    private final ScheduledTaskService service;
+    private final AgentProxyService proxy;
+    private final ObjectMapper json;
+    private final ThreadPoolExecutor workers;
+    private final boolean enabled;
+    private final int maxRunSeconds;
+    private final int tokenTtlSeconds;
+    private final Set<Long> submitted = Collections.newSetFromMap(
+            new ConcurrentHashMap<Long, Boolean>());
+
+    public ScheduledTaskScheduler(
+            ScheduledTaskService service,
+            AgentProxyService proxy,
+            ObjectMapper json,
+            @Value("${agent.scheduled-enabled:false}") boolean enabled,
+            @Value("${agent.scheduled-worker-threads:2}") int workerThreads,
+            @Value("${agent.scheduled-max-run-seconds:930}") int maxRunSeconds,
+            @Value("${agent.scheduled-token-ttl-seconds:960}") int tokenTtlSeconds) {
+        if (tokenTtlSeconds <= maxRunSeconds || tokenTtlSeconds > 3600)
+            throw new IllegalArgumentException(
+                    "scheduled token TTL must exceed max run time and be <= 3600");
+        this.service = service;
+        this.proxy = proxy;
+        this.json = json;
+        this.enabled = enabled;
+        this.maxRunSeconds = Math.max(60, maxRunSeconds);
+        this.tokenTtlSeconds = tokenTtlSeconds;
+        int threads = Math.max(1, Math.min(workerThreads, 16));
+        this.workers = new ThreadPoolExecutor(threads, threads, 0L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<Runnable>(WORKER_QUEUE_SIZE), new NamedThreadFactory(),
+                new ThreadPoolExecutor.AbortPolicy());
+    }
+
+    @Scheduled(initialDelay = 1000, fixedDelay = 5000)
+    public void scan() {
+        if (!enabled) return;
+        service.failStaleRuns(maxRunSeconds);
+        Set<Long> ready = new LinkedHashSet<>(service.pendingRunIds(SCAN_BATCH_SIZE));
+        while (ready.size() < SCAN_BATCH_SIZE) {
+            Long runId = service.claimDueRun();
+            if (runId == null) break;
+            ready.add(runId);
+        }
+        for (Long runId : ready) submit(runId);
+    }
+
+    private void submit(final long runId) {
+        if (!submitted.add(runId)) return;
+        try {
+            workers.execute(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        try {
+                            ScheduledExecutionToken token = ScheduledExecutionToken.issue();
+                            String expiresAt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
+                                    .withZone(ZoneOffset.UTC)
+                                    .format(Instant.now().plusSeconds(tokenTtlSeconds));
+                            if (!service.beginRun(runId, token.hash(), expiresAt)) return;
+                            long startedAt = System.nanoTime();
+                            LOG.info("Scheduled run started run_id={}", runId);
+                            service.completeFromProxy(runId, execute(token));
+                            LOG.info("Scheduled run completed run_id={} duration_ms={}", runId,
+                                    (System.nanoTime() - startedAt) / 1_000_000L);
+                        } catch (ScheduledAgentFailure error) {
+                            LOG.warn("Scheduled run failed run_id={} error_code={}",
+                                    runId, error.code);
+                            try {
+                                service.failRun(runId, error.code, error.userMessage);
+                            } catch (RuntimeException finishError) {
+                                LOG.error("Scheduled run failure persistence failed run_id={}", runId);
+                            }
+                        } catch (RuntimeException error) {
+                            LOG.warn("Scheduled run failed run_id={} error_type={}",
+                                    runId, error.getClass().getSimpleName());
+                            try {
+                                service.failRun(runId, "scheduled_run_failed", "定时任务执行失败");
+                            } catch (RuntimeException finishError) {
+                                LOG.error("Scheduled run failure persistence failed run_id={}", runId);
+                            }
+                        }
+                    } finally {
+                        submitted.remove(runId);
+                    }
+                }
+            });
+        } catch (RejectedExecutionException ignored) {
+            submitted.remove(runId);
+            LOG.warn("Scheduled worker queue full run_id={}", runId);
+        }
+    }
+
+    private Map<String, Object> execute(ScheduledExecutionToken token) {
+        try {
+            AgentResponse response = proxy.scheduled(token.authorizationHeader());
+            if (response.getStatus() < 200 || response.getStatus() >= 300)
+                throw failure(response);
+            String body = response.getBody();
+            if (body == null || body.isEmpty() || body.length() > 4000000)
+                throw new IllegalStateException("Agent scheduled 返回无效结果");
+            Map<String, Object> result = json.readValue(
+                    body, new TypeReference<Map<String, Object>>() {});
+            required(result, "content");
+            return result;
+        } catch (RuntimeException error) {
+            throw error;
+        } catch (Exception error) {
+            throw new IllegalStateException("Agent scheduled 请求或响应无效", error);
+        }
+    }
+
+    private static String required(Map<String, Object> values, String key) {
+        Object value = values.get(key);
+        if (!(value instanceof String) || ((String) value).trim().isEmpty())
+            throw new IllegalStateException("Scheduled run result 缺少 " + key);
+        return (String) value;
+    }
+
+    private ScheduledAgentFailure failure(AgentResponse response) {
+        String code = "agent_http_error";
+        String message = "Agent 服务返回 HTTP " + response.getStatus();
+        String body = response.getBody();
+        if (body != null && !body.isEmpty() && body.length() <= 65536) {
+            try {
+                Map<String, Object> error = json.readValue(
+                        body, new TypeReference<Map<String, Object>>() {});
+                code = safeCode(error.get("code"), code);
+                message = safeMessage(error.get("error"), message);
+            } catch (Exception ignored) {}
+        }
+        return new ScheduledAgentFailure(code, message);
+    }
+
+    private static String safeCode(Object value, String fallback) {
+        if (!(value instanceof String)) return fallback;
+        String code = ((String) value).trim();
+        return code.matches("[A-Za-z0-9._-]{1,64}") ? code : fallback;
+    }
+
+    private static String safeMessage(Object value, String fallback) {
+        if (!(value instanceof String)) return fallback;
+        String message = ((String) value).trim().replaceAll("\\s+", " ");
+        if (message.isEmpty()) return fallback;
+        return message.substring(0, Math.min(message.length(), 512));
+    }
+
+    @PreDestroy
+    public void close() { workers.shutdownNow(); }
+
+    private static final class ScheduledAgentFailure extends IllegalStateException {
+        private final String code;
+        private final String userMessage;
+
+        private ScheduledAgentFailure(String code, String userMessage) {
+            this.code = code;
+            this.userMessage = userMessage;
+        }
+    }
+
+    private static class NamedThreadFactory implements ThreadFactory {
+        private final AtomicInteger sequence = new AtomicInteger();
+
+        @Override
+        public Thread newThread(Runnable runnable) {
+            Thread thread = new Thread(runnable,
+                    "scheduled-task-" + sequence.incrementAndGet());
+            thread.setDaemon(true);
+            return thread;
+        }
+    }
+}

package/ark-control/src/main/java/com/union/control/service/impl/AgentExecutionServiceImpl.java

@@ -0,0 +1,212 @@
+package com.union.control.service.impl;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.union.control.mapper.AgentExecutionMapper;
+import com.union.control.mapper.ConversationMapper;
+import com.union.control.service.AgentExecutionService;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+import static com.union.control.utils.AgentSupport.*;
+
+@Service("agentExecutionService")
+public class AgentExecutionServiceImpl implements AgentExecutionService {
+    private final AgentExecutionMapper executionMapper;
+    private final ConversationMapper conversationMapper;
+    private final ObjectMapper json;
+
+    public AgentExecutionServiceImpl(
+            AgentExecutionMapper executionMapper,
+            ConversationMapper conversationMapper,
+            ObjectMapper json) {
+        this.executionMapper = executionMapper;
+        this.conversationMapper = conversationMapper;
+        this.json = json;
+    }
+
+    @Transactional
+    public Map<String, Object> claimAguiRun(String payload) {
+        Map<String, Object> input = request(json, payload);
+        String userId = userId(input);
+        String conversationId = text(input, "threadId", 64, true);
+        String runId = text(input, "runId", 64, true);
+        requireId(conversationId);
+        requireExecutionToken(runId);
+        String title = conversationTitle(input);
+        try {
+            conversationMapper.insertConversation(conversationId, userId, title);
+        } catch (DuplicateKeyException ignored) {
+            // Existing active conversation is expected on subsequent turns.
+        }
+        requireOwnedActive(userId, conversationId);
+        executionMapper.insertRootExecution(runId, conversationId, userId);
+        return ok(loadExecution(userId, conversationId, runId, false));
+    }
+
+    @Transactional
+    public Map<String, Object> completeRun(String input) {
+        Map<String, Object> payload = request(json, input);
+        String userId = userId(payload);
+        String conversationId = text(payload, "conversationId", 64, true);
+        String rootRunId = text(payload, "runId", 64, true);
+        requireId(conversationId);
+        requireExecutionToken(rootRunId);
+        if (conversationMapper.requireOwned(conversationId, userId, true) == null)
+            throw new NoSuchElementException("会话不存在");
+        Map<String, Object> root = loadExecution(
+                userId, conversationId, rootRunId, true);
+        if (root.get("parentExecutionId") != null)
+            throw new IllegalArgumentException("runId 不是 root execution");
+
+        Object rawExecutions = payload.get("executions");
+        if (!(rawExecutions instanceof List) || ((List<?>) rawExecutions).isEmpty())
+            throw new IllegalArgumentException("executions 非法");
+        Map<String, Map<String, Object>> requested = parseExecutionRows(
+                (List<?>) rawExecutions,
+                rootRunId);
+        Object rawMessages = payload.get("messages");
+        if (!(rawMessages instanceof List))
+            throw new IllegalArgumentException("messages 非法");
+        Map<String, Map<String, Object>> persisted = persistExecutions(
+                userId, conversationId, rootRunId, root, requested);
+        persistMessages(userId, conversationId, persisted, (List<?>) rawMessages);
+        for (Map<String, Object> value : requested.values())
+            finishExecution(persisted.get(String.valueOf(value.get("runId"))),
+                    String.valueOf(value.get("status")), (String) value.get("errorCode"));
+        conversationMapper.touchConversation(conversationId, userId);
+        return ok(null);
+    }
+
+    private Map<String, Map<String, Object>> persistExecutions(
+            String userId, String conversationId, String rootRunId,
+            Map<String, Object> root, Map<String, Map<String, Object>> requested) {
+        executionMapper.updateRootAgent(number(root.get("id")),
+                String.valueOf(requested.get(rootRunId).get("agentName")));
+        Map<String, Map<String, Object>> persisted = new HashMap<>();
+        persisted.put(rootRunId, root);
+        for (Map<String, Object> value : requested.values()) {
+            String runId = String.valueOf(value.get("runId"));
+            if (rootRunId.equals(runId)) continue;
+            String parentRunId = String.valueOf(value.get("parentRunId"));
+            Map<String, Object> parent = persisted.get(parentRunId);
+            if (parent == null) throw new IllegalArgumentException("parent execution 不存在");
+            executionMapper.insertChildExecution(runId, conversationId, userId,
+                    number(parent.get("id")), String.valueOf(value.get("agentName")),
+                    (String) value.get("delegationToolCallId"), (String) value.get("task"));
+            persisted.put(runId, loadExecution(userId, conversationId, runId, true));
+        }
+        return persisted;
+    }
+
+    private void persistMessages(
+            String userId, String conversationId,
+            Map<String, Map<String, Object>> executions, List<?> messages) {
+        Long current = conversationMapper.currentMessageSequence(conversationId);
+        long sequence = current == null ? 0 : current;
+        for (Object raw : messages) {
+            if (!(raw instanceof Map)) throw new IllegalArgumentException("AG-UI message 必须是对象");
+            Map<?, ?> envelope = (Map<?, ?>) raw;
+            String messageRunId = text(envelope, "runId", 64, true);
+            Object rawMessage = envelope.get("message");
+            if (!(rawMessage instanceof Map)) throw new IllegalArgumentException("message 非法");
+            @SuppressWarnings("unchecked") Map<String, Object> message =
+                    (Map<String, Object>) rawMessage;
+            String messageId = text(message, "id", 128, true);
+            String role = text(message, "role", 32, true);
+            Map<String, Object> execution = executions.get(messageRunId);
+            if (execution == null)
+                throw new IllegalArgumentException("message execution 不存在");
+            Map<String, Object> messagePayload = new LinkedHashMap<>(message);
+            messagePayload.remove("id");
+            messagePayload.remove("role");
+            String messageJson;
+            try {
+                messageJson = json.writeValueAsString(messagePayload);
+            } catch (Exception error) {
+                throw new IllegalArgumentException("AG-UI message 不是有效 JSON");
+            }
+            conversationMapper.insertMessage(conversationId, userId, messageId,
+                    number(execution.get("id")), role, ++sequence, messageJson);
+        }
+    }
+
+    private Map<String, Object> findExecution(
+            String userId, String conversationId, String runId, boolean lock) {
+        List<Map<String, Object>> rows = executionMapper.findExecution(
+                userId, conversationId, runId, lock);
+        return rows.isEmpty() ? null : rows.get(0);
+    }
+
+    private Map<String, Object> loadExecution(
+            String userId, String conversationId, String runId, boolean lock) {
+        requireId(conversationId);
+        requireExecutionToken(runId);
+        Map<String, Object> execution = findExecution(userId, conversationId, runId, lock);
+        if (execution == null) throw new IllegalStateException("execution 已失效");
+        return execution;
+    }
+
+    private void finishExecution(
+            Map<String, Object> execution, String status, String errorCode) {
+        int updated = executionMapper.finishExecution(number(execution.get("id")), status, errorCode);
+        if (updated != 1) throw new IllegalStateException("execution 已失效");
+    }
+
+    private Map<String, Map<String, Object>> parseExecutionRows(
+            List<?> values, String rootRunId) {
+        Map<String, Map<String, Object>> result = new LinkedHashMap<>();
+        for (Object raw : values) {
+            if (!(raw instanceof Map)) throw new IllegalArgumentException("execution 非法");
+            Map<?, ?> value = (Map<?, ?>) raw;
+            String runId = text(value, "runId", 64, true);
+            requireExecutionToken(runId);
+            String parentRunId = text(value, "parentRunId", 64, false);
+            String agentName = text(value, "agentName", 128, true);
+            String delegationCallId = text(value, "delegationToolCallId", 128, false);
+            String task = text(value, "task", 1000, false);
+            String status = text(value, "status", 32, true);
+            String errorCode = text(value, "errorCode", 64, false);
+            Map<String, Object> normalized = new LinkedHashMap<>();
+            normalized.put("runId", runId);
+            normalized.put("parentRunId", parentRunId);
+            normalized.put("agentName", agentName);
+            normalized.put("delegationToolCallId", delegationCallId);
+            normalized.put("task", task);
+            normalized.put("status", status);
+            normalized.put("errorCode", errorCode);
+            if (result.put(runId, normalized) != null)
+                throw new IllegalArgumentException("execution runId 重复");
+        }
+        if (!result.containsKey(rootRunId))
+            throw new IllegalArgumentException("executions 缺少 root");
+        return result;
+    }
+
+    private void requireOwnedActive(String userId, String conversationId) {
+        if (conversationMapper.requireOwnedActive(conversationId, userId) == null) {
+            throw new NoSuchElementException("会话不存在或未激活");
+        }
+    }
+
+
+
+    private static String conversationTitle(Map<String, Object> input) {
+        Object raw = input.get("messages");
+        if (!(raw instanceof List) || ((List<?>) raw).isEmpty()) return "新会话";
+        Object item = ((List<?>) raw).get(((List<?>) raw).size() - 1);
+        if (!(item instanceof Map)) return "新会话";
+        Map<?, ?> message = (Map<?, ?>) item;
+        if (!(message.get("content") instanceof String)) return "新会话";
+        String value = ((String) message.get("content")).trim();
+        if (value.isEmpty()) return "新会话";
+        return value.substring(0, Math.min(value.length(), 255));
+    }
+
+}