exponential-mcp 0.3.0 → 0.5.0

package/dist/index.js

@@ -9,21 +9,63 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextpro
 import { ExponentialClient, createConfigStore } from 'exponential-sdk';
 import { readFileSync, existsSync } from 'fs';
 import { homedir } from 'os';
-import { join } from 'path';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 const LEGACY_CONFIG_PATH = join(homedir(), '.config', 'exponential-mcp', 'config.json');
+// Report the real package version rather than a hand-maintained literal that drifts.
+const PKG_VERSION = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf-8')).version;
 const configStore = createConfigStore({ projectName: 'exponential-mcp' });
+/**
+ * Read the `exp` claim out of a JWT, without verifying the signature — we only
+ * want to know whether it is worth sending, not whether it is trustworthy.
+ *
+ * Returns null for opaque tokens (`exp_agent_…` keys, which never expire) and
+ * for anything that does not parse as a JWT.
+ */
+function getTokenExpiry(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+        return null;
+    }
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+        return typeof payload?.exp === 'number' ? new Date(payload.exp * 1000) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function assertTokenIsUsable(token, source) {
+    const expiry = getTokenExpiry(token);
+    if (!expiry || expiry.getTime() > Date.now()) {
+        return;
+    }
+    console.error(`Error: token expired on ${expiry.toISOString().slice(0, 10)} (${source}).`);
+    console.error('Run "npx exponential-mcp init" to store a fresh token.');
+    process.exit(1);
+}
 function migrateLegacyConfig() {
     if (configStore.isAuthenticated() || !existsSync(LEGACY_CONFIG_PATH)) {
         return;
     }
     try {
         const legacy = JSON.parse(readFileSync(LEGACY_CONFIG_PATH, 'utf-8'));
-        if (legacy?.apiKey) {
-            configStore.saveConfig({
-                token: legacy.apiKey,
-                apiUrl: legacy.baseUrl || 'https://www.exponential.im',
-            });
+        if (!legacy?.apiKey) {
+            return;
         }
+        // Don't resurrect a dead token: the legacy file long outlives the JWT in it,
+        // so migrating one blindly turns every config reset into a silent 401.
+        const expiry = getTokenExpiry(legacy.apiKey);
+        if (expiry && expiry.getTime() <= Date.now()) {
+            console.error(`Note: ignoring legacy config at ${LEGACY_CONFIG_PATH} — its token expired on ${expiry
+                .toISOString()
+                .slice(0, 10)}.`);
+            return;
+        }
+        configStore.saveConfig({
+            token: legacy.apiKey,
+            apiUrl: legacy.baseUrl || 'https://www.exponential.im',
+        });
     }
     catch {
         // Ignore legacy config parsing errors.
@@ -33,6 +75,7 @@ function loadClientConfig() {
     migrateLegacyConfig();
     if (configStore.isAuthenticated()) {
         const config = configStore.loadConfig();
+        assertTokenIsUsable(config.token, 'stored config');
         return { token: config.token, apiUrl: config.apiUrl };
     }
     const token = process.env.EXPONENTIAL_API_KEY || process.env.EXPONENTIAL_API_TOKEN;
@@ -44,6 +87,7 @@ function loadClientConfig() {
         console.error('Run "npx exponential-mcp init" to set up, or set EXPONENTIAL_API_KEY env var.');
         process.exit(1);
     }
+    assertTokenIsUsable(token, 'EXPONENTIAL_API_KEY');
     return { token, apiUrl };
 }
 /**
@@ -216,13 +260,54 @@ const TOOLS = [
     },
     {
         name: 'get_goals',
-        description: 'List OKRs (Objectives and Key Results) with their progress',
+        description: "List objectives (goals). Each objective carries its linked projects, which is how work ladders up to an OKR: every action has a projectId. Objectives have INTEGER ids — key results, which are separate, have CUIDs (see get_key_results). Use tree: true for the annual → quarterly cascade.",
         inputSchema: {
             type: 'object',
             properties: {
                 workspaceId: {
                     type: 'string',
-                    description: 'Optional workspace ID'
+                    description: 'Optional workspace ID. With it the list is workspace-wide (every member\'s objectives); without it you get your own.'
+                },
+                period: {
+                    type: 'string',
+                    description: 'Optional period filter, e.g. "Q3-2026" or "Annual-2026"'
+                },
+                status: {
+                    type: 'string',
+                    description: 'Optional status: planned, active, completed, archived, on-hold'
+                },
+                tree: {
+                    type: 'boolean',
+                    description: 'Return objectives nested parent → child (up to 5 levels), each with its projects and key results, instead of a flat list'
+                }
+            }
+        }
+    },
+    {
+        name: 'get_key_results',
+        description: "List key results — the measurable half of an OKR. By default groups them under their objectives (the richest read: one call for 'how is the quarter going'). Pass flat: true for a bare list. Key result ids are CUIDs; the goalId tying one to its objective is an integer.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: "Optional workspace ID. With it the list is workspace-wide (every member's key results); without it you get your own."
+                },
+                period: {
+                    type: 'string',
+                    description: 'Optional period filter, e.g. "Q3-2026"'
+                },
+                goalId: {
+                    type: 'number',
+                    description: 'Optional objective ID (an integer). Only applies with flat: true.'
+                },
+                status: {
+                    type: 'string',
+                    description: 'Optional status: not-started, on-track, at-risk, off-track, achieved. Only applies with flat: true.'
+                },
+                flat: {
+                    type: 'boolean',
+                    description: 'Return a flat list of key results rather than grouping them by objective'
                 }
             }
         }
@@ -267,7 +352,7 @@ async function main() {
     const trpcClient = client.client;
     const server = new Server({
         name: 'exponential-mcp',
-        version: '0.1.0',
+        version: PKG_VERSION,
     }, {
         capabilities: {
             tools: {},
@@ -421,10 +506,17 @@ async function main() {
                         ],
                     };
                 }
+                // Goes through the SDK's GoalsApi rather than a raw tRPC path. The old
+                // implementation called `goal.list`, which does not exist — the tool
+                // hard-errored with `No procedure found on path "goal.list"` on every
+                // invocation.
                 case 'get_goals': {
-                    const goals = await trpcClient.goal.list.query({
-                        workspaceId: args?.workspaceId,
-                    });
+                    const workspaceId = args?.workspaceId;
+                    const period = args?.period;
+                    const status = args?.status;
+                    const goals = args?.tree
+                        ? await client.goals.tree({ workspaceId, status })
+                        : await client.goals.list({ workspaceId, period, status });
                     return {
                         content: [
                             {
@@ -434,6 +526,26 @@ async function main() {
                         ],
                     };
                 }
+                case 'get_key_results': {
+                    const workspaceId = args?.workspaceId;
+                    const period = args?.period;
+                    const keyResults = args?.flat
+                        ? await client.goals.keyResults.list({
+                            workspaceId,
+                            period,
+                            goalId: args?.goalId,
+                            status: args?.status,
+                        })
+                        : await client.goals.keyResults.byObjective({ workspaceId, period });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(keyResults, null, 2),
+                            },
+                        ],
+                    };
+                }
                 case 'search': {
                     const results = await trpcClient.search.global.query({
                         query: args?.query,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exponential-mcp",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "MCP server for Exponential - connect Claude to your projects, actions, and goals",
   "main": "dist/index.js",
   "bin": {
@@ -11,7 +11,8 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
-    "cli": "node dist/cli.js"
+    "cli": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "mcp",
@@ -23,9 +24,9 @@
   "author": "Exponential",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "commander": "^12.0.0",
-    "exponential-sdk": "^1.10.0",
+    "exponential-sdk": "^1.12.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {