runline 0.13.0 → 0.14.1

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

@@ -1,6 +1,8 @@
 import * as t from "typebox";
+import { registerIssueViewActions } from "./issue-views.js";
 import { registerIssueActions } from "./issues.js";
 import { registerPageActions } from "./pages.js";
+import { registerProjectActions } from "./projects.js";
 import { registerTranscriptionActions } from "./transcription.js";
 export default function shiftLabs(rl) {
     rl.setName("shiftLabs");
@@ -15,7 +17,9 @@ export default function shiftLabs(rl) {
             env: "SHIFT_LABS_ORG_ID",
         })),
     }));
+    registerProjectActions(rl);
     registerIssueActions(rl);
+    registerIssueViewActions(rl);
     registerPageActions(rl);
     registerTranscriptionActions(rl);
 }

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

@@ -0,0 +1,200 @@
+import * as t from "typebox";
+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,
+        pattern: "\\S",
+        description: "View name",
+    }),
+    visibility: t.Optional(t.Literal("organization")),
+    layout: t.Optional(enumSchema("View layout", ISSUE_VIEW_LAYOUT)),
+    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(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), {
+        minItems: 1,
+        maxItems: 3,
+    })),
+};
+export function registerIssueViewActions(rl) {
+    const listFields = {
+        visibility: t.Optional(enumSchema("View visibility", ISSUE_VIEW_VISIBILITY)),
+        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, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, `/v1/issue-views?${listParams(input)}`);
+            return body.views;
+        },
+    });
+    rl.registerAction("issueView.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of Issue Views.",
+        inputSchema: t.Object(listFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            return request(ctx, `/v1/issue-views?${listParams(input)}`);
+        },
+    });
+    rl.registerAction("issueView.get", {
+        access: "read",
+        description: "Get an Issue View by ID.",
+        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)}`);
+            return body.view;
+        },
+    });
+    rl.registerAction("issueView.issues", {
+        access: "read",
+        description: "Execute the first page of a saved Issue View.",
+        inputSchema: t.Object({
+            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)));
+            return body.issues;
+        },
+    });
+    rl.registerAction("issueView.issuesPage", {
+        access: "read",
+        description: "Execute a cursor-paginated page of a saved Issue View.",
+        inputSchema: t.Object({
+            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)));
+        },
+    });
+    rl.registerAction("issueView.create", {
+        access: "write",
+        description: "Create a bounded saved Issue query. Views never own Issue membership.",
+        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(fields)),
+            });
+            return body.view;
+        },
+    });
+    rl.registerAction("issueView.update", {
+        access: "write",
+        description: "Patch a saved Issue View. Null filter values remove that filter without replacing unrelated filters.",
+        inputSchema: t.Object({
+            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: 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(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,
+            })),
+        }, 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;
+        },
+    });
+    rl.registerAction("issueView.delete", {
+        access: "write",
+        description: "Delete a saved Issue View without changing any Issues.",
+        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)}`, {
+                method: "DELETE",
+            });
+            return { deleted: true };
+        },
+    });
+}
+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;
+}
+function withQuery(path, params) {
+    const query = params.toString();
+    return query ? `${path}?${query}` : path;
+}
+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()]));
+}
+function toViewBody(input, applyDefaults = true) {
+    const { projectId, rootIssueId, statuses, priorities, assigneeUserIds, labels, startAfter, dueBefore, blocked, ...view } = input;
+    const filters = Object.fromEntries(Object.entries({
+        projectId,
+        rootIssueId,
+        statuses,
+        priorities,
+        assigneeUserIds,
+        labels,
+        startAfter,
+        dueBefore,
+        blocked,
+    }).filter(([, value]) => value !== undefined));
+    return {
+        ...view,
+        ...(applyDefaults
+            ? {
+                visibility: view.visibility ?? "organization",
+                layout: view.layout ?? "list",
+            }
+            : {}),
+        ...(Object.keys(filters).length > 0 ? { filters } : {}),
+        ...(applyDefaults && view.sortBy === undefined
+            ? { sortBy: ["updatedAt"] }
+            : {}),
+    };
+}

package/dist/plugins/shiftLabs/src/issues.js

@@ -1,74 +1,202 @@
 import * as t from "typebox";
