@h-rig/linear-plugin 0.0.6-alpha.100

package/README.md

@@ -0,0 +1,227 @@
+# @rig/linear-plugin
+
+Linear as a Rig task source — and the canonical example of a plugin that
+adapts an **external HTTP API** into Rig's task-source contract.
+
+The two first-party adapters in `@rig/standard-plugin` cover a CLI wrapper
+(`github-issues` shells out to `gh`) and the local filesystem (`files`). This
+package covers the third shape you'll actually build most often: a remote
+API spoken over HTTP, with credentials, pagination, write-back mutations, and
+tests that never touch the network. If you are writing a Jira/Asana/Shortcut/
+internal-queue adapter, copy this package.
+
+```
+packages/linear-plugin/
+├── package.json                       ← workspace package, mirrors standard-plugin
+├── tsconfig.json
+└── src/
+    ├── index.ts                       ← definePlugin wiring (metadata + runtime channels)
+    ├── linear-issues-source.ts        ← the adapter: GraphQL client, mapping, write-back
+    ├── fixture-transport.ts           ← fixture-driven fake transport for tests
+    ├── fixtures.ts                    ← canned Linear GraphQL payloads
+    ├── contract.test.ts               ← @rig/plugin-testkit contract suite + factory wiring
+    └── linear-issues-source.test.ts   ← mapping, lifecycle, pagination, error surfaces
+```
+
+## Using it
+
+```typescript
+// rig.config.ts
+import { defineConfig } from "@rig/core";
+import linear from "@rig/linear-plugin";
+
+export default defineConfig({
+  plugins: [linear()],
+  taskSource: {
+    kind: "linear",
+    options: {
+      teamKey: "ENG",                 // required — the "ENG" in ENG-123
+      states: ["Todo", "In Progress"], // optional: workflow state names
+      assignee: "alex@example.com",    // optional: email or display name
+      labels: ["rig"],                 // optional: issue must carry ALL listed labels
+      // pageSize: 50,                 // optional: issues per GraphQL page (max 250)
+      // listLimit: 1000,              // optional: fail-loud ceiling, no silent truncation
+    },
+  },
+  // ... workspace, runtime, etc.
+});
+```
+
+Authentication comes from the environment, never from the committed config:
+
+```bash
+export LINEAR_API_KEY=lin_api_...   # personal API key (Settings → API)
+```
+
+Personal API keys (`lin_api_…`) are sent raw in the `Authorization` header;
+OAuth access tokens (`lin_oauth_…`) are automatically sent as `Bearer <token>`.
+You can also pass the key programmatically: `linear({ apiKey })`.
+
+## Anatomy of an external-API task source
+
+### 1. Two channels, one `definePlugin` call
+
+Rig plugins declare *what they contribute* as Effect-Schema-validated metadata
+and ship *executable code* on a sibling runtime channel — schemas can't carry
+functions. `src/index.ts`:
+
+```typescript
+export default function linearPlugin(opts: LinearPluginOptions = {}) {
+  return definePlugin(
+    // Channel 1: metadata. Validated against the RigPlugin schema at load time.
+    {
+      name: "rig-linear",
+      version: "0.1.0",
+      contributes: {
+        taskSources: [{ id: "linear:issues", kind: "linear", description: "…" }],
+      },
+    },
+    // Channel 2: runtime. The factory turns a TaskSourceConfig into a live source.
+    {
+      taskSources: [{ id: "linear:issues", kind: "linear", factory(config) { … } }],
+    },
+  );
+}
+```
+
+`definePlugin` enforces referential integrity: every factory must match a
+metadata entry by `id` with the same `kind`, and (once a plugin opts into the
+runtime channel) every metadata entry must be backed by a factory. Drift
+throws at config-load time, not at dispatch time.
+
+At boot, `buildTaskSourceRegistry(config, pluginHost)` in `@rig/runtime` reads
+`config.taskSource.kind` (`"linear"`), resolves the factory through the plugin
+host (which also rejects duplicate kinds across plugins), and instantiates the
+source.
+
+### 2. Plugin-specific config rides in `options`
+
+`TaskSourceConfig`'s top-level fields (`path`, `owner`, `repo`, …) are
+reserved for the built-in adapters. Everything Linear-specific lives in the
+documented `options` extension bag — the factory pulls its own fields out and
+validates them with actionable errors:
+
+```typescript
+const teamKey = optionString(config, "teamKey");
+if (!teamKey) {
+  throw new Error('task source linear: options.teamKey is required — …');
+}
+```
+
+Process-level concerns (API key, endpoint override, transport injection)
+arrive through the plugin function's own options instead, because they belong
+to the environment, not to the committed project config.
+
+### 3. An injectable transport is the whole testing story
+
+The adapter never calls `fetch` directly. It calls a fetch-*shaped* function
+it was constructed with:
+
+```typescript
+export type LinearTransport = (
+  url: string,
+  init: { method: "POST"; headers: Record<string, string>; body: string },
+) => Promise<{ ok: boolean; status: number; text(): Promise<string> }>;
+
+const transport: LinearTransport = opts.transport ?? fetch; // global fetch satisfies it
+```
+
+That one seam is why this package's test suite makes **zero live API calls**.
+`fixture-transport.ts` exports `createFixtureTransport(routes)`, which routes
+requests by GraphQL *operation name* (every query/mutation in the adapter is
+deliberately named: `RigListIssues`, `RigTeamStates`, `RigIssueUpdate`, …),
+records every call for payload assertions, and fails loudly on any operation
+a test didn't explicitly allow:
+
+```typescript
+const fixture = createFixtureTransport({
+  RigListIssues: () => listIssuesPage(issueFixtures),
+  RigIssueUpdate: () => ({ issueUpdate: { success: true } }),
+});
+const source = createLinearIssuesTaskSource({
+  teamKey: "ENG",
+  apiKey: "lin_api_test",
+  transport: fixture.transport,
+});
+// …act…
+expect(fixture.callsFor("RigIssueUpdate")[0].variables.input).toEqual({ stateId: … });
+```
+
+`graphqlErrors([...])` and `httpFailure(status, body)` simulate the two
+failure layers a GraphQL API has (200-with-errors vs. non-200 HTTP).
+
+### 4. Mapping external records to `TaskRecord`
+
+`TaskRecord` requires `id`, `deps`, `status` and is open-ended beyond that.
+The mapping decisions here:
+
+| TaskRecord field | Source |
+|---|---|
+| `id` | Linear identifier (`ENG-123`) — human-facing, like GitHub issue numbers |
+| `status` | Linear workflow-state **type** (see table below) |
+| `title`, `body`/`description` | issue title/description (`body` is Rig convention; `description` mirrors Linear) |
+| `priority`, `priorityLabel` | Linear priority (0–4) and its label |
+| `labels` | label names; `scope:`/`role:`/`validator:` prefixes get the same treatment as the GitHub adapter |
+| `externalRef` | `linear:<identifier>` |
+| `sourceIssueId` | the identifier |
+| `linearIssueId` | Linear's internal UUID — kept so mutations can skip a lookup |
+| `url`, `raw` | issue URL, full raw node |
+
+Status mapping is keyed off Linear's fixed state-type taxonomy, not the
+user-renamable state names:
+
+| Linear state type | Rig status |
+|---|---|
+| `triage`, `backlog`, `unstarted` | `ready` |
+| `started` | `in_progress` |
+| `completed` | `completed` |
+| `canceled` | `cancelled` |
+| anything unknown | `open` (fail-soft) |
+
+### 5. Lifecycle write-back
+
+Rig drives the source through `updateStatus(id, status)` and
+`updateTask(id, update)` (status/title/body/comment/metadata). The Linear
+implementation mirrors the GitHub adapter's responsibilities with GraphQL
+mutations:
+
+- **Status** → resolve the team's workflow states (`RigTeamStates`, cached per
+  source instance), pick the lowest-`position` state whose `type` matches the
+  Rig status (`in_progress` → `started`, `closed`/`completed` → `completed`,
+  `cancelled` → `canceled`, `ready` → `unstarted`), then `issueUpdate` with
+  `stateId`. Statuses Linear has no workflow concept for (`blocked`,
+  `failed`, `needs_attention`) deliberately leave the state untouched — they
+  surface through comments instead of mangling the board.
+- **Title / body / metadata** → folded into the same single `issueUpdate`
+  call. `update.metadata` is rendered into the Rig-owned
+  `<!-- rig:metadata:start/end -->` block (same markers as the GitHub
+  adapter, so operator surfaces parse both identically), replacing a previous
+  block in the existing description when present.
+- **Comment** → `commentCreate` after the update.
+- Task ids are accepted as either the identifier (`ENG-123`) or Linear's UUID;
+  identifiers are resolved with one extra `issue(id:)` query.
+
+Every write fires the optional `onTaskChanged` callback so the host can
+refresh snapshots — same pattern as the GitHub adapter.
+
+### 6. Error surfaces are part of the contract
+
+- No key configured → `"Linear task source: no API key configured. Pass apiKey in plugin options or set the LINEAR_API_KEY environment variable."` — thrown before any request.
+- Bad token (HTTP 401 or a GraphQL `AUTHENTICATION_ERROR`) → `"Linear API authentication failed (…). Check that the configured API key (options.apiKey / LINEAR_API_KEY) is a valid Linear key…"`.
+- Other GraphQL errors → surfaced with the server's message.
+- Non-200 HTTP → status + body excerpt.
+- More matching issues than `listLimit` → a loud refusal to truncate, telling
+  you exactly which knob to turn — never a silently short task list.
+
+## Running the tests
+
+```bash
+cd packages/linear-plugin
+bun test            # 39 tests, no network
+bunx tsc --noEmit   # typecheck
+```
+
+`contract.test.ts` runs `pluginContractTests` from `@rig/plugin-testkit`
+(schema validity, namespaced ids, duplicate-id detection) plus factory-wiring
+assertions; `linear-issues-source.test.ts` covers mapping, filters,
+pagination, lifecycle mutation payloads, and every error surface above.

