@sideboard-ai/core 0.1.201 → 0.1.203

package/dist/chunk-3PYH2RLA.js

@@ -0,0 +1,388 @@
+import {
+  DEFAULT_ABLETIME_HOST,
+  ableTimeCredentialKind,
+  normalizeAbleTimeCredential,
+  normalizeAbleTimeHost,
+  rewriteAbleTimeError
+} from "./chunk-BFEBFGCS.js";
+import {
+  httpFetch
+} from "./chunk-N7WZ6NIN.js";
+import {
+  getAbleTimeAccessToken,
+  getAbleTimeHost
+} from "./chunk-QFBBUFD4.js";
+
+// src/integrations/abletime-rest.ts
+var ABLETIME_REST_PREFIX = "/api/public/v2";
+var ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function asList(value) {
+  if (Array.isArray(value)) return value;
+  const record = asRecord(value);
+  if (!record) return [];
+  for (const key of ["data", "tasks", "projects", "users", "items", "results"]) {
+    if (Array.isArray(record[key])) return record[key];
+  }
+  return [];
+}
+function ableTimeDocFromText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return { type: "doc", content: [] };
+  return {
+    type: "doc",
+    content: [{ type: "paragraph", content: [{ type: "text", text: trimmed }] }]
+  };
+}
+function textFromAbleTimeDoc(value) {
+  if (typeof value === "string") return value.trim();
+  const record = asRecord(value);
+  if (!record) return "";
+  if (typeof record.text === "string" && record.text.trim()) return record.text.trim();
+  const chunks = [];
+  const walk = (node) => {
+    const rec = asRecord(node);
+    if (!rec) return;
+    if (typeof rec.text === "string" && rec.text) chunks.push(rec.text);
+    if (Array.isArray(rec.content)) rec.content.forEach(walk);
+  };
+  walk(record);
+  return chunks.join("").trim();
+}
+function abletimeRestUrl(path, host, query) {
+  const base = `${normalizeAbleTimeHost(host)}${ABLETIME_REST_PREFIX}`;
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${base}${suffix}`);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value) url.searchParams.set(key, value);
+  }
+  return url.href;
+}
+function looksLikeAbleTimeUlid(id) {
+  return ULID_RE.test(id.trim());
+}
+async function abletimeRestRequest(path, opts = {}) {
+  const raw = opts.token ?? getAbleTimeAccessToken();
+  const token = normalizeAbleTimeCredential(raw ?? "");
+  if (!token) {
+    throw new Error("AbleTime is not connected \u2014 paste an API key or personal access token in Account settings");
+  }
+  const host = opts.host ?? (opts.token ? DEFAULT_ABLETIME_HOST : getAbleTimeHost());
+  const url = abletimeRestUrl(path, host, opts.query);
+  const method = (opts.method ?? "GET").toUpperCase();
+  const res = await httpFetch(url, {
+    method,
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+      ...opts.body !== void 0 ? { "Content-Type": "application/json" } : {}
+    },
+    ...opts.body !== void 0 ? { body: JSON.stringify(opts.body) } : {}
+  });
+  const text = await res.text().catch(() => "");
+  if (!res.ok) {
+    throw new Error(
+      rewriteAbleTimeError(
+        `AbleTime API error ${res.status}${text ? `: ${text.slice(0, 240)}` : ""}`
+      )
+    );
+  }
+  if (!text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`AbleTime API returned a non-JSON response: ${text.slice(0, 200)}`);
+  }
+}
+async function restPages(path, opts, maxPages = 20) {
+  const items = [];
+  let cursor;
+  for (let i = 0; i < maxPages; i += 1) {
+    const raw = await abletimeRestRequest(path, {
+      ...opts,
+      query: { ...opts.query, ...cursor ? { cursor } : {} }
+    });
+    items.push(...asList(raw));
+    const page = asRecord(asRecord(raw)?.page);
+    const next = page ? asString(page.nextCursor) : "";
+    if (!next) break;
+    cursor = next;
+  }
+  return items;
+}
+function userDisplayName(raw) {
+  const rec = asRecord(raw);
+  if (!rec) return null;
+  const id = asString(rec.userId) || asString(rec.id);
+  const name = [asString(rec.firstName), asString(rec.lastName)].filter(Boolean).join(" ") || asString(rec.username) || asString(rec.email) || asString(rec.name);
+  if (!name) return null;
+  return { id: id || void 0, name };
+}
+function restTaskToRaw(raw, users) {
+  const rec = asRecord(raw);
+  if (!rec) return null;
+  const id = asString(rec.timeflowTaskId) || asString(rec.taskId) || asString(rec.id);
+  const identifier = asString(rec.taskRef) || asString(rec.reference) || id;
+  const title = asString(rec.title);
+  if (!id && !identifier && !title) return null;
+  const assigned = asString(rec.assignedUserId);
+  const assignee = assigned ? users.get(assigned) : void 0;
+  const comments = asList(rec.comments).map((item) => {
+    const comment = asRecord(item) ?? {};
+    const user = userDisplayName(comment);
+    return {
+      id: asString(comment.commentId) || asString(comment.id),
+      body: textFromAbleTimeDoc(comment.content) || asString(comment.contentSanitized) || asString(comment.body),
+      createdAt: asString(comment.createdAt) || asString(comment.lastUpdate),
+      user: user?.name || asString(comment.username)
+    };
+  });
+  return {
+    id,
+    taskId: id,
+    timeflowTaskId: id,
+    reference: identifier,
+    taskRef: identifier,
+    title: title || identifier,
+    state: asString(rec.taskState) || asString(rec.state),
+    description: textFromAbleTimeDoc(rec.description) || asString(rec.descriptionSanitized),
+    projectId: asString(rec.projectId),
+    categoryId: asString(rec.projectCategoryId) || asString(rec.categoryId),
+    tags: rec.tags,
+    comments,
+    createdAt: asString(rec.dateCreated) || asString(rec.createdAt),
+    updatedAt: asString(rec.lastUpdate) || asString(rec.updatedAt),
+    ...assignee ? { assignee } : {}
+  };
+}
+function restProjectToRaw(raw) {
+  const rec = asRecord(raw);
+  if (!rec) return null;
+  const id = asString(rec.projectId) || asString(rec.id);
+  const name = asString(rec.projectName) || asString(rec.name);
+  if (!id && !name) return null;
+  const categories = asList(rec.categories).map((item) => {
+    const cat = asRecord(item) ?? {};
+    return {
+      id: asString(cat.projectCategoryId) || asString(cat.categoryId) || asString(cat.id),
+      name: asString(cat.categoryName) || asString(cat.name)
+    };
+  });
+  return { id, name, projectId: id, projectName: name, categories };
+}
+async function listUsers(opts) {
+  const users = /* @__PURE__ */ new Map();
+  for (const item of await restPages("/users", opts).catch(() => [])) {
+    const user = userDisplayName(item);
+    const rec = asRecord(item);
+    const id = user?.id || (rec ? asString(rec.userId) : "");
+    if (user && id) users.set(id, user);
+  }
+  return users;
+}
+async function listProjectsRaw(opts) {
+  const items = await restPages("/projects", { ...opts, query: { expand: "categories" } });
+  return items.map(restProjectToRaw).filter((item) => Boolean(item));
+}
+async function listTasksRaw(opts) {
+  const [users, items] = await Promise.all([
+    listUsers(opts),
+    restPages("/tasks", {
+      ...opts,
+      query: {
+        ...opts.projectId ? { projectId: opts.projectId } : {}
+      }
+    })
+  ]);
+  let tasks = items.map((item) => restTaskToRaw(item, users)).filter((item) => Boolean(item));
+  const needle = opts.query?.trim().toLowerCase();
+  if (needle) {
+    tasks = tasks.filter((task) => {
+      const hay = [task.title, task.reference, task.taskRef, task.id].map((value) => String(value ?? "").toLowerCase()).join(" ");
+      const tags = Array.isArray(task.tags) ? task.tags.join(" ").toLowerCase() : "";
+      return hay.includes(needle) || tags.includes(needle);
+    });
+  }
+  return tasks;
+}
+async function resolveTaskId(id, opts) {
+  const wanted = id.trim();
+  if (!wanted) throw new Error("AbleTime task id is required");
+  if (looksLikeAbleTimeUlid(wanted)) return wanted;
+  const tasks = await listTasksRaw(opts);
+  const match = tasks.find((task) => {
+    const ref = String(task.reference ?? task.taskRef ?? "").toLowerCase();
+    const taskId = String(task.id ?? "").toLowerCase();
+    return ref === wanted.toLowerCase() || taskId === wanted.toLowerCase();
+  });
+  if (!match?.id) throw new Error(`AbleTime task not found: ${id}`);
+  return String(match.id);
+}
+async function getTaskRaw(id, opts) {
+  const taskId = await resolveTaskId(id, opts);
+  const [users, raw] = await Promise.all([
+    listUsers(opts),
+    abletimeRestRequest(`/tasks/${encodeURIComponent(taskId)}`, {
+      ...opts,
+      query: { expand: "comments" }
+    })
+  ]);
+  const task = restTaskToRaw(raw, users);
+  if (!task) throw new Error(`AbleTime task not found: ${id}`);
+  return task;
+}
+function firstStringArg(args, keys) {
+  for (const key of keys) {
+    const value = asString(args[key]);
+    if (value) return value;
+  }
+  return "";
+}
+async function callAbleTimeRestTool(name, args = {}, opts) {
+  const token = normalizeAbleTimeCredential(opts?.token ?? getAbleTimeAccessToken() ?? "");
+  if (ableTimeCredentialKind(token) !== "org") {
+    throw new Error("AbleTime REST transport is for organization API keys (atk_\u2026)");
+  }
+  const requestOpts = { ...opts, token };
+  switch (name) {
+    case "orientation": {
+      const [users, projects, tasks] = await Promise.all([
+        listUsers(requestOpts),
+        listProjectsRaw(requestOpts),
+        listTasksRaw(requestOpts)
+      ]);
+      const viewer = [...users.values()].find((user) => user.name) ?? [...users.values()][0] ?? { name: "AbleTime" };
+      return { viewer, projects, tasks };
+    }
+    case "list_projects":
+      return { data: await listProjectsRaw(requestOpts) };
+    case "list_users":
+      return { data: [...(await listUsers(requestOpts)).values()] };
+    case "list_tasks":
+      return {
+        data: await listTasksRaw({
+          ...requestOpts,
+          projectId: firstStringArg(args, ["project_id", "projectId", "project"])
+        })
+      };
+    case "search_tasks":
+      return {
+        data: await listTasksRaw({
+          ...requestOpts,
+          query: firstStringArg(args, ["query", "q"])
+        })
+      };
+    case "get_task":
+      return await getTaskRaw(firstStringArg(args, ["id", "task_id", "task"]), requestOpts);
+    case "create_task": {
+      const title = firstStringArg(args, ["title"]);
+      if (!title) throw new Error("AbleTime task title is required");
+      const projectId = firstStringArg(args, ["project_id", "projectId", "project"]);
+      if (!projectId) throw new Error("AbleTime project is required");
+      const projects = await listProjectsRaw(requestOpts);
+      const project = projects.find(
+        (item) => String(item.id).toLowerCase() === projectId.toLowerCase() || String(item.name).toLowerCase() === projectId.toLowerCase()
+      ) ?? projects[0];
+      if (!project) throw new Error("AbleTime has no projects to create a task in");
+      const categories = asList(project.categories);
+      const wantedCategory = firstStringArg(args, ["category_id", "categoryId", "category"]);
+      const category = categories.map((item) => asRecord(item)).find((item) => {
+        if (!item || !wantedCategory) return false;
+        return asString(item.id).toLowerCase() === wantedCategory.toLowerCase() || asString(item.name).toLowerCase() === wantedCategory.toLowerCase();
+      }) ?? asRecord(categories[0]);
+      const created = await abletimeRestRequest("/tasks", {
+        ...requestOpts,
+        method: "POST",
+        body: {
+          projectId: project.id,
+          projectCategoryId: category ? asString(category.id) : void 0,
+          title
+        }
+      });
+      const state = firstStringArg(args, ["state"]);
+      const createdId = asString(asRecord(created)?.timeflowTaskId);
+      const description = asString(args.description);
+      if (createdId && description) {
+        await abletimeRestRequest(`/tasks/${encodeURIComponent(createdId)}`, {
+          ...requestOpts,
+          method: "PATCH",
+          body: { description: ableTimeDocFromText(description) }
+        }).catch(() => void 0);
+      }
+      if (createdId && state && state !== "todo") {
+        await abletimeRestRequest(`/tasks/${encodeURIComponent(createdId)}/state`, {
+          ...requestOpts,
+          method: "POST",
+          body: { taskState: state }
+        }).catch(() => void 0);
+      }
+      return createdId ? await getTaskRaw(createdId, requestOpts) : restTaskToRaw(created, await listUsers(requestOpts));
+    }
+    case "update_task": {
+      const id = await resolveTaskId(firstStringArg(args, ["id", "task_id", "task"]), requestOpts);
+      const patch = {};
+      const title = firstStringArg(args, ["title"]);
+      if (title) patch.title = title;
+      if (args.description !== void 0) {
+        patch.description = args.description == null || args.description === "" ? null : ableTimeDocFromText(String(args.description));
+      }
+      if (args.tags !== void 0 || args.labels !== void 0) {
+        patch.tags = args.tags ?? args.labels ?? args.tag_names;
+      }
+      if (Object.keys(patch).length > 0) {
+        await abletimeRestRequest(`/tasks/${encodeURIComponent(id)}`, {
+          ...requestOpts,
+          method: "PATCH",
+          body: patch
+        });
+      }
+      return await getTaskRaw(id, requestOpts);
+    }
+    case "set_task_state": {
+      const id = await resolveTaskId(firstStringArg(args, ["id", "task_id", "task"]), requestOpts);
+      const state = firstStringArg(args, ["state", "taskState"]);
+      if (!state) throw new Error("AbleTime task state is required");
+      await abletimeRestRequest(`/tasks/${encodeURIComponent(id)}/state`, {
+        ...requestOpts,
+        method: "POST",
+        body: { taskState: state }
+      });
+      return await getTaskRaw(id, requestOpts);
+    }
+    case "create_comment": {
+      const id = await resolveTaskId(firstStringArg(args, ["id", "task_id", "task"]), requestOpts);
+      const body = firstStringArg(args, ["body", "comment", "text"]);
+      if (!body) throw new Error("AbleTime comment body is required");
+      const created = await abletimeRestRequest(`/tasks/${encodeURIComponent(id)}/comments`, {
+        ...requestOpts,
+        method: "POST",
+        body: { content: ableTimeDocFromText(body) }
+      });
+      const rec = asRecord(created) ?? {};
+      return {
+        id: asString(rec.commentId) || void 0,
+        body: textFromAbleTimeDoc(rec.content) || body
+      };
+    }
+    case "set_task_dependency":
+      throw new Error(
+        "AbleTime organization API keys cannot set task dependencies on REST yet \u2014 use a personal access token (apt_\u2026) for MCP project-management tools."
+      );
+    default:
+      throw new Error(`AbleTime organization API keys do not support ${name} on REST`);
+  }
+}
+
+export {
+  ABLETIME_REST_PREFIX,
+  ableTimeDocFromText,
+  textFromAbleTimeDoc,
+  abletimeRestUrl,
+  looksLikeAbleTimeUlid,
+  callAbleTimeRestTool
+};

package/dist/{chunk-RV3ZKE4Y.js → chunk-5IXJTUST.js}

@@ -1,12 +1,12 @@
 import {
   isOrchestratorThread
-} from "./chunk-LJHC62LZ.js";
+} from "./chunk-TNDUTGDV.js";
 import {
   codexUnattendedGitConfigArgs,
   mergeAgentGitAuthEnv,
   resolveAgentGitAuthEnv,
   resolveCodexGitWritableRoots
-} from "./chunk-STPZQR5B.js";
+} from "./chunk-CMGRV36E.js";
 import {
   applyConnectedTeamToCli,
   brightsyMcpServerName,
@@ -41,7 +41,7 @@ import {
   loadAppSettings,
   resolveAgentExecutable,
   resolveClaudeExecutable
-} from "./chunk-CXFW5LIH.js";
+} from "./chunk-QFBBUFD4.js";
 import {
   isElectronLikeCommand,
   unwrapStrippedElectronLaunch
@@ -1036,7 +1036,7 @@ function applyAgentEvent(parts, event) {
       next.push(
         withPartTimes({
           type: "thinking",
-          text: data,
+          text: clipThinkingForStore(data),
           ...event.parentId ? { parentId: event.parentId } : {}
         })
       );
@@ -1937,7 +1937,7 @@ var claudeAdapter = {
       );
     }
     const mode = permissionMode(thread);
-    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-5AZEEQRU.js");
+    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-PU7ZS3LS.js");
     const isOrchestrator = isOrchestratorThread2(thread);
     const injectedServers = await buildInjectedMcpServers({
       includeSideboard: true,