@blogic-cz/agent-tools 1.10.1 → 1.12.0

package/src/credential-guard/shell-oracle.ts

@@ -0,0 +1,187 @@
+import { formatLiteralPrintf } from "./literal-output";
+import { parseBash } from "./bash";
+import { judge } from "./policy";
+import { splitXargsInput, type XargsInput } from "./xargs";
+
+const quote = (text: string): string => "'" + text.replaceAll("'", "'\\''") + "'";
+const receipt: Record<string, { checked: number; refused: number; mismatches: unknown[] }> = {};
+async function compare(
+  family: string,
+  shell: string,
+  source: string,
+  modeled: readonly string[] | null,
+) {
+  const count = (receipt[family] ??= { checked: 0, refused: 0, mismatches: [] });
+  const child = Bun.spawn([shell, "-c", source], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { PATH: "/usr/bin:/bin", HOME: "/tmp" },
+  });
+  const actual = await new Response(child.stdout).text();
+  await new Response(child.stderr).text();
+  await child.exited;
+  count.checked++;
+  if (modeled === null) count.refused++;
+  else if (family === "termination") {
+    const reached = actual.split("\n").includes("[reached]");
+    if (reached && !modeled.some((output) => output.includes("[reached]")))
+      count.mismatches.push({ shell, source, actual, modeled });
+  } else if (!modeled.includes(actual)) count.mismatches.push({ shell, source, actual, modeled });
+}
+function modeledOutput(source: string): readonly string[] | null {
+  const outputs: string[] = [];
+  let unresolved = false;
+  const decision = judge(parseBash(source), {
+    home: "/home/dev",
+    cwd: "/tmp",
+    onInvocation(executable, argv) {
+      if (executable === "/usr/bin/printf" && argv[1] === "[%s]\\n") {
+        if (argv.some((word) => word === undefined)) unresolved = true;
+        outputs.push(
+          (argv.length > 2 ? argv.slice(2) : [""]).map((word) => `[${word}]\n`).join(""),
+        );
+      }
+    },
+  });
+  return decision.kind === "pass" && !unresolved
+    ? outputs.length
+      ? [...outputs, outputs.join("")]
+      : [""]
+    : null;
+}
+const jobs: Array<() => Promise<void>> = [];
+const shells = ["/bin/bash", "/bin/sh", "/bin/zsh", "/bin/dash"];
+const available = await Promise.all(
+  shells.map(async (shell) => ({ shell, exists: await Bun.file(shell).exists() })),
+);
+for (const { shell, exists } of available) {
+  if (!exists) {
+    console.log(`SKIP missing shell ${shell}`);
+    continue;
+  }
+  const braces = [
+    "{a,}",
+    "{,}",
+    "{,b}",
+    "x{,b}",
+    "{a,b}{,c}",
+    "'{a,b}'",
+    '"{a,b}"',
+    "{a,{b,c}}",
+    "{a,}''",
+    "''{,b}",
+  ];
+  for (const left of ["a", "", "b"])
+    for (const right of ["", "c", "d"]) braces.push(`{${left},${right}}`, `p{${left},${right}}q`);
+  for (const words of braces) {
+    const source = `/usr/bin/printf '[%s]\\n' seed ${words}`;
+    const model =
+      shell.endsWith("/sh") || shell.endsWith("/dash")
+        ? `sh -c ${quote(source)}`
+        : shell.endsWith("/bash")
+          ? `bash -c ${quote(source)}`
+          : source;
+    jobs.push(() => compare("brace", shell, source, modeledOutput(model)));
+  }
+  for (const format of ["%s\\n", "%s ", "%s", "%s:%s\\n"])
+    for (const words of [[], ["alpha"], ["alpha", "beta"], ["", "beta"], ["a b", "c"]]) {
+      const source = `printf ${quote(format)} ${words.map(quote).join(" ")}`;
+      const modeled = formatLiteralPrintf([format, ...words]);
+      jobs.push(() => compare("printf", shell, source, modeled === null ? null : [modeled]));
+    }
+  for (const compound of [
+    "{ exit 0; }",
+    "(exit 0)",
+    "if true; then exit 0; fi",
+    "case x in x) exit 0;; esac",
+    "for x in a; do exit 0; done",
+    "while true; do exit 0; done",
+    "exit 0 && true",
+    "exit 0 || true",
+    "exit 0 && false || true",
+    "exit 0 || false && true",
+    "{ exit 0; } && true",
+    "! { exit 0; } || true",
+  ])
+    for (const redirect of ["&>/dev/null", "&>>/dev/null"]) {
+      const source = `${compound} ${redirect}; /usr/bin/printf '[%s]\\n' reached`;
+      jobs.push(() =>
+        compare(
+          "termination",
+          shell,
+          source,
+          modeledOutput(
+            `${shell.endsWith("/bash") || shell.endsWith("/zsh") ? "bash" : "sh"} -c ${quote(source)}`,
+          ),
+        ),
+      );
+    }
+  for (const command of ["exit", "return"])
+    for (const redirect of [
+      "",
+      " 2>/dev/null",
+      " &>/dev/null",
+      " &>>/dev/null",
+      " </tmp/guard-oracle-missing/input",
+      " >/dev/null/x",
+      " 2>&1",
+      " 2>&99",
+      " 1>&- 2>&1",
+    ])
+      for (const op of [";", "||"]) {
+        const source = `${command} 0${redirect} ${op} /usr/bin/printf '[%s]\\n' reached`;
+        jobs.push(() =>
+          compare(
+            "termination",
+            shell,
+            source,
+            modeledOutput(
+              `${shell.endsWith("/bash") || shell.endsWith("/zsh") ? "bash" : "sh"} -c ${quote(source)}`,
+            ),
+          ),
+        );
+      }
+}
+const modes: XargsInput[] = [
+  { replacement: null, maxArgs: null, maxLines: null },
+  { replacement: "{}", maxArgs: null, maxLines: null },
+  { replacement: null, maxArgs: 1, maxLines: null },
+  { replacement: null, maxArgs: null, maxLines: 1 },
+];
+const inputs = [
+  "a\nb\n",
+  "a b\n",
+  "'' word\n",
+  '"" word\n',
+  "a  b\n",
+  "a\tb\n",
+  "  a\n",
+  "a\n\nb\n",
+  "'a b'\n",
+  "a\\ b\n",
+];
+for (const a of ["a", "''", '""', " "])
+  for (const b of [" ", "  ", "\t", "\n"]) inputs.push(a + b + "b\n");
+for (const mode of modes)
+  for (const input of inputs) {
+    const groups = splitXargsInput(input, mode);
+    const output =
+      groups === null
+        ? null
+        : groups
+            .flatMap((words) => (words.length ? words : [""]).map((word) => `[${word}]\n`))
+            .join("");
+    const flags = mode.replacement ? "-I{}" : mode.maxArgs ? "-n1" : mode.maxLines ? "-L1" : "";
+    const source = `printf '%s' ${quote(input)} | /usr/bin/xargs ${flags} /usr/bin/printf '[%s]\\n' ${mode.replacement ? "'{}'" : ""}`;
+    jobs.push(() =>
+      compare(
+        `xargs-${flags || "default"}`,
+        "/bin/bash",
+        source,
+        output === null ? null : [output],
+      ),
+    );
+  }
+await jobs.reduce((previous, run) => previous.then(run), Promise.resolve());
+console.log(JSON.stringify(receipt, null, 2));
+if (Object.values(receipt).some((family) => family.mismatches.length)) process.exitCode = 1;

