@xdxer/dingtalk-agent 0.1.5-beta.2 → 0.1.5-beta.4

package/dist/src/multica-deploy.js

@@ -3,7 +3,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve } from 'node:path';
-import { WORKSPACE_STATE_ROOT, inspectAgentProject, showDevelopmentWorkspace, } from './development-workspace.js';
+import { WORKSPACE_STATE_ROOT, inspectAgentProject, projectSkillRef, showDevelopmentWorkspace, } from './development-workspace.js';
 import { digest, stableStringify } from './events.js';
 import { MULTICA_EVIDENCE_ROOT, inspectMulticaWorkspace, planMulticaWorkspace, statusMulticaWorkspace, } from './multica-provider.js';
 export const MULTICA_DEPLOYMENT_SCHEMA = 'dingtalk-agent/multica-deployment-receipt@1';
@@ -63,7 +63,11 @@ export function runMulticaWorkspaceIssue(start, name, prompt, options = {}) {
         throw new Error(`Multica workspace run 前置条件不完整: ${plan.blocking.join(', ')}`);
     }
     const command = options.command || env.DTA_MULTICA_BIN || 'multica';
-    const timeoutMs = positiveTimeout(options.timeoutMs, 30_000, 300_000);
+    // A real Issue-channel run does agent work plus issue get/comment/status side-tasks and
+    // routinely needs minutes; the old 30s default timed out on almost every honest run. Wait
+    // 4 minutes by default (still capped at 5). A run that overruns is resumable via
+    // `workspace run --status --run-id` against the same Issue — no duplicate Issue.
+    const timeoutMs = positiveTimeout(options.timeoutMs, 240_000, 300_000);
     const calls = [];
     const inspection = inspectMulticaWorkspace(info.root, name, {
         execute: true, yes: true, persist: false, command, env,
@@ -86,6 +90,18 @@ export function runMulticaWorkspaceIssue(start, name, prompt, options = {}) {
         '--description', normalizedPrompt, '--assignee-id', plan.agentId, '--output', 'json',
     ]), 'workspace-run.issue.create', 'write', info.root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run issue');
     const issueId = resourceId(issue.id, 'workspace run issue.id');
+    return readbackWorkspaceRun({
+        root: info.root, name, plan, issueId, runId, command, env, timeoutMs, calls, out: options.out,
+    });
+}
+/**
+ * Poll an existing Issue's assignee-agent task to a terminal state, then reconstruct the
+ * run report from its trace. Shared by the initial `workspace run` (right after it creates the
+ * Issue) and `workspace run --status --run-id` (resume against the SAME Issue, no new write) so
+ * a timed-out run reconciles instead of spawning a duplicate Issue.
+ */
+function readbackWorkspaceRun(ctx) {
+    const { root, name, plan, issueId, runId, command, env, timeoutMs, calls } = ctx;
     const started = Date.now();
     const pollIntervalMs = 2_000;
     const pollCalls = [];
@@ -95,7 +111,7 @@ export function runMulticaWorkspaceIssue(start, name, prompt, options = {}) {
         pollAttempts += 1;
         const runs = jsonArray(runProvider(command, scopedArgs({ profile: plan.profile, expected: { workspaceId: plan.workspaceId } }, [
             'issue', 'runs', issueId, '--full-id', '--output', 'json',
-        ]), 'workspace-run.issue.runs', 'read', info.root, env, Math.min(timeoutMs, 30_000), pollCalls).stdout, 'workspace run issue runs');
+        ]), 'workspace-run.issue.runs', 'read', root, env, Math.min(timeoutMs, 30_000), pollCalls).stdout, 'workspace run issue runs');
         task = runs.filter((item) => !optionalString(item.agent_id) ||
             optionalString(item.agent_id) === plan.agentId)
             .sort((a, b) => optionalString(b.created_at).localeCompare(optionalString(a.created_at)))[0];
