@tea-agent/loop-agent 0.43.0-next.9 → 0.43.0

package/dist/worker/console/chat/browser-routes.js

@@ -1,11 +1,9 @@
 /**
- * HTTP routes for the Operator Chat browser panel: one read-only probe
- * endpoint the panel uses to explain an iframe refusal (X-Frame-Options /
- * CSP frame-ancestors are exactly the signals the browser enforces when it
- * refuses to embed a site). The probe is display-only (headers back to the
- * caller), restricted to http(s) non-loopback URLs, with a hard timeout.
+ * HTTP API for the Console Browser panel. The panel renders screenshots from
+ * the controlled browser and sends pointer/keyboard input back to the same
+ * Playwright page used by Operator Chat tools.
  */
-import { embeddabilityOf, extractFrameAncestors, isLoopbackHostname, } from "./browser-policy.js";
+import { embeddabilityOf, extractFrameAncestors, normalizeBrowserUrl, } from "./browser-policy.js";
 function workspaceIdOf(req) {
     try {
         return new URL(req.url ?? "/", "http://localhost").searchParams.get("workspaceId") ?? undefined;
@@ -21,7 +19,38 @@ function sendJson(res, status, body) {
     });
     res.end(JSON.stringify(body));
 }
-/** Route dispatcher; returns true when the request was handled. */
+function errorPayload(error) {
+    return {
+        code: error instanceof Error && "code" in error
+            ? String(error.code)
+            : "BROWSER_OPERATION_FAILED",
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+function requireScope(req, deps) {
+    const ws = workspaceIdOf(req);
+    if (!ws) {
+        return { ok: false, status: 400, code: "WORKSPACE_REQUIRED", message: "workspaceId is required" };
+    }
+    if (deps.requireWorkspace && !deps.requireWorkspace(req).ok) {
+        return { ok: false, status: 403, code: "WORKSPACE_DENIED", message: "workspace scope mismatch" };
+    }
+    return { ok: true };
+}
+async function readJson(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > 1024 * 1024)
+            throw new Error("request body exceeds 1MB");
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
 export async function handleBrowserRequest(req, res, deps, pathname) {
     if (!pathname.startsWith("/api/operator/v1/chat/browser"))
         return false;
@@ -30,73 +59,62 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
     const parts = rest.split("/").filter(Boolean);
     const sub = parts[0] ?? "";
     try {
-        if (method === "GET" && sub === "probe" && parts.length === 1) {
-            // Fail-closed: the probe needs a workspaceId like every chat API.
-            if (deps.requireWorkspace) {
-                const ws = deps.requireWorkspace(req);
-                if (!ws.ok) {
-                    sendJson(res, 400, {
-                        ok: false,
-                        error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
-                    });
-                    return true;
-                }
-            }
-            else if (!workspaceIdOf(req)) {
-                sendJson(res, 400, {
+        if (method === "GET" && sub === "state" && parts.length === 1) {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, {
                     ok: false,
-                    error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
+                    error: { code: scope.code, message: scope.message },
                 });
                 return true;
             }
-            const url = new URL(req.url ?? "/", "http://localhost");
-            const raw = url.searchParams.get("url") ?? "";
-            let parsed;
-            try {
-                parsed = new URL(raw);
-            }
-            catch {
-                sendJson(res, 400, {
-                    ok: false,
-                    error: { code: "INVALID_URL", message: "invalid url" },
-                });
+            if (!deps.automation) {
+                sendJson(res, 200, { ok: true, data: { page: null } });
                 return true;
             }
-            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-                sendJson(res, 400, {
+            const page = await deps.automation.state();
+            sendJson(res, 200, { ok: true, data: { page } });
+            return true;
+        }
+        if (method === "GET" && sub === "probe" && parts.length === 1) {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, {
                     ok: false,
-                    error: { code: "BAD_SCHEME", message: "only http/https urls can be probed" },
+                    error: { code: scope.code, message: scope.message },
                 });
                 return true;
             }
-            // Mirror the address-bar policy: loopback stays unreachable from
-            // the panel, so probing it would leak nothing the panel could use.
-            if (isLoopbackHostname(parsed.hostname)) {
+            const raw = new URL(req.url ?? "/", "http://localhost").searchParams.get("url") ?? "";
+            const normalized = normalizeBrowserUrl(raw);
+            if (normalized.kind !== "ok") {
                 sendJson(res, 400, {
                     ok: false,
-                    error: { code: "LOOPBACK_REFUSED", message: "local addresses are not probed" },
+                    error: {
+                        code: normalized.kind === "blocked" ? "BAD_SCHEME" : "INVALID_URL",
+                        message: normalized.kind === "blocked"
+                            ? "only http/https urls can be probed"
+                            : "invalid url",
+                    },
                 });
                 return true;
             }
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), 8000);
             try {
-                let response = await fetch(parsed, {
+                let response = await fetch(normalized.url, {
                     method: "HEAD",
                     redirect: "follow",
                     signal: controller.signal,
                 });
-                // Some servers answer HEAD with 405/501; retry once as GET
-                // (the body is discarded — only the headers matter).
                 if (response.status === 405 || response.status === 501) {
-                    response = await fetch(parsed, {
+                    response = await fetch(normalized.url, {
                         method: "GET",
                         redirect: "follow",
                         signal: controller.signal,
                     });
                 }
-                const csp = response.headers.get("content-security-policy");
-                const frameAncestors = extractFrameAncestors(csp);
+                const frameAncestors = extractFrameAncestors(response.headers.get("content-security-policy"));
                 const xFrameOptions = response.headers.get("x-frame-options");
                 const probe = {
                     reachable: true,
@@ -112,11 +130,12 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 return true;
             }
             catch {
-                // DNS / TLS / connection / timeout: nothing to judge — the
-                // client keeps the plain iframe.
                 sendJson(res, 200, {
                     ok: true,
-                    data: { probe: { reachable: false }, verdict: "unknown" },
+                    data: {
+                        probe: { reachable: false },
+                        verdict: "unknown",
+                    },
                 });
                 return true;
             }
@@ -124,6 +143,27 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 clearTimeout(timer);
             }
         }
+        if (method === "POST" && parts.length >= 1) {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, {
+                    ok: false,
+                    error: { code: scope.code, message: scope.message },
+                });
+                return true;
+            }
+            if (!deps.automation) {
+                sendJson(res, 503, {
+                    ok: false,
+                    error: { code: "BROWSER_UNAVAILABLE", message: "browser service unavailable" },
+                });
+                return true;
+            }
+            const body = await readJson(req);
+            const result = await dispatchBrowserPost(deps.automation, sub, body);
+            sendJson(res, 200, { ok: true, data: result });
+            return true;
+        }
         sendJson(res, 404, {
             ok: false,
             error: { code: "NOT_FOUND", message: `unknown browser route: ${method} ${pathname}` },
@@ -132,13 +172,7 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
     }
     catch (error) {
         if (!res.headersSent) {
-            sendJson(res, 500, {
-                ok: false,
-                error: {
-                    code: "BROWSER_INTERNAL",
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            });
+            sendJson(res, 500, { ok: false, error: errorPayload(error) });
         }
         else {
             res.end();
@@ -146,3 +180,101 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
         return true;
     }
 }
+async function dispatchBrowserPost(automation, action, body) {
+    switch (action) {
+        case "navigate": {
+            const result = await automation.navigate(string(body.url));
+            if (!result.ok)
+                throw new BrowserRouteError(result.code, result.error);
+            return result.page;
+        }
+        case "focus":
+            return automation.focus();
+        case "reload":
+            return automation.reload();
+        case "back":
+            return automation.goBack();
+        case "forward":
+            return automation.goForward();
+        case "scroll":
+            return automation.scroll({
+                direction: body.direction === "up" ? "up" : "down",
+                amount: numberOrUndefined(body.amount),
+            });
+        case "tab":
+            if (body.mode === "new")
+                return automation.newTab(optionalString(body.url));
+            if (body.mode === "close")
+                return automation.closeTab(numberOrUndefined(body.tabId));
+            return automation.selectTab(number(body.tabId));
+        case "dialog":
+            return automation.handleDialog(body.action === "dismiss" ? "dismiss" : "accept", optionalString(body.promptText));
+        case "pointer": {
+            const type = string(body.type);
+            if (!["mousemove", "mousedown", "mouseup", "wheel"].includes(type)) {
+                throw new Error("invalid pointer event type");
+            }
+            const event = type === "wheel"
+                ? {
+                    type,
+                    x: number(body.x),
+                    y: number(body.y),
+                    deltaX: number(body.deltaX ?? 0),
+                    deltaY: number(body.deltaY ?? 0),
+                }
+                : {
+                    type,
+                    x: number(body.x),
+                    y: number(body.y),
+                    ...(body.button === "middle" || body.button === "right"
+                        ? { button: body.button }
+                        : {}),
+                };
+            return automation.dispatchPointer(event);
+        }
+        case "keyboard": {
+            const type = string(body.type);
+            if (type !== "keydown" && type !== "keyup")
+                throw new Error("invalid keyboard event type");
+            const key = string(body.key);
+            if (!isPanelKeyboardKey(key)) {
+                throw new Error("invalid keyboard key; use the text action for printable characters");
+            }
+            return automation.dispatchKeyboard({ type, key });
+        }
+        case "text":
+            return automation.inputText(string(body.text));
+        case "wait":
+            return automation.waitFor(number(body.ms ?? 500));
+        default:
+            throw new Error(`unknown browser action: ${action}`);
+    }
+}
+class BrowserRouteError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "BrowserRouteError";
+    }
+}
+function string(value) {
+    if (typeof value !== "string")
+        throw new Error("expected string");
+    return value;
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function number(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new Error("expected finite number");
+    return value;
+}
+function numberOrUndefined(value) {
+    return value === undefined || value === null ? undefined : number(value);
+}
+function isPanelKeyboardKey(key) {
+    return /^(Control|Meta|Alt|Shift)(\+[A-Za-z0-9][A-Za-z0-9]*)?$/.test(key)
+        || (key.length > 1 && /^[A-Za-z][A-Za-z0-9]*$/.test(key));
+}

package/dist/worker/console/chat/explore-tools.js

@@ -279,8 +279,11 @@ export async function safeGrep(repoRoot, pattern, options) {
             for (let i = 0; i < lines.length; i++) {
                 if (matches.length >= GREP_MATCH_LIMIT)
                     break;
-                if (re.test(lines[i])) {
-                    const { scrubbed, redactions } = scrubSecrets(lines[i]);
+                const line = lines[i];
+                if (line === undefined)
+                    continue;
+                if (re.test(line)) {
+                    const { scrubbed, redactions } = scrubSecrets(line);
                     if (redactions.length > 0) {
                         for (const r of redactions) {
                             const found = totalRedactions.find((t) => t.name === r.name);

package/dist/worker/console/chat/pi-mode-loop-isolation.js

@@ -0,0 +1,155 @@
+/**
+ * Pi-mode loop isolation for loop-agent init projections.
+ *
+ * Pi mode ("自由对话") should not auto-load the governance AGENTS.md managed
+ * block that `loop-agent init` writes into a target project, nor the loop-agent
+ * built-in skills it mirrors into `<cwd>/.agents/skills/`. Manual `/skills:name`
+ * invocation and third-party/custom project skills must stay available; the
+ * Workflow mode is untouched (isolation applied only for `sessionMode ===
+ * "pi"`).
+ *
+ * Everything here is a pure function over discovered resources + persisted
+ * auto-invocation prefs, so it is trivially unit-testable.
+ */
+import path from "node:path";
+import { skillResourceId, } from "./resource-preferences-store.js";
+/** init.ts `MANAGED_BLOCK_START` / `MANAGED_BLOCK_END` (docs/templates/init-managed-agents.md). */
+export const LOOP_AGENTS_MANAGED_BLOCK_START = "<!-- LOOP_AGENT_INIT_START -->";
+export const LOOP_AGENTS_MANAGED_BLOCK_END = "<!-- LOOP_AGENT_INIT_END -->";
+/**
+ * Built-in skill directory names that `loop-agent init` mirrors from the
+ * package's `skills/` into a target project's `.agents/skills/`.
+ *
+ * MUST be kept in sync with the repo-root `skills/` directory; a CI check
+ * asserts they match (see `scripts/check-loop-builtin-skills.sh`).
+ */
+export const LOOP_BUILTIN_SKILL_DIR_NAMES = [
+    "agent-worker",
+    "ai-engineering-context",
+    "analyze-product-dependencies",
+    "analyze-product-requirements",
+    "browser-tools",
+    "code-review-core",
+    "codebase-scout",
+    "fe-test-ui-scout",
+    "frontend-bounded-implement",
+    "frontend-contract",
+    "frontend-design-review",
+    "frontend-plan",
+    "frontend-review",
+    "frontend-scout",
+    "frontend-verification",
+    "grill-me",
+    "grill-with-docs",
+    "improve-codebase-architecture",
+    "init-capability-evolution",
+    "local-jacoco-coverage",
+    "loop-agent",
+    "playwright-cli",
+    "playwright-cli-case-generator",
+    "requesting-code-review",
+    "systematic-debugging",
+    "test-driven-development",
+    "using-git-worktrees",
+    "verification-before-completion",
+    "webapp-testing",
+];
+/* Case-insensitive set for fast membership (paths are compared lower-cased). */
+const LOOP_BUILTIN_SKILL_NAMES_LOWER = new Set(LOOP_BUILTIN_SKILL_DIR_NAMES.map((name) => name.toLowerCase()));
+/** Normalize to forward slashes + lower case for Windows/macOS path compares. */
+function normalizeForCompare(value) {
+    return value.replace(/\\/g, "/").toLowerCase();
+}
+/**
+ * Strip the loop-agent init managed block (inclusive of both markers) from an
+ * AGENTS.md content string.
+ *
+ * Returns the content unchanged when no valid marker pair is present (missing
+ * either marker, or END before START), so user-authored AGENTS.md and non-loop
+ * roots are never touched.
+ */
+export function stripLoopManagedBlock(content) {
+    const start = content.indexOf(LOOP_AGENTS_MANAGED_BLOCK_START);
+    if (start < 0)
+        return content;
+    const end = content.indexOf(LOOP_AGENTS_MANAGED_BLOCK_END, start + LOOP_AGENTS_MANAGED_BLOCK_START.length);
+    if (end < 0)
+        return content;
+    const endPos = end + LOOP_AGENTS_MANAGED_BLOCK_END.length;
+    const before = content.slice(0, start).trimEnd();
+    const after = content.slice(endPos).trimStart();
+    return `${before}${before && after ? "\n\n" : ""}${after}`;
+}
+/**
+ * True when a discovered skill is a loop-agent init projection: its file path
+ * is under `<cwd>/.agents/skills/<builtin-name>/` for a name in the builtin
+ * whitelist. Global user skills (`~/.agents/skills`, `~/.pi/agent/skills`) and
+ * third-party project skills outside the whitelist return false.
+ */
+export function isLoopInitProjectedSkill(skill, cwd) {
+    if (!skill?.filePath)
+        return false;
+    const cwdNorm = normalizeForCompare(path.resolve(cwd));
+    const fileNorm = normalizeForCompare(path.resolve(skill.filePath));
+    const prefix = `${cwdNorm}/.agents/skills/`;
+    if (!fileNorm.startsWith(prefix))
+        return false;
+    const rest = fileNorm.slice(prefix.length);
+    const topSeg = rest.split("/")[0];
+    if (!topSeg)
+        return false;
+    return LOOP_BUILTIN_SKILL_NAMES_LOWER.has(topSeg);
+}
+/**
+ * Pi-mode default isolation over skills: for skills that are loop init
+ * projections, default `disableModelInvocation` to true UNLESS the user has
+ * EXPLICITLY tuned auto-invocation ON for that resource id in the persisted
+ * prefs. Explicitly ON wins over the Pi default; explicit OFF is treated as the
+ * Pi default. Non-loop skills pass through untouched.
+ */
+export function applyPiModeSkillIsolation(skills, prefs, cwd) {
+    return skills.map((skill) => {
+        if (!isLoopInitProjectedSkill(skill, cwd))
+            return skill;
+        const id = skillResourceId(skill);
+        const pref = prefs.skills[id];
+        if (pref?.autoInvocationEnabled === true)
+            return skill;
+        if (skill.disableModelInvocation === true)
+            return skill;
+        return { ...skill, disableModelInvocation: true };
+    });
+}
+/**
+ * Build the pi-mode loop isolation resource-loader option fragments.
+ *
+ * - When `enabled` (session mode pi): returns an `agentsFilesOverride` that
+ *   strips the loop-agent managed AGENTS.md block, and wraps the given
+ *   `skillsOverride` so it ALSO applies Pi-mode default isolation after the
+ *   persisted auto-invocation prefs.
+ * - When disabled (workflow): returns ONLY the provided `skillsOverride`
+ *   unchanged, so workflow session behavior is byte-for-byte identical to today.
+ */
+export function buildPiModeLoopIsolationOptions(options) {
+    if (!options.enabled) {
+        return { skillsOverride: options.skillsOverride };
+    }
+    const { cwd, readPreferences } = options;
+    const agentsFilesOverride = (current) => ({
+        agentsFiles: current.agentsFiles.map((file) => ({
+            ...file,
+            content: stripLoopManagedBlock(file.content),
+        })),
+    });
+    return {
+        agentsFilesOverride,
+        skillsOverride: (current) => {
+            const prefs = readPreferences() ?? { schemaVersion: 1, skills: {} };
+            const withPrefs = options.skillsOverride(current);
+            return {
+                skills: applyPiModeSkillIsolation(withPrefs.skills, prefs, cwd),
+                diagnostics: current.diagnostics,
+            };
+        },
+    };
+}

package/dist/worker/console/chat/pi-runtime/custom-tools/ask-user-question.js

@@ -0,0 +1,44 @@
+/**
+ * Session-bound ask_user_question custom tool.
+ * ConsolePiRuntime supplies the sessionId and UserQuestionRegistry.
+ */
+const ASK_USER_QUESTION_DESCRIPTION = "Ask the user concise questions when a confirmation, choice, or missing detail is required before proceeding. " +
+    "The tool pauses until the user answers. Use it instead of writing questions as ordinary assistant text. " +
+    "Send one or more questions with stable ids; recommended options should be first and end with (Recommended).";
+export async function buildAskUserQuestionTool(options) {
+    const [{ Type }, { defineTool }] = await Promise.all([
+        import("typebox"),
+        import("@earendil-works/pi-coding-agent"),
+    ]);
+    return defineTool({
+        name: "ask_user_question",
+        label: "Ask user",
+        description: ASK_USER_QUESTION_DESCRIPTION,
+        promptSnippet: ASK_USER_QUESTION_DESCRIPTION,
+        parameters: Type.Object({
+            questions: Type.Array(Type.Object({
+                id: Type.String({ description: "Stable question id echoed in the answer." }),
+                question: Type.String({ description: "Specific user-facing question." }),
+                header: Type.Optional(Type.String({ description: "Optional short heading." })),
+                detail: Type.Optional(Type.String({ description: "Optional Markdown context shown below the question." })),
+                options: Type.Optional(Type.Array(Type.Object({
+                    label: Type.String({ description: "Short user-facing option label." }),
+                    description: Type.Optional(Type.String({ description: "One sentence explaining impact or tradeoff." })),
+                }, { additionalProperties: false }))),
+                multi_select: Type.Optional(Type.Boolean({ description: "Allow more than one option." })),
+            }, { additionalProperties: false }), { minItems: 1, maxItems: 20 }),
+        }, { additionalProperties: false }),
+        async execute(toolCallId, params, signal) {
+            const answer = await options.registry.ask({
+                sessionId: options.sessionId,
+                toolCallId,
+                questions: params.questions,
+                signal,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(answer) }],
+                details: answer,
+            };
+        },
+    });
+}