@vellumai/assistant 0.4.35 → 0.4.37

package/src/__tests__/skill-feature-flags.test.ts

@@ -2,10 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
-import {
-  isSkillFeatureEnabled,
-  resolveSkillStates,
-} from "../config/skill-state.js";
+import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
 import type { SkillSummary } from "../config/skills.js";
 
 const DECLARED_FLAG_KEY = "feature_flags.hatch-new-assistant.enabled";
@@ -55,27 +52,33 @@ function makeSkill(
 }
 
 // ---------------------------------------------------------------------------
-// isSkillFeatureEnabled (legacy wrapper — backward compat)
+// isAssistantFeatureFlagEnabled with skillFlagKey (canonical path)
 // ---------------------------------------------------------------------------
 
-describe("isSkillFeatureEnabled", () => {
+describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   test("returns false when no flag overrides (registry default is false)", () => {
     const config = makeConfig();
-    expect(isSkillFeatureEnabled(DECLARED_SKILL_ID, config)).toBe(false);
+    expect(
+      isAssistantFeatureFlagEnabled(skillFlagKey(DECLARED_SKILL_ID), config),
+    ).toBe(false);
   });
 
   test("returns true when skill key is explicitly true", () => {
     const config = makeConfig({
       assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: true },
     });
-    expect(isSkillFeatureEnabled(DECLARED_SKILL_ID, config)).toBe(true);
+    expect(
+      isAssistantFeatureFlagEnabled(skillFlagKey(DECLARED_SKILL_ID), config),
+    ).toBe(true);
   });
 
   test("returns false when skill key is explicitly false", () => {
     const config = makeConfig({
       assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
     });
-    expect(isSkillFeatureEnabled(DECLARED_SKILL_ID, config)).toBe(false);
+    expect(
+      isAssistantFeatureFlagEnabled(skillFlagKey(DECLARED_SKILL_ID), config),
+    ).toBe(false);
   });
 });
 

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -51,18 +51,39 @@ const platformOverrides: Record<string, (...args: unknown[]) => unknown> = {
   migrateToDataLayout: () => {},
   removeSocketFile: () => {},
 };
-mock.module("../util/platform.js", () => platformOverrides);
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPlatform = require("../util/platform.js");
+mock.module("../util/platform.js", () => ({
+  ...realPlatform,
+  ...platformOverrides,
+}));
+
+const noopLogger = new Proxy({} as Record<string, unknown>, {
+  get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+});
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
   isDebug: () => false,
+  truncateForLog: (value: string) => value,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
 }));
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => currentConfig,
+  loadConfig: () => currentConfig,
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  syncConfigToLockfile: () => {},
 }));
 
 await import("../tools/skills/load.js");

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -69,7 +69,6 @@ mock.module("../config/skills.js", () => ({
 // only needs skillFlagKey and doesn't exercise resolveSkillStates.
 mock.module("../config/skill-state.js", () => ({
   skillFlagKey: (id: string) => `feature_flags.${id}.enabled`,
-  isSkillFeatureEnabled: () => true,
   resolveSkillStates: () => [],
 }));
 

package/src/__tests__/skills.test.ts

@@ -12,33 +12,63 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const TEST_DIR = join(tmpdir(), `vellum-skills-test-${crypto.randomUUID()}`);
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPlatform = require("../util/platform.js");
 mock.module("../util/platform.js", () => ({
+  ...realPlatform,
   getRootDir: () => TEST_DIR,
   getDataDir: () => TEST_DIR,
+  getIpcBlobDir: () => join(TEST_DIR, "ipc-blobs"),
+  getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
+  getSandboxWorkingDir: () => TEST_DIR,
+  getInterfacesDir: () => join(TEST_DIR, "interfaces"),
   ensureDataDir: () => {},
   getSocketPath: () => join(TEST_DIR, "vellum.sock"),
   getPidPath: () => join(TEST_DIR, "vellum.pid"),
   getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
+  getHistoryPath: () => join(TEST_DIR, "history"),
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
   getPlatformName: () => process.platform,
+  getClipboardCommand: () => null,
   getWorkspaceConfigPath: () => join(TEST_DIR, "config.json"),
   getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
+  getWorkspaceHooksDir: () => join(TEST_DIR, "hooks"),
+  getHooksDir: () => join(TEST_DIR, "hooks"),
   getWorkspaceDir: () => TEST_DIR,
   getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
   migrateToDataLayout: () => {},
   migrateToWorkspaceLayout: () => {},
+  migratePath: () => {},
+  readSessionToken: () => null,
+  removeSocketFile: () => {},
+  normalizeAssistantId: (id: string) => id,
+  readLockfile: () => null,
+  writeLockfile: () => {},
 }));
 
+const noopLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+  trace: () => {},
+  fatal: () => {},
+  child: () => noopLogger,
+};
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
   isDebug: () => false,
   truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
 }));
 
 const { loadSkillCatalog, loadSkillBySelector, resolveSkillSelector } =

