runline 0.32.0 → 0.34.0

package/dist/plugins/shiftBwm/src/vendor/models.js

@@ -0,0 +1,525 @@
+/**
+ * SYNCED_FROM shift-labs-ai/cloud@42c9f13
+ *   packages/business-world-model-service/src/models.ts
+ *
+ * Verbatim copy; only the import paths are rewritten. Do not edit here.
+ */
+/**
+ * Public API shape: record envelopes, definitions, write inputs, queries.
+ * Browser-safe (Zod only).
+ */
+import { BWM_CARDINALITIES, BWM_HISTORY_DEFAULT_LIMIT, BWM_HISTORY_MAX_LIMIT, BWM_LIST_DEFAULT_LIMIT, BWM_LIST_MAX_LIMIT, BWM_SOCIAL_HANDLE_SERVICES, BWM_VALUE_TYPES, BWM_VISIBILITY_MODES, } from "./contracts.js";
+import { z } from "zod";
+export const BwmValueType = z.enum(BWM_VALUE_TYPES);
+export const BwmCardinality = z.enum(BWM_CARDINALITIES);
+export const BwmVisibilityMode = z.enum(BWM_VISIBILITY_MODES);
+export const BwmSocialHandleService = z.enum(BWM_SOCIAL_HANDLE_SERVICES);
+export const BwmPrincipalType = z.enum(["user", "service"]);
+export const BwmPrincipalRef = z.object({
+    type: BwmPrincipalType,
+    id: z.string().min(1),
+});
+const slug = z
+    .string()
+    .regex(/^[a-z][a-z0-9_]*$/)
+    .max(100);
+/** `$system` or bare custom slug. */
+const fieldKey = z.string().regex(/^\$?[a-zA-Z][a-zA-Z0-9_-]*$/);
+export const BwmSelectOption = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().nullable(),
+    parentId: z.string().optional(),
+});
+export const BwmTypeConfiguration = z.object({
+    currency: z.string().optional(),
+    handleService: BwmSocialHandleService.optional(),
+    multipleValues: z.boolean().optional(),
+    unique: z.boolean().optional(),
+    options: z.array(BwmSelectOption).optional(),
+    parentFieldKey: z.string().optional(),
+});
+export const BwmFieldDefinition = z.object({
+    id: z.string().nullable(),
+    slug: z.string(),
+    label: z.string(),
+    description: z.string().nullable(),
+    valueType: BwmValueType,
+    system: z.boolean(),
+    readOnly: z.boolean(),
+    required: z.boolean(),
+    typeConfiguration: BwmTypeConfiguration,
+});
+export const BwmRelationshipDefinition = z.object({
+    id: z.string().nullable(),
+    slug: z.string(),
+    label: z.string(),
+    description: z.string().nullable(),
+    system: z.boolean(),
+    readOnly: z.boolean(),
+    cardinality: BwmCardinality,
+    objectType: z.string(),
+    inverseKey: z.string().nullable(),
+});
+export const BwmDefinitions = z.object({
+    objectType: z.string(),
+    fieldDefinitions: z.record(z.string(), BwmFieldDefinition),
+    relationshipDefinitions: z.record(z.string(), BwmRelationshipDefinition),
+});
+export const BwmObjectType = z.object({
+    slug: z.string(),
+    label: z.string(),
+    pluralLabel: z.string(),
+    description: z.string().nullable(),
+    system: z.boolean(),
+    path: z.string(),
+});
+export const BwmVisibility = z.object({
+    mode: BwmVisibilityMode,
+    groups: z.array(z.string()),
+    principals: z.array(BwmPrincipalRef),
+});
+export const BwmFieldValue = z.object({
+    value: z.unknown(),
+    valueType: BwmValueType,
+});
+export const BwmRelationshipValue = z.object({
+    cardinality: BwmCardinality,
+    objectType: z.string(),
+    values: z.array(z.string()),
+});
+export const BwmRecord = z.object({
+    id: z.string(),
+    objectType: z.string(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    archivedAt: z.string().datetime().nullable(),
+    mergedIntoId: z.string().nullable(),
+    externalId: z.string().nullable(),
+    visibility: BwmVisibility,
+    fields: z.record(z.string(), BwmFieldValue),
+    relationships: z.record(z.string(), BwmRelationshipValue),
+});
+export const BwmRecordPage = z.object({
+    data: z.array(BwmRecord),
+    object: z.literal("list"),
+    totalCount: z.number().int().nonnegative(),
+});
+// ─── writes ──────────────────────────────────────────────────────
+const idOrIds = z.union([z.string().min(1), z.array(z.string().min(1))]);
+export const BwmRelationshipOps = z
+    .object({
+    add: idOrIds.optional(),
+    remove: idOrIds.optional(),
+    replace: idOrIds.nullable().optional(),
+})
+    .strict();
+export const BwmVisibilityInput = z.object({
+    mode: BwmVisibilityMode,
+    groups: z.array(z.string().min(1)).default([]),
+    principals: z.array(BwmPrincipalRef).default([]),
+});
+export const BwmCreateRecordInput = z.object({
+    fields: z.record(fieldKey, z.unknown()).default({}),
+    relationships: z.record(fieldKey, idOrIds).default({}),
+    externalId: z.string().trim().min(1).max(500).optional(),
+    visibility: BwmVisibilityInput.optional(),
+});
+export const BwmUpdateRecordInput = z.object({
+    fields: z.record(fieldKey, z.unknown()).optional(),
+    relationships: z
+        .record(fieldKey, z.union([idOrIds, z.null(), BwmRelationshipOps]))
+        .optional(),
+    externalId: z.string().trim().max(500).nullish(),
+    visibility: BwmVisibilityInput.optional(),
+    archived: z.boolean().optional(),
+});
+export const BwmCreateObjectTypeInput = z.object({
+    slug,
+    label: z.string().trim().min(1).max(200),
+    pluralLabel: z.string().trim().min(1).max(200).optional(),
+    description: z.string().trim().min(1).max(2_000).optional(),
+});
+export const BwmCreateFieldInput = z
+    .object({
+    key: slug,
+    label: z.string().trim().min(1).max(200),
+    description: z.string().trim().min(1).max(2_000).optional(),
+    valueType: BwmValueType,
+    options: z
+        .array(z.object({
+        id: z.string().trim().min(1).max(200).optional(),
+        label: z.string().trim().min(1).max(500),
+        description: z.string().trim().max(2_000).optional(),
+    }))
+        .default([]),
+    validation: z
+        .object({
+        minLength: z.number().int().nonnegative().optional(),
+        maxLength: z.number().int().nonnegative().optional(),
+        minimum: z.number().finite().optional(),
+        maximum: z.number().finite().optional(),
+        pattern: z.string().max(1_000).optional(),
+    })
+        .strict()
+        .default({}),
+    typeConfiguration: z
+        .object({
+        currency: z.string().trim().length(3).optional(),
+        handleService: BwmSocialHandleService.optional(),
+        multipleValues: z.boolean().optional(),
+        unique: z.boolean().optional(),
+    })
+        .strict()
+        .default({}),
+    filterable: z.boolean().default(true),
+})
+    .superRefine((input, context) => {
+    const isSelect = input.valueType === "SINGLE_SELECT" || input.valueType === "MULTI_SELECT";
+    if (isSelect && input.options.length === 0) {
+        context.addIssue({ code: "custom", message: "select_options_required" });
+    }
+    if (!isSelect && input.options.length > 0) {
+        context.addIssue({
+            code: "custom",
+            message: "select_options_not_allowed",
+        });
+    }
+    const labels = input.options.map((option) => option.label);
+    if (new Set(labels).size !== labels.length) {
+        context.addIssue({ code: "custom", message: "duplicate_select_option" });
+    }
+    if (input.validation.pattern !== undefined) {
+        try {
+            new RegExp(input.validation.pattern);
+        }
+        catch {
+            context.addIssue({ code: "custom", message: "pattern_invalid" });
+        }
+    }
+    const { minLength: minL, maxLength: maxL, minimum, maximum, } = input.validation;
+    if (minL !== undefined && maxL !== undefined && minL > maxL) {
+        context.addIssue({ code: "custom", message: "length_range_invalid" });
+    }
+    if (minimum !== undefined && maximum !== undefined && minimum > maximum) {
+        context.addIssue({ code: "custom", message: "number_range_invalid" });
+    }
+    const textual = input.valueType === "TEXT" || input.valueType === "MARKDOWN";
+    if (!textual &&
+        (minL !== undefined || maxL !== undefined || input.validation.pattern)) {
+        context.addIssue({
+            code: "custom",
+            message: "string_validation_not_allowed",
+        });
+    }
+    const numeric = input.valueType === "NUMBER" || input.valueType === "CURRENCY";
+    if (!numeric && (minimum !== undefined || maximum !== undefined)) {
+        context.addIssue({
+            code: "custom",
+            message: "number_validation_not_allowed",
+        });
+    }
+    if (input.valueType === "SOCIAL_HANDLE" &&
+        !input.typeConfiguration.handleService) {
+        context.addIssue({ code: "custom", message: "handle_service_required" });
+    }
+});
+export const BwmCreateRelationshipDefinitionInput = z.object({
+    key: slug,
+    label: z.string().trim().min(1).max(200),
+    description: z.string().trim().min(1).max(2_000).optional(),
+    objectType: slug,
+    cardinality: BwmCardinality.default("HAS_MANY"),
+    /** Read-only `HAS_MANY` key exposed on the target type. */
+    inverseKey: slug.optional(),
+});
+export const BwmCreatePipelineInput = z
+    .object({
+    name: z.string().trim().min(1).max(200),
+    isDefault: z.boolean().default(false),
+    stages: z
+        .array(z.object({
+        key: slug,
+        name: z.string().trim().min(1).max(200),
+        position: z.number().int().nonnegative(),
+        outcome: z.enum(["open", "won", "lost"]).default("open"),
+        defaultProbability: z.number().int().min(0).max(100).optional(),
+    }))
+        .min(1),
+})
+    .superRefine((input, context) => {
+    const keys = input.stages.map((stage) => stage.key);
+    if (new Set(keys).size !== keys.length) {
+        context.addIssue({ code: "custom", message: "duplicate_stage_key" });
+    }
+    const positions = input.stages.map((stage) => stage.position);
+    if (new Set(positions).size !== positions.length) {
+        context.addIssue({ code: "custom", message: "duplicate_stage_position" });
+    }
+});
+export const BwmPipeline = z.object({
+    id: z.string(),
+    name: z.string(),
+    isDefault: z.boolean(),
+    stages: z.array(z.object({
+        id: z.string(),
+        key: z.string(),
+        name: z.string(),
+        position: z.number().int(),
+        outcome: z.enum(["open", "won", "lost"]),
+        defaultProbability: z.number().int().nullable(),
+    })),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+});
+// ─── queries ─────────────────────────────────────────────────────
+export const BwmFilterOperator = z.enum([
+    "equal",
+    "startsWith",
+    "contains",
+    "greaterThan",
+    "greaterThanOrEqual",
+    "lessThan",
+    "lessThanOrEqual",
+]);
+export const BwmFilter = z.object({
+    key: z.string().min(1),
+    operator: BwmFilterOperator.optional(),
+    negate: z.boolean().default(false),
+    value: z.string(),
+});
+export const BwmListQuery = z.object({
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(BWM_LIST_MAX_LIMIT)
+        .default(BWM_LIST_DEFAULT_LIMIT),
+    offset: z.coerce.number().int().nonnegative().default(0),
+    includeArchived: z.boolean().default(false),
+    filters: z.array(BwmFilter).default([]),
+});
+export const BwmHistoryQuery = z.object({
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(BWM_HISTORY_MAX_LIMIT)
+        .default(BWM_HISTORY_DEFAULT_LIMIT),
+    after: z.string().min(1).optional(),
+});
+export const BwmFieldHistoryEntry = z.object({
+    value: z.unknown(),
+    valueType: BwmValueType,
+    displayValue: z.string(),
+    recordedAt: z.string().datetime(),
+    isCreate: z.boolean(),
+});
+export const BwmFieldHistory = z.object({
+    data: z.array(BwmFieldHistoryEntry),
+    hasMore: z.boolean(),
+    nextCursor: z.string().nullable(),
+});
+export const BwmLinkDirection = z.enum(["in", "out", "both"]);
+// ─── lists, groups, merges, members ──────────────────────────────
+export const BwmList = z.object({
+    id: z.string(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    archivedAt: z.string().datetime().nullable(),
+    fields: z.object({
+        $name: BwmFieldValue,
+        $objectType: BwmFieldValue,
+        $description: BwmFieldValue,
+    }),
+    relationships: z.object({ $records: BwmRelationshipValue }),
+});
+export const BwmCreateListInput = z.object({
+    fields: z.object({
+        $name: z.string().trim().min(1).max(200),
+        $objectType: z.string().min(1),
+        $description: z.string().trim().max(2_000).nullish(),
+    }),
+    relationships: z.object({ $records: idOrIds.optional() }).default({}),
+});
+export const BwmUpdateListInput = z.object({
+    fields: z
+        .object({
+        $name: z.string().trim().min(1).max(200).optional(),
+        $description: z.string().trim().max(2_000).nullish(),
+    })
+        .optional(),
+    relationships: z
+        .object({ $records: z.union([idOrIds, BwmRelationshipOps]).optional() })
+        .optional(),
+    archived: z.boolean().optional(),
+});
+export const BwmGroup = z.object({
+    id: z.string(),
+    slug: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    members: z.array(BwmPrincipalRef),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+});
+export const BwmCreateGroupInput = z.object({
+    slug,
+    name: z.string().trim().min(1).max(200),
+    description: z.string().trim().min(1).max(2_000).optional(),
+    members: z.array(BwmPrincipalRef).default([]),
+});
+export const BwmUpdateGroupInput = z.object({
+    name: z.string().trim().min(1).max(200).optional(),
+    description: z.string().trim().max(2_000).nullish(),
+});
+export const BwmGroupMembersInput = z
+    .object({
+    add: z.array(BwmPrincipalRef).default([]),
+    remove: z.array(BwmPrincipalRef).default([]),
+})
+    .refine((input) => input.add.length > 0 || input.remove.length > 0, "group_members_empty");
+export const BwmMergeInput = z.object({
+    primaryId: z.string().min(1),
+    duplicateId: z.string().min(1),
+    fieldResolutions: z
+        .record(fieldKey, z.union([
+        z.literal("primary"),
+        z.literal("duplicate"),
+        z.object({ value: z.unknown() }),
+    ]))
+        .default({}),
+    options: z.object({ multiSelectUnion: z.boolean().default(true) }).default({
+        multiSelectUnion: true,
+    }),
+});
+export const BwmMerge = z.object({
+    id: z.string(),
+    createdAt: z.string().datetime(),
+    objectType: z.string(),
+    primaryId: z.string(),
+    duplicateId: z.string(),
+    status: z.enum(["done", "failed"]),
+    summary: z.object({
+        fieldWriteCount: z.number().int(),
+        repointedCount: z.number().int(),
+        warnings: z.array(z.string()),
+    }),
+});
+export const BwmMergeResult = z.object({
+    merge: BwmMerge,
+    primary: BwmRecord,
+    summary: BwmMerge.shape.summary,
+});
+export const BwmMember = z.object({
+    id: z.string(),
+    createdAt: z.string().datetime(),
+    fields: z.object({
+        $name: BwmFieldValue,
+        $email: BwmFieldValue,
+        $role: BwmFieldValue,
+    }),
+});
+export const BwmMemberPage = z.object({
+    data: z.array(BwmMember),
+    object: z.literal("list"),
+    totalCount: z.number().int(),
+});
+export const BwmChangeEvent = z.object({
+    id: z.string(),
+    recordId: z.string(),
+    actor: BwmPrincipalRef,
+    action: z.enum(["created", "updated"]),
+    before: z.unknown().optional(),
+    after: z.unknown(),
+    importRunId: z.string().nullable(),
+    createdAt: z.string().datetime(),
+});
+export const BwmLink = z.object({
+    id: z.string(),
+    fromRecordId: z.string(),
+    toRecordId: z.string(),
+    fromObjectType: z.string(),
+    toObjectType: z.string(),
+    key: z.string(),
+    role: z.string().nullable(),
+    attributes: z.record(z.string(), z.unknown()),
+    declared: z.boolean(),
+    createdAt: z.string().datetime(),
+});
+export const BwmLinks = z.object({
+    outbound: z.array(BwmLink),
+    inbound: z.array(BwmLink),
+});
+export const BwmFileUploadInput = z.object({
+    filename: z.string().trim().min(1).max(500),
+    mimeType: z.string().trim().min(1).max(200),
+    sizeBytes: z.number().int().positive(),
+});
+export const BwmFile = z.object({
+    id: z.string(),
+    filename: z.string().nullable(),
+    mimeType: z.string(),
+    sizeBytes: z.number().int(),
+    status: z.enum(["PENDING", "COMPLETED", "ARCHIVED"]),
+    createdAt: z.string().datetime(),
+    completedAt: z.string().datetime().nullable(),
+});
+/** A file plus its one-time upload grant; `expiresAt` is the grant's. */
+export const BwmFileUpload = BwmFile.extend({
+    uploadUrl: z.string(),
+    uploadMethod: z.string(),
+    uploadHeaders: z.record(z.string(), z.string()),
+    expiresAt: z.string().datetime(),
+});
+export const BwmFileUrl = z.object({
+    url: z.string(),
+    expiresAt: z.string().datetime(),
+});
+// ─── imports (Shift protocol, unchanged) ─────────────────────────
+export const BwmCreateImportRunInput = z.object({
+    sourceSystem: z.string().trim().min(1).max(100),
+});
+export const BwmStageImportRowsInput = z.object({
+    rows: z
+        .array(z.object({
+        sourceId: z.string().trim().min(1).max(500),
+        objectType: slug,
+        rawPayload: z.json(),
+    }))
+        .min(1)
+        .max(500),
+});
+export const BwmCommitImportRowInput = z.object({
+    transformedPayload: z.json(),
+});
+/**
+ * Parses `key[op]=value` / `key[-op]=value` / `key=value` query pairs into
+ * filters. Reserved pagination keys are skipped.
+ */
+export function parseFilterQuery(entries) {
+    const reserved = new Set(["limit", "offset", "includeArchived"]);
+    const filters = [];
+    for (const [rawKey, value] of entries) {
+        if (reserved.has(rawKey))
+            continue;
+        const match = /^(.+?)(?:\[(-?)([a-zA-Z]+)\])?$/.exec(rawKey);
+        if (!match)
+            continue;
+        const [, key, minus, operator] = match;
+        if (!key)
+            continue;
+        const parsedOperator = operator
+            ? BwmFilterOperator.safeParse(operator)
+            : undefined;
+        if (parsedOperator && !parsedOperator.success)
+            continue;
+        filters.push({
+            key,
+            operator: parsedOperator?.data,
+            negate: minus === "-",
+            value,
+        });
+    }
+    return filters;
+}

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { CRM_ACCESS_ROLE, CRM_BASE, enumSchema, idSchema, listParams, pathSegment, request, STRICT_OBJECT, withQuery, } from "./shared.js";
+import { CRM_ACCESS_ROLE, CRM_BASE, enumSchema, idSchema, pathSegment, request, STRICT_OBJECT, } from "./shared.js";
 export function registerAccessActions(rl) {
     rl.registerAction("access.me", {
         access: "read",
@@ -14,7 +14,7 @@ export function registerAccessActions(rl) {
         description: "List CRM access grants. Requires a CRM admin grant or admin:* permission.",
         inputSchema: t.Object({ includeRevoked: t.Optional(t.Boolean()) }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const body = await request(ctx, withQuery(`${CRM_BASE}/access`, listParams(input)));
+            const body = await request(ctx, `${CRM_BASE}/access`, { query: input });
             return body.grants;
         },
     });

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { CRM_BASE, createRecordFields, idSchema, listParams, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, updateRecordFields, withQuery, } from "./shared.js";
+import { CRM_BASE, createRecordFields, idSchema, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, updateRecordFields, } from "./shared.js";
 const accountListFields = {
     search: t.Optional(t.String({ minLength: 1, pattern: "\\S", description: "Name search" })),
     accountType: t.Optional(t.String({ minLength: 1, description: "Account type filter" })),
@@ -19,7 +19,7 @@ export function registerAccountActions(rl) {
         description: "List the first page of CRM accounts.",
         inputSchema: t.Object(accountListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            const body = await request(ctx, withQuery(`${CRM_BASE}/accounts`, listParams(input)));
+            const body = await request(ctx, `${CRM_BASE}/accounts`, { query: input });
             return body.accounts;
         },
     });
@@ -28,7 +28,7 @@ export function registerAccountActions(rl) {
         description: "List a cursor-paginated page of CRM accounts.",
         inputSchema: t.Object(accountListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            return request(ctx, withQuery(`${CRM_BASE}/accounts`, listParams(input)));
+            return request(ctx, `${CRM_BASE}/accounts`, { query: input });
         },
     });
     rl.registerAction("account.get", {

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { assertTimeOrder, CRM_ACTIVITY_DIRECTION, CRM_ACTIVITY_STATUS, CRM_BASE, createRecordFields, enumSchema, idSchema, listParams, paginationFields, request, STRICT_OBJECT, timestampSchema, withQuery, } from "./shared.js";
+import { assertTimeOrder, CRM_ACTIVITY_DIRECTION, CRM_ACTIVITY_STATUS, CRM_BASE, createRecordFields, enumSchema, idSchema, paginationFields, request, STRICT_OBJECT, timestampSchema, } from "./shared.js";
 const activityListFields = {
     linkedRecordId: t.Optional(idSchema("Filter by linked CRM record ID")),
     status: t.Optional(enumSchema("Activity status", CRM_ACTIVITY_STATUS)),
@@ -11,7 +11,7 @@ export function registerActivityActions(rl) {
         description: "List the first page of CRM activities.",
         inputSchema: t.Object(activityListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            const body = await request(ctx, withQuery(`${CRM_BASE}/activities`, listParams(input)));
+            const body = await request(ctx, `${CRM_BASE}/activities`, { query: input });
             return body.activities;
         },
     });
@@ -20,7 +20,7 @@ export function registerActivityActions(rl) {
         description: "List a cursor-paginated page of CRM activities.",
         inputSchema: t.Object(activityListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            return request(ctx, withQuery(`${CRM_BASE}/activities`, listParams(input)));
+            return request(ctx, `${CRM_BASE}/activities`, { query: input });
         },
     });
     rl.registerAction("activity.log", {

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

@@ -0,0 +1,6 @@
+import { shiftClient } from "../../_shared/shiftCredentials.js";
+/**
+ * A user-subject Shift CRM API key, signed like every Shift key. The probe
+ * reads the key's own CRM access: a key without a grant is rejected there.
+ */
+export const { credential: shiftCrmCredential, request } = shiftClient("shiftCrm", { probe: "crm/access/me" });

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

@@ -2,6 +2,7 @@ import * as t from "typebox";
 import { registerAccessActions } from "./access.js";
 import { registerAccountActions } from "./accounts.js";
 import { registerActivityActions } from "./activities.js";
+import { shiftCrmCredential } from "./credentials.js";
 import { registerImportActions } from "./imports.js";
 import { registerOpportunityActions, registerPipelineActions, } from "./opportunities.js";
 import { registerPersonActions } from "./people.js";
@@ -10,6 +11,7 @@ import { registerTaskActions } from "./tasks.js";
 export default function shiftCrm(rl) {
     rl.setName("shiftCrm");
     rl.setVersion("0.1.0");
+    rl.setCredential(shiftCrmCredential);
     rl.setConnectionSchema(t.Object({
         apiKey: t.String({
             description: "User-subject Shift CRM API key minted by an operator via `bun run crm:access key`. It authenticates as its bound user, whose active CRM access grant authorizes data access. Regular Shift cloud service API keys (SHIFT_LABS_API_KEY) cannot reach CRM data.",

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { CRM_BASE, CRM_PIPELINE_OUTCOME, createRecordFields, enumSchema, idSchema, listParams, nullableTimestamp, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, updateRecordFields, withQuery, } from "./shared.js";
+import { CRM_BASE, CRM_PIPELINE_OUTCOME, createRecordFields, enumSchema, idSchema, nullableTimestamp, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, updateRecordFields, } from "./shared.js";
 const opportunityListFields = {
     accountId: t.Optional(idSchema("Filter by account record ID")),
     pipelineId: t.Optional(idSchema("Filter by pipeline ID")),
@@ -70,7 +70,7 @@ export function registerOpportunityActions(rl) {
         description: "List the first page of CRM opportunities.",
         inputSchema: t.Object(opportunityListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            const body = await request(ctx, withQuery(`${CRM_BASE}/opportunities`, listParams(input)));
+            const body = await request(ctx, `${CRM_BASE}/opportunities`, { query: input });
             return body.opportunities;
         },
     });
@@ -79,7 +79,7 @@ export function registerOpportunityActions(rl) {
         description: "List a cursor-paginated page of CRM opportunities.",
         inputSchema: t.Object(opportunityListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            return request(ctx, withQuery(`${CRM_BASE}/opportunities`, listParams(input)));
+            return request(ctx, `${CRM_BASE}/opportunities`, { query: input });
         },
     });
     rl.registerAction("opportunity.get", {

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { assertTimeOrder, CRM_BASE, CRM_IDENTITY_KIND, createRecordFields, enumSchema, idSchema, listParams, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, updateRecordFields, withQuery, } from "./shared.js";
+import { assertTimeOrder, CRM_BASE, CRM_IDENTITY_KIND, createRecordFields, enumSchema, idSchema, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, updateRecordFields, } from "./shared.js";
 const personListFields = {
     search: t.Optional(t.String({ minLength: 1, pattern: "\\S", description: "Name search" })),
     accountId: t.Optional(idSchema("Filter by affiliated account record ID")),
@@ -55,7 +55,7 @@ export function registerPersonActions(rl) {
         description: "List the first page of CRM people.",
         inputSchema: t.Object(personListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            const body = await request(ctx, withQuery(`${CRM_BASE}/people`, listParams(input)));
+            const body = await request(ctx, `${CRM_BASE}/people`, { query: input });
             return body.people;
         },
     });
@@ -64,7 +64,7 @@ export function registerPersonActions(rl) {
         description: "List a cursor-paginated page of CRM people.",
         inputSchema: t.Object(personListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            return request(ctx, withQuery(`${CRM_BASE}/people`, listParams(input)));
+            return request(ctx, `${CRM_BASE}/people`, { query: input });
         },
     });
     rl.registerAction("person.get", {

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { CRM_BASE, CRM_PROPERTY_DATA_TYPE, enumSchema, idSchema, listParams, pathSegment, recordTypeSchema, request, STRICT_OBJECT, withQuery, } from "./shared.js";
+import { CRM_BASE, CRM_PROPERTY_DATA_TYPE, enumSchema, idSchema, pathSegment, recordTypeSchema, request, STRICT_OBJECT, } from "./shared.js";
 export function registerRecordActions(rl) {
     rl.registerAction("record.changeEvents", {
         access: "read",
@@ -16,7 +16,7 @@ export function registerRecordActions(rl) {
         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)));
+            const body = await request(ctx, `${CRM_BASE}/property-definitions`, { query: input });
             return body.propertyDefinitions;
         },
     });