@vellumai/assistant 0.8.1 → 0.8.2

package/src/daemon/external-plugins-bootstrap.ts

@@ -29,15 +29,22 @@
  *    through untouched).
  * 6. Creates `<workspaceDir>/plugins-data/<plugin>/` on demand for per-plugin
  *    writable state and exposes it via {@link PluginInitContext.pluginStorageDir}.
- * 7. Awaits `plugin.init(ctx)` sequentially. One init failure surfaces as a
+ * 7. For each surviving plugin, registers its contributed tools, routes,
+ *    and skills into their global registries via
+ *    {@link registerPluginTools}, {@link registerSkillRoute}, and
+ *    {@link registerPluginSkills}. Contributions land BEFORE `init()` so
+ *    the plugin's hook can observe a registry where its own model-visible
+ *    surface is already wired — useful for plugins that want to attach
+ *    metadata, warm caches, or otherwise interact with their own
+ *    contributions during initialization.
+ * 8. Awaits `plugin.init(ctx)` sequentially. An init failure surfaces as a
  *    {@link PluginExecutionError} naming the offending plugin and aborts
  *    bootstrap — later plugins' `init()` never runs and the daemon fails
- *    startup cleanly rather than coming up in a half-wired state.
- * 8. After a plugin's `init()` succeeds, registers any tools declared on
- *    `plugin.tools` with the global tool registry via
- *    {@link registerPluginTools}. Tool contributions land after `init()` so
- *    a plugin that fails mid-init never leaves partial tool registrations
- *    behind.
+ *    startup cleanly rather than coming up in a half-wired state. The
+ *    failing plugin's already-registered tools, routes, and skills are
+ *    rolled back before the error propagates so the registry never
+ *    carries state contributed by a plugin that never finished
+ *    initializing.
  *
  * A single shutdown hook is registered via
  * {@link registerShutdownHook} that walks the plugin list in **reverse
@@ -54,21 +61,24 @@ import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/schema.js";
+import { HOOKS } from "../plugin-api/constants.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
+import { buildExternalPlugin } from "../plugins/external-plugin-loader.js";
 import {
   registerPluginSkills,
   unregisterPluginSkills,
 } from "../plugins/plugin-skill-contributions.js";
 import {
-  ASSISTANT_API_VERSIONS,
+  getRegisteredPlugin,
   getRegisteredPlugins,
+  setRegisteredPlugin,
   unregisterPlugin,
 } from "../plugins/registry.js";
 import {
   type Plugin,
   PluginExecutionError,
-  type PluginInitContext,
   type PluginShutdownContext,
   type PluginSkillRegistration,
 } from "../plugins/types.js";
@@ -84,6 +94,7 @@ import {
 } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import { APP_VERSION } from "../version.js";
 import { registerShutdownHook } from "./shutdown-registry.js";
 
 const log = getLogger("plugins-bootstrap");
@@ -170,6 +181,16 @@ function ensurePluginStorageDir(pluginName: string): string {
   return dir;
 }
 
