terse-types 0.0.19 → 0.0.21

package/dist/ApiRouteBuilder.d.ts

@@ -114,6 +114,7 @@ export declare const ApiRoutes: {
     INTEGRATIONS: {
         INSTALLATION_DETAILS_BY_TYPE: string;
         LIST: string;
+        DISCONNECT_BY_TYPE: string;
         ACTIVE: string;
     };
     NOTIFICATION_DESTINATIONS: {
@@ -133,6 +134,7 @@ export declare const ApiRoutes: {
     SDK: {
         ME: string;
         SAMPLE_EVENTS: string;
+        HYDRATE_SAMPLE_EVENT: string;
         VERIFY_JOB_SERVER: string;
         TOOL_EXECUTE: string;
         TOOL_DEFINITIONS: string;

package/dist/ApiRoutes.json

@@ -114,6 +114,7 @@
     "INTEGRATIONS": {
         "INSTALLATION_DETAILS_BY_TYPE": "/integrations/:integrationType/installation-details",
         "LIST": "/integrations",
+        "DISCONNECT_BY_TYPE": "/integrations/:integrationType/disconnect",
         "ACTIVE": "/integrations/active"
     },
     "NOTIFICATION_DESTINATIONS": {
@@ -133,6 +134,7 @@
     "SDK": {
         "ME": "/sdk/me",
         "SAMPLE_EVENTS": "/sdk/sample-events",
+        "HYDRATE_SAMPLE_EVENT": "/sdk/sample-events/hydrate",
         "VERIFY_JOB_SERVER": "/sdk/agents/:agentId/verify-job-server",
         "TOOL_EXECUTE": "/sdk/tool-execute",
         "TOOL_DEFINITIONS": "/sdk/tool-definitions",

package/dist/Integrations.d.ts

@@ -230,9 +230,26 @@ export declare const SnowflakeIntegrationSchema: z.ZodObject<{
     schemaName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type SnowflakeIntegration = z.infer<typeof SnowflakeIntegrationSchema>;
+export declare const CliIntegrationDisplayStateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"not_connected">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"connected">;
+    summaryLabel: z.ZodString;
+    summaryValue: z.ZodString;
+    integrationId: z.ZodString;
+}, z.core.$strip>], "status">;
+export type CliIntegrationDisplayState = z.infer<typeof CliIntegrationDisplayStateSchema>;
 export declare const IntegrationWithStatusSchema: z.ZodObject<{
     integrationType: z.ZodEnum<typeof IntegrationType>;
     isActive: z.ZodBoolean;
+    cliDisplayState: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"not_connected">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"connected">;
+        summaryLabel: z.ZodString;
+        summaryValue: z.ZodString;
+        integrationId: z.ZodString;
+    }, z.core.$strip>], "status">;
 }, z.core.$strip>;
 export type IntegrationWithStatus = z.infer<typeof IntegrationWithStatusSchema>;
 export {};

package/dist/Integrations.js

@@ -192,7 +192,19 @@ export const SnowflakeIntegrationSchema = IntegrationInstanceSchema.extend({
     databaseName: z.string().optional(),
     schemaName: z.string().optional()
 });
+export const CliIntegrationDisplayStateSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("not_connected")
+    }),
+    z.object({
+        status: z.literal("connected"),
+        summaryLabel: z.string(),
+        summaryValue: z.string(),
+        integrationId: z.string()
+    })
+]);
 export const IntegrationWithStatusSchema = z.object({
     integrationType: integrationTypeEnum,
-    isActive: z.boolean()
+    isActive: z.boolean(),
+    cliDisplayState: CliIntegrationDisplayStateSchema
 });

package/dist/TriggerPresenters.d.ts

@@ -1,3 +1,8 @@
 import type { Trigger } from "./Triggers.js";
+export interface TriggerDisplay {
+    title: string;
+    subtitle: string;
+}
 export declare function formatTriggerForAgent(event: Trigger): string;
 export declare function debugTrigger(event: Trigger): string;
+export declare function displayTrigger(event: Trigger): TriggerDisplay;

package/dist/TriggerPresenters.js

