@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/shared/events.js

@@ -0,0 +1,59 @@
+/**
+ * Reserved `agentId` for people-to-people chat in the Space. No agent ever
+ * has this id, so these messages never reach an agent's prompt or tab.
+ */
+export const SPACE_CHANNEL_ID = "space";
+export function isSpaceMessage(msg) {
+    return msg.agentId === SPACE_CHANNEL_ID;
+}
+export function isIntegratorAgent(agent) {
+    return agent.kind === "integrator";
+}
+export function isFeatureAgent(agent) {
+    return !isIntegratorAgent(agent);
+}
+/** Keep thinking (and other defined fields) when a later write omits them. */
+export function mergeChatMessage(prev, incoming) {
+    if (!prev || prev.id !== incoming.id)
+        return incoming;
+    const next = { ...prev };
+    for (const [key, value] of Object.entries(incoming)) {
+        if (value === undefined)
+            continue;
+        next[key] = value;
+    }
+    const kept = prev.thinking?.trim() ? prev.thinking : undefined;
+    const nextThinking = incoming.thinking?.trim() ? incoming.thinking : undefined;
+    if (kept && (!nextThinking || kept.length > nextThinking.length)) {
+        next.thinking = kept;
+    }
+    else if (nextThinking) {
+        next.thinking = nextThinking;
+    }
+    return next;
+}
+/**
+ * Kinds that belong in the in-app list and toasts. A room agent finishing a
+ * turn ("run_finished") is routine and only reaches the desktop app; an
+ * automation run finishing ("automation_finished") is shown, since nobody
+ * was watching it.
+ */
+export function isInboxNotification(kind) {
+    return kind !== "run_finished";
+}
+/** Where a notification opens: its link, else its room. */
+export function notificationHref(n) {
+    if (n.href)
+        return n.href;
+    return n.roomId ? `/room/${encodeURIComponent(n.roomId)}` : null;
+}
+export const AVATAR_COLORS = [
+    "#4d9fff",
+    "#3ecf8e",
+    "#e8a23a",
+    "#c084fc",
+    "#f07070",
+    "#38bdf8",
+    "#a3e635",
+    "#fb7185",
+];

package/dist/shared/integrations.d.ts