+function getDisabledPluginFlag(
+  plugin: Plugin,
+  config: AssistantConfig,
+): string | undefined {
+  for (const flagKey of plugin.manifest.requiresFlag ?? []) {
+    if (!isAssistantFeatureFlagEnabled(flagKey, config)) return flagKey;
+  }
+  return undefined;
+}
+
 /**
  * Run every registered plugin's `init()` hook sequentially and install a
  * reverse-order shutdown hook. See the module docstring for full semantics.
@@ -245,187 +266,20 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
   for (const plugin of plugins) {
     const name = plugin.manifest.name;
-
-    // Feature-flag gating — if any key in `manifest.requiresFlag` is
-    // disabled, skip this plugin entirely. Skipping means: no `init()`, no
-    // tool / route / skill contributions, and no shutdown hook entry. A
-    // later boot with the flag flipped ON picks up the plugin cleanly.
-    const requiredFlags = plugin.manifest.requiresFlag ?? [];
-    let disabledFlag: string | undefined;
-    for (const flagKey of requiredFlags) {
-      if (!isAssistantFeatureFlagEnabled(flagKey, ctx.config)) {
-        disabledFlag = flagKey;
-        break;
-      }
-    }
+    const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
     if (disabledFlag !== undefined) {
       log.info(
         { plugin: name, flag: disabledFlag },
         `skipping plugin ${name}: feature flag ${disabledFlag} is disabled`,
       );
-      // Drop the plugin from the registry too. `registerPlugin()` added it at
-      // import time, and `getMiddlewaresFor()` / `getInjectors()` iterate over
-      // every registered entry — without this call, the gated plugin's
-      // middleware and injectors would still participate in every pipeline
-      // run and system-prompt assembly despite `init()` never firing.
       unregisterPlugin(name);
       continue;
     }
 
-    // Collected as routes are accepted so the catch block can revoke exactly
-    // the routes this plugin contributed if a later contribution step throws.
-    // Hoisted above the try so it's in scope for the error path.
-    const routeHandles: SkillRouteHandle[] = [];
-
-    // Tracks whether `plugin.init()` ran to completion (or the plugin has no
-    // init at all). The catch block consults this to decide whether the
-    // currently-failing plugin's `onShutdown()` may run: onShutdown is paired
-    // with init, so a plugin that never completed init never set up the state
-    // onShutdown is meant to tear down. Calling onShutdown in that case would
-    // surprise plugin authors (their teardown runs against an uninitialized
-    // self) and breaks the documented lifecycle contract.
-    let initCompleted = false;
-
     try {
-      // Credential resolution — gather every entry in `requiresCredential`
-      // before calling `init()` so the plugin receives a fully-populated map.
-      const credentials: Record<string, string> = {};
-      const required = plugin.manifest.requiresCredential ?? [];
-      for (const key of required) {
-        credentials[key] = await resolveCredentialOrThrow(name, key);
-      }
-
-      // Per-plugin config block, validated against the manifest's parser-like
-      // validator when one is declared.
-      const rawConfig = getPluginConfigRaw(ctx.config, name);
-      const config = validatePluginConfig(
-        name,
-        plugin.manifest.config,
-        rawConfig,
-      );
-
-      // Per-plugin writable data directory. Created lazily during bootstrap
-      // rather than at registration time so the side effect is isolated to
-      // the boot path.
-      const pluginStorageDir = ensurePluginStorageDir(name);
-
-      const initContext: PluginInitContext = {
-        config,
-        credentials,
-        logger: log.child({ plugin: name }),
-        pluginStorageDir,
-        assistantVersion: ctx.assistantVersion,
-        apiVersions: ASSISTANT_API_VERSIONS,
-      };
-
-      if (plugin.hooks?.init) {
-        try {
-          await plugin.hooks.init(initContext);
-        } catch (err) {
-          throw new PluginExecutionError(
-            `plugin ${name} init() failed: ${
-              err instanceof Error ? err.message : String(err)
-            }`,
-            name,
-            { cause: err },
-          );
-        }
-      }
-      // Reached when init() succeeded or the plugin has no init hook. The
-      // catch block reads this to decide whether onShutdown may run.
-      initCompleted = true;
-
-      // After init succeeds, wire in the plugin's model-visible capabilities.
-      // Tool contributions (PR 31) register only after `init()` succeeds so a
-      // plugin that fails mid-init never leaves partially-wired tools behind.
-      // Tool registration failures are wrapped in a PluginExecutionError so
-      // the offending plugin name surfaces in the abort — matching the
-      // strict-fail semantics of `init()` errors.
-      if (plugin.tools && plugin.tools.length > 0) {
-        try {
-          const accepted = registerPluginTools(name, plugin.tools);
-          log.info(
-            { plugin: name, count: accepted.length },
-            "plugin tools registered",
-          );
-        } catch (err) {
-          throw new PluginExecutionError(
-            `plugin ${name} tool registration failed: ${
-              err instanceof Error ? err.message : String(err)
-            }`,
-            name,
-            { cause: err },
-          );
-        }
-      }
-
-      // Route contributions (PR 32) — registered after init() succeeds so a
-      // plugin that fails to initialize never exposes a half-wired HTTP
-      // surface. Mirrors the skill-route registry shape; see
-      // {@link PluginRouteRegistration}. Retain every returned handle so the
-      // teardown path unregisters by identity rather than pattern text — two
-      // plugins (or a plugin and a skill) that happen to register the same
-      // regex must not evict each other's routes during shutdown.
-      if (plugin.routes && plugin.routes.length > 0) {
-        for (const route of plugin.routes) {
-          routeHandles.push(registerSkillRoute(route));
-        }
-        log.info(
-          { plugin: name, count: plugin.routes.length },
-          "plugin routes registered",
-        );
-      }
-
-      // Skills register into the in-memory plugin-skill catalog so
-      // `skill_load` / `skill_execute` can resolve them alongside filesystem
-      // skills. A registration failure aborts bootstrap with the plugin named
-      // — same strict-fail posture as init() throws.
-      if (plugin.skills && plugin.skills.length > 0) {
-        try {
-          // `plugin.skills` is typed as `PluginSkillRegistration[]` at the
-          // Plugin interface — the type assertion here is a narrowing from
-          // that generic slot into the concrete shape the registry expects.
-          registerPluginSkills(
-            name,
-            plugin.skills as readonly PluginSkillRegistration[],
-          );
-        } catch (err) {
-          throw new PluginExecutionError(
-            `plugin ${name} skill registration failed: ${
-              err instanceof Error ? err.message : String(err)
-            }`,
-            name,
-            { cause: err },
-          );
-        }
-      }
-
-      activePlugins.push({ plugin, routeHandles });
-
-      log.info({ plugin: name }, "plugin initialized");
+      activePlugins.push(await initializePlugin(plugin, ctx));
     } catch (err) {
-      // Roll back the currently-failing plugin first — it is not in
-      // `activePlugins` yet (that push happens only after every contribution
-      // step succeeds), so `teardownPartialInit()` alone would leave its
-      // already-registered tools, routes, and skills live.
-      //
-      // Branching on `initCompleted` keeps the init/onShutdown pairing
-      // intact. When init succeeded but a later contribution step (tools,
-      // routes, skills) threw, the plugin has live init-side state that
-      // `onShutdown()` is responsible for cleaning up, so the full
-      // rollbackPlugin() path runs. When init itself failed (or a step
-      // before init — credential resolution, config validation — threw),
-      // onShutdown must not run: calling it would invoke the plugin's
-      // teardown against an uninitialized self, violating the lifecycle
-      // contract documented on `Plugin.onShutdown`. In the init-failed case
-      // there is also nothing to unregister — tools, routes, and skills are
-      // all registered after init — so just drop the plugin from the
-      // registry (idempotent if already removed).
-      if (initCompleted) {
-        await rollbackPlugin({ plugin, routeHandles });
-      } else {
-        unregisterPlugin(name);
-      }
+      unregisterPlugin(name);
       await teardownPartialInit();
       throw err;
     }
@@ -470,6 +324,114 @@ interface ActivePlugin {
   readonly routeHandles: readonly SkillRouteHandle[];
 }
 
+async function initializePlugin(
+  plugin: Plugin,
+  ctx: DaemonContext,
+): Promise<ActivePlugin> {
+  const name = plugin.manifest.name;
+  const routeHandles: SkillRouteHandle[] = [];
+  let initCompleted = false;
+
+  try {
+    const credentials: Record<string, string> = {};
+    for (const key of plugin.manifest.requiresCredential ?? []) {
+      credentials[key] = await resolveCredentialOrThrow(name, key);
+    }
+
+    const config = validatePluginConfig(
+      name,
+      plugin.manifest.config,
+      getPluginConfigRaw(ctx.config, name),
+    );
+
+    const initContext = {
+      config,
+      credentials,
+      logger: log.child({ plugin: name }),
+      pluginStorageDir: ensurePluginStorageDir(name),
+      assistantVersion: ctx.assistantVersion,
+    };
+
+    if (plugin.tools && plugin.tools.length > 0) {
+      try {
+        const accepted = registerPluginTools(name, plugin.tools);
+        log.info(
+          { plugin: name, count: accepted.length },
+          "plugin tools registered",
+        );
+      } catch (err) {
+        throw new PluginExecutionError(
+          `plugin ${name} tool registration failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+          name,
+          { cause: err },
+        );
+      }
+    }
+
+    if (plugin.routes && plugin.routes.length > 0) {
+      for (const route of plugin.routes) {
+        routeHandles.push(registerSkillRoute(route));
+      }
+      log.info(
+        { plugin: name, count: plugin.routes.length },
+        "plugin routes registered",
+      );
+    }
+
+    if (plugin.skills && plugin.skills.length > 0) {
+      try {
+        registerPluginSkills(
+          name,
+          plugin.skills as readonly PluginSkillRegistration[],
+        );
+      } catch (err) {
+        throw new PluginExecutionError(
+          `plugin ${name} skill registration failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+          name,
+          { cause: err },
+        );
+      }
+    }
+
+    if (plugin.hooks?.[HOOKS.INIT]) {
+      try {
+        await plugin.hooks[HOOKS.INIT](initContext);
+      } catch (err) {
+        throw new PluginExecutionError(
+          `plugin ${name} init() failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+          name,
+          { cause: err },
+        );
+      }
+    }
+    initCompleted = true;
+
+    log.info({ plugin: name }, "plugin initialized");
+    return { plugin, routeHandles };
+  } catch (err) {
+    if (initCompleted) {
+      await teardownPlugin({ plugin, routeHandles }, "bootstrap-failed", {
+        assistantVersion: ctx.assistantVersion,
+      });
+    } else {
+      for (const handle of routeHandles) {
+        unregisterSkillRoute(handle);
+      }
+      unregisterPluginTools(name);
+      if (plugin.skills && plugin.skills.length > 0) {
+        unregisterPluginSkills(name);
+      }
+    }
+    throw err;
+  }
+}
+
 /**
  * Tear down a single fully-initialized plugin: unregister routes, unregister
  * tools, invoke `onShutdown()` if present, then unregister skills. Every step
@@ -514,9 +476,9 @@ async function teardownPlugin(
     );
   }
 
-  if (plugin.hooks?.shutdown) {
+  if (plugin.hooks?.[HOOKS.SHUTDOWN]) {
     try {
-      await plugin.hooks.shutdown(shutdownContext);
+      await plugin.hooks[HOOKS.SHUTDOWN](shutdownContext);
     } catch (err) {
       // Swallow — we want every plugin's shutdown to get a chance to run
       // even when an earlier one throws. The outer runShutdownHooks already
@@ -540,3 +502,77 @@ async function teardownPlugin(
     }
   }
 }
+
+/** Rebuild a changed external plugin and swap it into the live registry. */
+export async function reregisterExternalPlugin(
+  pluginName: string,
+): Promise<void> {
+  const pluginDir = join(getWorkspaceDir(), "plugins", pluginName);
+  const plugin = await buildExternalPlugin(pluginDir);
+  if (plugin === undefined) return;
+
+  if (plugin.manifest.name !== pluginName) {
+    log.warn(
+      { plugin: pluginName, manifestName: plugin.manifest.name, pluginDir },
+      `external plugin reload skipped: directory name "${pluginName}" does not match manifest.name "${plugin.manifest.name}"`,
+    );
+    return;
+  }
+
+  const ctx: DaemonContext = {
+    config: getConfig(),
+    assistantVersion: APP_VERSION,
+  };
+  const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
+  if (disabledFlag !== undefined) {
+    log.info(
+      { plugin: pluginName, flag: disabledFlag },
+      `external plugin reload skipped: feature flag ${disabledFlag} is disabled`,
+    );
+    return;
+  }
+
+  const existing = getRegisteredPlugin(pluginName);
+  if (existing === undefined) {
+    try {
+      await initializePlugin(plugin, ctx);
+      setRegisteredPlugin(plugin);
+      log.info({ plugin: pluginName }, "external plugin registered post-boot");
+    } catch (err) {
+      log.error(
+        { err, plugin: pluginName },
+        "external plugin post-boot registration failed",
+      );
+    }
+    return;
+  }
+
+  try {
+    unregisterPluginTools(pluginName);
+  } catch (err) {
+    log.warn(
+      { err, plugin: pluginName },
+      "external plugin reload: tool unregister failed (continuing)",
+    );
+  }
+
+  setRegisteredPlugin(plugin);
+
+  if (plugin.tools && plugin.tools.length > 0) {
+    try {
+      const accepted = registerPluginTools(pluginName, plugin.tools);
+      log.info(
+        { plugin: pluginName, count: accepted.length },
+        "external plugin reloaded",
+      );
+    } catch (err) {
+      log.error(
+        { err, plugin: pluginName },
+        "external plugin reload: tool registration failed",
+      );
+    }
+    return;
+  }
+
+  log.info({ plugin: pluginName }, "external plugin reloaded");
+}

