@hadooppei/hwcode 0.1.0

package/.pi/extensions/model-providers.ts

@@ -0,0 +1,450 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type {
+  ApiKeyCredential,
+  Model,
+  Provider,
+  ProviderAuthInteraction,
+  RefreshModelsContext,
+} from "@earendil-works/pi-ai";
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+
+type ModelInput = "text" | "image";
+type OpenAIModel = Model<"openai-completions">;
+
+interface ConfiguredModel {
+  id: string;
+  name?: string;
+  reasoning?: boolean;
+  input?: ModelInput[];
+  contextWindow?: number;
+  maxTokens?: number;
+}
+
+interface ModelDefaults {
+  reasoning?: boolean;
+  input?: ModelInput[];
+  contextWindow?: number;
+  maxTokens?: number;
+}
+
+interface LoginConfig {
+  enabled: true;
+  promptBaseUrl?: boolean;
+  promptApiKey?: boolean;
+  apiKeyRequired?: boolean;
+  catalogPath?: string;
+  timeoutMs?: number;
+}
+
+interface ModelProviderConfig {
+  id: string;
+  name?: string;
+  baseUrl?: string;
+  baseUrlEnv?: string;
+  apiKeyEnv?: string;
+  login?: LoginConfig;
+  modelDefaults?: ModelDefaults;
+  models?: ConfiguredModel[];
+}
+
+interface ModelProvidersConfig {
+  providers: ModelProviderConfig[];
+}
+
+interface RemoteModel {
+  id: string;
+  name?: string;
+  input?: ModelInput[];
+}
+
+const BUNDLED_CONFIG_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "model-providers.json");
+const CREDENTIAL_BASE_URL = "BASE_URL";
+const DEFAULT_CONTEXT_WINDOW = 32768;
+const DEFAULT_MAX_TOKENS = 8192;
+const DEFAULT_CATALOG_PATH = "models";
+const DEFAULT_TIMEOUT_MS = 15000;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isPositiveNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function normalizeBaseUrl(value: string): string {
+  const url = new URL(value.trim());
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Provider base URL must use http or https");
+  }
+  url.hash = "";
+  url.search = "";
+  return url.toString().replace(/\/$/u, "");
+}
+
+function validateModel(providerId: string, model: ConfiguredModel): void {
+  if (!model.id?.trim()) {
+    throw new Error(`Provider "${providerId}" contains a model without an id`);
+  }
+  if (model.input?.some((input) => input !== "text" && input !== "image")) {
+    throw new Error(`Model "${model.id}" has an unsupported input type`);
+  }
+  if (model.contextWindow !== undefined && !isPositiveNumber(model.contextWindow)) {
+    throw new Error(`Model "${model.id}" has an invalid contextWindow`);
+  }
+  if (model.maxTokens !== undefined && !isPositiveNumber(model.maxTokens)) {
+    throw new Error(`Model "${model.id}" has an invalid maxTokens`);
+  }
+}
+
+function loadConfig(): ModelProvidersConfig {
+  const projectConfigPath = resolve(process.cwd(), ".pi/model-providers.json");
+  const profileConfigPath = process.env.HWCODE_PROFILE_DIR
+    ? join(process.env.HWCODE_PROFILE_DIR, "model-providers.json")
+    : BUNDLED_CONFIG_PATH;
+  const configPath = existsSync(projectConfigPath) ? projectConfigPath : profileConfigPath;
+  const config = JSON.parse(readFileSync(configPath, "utf8")) as ModelProvidersConfig;
+  if (!Array.isArray(config.providers) || config.providers.length === 0) {
+    throw new Error(`${configPath} must contain a non-empty providers array`);
+  }
+
+  const providerIds = new Set<string>();
+  for (const provider of config.providers) {
+    if (!provider.id?.trim()) {
+      throw new Error(`${configPath} contains a provider without an id`);
+    }
+    if (providerIds.has(provider.id)) {
+      throw new Error(`${configPath} contains duplicate provider id "${provider.id}"`);
+    }
+    providerIds.add(provider.id);
+
+    if (provider.baseUrl) normalizeBaseUrl(provider.baseUrl);
+    if (!provider.login?.enabled && !provider.baseUrl?.trim()) {
+      throw new Error(`Static provider "${provider.id}" requires baseUrl`);
+    }
+    if (!provider.login?.enabled && (!Array.isArray(provider.models) || provider.models.length === 0)) {
+      throw new Error(`Static provider "${provider.id}" must contain at least one model`);
+    }
+    if (provider.login?.enabled && provider.login.promptBaseUrl === false && !provider.baseUrl?.trim()) {
+      throw new Error(`Login provider "${provider.id}" requires baseUrl when promptBaseUrl is false`);
+    }
+    if (provider.login?.catalogPath !== undefined && !provider.login.catalogPath.trim()) {
+      throw new Error(`Login provider "${provider.id}" has an empty catalogPath`);
+    }
+    if (provider.login?.timeoutMs !== undefined && !isPositiveNumber(provider.login.timeoutMs)) {
+      throw new Error(`Login provider "${provider.id}" has an invalid timeoutMs`);
+    }
+
+    const modelIds = new Set<string>();
+    for (const model of provider.models ?? []) {
+      validateModel(provider.id, model);
+      if (modelIds.has(model.id)) {
+        throw new Error(`Provider "${provider.id}" contains duplicate model id "${model.id}"`);
+      }
+      modelIds.add(model.id);
+    }
+  }
+
+  return config;
+}
+
+function compatibility() {
+  return {
+    supportsDeveloperRole: false,
+    supportsReasoningEffort: false,
+    supportsStore: false,
+    supportsStrictMode: false,
+    maxTokensField: "max_tokens" as const,
+  };
+}
+
+function toPiModel(
+  provider: ModelProviderConfig,
+  baseUrl: string,
+  remote: RemoteModel,
+): OpenAIModel {
+  const override = provider.models?.find((model) => model.id === remote.id);
+  const defaults = provider.modelDefaults;
+  const contextWindow = override?.contextWindow ?? defaults?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+  const maxTokens = override?.maxTokens ?? defaults?.maxTokens ?? DEFAULT_MAX_TOKENS;
+
+  return {
+    id: remote.id,
+    name: override?.name ?? remote.name ?? remote.id,
+    api: "openai-completions",
+    provider: provider.id,
+    baseUrl,
+    reasoning: override?.reasoning ?? defaults?.reasoning ?? false,
+    input: override?.input ?? remote.input ?? defaults?.input ?? ["text"],
+    contextWindow,
+    maxTokens: Math.min(maxTokens, contextWindow),
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    compat: compatibility(),
+  };
+}
+
+function remoteInput(model: Record<string, unknown>): ModelInput[] | undefined {
+  const architecture = isRecord(model.architecture) ? model.architecture : undefined;
+  const raw = model.input_modalities ?? architecture?.input_modalities;
+  if (!Array.isArray(raw)) return undefined;
+  const values = raw.filter((value): value is string => typeof value === "string");
+  const input: ModelInput[] = ["text"];
+  if (values.some((value) => value === "image" || value === "vision")) input.push("image");
+  return input;
+}
+
+function parseRemoteModels(payload: unknown): RemoteModel[] {
+  const entries = Array.isArray(payload)
+    ? payload
+    : isRecord(payload) && Array.isArray(payload.data)
+      ? payload.data
+      : undefined;
+  if (!entries) throw new Error("Model endpoint returned an invalid catalog");
+
+  const models: RemoteModel[] = [];
+  const ids = new Set<string>();
+  for (const entry of entries) {
+    if (!isRecord(entry) || typeof entry.id !== "string" || !entry.id.trim()) continue;
+    const id = entry.id.trim();
+    if (ids.has(id)) continue;
+    ids.add(id);
+    models.push({
+      id,
+      name: typeof entry.name === "string" && entry.name.trim() ? entry.name.trim() : undefined,
+      input: remoteInput(entry),
+    });
+  }
+
+  if (models.length === 0) throw new Error("Model endpoint returned no usable models");
+  return models;
+}
+
+function responseError(payload: unknown): string | undefined {
+  if (!isRecord(payload)) return undefined;
+  if (typeof payload.message === "string") return payload.message;
+  return isRecord(payload.error) && typeof payload.error.message === "string"
+    ? payload.error.message
+    : undefined;
+}
+
+async function discoverModels(
+  provider: ModelProviderConfig,
+  baseUrl: string,
+  apiKey: string | undefined,
+  signal: AbortSignal,
+): Promise<OpenAIModel[]> {
+  const login = provider.login;
+  if (!login) throw new Error(`Provider "${provider.id}" has no login configuration`);
+
+  const catalogUrl = new URL(login.catalogPath ?? DEFAULT_CATALOG_PATH, `${baseUrl}/`);
+  const headers = new Headers({ Accept: "application/json" });
+  if (apiKey) headers.set("Authorization", `Bearer ${apiKey}`);
+  const timeoutSignal = AbortSignal.timeout(login.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const response = await fetch(catalogUrl, {
+    headers,
+    signal: AbortSignal.any([signal, timeoutSignal]),
+  });
+
+  let payload: unknown;
+  try {
+    payload = await response.json();
+  } catch {
+    payload = undefined;
+  }
+  if (!response.ok) {
+    const detail = responseError(payload);
+    throw new Error(`Model discovery failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+  }
+
+  return parseRemoteModels(payload).map((model) => toPiModel(provider, baseUrl, model));
+}
+
+async function environmentValue(name: string | undefined): Promise<string | undefined> {
+  if (!name) return undefined;
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+
+function storedBaseUrl(credential: ApiKeyCredential | undefined): string | undefined {
+  const value = credential?.env?.[CREDENTIAL_BASE_URL];
+  return typeof value === "string" && value.trim() ? normalizeBaseUrl(value) : undefined;
+}
+
+async function configuredBaseUrl(
+  provider: ModelProviderConfig,
+  credential: ApiKeyCredential | undefined,
+  readEnv: (name: string) => Promise<string | undefined>,
+): Promise<string | undefined> {
+  const fromCredential = storedBaseUrl(credential);
+  if (fromCredential) return fromCredential;
+  if (provider.baseUrlEnv) {
+    const fromEnvironment = (await readEnv(provider.baseUrlEnv))?.trim();
+    if (fromEnvironment) return normalizeBaseUrl(fromEnvironment);
+  }
+  return provider.baseUrl ? normalizeBaseUrl(provider.baseUrl) : undefined;
+}
+
+function registerStaticProvider(pi: ExtensionAPI, config: ModelProviderConfig): void {
+  const baseUrl = normalizeBaseUrl(config.baseUrl!);
+  const apiKey = config.apiKeyEnv
+    ? process.env[config.apiKeyEnv]?.trim() || "local"
+    : "local";
+
+  pi.registerProvider(config.id, {
+    name: config.name ?? config.id,
+    baseUrl,
+    api: "openai-completions",
+    apiKey,
+    compat: compatibility(),
+    models: (config.models ?? []).map((model) => ({
+      id: model.id,
+      name: model.name ?? model.id,
+      reasoning: model.reasoning ?? config.modelDefaults?.reasoning ?? false,
+      input: model.input ?? config.modelDefaults?.input ?? ["text"],
+      contextWindow: model.contextWindow ?? config.modelDefaults?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+      maxTokens: model.maxTokens ?? config.modelDefaults?.maxTokens ?? DEFAULT_MAX_TOKENS,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    })),
+  });
+}
+
+async function loginAndDiscover(
+  config: ModelProviderConfig,
+  interaction: ProviderAuthInteraction,
+): Promise<{ credential: ApiKeyCredential; models: OpenAIModel[] }> {
+  const login = config.login!;
+  try {
+    let baseUrl = config.baseUrl ? normalizeBaseUrl(config.baseUrl) : undefined;
+    if (login.promptBaseUrl !== false) {
+      const entered = await interaction.prompt({
+        type: "text",
+        message: `${config.name ?? config.id} OpenAI-compatible base URL`,
+        placeholder: baseUrl,
+      });
+      const selectedBaseUrl = entered.trim() || baseUrl;
+      if (!selectedBaseUrl) throw new Error(`Provider "${config.id}" requires a base URL`);
+      baseUrl = normalizeBaseUrl(selectedBaseUrl);
+    }
+    if (!baseUrl) throw new Error(`Provider "${config.id}" requires a base URL`);
+
+    let enteredApiKey = "";
+    if (login.promptApiKey !== false) {
+      enteredApiKey = (await interaction.prompt({
+        type: "secret",
+        message: `API key${login.apiKeyRequired ? "" : " (optional)"}`,
+      })).trim();
+    }
+    const apiKey = enteredApiKey || await environmentValue(config.apiKeyEnv);
+    if (login.apiKeyRequired && !apiKey) {
+      throw new Error(`Provider "${config.id}" requires an API key`);
+    }
+
+    interaction.notify({ type: "progress", message: `Discovering models from ${baseUrl}` });
+    const models = await discoverModels(config, baseUrl, apiKey, interaction.signal);
+    interaction.notify({ type: "info", message: `Found ${models.length} model${models.length === 1 ? "" : "s"}.` });
+
+    return {
+      credential: {
+        type: "api_key",
+        key: enteredApiKey || undefined,
+        env: { [CREDENTIAL_BASE_URL]: baseUrl },
+      },
+      models,
+    };
+  } catch (error) {
+    if (interaction.signal.aborted || (error instanceof Error && error.name === "AbortError")) {
+      throw new Error("Login cancelled");
+    }
+    throw error;
+  }
+}
+
+function createLoginProvider(config: ModelProviderConfig): Provider<"openai-completions"> {
+  const login = config.login!;
+  const displayName = config.name ?? config.id;
+  let models: OpenAIModel[] = config.baseUrl
+    ? (config.models ?? []).map((model) => toPiModel(
+      config,
+      normalizeBaseUrl(config.baseUrl!),
+      { id: model.id, name: model.name, input: model.input },
+    ))
+    : [];
+
+  const ambientApiKey = () => environmentValue(config.apiKeyEnv);
+  const ambientBaseUrl = () => environmentValue(config.baseUrlEnv);
+  const hasAmbientConfiguration = async () => Boolean(await ambientApiKey() || await ambientBaseUrl());
+
+  return {
+    id: config.id,
+    name: displayName,
+    baseUrl: config.baseUrl ? normalizeBaseUrl(config.baseUrl) : undefined,
+    auth: {
+      apiKey: {
+        name: `${displayName} credentials`,
+        login: async (interaction: ProviderAuthInteraction) => {
+          const result = await loginAndDiscover(config, interaction);
+          models = result.models;
+          return result.credential;
+        },
+        check: async ({ ctx, credential, signal }) => {
+          signal.throwIfAborted();
+          if (!credential && !await hasAmbientConfiguration()) return undefined;
+          const baseUrl = await configuredBaseUrl(config, credential, (name) => ctx.env(name));
+          const apiKey = credential?.key ?? (config.apiKeyEnv ? await ctx.env(config.apiKeyEnv) : undefined);
+          if (!baseUrl || (login.apiKeyRequired && !apiKey)) return undefined;
+          return { type: "api_key", source: credential ? "stored credential" : config.apiKeyEnv ?? config.baseUrlEnv };
+        },
+        resolve: async ({ ctx, credential, signal }) => {
+          signal.throwIfAborted();
+          if (!credential && !await hasAmbientConfiguration()) return undefined;
+          const baseUrl = await configuredBaseUrl(config, credential, (name) => ctx.env(name));
+          const apiKey = credential?.key ?? (config.apiKeyEnv ? await ctx.env(config.apiKeyEnv) : undefined);
+          if (!baseUrl || (login.apiKeyRequired && !apiKey)) return undefined;
+          return {
+            auth: { apiKey: apiKey || "local", baseUrl },
+            env: { ...credential?.env, [CREDENTIAL_BASE_URL]: baseUrl },
+            source: credential ? "stored credential" : config.apiKeyEnv ?? config.baseUrlEnv,
+          };
+        },
+      },
+    },
+    getModels: () => models,
+    refreshModels: async (context: RefreshModelsContext) => {
+      if (context.stored) {
+        const restored = context.stored.models.filter(
+          (model): model is OpenAIModel => model.provider === config.id && model.api === "openai-completions",
+        );
+        if (!await context.publish({ update: () => { models = restored; } })) return;
+      }
+      if (!context.allowNetwork || context.signal.aborted) return;
+
+      const credential = context.credential?.type === "api_key" ? context.credential : undefined;
+      if (!credential && !await hasAmbientConfiguration()) return;
+      const environmentBaseUrl = await ambientBaseUrl();
+      const baseUrl = storedBaseUrl(credential)
+        ?? (environmentBaseUrl ? normalizeBaseUrl(environmentBaseUrl) : undefined)
+        ?? (config.baseUrl ? normalizeBaseUrl(config.baseUrl) : undefined);
+      const apiKey = credential?.key ?? await ambientApiKey();
+      if (!baseUrl || (login.apiKeyRequired && !apiKey)) return;
+
+      const refreshed = await discoverModels(config, baseUrl, apiKey, context.signal);
+      await context.publish({
+        persist: { models: refreshed, checkedAt: Date.now() },
+        update: () => { models = refreshed; },
+      });
+    },
+    stream: (model, context, options) => stream(model, context, options),
+    streamSimple: (model, context, options) => streamSimple(model, context, options),
+  };
+}
+
+export default function modelProvidersExtension(pi: ExtensionAPI) {
+  const config = loadConfig();
+  for (const provider of config.providers) {
+    if (provider.login?.enabled) pi.registerProvider(createLoginProvider(provider));
+    else registerStaticProvider(pi, provider);
+  }
+}

package/.pi/extensions/welcome.ts

@@ -0,0 +1,168 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  CONFIG_DIR_NAME,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type ThemeColor,
+} from "@earendil-works/pi-coding-agent";
+import { isThemeColor, renderPixelText } from "../lib/pixel-font.ts";
+import { shouldDismissWelcomeOnSubmit } from "../lib/welcome-input.ts";
+
+interface WelcomeConfig {
+  title: string;
+  logo: string;
+  characterColors: ThemeColor[];
+  subtitle: string;
+  subtitleColor: ThemeColor;
+  reservedRows: number;
+}
+
+const DEFAULT_CONFIG: WelcomeConfig = {
+  title: "HWCode · Pi",
+  logo: "HWCODE",
+  characterColors: ["accent"],
+  subtitle: "Local AI Coding Workspace",
+  subtitleColor: "muted",
+  reservedRows: 8,
+};
+
+function loadConfig(cwd: string): WelcomeConfig {
+  const projectPath = join(cwd, CONFIG_DIR_NAME, "welcome.json");
+  const profilePath = process.env.HWCODE_PROFILE_DIR
+    ? join(process.env.HWCODE_PROFILE_DIR, "welcome.json")
+    : join(dirname(fileURLToPath(import.meta.url)), "..", "welcome.json");
+  const path = existsSync(projectPath) ? projectPath : profilePath;
+  const raw = JSON.parse(readFileSync(path, "utf8")) as Partial<WelcomeConfig>;
+  const logo = raw.logo?.trim().toUpperCase() ?? DEFAULT_CONFIG.logo;
+
+  if (!/^[A-Z]{1,6}$/.test(logo)) {
+    throw new Error("welcome.logo must contain 1-6 English letters");
+  }
+
+  const characterColors = raw.characterColors ?? DEFAULT_CONFIG.characterColors;
+  if (characterColors.length === 0 || !characterColors.every(isThemeColor)) {
+    throw new Error("welcome.characterColors contains an unsupported Pi theme color");
+  }
+  if (raw.subtitleColor !== undefined && !isThemeColor(raw.subtitleColor)) {
+    throw new Error("welcome.subtitleColor is not a supported Pi theme color");
+  }
+
+  return {
+    title: raw.title?.trim() || DEFAULT_CONFIG.title,
+    logo,
+    characterColors,
+    subtitle: raw.subtitle?.trim() ?? DEFAULT_CONFIG.subtitle,
+    subtitleColor: raw.subtitleColor ?? DEFAULT_CONFIG.subtitleColor,
+    reservedRows:
+      typeof raw.reservedRows === "number" && raw.reservedRows >= 5
+        ? Math.floor(raw.reservedRows)
+        : DEFAULT_CONFIG.reservedRows,
+  };
+}
+
+function centerText(text: string, width: number): string {
+  return `${" ".repeat(Math.max(0, Math.floor((width - text.length) / 2)))}${text}`;
+}
+
+export default function welcomeExtension(pi: ExtensionAPI) {
+  let welcomeVisible = false;
+  let clearTerminal: (() => void) | undefined;
+
+  function showWelcome(ctx: ExtensionContext) {
+    if (ctx.mode !== "tui") return;
+
+    let config: WelcomeConfig;
+    try {
+      config = loadConfig(ctx.cwd);
+    } catch (error) {
+      config = DEFAULT_CONFIG;
+      ctx.ui.notify(`Welcome config error: ${(error as Error).message}`, "error");
+    }
+
+    const model = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "未选择";
+    welcomeVisible = true;
+    ctx.ui.setTitle(config.title);
+
+    ctx.ui.setHeader((tui, theme) => {
+      clearTerminal = () => {
+        tui.terminal.clearScreen();
+        tui.requestRender(true);
+      };
+
+      return {
+        render(width) {
+          const availableHeight = Math.max(1, tui.terminal.rows - config.reservedRows);
+          const subtitleHeight = config.subtitle ? 2 : 0;
+          const logo = renderPixelText(
+            config.logo,
+            config.characterColors,
+            theme,
+            width,
+            Math.max(1, availableHeight - subtitleHeight),
+          );
+          const groupHeight = logo.height + subtitleHeight;
+          const topPadding = Math.max(0, Math.floor((availableHeight - groupHeight) / 2));
+          const bottomPadding = Math.max(0, availableHeight - topPadding - groupHeight);
+          const lines = [...Array<string>(topPadding).fill(""), ...logo.lines];
+
+          if (config.subtitle) {
+            lines.push("", theme.fg(config.subtitleColor, centerText(config.subtitle, width)));
+          }
+
+          lines.push(...Array<string>(bottomPadding).fill(""));
+          return lines;
+        },
+        invalidate() {},
+      };
+    });
+
+    ctx.ui.setWidget("hwcode-welcome", [
+      `当前模型：${model}`,
+      "输入任何内容开始会话",
+      "命令：/model 切换模型",
+    ]);
+  }
+
+  function dismissWelcome(ctx: ExtensionContext) {
+    if (!welcomeVisible) return;
+
+    welcomeVisible = false;
+    ctx.ui.setHeader(undefined);
+    ctx.ui.setWidget("hwcode-welcome", undefined);
+    clearTerminal?.();
+    clearTerminal = undefined;
+  }
+
+  pi.on("session_start", (event, ctx) => {
+    if (ctx.mode === "tui") {
+      ctx.ui.onTerminalInput((data) => {
+        if (welcomeVisible && shouldDismissWelcomeOnSubmit(data, ctx.ui.getEditorText())) {
+          dismissWelcome(ctx);
+        }
+        return undefined;
+      });
+    }
+    if (event.reason === "startup") showWelcome(ctx);
+  });
+
+  pi.on("input", (_event, ctx) => {
+    dismissWelcome(ctx);
+    return { action: "continue" };
+  });
+
+  pi.on("before_agent_start", (_event, ctx) => {
+    dismissWelcome(ctx);
+  });
+
+  pi.on("user_bash", (_event, ctx) => {
+    dismissWelcome(ctx);
+    return undefined;
+  });
+
+  pi.registerCommand("welcome", {
+    description: "Show the HWCode welcome panel",
+    handler: async (_args, ctx) => showWelcome(ctx),
+  });
+}