package/dist/src/fixture-transport.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Fixture-driven fake transport for testing the Linear adapter (and plugins
+ * built on the same pattern) without any live API calls.
+ *
+ * The adapter names every GraphQL operation (`RigListIssues`,
+ * `RigTeamStates`, …), so fixtures route on the operation name instead of
+ * fragile query-string matching. Each route returns either:
+ *   - a plain object        → wrapped as `{ data: <object> }` with HTTP 200
+ *   - `graphqlErrors([...])` → `{ errors: [...] }` with HTTP 200
+ *   - `httpFailure(status, body)` → a raw non-200 HTTP response
+ */
+import type { LinearTransport } from "./linear-issues-source";
+export interface RecordedLinearCall {
+    url: string;
+    /** Raw Authorization header the adapter sent. */
+    authorization: string | undefined;
+    /** GraphQL operation name parsed from the request body. */
+    operation: string;
+    query: string;
+    variables: Record<string, unknown>;
+}
+declare const HTTP_FAILURE: unique symbol;
+declare const GRAPHQL_ERRORS: unique symbol;
+interface HttpFailureFixture {
+    [HTTP_FAILURE]: true;
+    status: number;
+    body: string;
+}
+interface GraphQLErrorsFixture {
+    [GRAPHQL_ERRORS]: true;
+    errors: ReadonlyArray<{
+        message: string;
+        extensions?: {
+            code?: string;
+        };
+    }>;
+}
+/** Make a route fail at the HTTP layer (e.g. `httpFailure(401, "Unauthorized")`). */
+export declare function httpFailure(status: number, body: string): HttpFailureFixture;
+/** Make a route return a GraphQL-level errors payload with HTTP 200. */
+export declare function graphqlErrors(errors: ReadonlyArray<{
+    message: string;
+    extensions?: {
+        code?: string;
+    };
+}>): GraphQLErrorsFixture;
+export type FixtureRoute = (variables: Record<string, unknown>, call: RecordedLinearCall) => unknown;
+export interface FixtureTransport {
+    transport: LinearTransport;
+    /** Every request the adapter made, in order. Assert payloads against this. */
+    calls: RecordedLinearCall[];
+    /** Calls filtered to one operation name. */
+    callsFor(operation: string): RecordedLinearCall[];
+}
+/**
+ * Build a transport whose responses come from fixtures keyed by GraphQL
+ * operation name. Unrouted operations fail loudly so tests never silently
+ * exercise a request they didn't mean to allow.
+ */
+export declare function createFixtureTransport(routes: Record<string, FixtureRoute>): FixtureTransport;
+export {};

