@xdxer/dingtalk-agent 0.1.4-beta.9 → 0.1.5-beta.1

package/dist/src/multica-deploy.js

@@ -7,6 +7,7 @@ import { WORKSPACE_STATE_ROOT, inspectAgentProject, showDevelopmentWorkspace, }
 import { digest, stableStringify } from './events.js';
 import { MULTICA_BOOT_SKILL, MULTICA_EVIDENCE_ROOT, inspectMulticaWorkspace, planMulticaWorkspace, statusMulticaWorkspace, } from './multica-provider.js';
 import { resolvePackageRoot } from './package-root.js';
+import { bundledSkillPath } from './skill-manager.js';
 export const MULTICA_DEPLOYMENT_SCHEMA = 'dingtalk-agent/multica-deployment-receipt@1';
 const MAX_DEPLOY_SKILLS = 32;
 const MAX_SKILL_SUPPORTING_FILES = 128;
@@ -80,7 +81,7 @@ export function planMulticaDeployment(start, name, options = {}) {
             workspaceId: readPlan.expected.workspaceId,
             runtimeId: readPlan.expected.runtimeId,
             agentId: readPlan.expected.agentId,
-            agentName: info.project.name,
+            agentName: info.project.displayName,
             skills: expectedSkills,
             definitionHash: source.definitionHash,
             instructionsHash: source.instructionsHash,
@@ -350,7 +351,7 @@ function loadDeploymentSource(root) {
     const packageRoot = resolvePackageRoot(import.meta.url);
     skillRoots.push({
         name: MULTICA_BOOT_SKILL,
-        root: safeExternalSkillRoot(join(packageRoot, 'skills', MULTICA_BOOT_SKILL)),
+        root: safeExternalSkillRoot(bundledSkillPath(packageRoot, MULTICA_BOOT_SKILL)),
     });
     if (skillRoots.length > MAX_DEPLOY_SKILLS) {
         throw new Error(`Multica deploy 最多支持 ${MAX_DEPLOY_SKILLS} 个受管 Skills`);
@@ -598,24 +599,20 @@ function readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command
         'issue', 'run-messages', taskId, '--issue', issueId, '--output', 'json',
     ]), 'smoke.issue.messages', 'read', root, env, timeoutMs, calls).stdout, 'smoke messages');
     const toolUses = messages.filter((item) => optionalString(item.type) === 'tool_use');
-    const nonSkillTools = toolUses.filter((item) => !/skill/i.test(optionalString(item.tool)));
-    const loadedSkills = requiredSkills.filter((name) => toolUses.some((item) => JSON.stringify(item.input || {}).includes(name))).sort();
+    const skillToolUses = toolUses.filter((item) => optionalString(item.tool) === 'skill');
+    const skillNames = skillToolUses.map((item) => smokeToolInput(item).name)
+        .filter((item) => typeof item === 'string' && Boolean(item)).sort();
+    const loadedSkills = requiredSkills.filter((name) => skillNames.includes(name)).sort();
     const texts = messages.filter((item) => optionalString(item.type) === 'text')
         .map((item) => optionalString(item.content)).filter(Boolean);
     const finalText = texts.at(-1) || '';
-    let responsePassed = false;
-    try {
-        const parsed = JSON.parse(finalText);
-        responsePassed = parsed?.schema === 'dta-multica-load-smoke@1' &&
-            parsed?.marker === marker &&
-            stableStringify(Array.isArray(parsed?.loaded) ? [...parsed.loaded].sort() : []) ===
-                stableStringify(requiredSkills);
-    }
-    catch {
-        responsePassed = false;
-    }
-    const toolTracePassed = nonSkillTools.length === 0 &&
-        stableStringify(loadedSkills) === stableStringify(requiredSkills);
+    const matchesResponse = (value) => smokeResponseMatches(value, marker, requiredSkills);
+    const replyWrites = toolUses.filter((item) => optionalString(item.tool) === 'write')
+        .map((item) => smokeToolInput(item)).filter((input) => optionalString(input.filePath).endsWith('/reply.md'))
+        .map((input) => optionalString(input.content)).filter(Boolean);
+    const responseEvidence = [...texts, ...replyWrites].find(matchesResponse) || '';
+    const responsePassed = Boolean(responseEvidence);
+    const toolTracePassed = toolUses.every((item) => allowedSmokeToolUse(item, issueId, marker, requiredSkills)) && stableStringify(skillNames) === stableStringify(requiredSkills);
     const failures = [];
     if (taskStatus !== 'completed')
         failures.push(`smoke.task.${taskStatus || 'unknown'}`);
