@phren/cli 0.0.20 → 0.0.22

package/mcp/dist/hooks.js

@@ -63,8 +63,13 @@ function resolveCliEntryScript() {
 function phrenPackageSpec() {
     return PACKAGE_SPEC;
 }
+/** Shell-escape a value by wrapping in single quotes with proper escaping of embedded single quotes. */
+export function shellEscape(s) {
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+/** @deprecated Use shellEscape instead */
 function shellSingleQuote(value) {
-    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+    return shellEscape(value);
 }
 function buildPackageLifecycleCommands() {
     const packageSpec = phrenPackageSpec();
@@ -280,7 +285,7 @@ export function validateCustomHookCommand(command) {
     if (trimmed.length > 1000)
         return "Command too long (max 1000 characters).";
     if (/[`$(){}&|;<>\n\r#]/.test(trimmed)) {
-        return "Command contains disallowed shell characters: ` $ ( ) { } & | ; < >";
+        return "Command contains disallowed shell characters: ` $ ( ) { } & | ; < > # \\n \\r";
     }
     if (/\b(eval|source)\b/.test(trimmed))
         return "eval and source are not permitted in hook commands.";
@@ -352,27 +357,52 @@ export function validateCustomWebhookUrl(webhook) {
     }
     return blockedWebhookHostnameReason(parsed.hostname);
 }
-async function validateWebhookAtExecution(webhook) {
+/**
+ * Validate a webhook URL at execution time and return the resolved IP address
+ * to use for the fetch. Resolving once and re-using the IP prevents DNS
+ * rebinding attacks where the hostname resolves to a safe IP during validation
+ * but a private/loopback IP when fetch performs its own lookup.
+ *
+ * Returns { error } if blocked, or { resolvedUrl, host } if safe.
+ */
+async function validateAndResolveWebhook(webhook) {
     let parsed;
     try {
         parsed = new URL(webhook);
     }
     catch {
-        return "webhook is not a valid URL.";
+        return { error: "webhook is not a valid URL." };
     }
     const literalBlock = blockedWebhookHostnameReason(parsed.hostname);
     if (literalBlock)
-        return literalBlock;
+        return { error: literalBlock };
+    // If the hostname is already a literal IP, validate it directly
+    if (isIP(parsed.hostname)) {
+        if (isPrivateOrLoopbackAddress(parsed.hostname)) {
+            return { error: `webhook hostname "${parsed.hostname}" is a private or loopback address.` };
+        }
+        return { resolvedUrl: webhook, host: parsed.hostname };
+    }
     try {
         const records = await lookup(parsed.hostname, { all: true, verbatim: true });
+        if (records.length === 0) {
+            return { error: `webhook hostname "${parsed.hostname}" did not resolve to any address.` };
+        }
         if (records.some((record) => isPrivateOrLoopbackAddress(record.address))) {
-            return `webhook hostname "${parsed.hostname}" resolved to a private or loopback address.`;
+            return { error: `webhook hostname "${parsed.hostname}" resolved to a private or loopback address.` };
         }
+        // Use the first resolved IP to build a pinned URL, preventing DNS rebinding
+        const resolvedIp = records[0].address;
+        const pinnedUrl = new URL(webhook);
+        pinnedUrl.hostname = records[0].family === 6 ? `[${resolvedIp}]` : resolvedIp;
+        return { resolvedUrl: pinnedUrl.href, host: parsed.host };
     }
     catch (err) {
-        debugLog(`validateWebhookAtExecution lookup failed for ${parsed.hostname}: ${errorMessage(err)}`);
+        debugLog(`validateAndResolveWebhook lookup failed for ${parsed.hostname}: ${errorMessage(err)}`);
+        // DNS resolution failed; allow the fetch to proceed with the original URL
+        // (fetch will do its own resolution and may fail with a network error)
+        return { resolvedUrl: webhook, host: parsed.host };
     }
-    return null;
 }
 const DEFAULT_CUSTOM_HOOK_TIMEOUT = 5000;
 const HOOK_TIMEOUT_MS = parseInt(process.env.PHREN_HOOK_TIMEOUT_MS || '14000', 10);
@@ -428,17 +458,24 @@ export function runCustomHooks(phrenPath, event, env = {}) {
             if (hook.secret) {
                 headers["X-Phren-Signature"] = `sha256=${createHmac("sha256", hook.secret).update(payload).digest("hex")}`;
             }
-            void validateWebhookAtExecution(hook.webhook)
-                .then((blockReason) => {
-                if (blockReason) {
-                    const message = `${event}: skipped webhook ${hook.webhook}: ${blockReason}`;
+            void validateAndResolveWebhook(hook.webhook)
+                .then((result) => {
+                if ("error" in result && result.error) {
+                    const message = `${event}: skipped webhook ${hook.webhook}: ${result.error}`;
                     debugLog(`runCustomHooks webhook: ${message}`);
                     appendHookErrorLog(phrenPath, event, message);
                     return;
                 }
-                return fetch(hook.webhook, {
+                // Use the pinned resolved URL to prevent DNS rebinding;
+                // set Host header to the original hostname for correct routing.
+                const { resolvedUrl, host } = result;
+                const fetchHeaders = { ...headers };
+                if (host) {
+                    fetchHeaders["Host"] = host;
+                }
+                return fetch(resolvedUrl, {
                     method: "POST",
-                    headers,
+                    headers: fetchHeaders,
                     body: payload,
                     redirect: "manual",
                     signal: AbortSignal.timeout(hook.timeout ?? DEFAULT_CUSTOM_HOOK_TIMEOUT),

package/mcp/dist/mcp-data.js

@@ -11,6 +11,7 @@ const importPayloadSchema = z.object({
     summary: z.string().optional(),
     claudeMd: z.string().optional(),
     taskRaw: z.string().optional(),
+    findingsRaw: z.string().optional(),
     learnings: z
         .array(z.object({
         text: z.string(),
@@ -134,9 +135,8 @@ export function register(server, ctx) {
             };
             const buildTaskContent = () => {
                 // Prefer the raw task string (lossless: preserves priority/pinned/stable IDs)
-                const taskRaw = parsed.taskRaw;
-                if (typeof taskRaw === "string")
-                    return taskRaw;
+                if (typeof parsed.taskRaw === "string")
+                    return parsed.taskRaw;
                 if (!parsed.task)
                     return null;
                 const sections = ["Active", "Queue", "Done"];
@@ -175,8 +175,7 @@ export function register(server, ctx) {
                     fs.writeFileSync(path.join(stagedProjectDir, "CLAUDE.md"), parsed.claudeMd);
                     imported.push("CLAUDE.md");
                 }
-                const findingsRaw = parsed.findingsRaw;
-                const findingsContent = typeof findingsRaw === "string" ? findingsRaw : buildFindingsContent();
+                const findingsContent = typeof parsed.findingsRaw === "string" ? parsed.findingsRaw : buildFindingsContent();
                 if (findingsContent) {
                     fs.writeFileSync(path.join(stagedProjectDir, "FINDINGS.md"), findingsContent);
                     imported.push("FINDINGS.md");