wizards 0.1.9

package/apps/runtime/dist/engenty/connections-sdk/storage-capability.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+/**
+ * Synthesize the write actions for a connector's storage capability, the
+ * counterpart of `filesCapabilityActions`. `files_write`/`files_move` are
+ * `group: "write"` and `files_delete` is `group: "destructive"`, so the
+ * projected gateway operations inherit the ask-by-default policy, approval
+ * flow, and audit with no extra code. Refs share the read capability's
+ * semantics (provider-relative to the connection root).
+ */
+export function storageCapabilityActions(storage, providerScopes) {
+    const scopes = providerScopes ?? [];
+    const writeAction = {
+        description: "Write (create or overwrite) a file. Pass folder_ref: null for the connection root. Provide the content as content_text for text or content_base64 for binary — exactly one of the two.",
+        group: "write",
+        id: "files_write",
+        inputSchema: z.object({
+            content_base64: z
+                .string()
+                .optional()
+                .describe("Base64-encoded file bytes (binary content)."),
+            content_text: z
+                .string()
+                .optional()
+                .describe("UTF-8 text content (text files)."),
+            folder_ref: z
+                .string()
+                .nullable()
+                .describe("Folder to write into; null targets the connection root."),
+            mime_type: z
+                .string()
+                .nullish()
+                .describe("Content type; inferred from the name when omitted."),
+            name: z.string().min(1).max(512).describe("File name."),
+        }),
+        providerScopes: scopes,
+        summary: "Write a file",
+        handler: (input, ctx) => {
+            const write = input;
+            const hasText = typeof write.content_text === "string";
+            const hasBase64 = typeof write.content_base64 === "string";
+            if (hasText === hasBase64) {
+                throw new Error("files_write: provide exactly one of content_text or content_base64");
+            }
+            return storage.write(ctx, write);
+        },
+    };
+    const deleteAction = {
+        description: "Permanently delete a file from the connected storage. This cannot be undone.",
+        group: "destructive",
+        id: "files_delete",
+        inputSchema: z.object({
+            ref: z.string().min(1).describe("File ref to delete (an entry's ref)."),
+        }),
+        providerScopes: scopes,
+        summary: "Delete a file",
+        handler: (input, ctx) => storage.delete(ctx, input),
+    };
+    const actions = [writeAction, deleteAction];
+    if (storage.move) {
+        const move = storage.move.bind(storage);
+        actions.push({
+            description: "Move (or rename) a file to another folder. Pass to_folder_ref: null for the connection root.",
+            group: "write",
+            id: "files_move",
+            inputSchema: z.object({
+                new_name: z
+                    .string()
+                    .min(1)
+                    .max(512)
+                    .optional()
+                    .describe("Rename while moving; keeps the current name if omitted."),
+                ref: z.string().min(1).describe("File ref to move."),
+                to_folder_ref: z
+                    .string()
+                    .nullable()
+                    .describe("Destination folder; null targets the connection root."),
+            }),
+            providerScopes: scopes,
+            summary: "Move or rename a file",
+            handler: (input, ctx) => move(ctx, input),
+        });
+    }
+    return actions;
+}

package/apps/runtime/dist/engenty/connections-sdk/types.js

@@ -0,0 +1,30 @@
+export const ACTION_GROUP_CONTRACTS = {
+    read: { idempotent: true, requiresApproval: false, riskLevel: "low" },
+    write: { idempotent: false, requiresApproval: true, riskLevel: "medium" },
+    destructive: { idempotent: false, requiresApproval: true, riskLevel: "high" },
+};
+/** Default connection policy per group when the user has not overridden it. */
+export const ACTION_GROUP_DEFAULT_POLICY = {
+    read: "allow",
+    write: "ask",
+    destructive: "ask",
+};
+export function connectorOperationId(connector, actionId) {
+    return `${connector.toolPrefix}_${actionId}`;
+}
+/** Union of provider scopes for the given groups (plus base scopes). */
+export function scopesForGroups(connector, groups) {
+    if (connector.auth.kind !== "oauth2") {
+        return [];
+    }
+    const scopes = new Set(connector.auth.oauth2.baseScopes);
+    for (const action of connector.actions) {
+        if (!groups.has(action.group)) {
+            continue;
+        }
+        for (const scope of action.providerScopes ?? []) {
+            scopes.add(scope);
+        }
+    }
+    return [...scopes];
+}

