runline 0.8.0 → 0.9.0

package/dist/commands/auth.js

@@ -5,6 +5,7 @@ import { addConnection } from "../config/loader.js";
 import { OAUTH_CALLBACK_PORT, runOAuth } from "../core/oauth.js";
 import { loadAllPlugins } from "../plugin/loader.js";
 import { registry } from "../plugin/registry.js";
+import { connectionFields } from "../plugin/schema.js";
 import { printError, printJson, printSuccess } from "../utils/output.js";
 export async function auth(plugin, options) {
     await loadAllPlugins();
@@ -20,8 +21,9 @@ export async function auth(plugin, options) {
     // Client credentials: CLI flag > env > interactive prompt.
     // Env var names follow the plugin's own convention when declared
     // on its connection schema; fall back to generic names otherwise.
-    const envIdVar = def.connectionConfigSchema?.clientId?.env;
-    const envSecretVar = def.connectionConfigSchema?.clientSecret?.env;
+    const connectionSchema = connectionFields(def.connectionConfigSchema);
+    const envIdVar = connectionSchema.clientId?.env;
+    const envSecretVar = connectionSchema.clientSecret?.env;
     const resolvedClientId = options.clientId ?? (envIdVar ? process.env[envIdVar] : undefined);
     const resolvedClientSecret = options.clientSecret ??
         (envSecretVar ? process.env[envSecretVar] : undefined);

package/dist/config/loader.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionConfig } from "../plugin/types.js";
+import type { ConnectionConfig, ConnectionSchema } from "../plugin/types.js";
 import { type RunlineConfig } from "./types.js";
 export declare function findConfigDir(): string | null;
 export declare function loadConfig(): RunlineConfig;
@@ -17,6 +17,4 @@ export declare function removeConnection(name: string): boolean;
  */
 export declare function updateConnectionConfig(name: string, patch: Record<string, unknown>): Promise<void>;
 export declare function getConnection(plugin: string, name?: string): ConnectionConfig | undefined;
-export declare function applyEnvOverrides(conn: ConnectionConfig, schema?: Record<string, {
-    env?: string;
-}>): ConnectionConfig;
+export declare function applyEnvOverrides(conn: ConnectionConfig, schema?: ConnectionSchema): ConnectionConfig;

package/dist/config/loader.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import lockfile from "proper-lockfile";
+import { connectionFields } from "../plugin/schema.js";
 import { DEFAULT_CONFIG } from "./types.js";
 const CONFIG_DIR_NAME = ".runline";
 const CONFIG_FILE = "config.json";
@@ -117,7 +118,7 @@ export function applyEnvOverrides(conn, schema) {
     if (!schema)
         return conn;
     const config = { ...conn.config };
-    for (const [key, field] of Object.entries(schema)) {
+    for (const [key, field] of Object.entries(connectionFields(schema))) {
         if (field.env && !config[key]) {
             const envVal = process.env[field.env];
             if (envVal)

package/dist/core/engine.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { getQuickJS, shouldInterruptAfterDeadline, } from "quickjs-emscripten";
 import { applyEnvOverrides, updateConnectionConfig } from "../config/loader.js";
+import { formatValidationError, helpInputs, isTypedInputSchema, validateTypedInput, } from "../plugin/schema.js";
 export class ExecutionEngine {
     registry;
     config;
@@ -146,6 +147,12 @@ export class ExecutionEngine {
                 await updateConnectionConfig(connection.name, patch);
             },
         };
+        if (isTypedInputSchema(action.inputSchema)) {
+            const validation = validateTypedInput(action.inputSchema, args);
+            if (!validation.ok) {
+                throw new Error(formatValidationError(path, validation));
+            }
+        }
         return action.execute(args, ctx);
     }
     resolveConnection(plugin) {
@@ -230,14 +237,7 @@ function buildHelpData(plugins) {
         data[p.name] = p.actions.map((a) => ({
             action: a.name,
             description: a.description,
-            inputs: Object.fromEntries(Object.entries(a.inputSchema ?? {}).map(([k, v]) => [
-                k,
-                {
-                    type: v.type,
-                    required: !!v.required,
-                    description: v.description,
-                },
-            ])),
+            inputs: helpInputs(a.inputSchema),
         }));
     }
     return data;
@@ -291,7 +291,7 @@ const __index = (() => {
 
 const __formatSignature = (plugin, entry) => {
   const fields = Object.entries(entry.inputs || {})
-    .map(([k, v]) => k + (v.required ? '' : '?') + ': ' + v.type)
+    .map(([k, v]) => k + (v.required ? '' : '?') + ': ' + (v.displayType || v.type))
     .join(', ');
   return plugin + '.' + entry.action + (fields ? '({ ' + fields + ' })' : '()');
 };
@@ -370,10 +370,15 @@ const __actionsApi = {
     for (const k of Object.keys(provided)) {
       if (!(k in inputs)) unknown.push(k);
       else {
-        const expected = inputs[k].type;
-        const actual = Array.isArray(provided[k]) ? 'array' : typeof provided[k];
-        if (expected !== actual && !(provided[k] === null || provided[k] === undefined)) {
-          typeErrors.push({ field: k, expected, actual });
+        const spec = inputs[k];
+        const expected = spec.type;
+        const actual = Array.isArray(provided[k]) ? 'array' : provided[k] === null ? 'null' : typeof provided[k];
+        if (provided[k] !== null && provided[k] !== undefined && expected !== actual) {
+          typeErrors.push({ field: k, expected: spec.displayType || expected, actual });
+        } else if (spec.enum && !spec.enum.includes(provided[k])) {
+          typeErrors.push({ field: k, expected: spec.enum.map(String).join(' | '), actual: __fmt(provided[k]) });
+        } else if ('const' in spec && provided[k] !== spec.const) {
+          typeErrors.push({ field: k, expected: __fmt(spec.const), actual: __fmt(provided[k]) });
         }
       }
     }

package/dist/index.d.ts

@@ -5,13 +5,13 @@ export type { EngineOptions, ExecuteResult } from "./core/engine.js";
 export { ExecutionEngine } from "./core/engine.js";
 export type { BuildAuthUrlOptions, ExchangeCodeOptions, OAuthTokens, PKCEPair, RunOAuthOptions, } from "./core/oauth.js";
 export { buildAuthUrl, exchangeAuthCode, generatePKCE, OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_URI, runOAuth, } from "./core/oauth.js";
-export type { ActionDefinition, PluginFunction, RunlinePluginAPI, SchemaField, } from "./plugin/api.js";
+export type { ActionDefinition, PluginFunction, RunlinePluginAPI, } from "./plugin/api.js";
 export { createPluginAPI, isPluginFunction, resolvePluginExport, } from "./plugin/api.js";
 export type { InstalledPlugin, PluginSource } from "./plugin/installer.js";
 export { installPlugin, listInstalled, parsePluginSource, removePlugin, } from "./plugin/installer.js";
 export { discoverPlugins, loadAllPlugins, loadPluginFromPath, loadPluginsFromConfig, } from "./plugin/loader.js";
 export { PluginRegistry, registry } from "./plugin/registry.js";
-export type { ActionContext, ActionDef, ConnectionConfig, InputField, InputSchema, OAuthConfig, PluginDef, } from "./plugin/types.js";
+export type { ActionContext, ActionDef, ConnectionConfig, ConnectionSchema, ConnectionSchemaField, InputField, InputSchema, LegacyConnectionSchema, OAuthConfig, PluginDef, } from "./plugin/types.js";
 export type { RunlineOptions } from "./sdk.js";
 export { Runline } from "./sdk.js";
 export type { ExecOptions, ExecResult, OutputParser } from "./utils/cli.js";

package/dist/plugin/api.d.ts

@@ -1,11 +1,4 @@
-import type { ActionDef, InputSchema, OAuthConfig, PluginDef } from "./types.js";
-export interface SchemaField {
-    type: "string" | "number" | "boolean";
-    required?: boolean;
-    description?: string;
-    default?: unknown;
-    env?: string;
-}
+import type { ActionDef, ConnectionSchema, InputSchema, OAuthConfig, PluginDef } from "./types.js";
 export interface ActionDefinition {
     description?: string;
     inputSchema?: InputSchema;
@@ -13,7 +6,7 @@ export interface ActionDefinition {
 }
 export interface RunlinePluginAPI {
     registerAction(name: string, def: ActionDefinition): void;
-    setConnectionSchema(schema: Record<string, SchemaField>): void;
+    setConnectionSchema(schema: ConnectionSchema): void;
     setName(name: string): void;
     setVersion(version: string): void;
     /**

package/dist/plugin/api.js

@@ -19,10 +19,7 @@ export function createPluginAPI(pluginId) {
             actions.push({ name: actionName, ...def });
         },
         setConnectionSchema(schema) {
-            connectionConfigSchema = {};
-            for (const [key, field] of Object.entries(schema)) {
-                connectionConfigSchema[key] = { ...field };
-            }
+            connectionConfigSchema = { ...schema };
         },
         setOAuth(cfg) {
             oauth = { ...cfg };

package/dist/plugin/loader.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createJiti } from "jiti";
 import { findConfigDir } from "../config/loader.js";
@@ -81,6 +81,19 @@ async function loadFromDirectory(dir) {
                 join(fullPath, "src", "index.ts"),
                 join(fullPath, "src", "index.js"),
             ];
+            const pkgJson = join(fullPath, "package.json");
+            let packagePluginPaths = [];
+            if (existsSync(pkgJson)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+                    if (pkg.main)
+                        candidates.unshift(join(fullPath, pkg.main));
+                    packagePluginPaths = pkg.runline?.plugins ?? [];
+                }
+                catch (err) {
+                    console.error(`[runline] Failed to parse ${pkgJson}:`, err.message);
+                }
+            }
             const found = candidates.find((c) => existsSync(c));
             if (found) {
                 try {
@@ -90,22 +103,15 @@ async function loadFromDirectory(dir) {
                     console.error(`[runline] Failed to load plugin from ${found}:`, err.message);
                 }
             }
-            const pkgJson = join(fullPath, "package.json");
-            if (existsSync(pkgJson)) {
+            else if (packagePluginPaths.length === 0) {
+                console.error(`[runline] Failed to load plugin from ${fullPath}: No entry point found`);
+            }
+            for (const p of packagePluginPaths) {
                 try {
-                    const pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
-                    const pluginPaths = pkg.runline?.plugins ?? [];
-                    for (const p of pluginPaths) {
-                        try {
-                            plugins.push(await loadPluginFromPath(join(fullPath, p)));
-                        }
-                        catch (err) {
-                            console.error(`[runline] Failed to load plugin from ${join(fullPath, p)}:`, err.message);
-                        }
-                    }
+                    plugins.push(await loadPluginFromPath(join(fullPath, p)));
                 }
                 catch (err) {
-                    console.error(`[runline] Failed to parse ${pkgJson}:`, err.message);
+                    console.error(`[runline] Failed to load plugin from ${join(fullPath, p)}:`, err.message);
                 }
             }
         }
@@ -120,13 +126,21 @@ export async function loadPluginsFromConfig(configDir) {
     try {
         const data = JSON.parse(readFileSync(pluginsFile, "utf-8"));
         const entries = data.plugins ?? data;
+        if (!Array.isArray(entries)) {
+            throw new Error("Expected an array or { plugins: [...] }");
+        }
         for (const entry of entries) {
-            const p = typeof entry === "string" ? entry : entry.path;
+            const p = typeof entry === "string" ? entry : entry?.path;
+            if (typeof p !== "string" || p.length === 0) {
+                console.error(`[runline] Invalid plugin entry in ${pluginsFile}: expected string path or { path }`);
+                continue;
+            }
+            const pluginPath = isAbsolute(p) ? p : join(configDir, p);
             try {
-                plugins.push(await loadPluginFromPath(p));
+                plugins.push(await loadPluginFromPath(pluginPath));
             }
             catch (err) {
-                console.error(`[runline] Failed to load plugin from ${p}:`, err.message);
+                console.error(`[runline] Failed to load plugin from ${pluginPath}:`, err.message);
             }
         }
     }
@@ -146,32 +160,34 @@ export function defaultBuiltinDir() {
 export async function discoverPlugins(configDir, options = {}) {
     const loaded = new Set();
     const result = [];
-    function addIfNew(plugin) {
-        if (!loaded.has(plugin.name)) {
-            result.push(plugin);
-            loaded.add(plugin.name);
+    function addIfNew(plugin, source) {
+        if (loaded.has(plugin.name)) {
+            console.error(`[runline] Skipping duplicate plugin "${plugin.name}" from ${source}: a plugin with that name is already loaded`);
+            return;
         }
+        result.push(plugin);
+        loaded.add(plugin.name);
     }
     if (configDir) {
         const projectPluginsDir = join(configDir, "plugins");
         const projectPlugins = await loadFromDirectory(projectPluginsDir);
         for (const p of projectPlugins)
-            addIfNew(p);
+            addIfNew(p, projectPluginsDir);
         const configPlugins = await loadPluginsFromConfig(configDir);
         for (const p of configPlugins)
-            addIfNew(p);
+            addIfNew(p, join(configDir, "plugins.json"));
     }
     const globalDir = join(homedir(), ".runline", "plugins");
     const globalPlugins = await loadFromDirectory(globalDir);
     for (const p of globalPlugins)
-        addIfNew(p);
+        addIfNew(p, globalDir);
     const builtinDir = options.builtinDir ?? defaultBuiltinDir();
     const builtinPlugins = await loadFromDirectory(builtinDir);
     for (const p of builtinPlugins) {
         if (options.builtinAllowlist && !options.builtinAllowlist.has(p.name)) {
             continue;
         }
-        addIfNew(p);
+        addIfNew(p, builtinDir);
     }
     return result;
 }

package/dist/plugin/schema.d.ts

@@ -0,0 +1,19 @@
+import type { ConnectionSchema, HelpInput, InputSchema, LegacyConnectionSchema, LegacyInputSchema, TypedInputSchema } from "./types.js";
+export interface ValidationResult {
+    ok: boolean;
+    missing: string[];
+    unknown: string[];
+    typeErrors: Array<{
+        field: string;
+        expected: string;
+        actual: string;
+    }>;
+    errors: string[];
+}
+export declare function isTypedInputSchema(schema: InputSchema | undefined): schema is TypedInputSchema;
+export declare function legacyFields(schema: InputSchema | undefined): LegacyInputSchema;
+export declare function connectionFields(schema: ConnectionSchema | undefined): LegacyConnectionSchema;
+export declare function helpInputs(schema: InputSchema | undefined): Record<string, HelpInput>;
+export declare function validateLegacyInput(schema: LegacyInputSchema, input: unknown): ValidationResult;
+export declare function validateTypedInput(schema: TypedInputSchema, input: unknown): ValidationResult;
+export declare function formatValidationError(path: string, result: ValidationResult): string;

package/dist/plugin/schema.js

@@ -0,0 +1,168 @@
+import { Check, Errors } from "typebox/value";
+export function isTypedInputSchema(schema) {
+    if (!schema || typeof schema !== "object")
+        return false;
+    const candidate = schema;
+    return typeof candidate.type === "string" || Array.isArray(candidate.anyOf);
+}
+export function legacyFields(schema) {
+    if (!schema || isTypedInputSchema(schema))
+        return {};
+    return schema;
+}
+export function connectionFields(schema) {
+    if (!schema)
+        return {};
+    if (!isTypedInputSchema(schema))
+        return schema;
+    const metadata = schema;
+    if (metadata.type !== "object")
+        return {};
+    const required = new Set(metadata.required ?? []);
+    return Object.fromEntries(Object.entries(metadata.properties ?? {}).map(([key, field]) => [
+        key,
+        {
+            type: baseType(field),
+            required: required.has(key),
+            description: field.description,
+            default: field.default,
+            env: field.env,
+        },
+    ]));
+}
+export function helpInputs(schema) {
+    if (!schema)
+        return {};
+    if (!isTypedInputSchema(schema)) {
+        const legacy = schema;
+        return Object.fromEntries(Object.entries(legacy).map(([key, field]) => [
+            key,
+            {
+                type: field.type,
+                required: !!field.required,
+                description: field.description,
+            },
+        ]));
+    }
+    const metadata = schema;
+    if (metadata.type !== "object")
+        return {};
+    const required = new Set(metadata.required ?? []);
+    return Object.fromEntries(Object.entries(metadata.properties ?? {}).map(([key, field]) => [
+        key,
+        {
+            type: baseType(field),
+            displayType: displayType(field),
+            required: required.has(key),
+            description: field.description,
+            enum: enumValues(field),
+            const: field.const,
+        },
+    ]));
+}
+export function validateLegacyInput(schema, input) {
+    const provided = input && typeof input === "object"
+        ? input
+        : {};
+    const missing = [];
+    const unknown = [];
+    const typeErrors = [];
+    for (const [key, spec] of Object.entries(schema)) {
+        if (spec.required && !(key in provided))
+            missing.push(key);
+    }
+    for (const key of Object.keys(provided)) {
+        if (!(key in schema)) {
+            unknown.push(key);
+            continue;
+        }
+        const expected = schema[key].type;
+        const actual = valueType(provided[key]);
+        if (provided[key] !== null &&
+            provided[key] !== undefined &&
+            expected !== actual) {
+            typeErrors.push({ field: key, expected, actual });
+        }
+    }
+    return validationResult({ missing, unknown, typeErrors });
+}
+export function validateTypedInput(schema, input) {
+    if (Check(schema, input))
+        return validationResult({});
+    return validationResult({
+        errors: [...Errors(schema, input)].map((error) => {
+            const path = error.instancePath || "/";
+            return `${path} ${error.message}`;
+        }),
+    });
+}
+export function formatValidationError(path, result) {
+    const parts = [`Invalid input for ${path}.`];
+    if (result.missing.length > 0) {
+        parts.push(`Missing required fields: ${result.missing.join(", ")}.`);
+    }
+    if (result.unknown.length > 0) {
+        parts.push(`Unknown fields: ${result.unknown.join(", ")}.`);
+    }
+    if (result.typeErrors.length > 0) {
+        parts.push(`Type errors: ${result.typeErrors
+            .map((e) => `${e.field} expected ${e.expected}, got ${e.actual}`)
+            .join("; ")}.`);
+    }
+    if (result.errors.length > 0) {
+        parts.push(`Validation errors: ${result.errors.join("; ")}.`);
+    }
+    return parts.join(" ");
+}
+function validationResult(input) {
+    const missing = input.missing ?? [];
+    const unknown = input.unknown ?? [];
+    const typeErrors = input.typeErrors ?? [];
+    const errors = input.errors ?? [];
+    return {
+        ok: missing.length === 0 &&
+            unknown.length === 0 &&
+            typeErrors.length === 0 &&
+            errors.length === 0,
+        missing,
+        unknown,
+        typeErrors,
+        errors,
+    };
+}
+function displayType(schema) {
+    if (schema.anyOf?.length)
+        return schema.anyOf.map(displayType).join(" | ");
+    if (schema.enum?.length)
+        return schema.enum.map(String).join(" | ");
+    if (schema.const !== undefined)
+        return JSON.stringify(schema.const);
+    return schema.type ?? "unknown";
+}
+function baseType(schema) {
+    if (schema.anyOf?.length) {
+        const types = [...new Set(schema.anyOf.map(baseType))];
+        return types.length === 1 ? types[0] : types.join(" | ");
+    }
+    if (schema.type)
+        return schema.type;
+    if (schema.const !== undefined)
+        return valueType(schema.const);
+    return "unknown";
+}
+function enumValues(schema) {
+    if (schema.enum?.length)
+        return schema.enum;
+    if (schema.anyOf?.length &&
+        schema.anyOf.every((s) => s.const !== undefined)) {
+        return schema.anyOf.map((s) => s.const);
+    }
+    return undefined;
+}
+function valueType(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}

package/dist/plugin/types.d.ts

@@ -1,10 +1,30 @@
+import type { TSchema } from "typebox";
 export interface InputField {
     type: "string" | "number" | "boolean" | "object" | "array";
     description?: string;
     required?: boolean;
     default?: unknown;
 }
-export type InputSchema = Record<string, InputField>;
+export type LegacyInputSchema = Record<string, InputField>;
+export type TypedInputSchema = TSchema;
+export type InputSchema = LegacyInputSchema | TypedInputSchema;
+export interface ConnectionSchemaField {
+    type: string;
+    required?: boolean;
+    description?: string;
+    default?: unknown;
+    env?: string;
+}
+export type LegacyConnectionSchema = Record<string, ConnectionSchemaField>;
+export type ConnectionSchema = LegacyConnectionSchema | TSchema;
+export interface HelpInput {
+    type: string;
+    displayType?: string;
+    required: boolean;
+    description?: string;
+    enum?: unknown[];
+    const?: unknown;
+}
 export interface ActionDef {
     name: string;
     description?: string;
@@ -73,13 +93,7 @@ export interface PluginDef {
     name: string;
     version: string;
     actions: ActionDef[];
-    connectionConfigSchema?: Record<string, {
-        type: string;
-        required?: boolean;
-        description?: string;
-        default?: unknown;
-        env?: string;
-    }>;
+    connectionConfigSchema?: ConnectionSchema;
     /** OAuth2 config for `runline auth <plugin>`. */
     oauth?: OAuthConfig;
     /** @internal */

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

@@ -27,6 +27,11 @@ async function accessToken(ctx) {
 }
 // ─── Request ─────────────────────────────────────────────────────
 const API_BASE = "https://gmail.googleapis.com/gmail/v1/users/me";
+function sendFailureRetryHint(method, path) {
+    if (method !== "POST" || !path.endsWith("/send"))
+        return "";
+    return " Before retrying, check whether the email was already sent using gmail.message.list({ q: 'in:sent to:<recipient> subject:\"<subject>\"', maxResults: 10 }) and inspect likely matches with gmail.message.get({ id, format: 'metadata' }).";
+}
 async function gmailRequest(ctx, method, path, body, qs) {
     const token = await accessToken(ctx);
     const url = new URL(`${API_BASE}${path}`);
@@ -55,12 +60,19 @@ async function gmailRequest(ctx, method, path, body, qs) {
             "application/json";
         init.body = JSON.stringify(body);
     }
-    const res = await fetch(url.toString(), init);
+    let res;
+    try {
+        res = await fetch(url.toString(), init);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`gmail: ${method} ${path} failed: ${msg}.${sendFailureRetryHint(method, path)}`);
+    }
     if (res.status === 204)
         return { success: true };
     const text = await res.text();
     if (!res.ok) {
-        throw new Error(`gmail: ${method} ${path} → ${res.status} ${text}`);
+        throw new Error(`gmail: ${method} ${path} → ${res.status} ${text}${sendFailureRetryHint(method, path)}`);
     }
     return text ? JSON.parse(text) : { success: true };
 }

package/dist/plugins/linear/src/attachments.js

@@ -0,0 +1,87 @@
+import * as t from "typebox";
+import { ATTACHMENT_FIELDS, assertAttachmentInScope, assertIssueInScope, gql, key, requireUnscoped } from "./shared.js";
+export function registerAttachmentActions(rl) {
+    rl.registerAction("attachment.list", {
+        description: "List issue attachments. Disabled for scoped Linear connections.",
+        inputSchema: t.Object({ limit: t.Optional(t.Number()) }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "attachment.list");
+            const limit = input?.limit ?? 50;
+            const data = await gql(key(ctx), `query($first: Int) { attachments(first: $first) { nodes { ${ATTACHMENT_FIELDS} } pageInfo { hasNextPage endCursor } } }`, { first: limit });
+            return data.attachments;
+        },
+    });
+    rl.registerAction("attachment.get", {
+        description: "Get an attachment by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            const id = input.id;
+            await assertAttachmentInScope(ctx, id);
+            const data = await gql(key(ctx), `query($id: String!) { attachment(id: $id) { ${ATTACHMENT_FIELDS} } }`, { id });
+            return data.attachment;
+        },
+    });
+    rl.registerAction("attachment.create", {
+        description: "Create an attachment on an issue.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The issue to associate the attachment with. UUID or issue identifier (e.g., 'LIN-123')" }),
+            title: t.String({ description: "The attachment title" }),
+            url: t.String({ description: "Attachment location, also used as a unique identifier. Re-creating with the same url updates the existing record" }),
+            subtitle: t.Optional(t.String({ description: "The attachment subtitle" })),
+            iconUrl: t.Optional(t.String({ description: "An icon url to display with the attachment (jpg or png, max 1MB, ideally 20x20px)" })),
+            commentBody: t.Optional(t.String({ description: "Create a linked comment with markdown body" })),
+            groupBySource: t.Optional(t.Boolean({ description: "Whether attachments for the same source application should be grouped in the Linear UI" })),
+            metadata: t.Optional(t.Object({}, { description: "Attachment metadata object with string and number values (JSONObject)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const fields = input;
+            await assertIssueInScope(ctx, String(fields.issueId));
+            const data = await gql(key(ctx), `mutation($input: AttachmentCreateInput!) { attachmentCreate(input: $input) { success attachment { ${ATTACHMENT_FIELDS} } } }`, { input: fields });
+            return data.attachmentCreate?.attachment;
+        },
+    });
+    rl.registerAction("attachment.update", {
+        description: "Update an attachment. title is required.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the attachment to update" }),
+            title: t.String({ description: "The attachment title" }),
+            subtitle: t.Optional(t.String({ description: "The attachment subtitle" })),
+            iconUrl: t.Optional(t.String({ description: "An icon url to display with the attachment" })),
+            metadata: t.Optional(t.Object({}, { description: "Attachment metadata object with string and number values (JSONObject)" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            await assertAttachmentInScope(ctx, String(id));
+            const data = await gql(key(ctx), `mutation($id: String!, $input: AttachmentUpdateInput!) { attachmentUpdate(id: $id, input: $input) { success attachment { ${ATTACHMENT_FIELDS} } } }`, { id, input: fields });
+            return data.attachmentUpdate?.attachment;
+        },
+    });
+    rl.registerAction("attachment.linkURL", {
+        description: "Link any URL to an issue. If a workspace integration matches the URL (Zendesk, GitHub, Slack, etc.) a rich attachment is created; otherwise a basic one.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The issue for which to link the url. UUID or issue identifier (e.g., 'LIN-123')" }),
+            url: t.String({ description: "The url to link" }),
+            title: t.Optional(t.String({ description: "The title to use for the attachment" })),
+            id: t.Optional(t.String({ description: "The id for the attachment (optional UUID override)" })),
+        }),
+        async execute(input, ctx) {
+            const { issueId, url, title, id } = input;
+            await assertIssueInScope(ctx, String(issueId));
+            const data = await gql(key(ctx), `mutation($issueId: String!, $url: String!, $title: String, $id: String) {
+          attachmentLinkURL(issueId: $issueId, url: $url, title: $title, id: $id) { success attachment { ${ATTACHMENT_FIELDS} } }
+        }`, { issueId, url, title: title ?? null, id: id ?? null });
+            return data.attachmentLinkURL?.attachment;
+        },
+    });
+    rl.registerAction("attachment.delete", {
+        description: "Delete an attachment.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the attachment to delete" }) }),
+        async execute(input, ctx) {
+            const id = input.id;
+            await assertAttachmentInScope(ctx, id);
+            const data = await gql(key(ctx), `mutation($id: String!) { attachmentDelete(id: $id) { success } }`, { id });
+            return data.attachmentDelete;
+        },
+    });
+}