@@ -2,22 +2,32 @@ import { IntegrationType } from "./Integrations.js";
 const TriggerPresenters = {
     manual_sample: {
         formatForAgent: (event) => `Manual sample event for ${event.integrationType}.`,
-        debug: (event) => `${event.integrationType} ${event.eventType}`
+        debug: (event) => `${event.integrationType} ${event.eventType}`,
+        display: (event) => ({
+            title: `Manual ${event.integrationType} sample`,
+            subtitle: event.eventType
+        })
     },
     [IntegrationType.GITHUB]: {
         formatForAgent: formatGithubTrigger,
-        debug: (event) => `GitHub Event: ${event.eventType} - ${event.repository.owner}/${event.repository.name} - ${event.sender.login}`
+        debug: (event) => `GitHub Event: ${event.eventType} - ${event.repository.owner}/${event.repository.name} - ${event.sender.login}`,
+        display: formatGithubDisplay
     },
     [IntegrationType.SLACK]: {
         formatForAgent: formatSlackTrigger,
         debug: (event) => {
             const isDM = event.channelType === "im";
             return `Slack Event: ${event.eventType} - ${isDM ? "DM" : event.channelName || event.channelId} - ${event.userName || event.userId}`;
-        }
+        },
+        display: formatSlackDisplay
     },
     [IntegrationType.GMAIL]: {
         formatForAgent: formatGmailTrigger,
-        debug: (event) => `Gmail Event: ${event.subject} message ID: ${event.messageId}`
+        debug: (event) => `Gmail Event: ${event.subject} message ID: ${event.messageId}`,
+        display: (event) => ({
+            title: event.subject || "(no subject)",
+            subtitle: `from ${event.from}`
+        })
     },
     [IntegrationType.LINEAR]: {
         formatForAgent: formatLinearTrigger,
@@ -26,23 +36,39 @@ const TriggerPresenters = {
                 return `Linear ${event.type} Event: ${event.data.identifier} - ${event.data.title} (${event.action})`;
             }
             return `Linear ${event.type} Event: Comment on issue ${event.data.issueId || "Unknown"} (${event.action})`;
+        },
+        display: (event) => {
+            if (event.type === "Issue") {
+                return {
+                    title: `${event.data.identifier} ${event.data.title}`,
+                    subtitle: `${event.data.team?.name || "Linear"} · ${event.action} issue`
+                };
+            }
+            return {
+                title: `Comment on ${event.data.issueId || "Unknown issue"}`,
+                subtitle: `${event.actor.name} · ${event.action} comment`
+            };
         }
     },
     [IntegrationType.WORKOS]: {
         formatForAgent: formatWorkOSTrigger,
-        debug: (event) => `WorkOS ${event.eventType}`
+        debug: (event) => `WorkOS ${event.eventType}`,
+        display: formatWorkOSDisplay
     },
     [IntegrationType.WEBHOOK]: {
         formatForAgent: formatWebhookTrigger,
-        debug: (event) => `Webhook Trigger (${event.method})`
+        debug: (event) => `Webhook Trigger (${event.method})`,
+        display: formatWebhookDisplay
     },
     [IntegrationType.CRON_JOB]: {
         formatForAgent: formatCronTrigger,
-        debug: (event) => (event.isManualTrigger ? "Manual Trigger" : "Scheduled Event")
+        debug: (event) => (event.isManualTrigger ? "Manual Trigger" : "Scheduled Event"),
+        display: formatCronDisplay
     },
     [IntegrationType.WEBMONITOR]: {
         formatForAgent: formatWebMonitorTrigger,
-        debug: (event) => `${event.query.slice(0, 80)}${event.query.length > 80 ? "…" : ""}`
+        debug: (event) => `${event.query.slice(0, 80)}${event.query.length > 80 ? "…" : ""}`,
+        display: formatWebMonitorDisplay
     }
 };
 function dispatchPresenter(event, method) {
@@ -77,6 +103,12 @@ export function debugTrigger(event) {
     }
     return dispatchPresenter(event, "debug");
 }
