wave-agent-sdk 1.0.4 → 1.0.6

package/src/services/pluginLoader.ts

@@ -1,252 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import {
-  PluginManifest,
-  CustomSlashCommand,
-  Skill,
-  LspConfig,
-  McpConfig,
-  PartialHookConfiguration,
-} from "../types/index.js";
-import { scanCommandsDirectory } from "../utils/customCommands.js";
-import { parseSkillFile } from "../utils/skillParser.js";
-import {
-  parseAgentFile,
-  type SubagentConfiguration,
-} from "../utils/subagentParser.js";
-import { logger } from "../utils/globalLogger.js";
-
-export class PluginLoader {
-  /**
-   * Load and validate a plugin manifest from a directory
-   * @param pluginPath Absolute path to the plugin directory
-   */
-  static async loadManifest(pluginPath: string): Promise<PluginManifest> {
-    const dotWavePluginPath = path.join(pluginPath, ".wave-plugin");
-
-    // Check if .wave-plugin/ directory exists
-    let wavePluginDirExists = false;
-    try {
-      const entries = await fs.readdir(dotWavePluginPath);
-      wavePluginDirExists = true;
-      // T018: Ensure plugin.json is the only file in .wave-plugin/
-      const misplaced = entries.filter((e) => e !== "plugin.json");
-      if (misplaced.length > 0) {
-        throw new Error(
-          `Misplaced files/directories in .wave-plugin/: ${misplaced.join(", ")}. Only plugin.json should be in this directory.`,
-        );
-      }
-    } catch (error) {
-      if (
-        error instanceof Error &&
-        (error as { code?: string }).code === "ENOENT"
-      ) {
-        // .wave-plugin/ doesn't exist, will try .claude-plugin/ fallback below
-      } else {
-        throw error;
-      }
-    }
-
-    if (wavePluginDirExists) {
-      const manifestPath = path.join(dotWavePluginPath, "plugin.json");
-      try {
-        const content = await fs.readFile(manifestPath, "utf-8");
-        const manifest = JSON.parse(content) as PluginManifest;
-        this.validateManifest(manifest);
-        return manifest;
-      } catch (error) {
-        if (
-          error instanceof Error &&
-          (error as { code?: string }).code === "ENOENT"
-        ) {
-          throw new Error(`Plugin manifest not found at ${manifestPath}`);
-        }
-        throw new Error(
-          `Failed to load plugin manifest at ${manifestPath}: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    }
-
-    // Fallback to .claude-plugin/
-    const dotClaudePluginPath = path.join(pluginPath, ".claude-plugin");
-    const claudeManifestPath = path.join(dotClaudePluginPath, "plugin.json");
-    try {
-      const content = await fs.readFile(claudeManifestPath, "utf-8");
-      const manifest = JSON.parse(content) as PluginManifest;
-      this.validateManifest(manifest);
-      return manifest;
-    } catch (error) {
-      if (
-        error instanceof Error &&
-        (error as { code?: string }).code === "ENOENT"
-      ) {
-        throw new Error(
-          `Plugin manifest not found at ${dotWavePluginPath} or ${dotClaudePluginPath}`,
-        );
-      }
-      throw new Error(
-        `Failed to load plugin manifest at ${claudeManifestPath}: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      );
-    }
-  }
-
-  /**
-   * Load commands from a plugin's commands directory
-   * @param pluginPath Absolute path to the plugin directory
-   */
-  static loadCommands(pluginPath: string): CustomSlashCommand[] {
-    const commandsPath = path.join(pluginPath, "commands");
-    return scanCommandsDirectory(commandsPath);
-  }
-
-  /**
-   * Load skills from a plugin's skills directory
-   * @param pluginPath Absolute path to the plugin directory
-   */
-  static async loadSkills(pluginPath: string): Promise<Skill[]> {
-    const skillsPath = path.join(pluginPath, "skills");
-    const skills: Skill[] = [];
-
-    try {
-      const entries = await fs.readdir(skillsPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const skillDir = path.join(skillsPath, entry.name);
-          const skillFilePath = path.join(skillDir, "SKILL.md");
-          try {
-            await fs.stat(skillFilePath);
-            const parsed = parseSkillFile(skillFilePath, {
-              basePath: skillDir,
-              validateMetadata: true,
-            });
-            if (parsed.isValid) {
-              skills.push({
-                ...parsed.skillMetadata,
-                type: "project", // Plugin skills are treated as project skills
-                pluginRoot: pluginPath,
-                content: parsed.content,
-                frontmatter: parsed.frontmatter,
-                isValid: parsed.isValid,
-                errors: parsed.validationErrors,
-              });
-            }
-          } catch {
-            // Skip directories without SKILL.md
-          }
-        }
-      }
-    } catch {
-      // skills directory might not exist
-    }
-
-    return skills;
-  }
-
-  /**
-   * Load LSP configuration from a plugin
-   */
-  static async loadLspConfig(
-    pluginPath: string,
-  ): Promise<LspConfig | undefined> {
-    const lspPath = path.join(pluginPath, ".lsp.json");
-    try {
-      const content = await fs.readFile(lspPath, "utf-8");
-      return JSON.parse(content) as LspConfig;
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * Load MCP configuration from a plugin
-   */
-  static async loadMcpConfig(
-    pluginPath: string,
-  ): Promise<McpConfig | undefined> {
-    const mcpPath = path.join(pluginPath, ".mcp.json");
-    try {
-      const content = await fs.readFile(mcpPath, "utf-8");
-      // Return raw config — let McpManager resolve templates and capture originalUrl
-      return JSON.parse(content) as McpConfig;
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * Load hooks configuration from a plugin
-   */
-  static async loadHooksConfig(
-    pluginPath: string,
-  ): Promise<PartialHookConfiguration | undefined> {
-    const hooksPath = path.join(pluginPath, "hooks", "hooks.json");
-    try {
-      const content = await fs.readFile(hooksPath, "utf-8");
-      const parsed = JSON.parse(content);
-      // Claude Code wrapper format: { "hooks": { "SessionStart": [...] } }
-      // (optional "description" sibling key)
-      if (parsed && typeof parsed === "object" && "hooks" in parsed) {
-        return parsed.hooks as PartialHookConfiguration;
-      }
-      return undefined;
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * Load agent configurations from a plugin's agents directory
-   */
-  static async loadAgents(
-    pluginPath: string,
-  ): Promise<SubagentConfiguration[]> {
-    const agentsPath = path.join(pluginPath, "agents");
-    const agents: SubagentConfiguration[] = [];
-
-    try {
-      const entries = await fs.readdir(agentsPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith(".md")) {
-          const agentFilePath = path.join(agentsPath, entry.name);
-          try {
-            const config = parseAgentFile(agentFilePath, "plugin", pluginPath);
-            agents.push(config);
-          } catch (parseError) {
-            // Log error but continue with other files
-            logger?.warn(
-              `Warning: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
-            );
-          }
-        }
-      }
-    } catch {
-      // agents directory might not exist
-    }
-
-    return agents;
-  }
-
-  /**
-   * Validate the plugin manifest structure
-   */
-  private static validateManifest(manifest: PluginManifest): void {
-    if (!manifest.name) {
-      throw new Error("Plugin manifest missing 'name'");
-    }
-    if (!manifest.description) {
-      throw new Error("Plugin manifest missing 'description'");
-    }
-    if (!manifest.version) {
-      throw new Error("Plugin manifest missing 'version'");
-    }
-    if (!/^[a-z0-9-]+$/.test(manifest.name)) {
-      throw new Error(
-        `Invalid plugin name: ${manifest.name}. Only lowercase letters, numbers, and hyphens are allowed.`,
-      );
-    }
-  }
-}

package/src/services/remoteSettingsService.ts

@@ -1,366 +0,0 @@
-import * as fs from "node:fs";
-import { homedir } from "node:os";
-import * as path from "node:path";
-
-import { authService, createAuthAwareFetch } from "./authService.js";
-import type {
-  RemoteSettingsCache,
-  RemoteSettingsFetchResult,
-  RemoteSettingsResponse,
-} from "../types/configuration.js";
-import type { WaveConfiguration } from "../types/configuration.js";
-import type { HookEvent, HookEventConfig } from "../types/hooks.js";
-import { logger } from "../utils/globalLogger.js";
-
-const CACHE_FILE = path.join(homedir(), ".wave", "remote-settings.json");
-const POLLING_INTERVAL_MS = 60 * 60 * 1000; // 60 minutes
-const FETCH_TIMEOUT_MS = 10_000;
-
-let _cachedSettings: RemoteSettingsCache | null = null;
-let _pollingTimer: ReturnType<typeof setInterval> | null = null;
-let _onSettingsUpdateCallbacks: Array<() => void | Promise<void>> = [];
-
-/**
- * Register a callback invoked when remote settings change (checksum differs).
- * Returns an unsubscribe function.
- */
-export function onSettingsUpdate(
-  callback: () => void | Promise<void>,
-): () => void {
-  _onSettingsUpdateCallbacks.push(callback);
-  return () => {
-    _onSettingsUpdateCallbacks = _onSettingsUpdateCallbacks.filter(
-      (cb) => cb !== callback,
-    );
-  };
-}
-
-async function notifySettingsUpdate(): Promise<void> {
-  for (const cb of _onSettingsUpdateCallbacks) {
-    try {
-      await cb();
-    } catch {
-      // Don't let callback errors break the fetch flow
-    }
-  }
-}
-
-function loadCacheFromDisk(): void {
-  try {
-    if (!fs.existsSync(CACHE_FILE)) {
-      return;
-    }
-    const raw = fs.readFileSync(CACHE_FILE, "utf-8");
-    const parsed: RemoteSettingsCache = JSON.parse(raw);
-    _cachedSettings = parsed;
-    logger.debug("remoteSettings: loaded cache from disk", {
-      checksum: parsed.checksum,
-    });
-  } catch (err) {
-    logger.debug("remoteSettings: failed to load cache from disk", { err });
-  }
-}
-
-function writeCacheToDisk(): void {
-  if (!_cachedSettings) {
-    return;
-  }
-  try {
-    const dir = path.dirname(CACHE_FILE);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(CACHE_FILE, JSON.stringify(_cachedSettings, null, 2), {
-      mode: 0o600,
-    });
-    logger.debug("remoteSettings: wrote cache to disk", {
-      checksum: _cachedSettings.checksum,
-    });
-  } catch (err) {
-    logger.debug("remoteSettings: failed to write cache to disk", { err });
-  }
-}
-
-function removeCacheFromDisk(): void {
-  try {
-    if (fs.existsSync(CACHE_FILE)) {
-      fs.unlinkSync(CACHE_FILE);
-    }
-  } catch (err) {
-    logger.debug("remoteSettings: failed to remove cache file", { err });
-  }
-}
-
-async function fetchRemoteSettings(): Promise<RemoteSettingsFetchResult> {
-  if (!authService.isSSOAuthenticated()) {
-    logger.debug("remoteSettings: skipping fetch — not SSO authenticated");
-    return { success: false, error: "Not SSO authenticated" };
-  }
-
-  const token = authService.getSSOToken();
-  const serverUrl = authService.getServerUrl();
-  if (!token || !serverUrl) {
-    return { success: false, error: "Missing SSO token or server URL" };
-  }
-
-  const oldChecksum = _cachedSettings?.checksum;
-
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${token}`,
-  };
-  if (_cachedSettings?.checksum) {
-    headers["If-None-Match"] = _cachedSettings.checksum;
-  }
-
-  try {
-    const authFetch = createAuthAwareFetch(globalThis.fetch);
-    const response = await authFetch(`${serverUrl}/api/wave/settings`, {
-      method: "GET",
-      headers,
-      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-    });
-
-    if (response.status === 304) {
-      logger.debug("remoteSettings: 304 unchanged", {
-        checksum: _cachedSettings?.checksum,
-      });
-      return {
-        success: true,
-        settings: _cachedSettings!.settings,
-        checksum: _cachedSettings!.checksum,
-      };
-    }
-
-    if (response.status === 404) {
-      logger.debug("remoteSettings: 404 not configured — clearing stale cache");
-      _cachedSettings = null;
-      removeCacheFromDisk();
-      if (oldChecksum) {
-        await notifySettingsUpdate();
-      }
-      return { success: true, notConfigured: true, settings: null };
-    }
-
-    if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      logger.debug("remoteSettings: fetch failed", {
-        status: response.status,
-        body: body.slice(0, 200),
-      });
-      return {
-        success: false,
-        error: `HTTP ${response.status}`,
-        settings: _cachedSettings?.settings ?? null,
-      };
-    }
-
-    const data = (await response.json()) as RemoteSettingsResponse;
-    _cachedSettings = {
-      uuid: data.uuid,
-      checksum: data.checksum,
-      settings: data.settings,
-      fetchedAt: new Date().toISOString(),
-    };
-    writeCacheToDisk();
-    logger.debug("remoteSettings: fetched new settings", {
-      checksum: data.checksum,
-    });
-    if (data.checksum !== oldChecksum) {
-      await notifySettingsUpdate();
-    }
-    return {
-      success: true,
-      settings: data.settings,
-      checksum: data.checksum,
-    };
-  } catch (err) {
-    logger.debug("remoteSettings: network error, using cache", { err });
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : String(err),
-      settings: _cachedSettings?.settings ?? null,
-    };
-  }
-}
-
-function startPolling(): void {
-  if (_pollingTimer) {
-    return;
-  }
-  _pollingTimer = setInterval(async () => {
-    try {
-      await fetchRemoteSettings();
-    } catch (err) {
-      logger.debug("remoteSettings: polling fetch error", { err });
-    }
-  }, POLLING_INTERVAL_MS);
-  _pollingTimer.unref();
-}
-
-export function initialize(): void {
-  // Load disk cache synchronously so getRemoteSettingsSync() returns cached
-  // managed settings during loadMergedConfiguration() (must run BEFORE it).
-  loadCacheFromDisk();
-}
-
-/**
- * Start the fire-and-forget initial network fetch + background polling.
- *
- * Must be called AFTER loadMergedConfiguration() so disk-cached managed
- * settings are merged before the fetch, and so settings `env` WAVE_SERVER_URL
- * is mirrored to process.env (by setEnvironmentVars) before the fetch. The
- * fetch uses authService.getServerUrl(), which reads process.env.WAVE_SERVER_URL
- * — the settings value is visible there, so there is no init-ordering race
- * that would fall back to DEFAULT_SERVER_URL (prod) and hit a test endpoint (401).
- */
-export function startBackgroundFetch(): void {
-  fetchRemoteSettings()
-    .then(() => startPolling())
-    .catch((err) => {
-      logger.debug("remoteSettings: initial fetch failed", { err });
-      startPolling();
-    });
-}
-
-export function getRemoteSettingsSync(): WaveConfiguration | null {
-  return _cachedSettings?.settings ?? null;
-}
-
-export async function refresh(): Promise<RemoteSettingsFetchResult> {
-  // Clear in-memory so we force a fresh fetch
-  _cachedSettings = null;
-  removeCacheFromDisk();
-  return fetchRemoteSettings();
-}
-
-export function clear(): void {
-  _cachedSettings = null;
-  removeCacheFromDisk();
-  if (_pollingTimer) {
-    clearInterval(_pollingTimer);
-    _pollingTimer = null;
-  }
-}
-
-export function shutdown(): void {
-  if (_pollingTimer) {
-    clearInterval(_pollingTimer);
-    _pollingTimer = null;
-  }
-}
-
-function dedupe(arr: string[]): string[] {
-  return [...new Set(arr)];
-}
-
-function mergeHooks(
-  local: Partial<Record<HookEvent, HookEventConfig[]>> | undefined,
-  remote: Partial<Record<HookEvent, HookEventConfig[]>> | undefined,
-): Partial<Record<HookEvent, HookEventConfig[]>> | undefined {
-  if (!remote && !local) {
-    return undefined;
-  }
-  if (!remote) {
-    return local;
-  }
-  if (!local) {
-    return remote;
-  }
-  const merged: Partial<Record<HookEvent, HookEventConfig[]>> = { ...local };
-  for (const [event, remoteHooks] of Object.entries(remote)) {
-    const localHooks = merged[event as HookEvent] ?? [];
-    // Concatenate + dedupe by JSON serialization
-    const combined = [...localHooks, ...(remoteHooks ?? [])];
-    const seen = new Set<string>();
-    merged[event as HookEvent] = combined.filter((h) => {
-      const key = JSON.stringify(h);
-      if (seen.has(key)) {
-        return false;
-      }
-      seen.add(key);
-      return true;
-    });
-  }
-  return merged;
-}
-
-export function mergeRemoteSettings(
-  localMerged: WaveConfiguration,
-  remote: WaveConfiguration,
-): WaveConfiguration {
-  const result: WaveConfiguration = { ...localMerged };
-
-  // env: merge by key, remote wins per-key
-  if (remote.env || localMerged.env) {
-    result.env = { ...localMerged.env, ...remote.env };
-  }
-
-  // permissions
-  if (remote.permissions || localMerged.permissions) {
-    const lp = localMerged.permissions ?? {};
-    const rp = remote.permissions ?? {};
-    result.permissions = {
-      // allow: concatenate + dedupe
-      allow:
-        lp.allow || rp.allow
-          ? dedupe([...(lp.allow ?? []), ...(rp.allow ?? [])])
-          : undefined,
-      // deny: concatenate + dedupe
-      deny:
-        lp.deny || rp.deny
-          ? dedupe([...(lp.deny ?? []), ...(rp.deny ?? [])])
-          : undefined,
-      // permissionMode: remote wins (scalar)
-      permissionMode: rp.permissionMode ?? lp.permissionMode,
-      // additionalDirectories: concatenate + dedupe
-      additionalDirectories:
-        lp.additionalDirectories || rp.additionalDirectories
-          ? dedupe([
-              ...(lp.additionalDirectories ?? []),
-              ...(rp.additionalDirectories ?? []),
-            ])
-          : undefined,
-    };
-    // Clean up undefined keys
-    if (!result.permissions.allow) delete result.permissions.allow;
-    if (!result.permissions.deny) delete result.permissions.deny;
-    if (!result.permissions.permissionMode)
-      delete result.permissions.permissionMode;
-    if (!result.permissions.additionalDirectories)
-      delete result.permissions.additionalDirectories;
-  }
-
-  // hooks: concatenate per-event
-  result.hooks = mergeHooks(localMerged.hooks, remote.hooks);
-
-  // Scalar / last-write-wins fields: remote wins
-  if (remote.language !== undefined) result.language = remote.language;
-  if (remote.model !== undefined) result.model = remote.model;
-  if (remote.autoMemoryEnabled !== undefined)
-    result.autoMemoryEnabled = remote.autoMemoryEnabled;
-  if (remote.autoMemoryFrequency !== undefined)
-    result.autoMemoryFrequency = remote.autoMemoryFrequency;
-  if (remote.worktree !== undefined) result.worktree = remote.worktree;
-  if (remote.models !== undefined) result.models = remote.models;
-  if (remote.marketplaces !== undefined)
-    result.marketplaces = remote.marketplaces;
-  if (remote.enabledPlugins !== undefined)
-    result.enabledPlugins = remote.enabledPlugins;
-
-  return result;
-}
-
-/**
- * Singleton object for consumers that prefer a namespace-style import.
- * Usage: import { remoteSettingsService } from "./remoteSettingsService.js"
- */
-export const remoteSettingsService = {
-  initialize,
-  startBackgroundFetch,
-  getRemoteSettingsSync,
-  refresh,
-  clear,
-  shutdown,
-  mergeRemoteSettings,
-  onSettingsUpdate,
-} as const;