@nuvlore/extension-access-pagerduty 0.1.1

package/vendor/extension-sso/src/serviceReadSearch.mjs

@@ -0,0 +1,395 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { extensionReadGet } from "./extensionAccess.mjs";
+import { getWorkdayService, listWorkdayServices } from "./serviceRegistry.mjs";
+import { buildServiceOperationInput, getServiceOperation, readServiceOperation } from "./serviceOperations.mjs";
+
+const EXTENSIONS_DIR = join(dirname(fileURLToPath(import.meta.url)), "../..");
+
+const SEARCH_STRATEGIES = {
+  jira: {
+    mode: "structured-operation",
+    operation: "search",
+    description: "Jira JQL search.",
+    buildParams: ({ query, maxResults = 25, fields }) => ({ jql: query, maxResults, fields })
+  },
+  confluence: {
+    mode: "structured-operation",
+    operation: "search",
+    description: "Confluence CQL search.",
+    buildParams: ({ query, limit = 25, start, expand }) => ({ cql: query, limit, start, expand })
+  },
+  pagerduty: {
+    mode: "structured-operation",
+    operation: "incidents",
+    description: "PagerDuty incident list filtered by status/service/time.",
+    buildParams: ({ statuses, service_ids, since, until, limit = 25 }) => ({ statuses, service_ids, since, until, limit })
+  },
+  repository: {
+    mode: "structured-operation",
+    operation: "search_gavc",
+    description: "Artifactory Maven GAVC search.",
+    buildParams: ({ g, a, v, c, repos }) => ({ g, a, v, c, repos })
+  },
+  pharos: {
+    mode: "structured-operation",
+    operation: "search",
+    description: "Pharos API search endpoint.",
+    buildParams: ({ query, limit = 25 }) => ({ query, limit })
+  },
+  teamcity: {
+    mode: "structured-operation",
+    operation: "builds",
+    description: "TeamCity builds locator search.",
+    buildParams: ({ query, locator, limit = 25 }) => ({ locator: locator ?? query ?? `count:${limit}` })
+  },
+  bamboo: {
+    mode: "structured-operation",
+    operation: "plan_results",
+    description: "Bamboo plan result search. Requires planKey.",
+    required: ["planKey"],
+    buildParams: ({ planKey, maxResults = 25, startIndex, expand }) => ({ planKey, maxResults, startIndex, expand })
+  },
+  bitbucket: {
+    mode: "structured-operation",
+    operation: "pull_requests",
+    description: "Bitbucket pull request list/search. Requires projectKey and repoSlug.",
+    required: ["projectKey", "repoSlug"],
+    buildParams: ({ projectKey, repoSlug, query, limit = 25, start, state = "OPEN" }) => ({
+      projectKey,
+      repoSlug,
+      limit,
+      start,
+      state: query ?? state
+    })
+  },
+  github: {
+    mode: "structured-operation",
+    operation: "issues",
+    description: "GitHub Enterprise repository issue search/list. Requires owner and repo.",
+    required: ["owner", "repo"],
+    buildParams: ({ owner, repo, query, state = "open", per_page = 25 }) => ({
+      owner,
+      repo,
+      state: query ?? state,
+      per_page
+    })
+  },
+  dashboard: {
+    mode: "structured-operation",
+    operation: "discover",
+    description: "Dashboard discover read."
+  },
+  slack: {
+    mode: "specialized-function",
+    description: "Slack keyword search via browser SSO. Supports messages, files, all, and autocomplete scopes.",
+    async execute(input, options) {
+      const {
+        searchSlackAll,
+        searchSlackAutocomplete,
+        searchSlackFiles,
+        searchSlackMessages
+      } = await import("../../access-okta-slack/src/slackSearch.mjs");
+      const commonOptions = {
+        count: input.count,
+        sort: input.sort,
+        sortDir: input.sortDir,
+        highlight: input.highlight,
+        ...options
+      };
+      const scope = String(input.scope || "messages").toLowerCase();
+      if (scope === "all") return searchSlackAll(input.query, commonOptions);
+      if (scope === "files") return searchSlackFiles(input.query, commonOptions);
+      if (scope === "autocomplete") return searchSlackAutocomplete(input.query, { ...commonOptions, types: input.types });
+      return searchSlackMessages(input.query, commonOptions);
+    }
+  },
+  "service-hub": {
+    mode: "specialized-function",
+    description: "Service Hub (ServiceNow) table search via sysparm_query.",
+    async execute(input, options) {
+      const { searchServiceHubTable } = await import("../../access-okta-workday-service-hub/src/serviceHubSessionRead.mjs");
+      if (!input.query) throw new Error("query is required for service-hub search.");
+      return searchServiceHubTable(input.table ?? "incident", input.query, { ...input, ...options });
+    }
+  },
+  collibra: {
+    mode: "specialized-function",
+    description: "Collibra asset name search.",
+    async execute(input, options) {
+      const { searchCollibraAssets } = await import(
+        "../../access-okta-collibra-data-intelligence-platform/src/collibraSessionRead.mjs"
+      );
+      if (!input.query) throw new Error("query is required for collibra search.");
+      return searchCollibraAssets(input.query, { ...input, ...options });
+    }
+  },
+  snyk: {
+    mode: "specialized-function",
+    description: "Snyk project search within an org slug.",
+    required: ["orgSlug"],
+    async execute(input, options) {
+      const { listSnykOrganizations, readSnykCurrentUser, searchSnykProjects } = await import(
+        "../../access-okta-snyk/src/snykSessionRead.mjs"
+      );
+      const scope = String(input.scope || "projects").toLowerCase();
+      if (scope === "me") return readSnykCurrentUser({ ...input, ...options });
+      if (scope === "orgs") return listSnykOrganizations({ ...input, ...options });
+      return searchSnykProjects(input.query ?? "", {
+        ...input,
+        ...options,
+        orgSlug: input.orgSlug ?? input.org
+      });
+    }
+  },
+  "google-drive": {
+    mode: "specialized-function",
+    description: "Google Drive file search via Drive v3 q= query.",
+    async execute(input, options) {
+      const { searchGoogleDriveFiles } = await import(
+        "../../access-okta-workday-google-apps-drive/src/googleDriveSessionRead.mjs"
+      );
+      if (!input.query && !input.mimeType && !input.folderId) {
+        throw new Error("Provide query, mimeType, or folderId for google-drive search.");
+      }
+      return searchGoogleDriveFiles(input, { ...input, ...options });
+    }
+  },
+  mixpanel: {
+    mode: "specialized-function",
+    description: "Mixpanel report search or workspace list.",
+    async execute(input, options) {
+      const { readMixpanelWorkspaces, searchMixpanelReports } = await import(
+        "../../access-okta-mixpanel/src/mixpanelSessionRead.mjs"
+      );
+      const scope = String(input.scope || "reports").toLowerCase();
+      if (scope === "workspaces") return readMixpanelWorkspaces({ ...input, ...options });
+      if (!input.query) throw new Error("query is required for mixpanel report search.");
+      return searchMixpanelReports(input.query, { ...input, ...options });
+    }
+  }
+};
+
+const READ_STRATEGIES = {
+  slack: {
+    mode: "specialized-function",
+    description: "Slack read scopes: ai-capabilities, bot-history, bot-thread.",
+    async execute(input, options) {
+      const scope = String(input.scope || "ai-capabilities").toLowerCase();
+      if (scope === "bot-history") {
+        const { readSlackbotConversations } = await import("../../access-okta-slack/src/slackBotRead.mjs");
+        return readSlackbotConversations({ limit: input.limit, ...options });
+      }
+      if (scope === "bot-thread") {
+        const { readSlackbotThread } = await import("../../access-okta-slack/src/slackBotRead.mjs");
+        if (!input.threadTs) throw new Error("threadTs is required for slack bot-thread read.");
+        return readSlackbotThread(input.threadTs, options);
+      }
+      const { getSlackAiCapabilities } = await import("../../access-okta-slack/src/slackSearch.mjs");
+      return getSlackAiCapabilities(options);
+    }
+  },
+  sana: {
+    mode: "specialized-function",
+    description: "Sana browser-session GET read. Does not send chatbot messages.",
+    async execute(input, options) {
+      const { loadSanaSession, sanaReadGet } = await import("../../access-okta-sana/src/sanaSessionRead.mjs");
+      const session = await loadSanaSession(options);
+      return sanaReadGet(session, input.restPath || input.path || "/", {
+        followRedirects: input.followRedirects,
+        ...options
+      });
+    }
+  },
+  "service-hub": {
+    mode: "specialized-function",
+    description: "Service Hub record read by table + sys_id.",
+    async execute(input, options) {
+      const { readServiceHubRecord } = await import("../../access-okta-workday-service-hub/src/serviceHubSessionRead.mjs");
+      if (!input.table || !input.sysId) throw new Error("table and sysId are required for service-hub read.");
+      return readServiceHubRecord(input.table, input.sysId, { ...input, ...options });
+    }
+  },
+  collibra: {
+    mode: "specialized-function",
+    description: "Collibra asset read or communities list.",
+    async execute(input, options) {
+      const { listCollibraCommunities, readCollibraAsset } = await import(
+        "../../access-okta-collibra-data-intelligence-platform/src/collibraSessionRead.mjs"
+      );
+      if (input.scope === "communities") return listCollibraCommunities({ ...input, ...options });
+      if (!input.assetId) throw new Error("assetId is required for collibra asset read.");
+      return readCollibraAsset(input.assetId, { ...input, ...options });
+    }
+  },
+  snyk: {
+    mode: "specialized-function",
+    description: "Snyk project read by org slug + project id.",
+    async execute(input, options) {
+      const { readSnykProject } = await import("../../access-okta-snyk/src/snykSessionRead.mjs");
+      if (!input.orgSlug && !input.org) throw new Error("orgSlug is required for snyk project read.");
+      if (!input.projectId) throw new Error("projectId is required for snyk project read.");
+      return readSnykProject(input.orgSlug ?? input.org, input.projectId, { ...input, ...options });
+    }
+  },
+  "google-drive": {
+    mode: "specialized-function",
+    description: "Google Drive file read by fileId.",
+    async execute(input, options) {
+      const { readGoogleDriveFile } = await import("../../access-okta-workday-google-apps-drive/src/googleDriveSessionRead.mjs");
+      if (!input.fileId) throw new Error("fileId is required for google-drive file read.");
+      return readGoogleDriveFile(input.fileId, { ...input, ...options });
+    }
+  }
+};
+
+function defaultReadPath(service) {
+  return service.readAccess?.probePath ?? service.readAccess?.restPathPrefix ?? "/";
+}
+
+function serviceSearchCapability(service) {
+  const strategy = SEARCH_STRATEGIES[service.id];
+  if (strategy) {
+    return {
+      mode: strategy.mode,
+      operation: strategy.operation,
+      required: strategy.required ?? [],
+      description: strategy.description
+    };
+  }
+  if (service.readAccess?.oktaAppName) {
+    return {
+      mode: "generic-okta-get",
+      required: ["searchPath"],
+      description: "No stable search API is known. Provide an app-specific GET searchPath and query parameters."
+    };
+  }
+  if (service.readAccess?.mode === "cookie-http" || service.readAccess?.mode === "public-http") {
+    return {
+      mode: "generic-get",
+      required: ["searchPath"],
+      description: "No structured search operation is known. Provide a service-specific GET searchPath and query parameters."
+    };
+  }
+  return {
+    mode: service.readAccess?.mode ?? "unsupported",
+    required: [],
+    description: service.readAccess?.note ?? "Search must use the service-specific read-only workflow or command pack."
+  };
+}
+
+function packageDirFromExtension(extensionName) {
+  const prefix = "@nuvlore/extension-";
+  if (!String(extensionName).startsWith(prefix)) return "";
+  return join(EXTENSIONS_DIR, String(extensionName).slice(prefix.length));
+}
+
+function classifyTool(toolName) {
+  if (/(search|query|discover)/i.test(toolName)) return "search";
+  if (/(ask|chat)/i.test(toolName)) return "chatbot";
+  if (/(sync|export)/i.test(toolName)) return "sync";
+  if (/(verify|status|access)/i.test(toolName)) return "verify";
+  return "read";
+}
+
+function readToolMetadata(filePath) {
+  const text = readFileSync(filePath, "utf8");
+  const name = text.match(/\bname:\s*["']([^"']+)["']/)?.[1];
+  if (!name) return null;
+  const description = text.match(/\bdescription:\s*["']([^"']+)["']/)?.[1] ?? "";
+  return {
+    name,
+    description,
+    category: classifyTool(name),
+    file: filePath.slice(EXTENSIONS_DIR.length + 1)
+  };
+}
+
+export function listServiceSpecializedTools(service) {
+  const packageDir = packageDirFromExtension(service.extension);
+  const toolsDir = packageDir ? join(packageDir, "tools") : "";
+  if (!toolsDir || !existsSync(toolsDir)) return [];
+  return readdirSync(toolsDir)
+    .filter((fileName) => fileName.endsWith(".mjs"))
+    .map((fileName) => readToolMetadata(join(toolsDir, fileName)))
+    .filter(Boolean)
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+export function listServiceReadSearchCapabilities() {
+  return listWorkdayServices().map((service) => ({
+    service: service.id,
+    label: service.label,
+    extension: service.extension,
+    readOnly: service.readAccess?.readOnly !== false,
+    read: {
+      mode: service.readAccess?.mode ?? "unsupported",
+      defaultPath: defaultReadPath(service),
+      oktaAppName: service.readAccess?.oktaAppName,
+      specialized: READ_STRATEGIES[service.id]
+        ? {
+            mode: READ_STRATEGIES[service.id].mode,
+            description: READ_STRATEGIES[service.id].description
+          }
+        : undefined
+    },
+    search: serviceSearchCapability(service),
+    specializedTools: listServiceSpecializedTools(service)
+  })).map((capability) => {
+    const searchTools = capability.specializedTools.filter((tool) => tool.category === "search");
+    if (searchTools.length && String(capability.search.mode).startsWith("generic")) {
+      return {
+        ...capability,
+        search: {
+          mode: "specialized-tools",
+          required: [],
+          tools: searchTools.map((tool) => tool.name),
+          description: "Use the service-specific search/discover tools listed in specializedTools."
+        }
+      };
+    }
+    return capability;
+  });
+}
+
+export async function readAnyService(serviceId, input = {}, options = {}) {
+  const service = getWorkdayService(serviceId);
+  const strategy = READ_STRATEGIES[service.id];
+  if (strategy) {
+    return strategy.execute(input, options);
+  }
+  const restPath = input.restPath || input.path || defaultReadPath(service);
+  return extensionReadGet(service.id, {
+    ...input,
+    restPath
+  }, options);
+}
+
+export async function searchAnyService(serviceId, input = {}, options = {}) {
+  const service = getWorkdayService(serviceId);
+  const strategy = SEARCH_STRATEGIES[service.id];
+  if (strategy) {
+    if (strategy.execute) {
+      return strategy.execute(input, options);
+    }
+    const params = strategy.buildParams ? strategy.buildParams(input) : input;
+    getServiceOperation(service.id, strategy.operation);
+    buildServiceOperationInput(service.id, strategy.operation, params);
+    return readServiceOperation(service.id, strategy.operation, params, options);
+  }
+
+  const searchPath = String(input.searchPath || input.restPath || input.path || "").trim();
+  if (!searchPath) {
+    const capability = serviceSearchCapability(service);
+    throw new Error(
+      `No structured search operation is known for ${service.id}. Provide searchPath for a read-only GET search. Capability: ${capability.description}`
+    );
+  }
+  return extensionReadGet(service.id, {
+    restPath: searchPath,
+    query: input.query,
+    baseUrl: input.baseUrl,
+    allowCookieFallback: input.allowCookieFallback
+  }, options);
+}

package/vendor/extension-sso/src/serviceReads.mjs

@@ -0,0 +1,109 @@
+import { ssoReadGet, ssoReadHtml, verifySsoAccess } from "./ssoHttpRead.mjs";
+import { syncOktaAppCookies } from "./sessionManager.mjs";
+import { getOktaApp } from "./oktaAppCatalog.mjs";
+import { oktaAppHttpRead } from "./oktaAppRead.mjs";
+
+export async function readJiraMyself(options = {}) {
+  return ssoReadGet("jira", { restPath: "/rest/api/latest/myself" }, options);
+}
+
+export async function readJiraProjects(options = {}) {
+  return ssoReadGet("jira", { restPath: "/rest/api/latest/project" }, options);
+}
+
+export async function readJiraSearch(jql, options = {}) {
+  const query = { jql: String(jql || "order by updated DESC"), maxResults: options.maxResults ?? 10 };
+  return ssoReadGet("jira", { restPath: "/rest/api/latest/search", query }, options);
+}
+
+export async function readJiraIssue(issueKey, options = {}) {
+  const key = String(issueKey || "").trim();
+  if (!key) throw new Error("issueKey is required.");
+  return ssoReadGet("jira", { restPath: `/rest/api/latest/issue/${encodeURIComponent(key)}` }, options);
+}
+
+export async function readConfluenceUser(options = {}) {
+  return ssoReadGet("confluence", { restPath: "/rest/api/user/current" }, options);
+}
+
+export async function readConfluenceSpaces(options = {}) {
+  return ssoReadGet("confluence", { restPath: "/rest/api/space", query: { limit: options.limit ?? 25 } }, options);
+}
+
+export async function readBambooInfo(options = {}) {
+  return ssoReadGet("bamboo", { restPath: "/rest/api/latest/info" }, options);
+}
+
+export async function readBambooPlans(options = {}) {
+  return ssoReadGet("bamboo", { restPath: "/rest/api/latest/plan", query: { maxResults: options.limit ?? 25 } }, options);
+}
+
+export async function readGithubProfile(options = {}) {
+  return ssoReadHtml("github", "/settings/profile", { extract: "github-profile" }, options);
+}
+
+export async function readBitbucketSession(options = {}) {
+  return ssoReadHtml("bitbucket", "/login", { extract: "atlassian-session", followRedirects: true }, options);
+}
+
+export async function readPharosHealth(options = {}) {
+  return ssoReadGet("pharos", { restPath: "/api/health" }, options);
+}
+
+export async function readTeamCityLoginPage(options = {}) {
+  return ssoReadHtml("teamcity", "/login.html", { extract: "generic" }, options);
+}
+
+export async function readPagerDutyMe(options = {}) {
+  return ssoReadGet("pagerduty", { restPath: "/api/v2/users/me" }, options);
+}
+
+export async function readRepositoryPing(options = {}) {
+  return ssoReadGet("repository", { restPath: "/artifactory/api/system/ping" }, options);
+}
+
+export async function readOktaApp(appName, input = {}, options = {}) {
+  await syncOktaAppCookies(appName, options);
+  const app = getOktaApp(appName);
+  if (app.serviceId && !input.forceCookie) {
+    const route = SERVICE_READ_DEFAULTS[app.serviceId];
+    if (input.useDefault && route) {
+      return route(input, options);
+    }
+  }
+  return oktaAppHttpRead(appName, input, options);
+}
+
+const SERVICE_READ_DEFAULTS = {
+  jira: (_input, options) => readJiraMyself(options),
+  confluence: (_input, options) => readConfluenceUser(options),
+  bamboo: (_input, options) => readBambooInfo(options),
+  github: (_input, options) => readGithubProfile(options),
+  bitbucket: (_input, options) => readBitbucketSession(options),
+  pharos: (_input, options) => readPharosHealth(options),
+  pagerduty: (_input, options) => readPagerDutyMe(options),
+  repository: (_input, options) => readRepositoryPing(options)
+};
+
+export async function readServiceDefault(serviceId, options = {}) {
+  const reader = SERVICE_READ_DEFAULTS[serviceId];
+  if (!reader) {
+    return verifySsoAccess(serviceId, options);
+  }
+  return reader({}, options);
+}
+
+export function listServiceReadCapabilities() {
+  return {
+    jira: ["myself", "projects", "search", "issue", "project", "project_versions", "user_assignable_search"],
+    confluence: ["user", "spaces", "search", "content", "space", "space_content"],
+    bamboo: ["info", "plans", "plan", "plan_results", "result", "latest_result"],
+    bitbucket: ["session", "projects", "repos", "repo", "pull_request", "pull_requests", "commits"],
+    github: ["profile", "repo", "pull", "issues", "commits"],
+    pharos: ["health", "search", "datasources"],
+    teamcity: ["login-page", "projects", "project", "builds", "build"],
+    pagerduty: ["me", "incidents", "incident", "oncalls", "services"],
+    repository: ["ping", "artifact", "search_gavc", "system_ping"],
+    dashboard: ["discover", "path"]
+  };
+}