deepdebug-local-agent 1.0.22 → 1.1.0

package/src/git/github-provider.js

@@ -4,7 +4,7 @@ import { run } from '../utils/exec-utils.js';
 /**
  * GitHubProvider
  *
- * Implementação do Git provider para GitHub.
+ * Git provider implementation for GitHub.
  */
 export class GitHubProvider extends BaseGitProvider {
 
@@ -170,7 +170,7 @@ export class GitHubProvider extends BaseGitProvider {
 
         const cloneUrl = this.getCloneUrl(owner, repo, true);
 
-        // Inserir token na URL para autenticação
+        // Insert the token into the URL for authentication
         const authedUrl = cloneUrl.replace(
             'https://',
             `https://${this.accessToken}@`
@@ -212,16 +212,16 @@ export class GitHubProvider extends BaseGitProvider {
     }
 
     async createBranch(owner, repo, branchName, fromRef) {
-        // Obter SHA do ref de origem
+        // Get the SHA of the source ref
         let sha = fromRef;
 
         if (!fromRef.match(/^[a-f0-9]{40}$/)) {
-            // É um nome de branch, precisamos do SHA
+            // It is a branch name, we need the SHA
             const branch = await this.getBranch(owner, repo, fromRef);
             sha = branch.sha;
         }
 
-        // Criar a referência
+        // Create the reference
         const data = await this.apiRequest(`/repos/${owner}/${repo}/git/refs`, {
             method: 'POST',
             body: JSON.stringify({
@@ -268,17 +268,17 @@ export class GitHubProvider extends BaseGitProvider {
     }
 
     async createCommit(owner, repo, branch, message, changes) {
-        // 1. Obter referência atual
+        // 1. Get the current reference
         const branchData = await this.getBranch(owner, repo, branch);
         const baseSha = branchData.sha;
 
-        // 2. Obter tree atual
+        // 2. Get the current tree
         const baseCommit = await this.apiRequest(
             `/repos/${owner}/${repo}/git/commits/${baseSha}`
         );
         const baseTreeSha = baseCommit.tree.sha;
 
-        // 3. Criar blobs para cada arquivo modificado
+        // 3. Create blobs for each modified file
         const treeItems = [];
 
         for (const change of changes) {
@@ -290,7 +290,7 @@ export class GitHubProvider extends BaseGitProvider {
                     sha: null
                 });
             } else {
-                // Criar blob
+                // Create a blob
                 const blob = await this.apiRequest(`/repos/${owner}/${repo}/git/blobs`, {
                     method: 'POST',
                     body: JSON.stringify({
@@ -308,7 +308,7 @@ export class GitHubProvider extends BaseGitProvider {
             }
         }
 
-        // 4. Criar nova tree
+        // 4. Create a new tree
         const newTree = await this.apiRequest(`/repos/${owner}/${repo}/git/trees`, {
             method: 'POST',
             body: JSON.stringify({
@@ -317,7 +317,7 @@ export class GitHubProvider extends BaseGitProvider {
             })
         });
 
-        // 5. Criar commit
+        // 5. Create the commit
         const newCommit = await this.apiRequest(`/repos/${owner}/${repo}/git/commits`, {
             method: 'POST',
             body: JSON.stringify({
@@ -327,7 +327,7 @@ export class GitHubProvider extends BaseGitProvider {
             })
         });
 
-        // 6. Atualizar referência da branch
+        // 6. Update the branch reference
         await this.apiRequest(`/repos/${owner}/${repo}/git/refs/heads/${branch}`, {
             method: 'PATCH',
             body: JSON.stringify({
@@ -676,7 +676,7 @@ export class GitHubProvider extends BaseGitProvider {
         } catch {
             // Fallback: add a reply indicating resolution
             await this.replyToPRComment(owner, repo, prNumber, commentId,
-                '✅ Resolved by InspTech AI — fix has been applied.');
+                '✅ Resolved by VisionHammer — fix has been applied.');
             return { resolved: true };
         }
     }

package/src/git/multi-repo-pr.js

@@ -0,0 +1,161 @@
+// Multi-repo coordinated PR helpers.
+//
+// A Workbench multi-repo session clones N repos UNDER ONE per-workspace parent
+// dir (see POST /workspace/open cloud-multi-clone). The parent dir is NOT itself
+// a git repo; each immediate sub-dir is. This module holds the PURE, unit-tested
+// helpers used by /workspace/git/create-fix-branch to open ONE PR per CHANGED
+// repo on a SHARED branch name, and cross-link the sibling PRs in each body.
+//
+// Single-repo behavior is untouched: server.js only routes here when the
+// workspace root is a multi-repo parent AND the feature flag is enabled.
+
+import fs from "fs";
+import path from "path";
+
+/** Feature flag. Default ON; set MULTI_REPO_PR_ENABLED=false to disable. */
+export function multiRepoPrEnabled(env = process.env) {
+    return String(env.MULTI_REPO_PR_ENABLED ?? "true").toLowerCase() !== "false";
+}
+
+/**
+ * Immediate sub-directories of `root` that are themselves git repos
+ * (contain a `.git` entry). Returns [{ dir, path }] sorted by dir name for
+ * stable ordering. Never throws — an unreadable root yields [].
+ */
+export function listRepoSubdirs(root, fsImpl = fs) {
+    if (!root) return [];
+    let entries;
+    try {
+        entries = fsImpl.readdirSync(root, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+    const repos = [];
+    for (const e of entries) {
+        if (!e.isDirectory()) continue;
+        const repoPath = path.join(root, e.name);
+        let hasGit = false;
+        try {
+            hasGit = fsImpl.existsSync(path.join(repoPath, ".git"));
+        } catch {
+            hasGit = false;
+        }
+        if (hasGit) repos.push({ dir: e.name, path: repoPath });
+    }
+    repos.sort((a, b) => a.dir.localeCompare(b.dir));
+    return repos;
+}
+
+/**
+ * A "multi-repo root" is a dir that is NOT a git repo itself but has >= 1
+ * git sub-repo directly under it. When the root IS a git repo (single-repo
+ * clone) this returns false and the caller keeps the legacy single-repo path.
+ */
+export function isMultiRepoRoot(root, fsImpl = fs) {
+    if (!root) return false;
+    let rootIsRepo = false;
+    try {
+        rootIsRepo = fsImpl.existsSync(path.join(root, ".git"));
+    } catch {
+        rootIsRepo = false;
+    }
+    if (rootIsRepo) return false;
+    return listRepoSubdirs(root, fsImpl).length > 0;
+}
+
+/**
+ * Parse an authenticated git remote URL into its parts.
+ * Handles https URLs with embedded userinfo, e.g.
+ *   https://x-access-token:TOKEN@github.com/owner/repo.git
+ *   https://oauth2:TOKEN@gitlab.com/group/repo.git
+ *   https://user:appPassword@bitbucket.org/ws/repo.git
+ *   https://github.com/owner/repo (no auth)
+ * Returns { host, provider, ownerRepo, userinfo, apiToken } or null if unparseable.
+ * apiToken = the token component for REST auth (part after the first ':' in
+ * userinfo when present, else the whole userinfo).
+ */
+export function parseAuthedRemote(remoteUrl) {
+    if (!remoteUrl || typeof remoteUrl !== "string") return null;
+    let u = remoteUrl.trim();
+    // Normalize scp-like SSH form git@host:owner/repo.git -> https://host/owner/repo.git
+    const sshMatch = u.match(/^([^@]+)@([^:]+):(.+)$/);
+    if (sshMatch && !u.includes("://")) {
+        u = `https://${sshMatch[2]}/${sshMatch[3]}`;
+    }
+    const m = u.match(/^https?:\/\/(?:([^@/]+)@)?([^/]+)\/(.+?)(?:\.git)?\/?$/i);
+    if (!m) return null;
+    const userinfo = m[1] || "";
+    const host = m[2];
+    const ownerRepo = m[3];
+    let provider = "generic";
+    if (/github\./i.test(host)) provider = "github";
+    else if (/gitlab\./i.test(host)) provider = "gitlab";
+    else if (/bitbucket\./i.test(host)) provider = "bitbucket";
+    let apiToken = "";
+    if (userinfo) {
+        const ci = userinfo.indexOf(":");
+        apiToken = ci >= 0 ? userinfo.slice(ci + 1) : userinfo;
+    }
+    return { host, provider, ownerRepo, userinfo, apiToken };
+}
+
+/** Strip any embedded userinfo (credentials) from an https git URL for display. */
+export function stripRemoteCreds(remoteUrl) {
+    if (!remoteUrl) return "";
+    return remoteUrl.replace(/^(https?:\/\/)[^@/]+@/i, "$1").replace(/\.git$/i, "");
+}
+
+/**
+ * Build a "compare"/"new MR" web URL for a pushed branch when no API PR link
+ * is available (non-GitHub providers, or API failure). cleanBase = the repo web
+ * URL without creds or .git.
+ */
+export function buildCompareUrl(cleanBase, provider, branch, targetBranch) {
+    if (!cleanBase) return "";
+    switch (provider) {
+        case "gitlab":
+            return `${cleanBase}/-/merge_requests/new?merge_request[source_branch]=${branch}` +
+                `&merge_request[target_branch]=${targetBranch}`;
+        case "bitbucket":
+            return `${cleanBase}/pull-requests/new?source=${branch}&dest=${targetBranch}`;
+        case "github":
+        default:
+            return `${cleanBase}/compare/${targetBranch}...${branch}?expand=1`;
+    }
+}
+
+/**
+ * Cross-link note appended to each PR body: "part of a multi-repo change" plus
+ * links to the SIBLING PRs (all but the one identified by selfDir). Returns ""
+ * when there are no siblings with a usable url.
+ */
+export function buildCrossLinkNote(selfDir, prs) {
+    if (!Array.isArray(prs)) return "";
+    const siblings = prs.filter((p) => p && p.dir !== selfDir && p.prUrl);
+    if (siblings.length === 0) return "";
+    const links = siblings.map((p) => `- ${p.dir}: ${p.prUrl}`).join("\n");
+    return `\n\n---\nPart of a multi-repo change. Sibling pull requests:\n${links}\n`;
+}
+
+const VH_TRAILER = "\nGenerated by VisionHammer Agent\n";
+
+/**
+ * Base PR body for one repo of a coordinated multi-repo change (provider-neutral,
+ * ASCII-only). Sibling links are appended later via buildCrossLinkNote once every
+ * PR exists (two-pass), so this body is self-consistent even if a sibling fails.
+ */
+export function buildMultiRepoPrBody({ dir, branch, commitMessage, filesChanged, commitSha }) {
+    const lines = [
+        "## Coordinated multi-repo change",
+        "",
+        `**Repo dir:** \`${dir}\``,
+        `**Branch:** \`${branch}\``,
+        `**Files changed:** ${filesChanged}`,
+    ];
+    if (commitSha) lines.push(`**Commit:** ${String(commitSha).substring(0, 8)}`);
+    if (commitMessage) {
+        lines.push("", "### Summary", commitMessage);
+    }
+    lines.push("", "---", VH_TRAILER.trim());
+    return lines.join("\n");
+}

package/src/mcp-http-server.js

@@ -1,4 +1,8 @@
 import express from "express";
+import { sanitizedChildEnv } from "./utils/child-env.js";
+import { createAuthMiddleware } from "./utils/agent-auth.js";
+import { getSigningConfig, createSignatureMiddleware, captureRawBody } from "./utils/request-signing.js";
+import { decideExec, rejectionBody, resolveExecPolicyConfig } from "./utils/exec-policy.js";
 import path from "path";
 import { spawn } from "child_process";
 import { readFile, writeFile, listRecursive, exists } from "./fs-utils.js";
@@ -6,22 +10,30 @@ import { detectProject } from "./detectors.js";
 import { applyUnifiedDiff } from "./patch.js";
 
 /**
- * MCP HTTP Bridge — Expõe as MCP tools como REST API.
+ * MCP HTTP Bridge — Exposes the MCP tools as a REST API.
  *
- * O Gateway Java chama estes endpoints para obter contexto do código
- * ANTES de enviar o prompt ao Claude.
+ * The Java Gateway calls these endpoints to get code context
+ * BEFORE sending the prompt to Claude.
  *
- * Port: 5056 (separado do Express principal na 5055)
+ * Port: 5056 (separate from the main Express server on 5055)
  *
- * Isto é mais prático que stdio MCP para comunicação Gateway ↔ Agent,
- * e mantém compatibilidade com MCP tools para uso futuro com Claude Code.
+ * This is more practical than stdio MCP for Gateway ↔ Agent communication,
+ * and keeps compatibility with MCP tools for future use with Claude Code.
  */
 
 const IGNORE_DIRS = ["node_modules", ".git", "target", "build", "dist", ".idea", "__pycache__", "vendor", ".gradle"];
 
 export function startMCPHttpServer(workspaceManager, port = 5056) {
     const app = express();
-    app.use(express.json({ limit: "50mb" }));
+    // SECURITY: this bridge runs shell commands (/mcp/execute-command) and
+    // writes files. Its only consumer is the in-process WS tunnel, so it binds
+    // to loopback and sits behind the same auth perimeter as the main API.
+    app.use(createAuthMiddleware());
+    app.use(express.json({ limit: "50mb", verify: captureRawBody }));
+    // Same signed-command verification as the main API (shared nonce cache).
+    const signing = getSigningConfig();
+    const execPolicy = resolveExecPolicyConfig();
+    app.use(createSignatureMiddleware(signing));
 
     // ========================================
     // Health
@@ -175,14 +187,16 @@ export function startMCPHttpServer(workspaceManager, port = 5056) {
         const { workspaceId, command, timeout = 120 } = req.body;
         if (!command) return res.status(400).json({ error: "command required" });
 
-        // Security
-        const BLOCKED = ["rm -rf /", "mkfs", "dd if=/dev", ":(){ :|:"];
-        if (BLOCKED.some(b => command.includes(b))) {
-            return res.status(403).json({ error: "Command blocked" });
-        }
-
         try {
             const root = workspaceManager.resolveRoot(workspaceId);
+            // Security: allowlist (utils/exec-policy.js) instead of the old blocklist.
+            const decision = decideExec({
+                command, root, headers: req.headers, body: req.body || {},
+                vhSignature: req.vhSignature, signingCfg: signing,
+            }, execPolicy);
+            if (!decision.allow) {
+                return res.status(decision.status || 403).json(rejectionBody(decision));
+            }
             const result = await execInWorkspace(root, command, timeout);
             res.json({ ok: result.exitCode === 0, ...result });
         } catch (e) {
@@ -243,8 +257,9 @@ export function startMCPHttpServer(workspaceManager, port = 5056) {
     // ========================================
     // START SERVER
     // ========================================
-    app.listen(port, () => {
-        console.log(`🔌 MCP HTTP Bridge listening on http://localhost:${port}`);
+    const host = process.env.MCP_BIND_HOST || "127.0.0.1";
+    app.listen(port, host, () => {
+        console.log(`🔌 MCP HTTP Bridge listening on http://${host}:${port}`);
     });
 
     return app;
@@ -288,7 +303,8 @@ function grepWorkspace(root, query, filePattern, maxResults) {
 
 function execInWorkspace(root, command, timeoutSec) {
     return new Promise((resolve) => {
-        const child = spawn("sh", ["-c", command], { cwd: root });
+        // SECURITY (2026-10-11): model-authored command; strip the agent's secrets.
+        const child = spawn("sh", ["-c", command], { cwd: root, env: sanitizedChildEnv(process.env) });
         let stdout = "";
         let stderr = "";