@nanhara/hara 0.131.1 → 0.132.1

package/dist/serve/server.js

@@ -787,7 +787,9 @@ export async function startServe(opts, deps) {
                             "session.list", "session.create", "session.resume", "session.send", "session.steer", "session.interrupt", "session.set-model",
                             "session.rename", "session.archive", "session.compact", "session.rewind", "session.context", "session.delete", "session.fork",
                             "approval.reply", "plugins.list", "plugins.set", "skills.list", "models.list", "files.search", "project.panels",
-                            "settings.providers.list", "settings.providers.test", "settings.providers.save",
+                            "settings.providers.list", "settings.providers.test", "settings.providers.save", "settings.gateways.list",
+                            "settings.organizations.list", "settings.organizations.enroll", "settings.organizations.use",
+                            "settings.organizations.remove", "settings.organizations.check",
                             "automation.list", "automation.add", "automation.toggle", "automation.delete",
                             "artifact.import", "artifact.commit", "artifact.revert",
                             "artifact.list", "artifact.get", "artifact.revisions",
@@ -1031,6 +1033,59 @@ export async function startServe(opts, deps) {
                             const targetCwd = typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd;
                             return reply(rpcResult(id, redactSensitiveValue(deps.providerSettings(targetCwd)).value));
                         }
+                        case "settings.gateways.list": {
+                            if (!deps.gatewayStatuses)
+                                return reply(rpcError(id, ERR.METHOD, "gateway status not supported by this server"));
+                            const gateways = await deps.gatewayStatuses();
+                            return reply(rpcResult(id, { gateways: redactSensitiveValue(gateways).value }));
+                        }
+                        case "settings.organizations.list": {
+                            if (!deps.organizationConnections)
+                                return reply(rpcError(id, ERR.METHOD, "organization settings not supported by this server"));
+                            const targetCwd = typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd;
+                            return reply(rpcResult(id, redactSensitiveValue(deps.organizationConnections(targetCwd)).value));
+                        }
+                        case "settings.organizations.enroll": {
+                            if (!deps.enrollOrganizationConnection)
+                                return reply(rpcError(id, ERR.METHOD, "organization enrollment not supported by this server"));
+                            if (typeof p.id !== "string" ||
+                                typeof p.gatewayUrl !== "string" ||
+                                typeof p.code !== "string" ||
+                                (p.label !== undefined && typeof p.label !== "string") ||
+                                (p.activate !== undefined && typeof p.activate !== "boolean")) {
+                                return reply(rpcError(id, ERR.PARAMS, "id + gatewayUrl + code required; optional label/activate have invalid types"));
+                            }
+                            const targetCwd = typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd;
+                            const input = {
+                                id: p.id,
+                                gatewayUrl: p.gatewayUrl,
+                                code: p.code,
+                                ...(p.label !== undefined ? { label: p.label } : {}),
+                                ...(p.activate !== undefined ? { activate: p.activate } : {}),
+                            };
+                            const result = await deps.enrollOrganizationConnection(input, targetCwd);
+                            return reply(rpcResult(id, redactSensitiveValue(result, [p.code]).value));
+                        }
+                        case "settings.organizations.use":
+                        case "settings.organizations.remove":
+                        case "settings.organizations.check": {
+                            if (typeof p.id !== "string")
+                                return reply(rpcError(id, ERR.PARAMS, "organization connection id required"));
+                            const targetCwd = typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd;
+                            if (req.method === "settings.organizations.use") {
+                                if (!deps.useOrganizationConnection)
+                                    return reply(rpcError(id, ERR.METHOD, "organization switching not supported by this server"));
+                                return reply(rpcResult(id, redactSensitiveValue(deps.useOrganizationConnection(p.id, targetCwd)).value));
+                            }
+                            if (req.method === "settings.organizations.remove") {
+                                if (!deps.removeOrganizationConnection)
+                                    return reply(rpcError(id, ERR.METHOD, "organization removal not supported by this server"));
+                                return reply(rpcResult(id, redactSensitiveValue(deps.removeOrganizationConnection(p.id, targetCwd)).value));
+                            }
+                            if (!deps.checkOrganizationConnection)
+                                return reply(rpcError(id, ERR.METHOD, "organization connection check not supported by this server"));
+                            return reply(rpcResult(id, redactSensitiveValue(await deps.checkOrganizationConnection(p.id, targetCwd)).value));
+                        }
                         case "settings.providers.test":
                         case "settings.providers.save": {
                             const callback = req.method === "settings.providers.test" ? deps.testProviderSettings : deps.saveProviderSettings;

package/dist/tools/web.js

@@ -7,7 +7,9 @@ import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
+import { ProxyAgent, fetch as undiciFetch, request as undiciRequest } from "undici";
 import { wrapUntrusted } from "../security/external-content.js";
+import { loadConfig } from "../config.js";
 const MAX = 60_000;
 const SEARCH_ATTEMPT_MS = 8_000;
 const SEARCH_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0 Safari/537.36";
@@ -116,9 +118,179 @@ export async function resolvePublicHost(hostname, resolver = lookup) {
     const chosen = addrs[0];
     return { address: chosen.address, family: chosen.family };
 }
+function nonBlank(value) {
+    return value?.trim() || undefined;
+}
+function defaultPort(url) {
+    return url.port || (url.protocol === "https:" ? "443" : "80");
+}
+/** Common NO_PROXY matching: exact host, domain suffix (`.example.com` / `*.example.com`), optional port,
+ * and `*`. This decision always uses the original public hostname, never the later pinned IP. */
+export function bypassesWebProxy(url, noProxyValue) {
+    const hostname = url.hostname.replace(/^\[|\]$/g, "").replace(/\.$/, "").toLowerCase();
+    const port = defaultPort(url);
+    for (const raw of noProxyValue?.split(/[\s,]+/u) ?? []) {
+        let rule = raw.trim().toLowerCase();
+        if (!rule)
+            continue;
+        if (rule === "*")
+            return true;
+        try {
+            if (/^https?:\/\//u.test(rule)) {
+                const parsed = new URL(rule);
+                if (parsed.port && parsed.port !== port)
+                    continue;
+                rule = parsed.hostname.toLowerCase();
+            }
+        }
+        catch {
+            continue;
+        }
+        let rulePort;
+        if (rule.startsWith("[")) {
+            const match = /^\[([^\]]+)\](?::(\d+))?$/u.exec(rule);
+            if (!match)
+                continue;
+            rule = match[1];
+            rulePort = match[2];
+        }
+        else {
+            const match = /^([^:]+):(\d+)$/u.exec(rule);
+            if (match) {
+                rule = match[1];
+                rulePort = match[2];
+            }
+        }
+        if (rulePort && rulePort !== port)
+            continue;
+        rule = rule.replace(/\.$/u, "");
+        const suffix = rule.startsWith("*.") ? rule.slice(2) : rule.startsWith(".") ? rule.slice(1) : "";
+        if (suffix ? hostname === suffix || hostname.endsWith(`.${suffix}`) : hostname === rule)
+            return true;
+    }
+    return false;
+}
+function normalizedProxyUri(value) {
+    try {
+        const parsed = new URL(value);
+        if ((parsed.protocol !== "http:" && parsed.protocol !== "https:")
+            || !parsed.hostname
+            || parsed.pathname !== "/"
+            || parsed.search
+            || parsed.hash) {
+            throw new Error("unsupported proxy URL");
+        }
+        return parsed.href;
+    }
+    catch {
+        throw new Error("web proxy configuration is invalid; use an HTTP(S) proxy URL without a path, query, or fragment");
+    }
+}
+/** Resolve one proxy without mutating Undici's global dispatcher. Standard lowercase variables take
+ * precedence over uppercase, and HTTPS falls back to HTTP_PROXY as documented by EnvHttpProxyAgent. */
+export function selectWebProxy(url, configuredProxy, env = process.env) {
+    const noProxy = nonBlank(env.no_proxy) ?? nonBlank(env.NO_PROXY);
+    if (bypassesWebProxy(url, noProxy))
+        return undefined;
+    const haraProxy = nonBlank(env.HARA_WEB_PROXY);
+    if (haraProxy)
+        return { uri: normalizedProxyUri(haraProxy), source: "hara-env" };
+    const protocolProxy = url.protocol === "https:"
+        ? nonBlank(env.https_proxy) ?? nonBlank(env.HTTPS_PROXY) ?? nonBlank(env.http_proxy) ?? nonBlank(env.HTTP_PROXY)
+        : nonBlank(env.http_proxy) ?? nonBlank(env.HTTP_PROXY);
+    if (protocolProxy)
+        return { uri: normalizedProxyUri(protocolProxy), source: "environment" };
+    return configuredProxy ? { uri: normalizedProxyUri(configuredProxy), source: "config" } : undefined;
+}
+function webProxy(url, cwd) {
+    return selectWebProxy(url, loadConfig({ cwd }).proxy);
+}
+function proxySafeError(error) {
+    const candidate = error;
+    const code = typeof candidate?.code === "string"
+        ? candidate.code
+        : typeof candidate?.cause?.code === "string"
+            ? candidate.cause.code
+            : undefined;
+    const suffix = code && /^[A-Z][A-Z0-9_]{1,40}$/u.test(code) ? ` (${code})` : "";
+    const result = new Error(`proxy request failed${suffix}`);
+    result.name = typeof candidate?.name === "string" && /^(?:Abort|Timeout)Error$/u.test(candidate.name)
+        ? candidate.name
+        : "Error";
+    return result;
+}
+function safeNetworkError(error) {
+    const candidate = error;
+    if (candidate?.name === "AbortError" || candidate?.name === "TimeoutError")
+        return "timed out (30s)";
+    const rawCode = typeof candidate?.code === "string" ? candidate.code : candidate?.cause?.code;
+    const code = typeof rawCode === "string" && /^[A-Z][A-Z0-9_]{1,40}$/u.test(rawCode) ? ` [${rawCode}]` : "";
+    const message = String(candidate?.message ?? "network request failed")
+        .replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/giu, "$1[credentials]@")
+        .replace(/[\u0000-\u001f\u007f]/gu, " ")
+        .replace(/\s+/gu, " ")
+        .slice(0, 240);
+    return `${message}${code}`;
+}
+function pinnedUrl(url, pinned) {
+    const result = new URL(url.href);
+    result.hostname = pinned.family === 6 ? `[${pinned.address}]` : pinned.address;
+    result.username = "";
+    result.password = "";
+    return result;
+}
+function responseHeaders(values) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(values)) {
+        if (Array.isArray(value))
+            for (const item of value)
+                headers.append(name, item);
+        else if (value !== undefined)
+            headers.append(name, String(value));
+    }
+    return headers;
+}
 /** One HTTP hop whose TCP socket is pinned to the address approved above. `Host` and TLS SNI retain the
  * original hostname, so virtual hosting/certificate checks work without a second DNS lookup. */
