@hachej/boring-tasks 0.1.79

package/dist/server/index.d.ts

@@ -0,0 +1,161 @@
+import { WorkspaceServerPlugin } from '@hachej/boring-workspace/server';
+import { BoringTaskAdapterSummary, BoringTaskBoardConfig, BoringTaskCard, BoringTaskMoveInput, BoringTaskDeleteInput } from '../shared/index.js';
+
+interface BoringTaskSourceContext {
+    workspaceId?: string;
+    workspaceRoot?: string;
+}
+type BoringTaskSourceSummary = BoringTaskAdapterSummary;
+interface BoringTaskSourceRuntime {
+    summary(): BoringTaskSourceSummary;
+    getBoardConfig(ctx: BoringTaskSourceContext): Promise<BoringTaskBoardConfig> | BoringTaskBoardConfig;
+    listTasks(ctx: BoringTaskSourceContext): Promise<BoringTaskCard[]> | BoringTaskCard[];
+    moveTask?(ctx: BoringTaskSourceContext, input: BoringTaskMoveInput): Promise<BoringTaskCard> | BoringTaskCard;
+    deleteTask?(ctx: BoringTaskSourceContext, input: BoringTaskDeleteInput): Promise<void> | void;
+}
+interface BoringTaskSourceRegistry {
+    listSources(): BoringTaskSourceRuntime[];
+    getSource(sourceId: string): BoringTaskSourceRuntime | undefined;
+}
+declare function createTaskSourceRegistry(sources: readonly BoringTaskSourceRuntime[]): BoringTaskSourceRegistry;
+
+interface GitHubLabel {
+    name?: string;
+}
+interface GitHubMilestone {
+    id?: number;
+    number?: number;
+    title?: string;
+    url?: string;
+}
+interface GitHubIssue {
+    number: number;
+    title: string;
+    body?: string | null;
+    url?: string;
+    state: "OPEN" | "CLOSED" | "open" | "closed";
+    labels?: GitHubLabel[];
+    milestone?: GitHubMilestone | null;
+}
+interface GitHubPullRequest {
+    number: number;
+    title: string;
+    body?: string | null;
+    url?: string;
+    state?: string;
+}
+interface GitHubIssueExecutor {
+    listIssues(input: {
+        owner: string;
+        repo: string;
+        limit: number;
+        state: "open" | "closed" | "all";
+    }): Promise<GitHubIssue[]>;
+    listPullRequests?(input: {
+        owner: string;
+        repo: string;
+        limit: number;
+        state: "open" | "closed" | "all";
+    }): Promise<GitHubPullRequest[]>;
+    viewIssue(input: {
+        owner: string;
+        repo: string;
+        issueNumber: number;
+    }): Promise<GitHubIssue>;
+    addLabels(input: {
+        owner: string;
+        repo: string;
+        issueNumber: number;
+        labels: string[];
+    }): Promise<void>;
+    removeLabels(input: {
+        owner: string;
+        repo: string;
+        issueNumber: number;
+        labels: string[];
+    }): Promise<void>;
+    closeIssue(input: {
+        owner: string;
+        repo: string;
+        issueNumber: number;
+    }): Promise<void>;
+    reopenIssue(input: {
+        owner: string;
+        repo: string;
+        issueNumber: number;
+    }): Promise<void>;
+}
+interface GitHubRepositoryDetector {
+    detectRepository(input: {
+        workspaceRoot: string;
+    }): Promise<{
+        owner: string;
+        repo: string;
+    }>;
+}
+interface GitHubTaskSourceOptions {
+    owner: string;
+    repo: string;
+    limit?: number;
+    state?: "open" | "closed" | "all";
+    executor?: GitHubIssueExecutor;
+}
+interface WorkspaceGitHubTaskSourceOptions {
+    workspaceRoot?: string;
+    sourceId?: string;
+    limit?: number;
+    state?: "open" | "closed" | "all";
+    detector?: GitHubRepositoryDetector;
+    executorFactory?: (input: {
+        workspaceRoot: string;
+        owner: string;
+        repo: string;
+    }) => GitHubIssueExecutor;
+}
+declare function createGhCliGitHubIssueExecutor(options?: {
+    workspaceRoot?: string;
+}): GitHubIssueExecutor;
+declare function createGhCliGitHubRepositoryDetector(): GitHubRepositoryDetector;
+declare function createGitHubTaskSource({ owner, repo, limit, state, executor }: GitHubTaskSourceOptions): BoringTaskSourceRuntime;
+declare function createWorkspaceGitHubTaskSource({ workspaceRoot, sourceId, limit, state, detector, executorFactory, }?: WorkspaceGitHubTaskSourceOptions): BoringTaskSourceRuntime;
+
+declare class TaskSourceServiceError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+interface TaskListInput {
+    sourceIds?: string[];
+}
+interface TaskListOutput {
+    configs: Record<string, BoringTaskBoardConfig>;
+    tasks: BoringTaskCard[];
+}
+interface TaskMoveInput extends BoringTaskMoveInput {
+    sourceId: string;
+}
+interface TaskDeleteInput {
+    sourceId: string;
+    taskId: string;
+}
+declare function createTaskSourceService(registry: BoringTaskSourceRegistry): {
+    listSources(): BoringTaskSourceSummary[];
+    listTasks(ctx: BoringTaskSourceContext, input?: TaskListInput): Promise<TaskListOutput>;
+    moveTask(ctx: BoringTaskSourceContext, input: TaskMoveInput): Promise<BoringTaskCard>;
+    deleteTask(ctx: BoringTaskSourceContext, input: TaskDeleteInput): Promise<void>;
+};
+
+interface TasksServerPluginOptions {
+    config?: unknown;
+    sources?: BoringTaskSourceRuntime[];
+    workspaceRoot?: string;
+}
+declare function createTaskSourceRegistryFromConfig(config: unknown, options?: {
+    workspaceRoot?: string;
+}): BoringTaskSourceRegistry;
+declare function createTasksServerPlugin(options?: TasksServerPluginOptions): WorkspaceServerPlugin;
+declare function defaultTasksServerPlugin(options?: TasksServerPluginOptions, ctx?: {
+    workspaceRoot?: string;
+}): WorkspaceServerPlugin;
+
+export { TaskSourceServiceError, type TasksServerPluginOptions, createGhCliGitHubIssueExecutor, createGhCliGitHubRepositoryDetector, createGitHubTaskSource, createTaskSourceRegistry, createTaskSourceRegistryFromConfig, createTaskSourceService, createTasksServerPlugin, createWorkspaceGitHubTaskSource, defaultTasksServerPlugin as default };

