Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

7.6 KB
Raw Blame
import { SLACK_PIPEDREAM_SLUGS } from '@core/pipedream/slugs';
import type {
  PipedreamConnectionResponse,
  PipedreamProvider,
} from '@service-cognition/client';
import type { ServerResponse } from '@service-cognition/generated/schemas';

export type CapabilityStatus =
  | 'connected'
  | 'off'
  | 'action-required'
  | 'not-connected';

export type CapabilityScope = 'personal' | 'shared';

export type CapabilityMechanism = 'pipedream' | 'native-mcp';

export type ProviderId = CuratedAiProvider;

export type CuratedAiProvider = 'github' | 'linear' | 'notion' | 'slack';

export type CapabilityKind = 'ai';

export type Capability = {
  id: string;
  kind: CapabilityKind;
  provider: ProviderId;
  title: string;
  outcome: string;
  account: string;
  scope: CapabilityScope;
  status: CapabilityStatus;
  mechanism: CapabilityMechanism;
  /** Stored Pipedream slug used to update or remove this connection. */
  appSlug?: string;
  /** Backend holding this connection's grant, for `mechanism: 'pipedream'`. */
  grantProvider?: PipedreamProvider;
  /** Native MCP URL, when this row is that server. */
  sourceUrl?: string;
};

export type Leftover =
  | {
      kind: 'native-mcp';
      id: string;
      title: string;
      subtitle: string;
      url: string;
      enabled: boolean;
      authenticated: boolean;
    }
  | {
      kind: 'pipedream';
      id: string;
      title: string;
      appSlug: string;
      enabled: boolean;
    };

export type ProviderSummary = {
  id: ProviderId;
  name: string;
  ready: number;
  total: number;
  summary: string;
  accounts: string;
};

export type ConnectionsModel = {
  capabilities: Capability[];
  leftovers: Leftover[];
  providers: ProviderSummary[];
};

export type ConnectionsInput = {
  pipedream: PipedreamConnectionResponse[];
  nativeMcp: ServerResponse[];
};

export const CURATED_AI: Record<
  CuratedAiProvider,
  { title: string; outcome: string }
> = {
  github: {
    title: 'GitHub',
    outcome:
      'Macro AI can answer questions about your repos, pull requests, and issues.',
  },
  linear: {
    title: 'Linear',
    outcome:
      'Macro AI can create, read, and update Linear issues without leaving Macro.',
  },
  notion: {
    title: 'Notion',
    outcome: 'Macro AI can search your pages and wikis.',
  },
  slack: {
    title: 'Slack',
    outcome: 'Macro AI can search conversations and post updates for you.',
  },
};

const NATIVE_CURATED: {
  provider: CuratedAiProvider;
  url: string;
}[] = [
  { provider: 'github', url: 'https://api.githubcopilot.com/mcp' },
  { provider: 'linear', url: 'https://mcp.linear.app/mcp' },
  { provider: 'notion', url: 'https://mcp.notion.com/mcp' },
  { provider: 'slack', url: 'https://mcp.slack.com/mcp' },
];

const PROVIDER_NAMES: Record<ProviderId, string> = {
  github: 'GitHub',
  linear: 'Linear',
  notion: 'Notion',
  slack: 'Slack',
};

function nativeCuratedProvider(
  server: ServerResponse
): CuratedAiProvider | null {
  const url = server.url.replace(/\/$/, '');
  return NATIVE_CURATED.find((row) => row.url === url)?.provider ?? null;
}

function pipedreamBySlug(
  connections: PipedreamConnectionResponse[]
): Map<string, PipedreamConnectionResponse> {
  return new Map(connections.map((row) => [row.app_slug, row]));
}

function aiStatus(enabled: boolean): CapabilityStatus {
  return enabled ? 'connected' : 'off';
}

function mcpUrlPreview(url: string): string {
  try {
    const parsed = new URL(url);
    const path = parsed.pathname.replace(/\/$/, '');
    return path ? `${parsed.host}${path}` : parsed.host;
  } catch {
    return url;
  }
}

function leftoverNative(server: ServerResponse): Leftover {
  return {
    kind: 'native-mcp',
    id: `mcp:${server.url}`,
    title: server.server_name,
    subtitle: mcpUrlPreview(server.url),
    url: server.url,
    enabled: server.enabled,
    authenticated: server.authenticated,
  };
}

