@blogic-cz/agent-tools 1.5.8 → 1.5.10

package/src/gh-tool/api.ts

@@ -4,6 +4,7 @@ import { retryTransient } from "#shared/retry-transient";
 
 import { GitHubAuthError, GitHubCommandError, GitHubNotFoundError } from "./errors";
 import type { GitHubApiError } from "./errors";
+import { ghEnvironment } from "./environment";
 import { validateOutboundText } from "./text-input";
 
 // Direct HTTP, not `gh api`: the CLI collapses every failure into a non-zero exit and
@@ -44,6 +45,7 @@ export const resolveGitHubToken = Effect.fn("gh.resolveGitHubToken")(function* (
       const proc = Bun.spawn(["gh", "auth", "token", "--hostname", "github.com"], {
         stdout: "pipe",
         stderr: "ignore",
+        env: ghEnvironment(),
       });
       const stdout = await new Response(proc.stdout).text();
       const exitCode = await proc.exited;
@@ -67,27 +69,22 @@ export type GitHubApiRequest = {
 
 const MAX_API_RETRIES = 2;
 
-const outboundBodyText = (value: unknown): string => {
+// Traverse only parsed JSON, never the caller's getters or toJSON hooks.
+const decodedBodyText = (value: unknown): string => {
   if (typeof value === "string") return value;
-  if (Array.isArray(value)) return value.map(outboundBodyText).join("\n");
+  if (Array.isArray(value)) return value.map(decodedBodyText).join("\n");
   if (value !== null && typeof value === "object")
-    return Object.values(value).map(outboundBodyText).join("\n");
+    return Object.entries(value)
+      .map(([key, item]) => `${key}\n${decodedBodyText(item)}`)
+      .join("\n");
   return "";
 };
 
-const githubApiAttempt = Effect.fn("gh.githubApiAttempt")(function* <T>(opts: GitHubApiRequest) {
+const githubApiAttempt = Effect.fn("gh.githubApiAttempt")(function* <T>(
+  opts: GitHubApiRequest,
+  serializedBody: string | undefined,
+) {
   const method = opts.method ?? "GET";
-  const bodyText = yield* Effect.try({
-    try: () => outboundBodyText(opts.body),
-    catch: () =>
-      new GitHubCommandError({
-        command: `gh-tool ${method} ${opts.path}`,
-        exitCode: 1,
-        stderr: "Refusing to publish an invalid request body",
-        message: "Refusing to publish an invalid request body",
-      }),
-  });
-  yield* validateOutboundText(`${opts.path}\n${bodyText}`, `gh-tool ${method} ${opts.path}`);
   const token = yield* resolveGitHubToken();
   const url = `${GITHUB_API_ROOT}/${opts.path.replace(/^\//, "")}`;
 
@@ -99,9 +96,9 @@ const githubApiAttempt = Effect.fn("gh.githubApiAttempt")(function* <T>(opts: Gi
           Accept: GITHUB_ACCEPT,
           Authorization: `Bearer ${token}`,
           "X-GitHub-Api-Version": GITHUB_API_VERSION,
-          ...(opts.body === undefined ? {} : { "Content-Type": "application/json" }),
+          ...(serializedBody === undefined ? {} : { "Content-Type": "application/json" }),
         },
-        ...(opts.body === undefined ? {} : { body: JSON.stringify(opts.body) }),
+        ...(serializedBody === undefined ? {} : { body: serializedBody }),
       }),
     catch: (cause) =>
       new GitHubCommandError({
@@ -158,13 +155,42 @@ const githubApiAttempt = Effect.fn("gh.githubApiAttempt")(function* <T>(opts: Gi
 export const githubApi = <T>(
   opts: GitHubApiRequest,
 ): Effect.Effect<GitHubApiResponse<T>, GitHubApiError> =>
-  retryTransient({
-    attempt: () => githubApiAttempt<T>(opts),
-    isTransient: (error) =>
-      error._tag === "GitHubCommandError" &&
-      error.retryable === true &&
-      (opts.method ?? "GET") === "GET",
-    maxRetries: MAX_API_RETRIES,
+  Effect.gen(function* () {
+    const snapshot = yield* Effect.try({
+      try: () => {
+        const path = opts.path;
+        const method = opts.method ?? "GET";
+        const alsoAcceptStatus = opts.alsoAcceptStatus;
+        const request = {
+          path,
+          method,
+          ...(alsoAcceptStatus === undefined ? {} : { alsoAcceptStatus: [...alsoAcceptStatus] }),
+        };
+        const body = opts.body;
+        if (body === undefined) return { request, serialized: undefined, decoded: "" };
+        const serialized = JSON.stringify(body);
+        if (serialized === undefined) throw new Error("Body is not JSON serializable");
+        return { request, serialized, decoded: decodedBodyText(JSON.parse(serialized)) };
+      },
+      catch: () =>
+        new GitHubCommandError({
+          command: "gh-tool API",
+          exitCode: 1,
+          stderr: "Refusing to publish an invalid request body",
+          message: "Refusing to publish an invalid request body",
+        }),
+    });
+    const { request } = snapshot;
+    yield* validateOutboundText(
+      `${request.path}\n${snapshot.serialized ?? ""}\n${snapshot.decoded}`,
+      `gh-tool ${request.method} ${request.path}`,
+    );
+    return yield* retryTransient({
+      attempt: () => githubApiAttempt<T>(request, snapshot.serialized),
+      isTransient: (error) =>
+        error._tag === "GitHubCommandError" && error.retryable === true && request.method === "GET",
+      maxRetries: MAX_API_RETRIES,
+    });
   });
 
 const safeJsonParse = (text: string): unknown => {

package/src/gh-tool/environment.ts

@@ -0,0 +1,50 @@
+// Exact names only: GH children need their own auth/config, not unrelated credentials
+// or executable-loader, editor, and pager settings from the parent process.
+const GH_ENVIRONMENT_NAMES = [
+  "PATH",
+  "HOME",
+  "USERPROFILE",
+  "APPDATA",
+  "AppData",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "SYSTEMROOT",
+  "SystemRoot",
+  "WINDIR",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "XDG_CONFIG_HOME",
+  "DBUS_SESSION_BUS_ADDRESS",
+  "GH_CONFIG_DIR",
+  "GH_HOST",
+  "GH_REPO",
+  "GH_TOKEN",
+  "GITHUB_TOKEN",
+  "GH_ENTERPRISE_TOKEN",
+  "GITHUB_ENTERPRISE_TOKEN",
+  "HTTP_PROXY",
+  "http_proxy",
+  "HTTPS_PROXY",
+  "https_proxy",
+  "ALL_PROXY",
+  "all_proxy",
+  "NO_PROXY",
+  "no_proxy",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR",
+] as const;
+
+export const ghEnvironment = (
+  environment: Record<string, string | undefined> = process.env,
+): Record<string, string> =>
+  Object.fromEntries(
+    GH_ENVIRONMENT_NAMES.flatMap((name) => {
+      const value = environment[name];
+      return value === undefined ? [] : [[name, value]];
+    }),
+  );

package/src/gh-tool/service.ts

@@ -5,6 +5,7 @@ import type { GitHubRepoConfig } from "#config";
 import type { RepoInfo } from "./types";
 
 import { GH_BINARY } from "./config";
+import { ghEnvironment } from "./environment";
 import { GitHubAuthError, GitHubCommandError, GitHubNotFoundError } from "./errors";
 import { retryTransient } from "#shared/retry-transient";
 import { githubApi } from "./api";
@@ -165,7 +166,8 @@ export class GitHubService extends Context.Service<
               const command = ChildProcess.make(GH_BINARY, args, {
                 stdout: "pipe",
                 stderr: "pipe",
-                ...(ghRepo ? { env: { GH_REPO: ghRepo }, extendEnv: true } : {}),
+                env: { ...ghEnvironment(), ...(ghRepo ? { GH_REPO: ghRepo } : {}) },
+                extendEnv: false,
               });
 
               const proc = yield* executor.spawn(command);

package/src/gh-tool/text-input.ts

@@ -12,13 +12,19 @@ const SENSITIVE_PATH_PATTERNS = [
   /\.envrc$/,
   /\.(pem|key|p12|pfx|cer|crt)$/i,
   /(?:^|[\\/])(credentials?|passwd|shadow)$/i,
+  /(?:^|\/)(?:\.ssh|\.aws|\.kube|\.azure|secrets?|credentials?)(?:\/|$)/i,
+  /(?:^|\/)(?:\.npmrc|\.netrc|\.git-credentials|\.sentryclirc|\.pypirc|\.pgpass)$/i,
+  /(?:^|\/)\.docker\/config\.json$/i,
+  /(?:^|\/)\.config\/gh\/hosts\.yml$/i,
+  /(?:^|\/)GitHub CLI\/hosts\.yml$/i,
+  /(?:^|\/)(?:kubeconfig(?:[.-].+)?|[^/]+\.kubeconfig)$/i,
 ];
 const MissingMode = Schema.Literals(["error", "null", "default"]);
 
 const readTextFromStdin = () => Bun.stdin.text();
 
 export const isSensitivePath = (filePath: string) =>
-  SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(filePath));
+  SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(filePath.replaceAll("\\", "/")));
 
 export const validateOutboundText = (text: string, command: string) => {
   const reason = unsafeOutboundTextReason(text);