runline 0.14.0 → 0.15.0

package/dist/plugins/shiftCrm/src/records.js

@@ -0,0 +1,80 @@
+import * as t from "typebox";
+import { CRM_BASE, CRM_PROPERTY_DATA_TYPE, enumSchema, idSchema, listParams, pathSegment, recordTypeSchema, request, STRICT_OBJECT, withQuery, } from "./shared.js";
+export function registerRecordActions(rl) {
+    rl.registerAction("record.changeEvents", {
+        access: "read",
+        description: "List the immutable change-event history (created/updated snapshots) for a CRM record.",
+        inputSchema: t.Object({ recordId: idSchema("CRM record ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { recordId } = input;
+            const body = await request(ctx, `${CRM_BASE}/records/${pathSegment(recordId)}/change-events`);
+            return body.changeEvents;
+        },
+    });
+    rl.registerAction("propertyDefinition.list", {
+        access: "read",
+        description: "List governed custom-property definitions, optionally for one record type.",
+        inputSchema: t.Object({ recordType: t.Optional(recordTypeSchema()) }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, withQuery(`${CRM_BASE}/property-definitions`, listParams(input)));
+            return body.propertyDefinitions;
+        },
+    });
+    rl.registerAction("propertyDefinition.create", {
+        access: "write",
+        description: "Define a governed custom property for a record type. Requires a CRM admin grant. Enum types require options.",
+        inputSchema: t.Object({
+            recordType: recordTypeSchema(),
+            key: t.String({
+                maxLength: 100,
+                pattern: "^[a-z][a-z0-9_]*$",
+                description: "snake_case property key",
+            }),
+            label: t.String({
+                minLength: 1,
+                maxLength: 200,
+                pattern: "\\S",
+                description: "Human-readable label",
+            }),
+            dataType: enumSchema("Property data type", CRM_PROPERTY_DATA_TYPE),
+            options: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 500, pattern: "\\S" }), {
+                description: "Allowed values for enum and multi_enum types",
+            })),
+            validation: t.Optional(t.Object({
+                minLength: t.Optional(t.Integer({ minimum: 0 })),
+                maxLength: t.Optional(t.Integer({ minimum: 0 })),
+                minimum: t.Optional(t.Number()),
+                maximum: t.Optional(t.Number()),
+                pattern: t.Optional(t.String({ maxLength: 1_000 })),
+            }, { additionalProperties: false })),
+            filterable: t.Optional(t.Boolean()),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const fields = input;
+            const isEnum = fields.dataType === "enum" || fields.dataType === "multi_enum";
+            const options = fields.options ?? [];
+            if (isEnum && options.length === 0) {
+                throw new Error("Enum property definitions require options");
+            }
+            if (!isEnum && options.length > 0) {
+                throw new Error("Options are only allowed on enum property types");
+            }
+            if (new Set(options).size !== options.length) {
+                throw new Error("Duplicate property option");
+            }
+            if (fields.validation?.pattern) {
+                try {
+                    new RegExp(fields.validation.pattern);
+                }
+                catch {
+                    throw new Error("Property validation pattern is not a valid regex");
+                }
+            }
+            const body = await request(ctx, `${CRM_BASE}/property-definitions`, {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+            return body.propertyDefinition;
+        },
+    });
+}

package/dist/plugins/shiftCrm/src/shared.js