package/apps/runtime/dist/engenty/connections-slack/connector.js

@@ -0,0 +1,360 @@
+import { defineConnector, } from "../shims/connections-sdk.js";
+import { z } from "zod";
+/**
+ * Every user scope the Slack connector's actions need. Slack's OAuth v2
+ * user-token flow expects USER scopes in the `user_scope` query parameter —
+ * the `scope` parameter is reserved for BOT scopes. The generic SDK
+ * (`buildAuthorizationUrl`) only writes into `scope`, so:
+ *
+ * - `baseScopes` and every action's `providerScopes` are deliberately `[]`
+ *   (an empty `scope` param means "no bot scopes", which is what we want), and
+ * - the full user scope set is passed statically via
+ *   `extraAuthParams.user_scope` instead of incrementally per action group.
+ */
+export const SLACK_USER_SCOPES = [
+    "channels:read",
+    "groups:read",
+    "channels:history",
+    "groups:history",
+    "search:read",
+    "chat:write",
+    "reactions:write",
+    "users:read",
+];
+const SLACK_API_BASE = "https://slack.com/api";
+/**
+ * Call a Slack Web API method. Slack returns HTTP 200 with
+ * `{ ok: false, error }` on application-level failures, so both the HTTP
+ * status and the body's `ok` flag must be checked.
+ */
+async function slackApi(ctx, method, params = {}) {
+    const body = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            body.set(key, String(value));
+        }
+    }
+    const response = await ctx.fetchImpl(`${SLACK_API_BASE}/${method}`, {
+        body,
+        headers: {
+            authorization: `Bearer ${ctx.accessToken}`,
+            "content-type": "application/x-www-form-urlencoded",
+        },
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(`slack_http_error: ${method} returned ${response.status}`);
+    }
+    const data = (await response.json());
+    if (!data.ok) {
+        throw new Error(`slack_api_error: ${data.error ?? "unknown_error"}`);
+    }
+    return data;
+}
+function mapMessage(message) {
+    return {
+        reply_count: message.reply_count ?? 0,
+        subtype: message.subtype ?? null,
+        text: message.text ?? "",
+        thread_ts: message.thread_ts ?? null,
+        ts: message.ts,
+        user: message.user ?? null,
+    };
+}
+const listChannelsInput = z.object({
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .optional()
+        .describe("Maximum number of channels to return (1-50, default 50)."),
+});
+const getChannelHistoryInput = z.object({
+    channel: z
+        .string()
+        .describe("Channel ID to fetch history for (e.g. C0123456789)."),
+    latest: z
+        .string()
+        .optional()
+        .describe("Only messages before this Slack timestamp (exclusive)."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(25)
+        .optional()
+        .describe("Maximum number of messages to return (1-25, default 25)."),
+    oldest: z
+        .string()
+        .optional()
+        .describe("Only messages after this Slack timestamp (exclusive)."),
+});
+const getThreadRepliesInput = z.object({
+    channel: z.string().describe("Channel ID the thread lives in."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(25)
+        .optional()
+        .describe("Maximum number of replies to return (1-25, default 25)."),
+    thread_ts: z
+        .string()
+        .describe("Timestamp of the thread's parent message (e.g. 1712345678.000100)."),
+});
+const searchMessagesInput = z.object({
+    count: z
+        .number()
+        .int()
+        .min(1)
+        .max(25)
+        .optional()
+        .describe("Maximum number of matches to return (1-25, default 25)."),
+    query: z
+        .string()
+        .describe("Search query; supports Slack search modifiers like in:#channel or from:@user."),
+});
+const listUsersInput = z.object({
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .optional()
+        .describe("Maximum number of users to return (1-50, default 50)."),
+});
+const postMessageInput = z.object({
+    channel: z
+        .string()
+        .describe("Channel ID (or user ID for a DM) to post the message to."),
+    text: z.string().describe("Message text (Slack mrkdwn)."),
+    thread_ts: z
+        .string()
+        .optional()
+        .describe("Parent message timestamp to reply in a thread instead of the channel."),
+});
+const updateMessageInput = z.object({
+    channel: z.string().describe("Channel ID containing the message to update."),
+    text: z.string().describe("New message text (replaces the previous text)."),
+    ts: z.string().describe("Timestamp of the message to update."),
+});
+const addReactionInput = z.object({
+    channel: z
+        .string()
+        .describe("Channel ID containing the message to react to."),
+    emoji: z
+        .string()
+        .describe("Emoji name without colons (e.g. thumbsup, white_check_mark)."),
+    ts: z.string().describe("Timestamp of the message to react to."),
+});
+// Per-action providerScopes are [] on purpose — see SLACK_USER_SCOPES above:
+// Slack user scopes are requested via extraAuthParams.user_scope, not through
+// the SDK's incremental `scope` machinery (which would send them as bot scopes).
+const actions = [
+    {
+        description: "List public and private Slack channels the connected user can see, excluding archived ones.",
+        group: "read",
+        handler: async (input, ctx) => {
+            const args = listChannelsInput.parse(input);
+            const data = await slackApi(ctx, "conversations.list", {
+                exclude_archived: true,
+                limit: args.limit ?? 50,
+                types: "public_channel,private_channel",
+            });
+            return {
+                channels: (data.channels ?? []).map((channel) => ({
+                    id: channel.id,
+                    is_private: channel.is_private ?? false,
+                    name: channel.name ?? "",
+                    num_members: channel.num_members ?? 0,
+                    topic: channel.topic?.value ?? "",
+                })),
+            };
+        },
+        id: "list_channels",
+        inputSchema: listChannelsInput,
+        providerScopes: [],
+        summary: "List Slack channels",
+    },
+    {
+        description: "Fetch recent messages from a Slack channel, newest first.",
+        group: "read",
+        handler: async (input, ctx) => {
+            const args = getChannelHistoryInput.parse(input);
+            const data = await slackApi(ctx, "conversations.history", {
+                channel: args.channel,
+                latest: args.latest,
+                limit: args.limit ?? 25,
+                oldest: args.oldest,
+            });
+            return { messages: (data.messages ?? []).map(mapMessage) };
+        },
+        id: "get_channel_history",
+        inputSchema: getChannelHistoryInput,
+        providerScopes: [],
+        summary: "Get Slack channel history",
+    },
+    {
+        description: "Fetch the replies of a Slack thread (including the parent message).",
+        group: "read",
+        handler: async (input, ctx) => {
+            const args = getThreadRepliesInput.parse(input);
+            const data = await slackApi(ctx, "conversations.replies", {
+                channel: args.channel,
+                limit: args.limit ?? 25,
+                ts: args.thread_ts,
+            });
+            return { messages: (data.messages ?? []).map(mapMessage) };
+        },
+        id: "get_thread_replies",
+        inputSchema: getThreadRepliesInput,
+        providerScopes: [],
+        summary: "Get Slack thread replies",
+    },
+    {
+        description: "Search messages across the Slack workspace as the connected user.",
+        group: "read",
+        handler: async (input, ctx) => {
+            const args = searchMessagesInput.parse(input);
+            const data = await slackApi(ctx, "search.messages", {
+                count: args.count ?? 25,
+                query: args.query,
+            });
+            return {
+                matches: (data.messages?.matches ?? []).map((match) => ({
+                    channel: match.channel?.name ?? "",
+                    permalink: match.permalink ?? "",
+                    text: match.text ?? "",
+                    ts: match.ts ?? "",
+                    user: match.user ?? match.username ?? null,
+                })),
+            };
+        },
+        id: "search_messages",
+        inputSchema: searchMessagesInput,
+        providerScopes: [],
+        summary: "Search Slack messages",
+    },
+    {
+        description: "List workspace members (deactivated accounts are skipped).",
+        group: "read",
+        handler: async (input, ctx) => {
+            const args = listUsersInput.parse(input);
+            const data = await slackApi(ctx, "users.list", { limit: args.limit ?? 50 });
+            return {
+                users: (data.members ?? [])
+                    .filter((member) => !member.deleted)
+                    .map((member) => ({
+                    id: member.id,
+                    is_bot: member.is_bot ?? false,
+                    name: member.name ?? "",
+                    real_name: member.real_name ?? "",
+                })),
+            };
+        },
+        id: "list_users",
+        inputSchema: listUsersInput,
+        providerScopes: [],
+        summary: "List Slack users",
+    },
+    {
+        description: "Post a message to a Slack channel (or as a thread reply) as the connected user.",
+        group: "write",
+        handler: async (input, ctx) => {
+            const args = postMessageInput.parse(input);
+            const data = await slackApi(ctx, "chat.postMessage", {
+                channel: args.channel,
+                text: args.text,
+                thread_ts: args.thread_ts,
+            });
+            return { channel: data.channel ?? args.channel, ts: data.ts ?? "" };
+        },
+        id: "post_message",
+        inputSchema: postMessageInput,
+        providerScopes: [],
+        summary: "Post a Slack message",
+    },
+    {
+        description: "Update the text of a previously posted Slack message.",
+        group: "write",
+        handler: async (input, ctx) => {
+            const args = updateMessageInput.parse(input);
+            const data = await slackApi(ctx, "chat.update", {
+                channel: args.channel,
+                text: args.text,
+                ts: args.ts,
+            });
+            return { channel: data.channel ?? args.channel, ts: data.ts ?? args.ts };
+        },
+        id: "update_message",
+        inputSchema: updateMessageInput,
+        providerScopes: [],
+        summary: "Update a Slack message",
+    },
+    {
+        description: "Add an emoji reaction to a Slack message.",
+        group: "write",
+        handler: async (input, ctx) => {
+            const args = addReactionInput.parse(input);
+            await slackApi(ctx, "reactions.add", {
+                channel: args.channel,
+                name: args.emoji,
+                timestamp: args.ts,
+            });
+            return {
+                added: true,
+                channel: args.channel,
+                emoji: args.emoji,
+                ts: args.ts,
+            };
+        },
+        id: "add_reaction",
+        inputSchema: addReactionInput,
+        providerScopes: [],
+        summary: "Add a Slack reaction",
+    },
+    // No destructive actions in v1: chat.delete is deliberately omitted until
+    // there is a concrete need for agent-driven message deletion.
+];
+export const slackConnector = defineConnector({
+    actions,
+    auth: {
+        kind: "oauth2",
+        oauth2: {
+            authUrl: "https://slack.com/oauth/v2/authorize",
+            // Empty on purpose — Slack bot scopes are unused; see SLACK_USER_SCOPES.
+            baseScopes: [],
+            clientIdEnv: "SLACK_OAUTH_CLIENT_ID",
+            clientSecretEnv: "SLACK_OAUTH_CLIENT_SECRET",
+            extraAuthParams: {
+                user_scope: SLACK_USER_SCOPES.join(","),
+            },
+            resolveAccount: async (accessToken, fetchImpl) => {
+                const response = await fetchImpl(`${SLACK_API_BASE}/auth.test`, {
+                    headers: { authorization: `Bearer ${accessToken}` },
+                    method: "POST",
+                });
+                if (!response.ok) {
+                    throw new Error(`slack_http_error: auth.test returned ${response.status}`);
+                }
+                const data = (await response.json());
+                if (!data.ok) {
+                    throw new Error(`slack_api_error: ${data.error ?? "unknown_error"}`);
+                }
+                return {
+                    label: `${data.team ?? "Slack"} / ${data.user ?? "unknown"}`,
+                    ...(data.user_id ? { externalId: data.user_id } : {}),
+                };
+            },
+            scopeSeparator: ",",
+            tokenUrl: "https://slack.com/api/oauth.v2.access",
+        },
+    },
+    description: "Slack workspace access as the connected user: channels, history, search, messages, reactions.",
+    icon: "logo:slack",
+    id: "slack",
+    moduleId: "connections-slack",
+    name: "Slack",
+    toolPrefix: "slack",
+});

package/apps/runtime/dist/engenty/csv-import/csv-matrix.js

@@ -0,0 +1,178 @@
+/**
+ * A CSV as an editable matrix — the model behind `CsvTable`.
+ *
+ * Built on this package's own parser rather than a new dependency, and that is
+ * the point: `parseCSVRows`/`detectDelimiter`/`serializeDelimitedMatrix` are
+ * what the import wizard reads with, so a grid built on them shows exactly the
+ * cells an import would produce. A second CSV dialect in the codebase — a
+ * library that quotes, trims or splits by different rules — would let the
+ * viewer and the importer disagree about the same file, which is worse than
+ * anything a library would buy us here.
+ *
+ * Pure: every operation returns a new matrix and nothing here touches React.
+ */
+import { detectDelimiter, parseCSVRows } from "./parse-csv.js";
+import { escapeDelimitedField, serializeDelimitedMatrix, } from "./serialize-csv.js";
+export const EMPTY_CSV_MATRIX = {
+    columns: [],
+    delimiter: ",",
+    raggedRows: 0,
+    rows: [],
+};
+/** Text → matrix. Never throws: unparseable input is an empty matrix. */
+export function parseCsvMatrix(text) {
+    if (!text.trim()) {
+        return EMPTY_CSV_MATRIX;
+    }
+    const delimiter = detectDelimiter(text);
+    const raw = parseCSVRows(text, delimiter);
+    const [header = [], ...body] = raw;
+    // Widen to the widest row, so a row with more cells than the header keeps
+    // all of them — `serializeDelimitedMatrix` maps over the header, and a
+    // narrow header would drop the tail on the next save.
+    const width = body.reduce((max, row) => Math.max(max, row.length), header.length);
+    const columns = Array.from({ length: width }, (_, i) => header[i] ?? "");
+    const raggedRows = body.filter((row) => row.length > header.length).length;
+    return {
+        columns,
+        delimiter,
+        raggedRows,
+        rows: body.map((row) => Array.from({ length: width }, (_, i) => row[i] ?? "")),
+    };
+}
+/** Matrix → text, in the delimiter it was read with. */
+export function serializeCsvMatrix(matrix) {
+    if (matrix.columns.length === 0) {
+        return "";
+    }
+    return serializeDelimitedMatrix(matrix.columns, matrix.rows, matrix.delimiter);
+}
+export function setCsvCell(matrix, rowIndex, columnIndex, value) {
+    const rows = matrix.rows.map((row, index) => index === rowIndex
+        ? row.map((cell, column) => (column === columnIndex ? value : cell))
+        : row);
+    return { ...matrix, rows };
+}
+export function setCsvColumnName(matrix, columnIndex, name) {
+    return {
+        ...matrix,
+        columns: matrix.columns.map((column, index) => index === columnIndex ? name : column),
+    };
+}
+/** Append an empty row. A matrix with no columns gets one first. */
+export function appendCsvRow(matrix) {
+    const columns = matrix.columns.length > 0 ? matrix.columns : [""];
+    return {
+        ...matrix,
+        columns,
+        rows: [...matrix.rows, columns.map(() => "")],
+    };
+}
+export function removeCsvRow(matrix, rowIndex) {
+    return {
+        ...matrix,
+        rows: matrix.rows.filter((_, index) => index !== rowIndex),
+    };
+}
+export function appendCsvColumn(matrix, name = "") {
+    return {
+        ...matrix,
+        columns: [...matrix.columns, name],
+        rows: matrix.rows.map((row) => [...row, ""]),
+    };
+}
+export function removeCsvColumn(matrix, columnIndex) {
+    return {
+        ...matrix,
+        columns: matrix.columns.filter((_, index) => index !== columnIndex),
+        rows: matrix.rows.map((row) => row.filter((_, index) => index !== columnIndex)),
+    };
+}
+/** Two corners → a rectangle, in either drag direction. */
+export function csvRange(anchor, focus) {
+    return {
+        bottom: Math.max(anchor.row, focus.row),
+        left: Math.min(anchor.column, focus.column),
+        right: Math.max(anchor.column, focus.column),
+        top: Math.min(anchor.row, focus.row),
+    };
+}
+export function csvRangeContains(range, cell) {
+    return (cell.row >= range.top &&
+        cell.row <= range.bottom &&
+        cell.column >= range.left &&
+        cell.column <= range.right);
+}
+/**
+ * A selection as TAB-separated text.
+ *
+ * Tabs rather than the matrix's own delimiter because this is what goes on the
+ * clipboard, and tab-separated is what Excel, Numbers and Sheets paste back as
+ * cells. Cells containing a tab or newline are quoted so the round trip holds.
+ */
+export function csvRangeToText(matrix, range) {
+    const lines = [];
+    for (let row = range.top; row <= range.bottom; row++) {
+        const cells = [];
+        for (let column = range.left; column <= range.right; column++) {
+            const value = row < 0
+                ? (matrix.columns[column] ?? "")
+                : (matrix.rows[row]?.[column] ?? "");
+            cells.push(escapeDelimitedField(value, "\t"));
+        }
+        lines.push(cells.join("\t"));
+    }
+    return lines.join("\n");
+}
+/** Clipboard text → a block of cells. Tab-separated wins; CSV is the fallback. */
+export function parseCsvBlock(text) {
+    if (!text) {
+        return [];
+    }
+    const delimiter = text.includes("\t") ? "\t" : detectDelimiter(text);
+    return parseCSVRows(text, delimiter);
+}
+/**
+ * Write a block of cells at a corner, GROWING the matrix to fit.
+ *
+ * A paste that silently stopped at the last row would be the same data loss the
+ * ragged-row rule exists to prevent: pasting 12 rows into a 3-row table means
+ * you wanted 12 rows.
+ */
+export function writeCsvBlock(matrix, at, block) {
+    if (block.length === 0) {
+        return matrix;
+    }
+    const blockWidth = block.reduce((max, row) => Math.max(max, row.length), 0);
+    const width = Math.max(matrix.columns.length, at.column + blockWidth);
+    const headerOffset = at.row < 0 ? 1 : 0;
+    const height = Math.max(matrix.rows.length, Math.max(at.row, 0) + block.length - headerOffset);
+    const columns = Array.from({ length: width }, (_, index) => matrix.columns[index] ?? "");
+    const rows = Array.from({ length: height }, (_, rowIndex) => Array.from({ length: width }, (_, columnIndex) => matrix.rows[rowIndex]?.[columnIndex] ?? ""));
+    block.forEach((blockRow, blockRowIndex) => {
+        const targetRow = at.row + blockRowIndex;
+        blockRow.forEach((value, blockColumnIndex) => {
+            const targetColumn = at.column + blockColumnIndex;
+            if (targetColumn >= width) {
+                return;
+            }
+            if (targetRow < 0) {
+                columns[targetColumn] = value;
+                return;
+            }
+            const row = rows[targetRow];
+            if (row) {
+                row[targetColumn] = value;
+            }
+        });
+    });
+    return { ...matrix, columns, rows };
+}
+/** Empty every cell in the rectangle, keeping the rows and columns themselves. */
+export function clearCsvRange(matrix, range) {
+    const columns = matrix.columns.map((column, index) => range.top <= -1 && index >= range.left && index <= range.right ? "" : column);
+    const rows = matrix.rows.map((row, rowIndex) => rowIndex >= range.top && rowIndex <= range.bottom
+        ? row.map((cell, columnIndex) => columnIndex >= range.left && columnIndex <= range.right ? "" : cell)
+        : row);
+    return { ...matrix, columns, rows };
+}