@@ -111,7 +127,7 @@ export function runMulticaWorkspaceIssue(start, name, prompt, options = {}) {
     if (taskId && ['completed', 'failed', 'cancelled'].includes(taskStatus)) {
         messages = jsonArray(runProvider(command, scopedArgs({ profile: plan.profile, expected: { workspaceId: plan.workspaceId } }, [
             'issue', 'run-messages', taskId, '--issue', issueId, '--output', 'json',
-        ]), 'workspace-run.issue.messages', 'read', info.root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run messages');
+        ]), 'workspace-run.issue.messages', 'read', root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run messages');
     }
     const toolUses = messages.filter((item) => optionalString(item.type) === 'tool_use');
     const toolNames = toolUses.map((item) => optionalString(item.tool)).filter(Boolean);
@@ -125,7 +141,7 @@ export function runMulticaWorkspaceIssue(start, name, prompt, options = {}) {
     const answer = safeRemoteOutput(replyWrites.at(-1) || texts.at(-1) || '', 64 * 1024);
     const issueReadback = jsonObject(runProvider(command, scopedArgs({ profile: plan.profile, expected: { workspaceId: plan.workspaceId } }, [
         'issue', 'get', issueId, '--output', 'json',
-    ]), 'workspace-run.issue.readback', 'read', info.root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run issue readback');
+    ]), 'workspace-run.issue.readback', 'read', root, env, Math.min(timeoutMs, 30_000), calls).stdout, 'workspace run issue readback');
     const issueStatus = optionalString(issueReadback.status);
     const failures = [];
     if (!task)
@@ -165,17 +181,88 @@ export function runMulticaWorkspaceIssue(start, name, prompt, options = {}) {
         calls,
         evidencePath: '',
         remoteRead: true,
-        remoteWrite: true,
+        remoteWrite: calls.some((call) => call.kind === 'write'),
         triggerWrite: false,
         sideEffect: 'multica-issue-read-write',
         dingtalkSideEffect: false,
     };
     const defaultEvidence = join(MULTICA_EVIDENCE_ROOT, safeName(name), 'multica-runs', `${runId}.json`);
-    report.evidencePath = relative(info.root, safeProjectPath(info.root, options.out || defaultEvidence, false));
+    report.evidencePath = relative(root, safeProjectPath(root, ctx.out || defaultEvidence, false));
     assertReportRedacted(report);
-    atomicJson(safeProjectPath(info.root, report.evidencePath, false), report);
+    atomicJson(safeProjectPath(root, report.evidencePath, false), report);
     return report;
 }