@@ -0,0 +1,122 @@
+import * as t from "typebox";
+import { cursorSchema, enumSchema, idSchema, timestampSchema, } from "../../_shared/shiftCloud.js";
+export { enumSchema, idSchema, listParams, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, withQuery, } from "../../_shared/shiftCloud.js";
+export const CRM_BASE = "/v1/crm";
+export const CRM_ACCESS_ROLE = ["user", "admin"];
+export const CRM_RECORD_TYPE = [
+    "account",
+    "person",
+    "opportunity",
+    "activity",
+    "task",
+];
+export const CRM_IDENTITY_KIND = [
+    "email",
+    "phone",
+    "whatsapp",
+    "linkedin",
+    "other",
+];
+export const CRM_PIPELINE_OUTCOME = ["open", "won", "lost"];
+export const CRM_TASK_STATUS = [
+    "todo",
+    "in_progress",
+    "blocked",
+    "done",
+    "cancelled",
+];
+export const CRM_TASK_PRIORITY = ["low", "medium", "high", "urgent"];
+export const CRM_ACTIVITY_DIRECTION = [
+    "inbound",
+    "outbound",
+    "internal",
+];
+export const CRM_ACTIVITY_STATUS = [
+    "planned",
+    "completed",
+    "cancelled",
+];
+export const CRM_PROPERTY_DATA_TYPE = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "datetime",
+    "enum",
+    "multi_enum",
+    "json",
+];
+function propertiesSchema(description) {
+    return t.Record(t.String(), t.Unknown(), { description });
+}
+function externalRefSchema() {
+    return t.Object({
+        sourceSystem: t.String({
+            minLength: 1,
+            maxLength: 100,
+            pattern: "\\S",
+            description: "Upstream system name, e.g. hubspot",
+        }),
+        sourceId: t.String({
+            minLength: 1,
+            maxLength: 500,
+            pattern: "\\S",
+            description: "Stable ID in the upstream system",
+        }),
+        sourceUrl: t.Optional(t.String({ minLength: 1, maxLength: 2_000 })),
+        attributes: t.Optional(propertiesSchema("Source-specific attributes")),
+    }, { additionalProperties: false });
+}
+function relationshipSchema() {
+    return t.Object({
+        toRecordId: idSchema("Target CRM record ID"),
+        relationshipType: t.String({
+            minLength: 1,
+            maxLength: 100,
+            pattern: "\\S",
+            description: "Relationship type, e.g. participant, attendee, subject",
+        }),
+        role: t.Optional(t.String({ minLength: 1, maxLength: 200, pattern: "\\S" })),
+        attributes: t.Optional(propertiesSchema("Governed link attributes")),
+    }, { additionalProperties: false });
+}
+/** Shared create-time record fields (owner, custom properties, links). */
+export function createRecordFields() {
+    return {
+        ownerId: t.Optional(idSchema("Owning Shift user ID")),
+        customProperties: t.Optional(propertiesSchema("Governed custom properties; every key must have a property definition")),
+        externalRefs: t.Optional(t.Array(externalRefSchema())),
+        relationships: t.Optional(t.Array(relationshipSchema())),
+    };
+}
+/** Shared update-time record fields (tri-state PATCH semantics). */
+export function updateRecordFields() {
+    return {
+        ownerId: t.Optional(t.Union([idSchema("Owning Shift user ID"), t.Null()])),
+        customProperties: t.Optional(propertiesSchema("Replacement governed custom properties")),
+        externalRefs: t.Optional(t.Array(externalRefSchema())),
+        relationships: t.Optional(t.Array(relationshipSchema())),
+        archived: t.Optional(t.Boolean({ description: "Archive or restore" })),
+    };
+}
+export function paginationFields(maxLimit = 200) {
+    return {
+        cursor: t.Optional(cursorSchema()),
+        limit: t.Optional(t.Integer({
+            minimum: 1,
+            maximum: maxLimit,
+            description: "Max results, default 50",
+        })),
+    };
+}
+export function recordTypeSchema(description = "CRM record type") {
+    return enumSchema(description, CRM_RECORD_TYPE);
+}
+export function assertTimeOrder(start, end, message) {
+    if (typeof start === "string" && typeof end === "string" && start > end) {
+        throw new Error(message);
+    }
+}
+export function nullableTimestamp(description) {
+    return t.Optional(t.Union([timestampSchema(description), t.Null()]));
+}

package/dist/plugins/shiftCrm/src/tasks.js

