@blogic-cz/agent-tools 1.14.5 → 1.15.0

package/src/azdo-tool/main.ts

@@ -184,7 +184,7 @@ EXAMPLES:
 
 const commandsCommand = makeSchemaCommand(() => mainCommand);
 
-const mainCommand = Command.make("azdo-tool", {}).pipe(
+export const mainCommand = Command.make("azdo-tool", {}).pipe(
   Command.withDescription(
     `Azure DevOps Tool for Coding Agents (READ-ONLY)
 
@@ -219,6 +219,15 @@ const program = withRedactedOutput(withAudit("azdo", cli)).pipe(
   Effect.tapCause(renderCauseToStderr),
 );
 
-BunRuntime.runMain(program, {
-  disableErrorReporting: true,
-});
+export const runMain = () =>
+  BunRuntime.runMain(program, {
+    disableErrorReporting: true,
+  });
+
+export const runProgram = (args: readonly string[]) =>
+  withRedactedOutput(
+    withAudit(
+      "azdo",
+      Command.runWith(mainCommand, { version: VERSION, renderErrors: false })(args),
+    ),
+  ).pipe(Effect.provide(MainLayer), Effect.tapCause(renderCauseToStderr));

package/src/credential-guard/registry.ts

@@ -1164,6 +1164,78 @@ export const EXECUTABLES: readonly ExecutableEntry[] = [
     operands: [path],
     startup: ["JAVA_TOOL_OPTIONS", "JDK_JAVA_OPTIONS", "CLASSPATH", "_JAVA_OPTIONS", "JAVA_HOME"],
   },
+  {
+    name: "hc",
+    rejectsAbbreviations: true,
+    options: {
+      ...flags("--json", "--help", "-h", "--version", "-V", "--skill", "--licenses"),
+    },
+    operands: [data],
+    subcommands: {
+      ...Object.fromEntries(
+        [
+          "get",
+          "keys",
+          "interrupt",
+          "attach",
+          "kill",
+          "rm",
+          "label",
+          "keep",
+          "ls",
+          "read",
+          "wait",
+          "templates",
+          "events",
+          "schema",
+          "connect",
+          "server",
+        ].map((name) => [
+          name,
+          {
+            operands: [data],
+            options: {
+              ...flags("--all", "--off", "--wait", "--force"),
+              "--lines": arg(data),
+              "--output": arg(data),
+              "--children": arg(data),
+              "--timeout": arg(data),
+            },
+          },
+        ]),
+      ),
+      send: {
+        operands: [data, path],
+        options: {
+          ...flags("--force", "--json", "--wait"),
+          "--if": arg(data),
+          "--timeout": arg(data),
+        },
+      },
+      run: {
+        operands: [data],
+        options: {
+          ...flags("--bg", "--outlive-parent", "--no-parent", "--no-notify", "--rm", "--keep"),
+          "--name": arg(data),
+          "--cwd": arg(path),
+          "--on": arg(data),
+          "--label": arg(data),
+          "--parent": arg(data),
+          "--timeout": arg(data),
+        },
+      },
+      exec: {
+        operands: [data],
+        options: {
+          ...flags("-i", "--stdin"),
+          "--cwd": arg(path),
+          "--on": arg(data),
+          "--env": { roles: [data], issue: unknown("hc environment override") },
+          "--timeout": arg(data),
+        },
+      },
+    },
+  },
   {
     name: "herdr",
     options: {
@@ -4231,7 +4303,11 @@ function classifyInvocation(
     }
     const a = argv[position];
     if (a === undefined) {
-      if (["env", "forward", "timeout", "xargs"].includes(entry.semantics ?? ""))
+      if (
+        ["env", "forward", "timeout", "xargs"].includes(entry.semantics ?? "") ||
+        (entry.name === "hc" &&
+          (mode === entry.subcommands?.run || mode === entry.subcommands?.exec))
+      )
         issues.push({
           kind: "missing-knowledge",
           rule: "opaque-executable",
@@ -4457,8 +4533,8 @@ function classifyInvocation(
         (attached ?? argv[position + 1]) === undefined
       )
         issues.push(unknown("Bun option operand is not literal"));
-      if (entry.name === "bun" && optionName === "--cwd") {
-        if (cwdOperands.length) issues.push(unknown("repeated Bun working directory"));
+      if (["bun", "hc"].includes(entry.name) && optionName === "--cwd") {
+        if (cwdOperands.length) issues.push(unknown(`repeated ${entry.name} working directory`));
         cwdOperands.push({
           index: attached === undefined ? position + 1 : position,
           ...(attached !== undefined ? { literal: attached } : {}),
@@ -4581,6 +4657,18 @@ function classifyInvocation(
       position++;
       continue;
     }
+    if (
+      entry.name === "hc" &&
+      (mode === entry.subcommands?.run || mode === entry.subcommands?.exec)
+    ) {
+      if (mode === entry.subcommands?.run && position === argv.length - 1) {
+        roles.push({ index: position, role: code("bash") });
+        roles.push({ index: position, role: path });
+        issues.push(...unknownOperandIssues([a]));
+        codeSeen = true;
+      } else child(position);
+      break;
+    }
     if (entry.name === "git" && mode === entry.subcommands?.bisect?.subcommands?.run) {
       child(position);
       break;
@@ -4669,6 +4757,8 @@ function classifyInvocation(
   if (effect && effect !== "none") issues.push(effect);
   if (!positional.length && !children.length && !codeSeen && entry.bare) issues.push(entry.bare);
   roles.push(...optionRoles);
+  if (entry.name === "hc" && mode === entry.subcommands?.send)
+    issues.push(...unknownOperandIssues(positional.slice(1).map((index) => argv[index])));
   const operands =
     (filterOption && ["sed", "awk"].includes(entry.semantics ?? "")) ||
     (filterOption &&

package/src/db-tool/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
 import { checkEffectVersion } from "#shared/effect-version";
 
-if (await checkEffectVersion()) await import("./main");
+if (await checkEffectVersion()) (await import("./main")).runMain();
 else process.exitCode = 1;

package/src/db-tool/main.ts

@@ -225,7 +225,7 @@ const grantsCommand = makeDiagnosticCommand(
 
 const commandsCommand = makeSchemaCommand(() => mainCommand);
 
-const mainCommand = Command.make("db-tool", {}).pipe(
+export const mainCommand = Command.make("db-tool", {}).pipe(
   Command.withDescription("Database Query Tool for Coding Agents"),
   Command.withSubcommands([
     sqlCommand,
@@ -261,6 +261,12 @@ const program = withRedactedOutput(withAudit("db", cli)).pipe(
   Effect.tapCause(renderCauseToStderr),
 );
 
-BunRuntime.runMain(program, {
-  disableErrorReporting: true,
-});
+export const runMain = () =>
+  BunRuntime.runMain(program, {
+    disableErrorReporting: true,
+  });
+
+export const runProgram = (args: readonly string[]) =>
+  withRedactedOutput(
+    withAudit("db", Command.runWith(mainCommand, { version: VERSION, renderErrors: false })(args)),
+  ).pipe(Effect.provide(MainLayer), Effect.tapCause(renderCauseToStderr));

package/src/db-tool/service.ts

@@ -133,6 +133,10 @@ export function isFullyReadOnly(
 // Re-exported from the shared probe so existing `#db/service` consumers keep working.
 export { buildApiProbeArgs } from "#shared/k8s-probe";
 
+export const DbGuardianInProcess = Context.Reference<boolean>("@agent-tools/DbGuardianInProcess", {
+  defaultValue: () => false,
+});
+
 export class DbService extends Context.Service<
   DbService,
   {
@@ -156,6 +160,7 @@ export class DbService extends Context.Service<
         const sqlClient = yield* DbSqlClient;
         const secretEnvResolver = yield* SecretEnvResolver;
         const agentToolsConfig = yield* ConfigService;
+        const runGuardianInProcess = yield* DbGuardianInProcess;
         const dbConfig = yield* DbConfigService;
 
         if (!dbConfig) {
@@ -364,7 +369,7 @@ export class DbService extends Context.Service<
             prerequisiteConfig,
             (command, _label) => executeShellCommand(command),
             effect,
-            { tryWithoutPrerequisites: true },
+            { tryWithoutPrerequisites: true, runGuardianInProcess },
           ).pipe(
             Effect.mapError((error) =>
               isPrerequisiteRunError(error)

package/src/gh-tool/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
 import { checkEffectVersion } from "#shared/effect-version";
 
-if (await checkEffectVersion()) await import("./main");
+if (await checkEffectVersion()) (await import("./main")).runMain();
 else process.exitCode = 1;

package/src/gh-tool/main.ts

@@ -222,7 +222,7 @@ const gistCommand = Command.make("gist", {}).pipe(
 
 const commandsCommand = makeSchemaCommand(() => mainCommand);
 
-const mainCommand = Command.make("gh-tool", {}).pipe(
+export const mainCommand = Command.make("gh-tool", {}).pipe(
   Command.withDescription(
     `GitHub CLI Tool for Coding Agents
 
@@ -307,6 +307,7 @@ const observed = Effect.gen(function* () {
 });
 const program = observed.pipe(Effect.provide(MainLayer), Effect.tapCause(renderCauseToStderr));
 
-BunRuntime.runMain(program, {
-  disableErrorReporting: true,
-});
+export const runMain = () =>
+  BunRuntime.runMain(program, {
+    disableErrorReporting: true,
+  });

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

@@ -1,4 +1,4 @@
-import { reads, writes } from "#gh/read/index";
+import { reads, resolveRepo, writes } from "#gh/read/index";
 import { repoSlug } from "#gh/read/keys";
 import { Command, Flag, Param } from "effect/cli";
 import { Console, Effect, Option } from "effect";
@@ -511,6 +511,28 @@ const compactReviewTriage = (
   visibleOpenThreadIds: result.visibleOpenThreads.map((thread) => thread.threadId),
 });
 
+const fetchReviewTriageSummary = Effect.fn("pr.fetchReviewTriageSummary")(function* (pr: number) {
+  const repo = yield* resolveRepo(null);
+  return yield* reads
+    .prReviewTriageSummary(repo, pr)
+    .pipe(Effect.map((result) => ({ pr, ...result })));
+});
+
+const fetchReviewTriageSummaryBatch = Effect.fn("pr.fetchReviewTriageSummaryBatch")(function* (
+  prs: readonly number[],
+) {
+  return yield* Effect.forEach(
+    prs,
+    (pr) =>
+      fetchReviewTriageSummary(pr).pipe(
+        Effect.catch((error) =>
+          Effect.succeed({ pr, error: error instanceof Error ? error.message : String(error) }),
+        ),
+      ),
+    { concurrency: 5 },
+  );
+});
+
 export const fetchReviewTriageBatch = Effect.fn("pr.fetchReviewTriageBatch")(function* (
   prs: readonly number[],
 ) {
@@ -1835,12 +1857,23 @@ export const prReviewTriageBatchCommand = Command.make(
     format: formatOption,
     prs: Flag.String("prs").pipe(Flag.withDescription("Comma-separated PR numbers")),
     repo: repoOption,
+    summary: Flag.Boolean("summary").pipe(
+      Flag.withDescription(
+        "Fetch only PR state, review thread counts, and check names and buckets",
+      ),
+      Flag.withDefault(false),
+    ),
   },
-  ({ format, prs, repo }) =>
+  ({ format, prs, repo, summary }) =>
     withRepo(
       repo,
       Effect.gen(function* () {
         const numbers = yield* parsePrNumbers(prs);
+        if (summary) {
+          const results = yield* fetchReviewTriageSummaryBatch(numbers);
+          yield* logFormatted(results, format);
+          return;
+        }
         const results = yield* Effect.all(
           numbers.map((prNumber) => fetchReviewTriage(prNumber)),
           { concurrency: "unbounded" },

package/src/gh-tool/read/pulls.ts

@@ -278,6 +278,184 @@ export const prChecks = Effect.fn("reads.prChecks")(function* (
   });
 });
 
+const PR_REVIEW_TRIAGE_SUMMARY_QUERY = `
+  query($owner: String!, $name: String!, $pr: Int!, $after: String) {
+    repository(owner: $owner, name: $name) {
+      pullRequest(number: $pr) {
+        number
+        title
+        state
+        isDraft
+        baseRefName
+        reviewDecision
+        mergeable
+        reviewRequests(first: 100) {
+          nodes {
+            requestedReviewer {
+              ... on User { login }
+              ... on Team { slug }
+              ... on Bot { login }
+              ... on EnterpriseTeam { name }
+              ... on Mannequin { login }
+            }
+          }
+        }
+        reviewThreads(first: 100, after: $after) {
+          nodes {
+            isResolved
+            comments(first: 2) {
+              nodes { replyTo { id } }
+            }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  }
+`;
+
+const PR_REVIEW_THREAD_COUNTS_QUERY = `
+  query($owner: String!, $name: String!, $pr: Int!, $after: String) {
+    repository(owner: $owner, name: $name) {
+      pullRequest(number: $pr) {
+        reviewThreads(first: 100, after: $after) {
+          nodes {
+            isResolved
+            comments(first: 2) {
+              nodes { replyTo { id } }
+            }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  }
+`;
+
+type PrReviewTriageSummaryPage = {
+  readonly repository: {
+    readonly pullRequest: {
+      readonly number: number;
+      readonly title: string;
+      readonly state: string;
+      readonly isDraft: boolean;
+      readonly baseRefName: string;
+      readonly reviewDecision: string | null;
+      readonly mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+      readonly reviewRequests: {
+        readonly nodes: ReadonlyArray<{
+          readonly requestedReviewer: {
+            readonly login?: string;
+            readonly slug?: string;
+            readonly name?: string;
+          } | null;
+        }>;
+      };
+      readonly reviewThreads: {
+        readonly nodes: ReadonlyArray<{
+          readonly isResolved: boolean;
+          readonly comments: {
+            readonly nodes: ReadonlyArray<{ readonly replyTo: { readonly id: string } | null }>;
+          };
+        }>;
+        readonly pageInfo: { readonly hasNextPage: boolean; readonly endCursor: string | null };
+      };
+    };
+  };
+};
+
+export type PrReviewTriageSummary = {
+  readonly info: {
+    readonly number: number;
+    readonly title: string;
+    readonly state: string;
+    readonly isDraft: boolean;
+    readonly baseRefName: string;
+    readonly reviewDecision: string;
+    readonly mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+    readonly reviewRequests: ReadonlyArray<{ readonly login: string }>;
+  };
+  readonly summary: {
+    readonly unresolvedReviewThreadsCount: number;
+    readonly unrepliedReviewThreadsCount: number;
+  };
+  readonly checks: ReadonlyArray<{ readonly name: string; readonly bucket: string }>;
+};
+
+export const prReviewTriageSummary = Effect.fn("reads.prReviewTriageSummary")(function* (
+  repo: RepoRef,
+  pr: number,
+) {
+  const gh = yield* GitHubService;
+  const variables = { owner: repo.owner, name: repo.name, pr, after: null as string | null };
+  const first = (yield* gh.runGraphQL(
+    PR_REVIEW_TRIAGE_SUMMARY_QUERY,
+    variables,
+  )) as PrReviewTriageSummaryPage;
+  const firstPage = first.repository.pullRequest;
+  let unresolvedReviewThreadsCount = 0;
+  let unrepliedReviewThreadsCount = 0;
+  const countThreads = (
+    threads: PrReviewTriageSummaryPage["repository"]["pullRequest"]["reviewThreads"]["nodes"],
+  ) => {
+    for (const thread of threads) {
+      if (!thread.isResolved) unresolvedReviewThreadsCount++;
+      if (!thread.comments.nodes.some((comment) => comment.replyTo !== null))
+        unrepliedReviewThreadsCount++;
+    }
+  };
+  countThreads(firstPage.reviewThreads.nodes);
+
+  let pageInfo = firstPage.reviewThreads.pageInfo;
+  while (pageInfo.hasNextPage && pageInfo.endCursor !== null) {
+    const response = (yield* gh.runGraphQL(PR_REVIEW_THREAD_COUNTS_QUERY, {
+      ...variables,
+      after: pageInfo.endCursor,
+    })) as PrReviewTriageSummaryPage;
+    const pullRequest = response.repository.pullRequest;
+    countThreads(pullRequest.reviewThreads.nodes);
+    pageInfo = pullRequest.reviewThreads.pageInfo;
+  }
+
+  const checks = yield* gh
+    .runGhJson<ReadonlyArray<{ readonly name: string; readonly bucket: string }>>([
+      "pr",
+      "checks",
+      String(pr),
+      "--repo",
+      repoSlug(repo),
+      "--json",
+      "name,bucket",
+    ])
+    .pipe(
+      Effect.catchTag("GitHubCommandError", (error) =>
+        /no checks reported/i.test(`${error.message}\n${error.stderr}`)
+          ? Effect.succeed([])
+          : Effect.fail(error),
+      ),
+    );
+  const reviewRequests = firstPage.reviewRequests.nodes.flatMap(({ requestedReviewer }) => {
+    if (requestedReviewer === null) return [];
+    const login = requestedReviewer.login ?? requestedReviewer.slug ?? requestedReviewer.name;
+    return login === undefined ? [] : [{ login }];
+  });
+
+  return {
+    info: {
+      number: firstPage.number,
+      title: firstPage.title,
+      state: firstPage.state,
+      isDraft: firstPage.isDraft,
+      baseRefName: firstPage.baseRefName,
+      reviewDecision: firstPage.reviewDecision ?? "",
+      mergeable: firstPage.mergeable,
+      reviewRequests,
+    },
+    summary: { unresolvedReviewThreadsCount, unrepliedReviewThreadsCount },
+    checks,
+  };
+});
+
 const movedHead = (pr: number) =>
   new GitHubCommandError({
     command: `gh-tool pr checks --pr ${pr}`,

package/src/gh-tool/read/reads.ts

@@ -6,7 +6,15 @@ import { cachedRead, ReadCache } from "./cache";
 import { OPS } from "./classes";
 import { repoSlug } from "./keys";
 import { issueView, issueList, issueComments } from "./issues";
-import { prView, prList, prChecks, prHead, prBody, checkSignal } from "./pulls";
+import {
+  prView,
+  prList,
+  prChecks,
+  prHead,
+  prBody,
+  checkSignal,
+  prReviewTriageSummary,
+} from "./pulls";
 import { prComments, prReviews, reviewThreads, lastHumanReviewer } from "./reviews";
 import { reviewGuards } from "./review-guards";
 import type { RepoRef, RunFilter } from "./keys";
@@ -375,6 +383,7 @@ export const reads = {
   prView,
   prList,
   prChecks,
+  prReviewTriageSummary,
   prHead,
   prBody,
   checkSignal,

package/src/gh-tool/read/store.ts

@@ -87,11 +87,13 @@ export class FileStore {
   private constructor(
     readonly directory: string,
     readonly identity: string,
+    private readonly contentionTimeoutMs: number,
   ) {}
 
   static async open(
     identity: string,
     directory = process.env["GH_TOOL_CACHE_DIR"] ?? defaultCacheDirectory(),
+    options: { contentionTimeoutMs?: number } = {},
   ): Promise<FileStore> {
     const uid = process.getuid?.();
     if (uid === undefined) throw new Error("Cache ownership cannot be verified");
@@ -116,7 +118,11 @@ export class FileStore {
         await checkDirectory(path);
       }),
     );
-    const store = new FileStore(join(directory, "gh-read-v1"), identity);
+    const store = new FileStore(
+      join(directory, "gh-read-v1"),
+      identity,
+      options.contentionTimeoutMs ?? 2000,
+    );
     await mkdir(store.ghCacheDirectory, { recursive: true, mode: 0o700 });
     await checkDirectory(store.ghCacheDirectory);
     await store.readClock();
@@ -226,7 +232,7 @@ export class FileStore {
           }
         },
         25,
-        2000,
+        this.contentionTimeoutMs,
       );
       try {
         return await body();

package/src/k8s-tool/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
 import { checkEffectVersion } from "#shared/effect-version";
 
-if (await checkEffectVersion()) await import("./main");
+if (await checkEffectVersion()) (await import("./main")).runMain();
 else process.exitCode = 1;

package/src/k8s-tool/main.ts

@@ -457,7 +457,7 @@ const topCommand = Command.make(
 
 const commandsCommand = makeSchemaCommand(() => mainCommand);
 
-const mainCommand = Command.make("k8s-tool", {}).pipe(
+export const mainCommand = Command.make("k8s-tool", {}).pipe(
   Command.withDescription("Kubernetes CLI Tool for Coding Agents"),
   Command.withSubcommands([
     kubectlCommand,
@@ -486,6 +486,12 @@ const program = withRedactedOutput(withAudit("k8s", cli)).pipe(
   Effect.tapCause(renderCauseToStderr),
 );
 
-BunRuntime.runMain(program, {
-  disableErrorReporting: true,
-});
+export const runMain = () =>
+  BunRuntime.runMain(program, {
+    disableErrorReporting: true,
+  });
+
+export const runProgram = (args: readonly string[]) =>
+  withRedactedOutput(
+    withAudit("k8s", Command.runWith(mainCommand, { version: VERSION, renderErrors: false })(args)),
+  ).pipe(Effect.provide(MainLayer), Effect.tapCause(renderCauseToStderr));

package/src/logs-tool/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
 import { checkEffectVersion } from "#shared/effect-version";
 
-if (await checkEffectVersion()) await import("./main");
+if (await checkEffectVersion()) (await import("./main")).runMain();
 else process.exitCode = 1;

package/src/logs-tool/main.ts

@@ -221,7 +221,7 @@ const readCommand = Command.make(
 
 const commandsCommand = makeSchemaCommand(() => mainCommand);
 
-const mainCommand = Command.make("logs-tool", {}).pipe(
+export const mainCommand = Command.make("logs-tool", {}).pipe(
   Command.withDescription("Application Logs Tool for Coding Agents"),
   Command.withSubcommands([listCommand, readCommand, commandsCommand]),
 );
@@ -249,6 +249,15 @@ const program = withRedactedOutput(withAudit("logs", cli)).pipe(
   Effect.tapCause(renderCauseToStderr),
 );
 
-BunRuntime.runMain(program, {
-  disableErrorReporting: true,
-});
+export const runMain = () =>
+  BunRuntime.runMain(program, {
+    disableErrorReporting: true,
+  });
+
+export const runProgram = (args: readonly string[]) =>
+  withRedactedOutput(
+    withAudit(
+      "logs",
+      Command.runWith(mainCommand, { version: VERSION, renderErrors: false })(args),
+    ),
+  ).pipe(Effect.provide(MainLayer), Effect.tapCause(renderCauseToStderr));

package/src/observability-tool/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
 import { checkEffectVersion } from "#shared/effect-version";
 
-if (await checkEffectVersion()) await import("./main");
+if (await checkEffectVersion()) (await import("./main")).runMain();
 else process.exitCode = 1;

package/src/observability-tool/main.ts

@@ -16,7 +16,7 @@ import { traceCommand } from "./trace";
 
 const commandsCommand = makeSchemaCommand(() => mainCommand);
 
-const mainCommand = Command.make("observability-tool", {}).pipe(
+export const mainCommand = Command.make("observability-tool", {}).pipe(
   Command.withDescription(
     "LGTM observability queries — Tempo traces, Loki logs, Prometheus metrics",
   ),
@@ -37,4 +37,12 @@ const program = withRedactedOutput(withAudit("observability", cli)).pipe(
   Effect.tapCause(renderCauseToStderr),
 );
 
-BunRuntime.runMain(program, { disableErrorReporting: true });
+export const runMain = () => BunRuntime.runMain(program, { disableErrorReporting: true });
+
+export const runProgram = (args: readonly string[]) =>
+  withRedactedOutput(
+    withAudit(
+      "observability",
+      Command.runWith(mainCommand, { version: VERSION, renderErrors: false })(args),
+    ),
+  ).pipe(Effect.provide(MainLayer), Effect.tapCause(renderCauseToStderr));

package/src/session-tool/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
 import { checkEffectVersion } from "#shared/effect-version";
 
-if (await checkEffectVersion()) await import("./main");
+if (await checkEffectVersion()) (await import("./main")).runMain();
 else process.exitCode = 1;