@tea-agent/loop-agent 0.39.0-next.3 → 0.39.0-next.30

package/dist/{cli → shared}/update/state.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 export function updateStatePath(homeDir) {
     return path.join(homeDir, ".loop-agent", "update-state.json");
@@ -18,6 +18,7 @@ export async function readUpdateState(statePath) {
             latestVersion: stringOrUndefined(parsed.latestVersion),
             dismissedVersion: stringOrUndefined(parsed.dismissedVersion),
             retryAfter: stringOrUndefined(parsed.retryAfter),
+            lastPromptedLocalDate: stringOrUndefined(parsed.lastPromptedLocalDate),
         };
     }
     catch {
@@ -36,28 +37,55 @@ export async function acquireUpdateLock(lockPath, options = {}) {
     await mkdir(path.dirname(lockPath), { recursive: true });
     try {
         await mkdir(lockPath);
+        return await claimLock(lockPath, now);
+    }
+    catch {
+        if (await isFreshLock(lockPath, now, staleMs))
+            return undefined;
+        try {
+            await rm(lockPath, { recursive: true, force: true });
+            await mkdir(lockPath);
+            return await claimLock(lockPath, now);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+async function claimLock(lockPath, now) {
+    try {
         await writeFile(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, at: now().toISOString() }), "utf-8");
         return async () => {
             await rm(lockPath, { recursive: true, force: true });
         };
     }
+    catch {
+        await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
+        return undefined;
+    }
+}
+async function isFreshLock(lockPath, now, staleMs) {
+    try {
+        const ownerRaw = await readFile(path.join(lockPath, "owner.json"), "utf-8");
+        const owner = JSON.parse(ownerRaw);
+        if (typeof owner.at !== "string")
+            return false;
+        const at = Date.parse(owner.at);
+        if (!Number.isFinite(at))
+            return false;
+        return now().getTime() - at <= staleMs;
+    }
     catch {
         try {
-            const ownerRaw = await readFile(path.join(lockPath, "owner.json"), "utf-8");
-            const owner = JSON.parse(ownerRaw);
-            if (owner.at && now().getTime() - Date.parse(owner.at) > staleMs) {
-                await rm(lockPath, { recursive: true, force: true });
-                await mkdir(lockPath);
-                await writeFile(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, at: now().toISOString() }), "utf-8");
-                return async () => {
-                    await rm(lockPath, { recursive: true, force: true });
-                };
-            }
+            const info = await stat(lockPath);
+            const mtime = Number.isFinite(info.mtimeMs)
+                ? info.mtimeMs
+                : info.mtime.getTime();
+            return now().getTime() - mtime <= staleMs;
         }
         catch {
-            return undefined;
+            return false;
         }
-        return undefined;
     }
 }
 function emptyState() {

package/dist/task/config-types.js

@@ -124,6 +124,26 @@ export const frontendTestConfigSchema = z.object({
         .strict()
         .optional(),
 });
+/** Backend-test artifact layout and pipeline mode configuration (plan A/B/D). */
+export const backendTestConfigSchema = z
+    .object({
+    /** Repository-relative test root. Default "testcase". */
+    testRoot: z.string().min(1).optional(),
+    /** Markdown subdirectory relative to testRoot. Default "md". */
+    markdownRel: z.string().min(1).optional(),
+    /** Pytest script subdirectory relative to testRoot. Default "." (testRoot itself). */
+    scriptRel: z.string().min(1).optional(),
+    /** User-provided shared setup document (plan B). Read-only bound source. */
+    sharedSetupDoc: z.string().min(1).optional(),
+    /** Pipeline mode: full 16-node chain (default) or gap-fill incremental DAG (plan D). */
+    mode: z.enum(["full", "gap-fill"]).optional(),
+    /** Required for mode=gap-fill: user missing-scenario document path. */
+    gapDoc: z.string().min(1).optional(),
+    /** gap-fill pytest execution scope: only affected items (default) or all eligible. */
+    executeScope: z.enum(["affected", "all"]).optional(),
+})
+    .strict()
+    .optional();
 export const convergenceConfigSchema = z.object({
     enabled: z.boolean().optional().default(false),
     maxPasses: z.number().int().positive().optional().default(3),
@@ -196,6 +216,8 @@ const taskConfigObjectSchema = z.object({
     frontendTest: frontendTestConfigSchema.optional(),
     /** Frontend OpenSpec gate policy and contract-declared required read paths. */
     frontendOpenspec: frontendOpenspecConfigSchema.optional(),
+    /** Backend-test layout / shared-setup / gap-fill configuration. */
+    backendTest: backendTestConfigSchema,
     notes: z.string().optional().default(""),
 });
 export const taskConfigSchema = z.preprocess((raw) => {

package/dist/task/contract/constants.js

@@ -17,6 +17,7 @@ export const MANAGED_TASK_CONFIG_FIELDS = [
     "forbiddenPaths",
     "hardConstraints",
     "verifyCommands",
+    "backendTest",
 ];
 export const CONTRACT_FILE_NAME = "contract.json";
 export const TRANSACTIONS_DIR_NAME = ".transactions";

package/dist/task/contract/diff.js

@@ -1,3 +1,4 @@
+import { canonicalizeJsonValue } from "./canonicalize.js";
 import { MANAGED_TASK_CONFIG_FIELDS } from "./constants.js";
 function maxRisk(a, b) {
     const order = ["routine", "elevated", "blocking"];
@@ -139,6 +140,31 @@ export function diffDraftAgainstCurrent(input) {
                 path: "task.json#featureId",
             });
         }
+        // backendTest is managed whole-object: an absent draft value means
+        // "keep existing" and never diffs; declared values compare canonically.
+        if (input.draft.backendTest !== undefined) {
+            const before = cfg.backendTest ?? {};
+            const after = input.draft.backendTest;
+            if (canonicalizeJsonValue(before) !== canonicalizeJsonValue(after)) {
+                changedManagedFields.push("backendTest");
+                risks.push({
+                    code: "BACKEND_TEST_CONFIG_CHANGED",
+                    level: "routine",
+                    message: "backendTest configuration changed",
+                    path: "task.json#backendTest",
+                });
+                const afterKeys = new Set(Object.keys(after));
+                const droppedKeys = Object.keys(before).filter((key) => !afterKeys.has(key));
+                if (droppedKeys.length > 0) {
+                    risks.push({
+                        code: "BACKEND_TEST_CONFIG_WEAKENED",
+                        level: "elevated",
+                        message: `drop backendTest keys: ${droppedKeys.sort().join(", ")}`,
+                        path: "task.json#backendTest",
+                    });
+                }
+            }
+        }
     }
     else {
         for (const field of MANAGED_TASK_CONFIG_FIELDS) {

package/dist/task/contract/project.js

@@ -174,6 +174,11 @@ export function mergeManagedTaskConfigFields(existing, draft) {
     if (draft.featureId !== undefined) {
         next.featureId = draft.featureId;
     }
+    // backendTest is whole-object replace when the draft declares it (`{}` is a
+    // legal explicit clear back to the default layout); absent keeps existing.
+    if (draft.backendTest !== undefined) {
+        next.backendTest = draft.backendTest;
+    }
     return next;
 }
 /**

package/dist/task/contract/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { taskKindSchema, taskVerifyCommandSchema } from "../config-types.js";
+import { backendTestConfigSchema, taskKindSchema, taskVerifyCommandSchema, } from "../config-types.js";
 import { TASK_CONFIG_SCHEMA_VERSION, TASK_CONTRACT_CANONICALIZER_VERSION, TASK_CONTRACT_DRAFT_SCHEMA_VERSION, TASK_CONTRACT_PROJECTION_VERSION, TASK_CONTRACT_REF_SCHEMA_VERSION, } from "./constants.js";
 const sha256Schema = z
     .string()
@@ -62,6 +62,11 @@ export const taskContractDraftSchema = z
     requirement: taskContractDraftRequirementSchema,
     constraints: taskContractDraftConstraintsSchema,
     verification: taskContractDraftVerificationSchema,
+    /**
+     * Managed backend-test layout / pipeline configuration projected into
+     * task.json#backendTest. Optional: absent means "keep existing".
+     */
+    backendTest: backendTestConfigSchema,
     references: z.array(taskContractDraftReferenceSchema).optional(),
     sourceResolutions: z
         .array(taskContractDraftSourceResolutionSchema)

package/dist/task/source-prepare/build-draft.js

@@ -22,6 +22,18 @@ function resolveTaskKindExplicit(flags, baseDraft) {
         return flags.taskKindExplicit;
     return baseDraft?.taskKindExplicit ?? false;
 }
+/**
+ * Resolve managed backend-test layout config.
+ * Precedence: explicit CLI flags > --from-draft base > existing task.json
+ * (the last tier self-heals tasks whose backendTest was hand-written).
+ */
+function resolveBackendTest(flags, baseDraft, existing) {
+    if (flags.backendTest !== undefined)
+        return flags.backendTest;
+    if (baseDraft?.backendTest !== undefined)
+        return baseDraft.backendTest;
+    return existing?.backendTest ?? undefined;
+}
 function resolveTitle(taskId, flags, facts, baseDraft, existing) {
     return (trimNonEmpty(flags.title) ??
         trimNonEmpty(baseDraft?.title) ??
@@ -205,6 +217,9 @@ export function buildPrepareDraft(input) {
     };
     if (featureId)
         draft.featureId = featureId;
+    const backendTest = resolveBackendTest(flags, baseDraft, existingTaskConfig);
+    if (backendTest !== undefined)
+        draft.backendTest = backendTest;
     if (references && references.length > 0) {
         draft.references = references.map((ref) => ({
             role: ref.role,

package/dist/worker/cli.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import { readFile } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
+import { createNpmUpdateClient } from "../shared/update/npm-client.js";
+import { runConsoleDailyUpdateCheck } from "../shared/update/console-notifier.js";
 import { readPackageVersion } from "../shared/package-metadata.js";
 import YAML from "yaml";
 import { LoopAgentClient } from "./loop-agent/loop-agent-client.js";
@@ -838,10 +841,33 @@ function parseOptionalTimeoutMs(raw) {
     return value;
 }
 /** Console HTTP entry for bare `agent-worker console` (listen first, then optional browser open). */
-async function runConsoleServe(options) {
+export async function runConsoleServe(options) {
     const { createConsoleServer } = await import("./console/server.js");
     const { maybeOpenConsoleBrowser } = await import("./console/open-browser.js");
     try {
+        try {
+            const packageRoot = path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))));
+            const currentVersion = readPackageVersion(packageRoot) ?? "0.0.0";
+            await runConsoleDailyUpdateCheck({
+                currentVersion,
+                packageRoot,
+                homeDir: os.homedir(),
+                cwd: options.repoRoot,
+                env: process.env,
+                stdinIsTTY: process.stdin.isTTY === true,
+                stderrIsTTY: process.stderr.isTTY === true,
+                client: createNpmUpdateClient({
+                    currentVersion,
+                    packageRoot,
+                    cwd: options.repoRoot,
+                    env: process.env,
+                }),
+            });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`loop-agent 更新检查已跳过：${detail}\n`);
+        }
         const server = await createConsoleServer({
             repoRoot: options.repoRoot,
             host: options.host,
@@ -857,6 +883,10 @@ async function runConsoleServe(options) {
             noOpen: options.noOpen === true,
             serverUrl: server.url,
         });
+        if (options.holdUntilSignal === false) {
+            await server.close();
+            return;
+        }
         await new Promise((resolve) => {
             const shutdown = () => resolve();
             process.once("SIGINT", shutdown);

package/dist/worker/console/chat/deferred-turn.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+const IMAGE_MIME_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+]);
+export function hashDeferredTurnPayload(input) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        text: input.text,
+        images: input.images.map(({ type, mimeType, data }) => ({
+            type,
+            mimeType,
+            data,
+        })),
+    }))
+        .digest("hex");
+}
+export function parseDeferredTurn(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const item = value;
+    if (item.schemaVersion !== 1 ||
+        !Number.isSafeInteger(item.revision) ||
+        (item.revision ?? 0) < 1 ||
+        typeof item.clientRequestId !== "string" ||
+        !item.clientRequestId.trim() ||
+        typeof item.payloadHash !== "string" ||
+        !/^[a-f0-9]{64}$/.test(item.payloadHash) ||
+        typeof item.blockedByTurnId !== "string" ||
+        !item.blockedByTurnId.trim() ||
+        typeof item.text !== "string" ||
+        !Array.isArray(item.images) ||
+        !["queued", "dispatching", "accepted", "failed"].includes(item.state) ||
+        typeof item.createdAt !== "string" ||
+        typeof item.updatedAt !== "string") {
+        return undefined;
+    }
+    const images = [];
+    for (const image of item.images) {
+        if (!image || typeof image !== "object")
+            return undefined;
+        const candidate = image;
+        if (typeof candidate.name !== "string" ||
+            candidate.type !== "image" ||
+            typeof candidate.mimeType !== "string" ||
+            !IMAGE_MIME_TYPES.has(candidate.mimeType) ||
+            typeof candidate.data !== "string") {
+            return undefined;
+        }
+        images.push(candidate);
+    }
+    return {
+        schemaVersion: 1,
+        revision: item.revision,
+        clientRequestId: item.clientRequestId.trim(),
+        payloadHash: item.payloadHash,
+        blockedByTurnId: item.blockedByTurnId.trim(),
+        text: item.text,
+        images,
+        state: item.state,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+        ...(typeof item.acceptedTurnId === "string" && item.acceptedTurnId
+            ? { acceptedTurnId: item.acceptedTurnId }
+            : {}),
+        ...(item.lastError &&
+            typeof item.lastError.code === "string" &&
+            typeof item.lastError.message === "string"
+            ? { lastError: { code: item.lastError.code, message: item.lastError.message } }
+            : {}),
+    };
+}
+export function projectDeferredTurnSummary(deferredTurn) {
+    if (!deferredTurn)
+        return null;
+    return {
+        revision: deferredTurn.revision,
+        clientRequestId: deferredTurn.clientRequestId,
+        blockedByTurnId: deferredTurn.blockedByTurnId,
+        state: deferredTurn.state,
+        updatedAt: deferredTurn.updatedAt,
+        textPreview: deferredTurn.text.replace(/\s+/g, " ").trim().slice(0, 120),
+        imageCount: deferredTurn.images.length,
+        ...(deferredTurn.acceptedTurnId
+            ? { acceptedTurnId: deferredTurn.acceptedTurnId }
+            : {}),
+        ...(deferredTurn.lastError ? { lastError: deferredTurn.lastError } : {}),
+    };
+}

package/dist/worker/console/chat/mcp-inventory.js

@@ -0,0 +1,221 @@
+/**
+ * Read-only MCP inventory for Operator Chat.
+ *
+ * Pi has no built-in MCP catalog. Console projects two real facts:
+ *   1. mcp.json server specs (configured, may or may not have registered tools)
+ *   2. tools already on the live session that look like MCP registrations
+ *
+ * Never fabricate servers or tools. Missing files stay empty.
+ */
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+const MCP_CONFIG_NAMES = ["mcp.json"];
+export function isMcpToolName(name) {
+    const lower = name.trim().toLowerCase();
+    return lower === "mcp" || lower.startsWith("mcp_") || lower.startsWith("mcp-");
+}
+export function inferMcpServerName(toolName, knownServers = []) {
+    const name = toolName.trim();
+    if (/^mcp$/i.test(name))
+        return undefined;
+    const rest = name.replace(/^mcp[_-]/i, "");
+    if (!rest || rest === name || knownServers.length === 0)
+        return undefined;
+    const ranked = [...knownServers].sort((left, right) => right.length - left.length);
+    const lower = rest.toLowerCase();
+    return ranked.find((server) => {
+        const key = server.toLowerCase();
+        return lower === key || lower.startsWith(`${key}_`) || lower.startsWith(`${key}-`);
+    });
+}
+export function looksLikeMcpTool(tool) {
+    const name = typeof tool.name === "string" ? tool.name : "";
+    if (!name)
+        return false;
+    if (isMcpToolName(name))
+        return true;
+    const source = `${tool.sourceInfo?.source ?? ""} ${tool.sourceInfo?.path ?? ""}`.toLowerCase();
+    return source.includes("mcp");
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function readEnabled(entry) {
+    return entry.enabled !== false;
+}
+function readTransport(entry) {
+    if (typeof entry.transport === "string" && entry.transport.trim()) {
+        return entry.transport.trim();
+    }
+    if (typeof entry.type === "string" && entry.type.trim()) {
+        return entry.type.trim();
+    }
+    if (typeof entry.url === "string")
+        return "http";
+    if (Array.isArray(entry.command) || typeof entry.command === "string") {
+        return "stdio";
+    }
+    return undefined;
+}
+function readCommand(entry) {
+    if (typeof entry.command === "string" && entry.command.trim()) {
+        const args = Array.isArray(entry.args)
+            ? entry.args.filter((item) => typeof item === "string").join(" ")
+            : "";
+        return args ? `${entry.command} ${args}` : entry.command;
+    }
+    if (Array.isArray(entry.command)) {
+        return entry.command
+            .filter((item) => typeof item === "string")
+            .join(" ")
+            .trim();
+    }
+    return undefined;
+}
+function extractServerMap(parsed) {
+    const root = asRecord(parsed);
+    if (!root)
+        return {};
+    const mcpServers = asRecord(root.mcpServers);
+    if (mcpServers)
+        return mcpServers;
+    const mcp = asRecord(root.mcp);
+    if (mcp)
+        return mcp;
+    const servers = asRecord(root.servers);
+    if (servers)
+        return servers;
+    return {};
+}
+export function parseMcpConfig(raw, scope, configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const servers = [];
+    for (const [name, value] of Object.entries(extractServerMap(parsed))) {
+        if (!name.trim())
+            continue;
+        const entry = asRecord(value) ?? {};
+        const command = readCommand(entry);
+        const url = typeof entry.url === "string" ? entry.url.trim() : undefined;
+        servers.push({
+            name: name.trim(),
+            scope,
+            enabled: readEnabled(entry),
+            ...(readTransport(entry) ? { transport: readTransport(entry) } : {}),
+            ...(command ? { command } : {}),
+            ...(url ? { url } : {}),
+            configPath,
+        });
+    }
+    return servers;
+}
+export function projectSessionMcpTools(tools, activeToolNames = [], knownServers = []) {
+    const active = new Set(activeToolNames.map((name) => name.toLowerCase()));
+    const seen = new Set();
+    const projected = [];
+    for (const tool of tools) {
+        if (!looksLikeMcpTool(tool) || typeof tool.name !== "string")
+            continue;
+        const name = tool.name.trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        const server = inferMcpServerName(name, knownServers);
+        projected.push({
+            name,
+            description: typeof tool.description === "string" ? tool.description : "",
+            ...(server ? { server } : {}),
+            source: tool.sourceInfo?.source ?? "",
+            scope: tool.sourceInfo?.scope ?? "session",
+            ...(tool.sourceInfo?.path ? { path: tool.sourceInfo.path } : {}),
+            active: active.has(name.toLowerCase()),
+        });
+    }
+    return projected;
+}
+export function assembleMcpInventory(servers, tools) {
+    const byServer = new Map();
+    const unassigned = [];
+    for (const tool of tools) {
+        const key = tool.server?.toLowerCase();
+        if (!key) {
+            unassigned.push(tool);
+            continue;
+        }
+        const list = byServer.get(key) ?? [];
+        list.push(tool);
+        byServer.set(key, list);
+    }
+    const views = servers.map((server) => {
+        const matched = byServer.get(server.name.toLowerCase()) ?? [];
+        byServer.delete(server.name.toLowerCase());
+        const status = !server.enabled
+            ? "disabled"
+            : matched.length > 0
+                ? "loaded"
+                : "configured";
+        return {
+            name: server.name,
+            scope: server.scope,
+            status,
+            enabled: server.enabled,
+            ...(server.transport ? { transport: server.transport } : {}),
+            ...(server.command ? { command: server.command } : {}),
+            ...(server.url ? { url: server.url } : {}),
+            configPath: server.configPath,
+            tools: matched,
+        };
+    });
+    for (const [name, matched] of byServer) {
+        views.push({
+            name,
+            scope: "session",
+            status: "loaded",
+            enabled: true,
+            tools: matched,
+        });
+    }
+    return { servers: views, unassignedTools: unassigned };
+}
+async function readConfigFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function loadMcpServerSpecs(options) {
+    const candidates = [
+        { path: path.join(options.agentDir, ...MCP_CONFIG_NAMES), scope: "user" },
+        { path: path.join(options.cwd, ".pi", ...MCP_CONFIG_NAMES), scope: "project" },
+        { path: path.join(options.cwd, ".mcp.json"), scope: "project" },
+    ];
+    const servers = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const raw = await readConfigFile(candidate.path);
+        if (!raw)
+            continue;
+        for (const server of parseMcpConfig(raw, candidate.scope, candidate.path)) {
+            const key = `${server.scope}:${server.name.toLowerCase()}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            servers.push(server);
+        }
+    }
+    return servers;
+}
+export async function readMcpInventory(options) {
+    const servers = await loadMcpServerSpecs(options);
+    const tools = projectSessionMcpTools(options.tools ?? [], options.activeToolNames ?? [], servers.map((server) => server.name));
+    return assembleMcpInventory(servers, tools);
+}