@@ -0,0 +1,79 @@
+import * as t from "typebox";
+import { CRM_BASE, CRM_TASK_PRIORITY, CRM_TASK_STATUS, createRecordFields, enumSchema, idSchema, listParams, nullableTimestamp, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, updateRecordFields, withQuery, } from "./shared.js";
+const taskListFields = {
+    linkedRecordId: t.Optional(idSchema("Filter by linked CRM record ID")),
+    status: t.Optional(enumSchema("Task status", CRM_TASK_STATUS)),
+    includeArchived: t.Optional(t.Boolean()),
+    ...paginationFields(),
+};
+export function registerTaskActions(rl) {
+    rl.registerAction("task.list", {
+        access: "read",
+        description: "List the first page of CRM tasks.",
+        inputSchema: t.Object(taskListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, withQuery(`${CRM_BASE}/tasks`, listParams(input)));
+            return body.tasks;
+        },
+    });
+    rl.registerAction("task.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of CRM tasks.",
+        inputSchema: t.Object(taskListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            return request(ctx, withQuery(`${CRM_BASE}/tasks`, listParams(input)));
+        },
+    });
+    rl.registerAction("task.get", {
+        access: "read",
+        description: "Get a CRM task by record ID.",
+        inputSchema: t.Object({ id: idSchema("Task record ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `${CRM_BASE}/tasks/${pathSegment(id)}`);
+            return body.task;
+        },
+    });
+    rl.registerAction("task.create", {
+        access: "write",
+        description: "Create a CRM follow-up task, optionally linked to records via relationships.",
+        inputSchema: t.Object({
+            title: t.String({
+                minLength: 1,
+                maxLength: 500,
+                pattern: "\\S",
+                description: "Task title",
+            }),
+            status: t.Optional(enumSchema("Task status", CRM_TASK_STATUS)),
+            priority: t.Optional(enumSchema("Task priority", CRM_TASK_PRIORITY)),
+            dueAt: t.Optional(timestampSchema("ISO-8601 due timestamp")),
+            assignedTo: t.Optional(idSchema("Assigned Shift user ID")),
+            ...createRecordFields(),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, `${CRM_BASE}/tasks`, {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+            return body.task;
+        },
+    });
+    rl.registerAction("task.update", {
+        access: "write",
+        description: "Update or archive a CRM task: title, status, priority, due date, or assignee.",
+        inputSchema: t.Object({
+            id: idSchema("Task record ID"),
+            title: t.Optional(t.String({ minLength: 1, maxLength: 500, pattern: "\\S" })),
+            status: t.Optional(enumSchema("Task status", CRM_TASK_STATUS)),
+            priority: t.Optional(enumSchema("Task priority", CRM_TASK_PRIORITY)),
+            dueAt: nullableTimestamp("ISO-8601 due timestamp"),
+            assignedTo: t.Optional(t.Union([idSchema("Assigned Shift user ID"), t.Null()])),
+            ...updateRecordFields(),
+        }, STRICT_UPDATE_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            const body = await request(ctx, `${CRM_BASE}/tasks/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.task;
+        },
+    });
+}

package/dist/plugins/shiftLabs/src/issue-views.js

@@ -1,17 +1,24 @@
 import * as t from "typebox";
-import { enumSchema, ISSUE_PRIORITY, ISSUE_STATUS, ISSUE_VIEW_GROUP, ISSUE_VIEW_LAYOUT, ISSUE_VIEW_SORT, ISSUE_VIEW_VISIBILITY, pathSegment, request, } from "./shared.js";
+import { cursorSchema, enumSchema, ISSUE_PRIORITY, ISSUE_STATUS, ISSUE_VIEW_GROUP, ISSUE_VIEW_LAYOUT, ISSUE_VIEW_SORT, ISSUE_VIEW_VISIBILITY, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "./shared.js";
 const viewFields = {
-    name: t.String({ minLength: 1, maxLength: 120, description: "View name" }),
+    name: t.String({
+        minLength: 1,
+        maxLength: 120,
+        pattern: "\\S",
+        description: "View name",
+    }),
     visibility: t.Optional(t.Literal("organization")),
     layout: t.Optional(enumSchema("View layout", ISSUE_VIEW_LAYOUT)),
-    projectId: t.Optional(t.String({ minLength: 1 })),
-    rootIssueId: t.Optional(t.String({ minLength: 1 })),
+    projectId: t.Optional(idSchema("Project ID")),
+    rootIssueId: t.Optional(idSchema("Root Issue ID")),
     statuses: t.Optional(t.Array(enumSchema("Issue status", ISSUE_STATUS), { maxItems: 5 })),
     priorities: t.Optional(t.Array(enumSchema("Issue priority", ISSUE_PRIORITY), { maxItems: 5 })),
-    assigneeUserIds: t.Optional(t.Array(t.String({ minLength: 1 }), { maxItems: 20 })),
-    labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64 }), { maxItems: 20 })),
-    startAfter: t.Optional(t.String()),
-    dueBefore: t.Optional(t.String()),
+    assigneeUserIds: t.Optional(t.Array(idSchema("Assignee user ID"), { maxItems: 20 })),
+    labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }), {
+        maxItems: 20,
+    })),
+    startAfter: t.Optional(timestampSchema("ISO-8601 filter start timestamp")),
+    dueBefore: t.Optional(timestampSchema("ISO-8601 filter due timestamp")),
     blocked: t.Optional(t.Boolean()),
     groupBy: t.Optional(enumSchema("View grouping", ISSUE_VIEW_GROUP)),
     sortBy: t.Optional(t.Array(enumSchema("View sort", ISSUE_VIEW_SORT), {
@@ -22,13 +29,14 @@ const viewFields = {
 export function registerIssueViewActions(rl) {
     const listFields = {
         visibility: t.Optional(enumSchema("View visibility", ISSUE_VIEW_VISIBILITY)),
-        cursor: t.Optional(t.String({ minLength: 1, description: "Next-page cursor" })),
+        createdById: t.Optional(idSchema("Creator ID")),
+        cursor: t.Optional(cursorSchema()),
         limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
     };
     rl.registerAction("issueView.list", {
         access: "read",
         description: "List the first page of personal and organization Issue Views.",
-        inputSchema: t.Object(listFields),
+        inputSchema: t.Object(listFields, STRICT_OBJECT),
         async execute(input, ctx) {
             const body = await request(ctx, `/v1/issue-views?${listParams(input)}`);
             return body.views;
@@ -37,7 +45,7 @@ export function registerIssueViewActions(rl) {
     rl.registerAction("issueView.listPage", {
         access: "read",
         description: "List a cursor-paginated page of Issue Views.",
-        inputSchema: t.Object(listFields),
+        inputSchema: t.Object(listFields, STRICT_OBJECT),
         async execute(input, ctx) {
             return request(ctx, `/v1/issue-views?${listParams(input)}`);
         },
@@ -45,7 +53,7 @@ export function registerIssueViewActions(rl) {
     rl.registerAction("issueView.get", {
         access: "read",
         description: "Get an Issue View by ID.",
-        inputSchema: t.Object({ id: t.String() }),
+        inputSchema: t.Object({ id: idSchema("Issue View ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
             const body = await request(ctx, `/v1/issue-views/${pathSegment(id)}`);
@@ -56,9 +64,9 @@ export function registerIssueViewActions(rl) {
         access: "read",
         description: "Execute the first page of a saved Issue View.",
         inputSchema: t.Object({
-            id: t.String({ minLength: 1 }),
+            id: idSchema("Issue View ID"),
             limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
-        }),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, ...pagination } = input;
             const body = await request(ctx, withQuery(`/v1/issue-views/${pathSegment(id)}/issues`, listParams(pagination)));
@@ -69,10 +77,10 @@ export function registerIssueViewActions(rl) {
         access: "read",
         description: "Execute a cursor-paginated page of a saved Issue View.",
         inputSchema: t.Object({
-            id: t.String({ minLength: 1 }),
-            cursor: t.Optional(t.String({ minLength: 1 })),
+            id: idSchema("Issue View ID"),
+            cursor: t.Optional(cursorSchema()),
             limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
-        }),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, ...pagination } = input;
             return request(ctx, withQuery(`/v1/issue-views/${pathSegment(id)}/issues`, listParams(pagination)));
@@ -81,11 +89,13 @@ export function registerIssueViewActions(rl) {
     rl.registerAction("issueView.create", {
         access: "write",
         description: "Create a bounded saved Issue query. Views never own Issue membership.",
-        inputSchema: t.Object(viewFields),
+        inputSchema: t.Object(viewFields, STRICT_OBJECT),
         async execute(input, ctx) {
+            const fields = input;
+            assertDateOrder(fields.startAfter, fields.dueBefore);
             const body = await request(ctx, "/v1/issue-views", {
                 method: "POST",
-                body: JSON.stringify(toViewBody(input)),
+                body: JSON.stringify(toViewBody(fields)),
             });
             return body.view;
         },
@@ -94,27 +104,28 @@ export function registerIssueViewActions(rl) {
         access: "write",
         description: "Patch a saved Issue View. Null filter values remove that filter without replacing unrelated filters.",
         inputSchema: t.Object({
-            id: t.String({ minLength: 1 }),
-            name: t.Optional(t.String({ minLength: 1, maxLength: 120 })),
+            id: idSchema("Issue View ID"),
+            name: t.Optional(t.String({ minLength: 1, maxLength: 120, pattern: "\\S" })),
             visibility: t.Optional(t.Literal("organization")),
             layout: t.Optional(enumSchema("View layout", ISSUE_VIEW_LAYOUT)),
-            projectId: optionalNullableString(),
-            rootIssueId: optionalNullableString(),
+            projectId: optionalNullableId("Project ID"),
+            rootIssueId: optionalNullableId("Root Issue ID"),
             statuses: optionalNullableArray(enumSchema("Issue status", ISSUE_STATUS), 5),
             priorities: optionalNullableArray(enumSchema("Issue priority", ISSUE_PRIORITY), 5),
-            assigneeUserIds: optionalNullableArray(t.String({ minLength: 1 }), 20),
-            labels: optionalNullableArray(t.String({ minLength: 1, maxLength: 64 }), 20),
-            startAfter: optionalNullableString(),
-            dueBefore: optionalNullableString(),
+            assigneeUserIds: optionalNullableArray(idSchema("Assignee user ID"), 20),
+            labels: optionalNullableArray(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }), 20),
+            startAfter: optionalNullableTimestamp("ISO-8601 filter start timestamp"),
+            dueBefore: optionalNullableTimestamp("ISO-8601 filter due timestamp"),
             blocked: t.Optional(t.Union([t.Boolean(), t.Null()])),
             groupBy: t.Optional(t.Union([enumSchema("View grouping", ISSUE_VIEW_GROUP), t.Null()])),
             sortBy: t.Optional(t.Array(enumSchema("View sort", ISSUE_VIEW_SORT), {
                 minItems: 1,
                 maxItems: 3,
             })),
-        }, { minProperties: 2 }),
+        }, STRICT_UPDATE_OBJECT),
         async execute(input, ctx) {
             const { id, ...fields } = input;
+            assertDateOrder(fields.startAfter, fields.dueBefore);
             const body = await request(ctx, `/v1/issue-views/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(toViewBody(fields, false)) });
             return body.view;
         },
@@ -122,7 +133,7 @@ export function registerIssueViewActions(rl) {
     rl.registerAction("issueView.delete", {
         access: "write",
         description: "Delete a saved Issue View without changing any Issues.",
-        inputSchema: t.Object({ id: t.String() }),
+        inputSchema: t.Object({ id: idSchema("Issue View ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
             await request(ctx, `/v1/issue-views/${pathSegment(id)}`, {
@@ -144,8 +155,18 @@ function withQuery(path, params) {
     const query = params.toString();
     return query ? `${path}?${query}` : path;
 }
-function optionalNullableString() {
-    return t.Optional(t.Union([t.String({ minLength: 1 }), t.Null()]));
+function assertDateOrder(startAfter, dueBefore) {
+    if (typeof startAfter === "string" &&
+        typeof dueBefore === "string" &&
+        startAfter > dueBefore) {
+        throw new Error("View dueBefore must not precede startAfter");
+    }
+}
+function optionalNullableId(description) {
+    return t.Optional(t.Union([idSchema(description), t.Null()]));
+}
+function optionalNullableTimestamp(description) {
+    return t.Optional(t.Union([timestampSchema(description), t.Null()]));
 }
 function optionalNullableArray(item, maxItems) {
     return t.Optional(t.Union([t.Array(item, { maxItems }), t.Null()]));