@yagni-app/code-staging 1.2.3-staging.1570.1 → 1.2.3-staging.1580.1

package/dist/extension/prototypeVerify.js

@@ -0,0 +1,219 @@
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { Type } from "typebox";
+import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
+import { logEvent } from "./errorSink.js";
+async function launchProjectBrowser(cwd) {
+    const require = createRequire(join(cwd, "package.json"));
+    let runtime;
+    try {
+        runtime = require("playwright");
+    }
+    catch {
+        runtime = require("@playwright/test");
+    }
+    const browser = await runtime.chromium.launch({ headless: true, timeout: 10_000 });
+    return {
+        async open(viewport, allow) {
+            const context = await browser.newContext({ viewport, serviceWorkers: "block", permissions: [], acceptDownloads: false });
+            await context.route("**/*", async (route) => {
+                if (allow(route.request().url()))
+                    await route.continue();
+                else
+                    await route.abort();
+            });
+            // Block sockets too; request routing alone does not cover WebSockets.
+            await context.routeWebSocket("**/*", socket => socket.close());
+            const page = await context.newPage();
+            return {
+                async navigate(url) {
+                    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 10_000 });
+                    if (!allow(page.url()))
+                        throw new Error("Navigation left the verification origin");
+                },
+                async act(action) {
+                    const target = page.getByRole(action.role, { name: action.name, exact: true });
+                    if (action.action === "click")
+                        await target.click({ timeout: 3_000 });
+                    else
+                        await target.fill(action.value ?? "", { timeout: 3_000 });
+                    if (!allow(page.url()))
+                        throw new Error("Navigation left the verification origin");
+                },
+                async hasText(text) {
+                    try {
+                        await page.getByText(text, { exact: false }).first().waitFor({ state: "visible", timeout: 3_000 });
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                screenshot: () => page.screenshot({ type: "png", fullPage: false, timeout: 3_000 }),
+                close: () => context.close(),
+            };
+        },
+        close: () => browser.close(),
+    };
+}
+function loopbackOrigin(value) {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol) || !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) || url.username || url.password) {
+        throw new Error("Prototype verification requires a credential-free loopback http(s) URL");
+    }
+    return url.origin;
+}
+/** Race an operation against the run's deadline, so a hung browser call cannot outlive it. */
+function boundedBy(deadline) {
+    return async (operation) => {
+        if (deadline.aborted) {
+            void operation.catch(() => { });
+            deadline.throwIfAborted();
+        }
+        let rejectAbort;
+        try {
+            return await Promise.race([operation, new Promise((_resolve, reject) => {
+                    rejectAbort = () => reject(deadline.reason);
+                    deadline.addEventListener("abort", rejectAbort, { once: true });
+                })]);
+        }
+        finally {
+            if (rejectAbort)
+                deadline.removeEventListener("abort", rejectAbort);
+        }
+    };
+}
+/** One viewport: navigate, run each check's actions, then the screenshot the reviewer compares. */
+async function verifyViewport(page, input, label, bounded, checkCancelled) {
+    const checks = [];
+    await bounded(page.navigate(input.url));
+    for (const check of input.checks) {
+        checkCancelled();
+        let passed = false;
+        try {
+            for (const action of check.actions ?? []) {
+                checkCancelled();
+                await bounded(page.act(action));
+            }
+            passed = await bounded(page.hasText(check.expectText));
+        }
+        catch {
+            checkCancelled();
+        }
+        checks.push({ name: `${label}: ${check.name}`, status: passed ? "passed" : "failed", detail: passed ? "Expected text observed after the requested interactions." : "Requested interaction or visible text did not match." });
+    }
+    checkCancelled();
+    const png = await bounded(page.screenshot());
+    if (png.length > 2 * 1024 * 1024)
+        throw new Error("Screenshot exceeds the upload limit");
+    return { checks, png };
+}
+function errorReason(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").slice(0, 200);
+}
+export async function verifyPrototype(opts, input, cwd, signal) {
+    const origin = loopbackOrigin(input.url);
+    if (!Number.isInteger(input.revision) || input.revision < 1 || input.checks.length < 1 || input.checks.length > 8 || input.checks.some(check => (check.actions?.length ?? 0) > 8))
+        throw new Error("Verification requires a revision and 1–8 bounded checks");
+    const viewports = input.viewports ?? [{ width: 390, height: 844 }, { width: 1280, height: 800 }];
+    if (viewports.length < 1 || viewports.length > 3 || viewports.some(v => !Number.isInteger(v.width) || !Number.isInteger(v.height) || v.width < 320 || v.width > 1920 || v.height < 320 || v.height > 1200))
+        throw new Error("Invalid verification viewports");
+    const result = { revision: input.revision, status: "unverified", summary: "Browser verification unavailable.", checks: [], screenshots: [] };
+    const allow = (url) => { try {
+        return new URL(url).origin === origin;
+    }
+    catch {
+        return false;
+    } };
+    const deadline = new AbortController();
+    const post = async (suffix, body) => {
+        const response = await resilientFetch(`${opts.baseUrl}/api/yagni-code/prototypes/${encodeURIComponent(input.prototypeId)}/${suffix}`, {
+            method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${opts.getToken() ?? ""}` }, body: JSON.stringify(body),
+        }, { fetchImpl: opts.fetchImpl, signal: suffix === "verification" ? signal : deadline.signal, policy: METERED_POST_FETCH_POLICY });
+        if (!response.ok)
+            throw new Error(await friendlyFetchError("prototype_verify", response));
+        return await response.json();
+    };
+    let browser;
+    let timedOut = false;
+    let closing;
+    const close = () => { if (browser && !closing)
+        closing = browser.close().catch(() => { }); };
+    const abort = () => { deadline.abort(signal?.reason); close(); };
+    const timer = setTimeout(() => { timedOut = true; deadline.abort(new Error("Verification timed out")); close(); }, Math.min(opts.timeoutMs ?? 45_000, 45_000));
+    signal?.addEventListener("abort", abort, { once: true });
+    const bounded = boundedBy(deadline.signal);
+    const checkCancelled = () => {
+        signal?.throwIfAborted();
+        if (timedOut)
+            throw new Error("Verification timed out");
+    };
+    try {
+        checkCancelled();
+        const activeBrowser = await bounded((opts.launchBrowser ?? launchProjectBrowser)(cwd).then(launched => {
+            if (deadline.signal.aborted)
+                void launched.close().catch(() => { });
+            return launched;
+        }));
+        browser = activeBrowser;
+        checkCancelled();
+        for (const viewport of viewports) {
+            checkCancelled();
+            const page = await bounded(activeBrowser.open(viewport, allow));
+            try {
+                const label = `${viewport.width}x${viewport.height}`;
+                const { checks, png } = await verifyViewport(page, input, label, bounded, checkCancelled);
+                result.checks.push(...checks);
+                const uploaded = await post("screenshots", { revision: input.revision, label, pngBase64: png.toString("base64") });
+                if (!uploaded.url)
+                    throw new Error("Screenshot upload returned no evidence URL");
+                result.screenshots.push({ label, url: uploaded.url });
+            }
+            finally {
+                await bounded(page.close()).catch(() => { });
+            }
+        }
+        checkCancelled();
+        result.status = result.checks.every(check => check.status === "passed") && result.screenshots.length === viewports.length ? "passed" : "failed";
+        result.summary = result.status === "passed" ? "Requested interactions and visible text passed at every viewport; screenshots captured for visual review." : "One or more requested browser checks failed; review the captured screenshots.";
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        // Every failure records the same honest status, but keeps its cause: a
+        // missing Playwright, a crashed browser and a failed upload need
+        // different fixes.
+        const reason = errorReason(error);
+        logEvent({ source: "tool", level: "warn", event: "prototype_verify.unavailable", fields: { timedOut, reason } });
+        result.status = "unverified";
+        result.summary = timedOut
+            ? "Browser verification exceeded its time limit; incomplete checks remain unverified."
+            : `Browser, local app, or screenshot evidence unavailable (${reason}); verification is incomplete.`;
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
+        close();
+        if (closing)
+            await Promise.race([closing, new Promise(resolve => { const cleanupTimer = setTimeout(resolve, 2_000); cleanupTimer.unref(); })]);
+    }
+    signal?.throwIfAborted();
+    await post("verification", result);
+    return result;
+}
+const parameters = Type.Object({
+    prototypeId: Type.String(), revision: Type.Integer({ minimum: 1 }), url: Type.String(),
+    checks: Type.Array(Type.Object({ name: Type.String(), expectText: Type.String(), actions: Type.Optional(Type.Array(Type.Object({ action: Type.Union([Type.Literal("click"), Type.Literal("fill")]), role: Type.String(), name: Type.String(), value: Type.Optional(Type.String()) }), { maxItems: 8 })) }), { minItems: 1, maxItems: 8 }),
+    viewports: Type.Optional(Type.Array(Type.Object({ width: Type.Integer({ minimum: 320, maximum: 1920 }), height: Type.Integer({ minimum: 320, maximum: 1200 }) }), { minItems: 1, maxItems: 3 })),
+});
+export function makePrototypeVerifyTool(opts) {
+    return {
+        name: "prototype_verify", label: "Verify prototype implementation",
+        description: "Run real browser interaction checks on the implemented local app against an exact prototype revision and capture desktop/mobile screenshots for visual review. Supply agreed state checks from prototype_read and synthetic fill values only. Uses existing project Playwright without installing anything, in a fresh credential-free context restricted to the local app origin. Records passed/failed observed checks or explicitly unverified when the browser/app/evidence is unavailable. Screenshots support human visual comparison; passing text checks does not prove visual equivalence.",
+        parameters,
+        async execute(_id, input, signal, _update, context) {
+            const result = await verifyPrototype(opts, input, context.cwd, signal);
+            return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+        },
+    };
+}
+//# sourceMappingURL=prototypeVerify.js.map

package/dist/extension/subagents.d.ts

@@ -134,8 +134,9 @@ export interface MakeSubagentToolDeps {
 /**
  * The subagent lane's wall-clock ceiling: two hours per child.
  *
- * The /go stage default (20 minutes) is sized for one pipeline step; a chat
- * subagent is routinely handed a whole review, and at 20 minutes the runner
+ * The /go stage default (20 minutes when this was set, an hour since) is
+ * sized for one pipeline step; a chat subagent is routinely handed a whole
+ * review, and at 20 minutes the runner
  * killed three parallel reviewers mid-report and threw their findings away
  * as "PARTIAL output". The wall clock is not the stall guard — the idle timer
  * (4 minutes, deferred while a tool is in flight) is what catches a hung

package/dist/extension/subagents.js

@@ -465,8 +465,9 @@ const parameters = Type.Object({
 /**
  * The subagent lane's wall-clock ceiling: two hours per child.
  *
- * The /go stage default (20 minutes) is sized for one pipeline step; a chat
- * subagent is routinely handed a whole review, and at 20 minutes the runner
+ * The /go stage default (20 minutes when this was set, an hour since) is
+ * sized for one pipeline step; a chat subagent is routinely handed a whole
+ * review, and at 20 minutes the runner
  * killed three parallel reviewers mid-report and threw their findings away
  * as "PARTIAL output". The wall clock is not the stall guard — the idle timer
  * (4 minutes, deferred while a tool is in flight) is what catches a hung

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.3-staging.1570.1",
+  "version": "1.2.3-staging.1580.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "cf9eadbc3cdaaa5eb222270223c092ce900fd9cc"
+  "yagniSourceSha": "8592117c432a85b840ac26dd74f48e84d6bb3a1a"
 }