package/src/credential-guard/xargs.ts

@@ -0,0 +1,65 @@
+export type XargsInput = {
+  readonly replacement: string | null;
+  readonly maxArgs: number | null;
+  readonly maxLines: number | null;
+};
+
+export function splitXargsInput(text: string, mode: XargsInput): readonly string[][] | null {
+  if (/[^\t\n\x20-\x7e]/.test(text)) return null;
+  if (mode.replacement !== null && /['"\t]| {2}|^ |\n |\\/.test(text)) return null;
+  const lines: string[][] = [];
+  let words: string[] = [];
+  let word = "";
+  let started = false;
+  let quote = "";
+  const finishWord = () => {
+    if (started) words.push(word);
+    word = "";
+    started = false;
+  };
+  for (let index = 0; index < text.length; index++) {
+    const ch = text[index] ?? "";
+    if (ch === "\n") {
+      if (
+        quote ||
+        ((mode.maxLines !== null || mode.replacement !== null) &&
+          /[ \t]/.test(text[index - 1] ?? ""))
+      )
+        return null;
+      finishWord();
+      if (words.length) lines.push(words);
+      words = [];
+    } else if (ch === "\\" && !quote) {
+      const next = text[++index];
+      if (next === undefined || next === "\n") return null;
+      word += next;
+      started = true;
+    } else if ((ch === "'" || ch === '"') && (!quote || ch === quote)) {
+      quote = quote ? "" : ch;
+      started = true;
+    } else if (!quote && /[ \t]/.test(ch) && mode.replacement === null) {
+      finishWord();
+    } else if (mode.replacement !== null && !started && /[ \t]/.test(ch)) {
+      continue;
+    } else {
+      word += ch;
+      started = true;
+    }
+  }
+  if (quote) return null;
+  finishWord();
+  if (words.length) lines.push(words);
+  const result: string[][] = [];
+  if (mode.replacement !== null) result.push(...lines);
+  else if (mode.maxLines !== null) {
+    for (let index = 0; index < lines.length; index += mode.maxLines)
+      result.push(lines.slice(index, index + mode.maxLines).flat());
+  } else {
+    const all = lines.flat();
+    const size = mode.maxArgs ?? Math.max(all.length, 1);
+    for (let index = 0; index < all.length; index += size)
+      result.push(all.slice(index, index + size));
+  }
+  if (result.length > 64 || result.some((args) => args.length > 64)) return null;
+  return result.length ? result : null;
+}

package/src/db-tool/main.ts

@@ -14,6 +14,7 @@ import {
   VERSION,
 } from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
+import { SecretEnvResolver } from "#shared/secret-env";
 import { withRedactedOutput } from "#shared/output-boundary";
 import { ConfigService, ConfigServiceLayer, getDefaultEnvironment } from "#config";
 import { DbConfigService, makeDbConfigLayer } from "./config-service";
@@ -248,6 +249,7 @@ const MainLayer = DbService.layer.pipe(
   // provideMerge (not provide) so DbConfigService stays in the program context for the `envs` command,
   // which reads it directly rather than going through DbService.
   Layer.provideMerge(DbSqlClient.layer),
+  Layer.provideMerge(SecretEnvResolver.liveLayer),
   Layer.provideMerge(dbConfigLayer),
   Layer.provideMerge(ConfigServiceLayer),
   Layer.provideMerge(BunServices.layer),

package/src/db-tool/service.ts

@@ -1,5 +1,5 @@
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
-import { Clock, Context, Duration, Effect, Layer, Ref, Result, Stream } from "effect";
+import { Clock, Context, Duration, Effect, Layer, Result, Stream } from "effect";
 
 import type { DbConfig, DbMutationOperation, QueryResult, SchemaMode } from "./types";
 
@@ -7,6 +7,7 @@ import { ConfigService } from "#config";
 import { isPrerequisiteRunError } from "#shared/prerequisites/errors";
 import { resolveEnvTemplate } from "#shared/env-template";
 import { registerResolvedSecret, unsafeOutboundTextReason } from "#shared/content-security";
+import { SecretEnvResolver } from "#shared/secret-env";
 import { resolveEnvironmentScopedPrerequisites } from "#shared/prerequisites/config";
 import { runWithProfilePrerequisites } from "#shared/prerequisites/runtime";
 import { buildApiProbeArgs } from "#shared/k8s-probe";
@@ -43,12 +44,6 @@ const MIN_TCP_PORT = 1;
 const MAX_TCP_PORT = 65535;
 const INTEGER_ONLY = /^\d+$/;
 
-// Bun.env is the primary source: it carries the values Bun loads from a .env file, which is where
-// a per-worktree host/port lives. It aliases process.env, which is also the only one that exists
-// when this module runs outside Bun (the vitest runner).
-const readProcessEnv = (envVar: string): string | undefined =>
-  (typeof Bun === "undefined" ? process.env : Bun.env)[envVar];
-
 export type ResolvedPortOverride =
   | { readonly ok: true; readonly port: number }
   | { readonly ok: false; readonly message: string };
@@ -159,6 +154,7 @@ export class DbService extends Context.Service<
       Effect.gen(function* () {
         const executor = yield* ChildProcessSpawner.ChildProcessSpawner;
         const sqlClient = yield* DbSqlClient;
+        const secretEnvResolver = yield* SecretEnvResolver;
         const agentToolsConfig = yield* ConfigService;
         const dbConfig = yield* DbConfigService;
 
@@ -185,152 +181,138 @@ export class DbService extends Context.Service<
         const apiProbeTimeoutMs = dbConfig.apiProbeTimeoutMs ?? 2000;
         const remotePort = dbConfig.remotePort ?? 5432;
 
-        const zshrcEnvCache = yield* Ref.make<Record<string, string> | null>(null);
         const envTemplateRegex = /^\$\{([A-Za-z0-9_]+)\}$/;
+        const lookupConfigEnv = (name: string) =>
+          Effect.tryPromise({
+            try: () => secretEnvResolver.lookupConfigEnv(name),
+            catch: () => new Error(`${name} lookup failed`),
+          });
 
-        const loadEnvFromZshrc = Effect.fn("DbService.loadEnvFromZshrc")(function* () {
-          const cached = yield* Ref.get(zshrcEnvCache);
-          if (cached !== null) {
-            return cached;
-          }
-
-          const home = process.env.HOME;
-          if (!home || home.trim() === "") {
-            yield* Ref.set(zshrcEnvCache, {});
-            return {};
-          }
-
-          const zshrcPath = `${home}/.zshrc`;
-          const content = yield* Effect.tryPromise(async () => {
-            const file = Bun.file(zshrcPath);
-            if (!(await file.exists())) {
-              return "";
+        const resolvePassword = (config: DbConfig, env: string) =>
+          Effect.gen(function* () {
+            if (config.password) {
+              registerResolvedSecret(config.password);
+              return config.password;
             }
-            return await file.text();
-          }).pipe(Effect.orElseSucceed(() => ""));
 
-          const envVars: Record<string, string> = {};
-          const regex = /^export\s+([A-Z_][A-Z0-9_]*)=["']?([^"'\n]+)["']?/gm;
-          let match = regex.exec(content);
-
-          while (match !== null) {
-            envVars[match[1]] = match[2];
-            match = regex.exec(content);
-          }
-
-          yield* Ref.set(zshrcEnvCache, envVars);
-          return envVars;
-        });
+            const passwordEnvVar = config.passwordEnvVar;
+            if (passwordEnvVar) {
+              return yield* Effect.tryPromise({
+                try: () => secretEnvResolver.resolveSecretEnv(passwordEnvVar),
+                catch: () =>
+                  new Error(
+                    `${passwordEnvVar} is not in the environment or in the interactive zsh`,
+                  ),
+              }).pipe(
+                Effect.mapError(
+                  () =>
+                    new DbConnectionError({
+                      message: `${passwordEnvVar} is not in the environment or in the interactive zsh`,
+                      environment: env,
+                    }),
+                ),
+              );
+            }
 
-        const resolvePassword = Effect.fn("DbService.resolvePassword")(function* (
-          config: DbConfig,
-          env: string,
-        ) {
-          if (config.password) {
-            registerResolvedSecret(config.password);
-            return config.password;
-          }
+            // Local databases typically don't need a password
+            return "";
+          });
 
-          if (config.passwordEnvVar) {
-            const fromEnv = process.env[config.passwordEnvVar];
-            if (fromEnv) {
-              registerResolvedSecret(fromEnv);
-              return fromEnv;
+        const resolveConfigString = (value: string, env: string, label: string) =>
+          Effect.gen(function* () {
+            const match = value.match(envTemplateRegex);
+            if (!match) return value;
+
+            const envVar = match[1];
+            const result = yield* lookupConfigEnv(envVar).pipe(
+              Effect.mapError(
+                () =>
+                  new DbConnectionError({
+                    message: `${envVar} lookup failed (required for '${label}' config field) in environment ${env}.`,
+                    environment: env,
+                  }),
+              ),
+            );
+            if (result._tag === "failed") {
+              return yield* new DbConnectionError({
+                message: `${envVar} lookup failed (required for '${label}' config field) in environment ${env}.`,
+                environment: env,
+              });
             }
-
-            const zshrcEnv = yield* loadEnvFromZshrc();
-            const fromZsh = zshrcEnv[config.passwordEnvVar];
-            if (fromZsh) {
-              registerResolvedSecret(fromZsh);
-              return fromZsh;
+            if (result._tag === "absent") {
+              return yield* new DbConnectionError({
+                message: `${envVar} is not in the environment or in the interactive zsh (required for '${label}' config field) in environment ${env}.`,
+                environment: env,
+              });
             }
-
-            return yield* new DbConnectionError({
-              message: `Environment variable ${config.passwordEnvVar} is not set.`,
-              environment: env,
-            });
-          }
-
-          // Local databases typically don't need a password
-          return "";
-        });
-
-        const resolveConfigString = Effect.fn("DbService.resolveConfigString")(function* (
-          value: string,
-          env: string,
-          label: string,
-          zshrcEnv: Record<string, string>,
-        ) {
-          const match = value.match(envTemplateRegex);
-          if (!match) return value;
-
-          const envVar = match[1];
-          const fromEnv = Bun.env[envVar];
-          if (fromEnv !== undefined) return fromEnv;
-
-          const fromZsh = zshrcEnv[envVar];
-          if (fromZsh !== undefined) return fromZsh;
-
-          return yield* new DbConnectionError({
-            message: `Environment variable ${envVar} (required for '${label}' config field) is not set in environment ${env}.`,
-            environment: env,
+            return result.value;
           });
-        });
 
-        const lookupEnvOverride = (envVar: string, zshrcEnv: Record<string, string>) =>
-          readProcessEnv(envVar) ?? zshrcEnv[envVar];
-
-        const resolveDbConfig = Effect.fn("DbService.resolveDbConfig")(function* (
-          config: DbConfig,
-          env: string,
-        ) {
-          const needsEnvResolution =
-            envTemplateRegex.test(config.user) ||
-            envTemplateRegex.test(config.database) ||
-            config.hostEnvVar !== undefined ||
-            config.portEnvVar !== undefined;
-          const zshrcEnv = needsEnvResolution ? yield* loadEnvFromZshrc() : {};
-
-          const host = resolveHostOverride(
-            config.host,
-            config.hostEnvVar,
-            config.hostEnvVar ? lookupEnvOverride(config.hostEnvVar, zshrcEnv) : undefined,
-          );
-          const portOverride = resolvePortOverride(
-            env,
-            config.port,
-            config.portEnvVar,
-            config.portEnvVar ? lookupEnvOverride(config.portEnvVar, zshrcEnv) : undefined,
-          );
+        const resolveDbConfig = (config: DbConfig, env: string) =>
+          Effect.gen(function* () {
+            const resolveOverride = (name: string | undefined) => {
+              if (!name) return Effect.succeed(undefined);
+              return lookupConfigEnv(name).pipe(
+                Effect.flatMap((result) => {
+                  if (result._tag === "absent") return Effect.succeed(undefined);
+                  if (result._tag === "failed") {
+                    return Effect.fail(
+                      new DbConnectionError({
+                        message: `${name} lookup failed in environment ${env}.`,
+                        environment: env,
+                      }),
+                    );
+                  }
+                  return Effect.succeed(result.value);
+                }),
+                Effect.mapError(
+                  () =>
+                    new DbConnectionError({
+                      message: `${name} lookup failed in environment ${env}.`,
+                      environment: env,
+                    }),
+                ),
+              );
+            };
+            const hostValue = yield* resolveOverride(config.hostEnvVar);
+            const portValue = yield* resolveOverride(config.portEnvVar);
+
+            const host = resolveHostOverride(config.host, config.hostEnvVar, hostValue);
+            const portOverride = resolvePortOverride(
+              env,
+              config.port,
+              config.portEnvVar,
+              portValue,
+            );
 
-          if (!portOverride.ok) {
-            return yield* new DbConnectionError({
-              message: portOverride.message,
-              environment: env,
-            });
-          }
+            if (!portOverride.ok) {
+              return yield* new DbConnectionError({
+                message: portOverride.message,
+                environment: env,
+              });
+            }
 
-          // A host override can flip the tunnel decision (a forwarded localhost port vs a directly
-          // reachable host), so re-derive the access mode whenever the override changed the host.
-          const needsTunnel =
-            host === config.host
-              ? config.needsTunnel
-              : resolveDbAccessMode(
-                  env,
-                  host,
-                  dbConfig.kubectl !== undefined,
-                  config.allowedMutations,
-                ).needsTunnel;
+            // A host override can flip the tunnel decision (a forwarded localhost port vs a directly
+            // reachable host), so re-derive the access mode whenever the override changed the host.
+            const needsTunnel =
+              host === config.host
+                ? config.needsTunnel
+                : resolveDbAccessMode(
+                    env,
+                    host,
+                    dbConfig.kubectl !== undefined,
+                    config.allowedMutations,
+                  ).needsTunnel;
 
-          return {
-            ...config,
-            host,
-            port: portOverride.port,
-            needsTunnel,
-            user: yield* resolveConfigString(config.user, env, "user", zshrcEnv),
-            database: yield* resolveConfigString(config.database, env, "database", zshrcEnv),
-          };
-        });
+            return {
+              ...config,
+              host,
+              port: portOverride.port,
+              needsTunnel,
+              user: yield* resolveConfigString(config.user, env, "user"),
+              database: yield* resolveConfigString(config.database, env, "database"),
+            };
+          });
 
         const executeShellCommand = (command: ChildProcess.Command) =>
           Effect.scoped(

package/src/db-tool/sql-client.ts

@@ -1,6 +1,7 @@
 import { Context, Effect, Layer } from "effect";
 
 import { DbQueryError } from "./errors";
+import { redactSensitiveText } from "#shared/content-security";
 
 export type DbConnection = {
   readonly host: string;
@@ -22,6 +23,11 @@ type BunQueryResult = unknown[] & { count?: number; command?: string };
 export const toErrorMessage = (cause: unknown): string =>
   cause instanceof Error ? cause.message : String(cause);
 
+export const toDbQueryError = (cause: unknown, sql: string): DbQueryError => {
+  const message = redactSensitiveText(toErrorMessage(cause));
+  return new DbQueryError({ message, sql, stderr: message });
+};
+
 const runWithBunSql = (connection: DbConnection, sql: string) =>
   Effect.tryPromise({
     try: async (): Promise<DbQueryOutcome> => {
@@ -61,10 +67,7 @@ const runWithBunSql = (connection: DbConnection, sql: string) =>
         await client.close().catch(() => undefined);
       }
     },
-    catch: (cause) => {
-      const message = toErrorMessage(cause);
-      return new DbQueryError({ message, sql, stderr: message });
-    },
+    catch: (cause) => toDbQueryError(cause, sql),
   });
 
 export class DbSqlClient extends Context.Service<