package/dist/src/fixture-transport.js

@@ -0,0 +1,56 @@
+// @bun
+// packages/linear-plugin/src/fixture-transport.ts
+var HTTP_FAILURE = Symbol("linear-fixture-http-failure");
+var GRAPHQL_ERRORS = Symbol("linear-fixture-graphql-errors");
+function httpFailure(status, body) {
+  return { [HTTP_FAILURE]: true, status, body };
+}
+function graphqlErrors(errors) {
+  return { [GRAPHQL_ERRORS]: true, errors };
+}
+function isHttpFailure(value) {
+  return typeof value === "object" && value !== null && HTTP_FAILURE in value;
+}
+function isGraphQLErrors(value) {
+  return typeof value === "object" && value !== null && GRAPHQL_ERRORS in value;
+}
+function jsonResponse(status, body) {
+  return { ok: status >= 200 && status < 300, status, text: async () => body };
+}
+function createFixtureTransport(routes) {
+  const calls = [];
+  const transport = async (url, init) => {
+    const body = JSON.parse(init.body);
+    const operation = /(?:query|mutation)\s+([A-Za-z0-9_]+)/.exec(body.query)?.[1] ?? "<anonymous>";
+    const call = {
+      url,
+      authorization: init.headers["Authorization"],
+      operation,
+      query: body.query,
+      variables: body.variables ?? {}
+    };
+    calls.push(call);
+    const route = routes[operation];
+    if (!route) {
+      throw new Error(`createFixtureTransport: no fixture route for operation "${operation}"`);
+    }
+    const result = route(call.variables, call);
+    if (isHttpFailure(result)) {
+      return jsonResponse(result.status, result.body);
+    }
+    if (isGraphQLErrors(result)) {
+      return jsonResponse(200, JSON.stringify({ errors: result.errors }));
+    }
+    return jsonResponse(200, JSON.stringify({ data: result }));
+  };
+  return {
+    transport,
+    calls,
+    callsFor: (operation) => calls.filter((c) => c.operation === operation)
+  };
+}
+export {
+  httpFailure,
+  graphqlErrors,
+  createFixtureTransport
+};

