runline 0.14.1 → 0.15.0

package/dist/plugins/_shared/shiftCloud.js

@@ -0,0 +1,65 @@
+import * as t from "typebox";
+export const STRICT_OBJECT = { additionalProperties: false };
+export const STRICT_UPDATE_OBJECT = {
+    additionalProperties: false,
+    minProperties: 2,
+};
+export function idSchema(description) {
+    return t.String({ minLength: 1, pattern: "\\S", description });
+}
+export function cursorSchema(description = "Next-page cursor") {
+    return t.String({ minLength: 1, maxLength: 512, description });
+}
+export function timestampSchema(description) {
+    return t.String({
+        format: "date-time",
+        pattern: "Z$",
+        description,
+    });
+}
+export function enumDescription(name, values) {
+    return `${name}: ${values.join(" | ")}`;
+}
+export function enumSchema(name, values) {
+    return t.Union(values.map((value) => t.Literal(value)), { description: enumDescription(name, values) });
+}
+const SHIFT_API_URL = "https://cloud.shift-labs.ai";
+export function baseUrl() {
+    return `${SHIFT_API_URL}/`;
+}
+export async function request(ctx, path, init = {}) {
+    const headers = new Headers(init.headers);
+    const apiKey = ctx.connection.config.apiKey;
+    if (typeof apiKey !== "string" || !apiKey) {
+        throw new Error("Shift Labs apiKey is required");
+    }
+    headers.set("authorization", `Bearer ${apiKey}`);
+    if (init.body && !headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    const response = await fetch(new URL(path, baseUrl()), {
+        ...init,
+        headers,
+    });
+    if (!response.ok) {
+        throw new Error(`Shift Labs API error ${response.status}: ${await response.text()}`);
+    }
+    if (response.status === 204)
+        return undefined;
+    return (await response.json());
+}
+export function pathSegment(value) {
+    return encodeURIComponent(value);
+}
+export function listParams(input) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries((input ?? {}))) {
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}
+export function withQuery(path, params) {
+    const query = params.toString();
+    return query ? `${path}?${query}` : path;
+}

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