-async function requestPinned(url, pinned, signal) {
+export async function requestPinned(url, pinned, signal, proxy) {
+    if (proxy) {
+        const servername = url.hostname.replace(/^\[|\]$/g, "");
+        const agent = new ProxyAgent({
+            uri: proxy.uri,
+            proxyTunnel: true,
+            ...(url.protocol === "https:" && !isIP(servername) ? { requestTls: { servername } } : {}),
+        });
+        try {
+            const response = await undiciRequest(pinnedUrl(url, pinned), {
+                dispatcher: agent,
+                method: "GET",
+                signal,
+                headers: {
+                    host: url.host,
+                    "user-agent": "hara-cli",
+                    accept: "text/html,text/plain,application/json,*/*",
+                },
+            });
+            let released = false;
+            return {
+                status: response.statusCode,
+                headers: responseHeaders(response.headers),
+                body: response.body,
+                async release(discard = false) {
+                    if (released)
+                        return;
+                    released = true;
+                    if (discard)
+                        response.body.destroy();
+                    await agent.close();
+                },
+            };
+        }
+        catch (error) {
+            await agent.destroy().catch(() => { });
+            throw proxySafeError(error);
+        }
+    }
     return new Promise((resolve, reject) => {
         const request = (url.protocol === "https:" ? httpsRequest : httpRequest)({
             protocol: url.protocol,
@@ -138,7 +310,15 @@ async function requestPinned(url, pinned, signal) {
             const headers = new Headers();
             for (let i = 0; i < body.rawHeaders.length; i += 2)
                 headers.append(body.rawHeaders[i], body.rawHeaders[i + 1]);
-            resolve({ status: body.statusCode ?? 0, headers, body });
+            resolve({
+                status: body.statusCode ?? 0,
+                headers,
+                body,
+                async release(discard = false) {
+                    if (discard)
+                        body.destroy();
+                },
+            });
         });
         request.once("error", reject);
         request.end();
@@ -354,12 +534,34 @@ function interrupted(label) {
     error.name = "AbortError";
     return error;
 }
-async function searchFetch(url, init, parentSignal) {
+const searchProxyAgents = new Map();
+function searchProxyAgent(uri) {
+    let agent = searchProxyAgents.get(uri);
+    if (!agent) {
+        agent = new ProxyAgent({ uri, proxyTunnel: true });
+        searchProxyAgents.set(uri, agent);
+    }
+    return agent;
+}
+async function searchFetch(url, init, parentSignal, cwd) {
     if (parentSignal?.aborted)
         throw interrupted("web search");
     const attemptSignal = AbortSignal.timeout(SEARCH_ATTEMPT_MS);
     const signal = parentSignal ? AbortSignal.any([parentSignal, attemptSignal]) : attemptSignal;
-    return fetch(url, { ...init, signal });
+    const proxy = webProxy(new URL(url), cwd);
+    if (!proxy)
+        return fetch(url, { ...init, signal });
+    try {
+        const response = await undiciFetch(url, {
+            ...init,
+            dispatcher: searchProxyAgent(proxy.uri),
+            signal,
+        });
+        return response;
+    }
+    catch (error) {
+        throw proxySafeError(error);
+    }
 }
 async function firstSuccessfulSearch(attempts, failures, signal) {
     // Try one provider at a time. Search terms can be sensitive; a successful request must not be mirrored
@@ -422,7 +624,7 @@ registerTool({
                         method: "POST",
                         headers: { "content-type": "application/json" },
                         body: JSON.stringify({ api_key: key, query: q, max_results: limit }),
-                    }, ctx.signal);
+                    }, ctx.signal, ctx.cwd);
                     if (!res.ok)
                         throw new Error(`HTTP ${res.status}`);
                     const j = (await res.json());
@@ -437,7 +639,7 @@ registerTool({
                     method: "GET",
                     redirect: "follow",
                     headers: { "user-agent": SEARCH_UA, accept: "text/html" },
-                }, ctx.signal);
+                }, ctx.signal, ctx.cwd);
                 if (!res.ok)
                     throw new Error(`HTTP ${res.status}`);
                 return parseBingSearchResults(await res.text(), limit);
@@ -456,7 +658,7 @@ registerTool({
                         method: "GET",
                         redirect: "follow",
                         headers: { "user-agent": SEARCH_UA, accept: "text/html" },
-                    }, ctx.signal);
+                    }, ctx.signal, ctx.cwd);
                     if (!res.ok)
                         throw new Error(`HTTP ${res.status}`);
                     return parseBaiduSearchResults(await res.text(), limit);
@@ -469,7 +671,7 @@ registerTool({
                         method: "GET",
                         redirect: "follow",
                         headers: { "user-agent": SEARCH_UA, accept: "text/html" },
-                    }, ctx.signal);
+                    }, ctx.signal, ctx.cwd);
                     if (!res.ok)
                         throw new Error(`HTTP ${res.status}`);
                     return parseGoogleSearchResults(await res.text(), limit);