package/dist/src/fixtures.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Shared GraphQL fixtures for the test suite — shaped exactly like real
+ * Linear API responses (the `data` payload of each operation). No live API
+ * calls happen anywhere in this package's tests.
+ */
+export declare const TEAM_KEY = "ENG";
+export declare const STATE_IDS: {
+    readonly triage: "11111111-1111-4111-8111-111111111101";
+    readonly backlog: "11111111-1111-4111-8111-111111111102";
+    readonly todo: "11111111-1111-4111-8111-111111111103";
+    readonly inProgress: "11111111-1111-4111-8111-111111111104";
+    readonly inReview: "11111111-1111-4111-8111-111111111105";
+    readonly done: "11111111-1111-4111-8111-111111111106";
+    readonly canceled: "11111111-1111-4111-8111-111111111107";
+};
+/** Response payload for the RigTeamStates operation. */
+export declare const teamStatesFixture: {
+    teams: {
+        nodes: {
+            id: string;
+            key: string;
+            states: {
+                nodes: ({
+                    id: "11111111-1111-4111-8111-111111111101";
+                    name: string;
+                    type: string;
+                    position: number;
+                } | {
+                    id: "11111111-1111-4111-8111-111111111102";
+                    name: string;
+                    type: string;
+                    position: number;
+                } | {
+                    id: "11111111-1111-4111-8111-111111111103";
+                    name: string;
+                    type: string;
+                    position: number;
+                } | {
+                    id: "11111111-1111-4111-8111-111111111105";
+                    name: string;
+                    type: string;
+                    position: number;
+                } | {
+                    id: "11111111-1111-4111-8111-111111111104";
+                    name: string;
+                    type: string;
+                    position: number;
+                } | {
+                    id: "11111111-1111-4111-8111-111111111106";
+                    name: string;
+                    type: string;
+                    position: number;
+                } | {
+                    id: "11111111-1111-4111-8111-111111111107";
+                    name: string;
+                    type: string;
+                    position: number;
+                })[];
+            };
+        }[];
+    };
+};
+export declare const ISSUE_UUIDS: {
+    readonly eng1: "33333333-3333-4333-8333-333333333301";
+    readonly eng2: "33333333-3333-4333-8333-333333333302";
+    readonly eng3: "33333333-3333-4333-8333-333333333303";
+    readonly eng4: "33333333-3333-4333-8333-333333333304";
+    readonly eng5: "33333333-3333-4333-8333-333333333305";
+    readonly eng6: "33333333-3333-4333-8333-333333333306";
+    readonly eng7: "33333333-3333-4333-8333-333333333307";
+};
+export interface FixtureIssue {
+    id: string;
+    identifier: string;
+    title: string;
+    description: string | null;
+    priority: number | null;
+    priorityLabel: string | null;
+    url: string;
+    state: {
+        id: string;
+        name: string;
+        type: string;
+    };
+    labels: {
+        nodes: Array<{
+            name: string;
+        }>;
+    };
+    assignee: {
+        name: string;
+        email: string;
+    } | null;
+}
+export declare const issueFixtures: FixtureIssue[];
+/** Single-page RigListIssues payload containing every fixture issue. */
+export declare function listIssuesPage(issues: readonly FixtureIssue[], pageInfo?: {
+    hasNextPage: boolean;
+    endCursor?: string | null;
+}): {
+    issues: {
+        pageInfo: {
+            hasNextPage: boolean;
+            endCursor?: string | null;
+        };
+        nodes: readonly FixtureIssue[];
+    };
+};
+export declare function issueByIdentifier(identifier: string): FixtureIssue;