-import { enumSchema, ISSUE_KIND, ISSUE_PRIORITY, ISSUE_SEVERITY, ISSUE_SOURCE, ISSUE_STATUS, request, } from "./shared.js";
+import { cursorSchema, enumSchema, ISSUE_PRIORITY, ISSUE_SOURCE, ISSUE_STATUS, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "./shared.js";
+const issueListFields = {
+    status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
+    projectId: t.Optional(idSchema("Project ID")),
+    parentIssueId: t.Optional(idSchema("Parent Issue ID")),
+    assigneeUserId: t.Optional(idSchema("Assignee user ID")),
+    source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
+    includeArchived: t.Optional(t.Boolean()),
+    cursor: t.Optional(cursorSchema()),
+    limit: t.Optional(t.Integer({
+        minimum: 1,
+        maximum: 100,
+        description: "Max results, default 50",
+    })),
+};
+function issueListParams(input) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries((input ?? {}))) {
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}
+function withQuery(path, params) {
+    const query = params.toString();
+    return query ? `${path}?${query}` : path;
+}
 export function registerIssueActions(rl) {
     rl.registerAction("issue.list", {
         access: "read",
-        description: "List Shift Labs issues for the API key's organization.",
-        inputSchema: t.Object({
-            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
-            assigneeUserId: t.Optional(t.String()),
-            source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
-            limit: t.Optional(t.Number({ description: "Max results, default 50" })),
-        }),
+        description: "List the first page of Shift Labs Issues for the API key's organization.",
+        inputSchema: t.Object(issueListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            const fields = (input ?? {});
-            const params = new URLSearchParams();
-            for (const key of ["status", "assigneeUserId", "source", "limit"]) {
-                const value = fields[key];
-                if (value !== undefined)
-                    params.set(key, String(value));
-            }
-            const body = await request(ctx, `/v1/issues?${params}`);
+            const body = await request(ctx, `/v1/issues?${issueListParams(input)}`);
             return body.issues;
         },
     });
+    rl.registerAction("issue.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of Shift Labs Issues.",
+        inputSchema: t.Object(issueListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            return request(ctx, `/v1/issues?${issueListParams(input)}`);
+        },
+    });
     rl.registerAction("issue.get", {
         access: "read",
-        description: "Get a Shift Labs issue by ID.",
-        inputSchema: t.Object({ id: t.String({ description: "Issue ID" }) }),
+        description: "Get a Shift Labs Issue by ID.",
+        inputSchema: t.Object({ id: idSchema("Issue ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
-            const body = await request(ctx, `/v1/issues/${encodeURIComponent(id)}`);
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}`);
             return body.issue;
         },
     });
     rl.registerAction("issue.create", {
         access: "write",
-        description: "Create a Shift Labs issue. The issue starts in triage.",
+        description: "Create an Issue. Leave projectId empty for inbox work; parentIssueId requires a Project.",
         inputSchema: t.Object({
-            title: t.String({ description: "Issue title" }),
-            description: t.Optional(t.String({ description: "Issue description" })),
-            kind: t.Optional(enumSchema("Issue kind", ISSUE_KIND)),
+            title: t.String({
+                minLength: 1,
+                maxLength: 160,
+                pattern: "\\S",
+                description: "Issue title",
+            }),
+            description: t.Optional(t.String({ maxLength: 20_000, description: "Issue description" })),
+            projectId: t.Optional(idSchema("Project ID")),
+            parentIssueId: t.Optional(idSchema("Parent Issue ID")),
+            sortOrder: t.Optional(t.Integer({ minimum: 0 })),
+            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
             priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
-            severity: t.Optional(enumSchema("Issue severity", ISSUE_SEVERITY)),
             source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
-            deploymentId: t.Optional(t.String()),
-            workspaceId: t.Optional(t.String()),
-            sessionId: t.Optional(t.String()),
-            traceId: t.Optional(t.String()),
-            fingerprint: t.Optional(t.String()),
-            labels: t.Optional(t.Array(t.String())),
-            metadata: t.Optional(t.Object({}, { description: "Issue metadata" })),
-        }),
+            assigneeUserId: t.Optional(idSchema("Assignee user ID")),
+            startAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
+            dueAt: t.Optional(timestampSchema("ISO-8601 due timestamp")),
+            deploymentId: t.Optional(idSchema("Deployment ID")),
+            workspaceId: t.Optional(idSchema("Workspace ID")),
+            sessionId: t.Optional(idSchema("Session ID")),
+            traceId: t.Optional(idSchema("Trace ID")),
+            fingerprint: t.Optional(t.String({ minLength: 1, maxLength: 512, pattern: "\\S" })),
+            labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }))),
+            metadata: t.Optional(t.Record(t.String(), t.Unknown(), { description: "Issue metadata" })),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
+            const fields = input;
+            if (fields.parentIssueId !== undefined &&
+                fields.projectId === undefined) {
+                throw new Error("projectId is required when parentIssueId is set");
+            }
+            assertDateOrder(fields.startAt, fields.dueAt, "Issue dueAt must not precede startAt");
             const body = await request(ctx, "/v1/issues", {
                 method: "POST",
-                body: JSON.stringify(input),
+                body: JSON.stringify(fields),
             });
             return body.issue;
         },
     });
+    rl.registerAction("issue.update", {
+        access: "write",
+        description: "Update an Issue, including Project assignment, one-level parentage, ordering, status, dates, or assignee.",
+        inputSchema: t.Object({
+            id: idSchema("Issue ID"),
+            title: t.Optional(t.String({ minLength: 1, maxLength: 160, pattern: "\\S" })),
+            description: t.Optional(t.String({ maxLength: 20_000 })),
+            projectId: t.Optional(t.Union([idSchema("Project ID"), t.Null()])),
+            parentIssueId: t.Optional(t.Union([idSchema("Parent Issue ID"), t.Null()])),
+            sortOrder: t.Optional(t.Integer({ minimum: 0 })),
+            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
+            priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
+            assigneeUserId: t.Optional(t.Union([idSchema("Assignee user ID"), t.Null()])),
+            startAt: t.Optional(t.Union([timestampSchema("ISO-8601 start timestamp"), t.Null()])),
+            dueAt: t.Optional(t.Union([timestampSchema("ISO-8601 due timestamp"), t.Null()])),
+            labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }))),
+            archived: t.Optional(t.Boolean()),
+        }, STRICT_UPDATE_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            assertDateOrder(patch.startAt, patch.dueAt, "Issue dueAt must not precede startAt");
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.issue;
+        },
+    });
     rl.registerAction("issue.comment", {
         access: "write",
-        description: "Add a comment to a Shift Labs issue.",
+        description: "Add a comment to a Shift Labs Issue.",
         inputSchema: t.Object({
-            id: t.String({ description: "Issue ID" }),
-            body: t.String({ description: "Comment body" }),
-        }),
+            id: idSchema("Issue ID"),
+            body: t.String({
+                minLength: 1,
+                maxLength: 20_000,
+                pattern: "\\S",
+                description: "Comment body",
+            }),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, body } = input;
-            const response = await request(ctx, `/v1/issues/${encodeURIComponent(id)}/comments`, { method: "POST", body: JSON.stringify({ body }) });
+            const response = await request(ctx, `/v1/issues/${pathSegment(id)}/comments`, { method: "POST", body: JSON.stringify({ body }) });
             return response.event;
         },
     });
+    rl.registerAction("issue.dependency.list", {
+        access: "read",
+        description: "List the first page of blocking and blocked-by links.",
+        inputSchema: t.Object({
+            id: idSchema("Issue 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/issues/${pathSegment(id)}/dependencies`, issueListParams(pagination)));
+            return body.dependencies;
+        },
+    });
+    rl.registerAction("issue.dependency.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of Issue dependencies.",
+        inputSchema: t.Object({
+            id: idSchema("Issue 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/issues/${pathSegment(id)}/dependencies`, issueListParams(pagination)));
+        },
+    });
+    rl.registerAction("issue.dependency.add", {
+        access: "write",
+        description: "Declare that one Issue blocks another Issue.",
+        inputSchema: t.Object({
+            blockedIssueId: idSchema("Issue that is blocked"),
+            blockingIssueId: idSchema("Issue that blocks it"),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { blockedIssueId, blockingIssueId } = input;
+            if (blockedIssueId === blockingIssueId) {
+                throw new Error("An Issue cannot block itself");
+            }
+            const body = await request(ctx, `/v1/issues/${pathSegment(blockedIssueId)}/dependencies`, { method: "POST", body: JSON.stringify({ blockingIssueId }) });
+            return body.dependency;
+        },
+    });
+    rl.registerAction("issue.dependency.remove", {
+        access: "write",
+        description: "Remove an Issue dependency link.",
+        inputSchema: t.Object({
+            issueId: idSchema("Issue ID"),
+            dependencyId: idSchema("Dependency ID"),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { issueId, dependencyId } = input;
+            await request(ctx, `/v1/issues/${pathSegment(issueId)}/dependencies/${pathSegment(dependencyId)}`, { method: "DELETE" });
+            return { removed: true };
+        },
+    });
+}
+function assertDateOrder(start, end, message) {
+    if (typeof start === "string" && typeof end === "string" && start > end) {
+        throw new Error(message);
+    }
 }

package/dist/plugins/shiftLabs/src/pages.js

@@ -1,13 +1,23 @@
 import * as t from "typebox";
-import { enumSchema, PAGE_STATUS, PAGE_VISIBILITY, pageRenderUrl, request, } from "./shared.js";
+import { enumSchema, idSchema, PAGE_STATUS, PAGE_VISIBILITY, pageRenderUrl, pathSegment, request, STRICT_OBJECT, timestampSchema, } from "./shared.js";
+const PageSlug = t.String({
+    minLength: 1,
+    maxLength: 120,
+    pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$",
+    description: "Lowercase kebab-case page slug",
+});
 export function registerPageActions(rl) {
     rl.registerAction("page.list", {
         access: "read",
         description: "List Shift Labs pages for the API key's organization.",
         inputSchema: t.Object({
             status: t.Optional(enumSchema("Page status", PAGE_STATUS)),
-            limit: t.Optional(t.Number({ description: "Max results, default 50" })),
-        }),
+            limit: t.Optional(t.Integer({
+                minimum: 1,
+                maximum: 100,
+                description: "Max results, default 50",
+            })),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = (input ?? {});
             const params = new URLSearchParams();
@@ -22,10 +32,10 @@ export function registerPageActions(rl) {
     rl.registerAction("page.get", {
         access: "read",
         description: "Get a Shift Labs page by ID.",
-        inputSchema: t.Object({ id: t.String({ description: "Page ID" }) }),
+        inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
-            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}`);
+            const body = await request(ctx, `/v1/pages/${pathSegment(id)}`);
             return body.page;
         },
     });
@@ -33,11 +43,19 @@ export function registerPageActions(rl) {
         access: "write",
         description: "Create a draft hosted HTML page. Agents can publish it with page.publish.",
         inputSchema: t.Object({
-            slug: t.String({ description: "Lowercase kebab-case page slug" }),
-            title: t.String({ description: "Page title" }),
-            html: t.Optional(t.String({ description: "Hosted HTML content" })),
+            slug: PageSlug,
+            title: t.String({
+                minLength: 1,
+                maxLength: 160,
+                pattern: "\\S",
+                description: "Page title",
+            }),
+            html: t.Optional(t.String({
+                maxLength: 1_000_000,
+                description: "Hosted HTML content",
+            })),
             visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
-        }),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
             const body = await request(ctx, "/v1/pages", {
@@ -55,15 +73,23 @@ export function registerPageActions(rl) {
         access: "write",
         description: "Update a hosted HTML page's slug, title, visibility, or HTML.",
         inputSchema: t.Object({
-            id: t.String({ description: "Page ID" }),
-            slug: t.Optional(t.String({ description: "Lowercase kebab-case page slug" })),
-            title: t.Optional(t.String({ description: "Page title" })),
+            id: idSchema("Page ID"),
+            slug: t.Optional(PageSlug),
+            title: t.Optional(t.String({
+                minLength: 1,
+                maxLength: 160,
+                pattern: "\\S",
+                description: "Page title",
+            })),
             visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
-            html: t.Optional(t.String({ description: "Hosted HTML content" })),
-        }),
+            html: t.Optional(t.String({
+                maxLength: 1_000_000,
+                description: "Hosted HTML content",
+            })),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, ...fields } = input;
-            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}`, {
+            const body = await request(ctx, `/v1/pages/${pathSegment(String(id))}`, {
                 method: "PATCH",
                 body: JSON.stringify(fields),
             });
@@ -73,30 +99,30 @@ export function registerPageActions(rl) {
     rl.registerAction("page.publish", {
         access: "write",
         description: "Publish a Shift Labs hosted HTML page.",
-        inputSchema: t.Object({ id: t.String({ description: "Page ID" }) }),
+        inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
-            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}/publish`, { method: "POST" });
+            const body = await request(ctx, `/v1/pages/${pathSegment(id)}/publish`, { method: "POST" });
             return body.page;
         },
     });
     rl.registerAction("page.archive", {
         access: "write",
         description: "Archive a Shift Labs page.",
-        inputSchema: t.Object({ id: t.String({ description: "Page ID" }) }),
+        inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
-            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}/archive`, { method: "POST" });
+            const body = await request(ctx, `/v1/pages/${pathSegment(id)}/archive`, { method: "POST" });
             return body.page;
         },
     });
     rl.registerAction("page.shares", {
         access: "read",
         description: "List shares for a Shift Labs page.",
-        inputSchema: t.Object({ pageId: t.String({ description: "Page ID" }) }),
+        inputSchema: t.Object({ pageId: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { pageId } = input;
-            const body = await request(ctx, `/v1/pages/${encodeURIComponent(pageId)}/shares`);
+            const body = await request(ctx, `/v1/pages/${pathSegment(pageId)}/shares`);
             return body.shares;
         },
     });
@@ -104,13 +130,17 @@ export function registerPageActions(rl) {
         access: "write",
         description: "Create a viewer share for a Shift Labs page.",
         inputSchema: t.Object({
-            pageId: t.String({ description: "Page ID" }),
-            email: t.String({ description: "Viewer email address" }),
-            expiresAt: t.Optional(t.String({ description: "Optional ISO expiration" })),
-        }),
+            pageId: idSchema("Page ID"),
+            email: t.String({
+                minLength: 1,
+                format: "email",
+                description: "Viewer email address",
+            }),
+            expiresAt: t.Optional(timestampSchema("Optional ISO-8601 expiration")),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { pageId, ...fields } = input;
-            const body = await request(ctx, `/v1/pages/${encodeURIComponent(pageId)}/shares`, {
+            const body = await request(ctx, `/v1/pages/${pathSegment(String(pageId))}/shares`, {
                 method: "POST",
                 body: JSON.stringify(fields),
             });
@@ -120,12 +150,10 @@ export function registerPageActions(rl) {
     rl.registerAction("page.revokeShare", {
         access: "write",
         description: "Revoke a Shift Labs page share.",
-        inputSchema: t.Object({
-            shareId: t.String({ description: "Page share ID" }),
-        }),
+        inputSchema: t.Object({ shareId: idSchema("Page share ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { shareId } = input;
-            await request(ctx, `/v1/pages/shares/${encodeURIComponent(shareId)}`, {
+            await request(ctx, `/v1/pages/shares/${pathSegment(shareId)}`, {
                 method: "DELETE",
             });
             return { success: true };
@@ -134,12 +162,10 @@ export function registerPageActions(rl) {
     rl.registerAction("page.renderUrl", {
         access: "read",
         description: "Return the authenticated render URL for a page.",
-        inputSchema: t.Object({
-            pageId: t.String({ description: "Page ID" }),
-        }),
+        inputSchema: t.Object({ pageId: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { pageId } = input;
-            const body = await request(ctx, `/v1/pages/${encodeURIComponent(pageId)}`);
+            const body = await request(ctx, `/v1/pages/${pathSegment(pageId)}`);
             return {
                 url: pageRenderUrl(body.page.organizationId, body.page.slug),
             };

package/dist/plugins/shiftLabs/src/projects.js

@@ -0,0 +1,102 @@
+import * as t from "typebox";
+import { cursorSchema, enumSchema, idSchema, PROJECT_STATUS, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "./shared.js";
+const projectListFields = {
+    status: t.Optional(enumSchema("Project status", PROJECT_STATUS)),
+    leadUserId: t.Optional(idSchema("Lead user ID")),
+    includeArchived: t.Optional(t.Boolean()),
+    cursor: t.Optional(cursorSchema()),
+    limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+};
+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 registerProjectActions(rl) {
+    rl.registerAction("project.list", {
+        access: "read",
+        description: "List the first page of concrete Shift Labs Projects.",
+        inputSchema: t.Object(projectListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, `/v1/projects?${listParams(input)}`);
+            return body.projects;
+        },
+    });
+    rl.registerAction("project.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of concrete Projects.",
+        inputSchema: t.Object(projectListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            return request(ctx, `/v1/projects?${listParams(input)}`);
+        },
+    });
+    rl.registerAction("project.get", {
+        access: "read",
+        description: "Get a Project and its derived Issue progress.",
+        inputSchema: t.Object({ id: idSchema("Project ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const [project, progress] = await Promise.all([
+                request(ctx, `/v1/projects/${pathSegment(id)}`),
+                request(ctx, `/v1/projects/${pathSegment(id)}/progress`),
+            ]);
+            return { project: project.project, progress: progress.progress };
+        },
+    });
+    rl.registerAction("project.create", {
+        access: "write",
+        description: "Create a concrete Project container.",
+        inputSchema: t.Object({
+            name: t.String({
+                minLength: 1,
+                maxLength: 160,
+                pattern: "\\S",
+                description: "Project name",
+            }),
+            description: t.Optional(t.String({ maxLength: 20_000 })),
+            status: t.Optional(enumSchema("Project status", PROJECT_STATUS)),
+            leadUserId: t.Optional(idSchema("Lead user ID")),
+            startAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
+            targetAt: t.Optional(timestampSchema("ISO-8601 target timestamp")),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const fields = input;
+            assertDateOrder(fields.startAt, fields.targetAt);
+            const body = await request(ctx, "/v1/projects", {
+                method: "POST",
+                body: JSON.stringify(fields),
+            });
+            return body.project;
+        },
+    });
+    rl.registerAction("project.update", {
+        access: "write",
+        description: "Update Project lifecycle, ownership, dates, or content.",
+        inputSchema: t.Object({
+            id: idSchema("Project ID"),
+            name: t.Optional(t.String({ minLength: 1, maxLength: 160, pattern: "\\S" })),
+            description: t.Optional(t.String({ maxLength: 20_000 })),
+            status: t.Optional(enumSchema("Project status", PROJECT_STATUS)),
+            leadUserId: t.Optional(t.Union([idSchema("Lead user ID"), t.Null()])),
+            startAt: t.Optional(t.Union([timestampSchema("ISO-8601 start timestamp"), t.Null()])),
+            targetAt: t.Optional(t.Union([timestampSchema("ISO-8601 target timestamp"), t.Null()])),
+            archived: t.Optional(t.Boolean()),
+        }, STRICT_UPDATE_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            assertDateOrder(patch.startAt, patch.targetAt);
+            const body = await request(ctx, `/v1/projects/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.project;
+        },
+    });
+}
+function assertDateOrder(startAt, targetAt) {
+    if (typeof startAt === "string" &&
+        typeof targetAt === "string" &&
+        startAt > targetAt) {
+        throw new Error("Project targetAt must not precede startAt");
+    }
+}

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

@@ -1,4 +1,22 @@
 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}/`;
@@ -31,18 +49,17 @@ export function pageRenderUrl(organizationId, slug) {
     return new URL(`/pages/${pathSegment(organizationId)}/${pathSegment(slug)}`, baseUrl()).toString();
 }
 export const ISSUE_STATUS = [
-    "triage",
-    "open",
+    "backlog",
+    "todo",
     "in_progress",
-    "resolved",
-    "closed",
+    "done",
+    "canceled",
 ];
-export const ISSUE_KIND = [
-    "bug",
-    "support",
-    "feature_request",
-    "incident",
-    "task",
+export const PROJECT_STATUS = [
+    "planned",
+    "active",
+    "completed",
+    "canceled",
 ];
 export const ISSUE_PRIORITY = [
     "none",
@@ -51,7 +68,6 @@ export const ISSUE_PRIORITY = [
     "high",
     "urgent",
 ];
-export const ISSUE_SEVERITY = ["info", "warning", "error", "critical"];
 export const ISSUE_SOURCE = [
     "user",
     "agent",
@@ -59,6 +75,21 @@ export const ISSUE_SOURCE = [
     "api",
     "integration",
 ];
+export const ISSUE_VIEW_VISIBILITY = ["personal", "organization"];
+export const ISSUE_VIEW_LAYOUT = ["list", "board", "timeline"];
+export const ISSUE_VIEW_GROUP = [
+    "status",
+    "assignee",
+    "priority",
+    "project",
+];
+export const ISSUE_VIEW_SORT = [
+    "manual",
+    "priority",
+    "startAt",
+    "dueAt",
+    "updatedAt",
+];
 export const PAGE_STATUS = ["draft", "published", "archived"];
 export const PAGE_VISIBILITY = ["org", "invited"];
 export const TRANSCRIPTION_LANGUAGE = ["auto", "en", "he"];

package/package.json

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