@blackenedd18/planio-connector 2026.623.2 → 2026.623.3

package/.env.example

@@ -7,3 +7,6 @@ REDMINE_URL=https://your-redmine.example.com
 
 # Optional: debug | info | warn | error
 LOG_LEVEL=debug
+
+# Optional: base dir for the users cache (defaults to ~/.cache)
+# XDG_CACHE_HOME=

package/Redmine-functions/index.js

@@ -2,6 +2,13 @@
 // issueStatuses / issueTrackers / issuePriorities / activities remain as
 // hardcoded stubs (stable reference data maintained by the team).
 
+import { logDebug, logWarn } from '../src/shared/logger.js';
+import {
+  resolveUsersCachePath,
+  readUsersCache,
+  writeUsersCache,
+} from './users-cache.js';
+
 // --- HTTP client --------------------------------------------------------------
 
 // Builds a fetch helper bound to a resolved Redmine base URL and API key.
@@ -150,16 +157,66 @@ function resolveActivityId(payload) {
   return null;
 }
 
-// Parses the Planio /queries/filter response which may be [{id, name}],
-// [{value, label}], or [[name, id]] depending on the Planio version.
-function parseFilterValues(data) {
-  if (!Array.isArray(data)) return [];
-  return data.map((item) => {
-    if (Array.isArray(item)) return { id: Number(item[1]) || item[1], name: item[0] };
-    const id = item.id ?? item.value;
-    const name = item.name ?? item.label;
-    return { id: typeof id === 'string' ? (Number(id) || id) : id, name };
-  });
+// --- user crawl (all system users via project memberships) -------------------
+
+const PAGE_LIMIT = 100;
+
+// Fetches every page of a paginated Planio collection. `key` is the array
+// property in the response (e.g. "projects", "memberships"). Terminates via
+// total_count when present, otherwise stops on a short page.
+async function fetchAllPaged(planioFetch, basePath, key) {
+  const items = [];
+  let offset = 0;
+  for (;;) {
+    const sep = basePath.includes('?') ? '&' : '?';
+    const data = await planioFetch(`${basePath}${sep}offset=${offset}&limit=${PAGE_LIMIT}`);
+    const page = Array.isArray(data?.[key]) ? data[key] : [];
+    items.push(...page);
+
+    const total = Number(data?.total_count);
+    offset += page.length;
+    if (Number.isFinite(total)) {
+      if (offset >= total || page.length === 0) break;
+    } else if (page.length < PAGE_LIMIT) {
+      break;
+    }
+  }
+  return items;
+}
+
+function fetchAllProjects(planioFetch) {
+  return fetchAllPaged(planioFetch, '/projects.json', 'projects');
+}
+
+function fetchProjectMemberships(planioFetch, projectId) {
+  return fetchAllPaged(planioFetch, `/projects/${projectId}/memberships.json`, 'memberships');
+}
+
+// Crawls every project's memberships and returns a de-duplicated, id-sorted
+// list of users. Group-only memberships (no `user`) are skipped.
+async function crawlAllUsers(planioFetch) {
+  const projects = await fetchAllProjects(planioFetch);
+  const byId = new Map();
+
+  for (const project of projects) {
+    let memberships;
+    try {
+      memberships = await fetchProjectMemberships(planioFetch, project.id);
+    } catch (error) {
+      logWarn('Failed to fetch memberships for project', {
+        project_id: project.id,
+        status: error?.status,
+      });
+      continue;
+    }
+    for (const membership of memberships) {
+      const user = membership?.user;
+      if (!user || user.id == null) continue;
+      if (!byId.has(user.id)) byId.set(user.id, { id: user.id, name: user.name });
+    }
+  }
+
+  return [...byId.values()].sort((a, b) => a.id - b.id);
 }
 
 // --- ISO week helpers --------------------------------------------------------
@@ -518,8 +575,21 @@ export async function executeRequest({ method, endpoint, params = {}, body = {},
   }
 
   if (method === 'GET' && endpoint === 'users/all') {
-    const data = await planioFetch('/queries/filter.json?type=IssueQuery&name=author_id');
-    return parseFilterValues(data);
+    const cachePath = resolveUsersCachePath(baseUrl);
+    const cached = await readUsersCache(cachePath);
+    if (cached) {
+      logDebug('Returning all users from cache', { count: cached.length, path: cachePath });
+      return cached;
+    }
+
+    const users = await crawlAllUsers(planioFetch);
+    try {
+      await writeUsersCache(cachePath, baseUrl, users);
+      logDebug('Wrote users cache', { count: users.length, path: cachePath });
+    } catch (error) {
+      logWarn('Failed to write users cache', { path: cachePath, message: error?.message });
+    }
+    return users;
   }
 
   // --- issues reference data (hardcoded stubs) ---

package/Redmine-functions/users-cache.js

@@ -0,0 +1,39 @@
+// Users cache — persisted list of all system users, built once from project
+// memberships. Stored under the OS cache dir, scoped per Redmine instance URL
+// so different REDMINE_URL values never collide.
+
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+
+function cacheDir() {
+  const base = process.env.XDG_CACHE_HOME || join(homedir(), '.cache');
+  return join(base, 'planio-connector');
+}
+
+export function resolveUsersCachePath(redmineUrl) {
+  const hash = createHash('sha1').update(String(redmineUrl)).digest('hex').slice(0, 12);
+  return join(cacheDir(), `users-${hash}.json`);
+}
+
+export async function readUsersCache(path) {
+  try {
+    const raw = await readFile(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed?.users) ? parsed.users : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeUsersCache(path, redmineUrl, users) {
+  await mkdir(dirname(path), { recursive: true });
+  const payload = {
+    generated_at: new Date().toISOString(),
+    redmine_url: redmineUrl,
+    count: users.length,
+    users,
+  };
+  await writeFile(path, JSON.stringify(payload, null, 2), 'utf8');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackenedd18/planio-connector",
-  "version": "2026.623.2",
+  "version": "2026.623.3",
   "description": "MCP server exposing Planio/Redmine operations (users, issues, projects, hours, time entries) over stdio",
   "type": "module",
   "main": "src/index.js",

package/src/server.js

@@ -7,8 +7,9 @@ import {
   McpError,
 } from '@modelcontextprotocol/sdk/types.js';
 import { createRequire } from 'node:module';
-import { logError, logInfo } from './shared/logger.js';
+import { logError, logInfo, logWarn } from './shared/logger.js';
 import { validateRuntimeConfig } from './shared/config.js';
+import { makeRequest } from './shared/request.js';
 import * as users from './modules/users/index.js';
 import * as issues from './modules/issues/index.js';
 import * as projects from './modules/projects/index.js';
@@ -83,5 +84,20 @@ export class RedmineServer {
     logInfo('[server.run] Connecting MCP stdio transport');
     await this.server.connect(transport);
     logInfo('[server.run] MCP server connected');
+    this.warmUsersCache();
+  }
+
+  // Best-effort, non-blocking warm-up: builds the all-users cache once at
+  // startup so the first get_all_users_ids call is fast. The handler itself is
+  // lazy and idempotent, so failures here are safe to ignore.
+  warmUsersCache() {
+    makeRequest('GET', 'users/all')
+      .then((users) => {
+        const count = Array.isArray(users) ? users.length : 0;
+        logInfo('[server.run] Users cache warmed', { count });
+      })
+      .catch((error) => {
+        logWarn('[server.run] Users cache warm-up failed', { message: error?.message });
+      });
   }
 }