@sideboard-ai/core 0.1.202 → 0.1.204

package/dist/chunk-SGUVAK66.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+import {
+  httpFetch
+} from "./chunk-VKQGAWHY.js";
+import {
+  getAbleTimeHost,
+  isAbleTimeConnected
+} from "./chunk-X743YN5Y.js";
+
+// src/integrations/abletime-mcp.ts
+var DEFAULT_ABLETIME_HOST = "https://track.abletime.com";
+var ABLETIME_MCP_PATH = "/api/public/v2/mcp";
+var ABLETIME_MCP_PM_PATH = "/api/public/v2/mcp/pm";
+var MCP_PROTOCOL_VERSION = "2025-03-26";
+var ABLETIME_PM_TOOL_NAMES = [
+  "set_task_assignee",
+  "set_task_priority",
+  "set_task_stage",
+  "set_task_dependency",
+  "set_task_blocked",
+  "set_task_locked",
+  "set_task_schedule",
+  "clear_task_schedule",
+  "archive_task",
+  "delete_task"
+];
+function abletimeToolUsesPm(name) {
+  return ABLETIME_PM_TOOL_NAMES.includes(name);
+}
+function normalizeAbleTimeHost(raw) {
+  const trimmed = raw?.trim() || DEFAULT_ABLETIME_HOST;
+  const withScheme = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  return withScheme.replace(/\/+$/, "");
+}
+function abletimeMcpUrl(host, opts) {
+  const path = opts?.pm ? ABLETIME_MCP_PM_PATH : ABLETIME_MCP_PATH;
+  return `${normalizeAbleTimeHost(host)}${path}`;
+}
+var ABLETIME_PAT_PREFIX = "apt_";
+var ABLETIME_ORG_KEY_PREFIX = "atk_";
+var ABLETIME_OAUTH_TOKEN_PREFIX = "acn_";
+var ORG_KEY_HINT = "AbleTime MCP needs a personal access token (apt_\u2026) from Edit Profile \u2192 API Access, not an organization API key (atk_\u2026) from Settings \u2192 Integrations \u2192 API Keys.";
+var REJECTED_CREDENTIAL_HINT = "AbleTime rejected this credential (unknown, revoked, or expired). Reconnect via browser, or paste a personal access token (apt_\u2026) from Edit Profile \u2192 API Access. Organization API keys (atk_\u2026) use REST, not MCP.";
+var REWRITE_APPLIED = /— Enable Agent access \(MCP\)|— AbleTime MCP needs a personal access token|— AbleTime plan does not include API access|— AbleTime rejected this credential/;
+function normalizeAbleTimeCredential(raw) {
+  return raw.trim().replace(/^bearer\s+/i, "").trim();
+}
+function ableTimeCredentialKind(raw) {
+  const token = normalizeAbleTimeCredential(raw);
+  const lower = token.toLowerCase();
+  if (lower.startsWith(ABLETIME_PAT_PREFIX)) return "pat";
+  if (lower.startsWith(ABLETIME_ORG_KEY_PREFIX)) return "org";
+  if (lower.startsWith(ABLETIME_OAUTH_TOKEN_PREFIX) || token.startsWith("eyJ")) return "oauth";
+  return "unknown";
+}
+function ableTimeUsesRest(raw) {
+  const token = normalizeAbleTimeCredential(raw);
+  const kind = ableTimeCredentialKind(token);
+  if (kind === "org") return true;
+  if (kind === "oauth") return token.startsWith("eyJ");
+  return kind === "unknown";
+}
+function isAbleTimeRejectedCredential(message) {
+  return /INTEGRATION_KEY_INVALID|INTEGRATION_KEY_MISSING|INTEGRATION_PAT_REQUIRED|\b401\b/i.test(
+    message
+  );
+}
+function assertAbleTimeMcpCredential(raw) {
+  const token = normalizeAbleTimeCredential(raw);
+  if (!token) {
+    throw new Error("AbleTime personal access token is required");
+  }
+  if (ableTimeCredentialKind(token) === "org") {
+    throw new Error(ORG_KEY_HINT);
+  }
+  return token;
+}
+function assertAbleTimeCredential(raw) {
+  const token = normalizeAbleTimeCredential(raw);
+  if (!token) {
+    throw new Error("AbleTime API key or personal access token is required");
+  }
+  return token;
+}
+function rewriteAbleTimeError(message) {
+  if (REWRITE_APPLIED.test(message)) return message;
+  if (/INTEGRATION_AGENT_ACCESS_DISABLED/i.test(message)) {
+    return `${message} \u2014 Enable Agent access (MCP) in AbleTime Settings \u2192 Integrations \u2192 API Keys.`;
+  }
+  if (/INTEGRATION_PAT_REQUIRED/i.test(message)) {
+    return `${message} \u2014 ${ORG_KEY_HINT}`;
+  }
+  if (/INTEGRATION_PLAN_REQUIRED/i.test(message)) {
+    return `${message} \u2014 AbleTime plan does not include API access.`;
+  }
+  if (/INTEGRATION_KEY_INVALID|INTEGRATION_KEY_MISSING|401|unauthorized|invalid token/i.test(message)) {
+    return `${message} \u2014 ${REJECTED_CREDENTIAL_HINT}`;
+  }
+  return message;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function parseSseJson(body) {
+  const blocks = body.split(/\n\n+/);
+  let last;
+  for (const block of blocks) {
+    const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).filter((line) => line && line !== "[DONE]").join("\n");
+    if (!data) continue;
+    try {
+      last = JSON.parse(data);
+    } catch {
+    }
+  }
+  if (last !== void 0) return last;
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new Error(`AbleTime MCP returned a non-JSON response: ${body.slice(0, 200)}`);
+  }
+}
+function unwrapToolResult(result) {
+  const record = asRecord(result);
+  if (!record) return result;
+  const content = record.content;
+  if (Array.isArray(content)) {
+    const texts = content.map((part) => {
+      const item = asRecord(part);
+      if (!item) return "";
+      return typeof item.text === "string" ? item.text : "";
+    }).filter(Boolean);
+    if (texts.length === 1) {
+      const text = texts[0];
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+    if (texts.length > 1) return texts.join("\n");
+  }
+  if (record.structuredContent != null) return record.structuredContent;
+  if (record.isError === true) {
+    const message = typeof record.message === "string" ? record.message : textsFromUnknown(result) || "AbleTime tool failed";
+    throw new Error(message);
+  }
+  return result;
+}
+function textsFromUnknown(value) {
+  const record = asRecord(value);
+  if (!record) return "";
+  if (typeof record.message === "string") return record.message;
+  if (typeof record.error === "string") return record.error;
+  return "";
+}
+async function abletimeMcpRequest(method, params, opts) {
+  const rawToken = opts?.token ?? await import("./abletime-oauth-AVCEO2DY.js").then((m) => m.ensureAbleTimeAccessToken());
+  if (!rawToken?.trim()) {
+    throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
+  }
+  const token = assertAbleTimeMcpCredential(rawToken);
+  const url = abletimeMcpUrl(
+    opts?.host ?? (opts?.token ? DEFAULT_ABLETIME_HOST : getAbleTimeHost()),
+    { pm: opts?.pm }
+  );
+  const res = await httpFetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${token}`,
+      "MCP-Protocol-Version": MCP_PROTOCOL_VERSION
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method,
+      ...params === void 0 ? {} : { params }
+    })
+  });
+  const body = await res.text().catch(() => "");
+  if (!res.ok) {
+    throw new Error(
+      rewriteAbleTimeError(
+        `AbleTime MCP error ${res.status}${body ? `: ${body.slice(0, 240)}` : ""}`
+      )
+    );
+  }
+  const contentType = res.headers.get("content-type") ?? "";
+  const parsed = contentType.includes("text/event-stream") ? parseSseJson(body) : (() => {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return parseSseJson(body);
+    }
+  })();
+  const rpc = asRecord(parsed);
+  if (rpc?.error) {
+    const detail = typeof rpc.error.message === "string" && rpc.error.message.trim() ? rpc.error.message : `AbleTime MCP error ${rpc.error.code ?? ""}`.trim();
+    throw new Error(rewriteAbleTimeError(detail));
+  }
+  if (rpc && "result" in rpc) return rpc.result;
+  return parsed;
+}
+async function initializeIfNeeded(opts) {
+  try {
+    await abletimeMcpRequest(
+      "initialize",
+      {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "sideboard", version: "1.0.0" }
+      },
+      opts
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/already initialized|not (required|supported)|method not found|-32601/i.test(message)) {
+      return;
+    }
+    throw err;
+  }
+}
+async function callAbleTimeTool(name, args = {}, opts) {
+  if (!opts?.token && !isAbleTimeConnected()) {
+    throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
+  }
+  const rawToken = opts?.token ?? await import("./abletime-oauth-AVCEO2DY.js").then((m) => m.ensureAbleTimeAccessToken());
+  if (rawToken && ableTimeUsesRest(rawToken)) {
+    const { callAbleTimeRestTool } = await import("./abletime-rest-6ODSXV7G.js");
+    return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
+  }
+  const requestOpts = { ...opts, pm: opts?.pm ?? abletimeToolUsesPm(name) };
+  const call = () => abletimeMcpRequest("tools/call", { name, arguments: args }, requestOpts).then((result) => {
+    return unwrapToolResult(result);
+  });
+  try {
+    return await call();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/initialize|session|not initialized|-32000/i.test(message)) {
+      await initializeIfNeeded(requestOpts);
+      return await call();
+    }
+    if (rawToken && ableTimeUsesRest(rawToken) && isAbleTimeRejectedCredential(message)) {
+      const { callAbleTimeRestTool } = await import("./abletime-rest-6ODSXV7G.js");
+      return callAbleTimeRestTool(name, args, { ...opts, token: rawToken });
+    }
+    throw err instanceof Error ? new Error(rewriteAbleTimeError(err.message)) : err;
+  }
+}
+
+export {
+  DEFAULT_ABLETIME_HOST,
+  normalizeAbleTimeHost,
+  normalizeAbleTimeCredential,
+  ableTimeCredentialKind,
+  assertAbleTimeCredential,
+  rewriteAbleTimeError,
+  callAbleTimeTool
+};