package/dist/server/index.js

@@ -0,0 +1,469 @@
+// src/server/index.ts
+import { defineServerPlugin } from "@hachej/boring-workspace/server";
+
+// src/shared/index.ts
+var TASKS_PLUGIN_ID = "tasks";
+var TASKS_PLUGIN_LABEL = "Tasks";
+
+// src/server/githubSource.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/server/taskSourceService.ts
+var TaskSourceServiceError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "TaskSourceServiceError";
+  }
+  status;
+  code;
+};
+function createTaskSourceService(registry) {
+  return {
+    listSources() {
+      return registry.listSources().map((source) => source.summary());
+    },
+    async listTasks(ctx, input = {}) {
+      const selected = input.sourceIds?.length ? input.sourceIds.map((sourceId) => {
+        const source = registry.getSource(sourceId);
+        if (!source) throw new TaskSourceServiceError(404, "TASK_SOURCE_NOT_FOUND", `Task source not found: ${sourceId}`);
+        return source;
+      }) : registry.listSources();
+      const entries = await Promise.all(selected.map(async (source) => {
+        const summary = source.summary();
+        const [config, tasks] = await Promise.all([source.getBoardConfig(ctx), source.listTasks(ctx)]);
+        return { sourceId: summary.id, config, tasks };
+      }));
+      return {
+        configs: Object.fromEntries(entries.map((entry) => [entry.sourceId, entry.config])),
+        tasks: entries.flatMap((entry) => entry.tasks)
+      };
+    },
+    async moveTask(ctx, input) {
+      const source = registry.getSource(input.sourceId);
+      if (!source) throw new TaskSourceServiceError(404, "TASK_SOURCE_NOT_FOUND", `Task source not found: ${input.sourceId}`);
+      if (!source.summary().capabilities.move || !source.moveTask) {
+        throw new TaskSourceServiceError(409, "TASK_SOURCE_MOVE_UNSUPPORTED", `Task source does not support moves: ${input.sourceId}`);
+      }
+      return await source.moveTask(ctx, { taskId: input.taskId, statusId: input.statusId });
+    },
+    async deleteTask(ctx, input) {
+      const source = registry.getSource(input.sourceId);
+      if (!source) throw new TaskSourceServiceError(404, "TASK_SOURCE_NOT_FOUND", `Task source not found: ${input.sourceId}`);
+      if (!source.summary().capabilities.delete || !source.deleteTask) {
+        throw new TaskSourceServiceError(409, "TASK_SOURCE_DELETE_UNSUPPORTED", `Task source does not support issue deletion: ${input.sourceId}`);
+      }
+      await source.deleteTask(ctx, { taskId: input.taskId });
+    }
+  };
+}
+
+// src/server/githubSource.ts
+var execFileAsync = promisify(execFile);
+var GITHUB_COLUMNS = [
+  { id: "needs-triage", title: "Needs triage", description: "Fresh issues that need a first pass", color: "#8b5cf6" },
+  { id: "needs-info", title: "Needs info", description: "Blocked on clarification or missing context", color: "#ef4444" },
+  { id: "ready-for-agent", title: "Ready for agent", description: "Clear agent-pickable work", color: "#0ea5e9" },
+  { id: "ready-for-human", title: "Ready for human", description: "Waiting for owner review or human decision", color: "#f59e0b" },
+  { id: "done", title: "Done", description: "Closed GitHub issues", color: "#64748b" }
+];
+var WORKFLOW_LABELS = ["needs-triage", "needs-info", "ready-for-agent", "ready-for-human", "done"];
+var STATUS_MAPPINGS = {
+  "needs-triage": { removeStateLabels: true, addLabels: ["needs-triage"], reopen: true },
+  "needs-info": { removeStateLabels: true, addLabels: ["needs-info"], reopen: true },
+  "ready-for-agent": { removeStateLabels: true, addLabels: ["ready-for-agent"], reopen: true },
+  "ready-for-human": { removeStateLabels: true, addLabels: ["ready-for-human"], reopen: true },
+  done: { removeStateLabels: true, addLabels: ["done"], close: true }
+};
+function defaultWorkspaceRoot() {
+  return process.env.BORING_AGENT_WORKSPACE_ROOT || process.cwd();
+}
+async function runGhJson(args, cwd = defaultWorkspaceRoot()) {
+  try {
+    const { stdout } = await execFileAsync("gh", args, {
+      cwd,
+      env: { ...process.env, GH_PROMPT_DISABLED: "1" },
+      maxBuffer: 1024 * 1024 * 8,
+      timeout: 3e4
+    });
+    return JSON.parse(stdout);
+  } catch {
+    throw new TaskSourceServiceError(500, "TASK_GITHUB_COMMAND_FAILED", "GitHub command failed; check server authentication and repository access.");
+  }
+}
+async function runGh(args, cwd = defaultWorkspaceRoot()) {
+  try {
+    await execFileAsync("gh", args, {
+      cwd,
+      env: { ...process.env, GH_PROMPT_DISABLED: "1" },
+      maxBuffer: 1024 * 1024,
+      timeout: 3e4
+    });
+  } catch {
+    throw new TaskSourceServiceError(500, "TASK_GITHUB_COMMAND_FAILED", "GitHub command failed; check server authentication and repository access.");
+  }
+}
+function createGhCliGitHubIssueExecutor(options = {}) {
+  const repoArg = (owner, repo) => `${owner}/${repo}`;
+  const jsonFields = "number,title,body,url,state,labels,milestone";
+  const cwd = options.workspaceRoot;
+  return {
+    listIssues: ({ owner, repo, limit, state }) => runGhJson([
+      "issue",
+      "list",
+      "--repo",
+      repoArg(owner, repo),
+      "--state",
+      state,
+      "--limit",
+      String(limit),
+      "--json",
+      jsonFields
+    ], cwd),
+    listPullRequests: ({ owner, repo, limit, state }) => runGhJson([
+      "pr",
+      "list",
+      "--repo",
+      repoArg(owner, repo),
+      "--state",
+      state,
+      "--limit",
+      String(limit),
+      "--json",
+      "number,title,body,url,state"
+    ], cwd),
+    viewIssue: ({ owner, repo, issueNumber }) => runGhJson([
+      "issue",
+      "view",
+      String(issueNumber),
+      "--repo",
+      repoArg(owner, repo),
+      "--json",
+      jsonFields
+    ], cwd),
+    addLabels: async ({ owner, repo, issueNumber, labels }) => {
+      if (labels.length === 0) return;
+      await runGh(["issue", "edit", String(issueNumber), "--repo", repoArg(owner, repo), "--add-label", labels.join(",")], cwd);
+    },
+    removeLabels: async ({ owner, repo, issueNumber, labels }) => {
+      if (labels.length === 0) return;
+      await runGh(["issue", "edit", String(issueNumber), "--repo", repoArg(owner, repo), "--remove-label", labels.join(",")], cwd);
+    },
+    closeIssue: ({ owner, repo, issueNumber }) => runGh(["issue", "close", String(issueNumber), "--repo", repoArg(owner, repo)], cwd),
+    reopenIssue: ({ owner, repo, issueNumber }) => runGh(["issue", "reopen", String(issueNumber), "--repo", repoArg(owner, repo)], cwd)
+  };
+}
+function createGhCliGitHubRepositoryDetector() {
+  return {
+    async detectRepository({ workspaceRoot }) {
+      const payload = await runGhJson(["repo", "view", "--json", "nameWithOwner"], workspaceRoot);
+      const [owner, repo] = payload.nameWithOwner?.split("/") ?? [];
+      if (!owner || !repo) {
+        throw new TaskSourceServiceError(404, "TASK_GITHUB_REPO_NOT_FOUND", "No GitHub repository is associated with this workspace.");
+      }
+      return { owner, repo };
+    }
+  };
+}
+function issueLabels(issue) {
+  return (issue.labels ?? []).map((label) => label.name?.trim()).filter((label) => Boolean(label));
+}
+function issueStatus(issue) {
+  if (issue.state.toLowerCase() === "closed") return "done";
+  const labels = issueLabels(issue).map((label) => label.toLowerCase());
+  return WORKFLOW_LABELS.find((label) => labels.includes(label)) ?? "needs-triage";
+}
+function descriptionFromBody(body) {
+  if (!body) return void 0;
+  const compact = body.replace(/```[\s\S]*?```/g, " ").replace(/`([^`]+)`/g, "$1").replace(/[#>*_\-[\]()]/g, " ").replace(/\s+/g, " ").trim();
+  return compact.length > 180 ? `${compact.slice(0, 177)}\u2026` : compact || void 0;
+}
+function associatedPullRequests(issue, pullRequests) {
+  const issueRef = `#${issue.number}`;
+  const issueUrl = issue.url?.toLowerCase();
+  return pullRequests.filter((pr) => {
+    const haystack = `${pr.title}
+${pr.body ?? ""}
+${pr.url ?? ""}`.toLowerCase();
+    return haystack.includes(issueRef.toLowerCase()) || Boolean(issueUrl && haystack.includes(issueUrl));
+  });
+}
+function taskFromIssue(issue, adapterId, pullRequests = []) {
+  const prs = associatedPullRequests(issue, pullRequests);
+  return {
+    id: String(issue.number),
+    number: `#${issue.number}`,
+    title: issue.title,
+    description: descriptionFromBody(issue.body),
+    statusId: issueStatus(issue),
+    tags: issueLabels(issue).filter((label) => !WORKFLOW_LABELS.includes(label.toLowerCase())),
+    epic: issue.milestone?.title ? {
+      id: String(issue.milestone.id ?? issue.milestone.number ?? issue.milestone.title),
+      title: issue.milestone.title,
+      url: issue.milestone.url
+    } : void 0,
+    adapterId,
+    pullRequests: prs.map((pr) => ({
+      id: String(pr.number),
+      number: `#${pr.number}`,
+      title: pr.title,
+      url: pr.url,
+      state: pr.state
+    })),
+    url: issue.url
+  };
+}
+function createGitHubTaskSource({ owner, repo, limit = 200, state = "open", executor = createGhCliGitHubIssueExecutor() }) {
+  const sourceId = `github:${owner}/${repo}`;
+  const board = {
+    adapterId: sourceId,
+    defaultColumnId: "needs-triage",
+    columns: GITHUB_COLUMNS
+  };
+  return {
+    summary: () => ({
+      id: sourceId,
+      label: `GitHub ${owner}/${repo}`,
+      description: "GitHub Issues via backend task source",
+      capabilities: { move: true, delete: true }
+    }),
+    getBoardConfig: () => board,
+    async listTasks(_ctx) {
+      const [issues, pullRequests] = await Promise.all([
+        executor.listIssues({ owner, repo, limit, state }),
+        executor.listPullRequests?.({ owner, repo, limit: 100, state: "open" }) ?? Promise.resolve([])
+      ]);
+      return issues.map((issue) => taskFromIssue(issue, sourceId, pullRequests));
+    },
+    async moveTask(_ctx, { taskId, statusId }) {
+      const issueNumber = Number(taskId);
+      if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
+        throw new TaskSourceServiceError(400, "TASK_INVALID_ID", `Invalid GitHub issue task id: ${taskId}`);
+      }
+      const mapping = STATUS_MAPPINGS[statusId];
+      if (!mapping) throw new TaskSourceServiceError(400, "TASK_STATUS_NOT_FOUND", `Unknown GitHub task status: ${statusId}`);
+      const before = await executor.viewIssue({ owner, repo, issueNumber });
+      if (mapping.close) await executor.closeIssue({ owner, repo, issueNumber });
+      if (mapping.reopen && before.state.toLowerCase() === "closed") await executor.reopenIssue({ owner, repo, issueNumber });
+      if (mapping.removeStateLabels) {
+        const stateLabels = issueLabels(before).filter((label) => WORKFLOW_LABELS.includes(label.toLowerCase()));
+        await executor.removeLabels({ owner, repo, issueNumber, labels: stateLabels });
+      }
+      await executor.addLabels({ owner, repo, issueNumber, labels: mapping.addLabels ?? [] });
+      const after = await executor.viewIssue({ owner, repo, issueNumber });
+      return taskFromIssue(after, sourceId);
+    },
+    async deleteTask(_ctx, { taskId }) {
+      const issueNumber = Number(taskId);
+      if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
+        throw new TaskSourceServiceError(400, "TASK_INVALID_ID", `Invalid GitHub issue task id: ${taskId}`);
+      }
+      await executor.closeIssue({ owner, repo, issueNumber });
+    }
+  };
+}
+function createWorkspaceGitHubTaskSource({
+  workspaceRoot,
+  sourceId = "github:workspace",
+  limit = 200,
+  state = "open",
+  detector = createGhCliGitHubRepositoryDetector(),
+  executorFactory = ({ workspaceRoot: workspaceRoot2 }) => createGhCliGitHubIssueExecutor({ workspaceRoot: workspaceRoot2 })
+} = {}) {
+  const board = {
+    adapterId: sourceId,
+    defaultColumnId: "needs-triage",
+    columns: GITHUB_COLUMNS
+  };
+  const resolveWorkspaceRoot = (ctx) => ctx.workspaceRoot ?? workspaceRoot ?? defaultWorkspaceRoot();
+  const resolveRepo = async (ctx) => {
+    const root = resolveWorkspaceRoot(ctx);
+    const repoInfo = await detector.detectRepository({ workspaceRoot: root });
+    return { ...repoInfo, workspaceRoot: root };
+  };
+  return {
+    summary: () => ({
+      id: sourceId,
+      label: "GitHub repository",
+      description: "GitHub Issues from the current workspace repository via gh CLI",
+      capabilities: { move: true, delete: true }
+    }),
+    getBoardConfig: () => board,
+    async listTasks(ctx) {
+      const repoInfo = await resolveRepo(ctx);
+      const executor = executorFactory(repoInfo);
+      const [issues, pullRequests] = await Promise.all([
+        executor.listIssues({ owner: repoInfo.owner, repo: repoInfo.repo, limit, state }),
+        executor.listPullRequests?.({ owner: repoInfo.owner, repo: repoInfo.repo, limit: 100, state: "open" }) ?? Promise.resolve([])
+      ]);
+      return issues.map((issue) => taskFromIssue(issue, sourceId, pullRequests));
+    },
+    async moveTask(ctx, { taskId, statusId }) {
+      const issueNumber = Number(taskId);
+      if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
+        throw new TaskSourceServiceError(400, "TASK_INVALID_ID", `Invalid GitHub issue task id: ${taskId}`);
+      }
+      const mapping = STATUS_MAPPINGS[statusId];
+      if (!mapping) throw new TaskSourceServiceError(400, "TASK_STATUS_NOT_FOUND", `Unknown GitHub task status: ${statusId}`);
+      const repoInfo = await resolveRepo(ctx);
+      const executor = executorFactory(repoInfo);
+      const input = { owner: repoInfo.owner, repo: repoInfo.repo, issueNumber };
+      const before = await executor.viewIssue(input);
+      if (mapping.close) await executor.closeIssue(input);
+      if (mapping.reopen && before.state.toLowerCase() === "closed") await executor.reopenIssue(input);
+      if (mapping.removeStateLabels) {
+        const stateLabels = issueLabels(before).filter((label) => WORKFLOW_LABELS.includes(label.toLowerCase()));
+        await executor.removeLabels({ ...input, labels: stateLabels });
+      }
+      await executor.addLabels({ ...input, labels: mapping.addLabels ?? [] });
+      const after = await executor.viewIssue(input);
+      return taskFromIssue(after, sourceId);
+    },
+    async deleteTask(ctx, { taskId }) {
+      const issueNumber = Number(taskId);
+      if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
+        throw new TaskSourceServiceError(400, "TASK_INVALID_ID", `Invalid GitHub issue task id: ${taskId}`);
+      }
+      const repoInfo = await resolveRepo(ctx);
+      const executor = executorFactory(repoInfo);
+      await executor.closeIssue({ owner: repoInfo.owner, repo: repoInfo.repo, issueNumber });
+    }
+  };
+}
+
+// src/server/sourceRuntime.ts
+function createTaskSourceRegistry(sources) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const id = source.summary().id;
+    if (byId.has(id)) throw new Error(`Duplicate task source id: ${id}`);
+    byId.set(id, source);
+  }
+  return {
+    listSources: () => [...sources],
+    getSource: (sourceId) => byId.get(sourceId)
+  };
+}
+
+// src/server/index.ts
+function workspaceIdFromRequest(request) {
+  const header = request.headers["x-boring-workspace-id"];
+  if (typeof header === "string" && header.length > 0) return header;
+  const query = request.query;
+  return typeof query?.workspaceId === "string" && query.workspaceId.length > 0 ? query.workspaceId : void 0;
+}
+function responseError(cause) {
+  if (cause instanceof TaskSourceServiceError) {
+    return { ok: false, code: cause.code, error: cause.message };
+  }
+  return { ok: false, code: "TASK_SOURCE_ERROR", error: "Task source request failed." };
+}
+function statusFor(cause) {
+  return cause instanceof TaskSourceServiceError ? cause.status : 500;
+}
+function stringArray(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    throw new TaskSourceServiceError(400, "TASK_INVALID_BODY", "sourceIds must be an array of non-empty strings");
+  }
+  return value;
+}
+function requiredString(body, key) {
+  const value = body[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TaskSourceServiceError(400, "TASK_INVALID_BODY", `${key} must be a non-empty string`);
+  }
+  return value;
+}
+function bodyObject(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw new TaskSourceServiceError(400, "TASK_INVALID_BODY", "request body must be an object");
+  }
+  return body;
+}
+function taskProvidersFromConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) return [];
+  const providers = config.providers;
+  return Array.isArray(providers) ? providers.filter((provider) => Boolean(provider) && typeof provider === "object" && !Array.isArray(provider)) : [];
+}
+function createTaskSourceRegistryFromConfig(config, options = {}) {
+  const sources = taskProvidersFromConfig(config).flatMap((provider, index) => {
+    if (provider.provider !== "github") return [];
+    const repo = typeof provider.repo === "string" ? provider.repo.trim() : "";
+    if (repo && repo !== "auto") {
+      const [owner, name] = repo.split("/");
+      if (!owner || !name) return [];
+      return [createGitHubTaskSource({
+        owner,
+        repo: name,
+        executor: createGhCliGitHubIssueExecutor({ workspaceRoot: options.workspaceRoot })
+      })];
+    }
+    return [createWorkspaceGitHubTaskSource({
+      workspaceRoot: options.workspaceRoot,
+      sourceId: index === 0 ? "github:workspace" : `github:workspace:${index + 1}`
+    })];
+  });
+  return createTaskSourceRegistry(sources);
+}
+function createTasksServerPlugin(options = {}) {
+  const registry = options.sources ? createTaskSourceRegistry(options.sources) : createTaskSourceRegistryFromConfig(options.config, { workspaceRoot: options.workspaceRoot });
+  const service = createTaskSourceService(registry);
+  return defineServerPlugin({
+    id: TASKS_PLUGIN_ID,
+    label: TASKS_PLUGIN_LABEL,
+    routes: async (app) => {
+      app.get("/api/boring-tasks/sources", async () => ({ ok: true, sources: service.listSources() }));
+      app.post("/api/boring-tasks/sources/tasks/list", async (request, reply) => {
+        try {
+          const body = request.body === void 0 ? {} : bodyObject(request.body);
+          return { ok: true, ...await service.listTasks({ workspaceId: workspaceIdFromRequest(request), workspaceRoot: options.workspaceRoot }, { sourceIds: stringArray(body.sourceIds) }) };
+        } catch (cause) {
+          return reply.status(statusFor(cause)).send(responseError(cause));
+        }
+      });
+      app.post("/api/boring-tasks/sources/tasks/move", async (request, reply) => {
+        try {
+          const body = bodyObject(request.body);
+          const task = await service.moveTask({ workspaceId: workspaceIdFromRequest(request), workspaceRoot: options.workspaceRoot }, {
+            sourceId: requiredString(body, "sourceId"),
+            taskId: requiredString(body, "taskId"),
+            statusId: requiredString(body, "statusId")
+          });
+          return { ok: true, task };
+        } catch (cause) {
+          return reply.status(statusFor(cause)).send(responseError(cause));
+        }
+      });
+      app.post("/api/boring-tasks/sources/tasks/delete", async (request, reply) => {
+        try {
+          const body = bodyObject(request.body);
+          await service.deleteTask({ workspaceId: workspaceIdFromRequest(request), workspaceRoot: options.workspaceRoot }, {
+            sourceId: requiredString(body, "sourceId"),
+            taskId: requiredString(body, "taskId")
+          });
+          return { ok: true };
+        } catch (cause) {
+          return reply.status(statusFor(cause)).send(responseError(cause));
+        }
+      });
+    }
+  });
+}
+function defaultTasksServerPlugin(options, ctx) {
+  return createTasksServerPlugin({ ...options, workspaceRoot: options?.workspaceRoot ?? ctx?.workspaceRoot });
+}
+export {
+  TaskSourceServiceError,
+  createGhCliGitHubIssueExecutor,
+  createGhCliGitHubRepositoryDetector,
+  createGitHubTaskSource,
+  createTaskSourceRegistry,
+  createTaskSourceRegistryFromConfig,
+  createTaskSourceService,
+  createTasksServerPlugin,
+  createWorkspaceGitHubTaskSource,
+  defaultTasksServerPlugin as default
+};