@runfusion/fusion 0.54.0 → 0.56.0

package/dist/plugins/fusion-plugin-linear-import/bundled.js

@@ -0,0 +1,658 @@
+// ../plugin-sdk/src/index.ts
+import {
+  WORKFLOW_EXTENSION_SCHEMA_VERSION,
+  workflowExtensionRegistryId,
+  createBoardActionServices
+} from "@fusion/core";
+function definePlugin(plugin2) {
+  return plugin2;
+}
+
+// ../../plugins/fusion-plugin-linear-import/src/settings.ts
+var LINEAR_PLUGIN_ID = "fusion-plugin-linear-import";
+var linearSettingsSchema = {
+  apiKey: {
+    type: "password",
+    label: "Linear API key",
+    description: "Personal Linear API key used only by this plugin to browse and import issues.",
+    required: true,
+    group: "Authentication"
+  },
+  defaultTeamKey: {
+    type: "string",
+    label: "Default team key or ID",
+    description: "Optional Linear team key or UUID to prefill issue searches.",
+    group: "Defaults"
+  },
+  defaultStateFilter: {
+    type: "enum",
+    label: "Default issue state filter",
+    description: "Initial issue state filter for browse and import tools.",
+    enumValues: ["active", "backlog", "started", "unstarted", "completed", "canceled", "all"],
+    defaultValue: "active",
+    group: "Defaults"
+  },
+  defaultAssigneeId: {
+    type: "string",
+    label: "Default assignee ID",
+    description: "Optional Linear user UUID used as the default assignee filter.",
+    group: "Defaults"
+  }
+};
+function optionalTrimmed(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveLinearSettings(settings) {
+  const rawState = optionalTrimmed(settings.defaultStateFilter);
+  const defaultStateFilter = rawState && linearSettingsSchema.defaultStateFilter.enumValues?.includes(rawState) ? rawState : "active";
+  return {
+    apiKey: optionalTrimmed(settings.apiKey),
+    defaultTeamKey: optionalTrimmed(settings.defaultTeamKey),
+    defaultStateFilter,
+    defaultAssigneeId: optionalTrimmed(settings.defaultAssigneeId)
+  };
+}
+function hasLinearApiKey(settings) {
+  return Boolean(resolveLinearSettings(settings).apiKey);
+}
+
+// ../../plugins/fusion-plugin-linear-import/src/linear-client.ts
+var LINEAR_GRAPHQL_ENDPOINT = "https://api.linear.app/graphql";
+var DEFAULT_LIMIT = 30;
+var MAX_LIMIT = 100;
+var PAGE_SIZE = 50;
+var MAX_PAGES = 5;
+var LinearApiError = class extends Error {
+  constructor(status, message, code = "linear_api_error") {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "LinearApiError";
+  }
+};
+function clampLinearLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) return DEFAULT_LIMIT;
+  return Math.max(1, Math.min(MAX_LIMIT, Math.floor(limit)));
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function redactSensitiveText(message, secrets = []) {
+  let redacted = message;
+  for (const secret of secrets) {
+    if (secret) redacted = redacted.split(secret).join("[redacted]");
+  }
+  return redacted.replace(/\b(token|key|secret)[-_:=][A-Za-z0-9._-]+/giu, "$1-[redacted]");
+}
+function normalizeLinearErrorMessage(status, body, secrets = []) {
+  if (status === 401) return "Linear API key is missing, invalid, or expired.";
+  if (status === 403) return "Linear API key does not have access to the requested Linear workspace or team.";
+  if (status === 429) return "Linear rate limit exceeded. Try again later.";
+  const raw = asRecord(body);
+  const errors = Array.isArray(raw.errors) ? raw.errors : [];
+  const first = asRecord(errors[0]);
+  const message = asString(first.message) ?? asString(raw.error) ?? asString(raw.message);
+  return message ? `Linear GraphQL error: ${redactSensitiveText(message, secrets)}` : `Linear API request failed with status ${status}.`;
+}
+function mapFetchError(error) {
+  if (error instanceof LinearApiError) return error;
+  return new LinearApiError(0, "Unable to reach Linear API. Check network access and plugin configuration.", "network_error");
+}
+function buildLinearIssueFilter(options) {
+  const and = [];
+  if (options.teamKey?.trim()) {
+    and.push({ team: { or: [{ key: { eqIgnoreCase: options.teamKey.trim() } }, { id: { eq: options.teamKey.trim() } }] } });
+  }
+  if (options.assigneeId?.trim()) {
+    and.push({ assignee: { id: { eq: options.assigneeId.trim() } } });
+  }
+  if (options.state && options.state !== "all") {
+    and.push({ state: { type: { eq: options.state } } });
+  }
+  if (options.query?.trim()) {
+    const q = options.query.trim();
+    and.push({ or: [{ title: { containsIgnoreCase: q } }, { description: { containsIgnoreCase: q } }, { identifier: { containsIgnoreCase: q } }] });
+  }
+  return and.length > 0 ? { and } : void 0;
+}
+var LINEAR_ISSUES_QUERY = `query FusionLinearImportIssues($first: Int!, $after: String, $filter: IssueFilter) {
+  issues(first: $first, after: $after, filter: $filter, orderBy: updatedAt) {
+    nodes {
+      id
+      identifier
+      title
+      description
+      url
+      createdAt
+      updatedAt
+      state { id name type }
+      team { id key name }
+      assignee { id name email }
+      creator { id name email }
+      labels { nodes { id name } }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`;
+var LINEAR_ISSUE_QUERY = `query FusionLinearImportIssue($id: String!) {
+  issue(id: $id) {
+    id
+    identifier
+    title
+    description
+    url
+    createdAt
+    updatedAt
+    state { id name type }
+    team { id key name }
+    assignee { id name email }
+    creator { id name email }
+    labels { nodes { id name } }
+  }
+}`;
+function normalizeIssue(rawIssue) {
+  const raw = asRecord(rawIssue);
+  const id = asString(raw.id);
+  const identifier = asString(raw.identifier);
+  const title = asString(raw.title);
+  const url = asString(raw.url);
+  if (!id || !identifier || !title || !url) return null;
+  const labelsRaw = asRecord(raw.labels).nodes;
+  const labels = Array.isArray(labelsRaw) ? labelsRaw.flatMap((label) => {
+    const rawLabel = asRecord(label);
+    const name = asString(rawLabel.name);
+    return name ? [{ id: asString(rawLabel.id), name }] : [];
+  }) : [];
+  const state = asRecord(raw.state);
+  const team = asRecord(raw.team);
+  const assignee = asRecord(raw.assignee);
+  const creator = asRecord(raw.creator);
+  return {
+    id,
+    identifier,
+    title,
+    description: typeof raw.description === "string" ? raw.description : null,
+    url,
+    state: Object.keys(state).length ? { id: asString(state.id), name: asString(state.name), type: asString(state.type) } : null,
+    team: Object.keys(team).length ? { id: asString(team.id), key: asString(team.key), name: asString(team.name) } : null,
+    assignee: Object.keys(assignee).length ? { id: asString(assignee.id), name: asString(assignee.name), email: asString(assignee.email) } : null,
+    creator: Object.keys(creator).length ? { id: asString(creator.id), name: asString(creator.name), email: asString(creator.email) } : null,
+    labels,
+    createdAt: asString(raw.createdAt),
+    updatedAt: asString(raw.updatedAt)
+  };
+}
+var LinearClient = class {
+  constructor(apiKey, fetchImpl = fetch) {
+    this.apiKey = apiKey;
+    this.fetchImpl = fetchImpl;
+  }
+  async request(query, variables) {
+    let response2;
+    try {
+      response2 = await this.fetchImpl(LINEAR_GRAPHQL_ENDPOINT, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          Authorization: this.apiKey
+        },
+        body: JSON.stringify({ query, variables })
+      });
+    } catch (error) {
+      throw mapFetchError(error);
+    }
+    const body = await response2.json().catch(() => ({}));
+    if (!response2.ok) {
+      throw new LinearApiError(response2.status, normalizeLinearErrorMessage(response2.status, body, [this.apiKey]));
+    }
+    const errors = Array.isArray(asRecord(body).errors) ? asRecord(body).errors : [];
+    if (errors.length > 0) {
+      throw new LinearApiError(400, normalizeLinearErrorMessage(400, body, [this.apiKey]), "graphql_error");
+    }
+    return asRecord(body).data;
+  }
+  /*
+  FNXC:LinearImport 2026-07-02-00:00:
+  FN-7443 integrates Linear as a plugin-owned SaaS GraphQL HTTP client. Keep pagination bounded and errors credential-safe so plugin routes/tools can expose actionable failures without ever returning the API key.
+  */
+  async listIssues(options = {}) {
+    const limit = clampLinearLimit(options.limit);
+    const issues = [];
+    let after = options.after;
+    let pageInfo = { hasNextPage: false, endCursor: null };
+    for (let page = 0; issues.length < limit && page < MAX_PAGES; page += 1) {
+      const data = await this.request(LINEAR_ISSUES_QUERY, {
+        first: Math.min(PAGE_SIZE, limit - issues.length),
+        after: after ?? null,
+        filter: buildLinearIssueFilter(options) ?? null
+      });
+      const connection = data.issues ?? {};
+      const nodes = Array.isArray(connection.nodes) ? connection.nodes : [];
+      issues.push(...nodes.map(normalizeIssue).filter((issue) => Boolean(issue)));
+      pageInfo = {
+        hasNextPage: connection.pageInfo?.hasNextPage === true,
+        endCursor: connection.pageInfo?.endCursor ?? null
+      };
+      if (!pageInfo.hasNextPage || !pageInfo.endCursor || nodes.length === 0) break;
+      after = pageInfo.endCursor;
+    }
+    return { issues: issues.slice(0, limit), pageInfo };
+  }
+  async getIssue(idOrIdentifier) {
+    const id = idOrIdentifier.trim();
+    if (!id) throw new LinearApiError(400, "Linear issue id or identifier is required.", "validation_error");
+    const data = await this.request(LINEAR_ISSUE_QUERY, { id });
+    const issue = normalizeIssue(data.issue);
+    if (!issue) throw new LinearApiError(404, "Linear issue was not found or is inaccessible.", "not_found");
+    return issue;
+  }
+};
+function linearErrorToResponse(error) {
+  if (error instanceof LinearApiError) {
+    const status = error.status === 0 ? 502 : error.status;
+    return { status, error: error.message, code: error.code };
+  }
+  return { status: 500, error: "Linear import failed unexpectedly.", code: "unexpected_error" };
+}
+
+// ../../plugins/fusion-plugin-linear-import/src/import-linear.ts
+function cleanText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function linearRepository(issue) {
+  return issue.team?.key ?? issue.team?.id ?? "linear";
+}
+function getLinearDuplicateKeys(issue) {
+  return {
+    issueId: issue.id,
+    identifier: issue.identifier,
+    url: issue.url
+  };
+}
+function buildLinearSourceMetadata(issue) {
+  return {
+    provider: "linear",
+    issueId: issue.id,
+    identifier: issue.identifier,
+    url: issue.url,
+    teamId: issue.team?.id,
+    teamKey: issue.team?.key,
+    teamName: issue.team?.name,
+    stateName: issue.state?.name,
+    stateType: issue.state?.type,
+    assigneeId: issue.assignee?.id,
+    assigneeName: issue.assignee?.name,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt
+  };
+}
+function buildLinearImportPreview(issue) {
+  const description = cleanText(issue.description) ?? "(no description)";
+  const details = [
+    description,
+    "",
+    `Source: ${issue.url}`,
+    `Linear: ${issue.identifier}`,
+    issue.team?.key || issue.team?.name ? `Team: ${issue.team.key ?? issue.team.name}` : void 0,
+    issue.state?.name ? `State: ${issue.state.name}` : void 0
+  ].filter(Boolean).join("\n");
+  return {
+    title: `[${issue.identifier}] ${issue.title}`,
+    description: details,
+    sourceIssue: {
+      provider: "linear",
+      repository: linearRepository(issue),
+      externalIssueId: issue.id,
+      issueNumber: Number.parseInt(issue.identifier.replace(/^[A-Z]+-/iu, ""), 10) || 0,
+      url: issue.url
+    },
+    sourceMetadata: buildLinearSourceMetadata(issue),
+    duplicateKeys: getLinearDuplicateKeys(issue)
+  };
+}
+function getTaskSourceMetadata(task) {
+  return task.source?.sourceMetadata ?? {};
+}
+function taskMatchesLinearIssue(task, issue) {
+  const metadata = getTaskSourceMetadata(task);
+  if (task.sourceIssue?.provider === "linear") {
+    if (task.sourceIssue.externalIssueId === issue.id) return true;
+    if (task.sourceIssue.url && task.sourceIssue.url === issue.url) return true;
+  }
+  if (task.source?.sourceType === "api" && metadata.provider === "linear") {
+    if (metadata.issueId === issue.id || metadata.identifier === issue.identifier || metadata.url === issue.url) return true;
+  }
+  const description = typeof task.description === "string" ? task.description : "";
+  return description.includes(`Source: ${issue.url}`);
+}
+async function findExistingLinearTask(taskStore, issue) {
+  if (typeof taskStore.listTasks !== "function") return null;
+  const tasks = await taskStore.listTasks({ includeArchived: false, slim: false });
+  return tasks.find((task) => taskMatchesLinearIssue(task, issue)) ?? null;
+}
+function buildLinearTaskCreateInput(issue) {
+  const preview = buildLinearImportPreview(issue);
+  return {
+    title: preview.title,
+    description: preview.description,
+    column: "triage",
+    sourceIssue: preview.sourceIssue,
+    source: {
+      sourceType: "api",
+      sourceMetadata: preview.sourceMetadata
+    }
+  };
+}
+async function importLinearIssue(taskStore, issue) {
+  const preview = buildLinearImportPreview(issue);
+  const existing = await findExistingLinearTask(taskStore, issue);
+  if (existing) {
+    return { imported: false, duplicate: true, taskId: existing.id, task: existing, issue: preview };
+  }
+  if (typeof taskStore.createTask !== "function") {
+    throw new Error("Plugin task store cannot create tasks in this context.");
+  }
+  const task = await taskStore.createTask(buildLinearTaskCreateInput(issue));
+  return { imported: true, duplicate: false, taskId: task.id, task, issue: preview };
+}
+
+// ../../plugins/fusion-plugin-linear-import/src/routes.ts
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readBody(req) {
+  return asRecord2(req.body);
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function response(status, body) {
+  return { status, body };
+}
+function requireClient(ctx) {
+  const settings = resolveLinearSettings(ctx.settings);
+  if (!settings.apiKey) {
+    return response(401, { ok: false, authenticated: false, error: "Configure a Linear API key in Plugin Manager settings before importing issues.", code: "missing_api_key" });
+  }
+  return new LinearClient(settings.apiKey);
+}
+function readListOptions(ctx, source) {
+  const settings = resolveLinearSettings(ctx.settings);
+  return {
+    query: readString(source.query),
+    teamKey: readString(source.teamKey) ?? readString(source.teamId) ?? settings.defaultTeamKey,
+    state: readString(source.state) ?? settings.defaultStateFilter,
+    assigneeId: readString(source.assigneeId) ?? settings.defaultAssigneeId,
+    limit: readNumber(source.limit),
+    after: readString(source.after)
+  };
+}
+function errorResponse(error) {
+  const mapped = linearErrorToResponse(error);
+  return response(mapped.status, { ok: false, error: mapped.error, code: mapped.code });
+}
+async function getLinearStatus(_req, ctx) {
+  const settings = resolveLinearSettings(ctx.settings);
+  if (!settings.apiKey) {
+    return response(200, { ok: true, authenticated: false, configured: false, defaultTeamKey: settings.defaultTeamKey ?? null, defaultStateFilter: settings.defaultStateFilter });
+  }
+  try {
+    const client = new LinearClient(settings.apiKey);
+    await client.listIssues({ limit: 1, teamKey: settings.defaultTeamKey, state: settings.defaultStateFilter, assigneeId: settings.defaultAssigneeId });
+    return response(200, { ok: true, authenticated: true, configured: true, defaultTeamKey: settings.defaultTeamKey ?? null, defaultStateFilter: settings.defaultStateFilter });
+  } catch (error) {
+    const mapped = linearErrorToResponse(error);
+    return response(mapped.status, { ok: false, authenticated: false, configured: true, error: mapped.error, code: mapped.code });
+  }
+}
+async function listLinearIssues(req, ctx) {
+  const client = requireClient(ctx);
+  if (!(client instanceof LinearClient)) return client;
+  try {
+    const query = { ...asRecord2(req.query), ...readBody(req) };
+    const result = await client.listIssues(readListOptions(ctx, query));
+    return response(200, { ok: true, issues: result.issues, pageInfo: result.pageInfo });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function getLinearIssueDetail(req, ctx) {
+  const client = requireClient(ctx);
+  if (!(client instanceof LinearClient)) return client;
+  const body = readBody(req);
+  const issueId = readString(body.issueId) ?? readString(body.id) ?? readString(body.identifier);
+  if (!issueId) return response(400, { ok: false, error: "issueId or identifier is required.", code: "validation_error" });
+  try {
+    const issue = await client.getIssue(issueId);
+    return response(200, { ok: true, issue });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function importSingleLinearIssue(req, ctx) {
+  const client = requireClient(ctx);
+  if (!(client instanceof LinearClient)) return client;
+  const body = readBody(req);
+  const issueId = readString(body.issueId) ?? readString(body.id) ?? readString(body.identifier);
+  if (!issueId) return response(400, { ok: false, error: "issueId or identifier is required.", code: "validation_error" });
+  try {
+    const issue = await client.getIssue(issueId);
+    const result = await importLinearIssue(ctx.taskStore, issue);
+    return response(result.duplicate ? 200 : 201, { ok: true, ...result, task: void 0 });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+async function importBatchLinearIssues(req, ctx) {
+  const client = requireClient(ctx);
+  if (!(client instanceof LinearClient)) return client;
+  const body = readBody(req);
+  const issueIds = Array.isArray(body.issueIds) ? body.issueIds.map(readString).filter((id) => Boolean(id)) : [];
+  if (issueIds.length === 0) return response(400, { ok: false, error: "issueIds must include at least one Linear issue id or identifier.", code: "validation_error" });
+  if (issueIds.length > 25) return response(400, { ok: false, error: "Batch import is limited to 25 Linear issues at a time.", code: "limit_exceeded" });
+  try {
+    const results = [];
+    for (const issueId of issueIds) {
+      const issue = await client.getIssue(issueId);
+      const result = await importLinearIssue(ctx.taskStore, issue);
+      results.push({ ...result, task: void 0 });
+    }
+    return response(200, {
+      ok: true,
+      results,
+      imported: results.filter((result) => result.imported).length,
+      duplicates: results.filter((result) => result.duplicate).length
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}
+var linearImportRoutes = [
+  { method: "GET", path: "/status", handler: getLinearStatus, description: "Check Linear import plugin authentication status." },
+  { method: "POST", path: "/issues", handler: listLinearIssues, description: "List/search Linear issues using plugin settings." },
+  { method: "POST", path: "/issues/detail", handler: getLinearIssueDetail, description: "Fetch one Linear issue by id or identifier." },
+  { method: "POST", path: "/issues/import", handler: importSingleLinearIssue, description: "Import one Linear issue as a Fusion task." },
+  { method: "POST", path: "/issues/import-batch", handler: importBatchLinearIssues, description: "Import selected Linear issues as Fusion tasks." }
+];
+
+// ../../plugins/fusion-plugin-linear-import/src/tools.ts
+function textResult(text, details, isError = false) {
+  return { content: [{ type: "text", text }], details, isError };
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getClient(ctx) {
+  const settings = resolveLinearSettings(ctx.settings);
+  if (!settings.apiKey) {
+    return textResult("Linear Import is not configured. Add a Linear API key in Plugin Manager settings.", { code: "missing_api_key" }, true);
+  }
+  return new LinearClient(settings.apiKey);
+}
+function listOptions(params, ctx) {
+  const settings = resolveLinearSettings(ctx.settings);
+  return {
+    query: readString2(params.query),
+    teamKey: readString2(params.teamKey) ?? readString2(params.teamId) ?? settings.defaultTeamKey,
+    state: readString2(params.state) ?? settings.defaultStateFilter,
+    assigneeId: readString2(params.assigneeId) ?? settings.defaultAssigneeId,
+    limit: readNumber2(params.limit),
+    after: readString2(params.after)
+  };
+}
+function safeErrorResult(error) {
+  const mapped = linearErrorToResponse(error);
+  return textResult(`Linear import failed: ${mapped.error}`, { code: mapped.code, status: mapped.status }, true);
+}
+var browseParams = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Optional text search over Linear issue title, description, or identifier." },
+    teamKey: { type: "string", description: "Optional Linear team key or UUID." },
+    state: { type: "string", enum: ["active", "backlog", "started", "unstarted", "completed", "canceled", "all"], description: "Optional Linear state type filter." },
+    assigneeId: { type: "string", description: "Optional Linear assignee user UUID." },
+    limit: { type: "number", minimum: 1, maximum: 100, description: "Maximum issues to return." },
+    after: { type: "string", description: "Optional Linear pagination cursor." }
+  },
+  required: []
+};
+var browseLinearIssuesTool = {
+  name: "linear_import_browse_issues",
+  description: "Browse/search Linear issues through the Linear Import plugin settings.",
+  parameters: browseParams,
+  execute: async (params, ctx) => {
+    const client = getClient(ctx);
+    if (!(client instanceof LinearClient)) return client;
+    try {
+      const result = await client.listIssues(listOptions(params, ctx));
+      const lines = result.issues.length === 0 ? ["No Linear issues matched the filters."] : result.issues.map((issue) => `- ${issue.identifier}: ${issue.title} (${issue.url})`);
+      return textResult(lines.join("\n"), { issues: result.issues, pageInfo: result.pageInfo });
+    } catch (error) {
+      return safeErrorResult(error);
+    }
+  }
+};
+var importLinearIssueTool = {
+  name: "linear_import_issue",
+  description: "Import one Linear issue into Fusion as a triage task, skipping duplicates.",
+  parameters: {
+    type: "object",
+    properties: {
+      issueId: { type: "string", description: "Linear issue UUID or human identifier such as ENG-123." }
+    },
+    required: ["issueId"]
+  },
+  execute: async (params, ctx) => {
+    const issueId = readString2(params.issueId);
+    if (!issueId) return textResult("issueId is required.", { code: "validation_error" }, true);
+    const client = getClient(ctx);
+    if (!(client instanceof LinearClient)) return client;
+    try {
+      const issue = await client.getIssue(issueId);
+      const result = await importLinearIssue(ctx.taskStore, issue);
+      const message = result.duplicate ? `Skipped duplicate Linear issue ${issue.identifier}; existing task ${result.taskId}.` : `Imported Linear issue ${issue.identifier} as task ${result.taskId}.`;
+      return textResult(message, { imported: result.imported, duplicate: result.duplicate, taskId: result.taskId, issue: result.issue });
+    } catch (error) {
+      return safeErrorResult(error);
+    }
+  }
+};
+var importLinearIssuesTool = {
+  name: "linear_import_issues",
+  description: "Import multiple Linear issues into Fusion as triage tasks, skipping duplicates.",
+  parameters: {
+    type: "object",
+    properties: {
+      issueIds: { type: "array", items: { type: "string" }, description: "Linear issue UUIDs or identifiers to import. Maximum 25." }
+    },
+    required: ["issueIds"]
+  },
+  execute: async (params, ctx) => {
+    const issueIds = Array.isArray(params.issueIds) ? params.issueIds.map(readString2).filter((id) => Boolean(id)) : [];
+    if (issueIds.length === 0) return textResult("issueIds must include at least one Linear issue id or identifier.", { code: "validation_error" }, true);
+    if (issueIds.length > 25) return textResult("Batch import is limited to 25 Linear issues at a time.", { code: "limit_exceeded" }, true);
+    const client = getClient(ctx);
+    if (!(client instanceof LinearClient)) return client;
+    try {
+      const results = [];
+      for (const issueId of issueIds) {
+        const issue = await client.getIssue(issueId);
+        results.push(await importLinearIssue(ctx.taskStore, issue));
+      }
+      const imported = results.filter((result) => result.imported).length;
+      const duplicates = results.filter((result) => result.duplicate).length;
+      return textResult(`Linear batch import complete: ${imported} imported, ${duplicates} duplicates skipped.`, {
+        imported,
+        duplicates,
+        results: results.map((result) => ({ imported: result.imported, duplicate: result.duplicate, taskId: result.taskId, issue: result.issue }))
+      });
+    } catch (error) {
+      return safeErrorResult(error);
+    }
+  }
+};
+var linearImportTools = [browseLinearIssuesTool, importLinearIssueTool, importLinearIssuesTool];
+
+// ../../plugins/fusion-plugin-linear-import/src/index.ts
+var dashboardViews = [
+  {
+    viewId: "linear-import",
+    label: "Linear Import",
+    componentPath: "./dashboard-view",
+    icon: "ListPlus",
+    placement: "more",
+    order: 55,
+    description: "Browse Linear issues and import selected issues as Fusion tasks."
+  }
+];
+var plugin = definePlugin({
+  manifest: {
+    id: LINEAR_PLUGIN_ID,
+    name: "Linear Import",
+    version: "0.1.0",
+    description: "Import Linear issues into Fusion tasks through plugin-owned settings, routes, tools, and dashboard view.",
+    author: "Fusion",
+    fusionVersion: ">=0.1.0",
+    settingsSchema: linearSettingsSchema
+  },
+  state: "installed",
+  hooks: {},
+  routes: linearImportRoutes,
+  tools: linearImportTools,
+  dashboardViews
+});
+var index_default = plugin;
+export {
+  LINEAR_GRAPHQL_ENDPOINT,
+  LINEAR_PLUGIN_ID,
+  LinearApiError,
+  LinearClient,
+  buildLinearImportPreview,
+  buildLinearIssueFilter,
+  buildLinearTaskCreateInput,
+  index_default as default,
+  findExistingLinearTask,
+  hasLinearApiKey,
+  importLinearIssue,
+  linearErrorToResponse,
+  linearImportRoutes,
+  linearImportTools,
+  linearSettingsSchema,
+  resolveLinearSettings,
+  taskMatchesLinearIssue
+};