@blogic-cz/agent-tools 1.5.7 → 1.5.9

package/src/db-tool/main.ts

@@ -14,6 +14,7 @@ import {
   VERSION,
 } from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
+import { withRedactedOutput } from "#shared/output-boundary";
 import { ConfigService, ConfigServiceLayer, getDefaultEnvironment } from "#config";
 import { DbConfigService, makeDbConfigLayer } from "./config-service";
 import { DbConnectionError } from "./errors";
@@ -238,6 +239,7 @@ const mainCommand = Command.make("db-tool", {}).pipe(
 
 const cli = Command.run(mainCommand, {
   version: VERSION,
+  renderErrors: false,
 });
 
 const dbConfigLayer = makeDbConfigLayer(profileArg);
@@ -252,7 +254,7 @@ const MainLayer = DbService.layer.pipe(
   Layer.provideMerge(AuditServiceLayer),
 );
 
-const program = withAudit("db", cli).pipe(
+const program = withRedactedOutput(withAudit("db", cli)).pipe(
   Effect.provide(MainLayer),
   Effect.tapCause(renderCauseToStderr),
 );

package/src/db-tool/service.ts

@@ -6,6 +6,7 @@ import type { DbConfig, DbMutationOperation, QueryResult, SchemaMode } from "./t
 import { ConfigService } from "#config";
 import { isPrerequisiteRunError } from "#shared/prerequisites/errors";
 import { resolveEnvTemplate } from "#shared/env-template";
+import { unsafeOutboundTextReason } from "#shared/content-security";
 import { resolveEnvironmentScopedPrerequisites } from "#shared/prerequisites/config";
 import { runWithProfilePrerequisites } from "#shared/prerequisites/runtime";
 import { buildApiProbeArgs } from "#shared/k8s-probe";
@@ -501,8 +502,18 @@ export class DbService extends Context.Service<
           readOnly: isFullyReadOnly(config),
         });
 