@@ -483,7 +685,7 @@ registerTool({
                         redirect: "follow",
                         headers: { "user-agent": SEARCH_UA, "content-type": "application/x-www-form-urlencoded", accept: "text/html" },
                         body: `q=${encodeURIComponent(q)}`,
-                    }, ctx.signal);
+                    }, ctx.signal, ctx.cwd);
                     if (!res.ok)
                         throw new Error(`HTTP ${res.status}`);
                     return parseSearchResults(await res.text(), limit);
@@ -518,10 +720,12 @@ registerTool({
             url = new URL(input.url);
         }
         catch {
-            return `Error: invalid URL: ${input.url}`;
+            return "Error: invalid URL.";
         }
         if (url.protocol !== "http:" && url.protocol !== "https:")
             return "Error: only http/https URLs are supported.";
+        if (url.username || url.password)
+            return "Error: URL-embedded credentials are not supported.";
         const cap = Math.min(Math.max(1000, input.max_chars ?? MAX), 200_000);
         const ctrl = new AbortController();
         const timer = setTimeout(() => ctrl.abort(), 30_000);
@@ -536,24 +740,36 @@ registerTool({
                 const pinned = await resolvePublicHost(current.hostname);
                 if (ctx.signal?.aborted)
                     throw interrupted("web fetch");
-                res = await requestPinned(current, pinned, signal);
+                res = await requestPinned(current, pinned, signal, webProxy(current, ctx.cwd));
                 const loc = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
                 if (!loc || hop >= 5)
                     break;
                 const next = new URL(loc, current);
                 if (next.protocol !== "http:" && next.protocol !== "https:") {
-                    res.body.destroy();
+                    await res.release(true);
                     return "Error: redirect to a non-http(s) URL was blocked.";
                 }
+                if (next.username || next.password) {
+                    await res.release(true);
+                    return "Error: redirect with URL-embedded credentials was blocked.";
+                }
                 // We never consume redirect bodies. Destroy the socket before following the next pinned hop so a
                 // server cannot accumulate idle response streams across a redirect chain.
-                res.body.destroy();
+                await res.release(true);
                 if (ctx.signal?.aborted)
                     throw interrupted("web fetch");
                 current = next;
             }
             const ct = res.headers.get("content-type") ?? "";
-            const raw = await readPinnedCapped(res.body, cap * 4); // byte ceiling (HTML→text shrinks; cap*4 leaves headroom)
+            let raw;
+            let bodyRead = false;
+            try {
+                raw = await readPinnedCapped(res.body, cap * 4); // byte ceiling (HTML→text shrinks; cap*4 leaves headroom)
+                bodyRead = true;
+            }
+            finally {
+                await res.release(!bodyRead);
+            }
             if (ctx.signal?.aborted)
                 throw interrupted("web fetch");
             let text = /html/i.test(ct) ? htmlToText(raw) : raw;
@@ -569,7 +785,10 @@ registerTool({
         catch (e) {
             if (ctx.signal?.aborted)
                 throw interrupted("web fetch");
-            return `Error fetching ${url.href}: ${e?.name === "AbortError" ? "timed out (30s)" : (e?.message ?? e)}`;
+            const display = new URL(url.href);
+            display.username = "";
+            display.password = "";
+            return `Error fetching ${display.href}: ${safeNetworkError(e)}`;
         }
         finally {
             clearTimeout(timer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.131.1",
+  "version": "0.132.1",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "runtime-bootstrap.cjs"
@@ -59,6 +59,7 @@
     "ink": "^6.8.0",
     "openai": "^6.44.0",
     "react": "^19.2.7",
+    "undici": "^7.28.0",
     "ws": "^8.19.0"
   },
   "devDependencies": {
@@ -77,6 +78,9 @@
     "@larksuiteoapi/node-sdk": {
       "axios": "1.18.1",
       "protobufjs": "7.6.5"
-    }
+    },
+    "@hono/node-server": "2.0.11",
+    "hono": "4.12.31",
+    "fast-uri": "3.1.3"
   }
 }