package/src/__tests__/slack-channel-config.test.ts

@@ -61,9 +61,9 @@ mock.module("../security/secure-keys.js", () => ({
   deleteSecureKey: (account: string) => {
     if (account in secureKeyStore) {
       delete secureKeyStore[account];
-      return true;
+      return "deleted";
     }
-    return false;
+    return "not-found";
   },
   listSecureKeys: () => Object.keys(secureKeyStore),
   getBackendType: () => "encrypted",

package/src/__tests__/system-prompt.test.ts

@@ -14,7 +14,10 @@ const TEST_DIR = join(tmpdir(), `vellum-sysprompt-test-${crypto.randomUUID()}`);
 
 import { mock } from "bun:test";
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPlatform = require("../util/platform.js");
 mock.module("../util/platform.js", () => ({
+  ...realPlatform,
   getRootDir: () => TEST_DIR,
   getDataDir: () => TEST_DIR,
   getWorkspaceDir: () => TEST_DIR,
@@ -38,19 +41,27 @@ mock.module("../util/platform.js", () => ({
   isWindows: () => process.platform === "win32",
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
+  readSessionToken: () => null,
   removeSocketFile: () => {},
   migratePath: () => {},
   migrateToWorkspaceLayout: () => {},
   migrateToDataLayout: () => {},
 }));
 
+const noopLogger = new Proxy({} as Record<string, unknown>, {
+  get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+});
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
   isDebug: () => false,
   truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -59,9 +70,20 @@ mock.module("../config/loader.js", () => ({
 
     sandbox: { enabled: true },
   }),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  syncConfigToLockfile: () => {},
 }));
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realUserReference = require("../config/user-reference.js");
 mock.module("../config/user-reference.js", () => ({
+  ...realUserReference,
   resolveUserReference: () => "John",
   resolveUserPronouns: () => null,
 }));

package/src/__tests__/telegram-bot-username-resolution.test.ts

@@ -0,0 +1,212 @@
+/**
+ * Tests for `ensureTelegramBotUsernameResolved()`.
+ *
+ * This function fills the bot-username gap when the token was configured
+ * without a `getMe` call (e.g. via `credential set` or ingress secret
+ * redirect). Each branch is exercised in isolation by controlling the
+ * mutable mock variables below.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mutable mock state — tests toggle these before each call
+// ---------------------------------------------------------------------------
+
+let mockMetadata: { accountInfo?: string } | undefined;
+let mockSecureKey: string | undefined;
+let mockUpsertCalls: Array<{
+  service: string;
+  key: string;
+  patch: Record<string, unknown>;
+}> = [];
+
+mock.module("../tools/credentials/metadata-store.js", () => ({
+  getCredentialMetadata: (_service: string, _key: string) => mockMetadata,
+  upsertCredentialMetadata: (
+    service: string,
+    key: string,
+    patch: Record<string, unknown>,
+  ) => {
+    mockUpsertCalls.push({ service, key, patch });
+  },
+}));
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKey: (_keyId: string) => mockSecureKey,
+}));
+
+// Suppress logger output during tests
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ---------------------------------------------------------------------------
+// Global fetch mock — swapped per test
+// ---------------------------------------------------------------------------
+
+let mockFetchResponse: {
+  ok: boolean;
+  status: number;
+  json: () => Promise<unknown>;
+};
+let mockFetchThrows: Error | undefined;
+let fetchCallCount = 0;
+
+beforeEach(() => {
+  mockMetadata = undefined;
+  mockSecureKey = undefined;
+  mockUpsertCalls = [];
+  mockFetchThrows = undefined;
+  mockFetchResponse = {
+    ok: true,
+    status: 200,
+    json: async () => ({ ok: true, result: { username: "ResolvedBot" } }),
+  };
+  fetchCallCount = 0;
+
+  globalThis.fetch = (async (..._args: unknown[]) => {
+    fetchCallCount++;
+    if (mockFetchThrows) throw mockFetchThrows;
+    return mockFetchResponse;
+  }) as typeof globalThis.fetch;
+});
+
+// ---------------------------------------------------------------------------
+// Import under test — AFTER mocks are registered
+// ---------------------------------------------------------------------------
+
+const { ensureTelegramBotUsernameResolved } =
+  await import("../runtime/channel-invite-transports/telegram.js");
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("ensureTelegramBotUsernameResolved", () => {
+  test("(a) early-returns when accountInfo is already cached", async () => {
+    mockMetadata = { accountInfo: "CachedBot" };
+    mockSecureKey = "some-token";
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(0);
+    expect(mockUpsertCalls).toHaveLength(0);
+  });
+
+  test("(b) fetches getMe and caches username on success", async () => {
+    mockMetadata = undefined;
+    mockSecureKey = "bot-token-123";
+    mockFetchResponse = {
+      ok: true,
+      status: 200,
+      json: async () => ({ ok: true, result: { username: "MyNewBot" } }),
+    };
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(1);
+    expect(mockUpsertCalls).toEqual([
+      {
+        service: "telegram",
+        key: "bot_token",
+        patch: { accountInfo: "MyNewBot" },
+      },
+    ]);
+  });
+
+  test("(c) handles non-200 response gracefully without caching", async () => {
+    mockMetadata = undefined;
+    mockSecureKey = "bot-token-123";
+    mockFetchResponse = {
+      ok: false,
+      status: 401,
+      json: async () => ({ ok: false, description: "Unauthorized" }),
+    };
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(1);
+    expect(mockUpsertCalls).toHaveLength(0);
+  });
+
+  test("(d) handles missing username in response gracefully", async () => {
+    mockMetadata = undefined;
+    mockSecureKey = "bot-token-123";
+    mockFetchResponse = {
+      ok: true,
+      status: 200,
+      json: async () => ({ ok: true, result: {} }),
+    };
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(1);
+    expect(mockUpsertCalls).toHaveLength(0);
+  });
+
+  test("(e) handles network errors (fetch throws) gracefully", async () => {
+    mockMetadata = undefined;
+    mockSecureKey = "bot-token-123";
+    mockFetchThrows = new Error("ECONNREFUSED");
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(1);
+    expect(mockUpsertCalls).toHaveLength(0);
+  });
+
+  test("(f) no-ops when no bot token is configured", async () => {
+    mockMetadata = undefined;
+    mockSecureKey = undefined;
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(0);
+    expect(mockUpsertCalls).toHaveLength(0);
+  });
+
+  test("treats whitespace-only accountInfo as uncached", async () => {
+    mockMetadata = { accountInfo: "   " };
+    mockSecureKey = "bot-token-123";
+    mockFetchResponse = {
+      ok: true,
+      status: 200,
+      json: async () => ({ ok: true, result: { username: "FreshBot" } }),
+    };
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(1);
+    expect(mockUpsertCalls).toEqual([
+      {
+        service: "telegram",
+        key: "bot_token",
+        patch: { accountInfo: "FreshBot" },
+      },
+    ]);
+  });
+
+  test("treats empty-string accountInfo as uncached", async () => {
+    mockMetadata = { accountInfo: "" };
+    mockSecureKey = "bot-token-456";
+    mockFetchResponse = {
+      ok: true,
+      status: 200,
+      json: async () => ({ ok: true, result: { username: "AnotherBot" } }),
+    };
+
+    await ensureTelegramBotUsernameResolved();
+
+    expect(fetchCallCount).toBe(1);
+    expect(mockUpsertCalls).toEqual([
+      {
+        service: "telegram",
+        key: "bot_token",
+        patch: { accountInfo: "AnotherBot" },
+      },
+    ]);
+  });
+});

package/src/__tests__/telegram-invite-adapter.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Tests for the Telegram channel invite adapter.
+ *
+ * Covers `buildShareLink`, `extractInboundToken`, and
+ * `resolveChannelHandle` on the real production adapter.
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ChannelId } from "../channels/types.js";
+import { telegramInviteAdapter } from "../runtime/channel-invite-transports/telegram.js";
+
+// Mock credential metadata so tests don't depend on local persisted state.
+mock.module("../tools/credentials/metadata-store.js", () => ({
+  getCredentialMetadata: () => undefined,
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const CHANNEL: ChannelId = "telegram" as ChannelId;
+
+function setEnv(key: string, value: string | undefined) {
+  if (value === undefined) {
+    delete process.env[key];
+  } else {
+    process.env[key] = value;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// buildShareLink
+// ---------------------------------------------------------------------------
+
+describe("telegramInviteAdapter.buildShareLink", () => {
+  let originalBotUsername: string | undefined;
+
+  beforeEach(() => {
+    originalBotUsername = process.env.TELEGRAM_BOT_USERNAME;
+  });
+
+  afterEach(() => {
+    setEnv("TELEGRAM_BOT_USERNAME", originalBotUsername);
+  });
+
+  test("builds a deep link with iv_ prefix", () => {
+    setEnv("TELEGRAM_BOT_USERNAME", "TestBot");
+
+    const link = telegramInviteAdapter.buildShareLink!({
+      rawToken: "abc123",
+      sourceChannel: CHANNEL,
+    });
+
+    expect(link.url).toBe("https://t.me/TestBot?start=iv_abc123");
+    expect(link.displayText).toContain("https://t.me/TestBot?start=iv_abc123");
+  });
+
+  test("throws when bot username is not configured", () => {
+    setEnv("TELEGRAM_BOT_USERNAME", undefined);
+
+    expect(() =>
+      telegramInviteAdapter.buildShareLink!({
+        rawToken: "abc123",
+        sourceChannel: CHANNEL,
+      }),
+    ).toThrow(/bot username/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// extractInboundToken
+// ---------------------------------------------------------------------------
+
+describe("telegramInviteAdapter.extractInboundToken", () => {
+  test("extracts token from structured commandIntent", () => {
+    const token = telegramInviteAdapter.extractInboundToken!({
+      commandIntent: { type: "start", payload: "iv_tok123" },
+      content: "/start iv_tok123",
+    });
+
+    expect(token).toBe("tok123");
+  });
+
+  test("returns undefined for non-invite commandIntent payload", () => {
+    const token = telegramInviteAdapter.extractInboundToken!({
+      commandIntent: { type: "start", payload: "gv_guardian_token" },
+      content: "/start gv_guardian_token",
+    });
+
+    expect(token).toBeUndefined();
+  });
+
+  test("returns undefined for commandIntent with empty payload after prefix", () => {
+    const token = telegramInviteAdapter.extractInboundToken!({
+      commandIntent: { type: "start", payload: "iv_" },
+      content: "/start iv_",
+    });
+
+    expect(token).toBeUndefined();
+  });
+
+  test("falls back to raw content parsing when no commandIntent", () => {
+    const token = telegramInviteAdapter.extractInboundToken!({
+      content: "/start iv_fallback_token",
+    });
+
+    expect(token).toBe("fallback_token");
+  });
+
+  test("returns undefined for non-invite raw content", () => {
+    const token = telegramInviteAdapter.extractInboundToken!({
+      content: "/start gv_something",
+    });
+
+    expect(token).toBeUndefined();
+  });
+
+  test("returns undefined for plain text content", () => {
+    const token = telegramInviteAdapter.extractInboundToken!({
+      content: "hello world",
+    });
+
+    expect(token).toBeUndefined();
+  });
+
+  test("returns undefined for commandIntent with non-start type", () => {
+    const token = telegramInviteAdapter.extractInboundToken!({
+      commandIntent: { type: "help", payload: "iv_tok" },
+      content: "/help iv_tok",
+    });
+
+    expect(token).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveChannelHandle
+// ---------------------------------------------------------------------------
+
+describe("telegramInviteAdapter.resolveChannelHandle", () => {
+  let originalBotUsername: string | undefined;
+
+  beforeEach(() => {
+    originalBotUsername = process.env.TELEGRAM_BOT_USERNAME;
+  });
+
+  afterEach(() => {
+    setEnv("TELEGRAM_BOT_USERNAME", originalBotUsername);
+  });
+
+  test("returns @-prefixed bot username from env", () => {
+    setEnv("TELEGRAM_BOT_USERNAME", "MyBot");
+
+    const handle = telegramInviteAdapter.resolveChannelHandle!();
+    expect(handle).toBe("@MyBot");
+  });
+
+  test("returns undefined when bot username is not configured", () => {
+    setEnv("TELEGRAM_BOT_USERNAME", undefined);
+
+    const handle = telegramInviteAdapter.resolveChannelHandle!();
+    expect(handle).toBeUndefined();
+  });
+});

package/src/__tests__/tool-execution-pipeline.benchmark.test.ts

@@ -63,7 +63,7 @@ mock.module("../config/loader.js", () => ({
 
     provider: "mock-provider",
     timeouts: { permissionTimeoutSec: 5, toolExecutionTimeoutSec: 120 },
-    permissions: { mode: "legacy" },
+    permissions: { mode: "workspace" },
     skills: { load: { extraDirs: [] } },
     secretDetection: { enabled: true, entropyThreshold: 4.0, action: "warn" },
     sandbox: { enabled: false },

package/src/__tests__/tool-permission-simulate-handler.test.ts

@@ -6,7 +6,10 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const testDir = mkdtempSync(join(tmpdir(), "permsim-handler-test-"));
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPlatform = require("../util/platform.js");
 mock.module("../util/platform.js", () => ({
+  ...realPlatform,
   getRootDir: () => testDir,
   getDataDir: () => join(testDir, "data"),
   getWorkspaceSkillsDir: () => join(testDir, "skills"),
@@ -21,7 +24,10 @@ mock.module("../util/platform.js", () => ({
   getIpcBlobDir: () => join(testDir, "ipc-blobs"),
 }));
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
+  ...realLogger,
   getLogger: () => ({
     info: () => {},
     warn: () => {},
@@ -39,7 +45,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const testConfig: Record<string, any> = {
-  permissions: { mode: "legacy" as "legacy" | "strict" | "workspace" },
+  permissions: { mode: "workspace" as "strict" | "workspace" },
   skills: { load: { extraDirs: [] as string[] } },
   sandbox: { enabled: true },
 };
@@ -111,7 +117,7 @@ describe("tool_permission_simulate handler", () => {
   beforeEach(() => {
     clearAllRules();
     clearCache();
-    testConfig.permissions.mode = "legacy";
+    testConfig.permissions.mode = "workspace";
   });
 
   test("validation: returns error when toolName is missing", async () => {