@hamp10/agentforge 0.2.26 → 0.2.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamp10/agentforge",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "AgentForge worker — connect your machine to agentforge.ai",
   "type": "module",
   "bin": {

package/scripts/check-task-semantics.js

@@ -35,6 +35,12 @@ const cases = [
     absent: ['example-com', 'delete', 'rebuild', 'readability', 'design', 'urls', 'site'],
     pageOnly: true,
   },
+  {
+    text: 'Delete and rebuild the listing pages for Alpha and Beta from a clean start. Only change those listing pages.',
+    slugs: ['alpha', 'beta'],
+    absent: ['beta-from', 'clean-start', 'from'],
+    pageOnly: true,
+  },
   {
     text: 'Work on Alpha pages for readability',
     slugs: ['alpha'],
@@ -214,6 +220,25 @@ try {
   const worker = Object.create(AgentForgeWorker.prototype);
   worker.cli = { isAnthropicApiKey: (key) => /^sk-ant-/i.test(String(key || '')) };
   const cli = Object.create(OpenClawCLI.prototype);
+  const deletedScopedPagePath = path.join(fixture.repo, 'public_html', 'domains', 'alpha.html');
+  rmSync(deletedScopedPagePath, { force: true });
+  assert.equal(
+    worker._buildDeletedScopedPageNudge(
+      [{ root: fixture.repo, head: fixture.head }],
+      'Delete the Example.com listing page for Alpha. Only change that listing page.'
+    ),
+    '',
+    'explicit page deletion tasks should be allowed to leave the scoped target page deleted'
+  );
+  assert.match(
+    worker._buildDeletedScopedPageNudge(
+      [{ root: fixture.repo, head: fixture.head }],
+      'Delete and rebuild the Alpha listing page from a clean start, preserving the same URL. Only change that listing page.'
+    ),
+    /deleted target page source\(s\) still missing/i,
+    'clean-start rebuild tasks should still require the scoped target page to be recreated'
+  );
+  git(fixture.repo, ['restore', '--', 'public_html/domains/alpha.html']);
   const projectsRoot = mkdtempSync(path.join(tmpdir(), 'agentforge-project-list-'));
   let agentWorkspace = null;
   try {
@@ -944,6 +969,16 @@ assert.match(
   /__agentforge_verify/i,
   'direct browser verification should cache-bust local verification URLs'
 );
+assert.match(
+  openClawSource,
+  /normalizeForNavigationCompare\(target\?\.url \|\| ''\) === normalizeForNavigationCompare\(effectiveRequestedUrl\)/,
+  'direct browser verification should reuse an existing cache-busted tab for the same requested local URL'
+);
+assert.match(
+  openClawSource,
+  /isLocalVerificationUrl[\s\S]*__agentforge_verify[\s\S]*closeDuplicateVerificationTargets[\s\S]*\/json\/close\//i,
+  'direct browser verification should close duplicate cache-busted local verification tabs'
+);
 assert.match(
   openClawSource,
   /forgetLocalScopedUrl[\s\S]*rendered page content did not identify target|rendered page content did not identify target[\s\S]*forgetLocalScopedUrl/i,
@@ -959,6 +994,16 @@ assert.match(
   /__agentforge_verify/i,
   'AgentForge browser tool should cache-bust localhost navigations'
 );
+assert.match(
+  browserSource,
+  /sameBrowserTargetUrl[\s\S]*stripLocalCacheBust[\s\S]*getPage\(agentId, url\)/i,
+  'AgentForge browser tool should reuse cache-busted tabs for the same requested local URL'
+);
+assert.match(
+  browserSource,
+  /isLocalVerificationUrl[\s\S]*__agentforge_verify[\s\S]*closeStaleVerificationTabs[\s\S]*page\.close/i,
+  'AgentForge browser tool should close stale cache-busted localhost verification tabs'
+);
 assert.match(
   previewServerSource,
   /extname\(urlPath\)[\s\S]*writeHead\(404[\s\S]*no-store/i,

package/src/OpenClawCLI.js

@@ -2761,6 +2761,8 @@ export class OpenClawCLI extends EventEmitter {
     const normalizeForNavigationCompare = (value) => stripAgentForgeCacheBust(normalize(value));
     const isLocalHttpUrl = (value) =>
       /^https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?(?:\/|$)/i.test(String(value || ''));
+    const isLocalVerificationUrl = (value) =>
+      isLocalHttpUrl(value) && /[?&]__agentforge_verify=/.test(String(value || ''));
     const withVerificationCacheBust = (value) => {
       if (!value || !isLocalHttpUrl(value)) return value;
       try {
@@ -2790,9 +2792,35 @@ export class OpenClawCLI extends EventEmitter {
     const usablePages = !taskIsAboutAgentForge
       ? pages.filter(p => !isAgentForgeControlSurface(p.url))
       : pages;
+    const matchesEffectiveRequestedUrl = (target) =>
+      !!effectiveRequestedUrl && normalizeForNavigationCompare(target?.url || '') === normalizeForNavigationCompare(effectiveRequestedUrl);
+    const requestedPageMatches = effectiveRequestedUrl
+      ? pages.filter(matchesEffectiveRequestedUrl)
+      : [];
     let page = effectiveRequestedUrl
-      ? pages.find(p => normalize(p.url) === normalize(effectiveRequestedUrl))
+      ? requestedPageMatches.find(p => !isLocalVerificationUrl(p.url)) || requestedPageMatches[0] || null
       : usablePages.find(p => p.url && p.url !== 'about:blank') || null;
+    const closeDuplicateVerificationTargets = async (keepTarget) => {
+      if (!effectiveRequestedUrl || !keepTarget) return;
+      const staleTargets = requestedPageMatches.filter(target =>
+        target.id !== keepTarget.id &&
+        isLocalVerificationUrl(target.url) &&
+        normalizeForNavigationCompare(target.url) === normalizeForNavigationCompare(effectiveRequestedUrl)
+      );
+      if (staleTargets.length === 0) return;
+      let closed = 0;
+      await Promise.all(staleTargets.map(async (target) => {
+        try {
+          const closeResp = await fetch(`${cdpBase}/json/close/${encodeURIComponent(target.id)}`, {
+            signal: AbortSignal.timeout(3_000),
+          });
+          if (closeResp.ok) closed += 1;
+        } catch {}
+      }));
+      if (closed > 0) {
+        console.log(`   [${agentId}] 🧹 Closed ${closed} stale verification tab(s) for ${stripAgentForgeCacheBust(effectiveRequestedUrl)}`);
+      }
+    };
 
     const controlSurfaceUrl = effectiveRequestedUrl || page?.url || '';
     if (!taskIsAboutAgentForge && isAgentForgeControlSurface(controlSurfaceUrl)) {
@@ -2811,6 +2839,7 @@ export class OpenClawCLI extends EventEmitter {
       if (!newResp.ok) throw new Error(`CDP new page failed: HTTP ${newResp.status}`);
       page = await newResp.json();
     }
+    await closeDuplicateVerificationTargets(page);
 
     const ws = new WebSocket(page.webSocketDebuggerUrl);
     let seq = 0;
@@ -2892,7 +2921,14 @@ export class OpenClawCLI extends EventEmitter {
         }
         return lastState;
       };
-      if (effectiveRequestedUrl && normalizeForNavigationCompare(page.url) !== normalizeForNavigationCompare(effectiveRequestedUrl)) {
+      const currentPageMatchesRequest = effectiveRequestedUrl && normalizeForNavigationCompare(page.url) === normalizeForNavigationCompare(effectiveRequestedUrl);
+      const shouldNavigateForFreshVerification = !!(
+        effectiveRequestedUrl &&
+        options?.afterMutation &&
+        navigationRequestedUrl &&
+        navigationRequestedUrl !== effectiveRequestedUrl
+      );
+      if (effectiveRequestedUrl && (!currentPageMatchesRequest || shouldNavigateForFreshVerification)) {
         await cdp('Page.navigate', { url: navigationRequestedUrl || effectiveRequestedUrl });
         await waitForRequestedDocument(effectiveRequestedUrl);
       } else if (effectiveRequestedUrl) {

package/src/browser.js

@@ -25,6 +25,43 @@ async function getBrowser() {
   return _browser;
 }
 
+function stripLocalCacheBust(value) {
+  try {
+    const parsed = new URL(value);
+    parsed.searchParams.delete('__agentforge_verify');
+    return parsed.href.replace(/\/$/, '');
+  } catch {
+    return String(value || '').replace(/([?&])__agentforge_verify=[^&#]+&?/, '$1').replace(/[?&]$/, '').replace(/\/$/, '');
+  }
+}
+
+function sameBrowserTargetUrl(left, right) {
+  if (!left || !right) return false;
+  return stripLocalCacheBust(left) === stripLocalCacheBust(right);
+}
+
+function isLocalVerificationUrl(value) {
+  return isLocalHttpUrl(value) && /[?&]__agentforge_verify=/.test(String(value || ''));
+}
+
+async function closeStaleVerificationTabs(browser, keepPage, targetUrl) {
+  const expected = targetUrl ? stripLocalCacheBust(targetUrl) : '';
+  const pages = await browser.pages();
+  let closed = 0;
+  await Promise.all(pages.map(async (page) => {
+    if (!page || page.isClosed() || page === keepPage) return;
+    let url = '';
+    try { url = page.url(); } catch { return; }
+    if (!isLocalVerificationUrl(url)) return;
+    if (expected && stripLocalCacheBust(url) !== expected) return;
+    try {
+      await page.close();
+      closed += 1;
+    } catch {}
+  }));
+  if (closed > 0) console.log(`[browser.js] Closed ${closed} stale verification tab(s) for ${targetUrl || 'local browser'}`);
+}
+
 // Return the active page for this agent. Creates a fresh tab on first use.
 // preferUrl: hint — if the agent's tab already has a better match among all open
 // tabs (e.g. a link opened a new tab), update the agent's pointer to it.
@@ -37,7 +74,7 @@ async function getPage(agentId, preferUrl) {
     // If preferUrl given, check if any tab matches better (handles new-tab links)
     if (preferUrl) {
       const pages = await browser.pages();
-      const match = pages.find(p => !p.isClosed() && p.url().includes(preferUrl));
+      const match = pages.find(p => !p.isClosed() && sameBrowserTargetUrl(p.url(), preferUrl));
       if (match && match !== existing) {
         _agentPages.set(agentId, match);
         return match;
@@ -46,6 +83,15 @@ async function getPage(agentId, preferUrl) {
     return existing;
   }
 
+  if (preferUrl) {
+    const pages = await browser.pages();
+    const match = pages.find(p => !p.isClosed() && sameBrowserTargetUrl(p.url(), preferUrl));
+    if (match) {
+      _agentPages.set(agentId, match);
+      return match;
+    }
+  }
+
   // Agent has no page — open a fresh tab so it doesn't land on another agent's tab
   const fresh = await browser.newPage();
   _agentPages.set(agentId, fresh);
@@ -71,23 +117,14 @@ function withLocalCacheBust(value) {
 }
 
 async function waitForPageReady(page, expectedUrl) {
-  const stripCacheBust = (value) => {
-    try {
-      const parsed = new URL(value);
-      parsed.searchParams.delete('__agentforge_verify');
-      return parsed.href.replace(/\/$/, '');
-    } catch {
-      return String(value || '').replace(/([?&])__agentforge_verify=[^&#]+&?/, '$1').replace(/[?&]$/, '').replace(/\/$/, '');
-    }
-  };
-  const expected = expectedUrl ? stripCacheBust(expectedUrl) : '';
+  const expected = expectedUrl ? stripLocalCacheBust(expectedUrl) : '';
   for (let i = 0; i < 45; i++) {
     try {
       const state = await page.evaluate(() => ({
         href: location.href,
         readyState: document.readyState,
       }));
-      if ((!expected || stripCacheBust(state.href) === expected) && state.readyState !== 'loading') return;
+      if ((!expected || stripLocalCacheBust(state.href) === expected) && state.readyState !== 'loading') return;
     } catch {
       // Page contexts can disappear while navigation commits.
     }
@@ -200,7 +237,7 @@ async function _browserActionInner(input, agentId, browser) {
       case 'navigate':
       case 'open': {
         const url = input.url || input.targetUrl;
-        const page = await getPage(agentId);
+        const page = await getPage(agentId, url);
         await page.setCacheEnabled(false).catch(() => null);
         const navigationUrl = withLocalCacheBust(url);
         // Use Promise.race to enforce a hard 20s cap — page.goto timeout option can hang
@@ -215,6 +252,7 @@ async function _browserActionInner(input, agentId, browser) {
         _agentPages.set(agentId, page);
         // Brief pause for initial render, then snapshot
         await waitForPageReady(page, url);
+        await closeStaleVerificationTabs(browser, page, url);
         await _wait(400);
         return await _snapshot(page, agentId);
       }

package/src/taskSemantics.js

@@ -112,7 +112,7 @@ export function extractNamedPageScopeSlugs(message) {
     addScopeCandidate(candidates, match[1]);
   }
 
-  const afterPage = /\b(?:pages?|screens?|routes?|views?|listings?)\s+(?:for|of|called|named)\s+(?:the\s+)?([a-z0-9][a-z0-9 ._/-]{0,160}?)(?=$|[?!;]|\.(?:\s|$)|\s+(?:on|at|in|with|without|that|which|where|when|because|so|but)\b)/gi;
+  const afterPage = /\b(?:pages?|screens?|routes?|views?|listings?)\s+(?:for|of|called|named)\s+(?:the\s+)?([a-z0-9][a-z0-9 ._/-]{0,160}?)(?=$|[?!;]|\.(?:\s|$)|\s+(?:on|at|in|from|with|without|while|using|preserv(?:e|ing)|that|which|where|when|because|so|but)\b)/gi;
   for (const match of text.matchAll(afterPage)) {
     const before = text.slice(Math.max(0, match.index - 120), match.index);
     const precedingToken = before.match(/\b([a-z0-9][a-z0-9._/-]{2,})\s*$/i)?.[1] || '';
@@ -124,7 +124,7 @@ export function extractNamedPageScopeSlugs(message) {
 
   for (const match of text.matchAll(/\b[a-z0-9]+(?:[.-][a-z0-9]+)+\b/gi)) {
     const after = text.slice(match.index + match[0].length);
-    const pageTarget = after.match(/^\s+(?:listing\s+)?(?:pages?|screens?|routes?|views?|listings?)\s+(?:for|of|called|named)\s+(?:the\s+)?([a-z0-9][a-z0-9 ._/-]{0,160}?)(?=$|[?!;]|\.(?:\s|$)|\s+(?:on|at|in|with|without|that|which|where|when|because|so|but)\b)/i);
+    const pageTarget = after.match(/^\s+(?:listing\s+)?(?:pages?|screens?|routes?|views?|listings?)\s+(?:for|of|called|named)\s+(?:the\s+)?([a-z0-9][a-z0-9 ._/-]{0,160}?)(?=$|[?!;]|\.(?:\s|$)|\s+(?:on|at|in|from|with|without|while|using|preserv(?:e|ing)|that|which|where|when|because|so|but)\b)/i);
     if (pageTarget) {
       const targetCandidates = new Set();
       addScopeCandidate(targetCandidates, pageTarget[1]);

package/src/worker.js

@@ -501,6 +501,15 @@ export class AgentForgeWorker extends EventEmitter {
     return /\b(delete|remove|drop|strip|simplify|replace|rewrite|rebuild|from scratch|start over|nuke|wipe|clear out|throw away)\b/i.test(String(userMessage || ''));
   }
 
+  _allowsScopedPageSourcesToRemainDeleted(userMessage) {
+    const text = String(userMessage || '');
+    const asksForDeletion = /\b(delete|remove|drop|unpublish|decommission|take down|take offline)\b/i.test(text);
+    if (!asksForDeletion) return false;
+
+    const asksForRebuildOrRepair = /\b(rebuild|recreate|remake|rewrite|replace|restore|redesign|build|create|implement|fix|improve|polish|repair|start over|from scratch|clean start|fresh start|same urls?|same paths?|preserv(?:e|ing) the same urls?)\b/i.test(text);
+    return !asksForRebuildOrRepair;
+  }
+
   _parseNumstat(output, source) {
     const stats = [];
     for (const line of String(output || '').split('\n')) {
@@ -848,6 +857,7 @@ export class AgentForgeWorker extends EventEmitter {
 
   _findDeletedScopedPageSources(repoBaselines, userMessage) {
     if (!Array.isArray(repoBaselines) || repoBaselines.length === 0) return [];
+    if (this._allowsScopedPageSourcesToRemainDeleted(userMessage)) return [];
     const { slugs: allowedSlugs, pageOnly } = this._extractExplicitScope(userMessage);
     if (allowedSlugs.length === 0 || !pageOnly) return [];