import {  type SourceControlProviderAuth,  type SourceControlDiscoveryResult,  type SourceControlProviderDiscoveryItem,  type SourceControlProviderKind,  type VcsDiscoveryItem,  type VcsDriverKind,} from "@t3tools/contracts";import { Context, Effect, Layer, Option } from "effect"; import { ServerConfig } from "../config.ts";import * as VcsProcess from "../vcs/VcsProcess.ts"; interface DiscoveryProbe {  readonly label: string;  readonly executable?: string;  readonly versionArgs?: ReadonlyArray<string>;  readonly implemented: boolean;  readonly installHint: string;} type VcsProbe = DiscoveryProbe & {  readonly kind: VcsDriverKind;  readonly executable: string;  readonly versionArgs: ReadonlyArray<string>;}; type ProviderProbe = DiscoveryProbe & {  readonly kind: SourceControlProviderKind;  readonly authArgs?: ReadonlyArray<string>;  readonly parseAuth?: (input: AuthProbeInput) => SourceControlProviderAuth;}; interface AuthProbeInput {  readonly stdout: string;  readonly stderr: string;  readonly exitCode: VcsProcess.VcsProcessOutput["exitCode"];} interface DiscoveryProbeResult<Kind extends string> {  readonly kind: Kind;  readonly label: string;  readonly executable?: string;  readonly implemented: boolean;  readonly status: "available" | "missing";  readonly version: Option.Option<string>;  readonly installHint: string;  readonly detail: Option.Option<string>;} const VCS_PROBES: ReadonlyArray<VcsProbe> = [  {    kind: "git",    label: "Git",    executable: "git",    versionArgs: ["--version"],    implemented: true,    installHint: "Install Git from https://git-scm.com/downloads or with your package manager.",  },  {    kind: "jj",    label: "Jujutsu",    executable: "jj",    versionArgs: ["--version"],    implemented: false,    installHint: "Install Jujutsu with `brew install jj` or from https://github.com/jj-vcs/jj.",  },]; const SOURCE_CONTROL_PROVIDER_PROBES: ReadonlyArray<ProviderProbe> = [  {    kind: "github",    label: "GitHub",    executable: "gh",    versionArgs: ["--version"],    authArgs: ["auth", "status"],    parseAuth: parseGitHubAuth,    implemented: true,    installHint: "Install GitHub CLI with `brew install gh` or from https://cli.github.com/.",  },  {    kind: "gitlab",    label: "GitLab",    executable: "glab",    versionArgs: ["--version"],    authArgs: ["auth", "status"],    parseAuth: parseGitLabAuth,    implemented: true,    installHint:      "Install GitLab CLI with `brew install glab` or from https://gitlab.com/gitlab-org/cli.",  },  {    kind: "azure-devops",    label: "Azure DevOps",    executable: "az",    versionArgs: ["--version"],    authArgs: ["account", "show", "--query", "user.name", "-o", "tsv"],    parseAuth: parseAzureAuth,    implemented: false,    installHint:      "Install Azure CLI with `brew install azure-cli`, then add Azure DevOps support with `az extension add --name azure-devops`.",  },  {    kind: "bitbucket",    label: "Bitbucket",    implemented: false,    installHint: "Bitbucket provider support is not available yet.",  },]; function firstNonEmptyLine(text: string): Option.Option<string> {  const line = text    .split(/\r?\n/)    .map((entry) => entry.trim())    .find((entry) => entry.length > 0);  return line === undefined ? Option.none() : Option.some(line);} function detailFromCause(cause: unknown): Option.Option<string> {  if (cause instanceof Error && cause.message.trim().length > 0) {    return Option.some(cause.message.trim());  }  return Option.none();} function authAccount(account: string | undefined): Option.Option<string> {  const trimmed = account?.trim();  return trimmed === undefined || trimmed.length === 0 ? Option.none() : Option.some(trimmed);} function authHost(host: string | undefined): Option.Option<string> {  const trimmed = host?.trim();  return trimmed === undefined || trimmed.length === 0 ? Option.none() : Option.some(trimmed);} function authDetail(detail: string | undefined): Option.Option<string> {  const trimmed = detail?.trim();  return trimmed === undefined || trimmed.length === 0 ? Option.none() : Option.some(trimmed);} function providerAuth(input: {  readonly status: SourceControlProviderAuth["status"];  readonly account?: string | undefined;  readonly host?: string | undefined;  readonly detail?: string | undefined;}): SourceControlProviderAuth {  return {    status: input.status,    account: authAccount(input.account),    host: authHost(input.host),    detail: authDetail(input.detail),  };} function unknownAuth(detail?: string): SourceControlProviderAuth {  return providerAuth({ status: "unknown", detail });} function combinedAuthOutput(input: AuthProbeInput): string {  return [input.stdout, input.stderr].filter((entry) => entry.trim().length > 0).join("\n");} function sanitizedAuthLines(text: string): ReadonlyArray<string> {  return text    .split(/\r?\n/)    .map((entry) => entry.trim())    .filter((entry) => entry.length > 0)    .filter((entry) => !/^[-\s]*token(?:\s+scopes?)?:/iu.test(entry));} function firstSafeAuthLine(text: string): string | undefined {  return sanitizedAuthLines(text)[0];} function parseCliHost(text: string): string | undefined {  return sanitizedAuthLines(text)    .map((line) => line.replace(/^[^a-z0-9]+/iu, ""))    .find((line) => /^[a-z0-9][a-z0-9.-]*(?::\d+)?$/iu.test(line));} function matchFirst(text: string, patterns: ReadonlyArray<RegExp>): string | undefined {  for (const pattern of patterns) {    const match = pattern.exec(text);    const value = match?.[1]?.trim();    if (value && value.length > 0) return value;  }  return undefined;} function parseGitHubAuth(input: AuthProbeInput): SourceControlProviderAuth {  const output = combinedAuthOutput(input);  const account = matchFirst(output, [    /Logged in to .* account\s+([^\s(]+)/iu,    /Logged in to .* as\s+([^\s(]+)/iu,  ]);  const host = parseCliHost(output);   if (input.exitCode !== 0) {    return providerAuth({      status: "unauthenticated",      host,      detail: firstSafeAuthLine(output) ?? "Run `gh auth login` to authenticate GitHub CLI.",    });  }   if (account) {    return providerAuth({ status: "authenticated", account, host });  }   return providerAuth({    status: "unknown",    host,    detail: firstSafeAuthLine(output) ?? "GitHub CLI auth status could not be parsed.",  });} function parseGitLabAuth(input: AuthProbeInput): SourceControlProviderAuth {  const output = combinedAuthOutput(input);  const account = matchFirst(output, [    /Logged in to .* as\s+([^\s(]+)/iu,    /Logged in to .* account\s+([^\s(]+)/iu,    /account:\s*([^\s(]+)/iu,  ]);  const host = parseCliHost(output);   if (input.exitCode !== 0) {    return providerAuth({      status: "unauthenticated",      host,      detail: firstSafeAuthLine(output) ?? "Run `glab auth login` to authenticate GitLab CLI.",    });  }   if (account) {    return providerAuth({ status: "authenticated", account, host });  }   return providerAuth({    status: "unknown",    host,    detail: firstSafeAuthLine(output) ?? "GitLab CLI auth status could not be parsed.",  });} function parseAzureAuth(input: AuthProbeInput): SourceControlProviderAuth {  const account = input.stdout.trim().split(/\r?\n/)[0]?.trim();   if (input.exitCode !== 0) {    return providerAuth({      status: "unauthenticated",      detail:        firstSafeAuthLine(combinedAuthOutput(input)) ?? "Run `az login` to authenticate Azure CLI.",    });  }   if (account && account.length > 0) {    return providerAuth({ status: "authenticated", account, host: "dev.azure.com" });  }   return providerAuth({    status: "unknown",    host: "dev.azure.com",    detail: "Azure CLI account status could not be parsed.",  });} export interface SourceControlDiscoveryShape {  readonly discover: Effect.Effect<SourceControlDiscoveryResult>;} export class SourceControlDiscovery extends Context.Service<  SourceControlDiscovery,  SourceControlDiscoveryShape>()("t3/source-control/SourceControlDiscovery") {} export const layer = Layer.effect(  SourceControlDiscovery,  Effect.gen(function* () {    const config = yield* ServerConfig;    const process = yield* VcsProcess.VcsProcess;     const probe = <Kind extends VcsDriverKind | SourceControlProviderKind>(      input: DiscoveryProbe & { readonly kind: Kind },    ): Effect.Effect<DiscoveryProbeResult<Kind>> => {      const executable = input.executable;      const versionArgs = input.versionArgs;       if (!executable || !versionArgs) {        return Effect.succeed({          kind: input.kind,          label: input.label,          implemented: input.implemented,          status: "missing" as const,          version: Option.none<string>(),          installHint: input.installHint,          detail: Option.some(input.installHint),        } satisfies DiscoveryProbeResult<Kind>);      }       return process        .run({          operation: "source-control.discovery.probe",          command: executable,          args: versionArgs,          cwd: config.cwd,          timeoutMs: 5_000,          maxOutputBytes: 8_000,          truncateOutputAtMaxBytes: true,        })        .pipe(          Effect.map(            (result) =>              ({                kind: input.kind,                label: input.label,                executable,                implemented: input.implemented,                status: "available" as const,                version: Option.orElse(firstNonEmptyLine(result.stdout), () =>                  firstNonEmptyLine(result.stderr),                ),                installHint: input.installHint,                detail: Option.none<string>(),              }) satisfies DiscoveryProbeResult<Kind>,          ),          Effect.catch((cause) =>            Effect.succeed({              kind: input.kind,              label: input.label,              executable,              implemented: input.implemented,              status: "missing" as const,              version: Option.none<string>(),              installHint: input.installHint,              detail: detailFromCause(cause),            } satisfies DiscoveryProbeResult<Kind>),          ),        );    };     const probeProvider = (input: ProviderProbe) =>      probe(input).pipe(        Effect.flatMap((item) => {          const executable = input.executable;          const authArgs = input.authArgs;          const parseAuth = input.parseAuth;           if (!executable || !authArgs || !parseAuth) {            return Effect.succeed({              ...item,              auth: unknownAuth(input.installHint),            } satisfies SourceControlProviderDiscoveryItem);          }           if (item.status !== "available") {            return Effect.succeed({              ...item,              auth: unknownAuth("CLI is not installed."),            } satisfies SourceControlProviderDiscoveryItem);          }           return process            .run({              operation: "source-control.discovery.auth",              command: executable,              args: authArgs,              cwd: config.cwd,              allowNonZeroExit: true,              timeoutMs: 5_000,              maxOutputBytes: 8_000,              truncateOutputAtMaxBytes: true,            })            .pipe(              Effect.map(                (result) =>                  ({                    ...item,                    auth: parseAuth(result),                  }) satisfies SourceControlProviderDiscoveryItem,              ),              Effect.catch((cause) =>                Effect.succeed({                  ...item,                  auth: unknownAuth(Option.getOrUndefined(detailFromCause(cause))),                } satisfies SourceControlProviderDiscoveryItem),              ),            );        }),      );     return SourceControlDiscovery.of({      discover: Effect.all({        versionControlSystems: Effect.all(          VCS_PROBES.map((entry) => probe(entry)) as ReadonlyArray<Effect.Effect<VcsDiscoveryItem>>,          { concurrency: "unbounded" },        ),        sourceControlProviders: Effect.all(          SOURCE_CONTROL_PROVIDER_PROBES.map((entry) => probeProvider(entry)) as ReadonlyArray<            Effect.Effect<SourceControlProviderDiscoveryItem>          >,          { concurrency: "unbounded" },        ),      }),    });  }),);