npm - @hamp10/agentforge - Versions diffs - 0.2.34 → 0.2.36 - Mend

@hamp10/agentforge 0.2.34 → 0.2.36

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/package.json +1 -1
package/scripts/check-task-semantics.js +58 -0
package/src/OpenClawCLI.js +68 -6

package/package.json CHANGED Viewed

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

package/scripts/check-task-semantics.js CHANGED Viewed

@@ -604,6 +604,15 @@ try {
   const nestedDuplicateGamma = path.join(fixture.repo, path.basename(fixture.repo), 'public_html', 'domains', 'gamma.html');
   mkdirSync(path.dirname(nestedDuplicateGamma), { recursive: true });
   writeFileSync(nestedDuplicateGamma, '<!doctype html><html><body><h1>Gamma</h1></body></html>');
+  assert.throws(
+    () => cli._guardDirectFileWritePath(
+      nestedDuplicateGamma,
+      fixture.repo,
+      { task: 'Can you make listing pages for Gamma?' }
+    ),
+    /nested duplicate of the current project/i,
+    'same-name nested project-copy paths should be blocked even when the nested copy is tracked or preexisting'
+  );
   assert.doesNotThrow(
     () => cli._guardDirectFileWritePath(
       path.join(fixture.repo, 'public_html', 'domains', 'gamma.html'),
@@ -612,6 +621,55 @@ try {
     ),
     'nested duplicate project copies should not block recreating the canonical page path'
   );
+  const linkedWorkspace = mkdtempSync(path.join(tmpdir(), 'agentforge-linked-project-'));
+  try {
+    const linkedProjectPath = path.join(linkedWorkspace, path.basename(fixture.repo));
+    symlinkSync(fixture.repo, linkedProjectPath, 'dir');
+    assert.doesNotThrow(
+      () => cli._guardDirectFileWritePath(
+        path.join(linkedProjectPath, 'public_html', 'domains', 'gamma.html'),
+        fixture.repo,
+        { task: 'Can you make listing pages for Gamma?' }
+      ),
+      'agent-workspace symlink paths should canonicalize to the real project before scoped page guard checks'
+    );
+  } finally {
+    rmSync(linkedWorkspace, { recursive: true, force: true });
+  }
+  const knownProjectsRoot = mkdtempSync(path.join(tmpdir(), 'agentforge-known-projects-'));
+  const knownAgentWorkspace = mkdtempSync(path.join(tmpdir(), 'agentforge-known-agent-workspace-'));
+  try {
+    const knownProject = path.join(knownProjectsRoot, 'Hamp.com');
+    const knownDomainsDir = path.join(knownProject, 'public_html', 'domains');
+    mkdirSync(knownDomainsDir, { recursive: true });
+    writeFileSync(path.join(knownDomainsDir, 'agentforge-ai.html'), '<!doctype html><html><body><h1>AgentForge.ai</h1></body></html>');
+    writeFileSync(path.join(knownDomainsDir, 'adgenius-ai.html'), '<!doctype html><html><body><h1>AdGenius.ai</h1></body></html>');
+    symlinkSync(knownProject, path.join(knownAgentWorkspace, 'Hamp.com'), 'dir');
+    writeFileSync(path.join(knownAgentWorkspace, 'AGENTFORGE.md'), '# AgentForge.ai platform notes');
+    const knownProjectCli = Object.create(OpenClawCLI.prototype);
+    knownProjectCli._knownProjectsRoots = () => [knownProjectsRoot];
+    const mixedKnownProjectTask = 'Can you make Hamp.com listing pages for AgentBoard.ai and Scrimmage.ai from scratch, and fix the AgentForge.ai listing page?';
+    assert.doesNotThrow(
+      () => knownProjectCli._guardDirectFileWritePath(
+        path.join(knownAgentWorkspace, 'Hamp.com', 'public_html', 'domains', 'agentboard-ai.html'),
+        knownAgentWorkspace,
+        { task: mixedKnownProjectTask }
+      ),
+      'agent-workspace root files such as AGENTFORGE.md should not count as scoped project pages when the target resolves into a known project'
+    );
+    assert.throws(
+      () => knownProjectCli._guardDirectFileWritePath(
+        path.join(knownAgentWorkspace, 'Hamp.com', 'Hamp.com', 'public_html', 'domains', 'agentboard-ai.html'),
+        knownAgentWorkspace,
+        { task: mixedKnownProjectTask }
+      ),
+      /nested duplicate of the current project/i,
+      'known-project symlink writes should still reject same-name nested project-copy paths from temp agent workspaces'
+    );
+  } finally {
+    rmSync(knownProjectsRoot, { recursive: true, force: true });
+    rmSync(knownAgentWorkspace, { recursive: true, force: true });
+  }
   assert.equal(
     cli._directScopeFileCandidates(fixture.repo, ['gamma']).some(candidate => candidate.startsWith(`${path.basename(fixture.repo)}/`)),
     false,

package/src/OpenClawCLI.js CHANGED Viewed

@@ -381,9 +381,62 @@ export class OpenClawCLI extends EventEmitter {
     return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
   }
+  _realPathForMaybeMissingPath(targetPath) {
+    const resolved = path.resolve(String(targetPath || ''));
+    if (!resolved) return resolved;
+    if (existsSync(resolved)) {
+      try {
+        return realpathSync(resolved);
+      } catch {
+        return resolved;
+      }
+    }
+    const missingParts = [];
+    let cursor = resolved;
+    while (cursor && !existsSync(cursor)) {
+      const parent = path.dirname(cursor);
+      if (!parent || parent === cursor) break;
+      missingParts.unshift(path.basename(cursor));
+      cursor = parent;
+    }
+    try {
+      return path.join(realpathSync(cursor), ...missingParts);
+    } catch {
+      return resolved;
+    }
+  }
+  _canonicalizeLinkedProjectPath(filePath, workDir) {
+    if (!filePath || !workDir) return filePath;
+    const realFilePath = this._realPathForMaybeMissingPath(filePath);
+    const realWorkDir = this._realPathForMaybeMissingPath(workDir);
+    return this._isPathInside(realFilePath, realWorkDir) ? realFilePath : filePath;
+  }
   _projectsRootForPath(candidate) {
     if (!candidate) return null;
-    return this._knownProjectsRoots().find(root => existsSync(root) && this._isPathInside(candidate, root)) || null;
+    const realCandidate = this._realPathForMaybeMissingPath(candidate);
+    return this._knownProjectsRoots().find(root => {
+      if (!existsSync(root)) return false;
+      const realRoot = this._realPathForMaybeMissingPath(root);
+      return this._isPathInside(realCandidate, realRoot);
+    }) || null;
+  }
+  _projectDirForKnownProjectPath(candidate) {
+    if (!candidate) return null;
+    const realCandidate = this._realPathForMaybeMissingPath(candidate);
+    const projectsRoot = this._projectsRootForPath(realCandidate);
+    if (!projectsRoot) return null;
+    let realProjectsRoot = projectsRoot;
+    try {
+      realProjectsRoot = realpathSync(projectsRoot);
+    } catch { /* non-fatal */ }
+    const relative = path.relative(realProjectsRoot, realCandidate);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return null;
+    const [projectName] = relative.split(path.sep).filter(Boolean);
+    if (!projectName) return null;
+    return path.join(realProjectsRoot, projectName);
   }
   _isProjectScopedWorkDir(workDir) {
@@ -867,8 +920,8 @@ export class OpenClawCLI extends EventEmitter {
     if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return false;
     const [firstPart] = relative.split(path.sep).filter(Boolean);
     if (!firstPart || firstPart.toLowerCase() !== path.basename(workDir).toLowerCase()) return false;
-    if (this._gitTracksPathOrPrefix(workDir, relative, firstPart)) return false;
-    return true;
+    const canonicalPath = this._nestedProjectCopyCanonicalPath(filePath, workDir);
+    return !!canonicalPath && (existsSync(canonicalPath) || existsSync(path.dirname(canonicalPath)));
   }
   _gitTracksPathOrPrefix(workDir, relativePath, prefix = '') {
@@ -912,11 +965,11 @@ export class OpenClawCLI extends EventEmitter {
 	  _nestedProjectDuplicateCanonicalPath(filePath, workDir) {
 	    const canonicalPath = this._nestedProjectCopyCanonicalPath(filePath, workDir);
-	    if (!canonicalPath || canonicalPath === filePath || !existsSync(canonicalPath)) return null;
+	    if (!canonicalPath || canonicalPath === filePath) return null;
 	    if (!this._isDirectPageSourcePath(filePath) || !this._isDirectPageSourcePath(canonicalPath)) return null;
 	    const canonicalRel = path.relative(workDir, canonicalPath);
 	    if (!canonicalRel || canonicalRel.startsWith('..') || path.isAbsolute(canonicalRel)) return null;
-	    if (!this._gitTracksPathOrPrefix(workDir, canonicalRel, canonicalRel.split(path.sep)[0])) return null;
+	    if (!existsSync(canonicalPath) && !existsSync(path.dirname(canonicalPath))) return null;
 	    return canonicalPath;
 	  }
@@ -956,6 +1009,15 @@ export class OpenClawCLI extends EventEmitter {
   }
 	  _guardDirectFileWritePath(filePath, workDir, options = {}) {
+	    const realFilePath = this._realPathForMaybeMissingPath(filePath);
+	    const projectDirForFile = this._projectDirForKnownProjectPath(realFilePath);
+	    if (projectDirForFile && this._isPathInside(realFilePath, projectDirForFile)) {
+	      filePath = realFilePath;
+	      workDir = projectDirForFile;
+	    } else {
+	      filePath = this._canonicalizeLinkedProjectPath(filePath, workDir);
+	    }
+	    workDir = this._realPathForMaybeMissingPath(workDir);
 	    const { slugs, pageOnly } = this._extractDirectExplicitScope(options.task);
     const relative = path.relative(workDir, filePath);
     const relativePath = (!relative || relative.startsWith('..') || path.isAbsolute(relative))
@@ -967,7 +1029,7 @@ export class OpenClawCLI extends EventEmitter {
 	      : null;
 	    if (duplicateCanonicalPath) {
 	      throw this._directScopeViolationError([
-	        'Refusing to write into a nested duplicate of the current project when the canonical target file also exists.',
+	        'Refusing to write into a nested duplicate of the current project.',
 	        `Workspace: ${workDir}`,
 	        `Target: ${filePath}`,
 	        `Use the canonical project path instead: ${duplicateCanonicalPath}`,