package/src/daemon/first-greeting.ts

@@ -11,6 +11,7 @@ export interface OnboardingGreetingContext {
   tone: string;
   userName?: string;
   assistantName?: string;
+  googleConnected?: boolean;
 }
 
 export const CANNED_FIRST_GREETING = [
@@ -76,6 +77,16 @@ const TONE_INVITE: Record<Tone, string> = {
     "We can start with whatever's in front of you, or just talk for a bit first. Either way.",
 };
 
+const TONE_GOOGLE_SCAN: Record<Tone, string> = {
+  grounded:
+    "I can scan your email, calendar, and drive in the background while we talk — just say the word.",
+  warm: "Also — I can scan your email, calendar, and drive in the background while we chat, if you'd like. Just let me know.",
+  energetic:
+    "Oh, and I can scan your email, calendar, and drive in the background right now — want me to?",
+  poetic:
+    "I can also look through your email, calendar, and drive quietly in the background — say the word.",
+};
+
 function buildInvite(tone: Tone = "grounded"): string {
   return TONE_INVITE[tone];
 }
@@ -96,11 +107,20 @@ function buildPersonalizedGreeting(ctx: OnboardingGreetingContext): string {
   const assistant = ctx.assistantName?.trim();
   const tone = resolveTone(ctx.tone);
 
-  if (!name && !assistant && !VALID_TONES.has(ctx.tone)) {
+  if (
+    !name &&
+    !assistant &&
+    !VALID_TONES.has(ctx.tone) &&
+    !ctx.googleConnected
+  ) {
     return CANNED_FIRST_GREETING;
   }
 
   const intro = buildIntroLine(name, assistant, tone);
   const invite = buildInvite(tone);
-  return [intro, "", invite].join("\n");
+  const parts = [intro, "", invite];
+  if (ctx.googleConnected) {
+    parts.push("", TONE_GOOGLE_SCAN[tone]);
+  }
+  return parts.join("\n");
 }

package/src/daemon/handlers/config-model.ts

@@ -7,8 +7,8 @@ import {
 import { setServiceField } from "../../config/raw-config-utils.js";
 import { providerForImageModelPrefix } from "../../media/types.js";
 import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
-import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
 import { getConfiguredProviders } from "../../providers/provider-availability.js";
+import { getVisibleProviderCatalog } from "../../providers/provider-catalog-visibility.js";
 import { CONFIG_RELOAD_DEBOUNCE_MS, log } from "./shared.js";
 
 // ---------------------------------------------------------------------------
@@ -65,15 +65,16 @@ export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
   const resolved = resolveCallSiteConfig("mainAgent", config.llm);
   const provider = resolved.provider;
+  const visibleCatalog = getVisibleProviderCatalog(config);
 
   return {
     model: resolved.model,
     provider,
     configuredProviders: await getConfiguredProviders(),
-    availableModels: PROVIDER_CATALOG.find(
-      (p) => p.id === provider,
-    )?.models?.map((m) => ({ id: m.id, displayName: m.displayName })),
-    allProviders: PROVIDER_CATALOG.map(projectProviderForWire),
+    availableModels: visibleCatalog
+      .find((p) => p.id === provider)
+      ?.models?.map((m) => ({ id: m.id, displayName: m.displayName })),
+    allProviders: visibleCatalog.map(projectProviderForWire),
   };
 }
 

package/src/daemon/handlers/config-slack-channel.ts

@@ -34,6 +34,7 @@ export interface SlackChannelConfigResult {
   connected: boolean;
   teamId?: string;
   teamName?: string;
+  teamUrl?: string;
   botUserId?: string;
   botUsername?: string;
   error?: string;
@@ -93,7 +94,8 @@ export function backfillSlackInjectionTemplates(): void {
 // -- Business logic --
 
 export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult> {
-  const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+  const { teamId, teamName, teamUrl, botUserId, botUsername } =
+    getConfig().slack;
   const accountInfo = teamName
     ? `${teamName}${botUsername ? ` (@${botUsername})` : ""}`
     : undefined;
@@ -129,6 +131,7 @@ export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult>
     connected,
     ...(teamId ? { teamId } : {}),
     ...(teamName ? { teamName } : {}),
+    ...(teamUrl ? { teamUrl } : {}),
     ...(botUserId ? { botUserId } : {}),
     ...(botUsername ? { botUsername } : {}),
   };
@@ -169,6 +172,7 @@ export async function setSlackChannelConfig(
   let metadata: {
     teamId?: string;
     teamName?: string;
+    teamUrl?: string;
     botUserId?: string;
     botUsername?: string;
   } = {};
@@ -187,6 +191,7 @@ export async function setSlackChannelConfig(
         error?: string;
         team_id?: string;
         team?: string;
+        url?: string;
         user_id?: string;
         user?: string;
       };
@@ -198,6 +203,7 @@ export async function setSlackChannelConfig(
       metadata = {
         teamId: data.team_id,
         teamName: data.team,
+        teamUrl: data.url,
         botUserId: data.user_id,
         botUsername: data.user,
       };
@@ -221,6 +227,7 @@ export async function setSlackChannelConfig(
     const raw = loadRawConfig();
     setNestedValue(raw, "slack.teamId", metadata.teamId ?? "");
     setNestedValue(raw, "slack.teamName", metadata.teamName ?? "");
+    setNestedValue(raw, "slack.teamUrl", metadata.teamUrl ?? "");
     setNestedValue(raw, "slack.botUserId", metadata.botUserId ?? "");
     setNestedValue(raw, "slack.botUsername", metadata.botUsername ?? "");
     saveRawConfig(raw);
@@ -293,10 +300,12 @@ export async function setSlackChannelConfig(
     }
   } else {
     // Use existing metadata from config if no new bot token provided
-    const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+    const { teamId, teamName, teamUrl, botUserId, botUsername } =
+      getConfig().slack;
     metadata = {
       ...(teamId ? { teamId } : {}),
       ...(teamName ? { teamName } : {}),
+      ...(teamUrl ? { teamUrl } : {}),
       ...(botUserId ? { botUserId } : {}),
       ...(botUsername ? { botUsername } : {}),
     };
@@ -468,7 +477,8 @@ export async function clearSlackUserToken(): Promise<SlackChannelConfigResult> {
     credentialKey("slack_channel", "app_token"),
   ));
   const conn = getConnectionByProvider("slack_channel");
-  const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+  const { teamId, teamName, teamUrl, botUserId, botUsername } =
+    getConfig().slack;
 
   return {
     success: true,
@@ -479,6 +489,7 @@ export async function clearSlackUserToken(): Promise<SlackChannelConfigResult> {
       !!(conn && conn.status === "active") && hasBotToken && hasAppToken,
     ...(teamId ? { teamId } : {}),
     ...(teamName ? { teamName } : {}),
+    ...(teamUrl ? { teamUrl } : {}),
     ...(botUserId ? { botUserId } : {}),
     ...(botUsername ? { botUsername } : {}),
   };
@@ -528,6 +539,7 @@ export async function clearSlackChannelConfig(): Promise<SlackChannelConfigResul
   const raw = loadRawConfig();
   setNestedValue(raw, "slack.teamId", "");
   setNestedValue(raw, "slack.teamName", "");
+  setNestedValue(raw, "slack.teamUrl", "");
   setNestedValue(raw, "slack.botUserId", "");
   setNestedValue(raw, "slack.botUsername", "");
   saveRawConfig(raw);