@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/shared/integrations.js

@@ -0,0 +1,449 @@
+/**
+ * Integrations Hub — Steer-owned MCP credentials for live external actions.
+ * Memory lives in Supermemory; live actions go through these connections.
+ */
+/** Composio marketplace sidebar groups (same taxonomy as composio.com toolkits). */
+export const COMPOSIO_MARKETPLACE_GROUP_NAMES = [
+    "Artificial Intelligence",
+    "Sales & CRM",
+    "Marketing",
+    "Communication",
+    "Commerce & Payments",
+    "Customer Support",
+    "Developer Tools",
+    "Data & Analytics",
+    "Databases & Storage",
+    "HR & Recruiting",
+];
+export function normalizeMarketplaceCategoryName(name) {
+    return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+export function marketplaceCategorySlug(name) {
+    return normalizeMarketplaceCategoryName(name).replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+/** Fallback ids when Composio category API is unavailable. */
+export function composioMarketplaceGroupCategoriesFallback() {
+    return COMPOSIO_MARKETPLACE_GROUP_NAMES.map((name) => ({
+        id: marketplaceCategorySlug(name),
+        name,
+    }));
+}
+/** Keep only the standard Composio sidebar groups, in display order. */
+export function filterComposioMarketplaceSidebarCategories(categories) {
+    const order = new Map(COMPOSIO_MARKETPLACE_GROUP_NAMES.map((name, index) => [normalizeMarketplaceCategoryName(name), index]));
+    const byNormName = new Map();
+    for (const c of categories) {
+        const norm = normalizeMarketplaceCategoryName(c.name);
+        if (order.has(norm) && !byNormName.has(norm))
+            byNormName.set(norm, c);
+    }
+    return COMPOSIO_MARKETPLACE_GROUP_NAMES.map((name) => {
+        const norm = normalizeMarketplaceCategoryName(name);
+        return byNormName.get(norm) || { id: marketplaceCategorySlug(name), name };
+    });
+}
+/** Map toolkit meta categories onto a canonical Composio sidebar group id. */
+export function resolveToolkitMarketplaceCategory(metaCategories, sidebar) {
+    const byId = new Map(sidebar.map((c) => [c.id, c]));
+    const bySlug = new Map(sidebar.map((c) => [marketplaceCategorySlug(c.name), c]));
+    const byName = new Map(sidebar.map((c) => [normalizeMarketplaceCategoryName(c.name), c]));
+    const raw = Array.isArray(metaCategories) ? metaCategories : [];
+    for (const mc of raw) {
+        const id = mc.id?.trim();
+        if (id && byId.has(id)) {
+            const hit = byId.get(id);
+            return { categoryId: hit.id, categoryLabel: hit.name };
+        }
+        const slug = mc.slug?.trim();
+        if (slug && byId.has(slug)) {
+            const hit = byId.get(slug);
+            return { categoryId: hit.id, categoryLabel: hit.name };
+        }
+        if (slug && bySlug.has(slug)) {
+            const hit = bySlug.get(slug);
+            return { categoryId: hit.id, categoryLabel: hit.name };
+        }
+        const name = mc.name?.trim();
+        if (name) {
+            const hit = byName.get(normalizeMarketplaceCategoryName(name));
+            if (hit)
+                return { categoryId: hit.id, categoryLabel: hit.name };
+        }
+    }
+    return { categoryId: "other", categoryLabel: "Other" };
+}
+export function integrationCatalogPublic() {
+    return INTEGRATION_CATALOG.map(({ id, name, tagline, category, tokenLabel, tokenHelpUrl, templates, accent }) => ({
+        id,
+        name,
+        tagline,
+        category,
+        tokenLabel,
+        tokenHelpUrl,
+        templates,
+        accent,
+    }));
+}
+export const INTEGRATION_CATALOG = [
+    {
+        id: "linear",
+        name: "Linear",
+        tagline: "Read issues and projects; file and update issues from your account.",
+        category: "planning",
+        mcpUrl: "https://mcp.linear.app/mcp",
+        credentialKind: "api_key",
+        composioToolkit: "linear",
+        tokenLabel: "Linear API key",
+        tokenHelpUrl: "https://linear.app/settings/account/security",
+        templates: ["incident", "planning", "support"],
+        accent: "#5e6ad2",
+    },
+    {
+        id: "sentry",
+        name: "Sentry",
+        tagline: "Pull issues, events, and stack traces into incident runs.",
+        category: "observability",
+        mcpUrl: "https://mcp.sentry.dev/mcp",
+        credentialKind: "hosted_oauth",
+        composioToolkit: "sentry",
+        tokenLabel: "Sentry account",
+        tokenHelpUrl: "https://sentry.io/settings/account/api/auth-tokens/",
+        templates: ["incident"],
+        accent: "#e1567c",
+    },
+    {
+        id: "notion",
+        name: "Notion",
+        tagline: "Search specs and docs; append pages when you allow writes.",
+        category: "docs",
+        mcpUrl: "https://mcp.notion.com/mcp",
+        credentialKind: "hosted_oauth",
+        composioToolkit: "notion",
+        tokenLabel: "Notion account",
+        tokenHelpUrl: "https://www.notion.so/my-integrations",
+        templates: ["planning"],
+        accent: "#e4e4e4",
+    },
+    {
+        id: "github",
+        name: "GitHub",
+        tagline: "Issues, discussions, releases, and Actions beyond the git checkout.",
+        category: "code",
+        mcpUrl: "https://api.githubcopilot.com/mcp/",
+        credentialKind: "api_key",
+        composioToolkit: "github",
+        tokenLabel: "GitHub personal access token",
+        tokenHelpUrl: "https://github.com/settings/tokens",
+        templates: ["incident", "planning"],
+        accent: "#8b949e",
+    },
+    {
+        id: "plain",
+        name: "Plain",
+        tagline: "Customer threads and support context for support runs.",
+        category: "support",
+        mcpUrl: "https://mcp.plain.com/mcp",
+        credentialKind: "api_key",
+        composioToolkit: "plain",
+        tokenLabel: "Plain API key",
+        tokenHelpUrl: "https://app.plain.com/settings/api-keys",
+        templates: ["support"],
+        accent: "#3ecf8e",
+    },
+    {
+        id: "posthog",
+        name: "PostHog",
+        tagline: "Query product analytics, flags, and error tracking.",
+        category: "analytics",
+        mcpUrl: "https://mcp.posthog.com/mcp",
+        credentialKind: "api_key",
+        composioToolkit: "posthog",
+        tokenLabel: "PostHog personal API key",
+        tokenHelpUrl: "https://app.posthog.com/settings/user-api-keys",
+        templates: ["incident", "support"],
+        accent: "#f9bd2b",
+    },
+    {
+        id: "custom",
+        name: "Custom MCP",
+        tagline: "Any streamable-HTTP MCP server on the admin allowlist.",
+        category: "custom",
+        mcpUrl: "",
+        credentialKind: "api_key",
+        tokenLabel: "Auth header value",
+        templates: [],
+        accent: "#8ec5ff",
+    },
+];
+export const INTEGRATION_TEMPLATES = {
+    incident: {
+        title: "Incident response",
+        description: "Sentry read + workspace brain, optional Linear write for follow-ups.",
+        read: ["sentry", "github", "posthog"],
+        write: ["linear"],
+    },
+    support: {
+        title: "Support triage",
+        description: "Plain threads + PostHog context, file bugs in Linear from your account.",
+        read: ["plain", "posthog"],
+        write: ["linear"],
+    },
+    planning: {
+        title: "Planning & research",
+        description: "Notion specs + Linear roadmap, no repository required.",
+        read: ["notion", "linear"],
+        write: [],
+    },
+};
+export function catalogItem(id) {
+    return INTEGRATION_CATALOG.find((c) => c.id === id);
+}
+export function composioToolkitSlug(provider) {
+    if (provider === "custom")
+        return undefined;
+    return catalogItem(provider)?.composioToolkit || provider;
+}
+export function providerSupportsComposioOAuth(provider) {
+    return provider !== "custom" && Boolean(composioToolkitSlug(provider));
+}
+export function staticCatalogPublic() {
+    return integrationCatalogPublic();
+}
+export function paginateMarketplaceCatalog(items, opts) {
+    const pageSize = Math.min(Math.max(Math.round(opts.pageSize) || 25, 1), 100);
+    const category = opts.category?.trim();
+    const q = (opts.q || "").trim().toLowerCase();
+    const sort = opts.sort === "name" ? "name" : "popular";
+    let filtered = items;
+    if (category && category !== "all") {
+        filtered = filtered.filter((i) => i.category === category);
+    }
+    if (q) {
+        filtered = filtered.filter((i) => i.name.toLowerCase().includes(q) ||
+            i.id.toLowerCase().includes(q) ||
+            i.tagline.toLowerCase().includes(q) ||
+            String(i.category).toLowerCase().includes(q) ||
+            (i.categoryLabel || "").toLowerCase().includes(q));
+    }
+    if (sort === "name") {
+        filtered = [...filtered].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    const total = filtered.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+    const page = Math.min(Math.max(Math.round(opts.page) || 0, 0), totalPages - 1);
+    const start = page * pageSize;
+    const counts = new Map();
+    for (const i of items) {
+        if (i.id === "custom")
+            continue;
+        const key = String(i.category);
+        counts.set(key, (counts.get(key) || 0) + 1);
+    }
+    let categories;
+    if (opts.categoryCatalog && opts.categoryCatalog.length) {
+        const sidebarSource = filterComposioMarketplaceSidebarCategories(opts.categoryCatalog);
+        categories = sidebarSource
+            .map((c) => ({
+            ...c,
+            count: counts.get(c.id) || 0,
+        }))
+            .filter((c) => (c.count ?? 0) > 0);
+    }
+    else {
+        categories = [...new Set(items.map((i) => String(i.category)))].sort().map((id) => ({
+            id,
+            name: items.find((i) => i.category === id)?.categoryLabel || id,
+            count: counts.get(id) || 0,
+        })).filter((c) => (c.count ?? 0) > 0);
+    }
+    return {
+        catalog: filtered.slice(start, start + pageSize),
+        pagination: { page, pageSize, total, totalPages },
+        categories,
+    };
+}
+export function normalizeMcpUrl(raw) {
+    return raw.trim().replace(/\/+$/, "");
+}
+/** True when connecting to the vendor's default hosted MCP (OAuth-only providers). */
+export function usesDefaultHostedMcp(provider, mcpUrl) {
+    const item = catalogItem(provider);
+    if (!item?.mcpUrl)
+        return false;
+    return normalizeMcpUrl(mcpUrl) === normalizeMcpUrl(item.mcpUrl);
+}
+export function hostedOAuthConnectBlockedMessage(provider) {
+    const item = catalogItem(provider);
+    const name = item?.name || provider;
+    if (provider === "notion") {
+        return (`${name}'s hosted MCP (${item?.mcpUrl}) requires a user OAuth session. Notion internal integration secrets and personal access tokens do not work on that endpoint. ` +
+            "Steer Integrations Hub only supports long-lived API keys today (Linear works this way). Notion support needs an OAuth connect flow — use Linear for now, or point Advanced → MCP URL at a self-hosted MCP bridge that accepts bearer tokens.");
+    }
+    if (provider === "sentry") {
+        return (`${name}'s hosted MCP (${item?.mcpUrl}) only accepts OAuth on the remote HTTP endpoint. Sentry User Auth Tokens work with the local \`@sentry/mcp-server\` stdio transport, not with a pasted Bearer token here. ` +
+            "Steer does not run OAuth for Sentry yet — use Linear, or self-host Sentry MCP and set a custom MCP URL in Advanced.");
+    }
+    return `${name}'s hosted MCP requires OAuth; API keys are not supported on ${item?.mcpUrl}.`;
+}
+/** Turn upstream MCP health-check errors into actionable copy for the Integrations UI. */
+export function formatIntegrationHealthError(provider, mcpUrl, raw) {
+    const msg = raw.trim();
+    const onHostedDefault = usesDefaultHostedMcp(provider, mcpUrl);
+    if (onHostedDefault &&
+        (/invalid_token|invalid access token/i.test(msg) ||
+            /restricted_resource|endpoint unavailable|api token is invalid/i.test(msg))) {
+        if (provider === "notion") {
+            return `${hostedOAuthConnectBlockedMessage("notion")} If your workspace restricts AI apps, a Notion admin must approve this client under Settings → Connections → Permissions.`;
+        }
+        return hostedOAuthConnectBlockedMessage(provider);
+    }
+    return msg.length > 400 ? `${msg.slice(0, 397)}…` : msg;
+}
+export function isIntegrationProvider(v) {
+    return typeof v === "string" && INTEGRATION_CATALOG.some((c) => c.id === v);
+}
+export const DEFAULT_INTEGRATION_POLICY = {
+    externalWrites: "approval",
+    toolAllowlist: [],
+    blockedTools: [],
+    allowCustomMcp: false,
+    customMcpHosts: [],
+    allowLeasing: true,
+    leaseTtlMinutes: 60,
+    leaseSlackNotify: false,
+    instantEnabled: false,
+};
+/** Verbs that change something outside Steer (send, reply, delete, schedule…). */
+const WRITE_VERBS = new Set([
+    "create", "update", "delete", "remove", "add", "set", "post", "comment", "assign", "archive", "close",
+    "reopen", "merge", "send", "edit", "move", "write", "upsert", "patch", "put", "insert", "resolve", "mute",
+    "publish", "invite", "transition", "trigger", "cancel", "rerun", "dispatch", "label", "link", "unlink",
+    "reply", "forward", "draft", "trash", "untrash", "modify", "mark", "star", "unstar", "schedule", "react",
+    "approve", "reject", "accept", "decline", "rename", "copy", "duplicate", "upload", "import", "share",
+    "unshare", "restore", "revoke", "grant", "transfer", "submit", "save", "start", "stop", "run", "execute",
+    "enable", "disable", "pin", "unpin", "follow", "unfollow", "like", "subscribe", "unsubscribe", "block",
+    "unblock", "clear", "purge", "empty", "reset", "book", "pay", "charge", "refund", "notify", "kick", "ban",
+    "unmute", "join", "leave", "upvote", "downvote", "retweet", "tweet",
+]);
+/** Verbs that only read. A tool counts as read-only only with one of these and no write verb. */
+const READ_VERBS = new Set([
+    "get", "list", "search", "fetch", "find", "read", "query", "retrieve", "lookup", "describe", "count",
+    "view", "show", "browse", "preview", "inspect", "download", "export", "check", "status",
+]);
+/**
+ * Apps whose outbound messages are drafted instead of sent. A Drive upload
+ * or a PostHog query is not one of these, so it runs.
+ */
+const OUTBOUND_PROVIDERS = new Set([
+    "gmail", "outlook", "hotmail",
+    "linkedin",
+    "reddit",
+    "twitter", "tweet", "x",
+    "slack",
+    "discord",
+    "whatsapp",
+    "telegram",
+    "facebook",
+    "instagram",
+    "threads",
+    "bluesky", "bsky",
+    "mastodon",
+    "messenger",
+]);
+/** Verbs that deliver a message or post on those apps. */
+const OUTBOUND_VERBS = new Set([
+    "send", "reply", "forward", "post", "comment", "tweet", "retweet",
+    "publish", "message", "dm", "share", "draft", "compose", "react",
+]);
+function toolTokens(name) {
+    return name
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+}
+function tokenIn(verbs, token) {
+    return verbs.has(token) || verbs.has(token.replace(/es$/, "")) || verbs.has(token.replace(/s$/, ""));
+}
+/**
+ * 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 function isOutboundAction(name) {
+    const tokens = toolTokens(name);
+    if (!tokens.some((token) => OUTBOUND_PROVIDERS.has(token)))
+        return false;
+    if (tokens.some((token) => tokenIn(OUTBOUND_VERBS, token)))
+        return true;
+    if (tokens.some((token) => tokenIn(READ_VERBS, token)))
+        return false;
+    return false;
+}
+/**
+ * Classify external tools. A write verb in the name (send, reply, create…)
+ * always wins, even if the provider tagged the tool read-only. Otherwise a
+ * read-only annotation is trusted. Anything else, including unfamiliar verbs,
+ * is a write, so a read-only connection does not expose it. Drafting is
+ * narrower: only {@link isOutboundAction}.
+ */
+const OUTBOUND_ARG_KEYS = new Set([
+    "to",
+    "recipient_email",
+    "recipient",
+    "recipients",
+    "to_email",
+    "to_emails",
+    "cc",
+    "bcc",
+    "subject",
+    "body",
+    "message_body",
+    "html_body",
+]);
+/**
+ * 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 function isOutboundMessage(toolName, args) {
+    if (!args)
+        return false;
+    if (!/(gmail|outlook|e-?mail|mail)/i.test(toolName))
+        return false;
+    return Object.keys(args).some((key) => OUTBOUND_ARG_KEYS.has(key.toLowerCase()));
+}
+export function isWriteTool(name, annotations) {
+    const tokens = toolTokens(name);
+    // Composio often conjugates: SENDS_A_MESSAGE, RETRIEVES, LISTS.
+    if (tokens.some((token) => tokenIn(WRITE_VERBS, token)))
+        return true;
+    if (annotations?.readOnlyHint === true)
+        return false;
+    if (annotations?.destructiveHint === true)
+        return true;
+    return !tokens.some((token) => tokenIn(READ_VERBS, token));
+}
+/** `linear__create_issue` — provider-prefixed, MCP-safe, ≤ 64 chars. */
+export function bundledToolName(provider, tool) {
+    const safe = `${provider}__${tool}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return safe.length <= 64 ? safe : safe.slice(0, 64);
+}
+export function splitBundledToolName(name) {
+    const i = name.indexOf("__");
+    if (i <= 0)
+        return null;
+    return { provider: name.slice(0, i), tool: name.slice(i + 2) };
+}
+export const EXTERNAL_TOOL_PREFIX = "external:";
+export function connectionHealthLabel(h) {
+    switch (h) {
+        case "healthy":
+            return "Healthy";
+        case "error":
+            return "Error";
+        case "expiring":
+            return "Expiring soon";
+        default:
+            return "Not tested";
+    }
+}

package/dist/shared/issueTranscript.d.ts

@@ -0,0 +1,64 @@
+export type IssueTranscriptItemKind = "user" | "assistant" | "thinking" | "tool" | "error";
+export type IssueTranscriptToolStatus = "running" | "done" | "error";
+export interface IssueTranscriptItem {
+    id: string;
+    kind: IssueTranscriptItemKind;
+    text: string;
+    toolName?: string;
+    detail?: string;
+    path?: string;
+    status?: IssueTranscriptToolStatus;
+    runId?: string;
+}
+export interface IssueTranscriptRun {
+    id: string;
+    status: "running" | "finished" | "error" | "cancelled";
+    createdAt?: number | null;
+    durationMs?: number | null;
+    result?: string | null;
+    error?: string | null;
+}
+export interface IssueTranscript {
+    cursorAgentId: string | null;
+    available: boolean;
+    live: boolean;
+    error?: string | null;
+    runs: IssueTranscriptRun[];
+    items: IssueTranscriptItem[];
+}
+export declare function emptyIssueTranscript(partial?: Partial<IssueTranscript>): IssueTranscript;
+export declare function parseStoredTranscriptItems(raw: unknown): IssueTranscriptItem[];
+export declare function applyIssueStreamEvent(items: IssueTranscriptItem[], event: {
+    kind: "user";
+    text: string;
+    runId?: string;
+} | {
+    kind: "assistant";
+    text: string;
+    runId?: string;
+} | {
+    kind: "thinking";
+    text: string;
+    runId?: string;
+} | {
+    kind: "tool_start" | "tool_done";
+    callId: string;
+    name: string;
+    detail?: string;
+    path?: string;
+    runId?: string;
+} | {
+    kind: "error";
+    text: string;
+    runId?: string;
+}): IssueTranscriptItem[];
+/**
+ * Build a chat timeline from listed/hydrated Cursor run metadata.
+ * `run.conversation()` is avoided here — on cloud that replays SSE.
+ */
+export declare function transcriptItemsFromListedRuns(runs: Array<Pick<IssueTranscriptRun, "id" | "status" | "result" | "error">>): IssueTranscriptItem[];
+/**
+ * Flatten Cursor `run.conversation()` turns into a read-only chat timeline.
+ * Pure: does not call Cursor.
+ */
+export declare function conversationTurnsToItems(runId: string, turns: unknown): IssueTranscriptItem[];