runline 0.11.4 → 0.11.6

package/dist/plugins/googleDocs/src/tables.js

@@ -292,6 +292,11 @@ export function registerTablesActions(rl) {
                 required: false,
                 description: "Column width in points.",
             },
+            widthType: {
+                type: "string",
+                required: false,
+                description: "WIDTH_TYPE_UNSPECIFIED | EVENLY_DISTRIBUTED | FIXED_WIDTH. Defaults to FIXED_WIDTH when widthPt is provided.",
+            },
             fields: {
                 type: "string",
                 required: false,
@@ -307,7 +312,12 @@ export function registerTablesActions(rl) {
             const fields = [];
             if (p.widthPt !== undefined) {
                 props.width = point(p.widthPt);
-                fields.push("width");
+                props.widthType = p.widthType ?? "FIXED_WIDTH";
+                fields.push("width", "widthType");
+            }
+            else if (p.widthType) {
+                props.widthType = p.widthType;
+                fields.push("widthType");
             }
             const mask = p.fields ?? fields.join(",");
             if (!mask)

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

@@ -0,0 +1,15 @@
+import * as t from "typebox";
+import { registerIssueActions } from "./issues.js";
+import { registerPageActions } from "./pages.js";
+export default function shiftLabs(rl) {
+    rl.setName("shiftLabs");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            description: "Shift Labs API key",
+            env: "SHIFT_LABS_API_KEY",
+        }),
+    }));
+    registerIssueActions(rl);
+    registerPageActions(rl);
+}

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

@@ -0,0 +1,70 @@
+import * as t from "typebox";
+import { enumSchema, ISSUE_KIND, ISSUE_PRIORITY, ISSUE_SEVERITY, ISSUE_SOURCE, ISSUE_STATUS, request, } from "./shared.js";
+export function registerIssueActions(rl) {
+    rl.registerAction("issue.list", {
+        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" })),
+        }),
+        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}`);
+            return body.issues;
+        },
+    });
+    rl.registerAction("issue.get", {
+        description: "Get a Shift Labs issue by ID.",
+        inputSchema: t.Object({ id: t.String({ description: "Issue ID" }) }),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/issues/${encodeURIComponent(id)}`);
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.create", {
+        description: "Create a Shift Labs issue. The issue starts in triage.",
+        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)),
+            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" })),
+        }),
+        async execute(input, ctx) {
+            const body = await request(ctx, "/v1/issues", {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.comment", {
+        description: "Add a comment to a Shift Labs issue.",
+        inputSchema: t.Object({
+            id: t.String({ description: "Issue ID" }),
+            body: t.String({ description: "Comment body" }),
+        }),
+        async execute(input, ctx) {
+            const { id, body } = input;
+            const response = await request(ctx, `/v1/issues/${encodeURIComponent(id)}/comments`, { method: "POST", body: JSON.stringify({ body }) });
+            return response.event;
+        },
+    });
+}

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