@@ -0,0 +1,45 @@
+import * as t from "typebox";
+import { CRM_ACCESS_ROLE, CRM_BASE, enumSchema, idSchema, listParams, pathSegment, request, STRICT_OBJECT, withQuery, } from "./shared.js";
+export function registerAccessActions(rl) {
+    rl.registerAction("access.me", {
+        access: "read",
+        description: "Resolve the caller's CRM access role (user, admin, or none). CRM data routes require a user principal with an active grant.",
+        inputSchema: t.Object({}, STRICT_OBJECT),
+        async execute(_input, ctx) {
+            return request(ctx, `${CRM_BASE}/access/me`);
+        },
+    });
+    rl.registerAction("access.list", {
+        access: "read",
+        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)));
+            return body.grants;
+        },
+    });
+    rl.registerAction("access.grant", {
+        access: "write",
+        description: "Grant a Shift user CRM access. Requires a CRM admin grant or admin:* permission.",
+        inputSchema: t.Object({
+            userId: idSchema("Shift user ID to grant access to"),
+            role: t.Optional(enumSchema("CRM access role", CRM_ACCESS_ROLE)),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, `${CRM_BASE}/access`, { method: "POST", body: JSON.stringify(input) });
+            return body.grant;
+        },
+    });
+    rl.registerAction("access.revoke", {
+        access: "write",
+        description: "Revoke a Shift user's CRM access grant. The grant is stamped revoked, not deleted.",
+        inputSchema: t.Object({ userId: idSchema("Shift user ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { userId } = input;
+            await request(ctx, `${CRM_BASE}/access/${pathSegment(userId)}`, {
+                method: "DELETE",
+            });
+            return { revoked: true };
+        },
+    });
+}

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

@@ -0,0 +1,81 @@
+import * as t from "typebox";
+import { CRM_BASE, createRecordFields, idSchema, listParams, paginationFields, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, updateRecordFields, withQuery, } 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" })),
+    lifecycleStage: t.Optional(t.String({ minLength: 1, description: "Lifecycle stage filter" })),
+    includeArchived: t.Optional(t.Boolean()),
+    ...paginationFields(),
+};
+function nullableString(maxLength, description) {
+    return t.Optional(t.Union([
+        t.String({ minLength: 1, maxLength, pattern: "\\S", description }),
+        t.Null(),
+    ]));
+}
+export function registerAccountActions(rl) {
+    rl.registerAction("account.list", {
+        access: "read",
+        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)));
+            return body.accounts;
+        },
+    });
+    rl.registerAction("account.listPage", {
+        access: "read",
+        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)));
+        },
+    });
+    rl.registerAction("account.get", {
+        access: "read",
+        description: "Get a CRM account by record ID.",
+        inputSchema: t.Object({ id: idSchema("Account record ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `${CRM_BASE}/accounts/${pathSegment(id)}`);
+            return body.account;
+        },
+    });
+    rl.registerAction("account.create", {
+        access: "write",
+        description: "Create a CRM account (organization, customer, partner, or competitor).",
+        inputSchema: t.Object({
+            name: t.String({
+                minLength: 1,
+                maxLength: 300,
+                pattern: "\\S",
+                description: "Account name",
+            }),
+            domain: t.Optional(t.String({ minLength: 1, maxLength: 300, pattern: "\\S" })),
+            accountType: t.Optional(t.String({ minLength: 1, maxLength: 100, pattern: "\\S" })),
+            lifecycleStage: t.Optional(t.String({ minLength: 1, maxLength: 100, pattern: "\\S" })),
+            ...createRecordFields(),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, `${CRM_BASE}/accounts`, { method: "POST", body: JSON.stringify(input) });
+            return body.account;
+        },
+    });
+    rl.registerAction("account.update", {
+        access: "write",
+        description: "Update or archive a CRM account. Omitted fields are preserved; null clears a nullable field.",
+        inputSchema: t.Object({
+            id: idSchema("Account record ID"),
+            name: t.Optional(t.String({ minLength: 1, maxLength: 300, pattern: "\\S" })),
+            domain: nullableString(300, "Primary web domain"),
+            accountType: nullableString(100, "Account type"),
+            lifecycleStage: nullableString(100, "Lifecycle stage"),
+            ...updateRecordFields(),
+        }, STRICT_UPDATE_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            const body = await request(ctx, `${CRM_BASE}/accounts/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.account;
+        },
+    });
+}

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

@@ -0,0 +1,61 @@
+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";
+const activityListFields = {
+    linkedRecordId: t.Optional(idSchema("Filter by linked CRM record ID")),
+    status: t.Optional(enumSchema("Activity status", CRM_ACTIVITY_STATUS)),
+    ...paginationFields(),
+};
+export function registerActivityActions(rl) {
+    rl.registerAction("activity.list", {
+        access: "read",
+        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)));
+            return body.activities;
+        },
+    });
+    rl.registerAction("activity.listPage", {
+        access: "read",
+        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)));
+        },
+    });
+    rl.registerAction("activity.log", {
+        access: "write",
+        description: "Log an append-only CRM activity (call, meeting, message, note). Must link to at least one CRM record via relationships.",
+        inputSchema: t.Object({
+            activityType: t.String({
+                minLength: 1,
+                maxLength: 100,
+                pattern: "\\S",
+                description: "Activity type, e.g. call, meeting, note",
+            }),
+            channel: t.Optional(t.String({ minLength: 1, maxLength: 100, pattern: "\\S" })),
+            direction: t.Optional(enumSchema("Activity direction", CRM_ACTIVITY_DIRECTION)),
+            status: t.Optional(enumSchema("Activity status", CRM_ACTIVITY_STATUS)),
+            subject: t.String({
+                minLength: 1,
+                maxLength: 500,
+                pattern: "\\S",
+                description: "Activity subject",
+            }),
+            body: t.Optional(t.String({ maxLength: 100_000 })),
+            startedAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
+            endedAt: t.Optional(timestampSchema("ISO-8601 end timestamp")),
+            externalKey: t.Optional(t.String({ minLength: 1, maxLength: 500, pattern: "\\S" })),
+            ...createRecordFields(),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const fields = input;
+            if (!fields.relationships || fields.relationships.length === 0) {
+                throw new Error("An activity must link to at least one CRM record via relationships");
+            }
+            assertTimeOrder(fields.startedAt, fields.endedAt, "Activity endedAt must not precede startedAt");
+            const body = await request(ctx, `${CRM_BASE}/activities`, { method: "POST", body: JSON.stringify(input) });
+            return body.activity;
+        },
+    });
+}

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

@@ -0,0 +1,101 @@
+import * as t from "typebox";
+import { CRM_BASE, idSchema, pathSegment, recordTypeSchema, request, STRICT_OBJECT, } from "./shared.js";
+export function registerImportActions(rl) {
+    rl.registerAction("import.create", {
+        access: "write",
+        description: "Create a CRM import run for a source system. Requires a CRM admin grant.",
+        inputSchema: t.Object({
+            sourceSystem: t.String({
+                minLength: 1,
+                maxLength: 100,
+                pattern: "\\S",
+                description: "Source system name, e.g. hubspot",
+            }),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, `${CRM_BASE}/imports`, { method: "POST", body: JSON.stringify(input) });
+            return body.importRun;
+        },
+    });
+    rl.registerAction("import.list", {
+        access: "read",
+        description: "List CRM import runs. Requires a CRM admin grant.",
+        inputSchema: t.Object({}, STRICT_OBJECT),
+        async execute(_input, ctx) {
+            const body = await request(ctx, `${CRM_BASE}/imports`);
+            return body.importRuns;
+        },
+    });
+    rl.registerAction("import.get", {
+        access: "read",
+        description: "Get a CRM import run and its staged rows. Requires a CRM admin grant.",
+        inputSchema: t.Object({ id: idSchema("Import run ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            return request(ctx, `${CRM_BASE}/imports/${pathSegment(id)}`);
+        },
+    });
+    rl.registerAction("import.stageRows", {
+        access: "write",
+        description: "Stage immutable raw rows on an import run (1-500 per call). Each row carries its typed source identity and raw payload.",
+        inputSchema: t.Object({
+            importRunId: idSchema("Import run ID"),
+            rows: t.Array(t.Object({
+                sourceId: t.String({
+                    minLength: 1,
+                    maxLength: 500,
+                    pattern: "\\S",
+                    description: "Stable ID in the source system",
+                }),
+                recordType: recordTypeSchema(),
+                rawPayload: t.Unknown({
+                    description: "Immutable raw source payload",
+                }),
+            }, { additionalProperties: false }), { minItems: 1, maxItems: 500 }),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { importRunId, ...payload } = input;
+            const body = await request(ctx, `${CRM_BASE}/imports/${pathSegment(importRunId)}/rows`, { method: "POST", body: JSON.stringify(payload) });
+            return body.rows;
+        },
+    });
+    rl.registerAction("import.commitRow", {
+        access: "write",
+        description: "Commit one staged import row with its typed transformed payload. Record creation, row result, and change event commit atomically.",
+        inputSchema: t.Object({
+            importRunId: idSchema("Import run ID"),
+            rowId: idSchema("Import row ID"),
+            transformedPayload: t.Unknown({
+                description: "Typed create payload for the row's record type (matches the corresponding create action input)",
+            }),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { importRunId, rowId, transformedPayload } = input;
+            const body = await request(ctx, `${CRM_BASE}/imports/${pathSegment(importRunId)}/rows/${pathSegment(rowId)}/commit`, { method: "POST", body: JSON.stringify({ transformedPayload }) });
+            return body.record;
+        },
+    });
+    rl.registerAction("import.skipRow", {
+        access: "write",
+        description: "Explicitly skip a staged import row without creating a record.",
+        inputSchema: t.Object({
+            importRunId: idSchema("Import run ID"),
+            rowId: idSchema("Import row ID"),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { importRunId, rowId } = input;
+            const body = await request(ctx, `${CRM_BASE}/imports/${pathSegment(importRunId)}/rows/${pathSegment(rowId)}/skip`, { method: "POST" });
+            return body.row;
+        },
+    });
+    rl.registerAction("import.commit", {
+        access: "write",
+        description: "Commit an import run. Allowed only after every staged row is imported or skipped.",
+        inputSchema: t.Object({ id: idSchema("Import run ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `${CRM_BASE}/imports/${pathSegment(id)}/commit`, { method: "POST" });
+            return body.importRun;
+        },
+    });
+}

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

@@ -0,0 +1,28 @@
+import * as t from "typebox";
+import { registerAccessActions } from "./access.js";
+import { registerAccountActions } from "./accounts.js";
+import { registerActivityActions } from "./activities.js";
+import { registerImportActions } from "./imports.js";
+import { registerOpportunityActions, registerPipelineActions, } from "./opportunities.js";
+import { registerPersonActions } from "./people.js";
+import { registerRecordActions } from "./records.js";
+import { registerTaskActions } from "./tasks.js";
+export default function shiftCrm(rl) {
+    rl.setName("shiftCrm");
+    rl.setVersion("0.1.0");
+    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.",
+            env: "SHIFT_CRM_API_KEY",
+        }),
+    }));
+    registerAccessActions(rl);
+    registerAccountActions(rl);
+    registerPersonActions(rl);
+    registerPipelineActions(rl);
+    registerOpportunityActions(rl);
+    registerActivityActions(rl);
+    registerTaskActions(rl);
+    registerRecordActions(rl);
+    registerImportActions(rl);
+}

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

@@ -0,0 +1,145 @@
+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";
+const opportunityListFields = {
+    accountId: t.Optional(idSchema("Filter by account record ID")),
+    pipelineId: t.Optional(idSchema("Filter by pipeline ID")),
+    stageId: t.Optional(idSchema("Filter by stage ID")),
+    includeArchived: t.Optional(t.Boolean()),
+    ...paginationFields(),
+};
+const probabilitySchema = t.Integer({
+    minimum: 0,
+    maximum: 100,
+    description: "Win probability percent",
+});
+export function registerPipelineActions(rl) {
+    rl.registerAction("pipeline.list", {
+        access: "read",
+        description: "List CRM opportunity pipelines with their ordered stages.",
+        inputSchema: t.Object({}, STRICT_OBJECT),
+        async execute(_input, ctx) {
+            const body = await request(ctx, `${CRM_BASE}/pipelines`);
+            return body.pipelines;
+        },
+    });
+    rl.registerAction("pipeline.get", {
+        access: "read",
+        description: "Get a CRM pipeline and its stages by ID.",
+        inputSchema: t.Object({ id: idSchema("Pipeline ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `${CRM_BASE}/pipelines/${pathSegment(id)}`);
+            return body.pipeline;
+        },
+    });
+    rl.registerAction("pipeline.create", {
+        access: "write",
+        description: "Create a CRM opportunity pipeline with ordered stages. Requires a CRM admin grant.",
+        inputSchema: t.Object({
+            name: t.String({
+                minLength: 1,
+                maxLength: 200,
+                pattern: "\\S",
+                description: "Pipeline name",
+            }),
+            isDefault: t.Optional(t.Boolean()),
+            stages: t.Array(t.Object({
+                key: t.String({ minLength: 1, maxLength: 100, pattern: "\\S" }),
+                name: t.String({ minLength: 1, maxLength: 200, pattern: "\\S" }),
+                position: t.Integer({ minimum: 0 }),
+                outcome: t.Optional(enumSchema("Stage outcome", CRM_PIPELINE_OUTCOME)),
+                defaultProbability: t.Optional(probabilitySchema),
+            }, { additionalProperties: false }), { minItems: 1 }),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { stages } = input;
+            if (new Set(stages.map((s) => s.key)).size !== stages.length) {
+                throw new Error("Duplicate pipeline stage key");
+            }
+            if (new Set(stages.map((s) => s.position)).size !== stages.length) {
+                throw new Error("Duplicate pipeline stage position");
+            }
+            const body = await request(ctx, `${CRM_BASE}/pipelines`, { method: "POST", body: JSON.stringify(input) });
+            return body.pipeline;
+        },
+    });
+}
+export function registerOpportunityActions(rl) {
+    rl.registerAction("opportunity.list", {
+        access: "read",
+        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)));
+            return body.opportunities;
+        },
+    });
+    rl.registerAction("opportunity.listPage", {
+        access: "read",
+        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)));
+        },
+    });
+    rl.registerAction("opportunity.get", {
+        access: "read",
+        description: "Get a CRM opportunity by record ID.",
+        inputSchema: t.Object({ id: idSchema("Opportunity record ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `${CRM_BASE}/opportunities/${pathSegment(id)}`);
+            return body.opportunity;
+        },
+    });
+    rl.registerAction("opportunity.create", {
+        access: "write",
+        description: "Create a CRM opportunity in a pipeline stage. accountId may be omitted while attribution is unresolved.",
+        inputSchema: t.Object({
+            accountId: t.Optional(idSchema("Account record ID")),
+            pipelineId: idSchema("Pipeline ID"),
+            stageId: idSchema("Stage ID (must belong to the pipeline)"),
+            title: t.String({
+                minLength: 1,
+                maxLength: 500,
+                pattern: "\\S",
+                description: "Opportunity title",
+            }),
+            amount: t.Optional(t.Number({ minimum: 0 })),
+            currency: t.Optional(t.String({ minLength: 1, maxLength: 10, pattern: "\\S" })),
+            probability: t.Optional(probabilitySchema),
+            expectedCloseAt: t.Optional(timestampSchema("ISO-8601 expected close timestamp")),
+            nextStep: t.Optional(t.String({ maxLength: 50_000 })),
+            closeReason: t.Optional(t.String({ maxLength: 10_000 })),
+            ...createRecordFields(),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, `${CRM_BASE}/opportunities`, { method: "POST", body: JSON.stringify(input) });
+            return body.opportunity;
+        },
+    });
+    rl.registerAction("opportunity.update", {
+        access: "write",
+        description: "Update or archive a CRM opportunity, including moving it to another stage of its pipeline.",
+        inputSchema: t.Object({
+            id: idSchema("Opportunity record ID"),
+            stageId: t.Optional(idSchema("Stage ID within the same pipeline")),
+            title: t.Optional(t.String({ minLength: 1, maxLength: 500, pattern: "\\S" })),
+            amount: t.Optional(t.Union([t.Number({ minimum: 0 }), t.Null()])),
+            currency: t.Optional(t.Union([
+                t.String({ minLength: 1, maxLength: 10, pattern: "\\S" }),
+                t.Null(),
+            ])),
+            probability: t.Optional(t.Union([probabilitySchema, t.Null()])),
+            expectedCloseAt: nullableTimestamp("ISO-8601 expected close timestamp"),
+            nextStep: t.Optional(t.Union([t.String({ maxLength: 50_000 }), t.Null()])),
+            closeReason: t.Optional(t.Union([t.String({ maxLength: 10_000 }), t.Null()])),
+            ...updateRecordFields(),
+        }, STRICT_UPDATE_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            const body = await request(ctx, `${CRM_BASE}/opportunities/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.opportunity;
+        },
+    });
+}

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

@@ -0,0 +1,117 @@
+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";
+const personListFields = {
+    search: t.Optional(t.String({ minLength: 1, pattern: "\\S", description: "Name search" })),
+    accountId: t.Optional(idSchema("Filter by affiliated account record ID")),
+    includeArchived: t.Optional(t.Boolean()),
+    ...paginationFields(),
+};
+function identitySchema() {
+    return t.Object({
+        kind: enumSchema("Identity kind", CRM_IDENTITY_KIND),
+        value: t.String({
+            minLength: 1,
+            maxLength: 1_000,
+            pattern: "\\S",
+            description: "Identity value, e.g. an email address",
+        }),
+        isPrimary: t.Optional(t.Boolean()),
+    }, { additionalProperties: false });
+}
+function affiliationSchema() {
+    return t.Object({
+        accountId: idSchema("Account record ID"),
+        title: t.Optional(t.String({ minLength: 1, maxLength: 300, pattern: "\\S" })),
+        role: t.Optional(t.String({ minLength: 1, maxLength: 200, pattern: "\\S" })),
+        isPrimary: t.Optional(t.Boolean()),
+        startedAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
+        endedAt: t.Optional(timestampSchema("ISO-8601 end timestamp")),
+    }, { additionalProperties: false });
+}
+function assertPersonDetails(input) {
+    const primaryKinds = new Set();
+    for (const identity of input.identities ?? []) {
+        if (!identity.isPrimary)
+            continue;
+        if (primaryKinds.has(identity.kind)) {
+            throw new Error(`A person may have only one primary ${identity.kind} identity`);
+        }
+        primaryKinds.add(identity.kind);
+    }
+    const accounts = input.accounts ?? [];
+    if (accounts.filter((a) => a.isPrimary && !a.endedAt).length > 1) {
+        throw new Error("A person may have only one current primary account");
+    }
+    if (new Set(accounts.map((a) => a.accountId)).size !== accounts.length) {
+        throw new Error("Duplicate account affiliation");
+    }
+    for (const account of accounts) {
+        assertTimeOrder(account.startedAt, account.endedAt, "Affiliation endedAt must not precede startedAt");
+    }
+}
+export function registerPersonActions(rl) {
+    rl.registerAction("person.list", {
+        access: "read",
+        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)));
+            return body.people;
+        },
+    });
+    rl.registerAction("person.listPage", {
+        access: "read",
+        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)));
+        },
+    });
+    rl.registerAction("person.get", {
+        access: "read",
+        description: "Get a CRM person with identities and account affiliations by record ID.",
+        inputSchema: t.Object({ id: idSchema("Person record ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `${CRM_BASE}/people/${pathSegment(id)}`);
+            return body.person;
+        },
+    });
+    rl.registerAction("person.create", {
+        access: "write",
+        description: "Create a CRM person with normalized identities (email, phone, WhatsApp, LinkedIn) and account affiliations.",
+        inputSchema: t.Object({
+            name: t.String({
+                minLength: 1,
+                maxLength: 300,
+                pattern: "\\S",
+                description: "Person name",
+            }),
+            identities: t.Optional(t.Array(identitySchema())),
+            accounts: t.Optional(t.Array(affiliationSchema())),
+            ...createRecordFields(),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            assertPersonDetails(input);
+            const body = await request(ctx, `${CRM_BASE}/people`, { method: "POST", body: JSON.stringify(input) });
+            return body.person;
+        },
+    });
+    rl.registerAction("person.update", {
+        access: "write",
+        description: "Update or archive a CRM person. Supplied identities and accounts replace the existing sets.",
+        inputSchema: t.Object({
+            id: idSchema("Person record ID"),
+            name: t.Optional(t.String({ minLength: 1, maxLength: 300, pattern: "\\S" })),
+            identities: t.Optional(t.Array(identitySchema())),
+            accounts: t.Optional(t.Array(affiliationSchema())),
+            ...updateRecordFields(),
+        }, STRICT_UPDATE_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            assertPersonDetails(patch);
+            const body = await request(ctx, `${CRM_BASE}/people/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.person;
+        },
+    });
+}

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/shared.js

@@ -1,50 +1,5 @@
-import * as t from "typebox";
-export const STRICT_OBJECT = { additionalProperties: false };
-export const STRICT_UPDATE_OBJECT = {
-    additionalProperties: false,
-    minProperties: 2,
-};
-export function idSchema(description) {
-    return t.String({ minLength: 1, pattern: "\\S", description });
-}
-export function cursorSchema(description = "Next-page cursor") {
-    return t.String({ minLength: 1, maxLength: 512, description });
-}
-export function timestampSchema(description) {
-    return t.String({
-        format: "date-time",
-        pattern: "Z$",
-        description,
-    });
-}
-const SHIFT_LABS_API_URL = "https://d1ood6y5zobtne.cloudfront.net";
-export function baseUrl() {
-    return `${SHIFT_LABS_API_URL}/`;
-}
-export async function request(ctx, path, init = {}) {
-    const headers = new Headers(init.headers);
-    const apiKey = ctx.connection.config.apiKey;
-    if (typeof apiKey !== "string" || !apiKey) {
-        throw new Error("Shift Labs apiKey is required");
-    }
-    headers.set("authorization", `Bearer ${apiKey}`);
-    if (init.body && !headers.has("content-type")) {
-        headers.set("content-type", "application/json");
-    }
-    const response = await fetch(new URL(path, baseUrl()), {
-        ...init,
-        headers,
-    });
-    if (!response.ok) {
-        throw new Error(`Shift Labs API error ${response.status}: ${await response.text()}`);
-    }
-    if (response.status === 204)
-        return undefined;
-    return (await response.json());
-}
-export function pathSegment(value) {
-    return encodeURIComponent(value);
-}
+import { baseUrl, pathSegment } from "../../_shared/shiftCloud.js";
+export { baseUrl, cursorSchema, enumDescription, enumSchema, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "../../_shared/shiftCloud.js";
 export function pageRenderUrl(organizationId, slug) {
     return new URL(`/pages/${pathSegment(organizationId)}/${pathSegment(slug)}`, baseUrl()).toString();
 }
@@ -94,9 +49,3 @@ export const PAGE_STATUS = ["draft", "published", "archived"];
 export const PAGE_VISIBILITY = ["org", "invited"];
 export const TRANSCRIPTION_LANGUAGE = ["auto", "en", "he"];
 export const TRANSCRIPT_FORMAT = ["txt", "srt", "vtt", "json"];
-export function enumDescription(name, values) {
-    return `${name}: ${values.join(" | ")}`;
-}
-export function enumSchema(name, values) {
-    return t.Union(values.map((value) => t.Literal(value)), { description: enumDescription(name, values) });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",