package/dist/src/fixtures.js

@@ -0,0 +1,155 @@
+// @bun
+// packages/linear-plugin/src/fixtures.ts
+var TEAM_KEY = "ENG";
+var STATE_IDS = {
+  triage: "11111111-1111-4111-8111-111111111101",
+  backlog: "11111111-1111-4111-8111-111111111102",
+  todo: "11111111-1111-4111-8111-111111111103",
+  inProgress: "11111111-1111-4111-8111-111111111104",
+  inReview: "11111111-1111-4111-8111-111111111105",
+  done: "11111111-1111-4111-8111-111111111106",
+  canceled: "11111111-1111-4111-8111-111111111107"
+};
+var teamStatesFixture = {
+  teams: {
+    nodes: [
+      {
+        id: "22222222-2222-4222-8222-222222222201",
+        key: TEAM_KEY,
+        states: {
+          nodes: [
+            { id: STATE_IDS.triage, name: "Triage", type: "triage", position: 0 },
+            { id: STATE_IDS.backlog, name: "Backlog", type: "backlog", position: 1 },
+            { id: STATE_IDS.todo, name: "Todo", type: "unstarted", position: 2 },
+            { id: STATE_IDS.inReview, name: "In Review", type: "started", position: 4 },
+            { id: STATE_IDS.inProgress, name: "In Progress", type: "started", position: 3 },
+            { id: STATE_IDS.done, name: "Done", type: "completed", position: 5 },
+            { id: STATE_IDS.canceled, name: "Canceled", type: "canceled", position: 6 }
+          ]
+        }
+      }
+    ]
+  }
+};
+var ISSUE_UUIDS = {
+  eng1: "33333333-3333-4333-8333-333333333301",
+  eng2: "33333333-3333-4333-8333-333333333302",
+  eng3: "33333333-3333-4333-8333-333333333303",
+  eng4: "33333333-3333-4333-8333-333333333304",
+  eng5: "33333333-3333-4333-8333-333333333305",
+  eng6: "33333333-3333-4333-8333-333333333306",
+  eng7: "33333333-3333-4333-8333-333333333307"
+};
+var issueFixtures = [
+  {
+    id: ISSUE_UUIDS.eng1,
+    identifier: "ENG-1",
+    title: "Untriaged crash report",
+    description: null,
+    priority: 0,
+    priorityLabel: "No priority",
+    url: "https://linear.app/acme/issue/ENG-1",
+    state: { id: STATE_IDS.triage, name: "Triage", type: "triage" },
+    labels: { nodes: [] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng2,
+    identifier: "ENG-2",
+    title: "Someday refactor",
+    description: "Park it in the backlog.",
+    priority: 4,
+    priorityLabel: "Low",
+    url: "https://linear.app/acme/issue/ENG-2",
+    state: { id: STATE_IDS.backlog, name: "Backlog", type: "backlog" },
+    labels: { nodes: [{ name: "tech-debt" }] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng3,
+    identifier: "ENG-3",
+    title: "Add retry to webhook dispatcher",
+    description: `Retries with backoff.
+
+See the incident doc.`,
+    priority: 2,
+    priorityLabel: "High",
+    url: "https://linear.app/acme/issue/ENG-3",
+    state: { id: STATE_IDS.todo, name: "Todo", type: "unstarted" },
+    labels: {
+      nodes: [
+        { name: "rig" },
+        { name: "scope:packages/server/**" },
+        { name: "role:builder" },
+        { name: "validator:typecheck" }
+      ]
+    },
+    assignee: { name: "Alex", email: "alex@example.com" }
+  },
+  {
+    id: ISSUE_UUIDS.eng4,
+    identifier: "ENG-4",
+    title: "Migrate auth tokens",
+    description: "In flight.",
+    priority: 1,
+    priorityLabel: "Urgent",
+    url: "https://linear.app/acme/issue/ENG-4",
+    state: { id: STATE_IDS.inProgress, name: "In Progress", type: "started" },
+    labels: { nodes: [{ name: "rig" }] },
+    assignee: { name: "Alex", email: "alex@example.com" }
+  },
+  {
+    id: ISSUE_UUIDS.eng5,
+    identifier: "ENG-5",
+    title: "Ship the dashboard",
+    description: "Done last sprint.",
+    priority: 3,
+    priorityLabel: "Medium",
+    url: "https://linear.app/acme/issue/ENG-5",
+    state: { id: STATE_IDS.done, name: "Done", type: "completed" },
+    labels: { nodes: [] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng6,
+    identifier: "ENG-6",
+    title: "Dead-end spike",
+    description: null,
+    priority: null,
+    priorityLabel: null,
+    url: "https://linear.app/acme/issue/ENG-6",
+    state: { id: STATE_IDS.canceled, name: "Canceled", type: "canceled" },
+    labels: { nodes: [] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng7,
+    identifier: "ENG-7",
+    title: "Issue in a state type this adapter has never heard of",
+    description: null,
+    priority: null,
+    priorityLabel: null,
+    url: "https://linear.app/acme/issue/ENG-7",
+    state: { id: "11111111-1111-4111-8111-111111111199", name: "Weird", type: "someday-new-type" },
+    labels: { nodes: [] },
+    assignee: null
+  }
+];
+function listIssuesPage(issues, pageInfo = { hasNextPage: false, endCursor: null }) {
+  return { issues: { pageInfo, nodes: issues } };
+}
+function issueByIdentifier(identifier) {
+  const issue = issueFixtures.find((i) => i.identifier === identifier);
+  if (!issue)
+    throw new Error(`fixture issue not found: ${identifier}`);
+  return issue;
+}
+export {
+  teamStatesFixture,
+  listIssuesPage,
+  issueFixtures,
+  issueByIdentifier,
+  TEAM_KEY,
+  STATE_IDS,
+  ISSUE_UUIDS
+};

package/dist/src/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `@rig/linear-plugin` — Linear as a Rig task source.
+ *
+ * This package is the canonical example of a plugin that adapts an external
+ * HTTP API into Rig's task-source contract. The README walks through the
+ * anatomy; `linear-issues-source.ts` holds the adapter, this file holds the
+ * `definePlugin` wiring (metadata channel + executable runtime channel).
+ *
+ * Usage in rig.config.ts:
+ *
+ *   import { defineConfig } from "@rig/core";
+ *   import linear from "@rig/linear-plugin";
+ *
+ *   export default defineConfig({
+ *     plugins: [linear()],
+ *     taskSource: {
+ *       kind: "linear",
+ *       options: { teamKey: "ENG", states: ["Todo"], labels: ["rig"] },
+ *     },
+ *     // ...
+ *   });
+ *
+ * The API key comes from LINEAR_API_KEY (or `linear({ apiKey })`) — never
+ * from rig.config.ts, which is committed.
+ */
+import { type RigPluginWithRuntime } from "@rig/core";
+import { type LinearIssuesOptions, type LinearTransport } from "./linear-issues-source";
+export { createLinearIssuesTaskSource, linearStateTypeForRigStatus, rigStatusForLinearStateType, updateRigOwnedMetadataBlock, RIG_METADATA_START, RIG_METADATA_END, } from "./linear-issues-source";
+export type { LinearIssuesOptions, LinearIssuesTaskSource, LinearTransport, LinearTransportRequest, LinearTransportResponse, } from "./linear-issues-source";
+export { createFixtureTransport, graphqlErrors, httpFailure, } from "./fixture-transport";
+export type { FixtureTransport, FixtureRoute, RecordedLinearCall } from "./fixture-transport";
+/**
+ * Process-level options passed where the plugin is instantiated (rig.config.ts).
+ * Per-project source configuration (team key, filters) lives in
+ * `taskSource.options` instead — see the factory below.
+ */
+export interface LinearPluginOptions {
+    /** Linear API key. Defaults to process.env.LINEAR_API_KEY at request time. */
+    apiKey?: string;
+    /** GraphQL endpoint override (self-hosted proxies, test servers). */
+    endpoint?: string;
+    /** fetch-shaped transport override — tests inject a fixture transport here. */
+    transport?: LinearTransport;
+    /** Notify the host that issue-backed task state changed. */
+    onTaskChanged?: LinearIssuesOptions["onTaskChanged"];
+}
+export default function linearPlugin(opts?: LinearPluginOptions): RigPluginWithRuntime;