@@ -626,9 +623,70 @@ function readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command
     return {
         status: failures.length ? 'failed' : 'passed',
         marker, markerHash: sha256(marker), issueId, taskId, taskStatus, requiredSkills, loadedSkills,
-        toolTracePassed, responsePassed, responseHash: sha256(finalText), failures,
+        toolTracePassed, responsePassed, responseHash: sha256(responseEvidence || finalText), failures,
     };
 }
+function smokeToolInput(item) {
+    return item.input && typeof item.input === 'object' && !Array.isArray(item.input)
+        ? item.input : {};
+}
+function smokeResponseMatches(value, marker, requiredSkills) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed?.schema === 'dta-multica-load-smoke@1' && parsed?.marker === marker &&
+            stableStringify(Array.isArray(parsed?.loaded) ? [...parsed.loaded].sort() : []) ===
+                stableStringify(requiredSkills);
+    }
+    catch {
+        return false;
+    }
+}
+function allowedSmokeToolUse(item, issueId, marker, requiredSkills) {
+    const tool = optionalString(item.tool);
+    if (tool === 'skill')
+        return true;
+    const input = smokeToolInput(item);
+    if (tool === 'write') {
+        return safeSmokeReplyPath(optionalString(input.filePath)) &&
+            smokeResponseMatches(optionalString(input.content), marker, requiredSkills);
+    }
+    if (tool !== 'bash')
+        return false;
+    const command = optionalString(input.command);
+    if (new Set([
+        `multica issue get ${issueId} --output json`,
+        `multica issue metadata list ${issueId} --output json`,
+        `multica issue comment list ${issueId} --recent 10 --output json`,
+        `multica issue status ${issueId} in_progress`,
+        `multica issue status ${issueId} in_review`,
+    ]).has(command))
+        return true;
+    const commentPrefix = `multica issue comment add ${issueId} --content-file `;
+    if (command.startsWith(commentPrefix)) {
+        return safeSmokeReplyPath(command.slice(commentPrefix.length));
+    }
+    const cleanupFirstPrefix = 'rm ';
+    const cleanupFirstSuffix = ` && multica issue status ${issueId} in_review`;
+    if (command.startsWith(cleanupFirstPrefix) && command.endsWith(cleanupFirstSuffix)) {
+        return safeSmokeReplyPath(command.slice(cleanupFirstPrefix.length, command.length - cleanupFirstSuffix.length));
+    }
+    const statusFirstPrefix = `multica issue status ${issueId} in_review && rm `;
+    if (command.startsWith(statusFirstPrefix)) {
+        return safeSmokeReplyPath(command.slice(statusFirstPrefix.length));
+    }
+    if (command.startsWith(cleanupFirstPrefix)) {
+        return safeSmokeReplyPath(command.slice(cleanupFirstPrefix.length));
+    }
+    return false;
+}
+function safeSmokeReplyPath(value) {
+    if (value === './reply.md')
+        return true;
+    if (!value.startsWith('/') || !value.endsWith('/reply.md'))
+        return false;
+    return value.split('/').every((part) => !part ||
+        (part !== '.' && part !== '..' && /^[A-Za-z0-9._-]+$/.test(part)));
+}
 function rollbackConfirmed(root, plan, command, env, timeoutMs, calls, rollback, temp) {
     const report = emptyRollback(true);
     const attempt = (id, argv) => {
@@ -833,7 +891,7 @@ export function statusMulticaDeployment(start, name, options = {}) {
             const matched = Boolean(snapshot && remoteMatchesDesired(snapshot, source, operation.runtimeId));
             const safelyBound = Boolean(snapshot?.agent && inspection.passed &&
                 snapshot.agent.id === operation.agentId &&
-                snapshot.agent.name === info.project.name &&
+                snapshot.agent.name === info.project.displayName &&
                 snapshot.agent.runtimeId === operation.runtimeId &&
                 snapshot.agent.instructions === source.instructions && !snapshot.agent.archived);
             receipt = { ...receipt,
@@ -934,7 +992,7 @@ function reconcileRemoteTarget(root, name, operation, source, command, env, time
     if (candidates.length > 10) {
         return { inspection: discovery, snapshot: null, failures: ['reconcile.agent-candidate-budget'] };
     }
-    const projectName = inspectAgentProject(root).project.name;
+    const projectName = inspectAgentProject(root).project.displayName;
     const matches = [];
     for (const [index, candidate] of candidates.entries()) {
         const inspection = inspectMulticaWorkspace(root, name, {