@@ -0,0 +1,266 @@
+/**
+ * Integrations Hub — Steer-owned MCP credentials for live external actions.
+ * Memory lives in Supermemory; live actions go through these connections.
+ */
+export type IntegrationProvider = "linear" | "sentry" | "notion" | "github" | "plain" | "posthog" | "custom";
+export type IntegrationCategory = "planning" | "observability" | "docs" | "code" | "support" | "analytics" | "custom";
+/** How Steer connects to the provider's default hosted MCP URL. */
+export type IntegrationCredentialKind = "api_key" | "hosted_oauth";
+export interface IntegrationCatalogItem {
+    id: IntegrationProvider;
+    name: string;
+    tagline: string;
+    category: IntegrationCategory;
+    /** Default streamable-HTTP MCP endpoint. Admins can override (self-hosted). */
+    mcpUrl: string;
+    /**
+     * `api_key` — paste a long-lived token (Linear, GitHub PAT, …).
+     * `hosted_oauth` — the vendor's hosted MCP only accepts an OAuth session, not integration/API tokens.
+     */
+    credentialKind: IntegrationCredentialKind;
+    tokenLabel: string;
+    tokenHelpUrl?: string;
+    /** Header used for the credential. Defaults to Authorization: Bearer. */
+    authHeader?: string;
+    /** Composio toolkit slug when using COMPOSIO_API_KEY OAuth bridge. */
+    composioToolkit?: string;
+    /** When false, Composio has no managed OAuth for this toolkit. */
+    composioManagedOAuth?: boolean;
+    templates: Array<"incident" | "support" | "planning">;
+    accent: string;
+}
+export type MarketplaceCategory = {
+    id: string;
+    name: string;
+    count?: number;
+};
+export type MarketplaceSort = "popular" | "name";
+/** Composio marketplace sidebar groups (same taxonomy as composio.com toolkits). */
+export declare const COMPOSIO_MARKETPLACE_GROUP_NAMES: readonly ["Artificial Intelligence", "Sales & CRM", "Marketing", "Communication", "Commerce & Payments", "Customer Support", "Developer Tools", "Data & Analytics", "Databases & Storage", "HR & Recruiting"];
+export declare function normalizeMarketplaceCategoryName(name: string): string;
+export declare function marketplaceCategorySlug(name: string): string;
+/** Fallback ids when Composio category API is unavailable. */
+export declare function composioMarketplaceGroupCategoriesFallback(): MarketplaceCategory[];
+/** Keep only the standard Composio sidebar groups, in display order. */
+export declare function filterComposioMarketplaceSidebarCategories(categories: MarketplaceCategory[]): MarketplaceCategory[];
+/** Map toolkit meta categories onto a canonical Composio sidebar group id. */
+export declare function resolveToolkitMarketplaceCategory(metaCategories: unknown, sidebar: MarketplaceCategory[]): {
+    categoryId: string;
+    categoryLabel: string;
+};
+/** Marketplace card fields returned from the API (no server wiring like composioToolkit / mcpUrl). */
+/** One user-supplied credential field for Composio API-key / custom-auth connect. */
+export type IntegrationConnectCredentialField = {
+    name: string;
+    label: string;
+    description?: string;
+    secret: boolean;
+};
+export type IntegrationCatalogItemPublic = {
+    id: string;
+    name: string;
+    tagline: string;
+    /** Composio category id/slug (or static Steer category when not on Composio). */
+    category: IntegrationCategory | string;
+    /** Human-readable category from Composio meta. */
+    categoryLabel?: string;
+    tokenLabel: string;
+    tokenHelpUrl?: string;
+    templates: Array<"incident" | "support" | "planning">;
+    accent: string;
+    /** When present (Composio catalog), approximate action tool count for this app. */
+    toolsCount?: number;
+    /** Toolkit logo URL from Composio (or elsewhere). */
+    logoUrl?: string | null;
+    /** When false, Composio has no managed OAuth — connect with an API key instead. */
+    composioManagedOAuth?: boolean;
+    /** At least one action in this toolkit can run on Composio Instant (no user account). */
+    instantSupported?: boolean;
+};
+/** Published Instant price for one action. Missing price is unknown, not free. */
+export interface InstantToolPrice {
+    description: string;
+    discount: string | null;
+}
+export declare function integrationCatalogPublic(): IntegrationCatalogItemPublic[];
+export declare const INTEGRATION_CATALOG: IntegrationCatalogItem[];
+export declare const INTEGRATION_TEMPLATES: Record<"incident" | "support" | "planning", {
+    title: string;
+    description: string;
+    read: IntegrationProvider[];
+    write: IntegrationProvider[];
+}>;
+export declare function catalogItem(id: string): IntegrationCatalogItem | undefined;
+export declare function composioToolkitSlug(provider: string): string | undefined;
+export declare function providerSupportsComposioOAuth(provider: string): boolean;
+export declare function staticCatalogPublic(): IntegrationCatalogItemPublic[];
+export interface MarketplaceCatalogPagination {
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+}
+export declare function paginateMarketplaceCatalog(items: IntegrationCatalogItemPublic[], opts: {
+    page: number;
+    pageSize: number;
+    category?: string | null;
+    q?: string | null;
+    sort?: MarketplaceSort | null;
+    categoryCatalog?: MarketplaceCategory[];
+}): {
+    catalog: IntegrationCatalogItemPublic[];
+    pagination: MarketplaceCatalogPagination;
+    categories: MarketplaceCategory[];
+};
+export declare function normalizeMcpUrl(raw: string): string;
+/** True when connecting to the vendor's default hosted MCP (OAuth-only providers). */
+export declare function usesDefaultHostedMcp(provider: string, mcpUrl: string): boolean;
+export declare function hostedOAuthConnectBlockedMessage(provider: string): string;
+/** Turn upstream MCP health-check errors into actionable copy for the Integrations UI. */
+export declare function formatIntegrationHealthError(provider: string, mcpUrl: string, raw: string): string;
+export declare function isIntegrationProvider(v: unknown): v is IntegrationProvider;
+export type ConnectionScope = "org" | "personal";
+export type ConnectionHealth = "healthy" | "error" | "unknown" | "expiring";
+export interface IntegrationToolInfo {
+    name: string;
+    description?: string;
+    write: boolean;
+}
+export interface IntegrationConnectionInfo {
+    id: string;
+    orgId: string;
+    provider: string;
+    scope: ConnectionScope;
+    userId: string | null;
+    userName?: string | null;
+    label: string;
+    mcpUrl: string;
+    authHeader: string;
+    tokenHint: string | null;
+    health: ConnectionHealth;
+    lastCheckedAt: number | null;
+    lastError: string | null;
+    expiresAt: number | null;
+    tools: IntegrationToolInfo[];
+    /** Composio toolkit logo when marketplace cache is warm. */
+    providerLogoUrl?: string | null;
+    /** Custom MCP servers need an admin security review before runs can use them. */
+    securityReviewed: boolean;
+    /**
+     * Team connections only: what agents may do with it. Writes still follow the
+     * team's external-write policy (approval card by default).
+     */
+    teamAccess: TeamConnectionAccess;
+    createdBy: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export type ExternalWritePolicy = "allow" | "approval" | "disabled";
+export type TeamConnectionAccess = "read" | "read_write";
+/** A room's integration setup: team connections are on unless switched off. */
+export interface RoomIntegrationsInfo {
+    /** Team connections, each with whether this room uses it. */
+    team: Array<IntegrationConnectionInfo & {
+        enabledInRoom: boolean;
+    }>;
+    /** The viewer's own connections — used automatically whenever they steer. */
+    mine: IntegrationConnectionInfo[];
+    /** Room owner / editor or team admin. */
+    canManage: boolean;
+}
+export interface IntegrationPolicy {
+    externalWrites: ExternalWritePolicy;
+    /** When non-empty, only these bundled tool names (provider__tool) are exposed. */
+    toolAllowlist: string[];
+    blockedTools: string[];
+    allowCustomMcp: boolean;
+    /** Admin-approved hostnames for Custom MCP URLs. */
+    customMcpHosts: string[];
+    allowLeasing: boolean;
+    leaseTtlMinutes: number;
+    leaseSlackNotify: boolean;
+    /**
+     * When true, rooms may turn on Instant-supported apps that nobody has connected.
+     * Composio bills the Eigen organization; default off.
+     */
+    instantEnabled: boolean;
+}
+export declare const DEFAULT_INTEGRATION_POLICY: IntegrationPolicy;
+export type LeaseStatus = "pending" | "approved" | "denied" | "expired" | "revoked";
+export interface IntegrationLeaseInfo {
+    id: string;
+    orgId: string;
+    connectionId: string;
+    provider: string;
+    ownerUserId: string;
+    ownerName?: string | null;
+    requesterUserId: string;
+    requesterName?: string | null;
+    roomId: string | null;
+    agentId: string | null;
+    reason: string;
+    status: LeaseStatus;
+    ttlMinutes: number;
+    expiresAt: number | null;
+    createdAt: number;
+    decidedAt: number | null;
+}
+export interface IntegrationAuditInfo {
+    id: string;
+    orgId: string;
+    userId: string | null;
+    userName?: string | null;
+    provider: string;
+    tool: string;
+    connectionId: string | null;
+    connectionScope: ConnectionScope | "lease" | "instant" | null;
+    /** `instant_account` when the call ran on Composio Instant. */
+    credentialSource?: string | null;
+    /** USD amount string from Composio when the call was billed as Instant. */
+    instantCharge?: string | null;
+    roomId: string | null;
+    issueId: string | null;
+    swarmId: string | null;
+    agentId: string | null;
+    /** Set when the call came from an automation run. */
+    automationId?: string | null;
+    automationRunId?: string | null;
+    /** Automation name, filled in when the audit is read. */
+    automationName?: string | null;
+    write: boolean;
+    outcome: "ok" | "error" | "blocked" | "approval_requested";
+    error: string | null;
+    createdAt: number;
+}
+/** What a given run gets: resolved per steering user + org. */
+export interface IntegrationBundleSummary {
+    provider: string;
+    label: string;
+    access: "read" | "read_write";
+    via: ConnectionScope | "lease" | "instant";
+    /** Whose account a personal / leased connection acts as. */
+    ownerName?: string | null;
+}
+/**
+ * Mail and social sends (Gmail, LinkedIn, Reddit, Twitter, Slack, and the
+ * same kind of app). Fetches on those apps are not included. Everything else
+ * runs, including uploads and analytics queries.
+ */
+export declare function isOutboundAction(name: string): boolean;
+/**
+ * A call that is trying to deliver a message, even when the tool name looks
+ * read-only. Ask-first automations draft these instead of executing them.
+ */
+export declare function isOutboundMessage(toolName: string, args: Record<string, unknown> | undefined): boolean;
+export declare function isWriteTool(name: string, annotations?: {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+} | null): boolean;
+/** `linear__create_issue` — provider-prefixed, MCP-safe, ≤ 64 chars. */
+export declare function bundledToolName(provider: string, tool: string): string;
+export declare function splitBundledToolName(name: string): {
+    provider: string;
+    tool: string;
+} | null;
+export declare const EXTERNAL_TOOL_PREFIX = "external:";
+export declare function connectionHealthLabel(h: ConnectionHealth): string;