@blogic-cz/agent-tools 0.14.61 → 0.15.1

package/src/k8s-tool/service.ts

@@ -1,3 +1,5 @@
+import { posix } from "node:path";
+
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 import { Context, Effect, Layer, Option, Ref, Stream } from "effect";
 
@@ -16,7 +18,7 @@ import { resolveEnvTemplate } from "#shared/env-template";
 import { isPrerequisiteRunError } from "#shared/prerequisites/errors";
 import { runWithProfilePrerequisites } from "#shared/prerequisites/runtime";
 import { buildApiProbeArgs } from "#shared/k8s-probe";
-import { isKubectlCommandAllowed } from "./security";
+import { isKubectlCommandAllowed, isSafeLogPath } from "./security";
 
 export class K8sService extends Context.Service<
   K8sService,
@@ -37,6 +39,16 @@ export class K8sService extends Context.Service<
       CommandResult,
       K8sContextError | K8sCommandError | K8sTimeoutError | K8sDangerousCommandError
     >;
+    readonly runLogTail: (
+      pod: string,
+      basePath: string,
+      path: string,
+      lines: number,
+      profile?: string,
+    ) => Effect.Effect<
+      CommandResult,
+      K8sContextError | K8sCommandError | K8sTimeoutError | K8sDangerousCommandError
+    >;
   }
 >()("@agent-tools/K8sService") {
   static readonly layer = Layer.effect(
@@ -86,6 +98,10 @@ export class K8sService extends Context.Service<
 
         const withKubeconfig = (command: string, kubeconfig: string | undefined) =>
           kubeconfig ? `KUBECONFIG=${quoteShellArg(kubeconfig)} ${command}` : command;
+        const renderArg = (arg: string) =>
+          /^[A-Za-z0-9_./:=,@+-]+$/.test(arg) ? arg : quoteShellArg(arg);
+        const renderKubectlCommand = (context: string, argv: readonly string[]) =>
+          ["kubectl", "--context", context, ...argv].map(renderArg).join(" ");
 
         // Cache context by selected profile/cluster instead of a single default profile.
         const contextRef = yield* Ref.make<Record<string, string>>({});
@@ -253,7 +269,7 @@ export class K8sService extends Context.Service<
         });
 
         const executeCommand = Effect.fn("K8sService.executeCommand")(function* (
-          cmd: string,
+          argv: readonly string[],
           profile?: string,
         ) {
           const k8sConfig = yield* requireK8sConfig(profile);
@@ -275,9 +291,29 @@ export class K8sService extends Context.Service<
                 });
               }
 