function curatedAiAndLeftovers(input: ConnectionsInput): {
  capabilities: Capability[];
  leftovers: Leftover[];
} {
  const pipedream = pipedreamBySlug(input.pipedream);
  const usedPipedream = new Set<string>();
  const usedNative = new Set<string>();
  const capabilities: Capability[] = [];
  const leftovers: Leftover[] = [];

  for (const provider of Object.keys(CURATED_AI) as CuratedAiProvider[]) {
    const copy = CURATED_AI[provider];
    // Match backend alias priority before considering enabled state.
    const slugs = provider === 'slack' ? SLACK_PIPEDREAM_SLUGS : [provider];
    const pd = slugs.map((slug) => pipedream.get(slug)).find((row) => row);
    const native = input.nativeMcp.find(
      (server) => nativeCuratedProvider(server) === provider
    );

    if (pd) {
      usedPipedream.add(pd.app_slug);
      capabilities.push({
        id: `${provider}-ai`,
        kind: 'ai',
        provider,
        title: copy.title,
        outcome: copy.outcome,
        account: pd.server_name,
        scope: 'personal',
        status: aiStatus(pd.enabled),
        mechanism: 'pipedream',
        appSlug: pd.app_slug,
        grantProvider: pd.provider,
      });
      if (native) {
        usedNative.add(native.url);
        leftovers.push(leftoverNative(native));
      }
      continue;
    }

    if (native) {
      usedNative.add(native.url);
      capabilities.push({
        id: `${provider}-ai`,
        kind: 'ai',
        provider,
        title: copy.title,
        outcome: copy.outcome,
        account: native.server_name,
        scope: 'personal',
        status: native.authenticated
          ? aiStatus(native.enabled)
          : 'action-required',
        mechanism: 'native-mcp',
        sourceUrl: native.url,
      });
    }
  }

  for (const server of input.nativeMcp) {
    if (usedNative.has(server.url)) continue;
    leftovers.push(leftoverNative(server));
  }

  for (const row of input.pipedream) {
    if (usedPipedream.has(row.app_slug)) continue;
    leftovers.push({
      kind: 'pipedream',
      id: `pipedream:${row.app_slug}`,
      title: row.server_name,
      appSlug: row.app_slug,
      enabled: row.enabled,
    });
  }

  return { capabilities, leftovers };
}

function providerSummary(
  id: ProviderId,
  rows: Capability[]
): ProviderSummary | null {
  const readyRows = rows.filter((row) => row.status === 'connected');
  if (
    readyRows.length === 0 &&
    !rows.some((row) => row.status !== 'not-connected')
  ) {
    return null;
  }

  const accounts = [
    ...new Set(
      rows
        .filter(
          (row) =>
            row.status !== 'not-connected' && row.mechanism !== 'pipedream'
        )
        .map((row) => row.account)
    ),
  ].join(' · ');

  const summary =
    readyRows[0]?.outcome ?? rows[0]?.outcome ?? PROVIDER_NAMES[id];

  return {
    id,
    name: PROVIDER_NAMES[id],
    ready: readyRows.length,
    total: rows.length,
    summary,
    accounts,
  };
}

/** Map connection records into the Connections presentation model. */
export function toConnectionsModel(input: ConnectionsInput): ConnectionsModel {
  const curated = curatedAiAndLeftovers(input);
  const capabilities = [...curated.capabilities];

  const order: ProviderId[] = ['github', 'linear', 'notion', 'slack'];
  const providers = order.flatMap((id) => {
    const summary = providerSummary(
      id,
      capabilities.filter((row) => row.provider === id)
    );
    return summary ? [summary] : [];
  });

  return {
    capabilities,
    leftovers: curated.leftovers,
    providers,
  };
}

export function capabilitiesFor(
  model: ConnectionsModel,
  provider: ProviderId
): Capability[] {
  return model.capabilities.filter((row) => row.provider === provider);
}

export function isConnectionsEmpty(model: ConnectionsModel): boolean {
  return model.providers.length === 0 && model.leftovers.length === 0;
}