@nuvlore/extension-access-jira 0.1.1 → 0.1.2

package/vendor/extension-sso/vendor/extension-browser-sso/src/cookieJar.mjs

@@ -1,132 +0,0 @@
-import { mkdir, readFile, writeFile, chmod } from "node:fs/promises";
-import { dirname } from "node:path";
-
-export async function loadCookieJar(path) {
-  try {
-    const raw = await readFile(path, "utf8");
-    return JSON.parse(raw);
-  } catch (error) {
-    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-
-export async function saveCookieJar(path, jar) {
-  await mkdir(dirname(path), { recursive: true });
-  const payload = {
-    ...jar,
-    version: 1,
-    updatedAt: new Date().toISOString()
-  };
-  await writeFile(path, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
-  await chmod(path, 0o600);
-}
-
-export function mergeCookies(existing = [], incoming = []) {
-  const map = new Map();
-  for (const cookie of [...existing, ...incoming]) {
-    const key = `${cookie.domain}\0${cookie.name}\0${cookie.path || "/"}`;
-    map.set(key, cookie);
-  }
-  return [...map.values()];
-}
-
-export function cookiesForHost(cookies, host) {
-  const normalized = host.toLowerCase().replace(/^\./, "");
-  return cookies.filter((cookie) => {
-    const domain = String(cookie.domain || "").toLowerCase().replace(/^\./, "");
-    return normalized === domain || normalized.endsWith(`.${domain}`) || domain.endsWith(`.${normalized}`);
-  });
-}
-
-function toHeaderByteString(value) {
-  const text = String(value ?? "");
-  return /[^\u0000-\u00ff]/u.test(text) ? encodeURIComponent(text) : text;
-}
-
-export function buildCookieHeader(cookies, host) {
-  return cookiesForHost(cookies, host)
-    .filter((cookie) => cookie.name)
-    .map((cookie) => `${toHeaderByteString(cookie.name)}=${toHeaderByteString(cookie.value)}`)
-    .join("; ");
-}
-
-const SESSION_COOKIE_PATTERN =
-  /^(JSESSIONID|sid|SID|connect\.sid|session|_session|auth|oauth|PDSESSION|atlassian|bitbucket|crowd\.|seraph\.|luf_|DT|ln|idx|__Host-|__Secure-)/i;
-
-export function hasMeaningfulSessionCookies(cookies, host) {
-  return cookiesForHost(cookies, host).some(
-    (cookie) => cookie.httpOnly || SESSION_COOKIE_PATTERN.test(cookie.name) || cookie.name.includes("SESSION")
-  );
-}
-
-export function listCookieHostCandidates(jar, domains = []) {
-  const candidates = [];
-  const seen = new Set();
-  const add = (host) => {
-    const bare = String(host || "").replace(/^\./, "").toLowerCase();
-    if (!bare || seen.has(bare)) return;
-    seen.add(bare);
-    candidates.push(bare);
-  };
-  for (const domain of domains) add(domain);
-  if (jar?.cookies?.length) {
-    for (const cookie of jar.cookies) {
-      const cookieDomain = String(cookie.domain || "").replace(/^\./, "").toLowerCase();
-      for (const domain of domains) {
-        const bare = domain.replace(/^\./, "").toLowerCase();
-        if (cookieDomain === bare || cookieDomain.endsWith(`.${bare}`) || bare.endsWith(`.${cookieDomain}`)) {
-          add(cookieDomain);
-        }
-      }
-    }
-  }
-  return candidates;
-}
-
-export function resolveBestCookieHost(jar, domains = [], { requireSession = false } = {}) {
-  if (!jar?.cookies?.length) {
-    return { host: domains[0] ?? "", cookie: "", hasCookies: false, hasSession: false };
-  }
-  for (const host of listCookieHostCandidates(jar, domains)) {
-    const cookie = buildCookieHeader(jar.cookies, host);
-    if (!cookie) continue;
-    const hasSession = hasMeaningfulSessionCookies(jar.cookies, host);
-    if (!requireSession || hasSession) {
-      return { host, cookie, hasCookies: true, hasSession };
-    }
-  }
-  return { host: domains[0] ?? "", cookie: "", hasCookies: false, hasSession: false };
-}
-
-export function jarSummary(jar, config) {
-  if (!jar?.cookies?.length) {
-    return {
-      authenticated: false,
-      mode: "browser-session",
-      domain: config.domain,
-      message: "No SSO cookie jar. Sign in through your SSO provider in Chrome, or enable browser auto-auth."
-    };
-  }
-  const oktaCookies = cookiesForHost(jar.cookies, config.domain);
-  const valid = jar.authenticated === true && oktaCookies.length > 0;
-  return {
-    authenticated: valid,
-    mode: "browser-session",
-    domain: config.domain,
-    cookieCount: jar.cookies.length,
-    oktaCookieCount: oktaCookies.length,
-    validatedAt: jar.validatedAt ?? null,
-    updatedAt: jar.updatedAt ?? null,
-    domains: [...new Set(jar.cookies.map((cookie) => cookie.domain))].sort()
-  };
-}
-
-export function isValidationFresh(jar, ttlMs, now = Date.now()) {
-  if (!jar?.validatedAt) return false;
-  const validatedAt = Date.parse(jar.validatedAt);
-  if (Number.isNaN(validatedAt)) return false;
-  return now - validatedAt < ttlMs;
-}

package/vendor/extension-sso/vendor/extension-browser-sso/src/extensions/toolkit/devops-data-paths.mjs

@@ -1,222 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { isAbsolute, resolve } from "node:path";
-import { parse as parseYaml } from "yaml";
-
-export class PathText {
-  static normalize(value) {
-    return typeof value === "string" ? value.trim() : "";
-  }
-
-  static resolve(path, cwd = process.cwd()) {
-    const normalized = PathText.normalize(path);
-    if (!normalized) {
-      return "";
-    }
-    return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
-  }
-}
-
-export class EnvTokenExpander {
-  constructor(env = process.env) {
-    this.env = env;
-  }
-
-  expand(value) {
-    if (typeof value !== "string") {
-      return "";
-    }
-    return value.replace(
-      /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g,
-      (_match, name, fallback = "") => this.env[name] ?? fallback,
-    );
-  }
-}
-
-export class DevopsDataConfigLoader {
-  constructor(env = process.env) {
-    this.env = env;
-  }
-
-  configPath() {
-    return PathText.resolve(this.env.DEVOPS_DATA_CONFIG ?? "config/devops-data.yaml");
-  }
-
-  load() {
-    const path = this.configPath();
-    if (!existsSync(path)) {
-      return {};
-    }
-
-    const parsed = parseYaml(readFileSync(path, "utf8")) ?? {};
-    return parsed.spec?.groups
-      ? { dataRoot: parsed.spec.dataRoot, ...parsed.spec.groups }
-      : parsed;
-  }
-}
-
-export class DevopsDataLayout {
-  constructor(config = {}, env = process.env) {
-    this.config = config;
-    this.env = env;
-    this.expander = new EnvTokenExpander(env);
-  }
-
-  dataRoot() {
-    return PathText.resolve(
-      this.env.DEVOPS_DATA_ROOT ??
-        (this.env.DEVOPS_HOME ? `${this.env.DEVOPS_HOME}/data` : undefined) ??
-        (this.expander.expand(this.config.dataRoot) || undefined) ??
-        `${homedir()}/.devops-tool/data`,
-    );
-  }
-
-  value(path) {
-    return path.split(".").reduce((current, segment) => {
-      if (!current || typeof current !== "object") {
-        return undefined;
-      }
-      return current[segment];
-    }, this.config);
-  }
-
-  configuredPath(configKey, fallback) {
-    const configured = this.expander.expand(this.value(configKey));
-    if (!configured) {
-      return fallback;
-    }
-    return isAbsolute(configured) ? configured : resolve(this.dataRoot(), configured);
-  }
-}
-
-export class DevopsDataPathResolver {
-  constructor(env = process.env, config = new DevopsDataConfigLoader(env).load()) {
-    this.env = env;
-    this.layout = new DevopsDataLayout(config, env);
-  }
-
-  root() {
-    return this.layout.dataRoot();
-  }
-
-  dataPath(...segments) {
-    return resolve(this.root(), ...segments);
-  }
-
-  cachePath(...segments) {
-    return this.dataPath("cache", ...segments);
-  }
-
-  projectPath(...segments) {
-    return this.dataPath("project", ...segments);
-  }
-
-  runtimePath(...segments) {
-    return this.dataPath("runtime", ...segments);
-  }
-
-  configuredDataPath(envName, configKey, fallback) {
-    const envPath = PathText.resolve(this.env[envName]);
-    if (envPath) {
-      return envPath;
-    }
-    return this.layout.configuredPath(configKey, fallback);
-  }
-
-  codexSessionRoot() {
-    return this.configuredDataPath(
-      "DEVOPS_CODEX_SESSION_ROOT",
-      "project.sessions",
-      this.projectPath("sessions", "codex"),
-    );
-  }
-
-  codexMemoryRoot() {
-    return this.configuredDataPath(
-      "DEVOPS_CODEX_MEMORY_ROOT",
-      "project.codexMemory",
-      this.projectPath("memory", "codex"),
-    );
-  }
-
-  generatedOutputRoot() {
-    return this.configuredDataPath(
-      "DEVOPS_GENERATED_ROOT",
-      "project.generated",
-      this.projectPath("generated"),
-    );
-  }
-
-  tempDataRoot() {
-    return this.configuredDataPath("DEVOPS_TMP_ROOT", "tmp", this.dataPath("tmp"));
-  }
-
-  summary() {
-    return {
-      dataRoot: this.root(),
-      runtime: {
-        claude: this.runtimePath("claude"),
-        npm: this.runtimePath("npm"),
-        cache: this.runtimePath("cache"),
-        config: this.runtimePath("config"),
-      },
-      project: {
-        agentMemory: this.projectPath("agent-memory-local"),
-        memory: this.projectPath("memory"),
-        codexMemory: this.codexMemoryRoot(),
-        sessions: this.codexSessionRoot(),
-        generated: this.generatedOutputRoot(),
-      },
-      cache: {},
-      tmp: this.tempDataRoot(),
-    };
-  }
-}
-
-function resolver(env = process.env) {
-  return new DevopsDataPathResolver(env);
-}
-
-export function devopsDataRoot(env = process.env) {
-  return resolver(env).root();
-}
-
-export function devopsDataPath(...segments) {
-  return resolver().dataPath(...segments);
-}
-
-export function devopsCachePath(...segments) {
-  return resolver().cachePath(...segments);
-}
-
-export function devopsProjectDataPath(...segments) {
-  return resolver().projectPath(...segments);
-}
-
-export function devopsRuntimeDataPath(...segments) {
-  return resolver().runtimePath(...segments);
-}
-
-export function configuredDataPath(envName, configKey, fallback) {
-  return resolver().configuredDataPath(envName, configKey, fallback);
-}
-
-export function codexSessionRoot() {
-  return resolver().codexSessionRoot();
-}
-
-export function codexMemoryRoot() {
-  return resolver().codexMemoryRoot();
-}
-
-export function generatedOutputRoot() {
-  return resolver().generatedOutputRoot();
-}
-
-export function tempDataRoot() {
-  return resolver().tempDataRoot();
-}
-
-export function dataPathSummary() {
-  return resolver().summary();
-}