+export function displayTrigger(event) {
+    if (event.eventType === "manual_sample") {
+        return TriggerPresenters.manual_sample.display(event);
+    }
+    return dispatchPresenter(event, "display");
+}
 function formatGithubTrigger(event) {
     const indentMultiline = (text) => text
         .split("\n")
@@ -174,6 +206,122 @@ function formatSlackTrigger(event) {
         : ""}
         `;
 }
+function formatSlackDisplay(event) {
+    const channelLabel = event.channelType === "im" ? "DM" : event.channelName || event.channelId;
+    const actorLabel = event.userName || event.userId;
+    if (event.eventType === "reaction_added") {
+        return {
+            title: `:${event.reaction || "reaction"}: reaction`,
+            subtitle: `${channelLabel} by ${actorLabel}`
+        };
+    }
+    const messageText = event.text?.trim();
+    return {
+        title: messageText && messageText.length > 0 ? truncateForDisplay(messageText, 80) : "(no message text)",
+        subtitle: `${channelLabel} by ${actorLabel}`
+    };
+}
+function truncateForDisplay(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, maxLength - 1)}…` : value;
+}
+function formatGithubDisplay(event) {
+    if (event.pullRequest) {
+        return {
+            title: `#${event.pullRequest.number} ${truncateForDisplay(event.pullRequest.title, 80)}`,
+            subtitle: `${event.repository.owner}/${event.repository.name} · ${event.eventType} by ${event.sender.login}`
+        };
+    }
+    if (event.commits.length > 0) {
+        const latestCommit = event.commits[event.commits.length - 1];
+        const commitMessage = latestCommit.message || latestCommit.name || latestCommit.sha.slice(0, 7);
+        return {
+            title: truncateForDisplay(commitMessage, 80),
+            subtitle: `${event.repository.owner}/${event.repository.name} · ${event.commits.length} commit${event.commits.length === 1 ? "" : "s"} on ${event.branch || "branch"}`
+        };
+    }
+    return {
+        title: `${event.repository.owner}/${event.repository.name}`,
+        subtitle: `${event.eventType} by ${event.sender.login}`
+    };
+}
+function formatWorkOSDisplay(event) {
+    if ("user" in event && event.user) {
+        return {
+            title: event.user.email,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    if ("organization" in event && event.organization) {
+        return {
+            title: event.organization.name,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    if ("invitation" in event && event.invitation) {
+        return {
+            title: event.invitation.email,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    if ("membership" in event && event.membership) {
+        return {
+            title: event.membership.role.slug,
+            subtitle: humanizeWorkOSEventType(event.eventType)
+        };
+    }
+    return {
+        title: "WorkOS event",
+        subtitle: humanizeWorkOSEventType(event.eventType)
+    };
+}
+function humanizeWorkOSEventType(eventType) {
+    return eventType.replaceAll(".", " ");
+}
+function formatWebhookDisplay(event) {
+    const bodyPreview = summarizeUnknown(event.body);
+    return {
+        title: bodyPreview || "Webhook trigger",
+        subtitle: event.method
+    };
+}
+function formatCronDisplay(event) {
+    return {
+        title: event.isManualTrigger ? "Manual trigger" : "Scheduled event",
+        subtitle: event.manualContext ? truncateForDisplay(event.manualContext, 80) : event.inputId
+    };
+}
+function formatWebMonitorDisplay(event) {
+    const sourceLabel = firstHost(event.sourceUrls);
+    const outputPreview = typeof event.payload === "string" ? event.payload : typeof event.rawPayload === "string" ? event.rawPayload : "";
+    return {
+        title: sourceLabel ? `Change detected on ${sourceLabel}` : "Web monitor match",
+        subtitle: truncateForDisplay(outputPreview || event.query, 100)
+    };
+}
+function firstHost(urls) {
+    const first = urls[0];
+    if (!first)
+        return null;
+    try {
+        return new URL(first).host;
+    }
+    catch {
+        return first;
+    }
+}
+function summarizeUnknown(value) {
+    if (typeof value === "string") {
+        return truncateForDisplay(value.trim() || "Webhook trigger", 80);
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const preferred = [record.title, record.subject, record.name, record.action, record.type, record.event].find(v => typeof v === "string" && v.trim().length > 0);
+        if (typeof preferred === "string") {
+            return truncateForDisplay(preferred, 80);
+        }
+    }
+    return "Webhook trigger";
+}
 function formatGmailTrigger(event) {
     const attachmentInfo = event.attachments?.map(attachment => `- ${attachment.filename} ${attachment.isInline ? "Inline" : "Attachment"} (${attachment.mimeType})`).join("\n") || "No attachments";
     return `

package/dist/Triggers.d.ts

@@ -2820,6 +2820,7 @@ export declare function createManualTrigger(params?: {
 }): Trigger;
 export declare function formatTriggerForAgent(event: Trigger): string;
 export declare function debugTrigger(event: Trigger): string;
+export declare function displayTrigger(event: Trigger): SerializedEventDisplay;
 export declare const TriggerArraySchema: z.ZodArray<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
     integrationType: z.ZodLiteral<IntegrationType.SLACK>;
     channelId: z.ZodString;
@@ -3496,6 +3497,11 @@ export declare const TriggerArraySchema: z.ZodArray<z.ZodUnion<readonly [z.ZodDi
     integrationType: z.ZodEnum<typeof IntegrationType>;
     eventType: z.ZodLiteral<"manual_sample">;
 }, z.core.$strip>]>>;
+export declare const serializedEventDisplaySchema: z.ZodObject<{
+    title: z.ZodString;
+    subtitle: z.ZodString;
+}, z.core.$strip>;
+export type SerializedEventDisplay = z.infer<typeof serializedEventDisplaySchema>;
 export declare const serializedEventSchema: z.ZodObject<{
     integrationType: z.ZodEnum<typeof IntegrationType>;
     eventType: z.ZodUnion<readonly [z.ZodEnum<{
@@ -3529,6 +3535,10 @@ export declare const serializedEventSchema: z.ZodObject<{
     }>, z.ZodLiteral<"webhook">, z.ZodLiteral<"cron">, z.ZodLiteral<"webmonitor">, z.ZodLiteral<"manual_sample">]>;
     formattedContent: z.ZodString;
     debugLog: z.ZodString;
+    display: z.ZodOptional<z.ZodObject<{
+        title: z.ZodString;
+        subtitle: z.ZodString;
+    }, z.core.$strip>>;
     data: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
         integrationType: z.ZodLiteral<IntegrationType.SLACK>;
         channelId: z.ZodString;

package/dist/Triggers.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { GitHubEventType, WorkOSEventType, frequencyUnitSchema, gitHubEventTypeSchema, gmailEventTypeSchema, linearEventTypeSchema, slackEventTypeSchema, workOSEventTypeSchema } from "./Configs.js";
 import { IntegrationType, integrationTypeEnum } from "./Integrations.js";
 import { SlackChannelType } from "./SlackTypes.js";
-import { debugTrigger as debugTriggerWithPresenter, formatTriggerForAgent as formatTriggerForAgentWithPresenter } from "./TriggerPresenters.js";
+import { debugTrigger as debugTriggerWithPresenter, displayTrigger as displayTriggerWithPresenter, formatTriggerForAgent as formatTriggerForAgentWithPresenter } from "./TriggerPresenters.js";
 const providerTriggerTypeSchema = z.union([slackEventTypeSchema, gitHubEventTypeSchema, linearEventTypeSchema, gmailEventTypeSchema, workOSEventTypeSchema]);
 const TriggerHeaderSchema = z.object({
     integrationType: integrationTypeEnum,
@@ -474,11 +474,19 @@ export function formatTriggerForAgent(event) {
 export function debugTrigger(event) {
     return debugTriggerWithPresenter(event);
 }
+export function displayTrigger(event) {
+    return displayTriggerWithPresenter(event);
+}
 export const TriggerArraySchema = z.array(TriggerSchema);
+export const serializedEventDisplaySchema = z.object({
+    title: z.string(),
+    subtitle: z.string()
+});
 export const serializedEventSchema = z.object({
     integrationType: integrationTypeEnum,
     eventType: TriggerTypeSchema,
     formattedContent: z.string(),
     debugLog: z.string(),
+    display: serializedEventDisplaySchema.optional(),
     data: TriggerSchema
 });