@@ -0,0 +1,138 @@
+import * as t from "typebox";
+import { enumSchema, PAGE_STATUS, PAGE_VISIBILITY, pageRenderUrl, request, } from "./shared.js";
+export function registerPageActions(rl) {
+    rl.registerAction("page.list", {
+        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" })),
+        }),
+        async execute(input, ctx) {
+            const fields = (input ?? {});
+            const params = new URLSearchParams();
+            if (fields.status)
+                params.set("status", String(fields.status));
+            if (fields.limit)
+                params.set("limit", String(fields.limit));
+            const body = await request(ctx, `/v1/pages?${params}`);
+            return body.pages;
+        },
+    });
+    rl.registerAction("page.get", {
+        description: "Get a Shift Labs page by ID.",
+        inputSchema: t.Object({ id: t.String({ description: "Page ID" }) }),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}`);
+            return body.page;
+        },
+    });
+    rl.registerAction("page.create", {
+        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" })),
+            visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
+        }),
+        async execute(input, ctx) {
+            const fields = input;
+            const body = await request(ctx, "/v1/pages", {
+                method: "POST",
+                body: JSON.stringify({
+                    type: "hosted_html",
+                    visibility: "org",
+                    ...fields,
+                }),
+            });
+            return body.page;
+        },
+    });
+    rl.registerAction("page.update", {
+        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" })),
+            visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
+            html: t.Optional(t.String({ description: "Hosted HTML content" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify(fields),
+            });
+            return body.page;
+        },
+    });
+    rl.registerAction("page.publish", {
+        description: "Publish a Shift Labs hosted HTML page.",
+        inputSchema: t.Object({ id: t.String({ description: "Page ID" }) }),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}/publish`, { method: "POST" });
+            return body.page;
+        },
+    });
+    rl.registerAction("page.archive", {
+        description: "Archive a Shift Labs page.",
+        inputSchema: t.Object({ id: t.String({ description: "Page ID" }) }),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/pages/${encodeURIComponent(id)}/archive`, { method: "POST" });
+            return body.page;
+        },
+    });
+    rl.registerAction("page.shares", {
+        description: "List shares for a Shift Labs page.",
+        inputSchema: t.Object({ pageId: t.String({ description: "Page ID" }) }),
+        async execute(input, ctx) {
+            const { pageId } = input;
+            const body = await request(ctx, `/v1/pages/${encodeURIComponent(pageId)}/shares`);
+            return body.shares;
+        },
+    });
+    rl.registerAction("page.share", {
+        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" })),
+        }),
+        async execute(input, ctx) {
+            const { pageId, ...fields } = input;
+            const body = await request(ctx, `/v1/pages/${encodeURIComponent(pageId)}/shares`, {
+                method: "POST",
+                body: JSON.stringify(fields),
+            });
+            return body.share;
+        },
+    });
+    rl.registerAction("page.revokeShare", {
+        description: "Revoke a Shift Labs page share.",
+        inputSchema: t.Object({
+            shareId: t.String({ description: "Page share ID" }),
+        }),
+        async execute(input, ctx) {
+            const { shareId } = input;
+            await request(ctx, `/v1/pages/shares/${encodeURIComponent(shareId)}`, {
+                method: "DELETE",
+            });
+            return { success: true };
+        },
+    });
+    rl.registerAction("page.renderUrl", {
+        description: "Return the authenticated render URL for a page.",
+        inputSchema: t.Object({
+            pageId: t.String({ description: "Page ID" }),
+        }),
+        async execute(input, ctx) {
+            const { pageId } = input;
+            const body = await request(ctx, `/v1/pages/${encodeURIComponent(pageId)}`);
+            return {
+                url: pageRenderUrl(body.page.organizationId, body.page.slug),
+            };
+        },
+    });
+}

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

@@ -0,0 +1,69 @@
+import * as t from "typebox";
+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);
+}
+export function pageRenderUrl(organizationId, slug) {
+    return new URL(`/pages/${pathSegment(organizationId)}/${pathSegment(slug)}`, baseUrl()).toString();
+}
+export const ISSUE_STATUS = [
+    "triage",
+    "open",
+    "in_progress",
+    "resolved",
+    "closed",
+];
+export const ISSUE_KIND = [
+    "bug",
+    "support",
+    "feature_request",
+    "incident",
+    "task",
+];
+export const ISSUE_PRIORITY = [
+    "none",
+    "low",
+    "medium",
+    "high",
+    "urgent",
+];
+export const ISSUE_SEVERITY = ["info", "warning", "error", "critical"];
+export const ISSUE_SOURCE = [
+    "user",
+    "agent",
+    "system",
+    "api",
+    "integration",
+];
+export const PAGE_STATUS = ["draft", "published", "archived"];
+export const PAGE_VISIBILITY = ["org", "invited"];
+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.11.4",
+  "version": "0.11.6",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",