@blogic-cz/agent-tools 0.14.4 → 0.14.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.14.4",
+  "version": "0.14.6",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",

package/src/db-tool/service.ts

@@ -76,6 +76,7 @@ export class DbService extends Context.Service<
         const remotePort = dbConfig.remotePort ?? 5432;
 
         const zshrcEnvCache = yield* Ref.make<Record<string, string> | null>(null);
+        const envTemplateRegex = /^\$\{([A-Za-z0-9_]+)\}$/;
 
         const loadEnvFromZshrc = Effect.fn("DbService.loadEnvFromZshrc")(function* () {
           const cached = yield* Ref.get(zshrcEnvCache);
@@ -141,6 +142,42 @@ export class DbService extends Context.Service<
           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,
+          });
+        });
+
+        const resolveDbConfig = Effect.fn("DbService.resolveDbConfig")(function* (
+          config: DbConfig,
+          env: string,
+        ) {
+          const needsEnvResolution =
+            envTemplateRegex.test(config.user) || envTemplateRegex.test(config.database);
+          const zshrcEnv = needsEnvResolution ? yield* loadEnvFromZshrc() : {};
+          return {
+            ...config,
+            user: yield* resolveConfigString(config.user, env, "user", zshrcEnv),
+            database: yield* resolveConfigString(config.database, env, "database", zshrcEnv),
+          };
+        });
+
         const executeShellCommand = (command: ChildProcess.Command) =>
           Effect.scoped(
             Effect.gen(function* () {
@@ -584,10 +621,11 @@ export class DbService extends Context.Service<
         ) {
           const config = getConfigForEnv(env);
           const startTimeMs = yield* Clock.currentTimeMillis;
-          const password = yield* resolvePassword(config, env);
+          const resolvedConfig = yield* resolveDbConfig(config, env);
+          const password = yield* resolvePassword(resolvedConfig, env);
           const mutation = isMutationQuery(sql);
 
-          if (mutation && !config.allowMutations) {
+          if (mutation && !resolvedConfig.allowMutations) {
             return yield* new DbMutationBlockedError({
               message:
                 "Mutation queries (UPDATE, INSERT, DELETE, etc.) are not allowed on this environment. Use a local environment for mutations.",
@@ -596,12 +634,12 @@ export class DbService extends Context.Service<
           }
 
           const queryEffect = mutation
-            ? executeMutationQuery(config, sql, password, Number(startTimeMs))
-            : executeSelectQuery(config, sql, password, Number(startTimeMs), true);
+            ? executeMutationQuery(resolvedConfig, sql, password, Number(startTimeMs))
+            : executeSelectQuery(resolvedConfig, sql, password, Number(startTimeMs), true);
 
           return yield* runWithVpnPrerequisites(
-            config.port,
-            runQueryWithOptionalTunnel(config, queryEffect),
+            resolvedConfig.port,
+            runQueryWithOptionalTunnel(resolvedConfig, queryEffect),
           );
         });
 
@@ -612,7 +650,8 @@ export class DbService extends Context.Service<
         ) {
           const config = getConfigForEnv(env);
           const startTimeMs = yield* Clock.currentTimeMillis;
-          const password = yield* resolvePassword(config, env);
+          const resolvedConfig = yield* resolveDbConfig(config, env);
+          const password = yield* resolvePassword(resolvedConfig, env);
 
           if (mode === "columns" && !table) {
             const endTime = yield* Clock.currentTimeMillis;
@@ -637,16 +676,26 @@ export class DbService extends Context.Service<
 
           const queryEffect =
             mode === "tables"
-              ? executeSelectQuery(config, getTableNames(), password, Number(startTimeMs))
+              ? executeSelectQuery(resolvedConfig, getTableNames(), password, Number(startTimeMs))
               : mode === "columns"
-                ? executeSelectQuery(config, getColumns(table ?? ""), password, Number(startTimeMs))
+                ? executeSelectQuery(
+                    resolvedConfig,
+                    getColumns(table ?? ""),
+                    password,
+                    Number(startTimeMs),
+                  )
                 : mode === "relationships"
-                  ? executeSelectQuery(config, getRelationships(), password, Number(startTimeMs))
-                  : executeFullSchemaQuery(config, password, Number(startTimeMs));
+                  ? executeSelectQuery(
+                      resolvedConfig,
+                      getRelationships(),
+                      password,
+                      Number(startTimeMs),
+                    )
+                  : executeFullSchemaQuery(resolvedConfig, password, Number(startTimeMs));
 
           const result = yield* runWithVpnPrerequisites(
-            config.port,
-            runQueryWithOptionalTunnel(config, queryEffect),
+            resolvedConfig.port,
+            runQueryWithOptionalTunnel(resolvedConfig, queryEffect),
           );
 
           if (result.success) {

package/src/shared/prerequisites/runtime.ts

@@ -126,83 +126,105 @@ export const runWithProfilePrerequisites = <A, E, CommandError>(
   }
 
   return Effect.gen(function* () {
-    if (options?.tryWithoutPrerequisites) {
-      const directResult = yield* effect.pipe(Effect.result);
+    const shouldTryDirect = options?.tryWithoutPrerequisites === true;
+
+    const tryDirect = () => effect.pipe(Effect.result);
+
+    if (shouldTryDirect) {
+      const directResult = yield* tryDirect();
       if (Result.isSuccess(directResult)) {
         return directResult.success;
       }
     }
 
-    const startedDrivers: Array<{ driver: ResolvedVpnDriver; cooldownMs: number }> = [];
+    const prerequisiteResult = yield* Effect.gen(function* () {
+      const startedDrivers: Array<{ driver: ResolvedVpnDriver; cooldownMs: number }> = [];
 
-    for (const prerequisite of vpnPrerequisites) {
-      const vpnConfig = config.vpns?.[prerequisite.key];
-      if (!vpnConfig) {
-        return yield* new PrerequisiteRunError({
-          message: `VPN prerequisite "${prerequisite.key}" is not defined.`,
-          hint: `Add vpns.${prerequisite.key} to agent-tools.json5 or remove the prerequisite.`,
-        });
-      }
+      for (const prerequisite of vpnPrerequisites) {
+        const vpnConfig = config.vpns?.[prerequisite.key];
+        if (!vpnConfig) {
+          return yield* new PrerequisiteRunError({
+            message: `VPN prerequisite "${prerequisite.key}" is not defined.`,
+            hint: `Add vpns.${prerequisite.key} to agent-tools.json5 or remove the prerequisite.`,
+          });
+        }
 
-      const driverResolution = resolveVpnDriverConfig(vpnConfig);
-      if (!driverResolution.success) {
-        return yield* new PrerequisiteRunError({
-          message: driverResolution.error,
-          hint: driverResolution.hint,
-        });
-      }
+        const driverResolution = resolveVpnDriverConfig(vpnConfig);
+        if (!driverResolution.success) {
+          return yield* new PrerequisiteRunError({
+            message: driverResolution.error,
+            hint: driverResolution.hint,
+          });
+        }
 
-      const driver = driverResolution.driver;
-      const wasConnected = yield* isVpnConnected(driver, runCommand);
-      if (wasConnected) {
-        continue;
-      }
+        const driver = driverResolution.driver;
+        const wasConnected = yield* isVpnConnected(driver, runCommand);
+        if (wasConnected) {
+          continue;
+        }
 
-      const startCommand = makeVpnCommand(driver, "start");
-      const startResult = yield* runCommand(startCommand.command, startCommand.label).pipe(
-        Effect.mapError(
-          () =>
-            new PrerequisiteRunError({
-              message: `Failed to start VPN prerequisite "${prerequisite.key}".`,
-              hint: missingVpnToolHint(driver),
-            }),
-        ),
-      );
-
-      if (startResult.exitCode !== 0) {
-        const stderr = startResult.stderr.trim();
-        return yield* new PrerequisiteRunError({
-          message:
-            stderr !== "" ? stderr : `Failed to start VPN prerequisite "${prerequisite.key}".`,
-          hint: missingVpnToolHint(driver),
-        });
-      }
+        const startCommand = makeVpnCommand(driver, "start");
+        const startResult = yield* runCommand(startCommand.command, startCommand.label).pipe(
+          Effect.mapError(
+            () =>
+              new PrerequisiteRunError({
+                message: `Failed to start VPN prerequisite "${prerequisite.key}".`,
+                hint: missingVpnToolHint(driver),
+              }),
+          ),
+        );
+
+        if (startResult.exitCode !== 0) {
+          const stderr = startResult.stderr.trim();
+          return yield* new PrerequisiteRunError({
+            message:
+              stderr !== "" ? stderr : `Failed to start VPN prerequisite "${prerequisite.key}".`,
+            hint: missingVpnToolHint(driver),
+          });
+        }
 
-      const ready = yield* waitForVpn(driver, vpnConfig.connectTimeoutMs ?? 30000, runCommand);
-      if (!ready) {
-        return yield* new PrerequisiteRunError({
-          message: `VPN prerequisite "${prerequisite.key}" did not connect within timeout.`,
-          hint: missingVpnToolHint(driver),
-        });
-      }
+        const ready = yield* waitForVpn(driver, vpnConfig.connectTimeoutMs ?? 30000, runCommand);
+        if (!ready) {
+          return yield* new PrerequisiteRunError({
+            message: `VPN prerequisite "${prerequisite.key}" did not connect within timeout.`,
+            hint: missingVpnToolHint(driver),
+          });
+        }
 
-      const cleanup = prerequisite.cleanup ?? vpnConfig.defaultCleanup ?? "stop-if-started";
-      if (cleanup === "stop-if-started") {
-        startedDrivers.push({ driver, cooldownMs: vpnConfig.cooldownMs ?? 0 });
+        const cleanup = prerequisite.cleanup ?? vpnConfig.defaultCleanup ?? "stop-if-started";
+        if (cleanup === "stop-if-started") {
+          startedDrivers.push({ driver, cooldownMs: vpnConfig.cooldownMs ?? 0 });
+        }
       }
-    }
 
-    const cleanup = Effect.gen(function* () {
-      for (const started of startedDrivers.toReversed()) {
-        if (started.cooldownMs > 0) {
-          yield* Effect.sleep(Duration.millis(started.cooldownMs));
+      const cleanup = Effect.gen(function* () {
+        for (const started of startedDrivers.toReversed()) {
+          if (started.cooldownMs > 0) {
+            yield* Effect.sleep(Duration.millis(started.cooldownMs));
+          }
+
+          const stopCommand = makeVpnCommand(started.driver, "stop");
+          yield* runCommand(stopCommand.command, stopCommand.label).pipe(Effect.ignore);
         }
+      });
+
+      return yield* effect.pipe(Effect.ensuring(cleanup));
+    }).pipe(Effect.result);
 
-        const stopCommand = makeVpnCommand(started.driver, "stop");
-        yield* runCommand(stopCommand.command, stopCommand.label).pipe(Effect.ignore);
+    if (Result.isSuccess(prerequisiteResult)) {
+      return prerequisiteResult.success;
+    }
+
+    if (shouldTryDirect && prerequisiteResult.failure instanceof PrerequisiteRunError) {
+      const directRetryResult = yield* tryDirect();
+      if (Result.isSuccess(directRetryResult)) {
+        return directRetryResult.success;
       }
-    });
+      if (!(directRetryResult.failure instanceof PrerequisiteRunError)) {
+        return yield* Effect.fail(directRetryResult.failure);
+      }
+    }
 
-    return yield* effect.pipe(Effect.ensuring(cleanup));
+    return yield* Effect.fail(prerequisiteResult.failure);
   });
 };