@aexol/opencode-wizard 0.3.3 → 0.3.4

package/dist/server/runtime.js

@@ -0,0 +1,1110 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { CREATE_OR_UPDATE_SKILL_FROM_MARKDOWN_MUTATION, SET_PUBLISHED_SKILL_PREFERENCE_MUTATION } from '../graphql-operations.js';
+import { createPublishedSkillToolDefinitions } from '../plugin-tools.js';
+import { readGlobalAuthState, resolveStoredAuthState, toAuthState, toStoredUserKey, writeAuthState } from './auth-store.js';
+import { resolveConfig } from './config.js';
+export { resolveConfig } from './config.js';
+import { createPluginSession, openBrowser, startLoginFlow } from './auth-flow.js';
+import { fetchPublishedSkillDetail, fetchPublishedSkillsCatalog, fetchPublishedSkillsGraphQl, maybePersistWorkspaceSlugFromCatalog } from './client.js';
+import { normalizeAbsolutePath } from './path-utils.js';
+import { emitPluginActionEvent, emitPresenceEvent } from './presence.js';
+import { normalizeDirectoryArg, normalizeRepositoryPath, resolveWorkspace, toDeliveryInput, toWorkspaceResolutionMetadata, toWorkspaceResolutionOutput } from './workspace.js';
+import { parseRequestedSkillArgs, selectPublishedSkills, toPublishedSkillDetail, toPublishedSkillSummary } from '../published-skills-transform.js';
+import { CACHE_TTL_MS, LOGIN_TIMEOUT_MS, OIDC_CALLBACK_URL, PLUGIN_ID, PRESENCE_EVENT_TIMEOUT_MS, PRESENCE_SHUTDOWN_SIGNALS, PRESENCE_SIGNAL_EXIT_CODES } from './constants.js';
+export { PLUGIN_ID, NATIVE_SKILLS_URL_COMPATIBILITY } from './constants.js';
+import { buildSystemNote, filterIgnoredPublishedSkills, resolvePluginStatusSnapshot, toAiFacingPluginStatusSnapshot, toFetchFailureOutput, toPluginStatusMetadata, toPublishedSkillCatalog, withStatusMessage } from './status.js';
+export { buildSystemNote, resolvePluginStatusSnapshot, toPluginAuthStateSummary, toPublishedSkillCatalog } from './status.js';
+const createIdleLoginBootstrapSnapshot = () => ({
+  status: 'idle',
+  trigger: null,
+  startedAt: null,
+  expiresAt: null,
+  browserUrl: null,
+  browserOpenError: null,
+  email: null,
+  message: null
+});
+const STATUS_PATH_LOGIN_RETRY_COOLDOWN_MS = 60_000;
+const statusPathLoginBootstrap = {
+  promise: null,
+  status: 'idle',
+  message: null,
+  failedAt: null
+};
+const importOpencodePluginModule = new Function('specifier', 'return import(specifier)');
+let publishedSkillPreferenceCacheVersion = 0;
+const toIgnoredSkillSlug = value => {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return null;
+  return normalized;
+};
+const toPublishedSkillPreferenceAction = value => {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'install' || normalized === 'uninstall' || normalized === 'ignore' || normalized === 'unignore') {
+    return normalized;
+  }
+  throw new Error('Published skill preference action must be one of: install, uninstall, ignore, unignore.');
+};
+const toPublishedSkillPreferenceScope = (value, defaultScope) => {
+  if (!value) return defaultScope;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'global' || normalized === 'project') return normalized;
+  throw new Error('Published skill preferenceScope must be either global or project.');
+};
+const resolvePublishedSkillPreferenceCacheContext = async config => {
+  const authState = await readGlobalAuthState(config.authStatePath);
+  return {
+    userKey: toStoredUserKey(authState),
+    preferenceVersion: publishedSkillPreferenceCacheVersion
+  };
+};
+const getCatalogCacheKey = (workspaceResolution, preferenceContext) => {
+  return JSON.stringify([workspaceResolution.cacheKey, preferenceContext.userKey, preferenceContext.preferenceVersion]);
+};
+const startStatusPathLoginBootstrap = (worktree, config) => {
+  if (statusPathLoginBootstrap.promise) return;
+  if (statusPathLoginBootstrap.status === 'failed' && statusPathLoginBootstrap.failedAt && Date.now() - statusPathLoginBootstrap.failedAt < STATUS_PATH_LOGIN_RETRY_COOLDOWN_MS) {
+    return;
+  }
+  statusPathLoginBootstrap.status = 'pending';
+  statusPathLoginBootstrap.message = 'Browser login started automatically from the TUI/status path.';
+  statusPathLoginBootstrap.failedAt = null;
+  statusPathLoginBootstrap.promise = (async () => {
+    const loginSignal = AbortSignal.timeout(LOGIN_TIMEOUT_MS);
+    const loginStart = await startLoginFlow(loginSignal);
+    const browserOpenError = await openBrowser(loginStart.browserUrl);
+    if (browserOpenError) {
+      statusPathLoginBootstrap.message = `Automatic browser open failed. Open ${loginStart.browserUrl} manually.`;
+    }
+    try {
+      const callbackPayload = await loginStart.callbackPromise;
+      if (callbackPayload.status === 'error') {
+        throw new Error(callbackPayload.message);
+      }
+      if (callbackPayload.state !== loginStart.expectedState) {
+        throw new Error('OAuth callback state did not match the original login request.');
+      }
+      const pluginSession = await createPluginSession({
+        code: callbackPayload.code,
+        codeVerifier: loginStart.codeVerifier,
+        redirectUri: OIDC_CALLBACK_URL,
+        config,
+        signal: loginSignal
+      });
+      const authState = toAuthState(pluginSession);
+      await writeAuthState(config.authStatePath, authState);
+      statusPathLoginBootstrap.status = 'authenticated';
+      statusPathLoginBootstrap.message = `Browser login completed successfully for ${authState.email}.`;
+      return authState;
+    } finally {
+      await loginStart.closeCallbackServer().catch(() => undefined);
+    }
+  })().catch(error => {
+    statusPathLoginBootstrap.status = 'failed';
+    statusPathLoginBootstrap.failedAt = Date.now();
+    statusPathLoginBootstrap.message = error instanceof Error ? error.message : 'Browser login failed.';
+    throw error;
+  }).finally(() => {
+    statusPathLoginBootstrap.promise = null;
+  });
+  statusPathLoginBootstrap.promise.catch(() => undefined);
+};
+export const resolvePluginStatusSnapshotWithAuthBootstrap = async ({
+  worktree,
+  directory,
+  signal
+}) => {
+  const snapshot = await resolvePluginStatusSnapshot({
+    worktree,
+    directory,
+    signal
+  });
+  if (snapshot.status !== 'missing_auth') return snapshot;
+  const config = await resolveConfig(worktree);
+  startStatusPathLoginBootstrap(worktree, config);
+  if (statusPathLoginBootstrap.message) {
+    return withStatusMessage(snapshot, statusPathLoginBootstrap.message);
+  }
+  return withStatusMessage(snapshot, 'Browser login is pending from the TUI/status path.');
+};
+const toBackendPreferenceScope = preferenceScope => {
+  if (preferenceScope === 'global') return 'GLOBAL';
+  return 'WORKSPACE';
+};
+const setPublishedSkillPreference = async ({
+  worktree,
+  directory,
+  config,
+  skillSlug,
+  preferenceScope,
+  installed,
+  ignored
+}) => {
+  const workspaceResolution = await resolveWorkspace({
+    config,
+    directory
+  });
+  const response = await fetchPublishedSkillsGraphQl({
+    worktree,
+    config,
+    query: SET_PUBLISHED_SKILL_PREFERENCE_MUTATION,
+    variables: {
+      input: {
+        ...toDeliveryInput(workspaceResolution),
+        skillSlug,
+        preferenceScope: toBackendPreferenceScope(preferenceScope),
+        installed,
+        ignored
+      }
+    },
+    signal: AbortSignal.timeout(PRESENCE_EVENT_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(response.result.message);
+  }
+  const preferences = response.data.setPublishedSkillPreference;
+  publishedSkillPreferenceCacheVersion += 1;
+  return {
+    scopeKey: preferences.scopeKey,
+    userKey: preferences.userKey,
+    ignoredSkillSlugs: preferences.ignoredSkills.map(item => item.skill.slug),
+    installedGlobalSkillSlugs: [],
+    installedWorkspaceSkillSlugs: []
+  };
+};
+export const setPublishedSkillIgnored = async ({
+  worktree,
+  directory,
+  skillSlug,
+  ignored,
+  preferenceScope
+}) => {
+  const config = await resolveConfig(worktree);
+  const normalizedSkillSlug = toIgnoredSkillSlug(skillSlug);
+  if (!normalizedSkillSlug) {
+    throw new Error('Cannot toggle an empty published skill slug.');
+  }
+  return setPublishedSkillPreference({
+    worktree,
+    directory,
+    config,
+    skillSlug: normalizedSkillSlug,
+    preferenceScope: preferenceScope ?? 'project',
+    ignored
+  });
+};
+export const setPublishedSkillInstalled = async ({
+  worktree,
+  directory,
+  skillSlug,
+  installed,
+  preferenceScope
+}) => {
+  const config = await resolveConfig(worktree);
+  const normalizedSkillSlug = toIgnoredSkillSlug(skillSlug);
+  if (!normalizedSkillSlug) {
+    throw new Error('Cannot toggle an empty published skill slug.');
+  }
+  return setPublishedSkillPreference({
+    worktree,
+    directory,
+    config,
+    skillSlug: normalizedSkillSlug,
+    preferenceScope,
+    installed
+  });
+};
+const getDetailCacheKey = (catalogCacheKey, skillVersionId) => {
+  return JSON.stringify([catalogCacheKey, skillVersionId]);
+};
+const getDetailInflightKey = (catalogCacheKey, skillVersionId, purpose) => {
+  return JSON.stringify([catalogCacheKey, skillVersionId, purpose]);
+};
+export const OpencodeWizardSkillsPlugin = async input => {
+  const {
+    tool
+  } = await importOpencodePluginModule('@opencode-ai/plugin');
+  const config = await resolveConfig(input.worktree);
+  const workspacePath = normalizeAbsolutePath(input.worktree);
+  const cache = new Map();
+  const catalogInflight = new Map();
+  const detailCache = new Map();
+  const detailInflight = new Map();
+  const initialAuthState = await resolveStoredAuthState(input.worktree, config);
+  const loginBootstrap = {
+    promise: null,
+    snapshot: createIdleLoginBootstrapSnapshot()
+  };
+  let lastAuthenticatedAuthState = initialAuthState;
+  let didEmitStart = false;
+  let didScheduleStop = false;
+  let presenceStartPromise = null;
+  let presenceStopPromise = null;
+  let lastInteractiveDirectoryPath = null;
+  const resolveActionAuthState = async () => {
+    const storedAuthState = await resolveStoredAuthState(input.worktree, config);
+    if (storedAuthState) return storedAuthState;
+    return lastAuthenticatedAuthState;
+  };
+  const emitActionEventForCurrentSession = async ({
+    event,
+    authState,
+    directoryPath
+  }) => {
+    await emitPluginActionEvent({
+      config,
+      authState: authState ?? (await resolveActionAuthState()),
+      event,
+      workspacePath,
+      directoryPath
+    });
+  };
+  const schedulePresenceStart = authState => {
+    lastAuthenticatedAuthState = authState;
+    if (didEmitStart) {
+      return presenceStartPromise ?? Promise.resolve();
+    }
+    didEmitStart = true;
+    presenceStartPromise = Promise.all([emitPresenceEvent({
+      config,
+      authState,
+      event: 'START',
+      workspacePath
+    }), emitActionEventForCurrentSession({
+      event: 'START',
+      authState,
+      directoryPath: lastInteractiveDirectoryPath ?? undefined
+    })]).then(() => undefined);
+    return presenceStartPromise;
+  };
+  const schedulePresenceStop = () => {
+    if (didScheduleStop) {
+      return presenceStopPromise ?? Promise.resolve();
+    }
+    didScheduleStop = true;
+    if (!didEmitStart || !lastAuthenticatedAuthState) {
+      presenceStopPromise = Promise.resolve();
+      return presenceStopPromise;
+    }
+    presenceStopPromise = (async () => {
+      await presenceStartPromise?.catch(() => undefined);
+      await Promise.all([emitPresenceEvent({
+        config,
+        authState: lastAuthenticatedAuthState,
+        event: 'STOP',
+        workspacePath
+      }), emitActionEventForCurrentSession({
+        event: 'STOP',
+        authState: lastAuthenticatedAuthState,
+        directoryPath: lastInteractiveDirectoryPath ?? undefined
+      })]);
+    })();
+    return presenceStopPromise;
+  };
+  const scheduleInteractivePresenceStart = async () => {
+    const authState = await resolveStoredAuthState(input.worktree, config);
+    if (!authState) return;
+    await schedulePresenceStart(authState);
+  };
+  process.once('beforeExit', () => {
+    void schedulePresenceStop();
+  });
+  for (const shutdownSignal of PRESENCE_SHUTDOWN_SIGNALS) {
+    try {
+      process.once(shutdownSignal, () => {
+        void schedulePresenceStop().finally(() => {
+          process.exit(PRESENCE_SIGNAL_EXIT_CODES[shutdownSignal]);
+        });
+      });
+    } catch {
+      continue;
+    }
+  }
+  const clearPublishedSkillState = () => {
+    cache.clear();
+    catalogInflight.clear();
+    detailCache.clear();
+    detailInflight.clear();
+  };
+  const persistAuthState = async session => {
+    const authState = toAuthState(session);
+    await writeAuthState(config.authStatePath, authState);
+    clearPublishedSkillState();
+    return authState;
+  };
+  const startLoginCompletion = trigger => {
+    if (loginBootstrap.promise) {
+      return loginBootstrap.promise;
+    }
+    const startedAt = new Date().toISOString();
+    loginBootstrap.snapshot = {
+      status: 'starting',
+      trigger,
+      startedAt,
+      expiresAt: null,
+      browserUrl: null,
+      browserOpenError: null,
+      email: null,
+      message: null
+    };
+    const loginPromise = (async () => {
+      const loginSignal = AbortSignal.timeout(LOGIN_TIMEOUT_MS);
+      let loginStart = null;
+      try {
+        loginStart = await startLoginFlow(loginSignal);
+        const browserOpenError = await openBrowser(loginStart.browserUrl);
+        loginBootstrap.snapshot = {
+          status: 'pending',
+          trigger,
+          startedAt,
+          expiresAt: loginStart.expiresAt,
+          browserUrl: loginStart.browserUrl,
+          browserOpenError,
+          email: null,
+          message: browserOpenError ? `Automatic browser open failed. Open ${loginStart.browserUrl} manually.` : `Browser login started for published skill ${trigger}.`
+        };
+        const callbackPayload = await loginStart.callbackPromise;
+        if (callbackPayload.status === 'error') {
+          throw new Error(callbackPayload.message);
+        }
+        if (callbackPayload.state !== loginStart.expectedState) {
+          throw new Error('OAuth callback state did not match the original login request.');
+        }
+        loginBootstrap.snapshot = {
+          status: 'pending',
+          trigger,
+          startedAt,
+          expiresAt: loginStart.expiresAt,
+          browserUrl: loginStart.browserUrl,
+          browserOpenError,
+          email: null,
+          message: 'OAuth callback received. Finalizing backend session exchange.'
+        };
+        const pluginSession = await createPluginSession({
+          code: callbackPayload.code,
+          codeVerifier: loginStart.codeVerifier,
+          redirectUri: OIDC_CALLBACK_URL,
+          config,
+          signal: loginSignal
+        });
+        const authState = await persistAuthState(pluginSession);
+        await emitActionEventForCurrentSession({
+          event: 'LOGIN_SUCCESS',
+          authState,
+          directoryPath: lastInteractiveDirectoryPath ?? undefined
+        });
+        loginBootstrap.snapshot = {
+          status: 'authenticated',
+          trigger,
+          startedAt,
+          expiresAt: authState.expiresAt,
+          browserUrl: loginStart.browserUrl,
+          browserOpenError,
+          email: authState.email,
+          message: `Browser login completed successfully for published skill ${trigger}.`
+        };
+        return authState;
+      } catch (error) {
+        await emitActionEventForCurrentSession({
+          event: 'LOGIN_FAILED',
+          directoryPath: lastInteractiveDirectoryPath ?? undefined
+        });
+        loginBootstrap.snapshot = {
+          status: 'failed',
+          trigger,
+          startedAt,
+          expiresAt: loginBootstrap.snapshot.expiresAt,
+          browserUrl: loginBootstrap.snapshot.browserUrl,
+          browserOpenError: loginBootstrap.snapshot.browserOpenError,
+          email: null,
+          message: error instanceof Error ? error.message : 'Browser login failed.'
+        };
+        throw error;
+      } finally {
+        await loginStart?.closeCallbackServer().catch(() => undefined);
+        loginBootstrap.promise = null;
+      }
+    })();
+    loginBootstrap.promise = loginPromise;
+    return loginPromise;
+  };
+  const loadPublishedSkillCatalog = async ({
+    directory,
+    useCache,
+    signal
+  }) => {
+    const workspaceResolution = await resolveWorkspace({
+      config,
+      directory
+    });
+    const directoryPath = workspaceResolution.directoryPath;
+    const preferenceContext = await resolvePublishedSkillPreferenceCacheContext(config);
+    const cacheKey = getCatalogCacheKey(workspaceResolution, preferenceContext);
+    const cached = cache.get(cacheKey);
+    if (useCache && cached && cached.expiresAt > Date.now()) {
+      return {
+        directoryPath,
+        workspaceResolution,
+        fetchResult: {
+          ...cached.result,
+          source: 'cache'
+        }
+      };
+    }
+    const inflight = catalogInflight.get(cacheKey);
+    if (inflight) {
+      return inflight;
+    }
+    const requestPromise = (async () => {
+      const fetchResult = await fetchPublishedSkillsCatalog(input.worktree, config, workspaceResolution, signal, clearPublishedSkillState);
+      await maybePersistWorkspaceSlugFromCatalog({
+        config,
+        resolution: workspaceResolution,
+        fetchResult
+      });
+      cache.set(cacheKey, {
+        result: fetchResult,
+        expiresAt: Date.now() + CACHE_TTL_MS
+      });
+      return {
+        directoryPath,
+        workspaceResolution,
+        fetchResult
+      };
+    })();
+    catalogInflight.set(cacheKey, requestPromise);
+    try {
+      return await requestPromise;
+    } finally {
+      catalogInflight.delete(cacheKey);
+    }
+  };
+  const loadPublishedSkillDetail = async ({
+    workspaceResolution,
+    item,
+    signal,
+    useCache,
+    purpose
+  }) => {
+    const directoryPath = workspaceResolution.directoryPath;
+    const preferenceContext = await resolvePublishedSkillPreferenceCacheContext(config);
+    const catalogCacheKey = getCatalogCacheKey(workspaceResolution, preferenceContext);
+    const cacheKey = getDetailCacheKey(catalogCacheKey, item.skillVersion.id);
+    const inflightKey = getDetailInflightKey(catalogCacheKey, item.skillVersion.id, purpose);
+    const cached = detailCache.get(cacheKey);
+    if (useCache && cached && cached.expiresAt > Date.now()) {
+      return {
+        ok: true,
+        detail: toPublishedSkillDetail({
+          ...item,
+          publishedArtifact: cached.artifact
+        })
+      };
+    }
+    const inflight = detailInflight.get(inflightKey);
+    if (inflight) {
+      return inflight;
+    }
+    const requestPromise = (async () => {
+      const detailResult = await fetchPublishedSkillDetail({
+        worktree: input.worktree,
+        config,
+        resolution: workspaceResolution,
+        skillVersionId: item.skillVersion.id,
+        signal,
+        onAuthStateChanged: clearPublishedSkillState,
+        purpose
+      });
+      if (!detailResult.ok) {
+        return {
+          ok: false,
+          status: detailResult.result.status,
+          output: JSON.stringify({
+            pluginId: PLUGIN_ID,
+            runtimeMode: 'tool_fetch_only',
+            status: detailResult.result.status,
+            requestedDirectoryPath: directoryPath,
+            workspaceResolution: toWorkspaceResolutionOutput(workspaceResolution),
+            requestedSkillVersionId: item.skillVersion.id,
+            message: detailResult.result.message,
+            fetchedAt: detailResult.result.fetchedAt,
+            source: detailResult.result.source
+          }, null, 2),
+          metadata: {
+            status: detailResult.result.status,
+            ...toWorkspaceResolutionMetadata(workspaceResolution),
+            source: detailResult.result.source
+          }
+        };
+      }
+      detailCache.set(cacheKey, {
+        artifact: detailResult.artifact,
+        expiresAt: Date.now() + CACHE_TTL_MS
+      });
+      return {
+        ok: true,
+        detail: toPublishedSkillDetail({
+          ...item,
+          publishedArtifact: detailResult.artifact
+        })
+      };
+    })();
+    detailInflight.set(inflightKey, requestPromise);
+    try {
+      return await requestPromise;
+    } finally {
+      detailInflight.delete(inflightKey);
+    }
+  };
+  const executePublishedSkillsFetchTool = async ({
+    args,
+    context
+  }) => {
+    const authState = await resolveStoredAuthState(input.worktree, config);
+    if (!authState || authState.role !== 'ADMIN' && authState.role !== 'EDITOR') {
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'forbidden',
+          message: 'This tool requires ADMIN or EDITOR role. Your current session does not have the required permission.'
+        }, null, 2),
+        metadata: {
+          status: 'forbidden',
+          role: authState?.role ?? 'none'
+        }
+      };
+    }
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    const requestedSkills = parseRequestedSkillArgs(args);
+    const fetchActionDirectoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
+    lastInteractiveDirectoryPath = fetchActionDirectoryPath;
+    const emitFetchOutcome = async event => {
+      await emitActionEventForCurrentSession({
+        event,
+        directoryPath: fetchActionDirectoryPath
+      });
+    };
+    let publishedSkillsResult = await loadPublishedSkillCatalog({
+      directory: requestedDirectory,
+      useCache: !args.refresh,
+      signal: context.abort
+    });
+    if (publishedSkillsResult.fetchResult.ok) {
+      await scheduleInteractivePresenceStart();
+    }
+    if (!publishedSkillsResult.fetchResult.ok && publishedSkillsResult.fetchResult.status === 'missing_auth') {
+      try {
+        await startLoginCompletion('fetch').then(async authState => {
+          await schedulePresenceStart(authState);
+        });
+        publishedSkillsResult = await loadPublishedSkillCatalog({
+          directory: requestedDirectory,
+          useCache: false,
+          signal: context.abort
+        });
+        if (publishedSkillsResult.fetchResult.ok) {
+          await scheduleInteractivePresenceStart();
+        }
+      } catch {
+        // Return the original fetch failure with the latest login bootstrap snapshot attached.
+      }
+    }
+    if (!publishedSkillsResult.fetchResult.ok) {
+      await emitFetchOutcome('FETCH_FAILED');
+      return toFetchFailureOutput({
+        worktree: input.worktree,
+        config,
+        publishedSkillsResult,
+        loginBootstrapSnapshot: loginBootstrap.snapshot
+      });
+    }
+    const filteredPublishedSkillsResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
+    if (!filteredPublishedSkillsResult.fetchResult.ok) {
+      await emitFetchOutcome('FETCH_FAILED');
+      return toFetchFailureOutput({
+        worktree: input.worktree,
+        config,
+        publishedSkillsResult: filteredPublishedSkillsResult,
+        loginBootstrapSnapshot: loginBootstrap.snapshot
+      });
+    }
+    const selection = selectPublishedSkills(filteredPublishedSkillsResult.fetchResult.payload, requestedSkills);
+    const isSingleRequest = requestedSkills.length === 1;
+    if (requestedSkills.length === 0) {
+      const catalog = toPublishedSkillCatalog(filteredPublishedSkillsResult.fetchResult.payload);
+      context.metadata({
+        title: `opencode-wizard published skills catalog: ${catalog.publishedSkillCount} active`,
+        metadata: {
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          status: 'ready',
+          publishedSkillCount: catalog.publishedSkillCount.toString(),
+          globalAssignmentCount: catalog.assignmentCounts.global.toString(),
+          projectAssignmentCount: catalog.assignmentCounts.project.toString(),
+          userAssignmentCount: catalog.assignmentCounts.user.toString(),
+          ignoredSkillCount: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length.toString()
+        }
+      });
+      await emitFetchOutcome('FETCH_SUCCESS');
+      return {
+        output: JSON.stringify({
+          ...catalog,
+          status: 'ready',
+          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
+          ignoredPublishedSkills: {
+            scopeKey: filteredPublishedSkillsResult.ignoreState.scopeKey,
+            count: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length
+          },
+          fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
+          source: filteredPublishedSkillsResult.fetchResult.source,
+          cacheTtlMs: CACHE_TTL_MS,
+          message: args.refresh ? 'Catalog discovery refreshed from the backend. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.' : 'Catalog discovery only. Cached results expire automatically after 30 seconds, or pass `refresh: true` to force a backend refresh immediately. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.'
+        }, null, 2),
+        metadata: {
+          status: 'ready',
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          source: filteredPublishedSkillsResult.fetchResult.source,
+          publishedSkillCount: catalog.publishedSkillCount.toString(),
+          globalAssignmentCount: catalog.assignmentCounts.global.toString(),
+          projectAssignmentCount: catalog.assignmentCounts.project.toString(),
+          userAssignmentCount: catalog.assignmentCounts.user.toString(),
+          ignoredSkillCount: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length.toString()
+        }
+      };
+    }
+    if (selection.selectedItems.length === 0 && isSingleRequest) {
+      await emitFetchOutcome('FETCH_FAILED');
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          runtimeMode: 'tool_fetch_only',
+          status: 'not_found',
+          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
+          requestedSkill: requestedSkills[0],
+          availableSkills: filteredPublishedSkillsResult.fetchResult.payload.skills.map(toPublishedSkillSummary),
+          ignoredPublishedSkills: {
+            scopeKey: filteredPublishedSkillsResult.ignoreState.scopeKey,
+            count: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length
+          }
+        }, null, 2),
+        metadata: {
+          status: 'not_found',
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution)
+        }
+      };
+    }
+    let skillDetailResults = await Promise.all(selection.selectedItems.map(item => loadPublishedSkillDetail({
+      workspaceResolution: filteredPublishedSkillsResult.workspaceResolution,
+      item,
+      signal: context.abort,
+      useCache: !args.refresh,
+      purpose: 'TOOL_FETCH'
+    })));
+    if (skillDetailResults.some(result => !result.ok && result.status === 'missing_auth')) {
+      try {
+        await startLoginCompletion('fetch').then(async authState => {
+          await schedulePresenceStart(authState);
+        });
+        skillDetailResults = await Promise.all(selection.selectedItems.map(item => loadPublishedSkillDetail({
+          workspaceResolution: filteredPublishedSkillsResult.workspaceResolution,
+          item,
+          signal: context.abort,
+          useCache: false,
+          purpose: 'TOOL_FETCH'
+        })));
+      } catch {
+        // Return the original detail failure after the login bootstrap attempt updates snapshot state.
+      }
+    }
+    const failedSkillDetail = skillDetailResults.find(result => !result.ok);
+    if (failedSkillDetail && !failedSkillDetail.ok) {
+      await emitFetchOutcome('FETCH_FAILED');
+      return failedSkillDetail;
+    }
+    const skillDetails = skillDetailResults.map(result => {
+      if (!result.ok) {
+        throw new Error('Published skill detail result unexpectedly missing after success guard.');
+      }
+      return result.detail;
+    });
+    if (isSingleRequest && skillDetails[0]) {
+      const detail = skillDetails[0];
+      context.metadata({
+        title: `opencode-wizard published skill: ${detail.artifactName || detail.skillName}`,
+        metadata: {
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          skillSlug: detail.skillSlug,
+          version: detail.version
+        }
+      });
+      await emitFetchOutcome('FETCH_SUCCESS');
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          runtimeMode: 'tool_fetch_only',
+          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
+          workspace: filteredPublishedSkillsResult.fetchResult.payload.workspace,
+          fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
+          source: filteredPublishedSkillsResult.fetchResult.source,
+          skill: detail
+        }, null, 2),
+        metadata: {
+          status: 'ready',
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          source: filteredPublishedSkillsResult.fetchResult.source,
+          skillSlug: detail.skillSlug
+        }
+      };
+    }
+    context.metadata({
+      title: `opencode-wizard published skills fetch: ${skillDetails.length}`,
+      metadata: {
+        ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+        requestedCount: requestedSkills.length.toString(),
+        matchedCount: skillDetails.length.toString()
+      }
+    });
+    await emitFetchOutcome('FETCH_SUCCESS');
+    return {
+      output: JSON.stringify({
+        pluginId: PLUGIN_ID,
+        runtimeMode: 'tool_fetch_only',
+        requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+        workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
+        workspace: filteredPublishedSkillsResult.fetchResult.payload.workspace,
+        fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
+        source: filteredPublishedSkillsResult.fetchResult.source,
+        requestedSkills,
+        missingSkills: selection.missingIdentifiers,
+        skills: skillDetails
+      }, null, 2),
+      metadata: {
+        status: selection.missingIdentifiers.length > 0 ? 'partial' : 'ready',
+        ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+        source: filteredPublishedSkillsResult.fetchResult.source,
+        matchedCount: skillDetails.length.toString()
+      }
+    };
+  };
+  const executeStatusTool = async ({
+    args,
+    context
+  }) => {
+    const authState = await resolveStoredAuthState(input.worktree, config);
+    if (!authState || authState.role !== 'ADMIN' && authState.role !== 'EDITOR') {
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'forbidden',
+          message: 'This tool requires ADMIN or EDITOR role. Your current session does not have the required permission.'
+        }, null, 2),
+        metadata: {
+          status: 'forbidden',
+          role: authState?.role ?? 'none'
+        }
+      };
+    }
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    let snapshot = await resolvePluginStatusSnapshot({
+      worktree: input.worktree,
+      directory: requestedDirectory,
+      signal: context.abort
+    });
+    if (snapshot.status === 'missing_auth') {
+      try {
+        await startLoginCompletion('status').then(async authState => {
+          await schedulePresenceStart(authState);
+        });
+        snapshot = await resolvePluginStatusSnapshot({
+          worktree: input.worktree,
+          directory: requestedDirectory,
+          signal: context.abort
+        });
+      } catch {
+        // Keep returning the safe missing-auth snapshot when interactive login is cancelled or fails.
+      }
+    }
+    if (snapshot.status === 'ready') {
+      await scheduleInteractivePresenceStart();
+    }
+    const metadata = toPluginStatusMetadata(snapshot);
+    context.metadata({
+      title: `opencode-wizard status: ${snapshot.status} / auth ${snapshot.authState.status}`,
+      metadata
+    });
+    return {
+      output: JSON.stringify(toAiFacingPluginStatusSnapshot(snapshot), null, 2),
+      metadata
+    };
+  };
+  const executePublishedSkillPreferenceTool = async ({
+    args,
+    context
+  }) => {
+    const authState = await resolveStoredAuthState(input.worktree, config);
+    if (!authState || authState.role !== 'ADMIN' && authState.role !== 'EDITOR') {
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'forbidden',
+          message: 'This tool requires ADMIN or EDITOR role. Your current session does not have the required permission.'
+        }, null, 2),
+        metadata: {
+          status: 'forbidden',
+          role: authState?.role ?? 'none'
+        }
+      };
+    }
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    const directoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
+    lastInteractiveDirectoryPath = directoryPath;
+    const requestedSkill = typeof args.skill === 'string' ? args.skill.trim() : '';
+    const emitPreferenceOutcome = async event => {
+      await emitActionEventForCurrentSession({
+        event,
+        directoryPath
+      });
+    };
+    try {
+      if (!requestedSkill) {
+        throw new Error('Published skill preference tool requires a non-empty skill slug, artifact name, or skill name.');
+      }
+      if (typeof args.action !== 'string') {
+        throw new Error('Published skill preference tool requires an action: install, uninstall, ignore, or unignore.');
+      }
+      const action = toPublishedSkillPreferenceAction(args.action);
+      const catalogResult = await loadPublishedSkillCatalog({
+        directory: requestedDirectory,
+        useCache: true,
+        signal: context.abort
+      });
+      if (!catalogResult.fetchResult.ok) {
+        throw new Error(`Cannot resolve published skill preference target: ${catalogResult.fetchResult.message}`);
+      }
+      const selectableCatalogSkills = catalogResult.fetchResult.payload.catalogSkills.map(item => ({
+        ...item,
+        assignmentSource: 'CATALOG',
+        assignmentType: 'PATH',
+        scopePath: '',
+        includeChildren: true
+      }));
+      const preferenceSelection = selectPublishedSkills({
+        ...catalogResult.fetchResult.payload,
+        skills: [...catalogResult.fetchResult.payload.skills, ...selectableCatalogSkills, ...catalogResult.fetchResult.payload.userPreferences.ignoredSkills]
+      }, [requestedSkill]);
+      const matchedSkill = preferenceSelection.selectedItems[0];
+      if (!matchedSkill) {
+        throw new Error(`Published skill preference target was not found for identifier: ${requestedSkill}.`);
+      }
+      const skillSlug = matchedSkill.skill.slug;
+      const preferenceState = action === 'ignore' || action === 'unignore' ? await setPublishedSkillIgnored({
+        worktree: input.worktree,
+        directory: requestedDirectory,
+        skillSlug,
+        ignored: action === 'ignore',
+        preferenceScope: toPublishedSkillPreferenceScope(args.preferenceScope, 'project')
+      }) : await setPublishedSkillInstalled({
+        worktree: input.worktree,
+        directory: requestedDirectory,
+        skillSlug,
+        installed: action === 'install',
+        preferenceScope: toPublishedSkillPreferenceScope(args.preferenceScope, 'project')
+      });
+      await scheduleInteractivePresenceStart();
+      await emitPreferenceOutcome('PREFERENCE_SUCCESS');
+      const metadata = {
+        status: 'updated',
+        skillSlug,
+        action,
+        directoryPath,
+        ignoredSkillCount: preferenceState.ignoredSkillSlugs.length.toString()
+      };
+      context.metadata({
+        title: `opencode-wizard published skill preference: ${action} ${skillSlug}`,
+        metadata
+      });
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'updated',
+          requestedIdentifier: requestedSkill,
+          skillSlug,
+          action,
+          requestedDirectoryPath: directoryPath,
+          preferenceState,
+          message: 'Published skill preference updated through the shared server-backed API; TUI views will reflect this after refresh.'
+        }, null, 2),
+        metadata
+      };
+    } catch (error) {
+      await emitPreferenceOutcome('PREFERENCE_FAILED');
+      throw error;
+    }
+  };
+  const executeEditorPublishSkillTool = async ({
+    args,
+    context
+  }) => {
+    const requestedSkillSlug = args.skillSlug.trim();
+    if (!requestedSkillSlug) {
+      throw new Error('Editor publish requires a non-empty skill slug.');
+    }
+    const authState = await resolveStoredAuthState(input.worktree, config);
+    if (!authState || authState.role !== 'EDITOR') {
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'forbidden',
+          skillSlug: requestedSkillSlug,
+          message: 'This tool requires EDITOR role. Your current session does not have the required editor permission.'
+        }, null, 2),
+        metadata: {
+          status: 'forbidden',
+          role: authState?.role ?? 'none'
+        }
+      };
+    }
+    const requestedDirectory = normalizeDirectoryArg(context.directory, args.directory);
+    const directoryPath = normalizeRepositoryPath(workspacePath, requestedDirectory);
+    lastInteractiveDirectoryPath = directoryPath;
+    const workspaceResolution = await resolveWorkspace({
+      config,
+      directory: requestedDirectory
+    });
+    const repositoryRoot = workspaceResolution.repositoryRoot;
+    const skillFilePath = path.resolve(repositoryRoot, config.rootSkillSeedPath, requestedSkillSlug, 'SKILL.md');
+    let markdownContent;
+    try {
+      markdownContent = await fs.readFile(skillFilePath, 'utf8');
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'file_not_found',
+          skillSlug: requestedSkillSlug,
+          skillFilePath,
+          message: `Skill markdown file not found at ${skillFilePath}: ${message}`
+        }, null, 2),
+        metadata: {
+          status: 'file_not_found',
+          skillSlug: requestedSkillSlug,
+          directoryPath
+        }
+      };
+    }
+    const response = await fetchPublishedSkillsGraphQl({
+      worktree: input.worktree,
+      config,
+      query: CREATE_OR_UPDATE_SKILL_FROM_MARKDOWN_MUTATION,
+      variables: {
+        markdownContent
+      },
+      signal: context.abort
+    });
+    if (!response.ok) {
+      return {
+        output: JSON.stringify({
+          pluginId: PLUGIN_ID,
+          status: 'request_failed',
+          skillSlug: requestedSkillSlug,
+          message: response.result.message
+        }, null, 2),
+        metadata: {
+          status: 'request_failed',
+          skillSlug: requestedSkillSlug,
+          directoryPath
+        }
+      };
+    }
+    const payload = response.data.createOrUpdateSkillFromMarkdown;
+    await scheduleInteractivePresenceStart();
+    return {
+      output: JSON.stringify({
+        pluginId: PLUGIN_ID,
+        status: payload.success ? 'published' : 'publish_failed',
+        skillSlug: payload.skillSlug,
+        skillVersionId: payload.skillVersionId,
+        errors: payload.errors
+      }, null, 2),
+      metadata: {
+        status: payload.success ? 'published' : 'publish_failed',
+        skillSlug: payload.skillSlug,
+        skillVersionId: payload.skillVersionId ?? '',
+        directoryPath
+      }
+    };
+  };
+  const role = initialAuthState?.role ?? null;
+  const hasSharedToolAccess = role === 'ADMIN' || role === 'EDITOR';
+  const isEditor = role === 'EDITOR';
+  const {
+    sharedTools,
+    editorOnlyTools
+  } = createPublishedSkillToolDefinitions(tool, {
+    fetchPublishedSkills: (args, context) => executePublishedSkillsFetchTool({
+      args,
+      context
+    }),
+    updatePublishedSkillPreference: (args, context) => executePublishedSkillPreferenceTool({
+      args,
+      context
+    }),
+    getStatus: (args, context) => executeStatusTool({
+      args,
+      context
+    }),
+    publishEditorSkill: (args, context) => executeEditorPublishSkillTool({
+      args,
+      context
+    })
+  });
+  return {
+    tool: !hasSharedToolAccess ? {} : {
+      ...sharedTools,
+      ...(isEditor ? editorOnlyTools : {})
+    },
+    'experimental.chat.system.transform': async (_hookInput, output) => {
+      let publishedSkillsResult = await loadPublishedSkillCatalog({
+        directory: input.directory,
+        useCache: true,
+        signal: AbortSignal.timeout(5_000)
+      });
+      if (!publishedSkillsResult.fetchResult.ok && publishedSkillsResult.fetchResult.status === 'missing_auth') {
+        try {
+          await startLoginCompletion('status').then(async authState => {
+            await schedulePresenceStart(authState);
+          });
+          publishedSkillsResult = await loadPublishedSkillCatalog({
+            directory: input.directory,
+            useCache: false,
+            signal: AbortSignal.timeout(5_000)
+          });
+        } catch {
+          const loginMessage = loginBootstrap.snapshot.message ? ` Last login status: ${loginBootstrap.snapshot.message}` : '';
+          output.system.push(`opencode-wizard plugin stored auth is missing, expired, or rejected. Startup browser login was started but did not complete successfully.${loginMessage} Use opencode_wizard_status or opencode_wizard_published_skills_fetch to retry authentication when published skills are needed. No tokens are exposed.`);
+          return;
+        }
+        if (!publishedSkillsResult.fetchResult.ok) {
+          output.system.push(`opencode-wizard plugin startup login completed, but published skills are still unavailable: ${publishedSkillsResult.fetchResult.message} No tokens are exposed.`);
+          return;
+        }
+      }
+      if (publishedSkillsResult.fetchResult.ok) {
+        await scheduleInteractivePresenceStart();
+      }
+      const filteredPublishedSkillsResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
+      const systemNote = buildSystemNote(filteredPublishedSkillsResult, config, []);
+      if (!systemNote) return;
+      output.system.push(systemNote);
+    }
+  };
+};
+export default {
+  id: PLUGIN_ID,
+  server: OpencodeWizardSkillsPlugin
+};
+//# sourceMappingURL=runtime.js.map