-              const fullCommand = withKubeconfig(`kubectl --context ${context} ${cmd}`, kubeconfig);
-
-              const resultOption = yield* runShellCommand(fullCommand, timeoutMs);
+              const fullCommand = renderKubectlCommand(context, argv);
+              const command = ChildProcess.make("kubectl", ["--context", context, ...argv], {
+                stdout: "pipe",
+                stderr: "pipe",
+                ...(kubeconfig ? { env: { KUBECONFIG: kubeconfig }, extendEnv: true } : {}),
+              });
+              const resultOption = yield* Effect.scoped(
+                Effect.gen(function* () {
+                  const process = yield* executor.spawn(command);
+                  return yield* collectProcessOutput(process);
+                }),
+              ).pipe(
+                Effect.timeoutOption(timeoutMs),
+                Effect.mapError(
+                  (platformError) =>
+                    new K8sCommandError({
+                      message: `Command execution failed: ${String(platformError)}`,
+                      command: fullCommand,
+                      exitCode: -1,
+                      stderr: undefined,
+                    }),
+                ),
+              );
 
               if (Option.isNone(resultOption)) {
                 return yield* new K8sTimeoutError({
@@ -316,16 +352,18 @@ export class K8sService extends Context.Service<
         ) {
           // Security: block dangerous commands before execution
           const securityCheck = isKubectlCommandAllowed(cmd);
-          if (!securityCheck.allowed) {
+          if (!securityCheck.allowed || !securityCheck.argv) {
             return yield* new K8sDangerousCommandError({
               message: securityCheck.reason ?? "Command not allowed",
               command: cmd,
-              verb: securityCheck.verb,
-              hint: "AI agents can only run read-only kubectl commands. For mutating operations, use kubectl directly or ask a human operator.",
+              ...(securityCheck.verb ? { verb: securityCheck.verb } : {}),
+              hint:
+                securityCheck.hint ??
+                "AI agents can only run read-only kubectl commands. For mutating operations, use kubectl directly or ask a human operator.",
             });
           }
 
-          const result = yield* executeCommand(cmd, profile);
+          const result = yield* executeCommand(securityCheck.argv, profile);
           if (result.exitCode !== 0) {
             return yield* new K8sCommandError({
               message: result.stderr ?? `kubectl exited with code ${result.exitCode}`,
@@ -345,20 +383,22 @@ export class K8sService extends Context.Service<
         ) {
           // Security: block dangerous commands before execution (even dry-run)
           const securityCheck = isKubectlCommandAllowed(cmd);
-          if (!securityCheck.allowed) {
+          if (!securityCheck.allowed || !securityCheck.argv) {
             return yield* new K8sDangerousCommandError({
               message: securityCheck.reason ?? "Command not allowed",
               command: cmd,
-              verb: securityCheck.verb,
-              hint: "AI agents can only run read-only kubectl commands. For mutating operations, use kubectl directly or ask a human operator.",
+              ...(securityCheck.verb ? { verb: securityCheck.verb } : {}),
+              hint:
+                securityCheck.hint ??
+                "AI agents can only run read-only kubectl commands. For mutating operations, use kubectl directly or ask a human operator.",
             });
           }
 
           const startTime = Date.now();
           if (dryRun) {
             const k8sConfig = yield* requireK8sConfig(profile);
-            const { context, kubeconfig } = yield* resolveContext(profile, k8sConfig);
-            const fullCommand = withKubeconfig(`kubectl --context ${context} ${cmd}`, kubeconfig);
+            const { context } = yield* resolveContext(profile, k8sConfig);
+            const fullCommand = renderKubectlCommand(context, securityCheck.argv);
             return {
               success: true,
               command: fullCommand,
@@ -367,8 +407,88 @@ export class K8sService extends Context.Service<
             };
           }
 
-          const result = yield* executeCommand(cmd, profile);
+          const result = yield* executeCommand(securityCheck.argv, profile);
+
+          if (result.exitCode !== 0) {
+            return yield* new K8sCommandError({
+              message: result.stderr ?? `kubectl exited with code ${result.exitCode}`,
+              command: result.command,
+              exitCode: result.exitCode,
+              stderr: result.stderr ?? undefined,
+            });
+          }
+
+          return {
+            success: true,
+            output: result.stdout.trim(),
+            command: result.command,
+            executionTimeMs: Date.now() - startTime,
+          };
+        });
+
+        const runLogTail = Effect.fn("K8sService.runLogTail")(function* (
+          pod: string,
+          basePath: string,
+          path: string,
+          lines: number,
+          profile?: string,
+        ) {
+          const normalizedBase = posix.resolve(basePath);
+          const normalizedPath = posix.resolve(path);
+          const lexicalRelative = posix.relative(normalizedBase, normalizedPath);
+          if (
+            !/^[a-z0-9](?:[-a-z0-9.]*[a-z0-9])?$/.test(pod) ||
+            !Number.isInteger(lines) ||
+            lines < 1 ||
+            lexicalRelative === ".." ||
+            lexicalRelative.startsWith("../") ||
+            posix.isAbsolute(lexicalRelative) ||
+            !isSafeLogPath(normalizedPath)
+          ) {
+            return yield* new K8sDangerousCommandError({
+              message: "Invalid internal log-tail request.",
+              command: "exec tail",
+              verb: "exec",
+              hint: "Use logs-tool with a log file inside its configured remote directory.",
+            });
+          }
+
+          const realpathArgv = ["exec", pod, "--", "realpath", normalizedBase, normalizedPath];
+          const realpathResult = yield* executeCommand(realpathArgv, profile);
+          if (realpathResult.exitCode !== 0) {
+            return yield* new K8sCommandError({
+              message:
+                realpathResult.stderr ||
+                `Remote realpath exited with code ${realpathResult.exitCode}`,
+              command: realpathResult.command,
+              exitCode: realpathResult.exitCode,
+              stderr: realpathResult.stderr || undefined,
+            });
+          }
+          const [canonicalBase, canonicalPath] = realpathResult.stdout.trim().split("\n");
+          const canonicalRelative =
+            canonicalBase === undefined || canonicalPath === undefined
+              ? ".."
+              : posix.relative(canonicalBase, canonicalPath);
+          if (
+            canonicalBase === undefined ||
+            canonicalPath === undefined ||
+            canonicalRelative === ".." ||
+            canonicalRelative.startsWith("../") ||
+            posix.isAbsolute(canonicalRelative) ||
+            !isSafeLogPath(canonicalPath)
+          ) {
+            return yield* new K8sDangerousCommandError({
+              message: "Canonical log path escapes the configured remote directory.",
+              command: realpathResult.command,
+              verb: "exec",
+              hint: "Remove symlinks that point outside the configured remote log directory.",
+            });
+          }
 
+          const argv = ["exec", pod, "--", "tail", "-n", String(lines), canonicalPath];
+          const startTime = Date.now();
+          const result = yield* executeCommand(argv, profile);
           if (result.exitCode !== 0) {
             return yield* new K8sCommandError({
               message: result.stderr ?? `kubectl exited with code ${result.exitCode}`,
@@ -386,7 +506,7 @@ export class K8sService extends Context.Service<
           };
         });
 
-        return { runCommand, runKubectl };
+        return { runCommand, runKubectl, runLogTail };
       }),
     ),
   );

package/src/logs-tool/index.ts

@@ -158,7 +158,7 @@ const readCommand = Command.make(
     ),
     format: formatOption,
     grep: Flag.string("grep").pipe(
-      Flag.withDescription("Filter lines containing pattern"),
+      Flag.withDescription("Filter lines containing case-insensitive literal text"),
       Flag.optional,
     ),
     pretty: Flag.boolean("pretty").pipe(

package/src/logs-tool/service.ts

@@ -1,13 +1,15 @@
+import { isAbsolute, posix, relative, resolve } from "node:path";
+
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { Context, Effect, Layer, Result, Stream } from "effect";
+import { Context, Effect, Layer, Result } from "effect";
 
 import type { Environment, LogFile, ReadOptions } from "./types";
 
-import { K8sCommandError } from "#k8s/errors";
 import { K8sService, K8sServiceLayer } from "#k8s/service";
 import { ConfigService, ConfigServiceLayer, getToolConfig } from "#config/loader";
 import type { LogsConfig } from "#config/types";
 import { LogsNotFoundError, LogsReadError, type LogsError } from "./errors";
+import { collectProcessOutput } from "#shared/exec";
 import { transformLogOutput } from "./transformers";
 
 export const parseLogFiles = (output: string): LogFile[] => {
@@ -46,6 +48,33 @@ export const formatPrettyOutput = (output: string): string => {
 export const sanitizeShellArg = (input: string): string => `'${input.replace(/'/g, "'\\''")}'`;
 
 const readCommandOutput = (output: unknown): string => (typeof output === "string" ? output : "");
+const filterLogLines = (output: string, grep: string | undefined): string => {
+  if (!grep) return output;
+  const needle = grep.toLowerCase();
+  return output
+    .split("\n")
+    .filter((line) => line.toLowerCase().includes(needle))
+    .join("\n");
+};
+const resolveLocalLogPath = (base: string, file: string): string | undefined => {
+  const resolvedBase = resolve(base);
+  const resolvedPath = resolve(resolvedBase, file);
+  const relativePath = relative(resolvedBase, resolvedPath);
+  return relativePath === ".." ||
+    relativePath.startsWith(`..${pathSeparator}`) ||
+    isAbsolute(relativePath)
+    ? undefined
+    : resolvedPath;
+};
+const pathSeparator = process.platform === "win32" ? "\\" : "/";
+const resolveRemoteLogPath = (base: string, file: string): string | undefined => {
+  const resolvedBase = posix.resolve(base);
+  const resolvedPath = posix.resolve(resolvedBase, file);
+  const relativePath = posix.relative(resolvedBase, resolvedPath);
+  return relativePath === ".." || relativePath.startsWith("../") || posix.isAbsolute(relativePath)
+    ? undefined
+    : resolvedPath;
+};
 
 export class LogsService extends Context.Service<
   LogsService,
@@ -73,15 +102,7 @@ export class LogsService extends Context.Service<
               stderr: "pipe",
             });
             const process = yield* executor.spawn(command);
-
-            const stdoutChunk = yield* process.stdout.pipe(Stream.decodeText(), Stream.runCollect);
-            const stderrChunk = yield* process.stderr.pipe(Stream.decodeText(), Stream.runCollect);
-
-            const stdout = stdoutChunk.join("");
-            const stderr = stderrChunk.join("");
-            const exitCode = yield* process.exitCode;
-
-            return { stdout, stderr, exitCode };
+            return yield* collectProcessOutput(process);
           }),
         ).pipe(
           Effect.catch((platformError) =>
@@ -93,6 +114,22 @@ export class LogsService extends Context.Service<
           ),
         );
 
+      const runDirectCommand = (executable: string, args: readonly string[]) =>
+        Effect.scoped(
+          Effect.gen(function* () {
+            const command = ChildProcess.make(executable, args, {
+              stdout: "pipe",
+              stderr: "pipe",
+            });
+            const process = yield* executor.spawn(command);
+            return yield* collectProcessOutput(process);
+          }),
+        ).pipe(
+          Effect.catch((platformError) =>
+            Effect.succeed({ stdout: "", stderr: String(platformError), exitCode: -1 }),
+          ),
+        );
+
       const getLogsConfig = (profile?: string): LogsConfig | undefined =>
         getToolConfig<LogsConfig>(config, "logs", profile);
 
@@ -196,27 +233,45 @@ export class LogsService extends Context.Service<
           logFile = latestPath.split("/").pop() ?? latestPath;
         }
 
-        const fullPath = `${localDir}/${logFile}`;
-        let command = `tail -${options.tail} ${sanitizeShellArg(fullPath)}`;
-
-        if (options.grep) {
-          command += ` | grep -i ${sanitizeShellArg(options.grep)}`;
+        const lexicalPath = resolveLocalLogPath(localDir, logFile);
+        if (lexicalPath === undefined) {
+          return yield* new LogsReadError({
+            message: "Log file must stay within the configured local log directory.",
+            source: localDir,
+          });
         }
-
+        const realpathResult = yield* runDirectCommand("realpath", [localDir, lexicalPath]);
+        if (realpathResult.exitCode !== 0) {
+          return yield* new LogsReadError({
+            message:
+              realpathResult.stderr.trim() ||
+              `realpath failed with exit code ${realpathResult.exitCode}`,
+            source: lexicalPath,
+          });
+        }
+        const [canonicalBase, canonicalPath] = realpathResult.stdout.trim().split("\n");
+        if (
+          canonicalBase === undefined ||
+          canonicalPath === undefined ||
+          resolveLocalLogPath(canonicalBase, canonicalPath) !== canonicalPath ||
+          !canonicalPath.endsWith(".log")
+        ) {
+          return yield* new LogsReadError({
+            message: "Canonical log path escapes the configured local log directory.",
+            source: localDir,
+          });
+        }
+        const command = `tail -${options.tail} ${sanitizeShellArg(canonicalPath)}`;
         const result = yield* runShellCommand(command);
 
-        if (result.exitCode !== 0 && result.exitCode !== 1) {
+        if (result.exitCode !== 0) {
           return yield* new LogsReadError({
             message: result.stderr.trim() || `Command failed with exit code ${result.exitCode}`,
-            source: fullPath,
+            source: canonicalPath,
           });
         }
 
-        if (result.exitCode === 1 && options.grep) {
-          return "(no matching lines)";
-        }
-
-        const output = result.stdout.trim();
+        const output = filterLogLines(result.stdout, options.grep).trim();
         if (!output) {
           return "(no matching lines)";
         }
@@ -231,6 +286,14 @@ export class LogsService extends Context.Service<
       ) {
         const remotePath = logsConfig.remotePath;
         const kubernetesProfile = logsConfig.kubernetesProfile;
+        const logFile = options.file ?? "app.log";
+        const logPath = resolveRemoteLogPath(remotePath, logFile);
+        if (logPath === undefined) {
+          return yield* new LogsReadError({
+            message: "Log file must stay within the configured remote log directory.",
+            source: remotePath,
+          });
+        }
 
         const podResult = yield* k8s
           .runKubectl(
@@ -249,38 +312,22 @@ export class LogsService extends Context.Service<
           );
 
         const pod = readCommandOutput(podResult.output).replace(/'/g, "");
-        const logFile = options.file ?? "app.log";
-        const logPath = `${remotePath}/${logFile}`;
-        let command = `tail -${options.tail} ${sanitizeShellArg(logPath)}`;
-
-        if (options.grep) {
-          command += ` | grep -i ${sanitizeShellArg(options.grep)}`;
-        }
-
         const execResult = yield* k8s
-          .runKubectl(`exec ${pod} -- sh -c "${command}"`, false, kubernetesProfile)
+          .runLogTail(pod, remotePath, logPath, options.tail, kubernetesProfile)
           .pipe(Effect.result);
 
         return yield* Result.match(execResult, {
-          onFailure: (error) => {
-            if (error instanceof K8sCommandError && error.exitCode === 1 && options.grep) {
-              return Effect.succeed("(no matching lines)");
-            }
-
-            return Effect.fail(
+          onFailure: (error) =>
+            Effect.fail(
               new LogsReadError({
                 message: error instanceof Error ? error.message : "Failed to read remote logs",
                 source: `${pod}:${logPath}`,
               }),
-            );
-          },
+            ),
           onSuccess: (result) => {
-            const trimmed = readCommandOutput(result.output).trim();
-            if (!trimmed) {
-              return Effect.succeed("(no matching lines)");
-            }
-
-            return Effect.succeed(transformLogOutput(trimmed));
+            const output = readCommandOutput(result.output);
+            const trimmed = filterLogLines(output, options.grep).trim();
+            return Effect.succeed(trimmed ? transformLogOutput(trimmed) : "(no matching lines)");
           },
         });
       });

package/src/shared/prerequisites/driver-commands.ts

@@ -0,0 +1,88 @@
+import { ChildProcess } from "effect/unstable/process";
+
+import type { ResolvedVpnDriver } from "#shared/prerequisites/types";
+import type { SanitizedVpnDriver } from "#shared/prerequisites/store";
+
+export type VpnDriverAction = "status" | "start" | "stop";
+export type VpnCommandSpec = { readonly executable: string; readonly args: readonly string[] };
+
+export const sanitizeVpnDriver = (driver: ResolvedVpnDriver): SanitizedVpnDriver => {
+  if (driver.type === "macos-scutil") {
+    return { type: driver.type, platform: driver.platform, serviceName: driver.serviceName };
+  }
+  if (driver.type === "linux-nmcli") {
+    return { type: driver.type, platform: driver.platform, connectionName: driver.connectionName };
+  }
+  return { type: driver.type, platform: driver.platform, entryName: driver.entryName };
+};
+
+export const vpnCommandSpec = (
+  driver: SanitizedVpnDriver,
+  action: VpnDriverAction,
+): VpnCommandSpec => {
+  if (driver.type === "macos-scutil") {
+    return {
+      executable: "scutil",
+      args:
+        action === "status"
+          ? ["--nc", "status", driver.serviceName]
+          : ["--nc", action, driver.serviceName],
+    };
+  }
+  if (driver.type === "linux-nmcli") {
+    return {
+      executable: "nmcli",
+      args:
+        action === "status"
+          ? ["-t", "-e", "no", "-f", "NAME", "connection", "show", "--active"]
+          : ["connection", action === "start" ? "up" : "down", driver.connectionName],
+    };
+  }
+  return {
+    executable: "rasdial",
+    args:
+      action === "status"
+        ? []
+        : action === "start"
+          ? [driver.entryName]
+          : [driver.entryName, "/disconnect"],
+  };
+};
+
+export const makeParentVpnCommand = (
+  driver: ResolvedVpnDriver,
+  action: VpnDriverAction,
+  secret?: string,
+) => {
+  const spec = vpnCommandSpec(sanitizeVpnDriver(driver), action);
+  const secretArgs = action === "start" && secret ? ["--secret", secret] : [];
+  const args = [...spec.args, ...secretArgs];
+  const labelArgs = [...spec.args, ...(secretArgs.length > 0 ? ["--secret", "<redacted>"] : [])];
+  return {
+    command: ChildProcess.make(spec.executable, args, { stdout: "pipe", stderr: "pipe" }),
+    label: [spec.executable, ...labelArgs].join(" "),
+  };
+};
+
+export const parseVpnStatus = (
+  driver: SanitizedVpnDriver,
+  result: { readonly stdout: string; readonly exitCode: number },
+): boolean | undefined => {
+  if (result.exitCode !== 0) return undefined;
+  const lines = result.stdout.split(/\r?\n/);
+  if (driver.type === "macos-scutil") {
+    if (lines.includes("Connected")) return true;
+    if (lines.includes("Disconnected")) return false;
+    return undefined;
+  }
+  if (driver.type === "linux-nmcli") {
+    return lines.some((line) => line === driver.connectionName);
+  }
+  const records = lines.map((line) => line.trim()).filter((line) => line.length > 0);
+  const successFooter = "Command completed successfully.";
+  if (records.at(-1) !== successFooter) return undefined;
+  const body = records.slice(0, -1);
+  if (body.length === 1 && body[0] === "No connections") return false;
+  if (body[0] !== "Connected to" || body.length === 1) return undefined;
+  return body.slice(1).includes(driver.entryName);
+};

package/src/shared/prerequisites/guardian-entry.ts

@@ -0,0 +1,49 @@
+import type {
+  GuardianInboundMessage,
+  GuardianOutboundMessage,
+} from "#shared/prerequisites/guardian";
+import { runGuardian } from "#shared/prerequisites/guardian";
+
+let release: (() => Promise<void>) | undefined;
+let initialized = false;
+let initializedLeaseId: string | undefined;
+let requestedLeaseId: string | undefined;
+let disconnected = false;
+let releaseStarted = false;
+
+const send = (message: GuardianOutboundMessage) => process.send?.(message);
+const fail = (error: unknown) => {
+  send({ type: "ERROR", message: error instanceof Error ? error.message : String(error) });
+  process.exitCode = 1;
+};
+const releaseIfRequested = () => {
+  if (releaseStarted || !release || (!disconnected && requestedLeaseId !== initializedLeaseId)) {
+    return;
+  }
+  releaseStarted = true;
+  void release().catch(fail);
+};
+
+process.on("message", (message: GuardianInboundMessage) => {
+  if (message.type === "INIT" && !initialized) {
+    initialized = true;
+    initializedLeaseId = message.leaseId;
+    void runGuardian(message, send)
+      .then((guardian) => {
+        release = guardian.release;
+        send({ type: "READY", leaseId: message.leaseId, guardianId: message.guardianId });
+        return releaseIfRequested();
+      })
+      .catch(fail);
+    return;
+  }
+  if (message.type === "RELEASE") {
+    requestedLeaseId = message.leaseId;
+    releaseIfRequested();
+  }
+});
+
+process.on("disconnect", () => {
+  disconnected = true;
+  releaseIfRequested();
+});