+/**
+ * Resume a `workspace run` by re-reading the SAME Issue's task instead of creating a new one.
+ * Loads the persisted run evidence by runId, confirms the workspace scope still resolves to the
+ * same target (fail closed on drift), then polls that Issue's assignee-agent task to a terminal
+ * state and rewrites the run report. Read-only against Multica — never enqueues a second Issue.
+ */
+export function statusMulticaWorkspaceRun(start, name, options = {}) {
+    const env = options.env || process.env;
+    const cliVersion = options.cliVersion || '';
+    const runId = String(options.runId || '').trim();
+    if (!/^multica_workspace_run_[0-9]+_[a-f0-9]{8}$/.test(runId)) {
+        throw new Error('workspace run --status 需要一个合法的 --run-id（来自上次 run 的 runId）');
+    }
+    if (!options.execute) {
+        throw new Error('workspace run --status 会向 Multica 独立回读同一 Issue；必须传 --execute');
+    }
+    if (!options.yes)
+        throw new Error('workspace run --status 远端回读必须同时传 --execute --yes');
+    const info = inspectAgentProject(start, cliVersion);
+    requireMulticaWorkspace(info.root, name, cliVersion);
+    // The original run persists evidence to `--out` when given, else the default runId path. Resume
+    // must look where the run actually wrote, so honor the same `--out` (and rewrite back to it).
+    const evidenceRel = options.out || join(MULTICA_EVIDENCE_ROOT, safeName(name), 'multica-runs', `${runId}.json`);
+    const evidenceAbs = safeProjectPath(info.root, evidenceRel, false);
+    if (!existsSync(evidenceAbs)) {
+        throw new Error(`找不到 run 证据 ${evidenceRel}；--run-id 必须是本 Workspace 已有的 runId` +
+            `${options.out ? '' : '（若原 run 用了 --out，请对 --status 传相同 --out）'}`);
+    }
+    const prior = JSON.parse(readFileSync(evidenceAbs, 'utf8'));
+    if (prior.$schema !== 'dingtalk-agent/multica-workspace-run@1' ||
+        prior.provider !== 'multica' || prior.workspace !== name || !prior.issueId) {
+        throw new Error('run 证据不是本 Workspace 的 multica run，或缺少 issueId；已 fail closed');
+    }
+    // The evidence file must belong to THIS runId. Two runs sharing one --out overwrite each
+    // other, so resuming the first runId against that path would otherwise read the second run's
+    // Issue while reporting the first runId — cross-wiring answer and run. Fail closed on mismatch.
+    if (prior.runId !== runId) {
+        throw new Error(`run 证据 ${evidenceRel} 属于 runId ${prior.runId}，与 --run-id ${runId} 不一致；已 fail closed` +
+            `（同一 --out 被后一次 run 覆盖时会这样）`);
+    }
+    // Re-resolve scope offline and refuse unless the WHOLE frozen target still matches: an env
+    // pointing at a different runtime/agent/profile (or an invalid ref surfacing in blocking) must
+    // not let the resume mis-record the old task or overwrite the frozen values. workspaceId alone
+    // is not enough.
+    const providerPlan = planMulticaWorkspace(info.root, name, { env, cliVersion });
+    const scopeDrift = providerPlan.blocking.length ? ['blocking:' + providerPlan.blocking.join(',')] : [];
+    if (providerPlan.profile !== prior.profile)
+        scopeDrift.push('profile');
+    if (providerPlan.expected.workspaceId !== prior.workspaceId)
+        scopeDrift.push('workspace');
+    if (providerPlan.expected.runtimeId !== prior.runtimeId)
+        scopeDrift.push('runtime');
+    if (providerPlan.expected.agentId !== prior.agentId)
+        scopeDrift.push('agent');
+    if (scopeDrift.length) {
+        throw new Error(`workspace run --status: 当前 workspace scope 与 run 证据不一致 [${scopeDrift.join(', ')}]；已 fail closed`);
+    }
+    const command = options.command || env.DTA_MULTICA_BIN || 'multica';
+    const timeoutMs = positiveTimeout(options.timeoutMs, 240_000, 300_000);
+    const plan = {
+        profile: providerPlan.profile,
+        workspaceId: providerPlan.expected.workspaceId,
+        runtimeId: providerPlan.expected.runtimeId,
+        agentId: providerPlan.expected.agentId,
+        promptHash: prior.promptHash,
+    };
+    return readbackWorkspaceRun({
+        root: info.root, name, plan, issueId: prior.issueId, runId,
+        command, env, timeoutMs, calls: [], out: options.out,
+    });
+}
 export function planMulticaDeployment(start, name, options = {}) {
     const action = options.action || 'apply';
     const env = options.env || process.env;
@@ -299,7 +386,7 @@ export function applyMulticaDeployment(start, name, options = {}, action = 'appl
             receipt = retireDeployment(info.root, workspace, source, plan, preflight, operation, command, env, timeoutMs, calls);
         }
         else {
-            receipt = executeApply(info.root, workspace, source, plan, preflight, operation, command, env, timeoutMs, positiveTimeout(options.smokeTimeoutMs, 30_000, 60_000), Boolean(options.noWait), calls, rollback, temp);
+            receipt = executeApply(info.root, workspace, source, plan, preflight, operation, command, env, timeoutMs, positiveTimeout(options.smokeTimeoutMs, 30_000, 300_000), Boolean(options.noWait), calls, rollback, temp);
         }
     }
     catch (error) {
@@ -499,8 +586,7 @@ function loadDeploymentSource(root) {
     const definitionHash = sha256(definition);
     const skillRoots = [];
     for (const name of info.project.skills) {
-        const ref = name === 'dingtalk-basic-behavior'
-            ? `.agents/skills/${name}` : `skills/${name}`;
+        const ref = projectSkillRef(info.project, name);
         skillRoots.push({ name, root: safeProjectPath(root, ref, true) });
     }
     if (skillRoots.length > MAX_DEPLOY_SKILLS) {
@@ -711,7 +797,7 @@ function createAndReadSmoke(root, plan, source, agentId, command, env, timeoutMs
             `required_skills=${JSON.stringify(requiredSkills)}`,
             'This is a deployment control-plane verification task.',
             'Use the Host native Skill tool exactly once for every required skill above, in the listed order.',
-            'Do not call DWS, Shell, network, or write tools.',
+            'Do not call DWS, network, or business tools. Only the Host Issue control-plane calls needed to read this Issue and persist the exact result are exempt.',
             `Return exactly this JSON and nothing else: ${expectedResponse}`,
         ].join('\n'),
         '--assignee-id', agentId, '--output', 'json',
@@ -778,7 +864,12 @@ function readSmoke(root, plan, marker, issueId, agentId, requiredSkills, command
     const responseWrites = toolUses.filter((item) => optionalString(item.tool) === 'write')
         .map((item) => smokeToolInput(item)).filter((input) => safeSmokeResponsePath(optionalString(input.filePath)))
         .map((input) => optionalString(input.content)).filter(Boolean);
-    const responseEvidence = [...texts, ...responseWrites].find(matchesResponse) || '';
+    const responseShells = toolUses.filter((item) => optionalString(item.tool) === 'bash')
+        .map((item) => optionalString(smokeToolInput(item).command))
+        .filter((command) => safeCombinedSmokeResponse(command, issueId, marker, requiredSkills))
+        .map(() => JSON.stringify({ schema: 'dta-multica-load-smoke@1', marker, loaded: requiredSkills }));
+    const responseEvidence = [...texts, ...responseWrites, ...responseShells]
+        .find(matchesResponse) || '';
     const responsePassed = Boolean(responseEvidence);
     const toolTracePassed = toolUses.every((item) => allowedSmokeToolUse(item, issueId, marker, requiredSkills)) && stableStringify(skillNames) === stableStringify(requiredSkills);
     const failures = [];
@@ -836,26 +927,45 @@ function allowedSmokeToolUse(item, issueId, marker, requiredSkills) {
     const cleanupFirstPrefix = 'rm ';
     const cleanupFirstSuffix = ` && multica issue status ${issueId} in_review`;
     if (command.startsWith(cleanupFirstPrefix) && command.endsWith(cleanupFirstSuffix)) {
-        return safeSmokeResponsePath(command.slice(cleanupFirstPrefix.length, command.length - cleanupFirstSuffix.length));
+        return safeSmokeCleanup(command.slice(cleanupFirstPrefix.length, command.length - cleanupFirstSuffix.length));
     }
     const statusFirstPrefix = `multica issue status ${issueId} in_review && rm `;
     if (command.startsWith(statusFirstPrefix)) {
-        return safeSmokeResponsePath(command.slice(statusFirstPrefix.length));
+        return safeSmokeCleanup(command.slice(statusFirstPrefix.length));
     }
     if (command.startsWith(cleanupFirstPrefix)) {
-        return safeSmokeResponsePath(command.slice(cleanupFirstPrefix.length));
+        return safeSmokeCleanup(command.slice(cleanupFirstPrefix.length));
     }
+    if (safeCombinedSmokeResponse(command, issueId, marker, requiredSkills))
+        return true;
     return false;
 }
+function safeCombinedSmokeResponse(command, issueId, marker, requiredSkills) {
+    const response = JSON.stringify({ schema: 'dta-multica-load-smoke@1', marker, loaded: requiredSkills });
+    return command === [
+        "cat > ./reply.md << 'REPLY_EOF'",
+        response,
+        'REPLY_EOF',
+        `multica issue comment add ${issueId} --content-file ./reply.md && rm ./reply.md`,
+    ].join('\n');
+}
 function safeSmokeResponsePath(value) {
-    const names = new Set(['reply.md', 'result.json']);
+    const names = new Set(['reply.md', 'result.md', 'result.json']);
     if (value.startsWith('./'))
         return names.has(value.slice(2));
-    if (!value.startsWith('/') || !names.has(value.split('/').at(-1) || ''))
+    // 裸文件名与 `./` 前缀等价：Agent 在 workdir 里写绝对路径、随后用裸名引用同一个文件是
+    // 平台的常见写法。只放行精确 basename —— `foo/result.md` 与 `../result.md` 仍然落到
+    // 下面的绝对路径分支并被拒绝，白名单没有变宽。
+    if (!value.startsWith('/'))
+        return names.has(value);
+    if (!names.has(value.split('/').at(-1) || ''))
         return false;
     return value.split('/').every((part) => !part ||
         (part !== '.' && part !== '..' && /^[A-Za-z0-9._-]+$/.test(part)));
 }
+function safeSmokeCleanup(value) {
+    return safeSmokeResponsePath(value.startsWith('-f ') ? value.slice(3) : value);
+}
 function rollbackConfirmed(root, plan, command, env, timeoutMs, calls, rollback, temp) {
     const report = emptyRollback(true);
     const attempt = (id, argv) => {