-        const runSql = (config: DbConfig, password: string, sql: string) =>
-          sqlClient.run(toConnection(config, password), sql);
+        const unsafeSqlError = (reason: string) =>
+          new DbQueryError({
+            message: `Refusing to send SQL containing ${reason}.`,
+            sql: "[redacted]",
+          });
+
+        const runSql = (config: DbConfig, password: string, sql: string) => {
+          const unsafeReason = unsafeOutboundTextReason(sql);
+          return unsafeReason === null
+            ? sqlClient.run(toConnection(config, password), sql)
+            : Effect.fail(unsafeSqlError(unsafeReason));
+        };
 
         const fetchSingleColumn = (config: DbConfig, password: string, sql: string) =>
           runSql(config, password, sql).pipe(
@@ -772,6 +783,11 @@ export class DbService extends Context.Service<
           sql: string,
           limit?: number,
         ) {
+          const unsafeReason = unsafeOutboundTextReason(sql);
+          if (unsafeReason !== null) {
+            return yield* unsafeSqlError(unsafeReason);
+          }
+
           const config = yield* getConfigForEnv(env);
           const startTimeMs = yield* Clock.currentTimeMillis;
           const resolvedConfig = yield* resolveDbConfig(config, env);
@@ -827,6 +843,13 @@ export class DbService extends Context.Service<
           mode: SchemaMode,
           table?: string,
         ) {
+          if (table !== undefined) {
+            const unsafeReason = unsafeOutboundTextReason(table);
+            if (unsafeReason !== null) {
+              return yield* unsafeSqlError(unsafeReason);
+            }
+          }
+
           const config = yield* getConfigForEnv(env);
           const startTimeMs = yield* Clock.currentTimeMillis;
           const resolvedConfig = yield* resolveDbConfig(config, env);

package/src/gh-tool/gist.ts

@@ -1,9 +1,15 @@
 import { Command, Flag } from "effect/unstable/cli";
 import { Effect, Option } from "effect";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { formatOption, logFormatted } from "#shared";
-import { isSensitivePath, resolveOptionalTextInput, validateOutboundFile } from "#gh/text-input";
+import {
+  isSensitivePath,
+  readValidatedOutboundFile,
+  resolveOptionalTextInput,
+} from "#gh/text-input";
 import { GitHubCommandError } from "./errors";
 import { GitHubService } from "./service";
 
@@ -118,29 +124,13 @@ const validateFilePath = (path: string, command: string) =>
 // `gh gist create/edit` read content from files only; inline --body is staged in a temp file
 // whose basename becomes the gist filename.
 const stageBody = Effect.fn("gist.stageBody")(function* (opts: {
-  body: string;
+  body: string | Uint8Array;
   filename: string;
   command: string;
 }) {
   const directory = yield* Effect.acquireRelease(
     Effect.tryPromise({
-      try: async () => {
-        const proc = Bun.spawn(
-          ["mktemp", "-d", join(process.env.TMPDIR ?? "/tmp", "gh-tool-gist-XXXXXX")],
-          { stdout: "pipe", stderr: "pipe" },
-        );
-        const [exitCode, stdout, stderr] = await Promise.all([
-          proc.exited,
-          new Response(proc.stdout).text(),
-          new Response(proc.stderr).text(),
-        ]);
-
-        if (exitCode !== 0) {
-          throw new Error(stderr.trim() || `mktemp exited with code ${exitCode}`);
-        }
-
-        return stdout.trim();
-      },
+      try: () => mkdtemp(join(process.env.TMPDIR ?? tmpdir(), "gh-tool-gist-")),
       catch: (error) =>
         inputError(
           `Failed to stage gist content: ${error instanceof Error ? error.message : String(error)}`,
@@ -149,20 +139,14 @@ const stageBody = Effect.fn("gist.stageBody")(function* (opts: {
     }),
     (tempDirectory) =>
       Effect.tryPromise({
-        try: async () => {
-          const proc = Bun.spawn(["rm", "-rf", tempDirectory], {
-            stdout: "ignore",
-            stderr: "ignore",
-          });
-          await proc.exited;
-        },
+        try: () => rm(tempDirectory, { recursive: true, force: true }),
         catch: () => undefined,
       }).pipe(Effect.ignore),
   );
   const path = join(directory, opts.filename);
 
   yield* Effect.tryPromise({
-    try: () => Bun.write(path, opts.body),
+    try: () => writeFile(path, opts.body),
     catch: (error) =>
       inputError(
         `Failed to stage gist content: ${error instanceof Error ? error.message : String(error)}`,
@@ -293,45 +277,55 @@ export const createGist = Effect.fn("gist.createGist")(function* (opts: {
   public: boolean;
 }) {
   const gh = yield* GitHubService;
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      const snapshots: string[] = [];
+      for (const path of opts.paths) {
+        const validated = yield* readValidatedOutboundFile(path, "gh-tool gist create");
+        const filename = path.split(/[\\/]/).at(-1) ?? path;
+        snapshots.push(
+          yield* stageBody({ body: validated.bytes, filename, command: "gh-tool gist create" }),
+        );
+      }
 
-  for (const path of opts.paths) yield* validateOutboundFile(path, "gh-tool gist create");
-
-  const args = ["gist", "create", ...opts.paths];
+      const args = ["gist", "create", ...snapshots];
 
-  if (opts.description !== null) {
-    args.push("--desc", opts.description);
-  }
+      if (opts.description !== null) {
+        args.push("--desc", opts.description);
+      }
 
-  if (opts.public) {
-    args.push("--public");
-  }
+      if (opts.public) {
+        args.push("--public");
+      }
 
-  const result = yield* gh.runGh(args);
-  const url =
-    result.stdout
-      .trim()
-      .split("\n")
-      .map((line) => line.trim())
-      .findLast((line) => line.startsWith("https://")) ?? "";
-
-  if (url === "") {
-    return yield* Effect.fail(
-      inputError("gh gist create did not return a gist URL", "gh-tool gist create"),
-    );
-  }
+      const result = yield* gh.runGh(args);
+      const url =
+        result.stdout
+          .trim()
+          .split("\n")
+          .map((line) => line.trim())
+          .findLast((line) => line.startsWith("https://")) ?? "";
+
+      if (url === "") {
+        return yield* Effect.fail(
+          inputError("gh gist create did not return a gist URL", "gh-tool gist create"),
+        );
+      }
 
-  const created: GistCreateResult = {
-    created: true,
-    id: url.split("/").at(-1) ?? "",
-    url,
-    public: opts.public,
-    files: opts.paths.map((path) => path.split("/").at(-1) ?? path),
-  };
+      const created: GistCreateResult = {
+        created: true,
+        id: url.split("/").at(-1) ?? "",
+        url,
+        public: opts.public,
+        files: opts.paths.map((path) => path.split(/[\\/]/).at(-1) ?? path),
+      };
 
-  return created;
+      return created;
+    }),
+  );
 });
 
-const editGist = Effect.fn("gist.editGist")(function* (opts: {
+export const editGist = Effect.fn("gist.editGist")(function* (opts: {
   id: string;
   description: string | null;
   add: string | null;
@@ -341,15 +335,13 @@ const editGist = Effect.fn("gist.editGist")(function* (opts: {
 }) {
   const gh = yield* GitHubService;
 
-  for (const path of [opts.sourcePath, opts.add]) {
-    if (path !== null) yield* validateOutboundFile(path, "gh-tool gist edit");
-  }
-
   const args = ["gist", "edit", opts.id];
   const changes: string[] = [];
 
   if (opts.sourcePath !== null) {
-    args.push(opts.sourcePath);
+    const validated = yield* readValidatedOutboundFile(opts.sourcePath, "gh-tool gist edit");
+    const filename = opts.filename ?? opts.sourcePath.split(/[\\/]/).at(-1) ?? "";
+    args.push(yield* stageBody({ body: validated.bytes, filename, command: "gh-tool gist edit" }));
     changes.push(`content:${opts.filename ?? opts.sourcePath.split("/").at(-1)}`);
   }
 
@@ -359,7 +351,14 @@ const editGist = Effect.fn("gist.editGist")(function* (opts: {
   }
 
   if (opts.add !== null) {
-    args.push("--add", opts.add);
+    const validated = yield* readValidatedOutboundFile(opts.add, "gh-tool gist edit");
+    const filename = opts.add.split(/[\\/]/).at(-1) ?? opts.add;
+    const snapshot = yield* stageBody({
+      body: validated.bytes,
+      filename,
+      command: "gh-tool gist edit",
+    });
+    args.push("--add", snapshot);
     changes.push(`add:${opts.add.split("/").at(-1)}`);
   }
 

package/src/gh-tool/main.ts

@@ -5,6 +5,7 @@ import { Effect, Layer } from "effect";
 
 import { makeSchemaCommand, renderCauseToStderr, VERSION } from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
+import { withRedactedOutput } from "#shared/output-boundary";
 import { ConfigServiceLayer } from "#config";
 import {
   issueCloseCommand,
@@ -240,6 +241,7 @@ WORKFLOW FOR AI AGENTS:
 
 const cli = Command.run(mainCommand, {
   version: VERSION,
+  renderErrors: false,
 });
 
 const MainLayer = GitHubService.layer.pipe(
@@ -248,7 +250,7 @@ const MainLayer = GitHubService.layer.pipe(
   Layer.provideMerge(ConfigServiceLayer),
 );
 
-const program = withAudit("gh", cli).pipe(
+const program = withRedactedOutput(withAudit("gh", cli)).pipe(
   Effect.provide(MainLayer),
   Effect.tapCause(renderCauseToStderr),
 );

package/src/gh-tool/pr/core.ts

@@ -21,6 +21,7 @@ import { GitHubCommandError, GitHubMergeError } from "#gh/errors";
 import { GitHubService } from "#gh/service";
 import type { GhResult } from "#gh/service";
 import { logText } from "#shared";
+import { redactSensitiveText } from "#shared/content-security";
 
 import type { ButStatusJson, PRViewJsonResult } from "./helpers";
 import { pollUntilResolved } from "#shared/poll-until-resolved";
@@ -114,14 +115,18 @@ const resolveMergeSha = Effect.fn("pr.resolveMergeSha")(function* (
     Effect.map((sha) => ({ sha, failed: false as const })),
     Effect.catch((error) =>
       Console.error(
-        `Warning: PR #${pr} was merged, but its merge commit SHA could not be read: ${error.message}`,
+        redactSensitiveText(
+          `Warning: PR #${pr} was merged, but its merge commit SHA could not be read: ${error.message}`,
+        ),
       ).pipe(Effect.as({ sha: null, failed: true as const })),
     ),
   );
 
   if (result.sha === null && !result.failed) {
     yield* Console.error(
-      `Warning: PR #${pr} was merged, but its merge commit SHA is still unknown after ${MERGE_SHA_WAIT_SECONDS}s.`,
+      redactSensitiveText(
+        `Warning: PR #${pr} was merged, but its merge commit SHA is still unknown after ${MERGE_SHA_WAIT_SECONDS}s.`,
+      ),
     );
   }
 
@@ -1088,7 +1093,9 @@ export const mergePR = Effect.fn("pr.mergePR")(function* (opts: {
                   if (error._tag !== "GitHubCommandError") {
                     return rollbackNote === ""
                       ? Effect.fail(error)
-                      : Console.error(rollbackNote.trim()).pipe(Effect.andThen(Effect.fail(error)));
+                      : Console.error(redactSensitiveText(rollbackNote.trim())).pipe(
+                          Effect.andThen(Effect.fail(error)),
+                        );
                   }
 
                   const stderr = error.stderr.toLowerCase();

package/src/gh-tool/pr/review.ts

@@ -15,6 +15,7 @@ import type { REVIEW_EVENTS } from "#gh/config";
 
 import { GitHubCommandError } from "#gh/errors";
 import { GitHubService } from "#gh/service";
+import { validateOutboundText } from "#gh/text-input";
 
 import { viewPR } from "./core";
 
@@ -83,16 +84,39 @@ const RESOLVE_THREAD_MUTATION = `
 `;
 
 const PENDING_REVIEWS_QUERY = `
-  query($owner: String!, $name: String!, $pr: Int!) {
+  query($owner: String!, $name: String!, $pr: Int!, $after: String) {
     viewer { login }
     repository(owner: $owner, name: $name) {
       pullRequest(number: $pr) {
-        reviews(last: 100, states: [PENDING]) {
+        reviews(first: 100, after: $after, states: [PENDING]) {
           nodes {
             id
             state
             author { login }
           }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  }
+`;
+
+const PENDING_REVIEW_CONTENT_QUERY = `
+  query($reviewId: ID!, $after: String) {
+    viewer { login }
+    node(id: $reviewId) {
+      ... on PullRequestReview {
+        id
+        state
+        body
+        author { login }
+        pullRequest {
+          number
+          repository { nameWithOwner }
+        }
+        comments(first: 100, after: $after) {
+          nodes { body }
+          pageInfo { hasNextPage endCursor }
         }
       }
     }
@@ -188,11 +212,27 @@ type PendingReviewsQueryResult = {
           state: string;
           author: { login: string };
         }>;
+        pageInfo: { hasNextPage: boolean; endCursor: string | null };
       };
     };
   };
 };
 
+type PendingReviewContentQueryResult = {
+  viewer: { login: string };
+  node: {
+    id: string;
+    state: string;
+    body: string | null;
+    author: { login: string };
+    pullRequest: { number: number; repository: { nameWithOwner: string } };
+    comments: {
+      nodes: Array<{ body: string }>;
+      pageInfo: { hasNextPage: boolean; endCursor: string | null };
+    };
+  } | null;
+};
+
 type SubmitReviewResult = {
   submitPullRequestReview: {
     pullRequestReview: { id: string; state: string };
@@ -1080,18 +1120,76 @@ export const submitPendingReview = Effect.fn("pr.submitPendingReview")(function*
   let targetReviewId = reviewId;
 
   if (targetReviewId === null) {
-    const pending = (yield* service.runGraphQL(PENDING_REVIEWS_QUERY, {
-      owner: repoInfo.owner,
-      name: repoInfo.name,
-      pr: resolvedPr,
-    })) as PendingReviewsQueryResult;
+    let after: string | null = null;
+    let hasNextPage = true;
+    let viewerLogin: string | null = null;
+    let ownPendingReviewId: string | null = null;
+    const seenPendingCursors = new Set<string>();
+
+    while (hasNextPage) {
+      const pending = (yield* service.runGraphQL(PENDING_REVIEWS_QUERY, {
+        owner: repoInfo.owner,
+        name: repoInfo.name,
+        pr: resolvedPr,
+        after,
+      })) as PendingReviewsQueryResult;
+
+      if (
+        typeof pending.viewer?.login !== "string" ||
+        !Array.isArray(pending.repository?.pullRequest?.reviews?.nodes) ||
+        typeof pending.repository.pullRequest.reviews?.pageInfo?.hasNextPage !== "boolean" ||
+        (pending.repository.pullRequest.reviews.pageInfo.endCursor !== null &&
+          typeof pending.repository.pullRequest.reviews.pageInfo.endCursor !== "string") ||
+        pending.repository.pullRequest.reviews.nodes.some(
+          (review) =>
+            typeof review?.id !== "string" ||
+            typeof review.state !== "string" ||
+            typeof review.author?.login !== "string",
+        )
+      ) {
+        return yield* Effect.fail(
+          new GitHubCommandError({
+            command: "gh-tool pr submit-review",
+            exitCode: 1,
+            message: "Could not verify pending reviews; refusing to submit",
+            stderr: "Pending review lookup returned incomplete data",
+          }),
+        );
+      }
 
-    const viewerLogin = pending.viewer.login;
-    const pendingReviews = pending.repository.pullRequest.reviews.nodes;
+      viewerLogin ??= pending.viewer.login;
+      const own = pending.repository.pullRequest.reviews.nodes.find(
+        (review) => review.author?.login === viewerLogin && review.state === "PENDING",
+      );
+      ownPendingReviewId ??= own?.id ?? null;
 
-    const ownPendingReview = pendingReviews.find((review) => review.author.login === viewerLogin);
+      const pageInfo = pending.repository.pullRequest.reviews.pageInfo;
+      hasNextPage = pageInfo.hasNextPage;
+      after = pageInfo.endCursor;
+      if (hasNextPage && (after === null || after.length === 0)) {
+        return yield* Effect.fail(
+          new GitHubCommandError({
+            command: "gh-tool pr submit-review",
+            exitCode: 1,
+            message: "Could not verify all pending reviews; refusing to submit",
+            stderr: "Pending review lookup returned an incomplete page cursor",
+          }),
+        );
+      }
+      if (hasNextPage && after !== null && seenPendingCursors.has(after)) {
+        return yield* Effect.fail(
+          new GitHubCommandError({
+            command: "gh-tool pr submit-review",
+            exitCode: 1,
+            message: "Could not verify all pending reviews; refusing to submit",
+            stderr: "Pending review lookup repeated a page cursor",
+          }),
+        );
+      }
+      if (hasNextPage && after !== null) seenPendingCursors.add(after);
+    }
 
-    if (!ownPendingReview) {
+    if (ownPendingReviewId === null) {
       return yield* Effect.fail(
         new GitHubCommandError({
           command: "gh-tool pr submit-review",
@@ -1102,7 +1200,96 @@ export const submitPendingReview = Effect.fn("pr.submitPendingReview")(function*
       );
     }
 
-    targetReviewId = ownPendingReview.id;
+    targetReviewId = ownPendingReviewId;
+  }
+
+  if (targetReviewId === null) {
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command: "gh-tool pr submit-review",
+        exitCode: 1,
+        message: "Could not identify pending review; refusing to submit",
+        stderr: "Pending review lookup returned no review ID",
+      }),
+    );
+  }
+
+  let afterComment: string | null = null;
+  let commentsHaveNextPage = true;
+  const seenCommentCursors = new Set<string>();
+  while (commentsHaveNextPage) {
+    const pendingReview = (yield* service.runGraphQL(PENDING_REVIEW_CONTENT_QUERY, {
+      reviewId: targetReviewId,
+      after: afterComment,
+    })) as PendingReviewContentQueryResult;
+
+    const review = pendingReview?.node;
+    if (
+      typeof pendingReview?.viewer?.login !== "string" ||
+      review === null ||
+      review === undefined ||
+      review.id !== targetReviewId ||
+      review.state !== "PENDING" ||
+      review.author?.login !== pendingReview.viewer.login ||
+      review.pullRequest?.number !== resolvedPr ||
+      typeof review.pullRequest.repository?.nameWithOwner !== "string" ||
+      review.pullRequest.repository.nameWithOwner.toLowerCase() !==
+        `${repoInfo.owner}/${repoInfo.name}`.toLowerCase() ||
+      typeof review.body !== "string" ||
+      !Array.isArray(review.comments?.nodes) ||
+      typeof review.comments.pageInfo?.hasNextPage !== "boolean" ||
+      (review.comments.pageInfo.endCursor !== null &&
+        typeof review.comments.pageInfo.endCursor !== "string")
+    ) {
+      return yield* Effect.fail(
+        new GitHubCommandError({
+          command: "gh-tool pr submit-review",
+          exitCode: 1,
+          message: "Could not verify pending review contents; refusing to submit",
+          stderr: "Pending review lookup returned incomplete or non-owned review data",
+        }),
+      );
+    }
+
+    yield* validateOutboundText(review.body, "gh-tool pr submit-review");
+    for (const comment of review.comments.nodes) {
+      if (typeof comment?.body !== "string") {
+        return yield* Effect.fail(
+          new GitHubCommandError({
+            command: "gh-tool pr submit-review",
+            exitCode: 1,
+            message: "Could not verify pending review comments; refusing to submit",
+            stderr: "Pending review lookup returned a comment without a body",
+          }),
+        );
+      }
+      yield* validateOutboundText(comment.body, "gh-tool pr submit-review");
+    }
+
+    const pageInfo = review.comments.pageInfo;
+    commentsHaveNextPage = pageInfo.hasNextPage;
+    afterComment = pageInfo.endCursor;
+    if (commentsHaveNextPage && (afterComment === null || afterComment.length === 0)) {
+      return yield* Effect.fail(
+        new GitHubCommandError({
+          command: "gh-tool pr submit-review",
+          exitCode: 1,
+          message: "Could not verify all pending review comments; refusing to submit",
+          stderr: "Pending review lookup returned an incomplete comment cursor",
+        }),
+      );
+    }
+    if (commentsHaveNextPage && afterComment !== null && seenCommentCursors.has(afterComment)) {
+      return yield* Effect.fail(
+        new GitHubCommandError({
+          command: "gh-tool pr submit-review",
+          exitCode: 1,
+          message: "Could not verify all pending review comments; refusing to submit",
+          stderr: "Pending review lookup repeated a comment cursor",
+        }),
+      );
+    }
+    if (commentsHaveNextPage && afterComment !== null) seenCommentCursors.add(afterComment);
   }
 
   const result = (yield* service.runGraphQL(SUBMIT_REVIEW_MUTATION, {