exponential-mcp 0.3.0 → 0.4.0

package/dist/api.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Exponential API Client
+ * Handles authenticated requests to the Exponential API
+ */
+export interface ExponentialConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+export interface Project {
+    id: string;
+    name: string;
+    description?: string;
+    status: string;
+    priority: string;
+    progress: number;
+}
+export interface Action {
+    id: string;
+    name: string;
+    description?: string;
+    status: string;
+    priority: string;
+    dueDate?: string;
+    projectId?: string;
+    project?: {
+        name: string;
+    };
+}
+export interface Goal {
+    id: number;
+    title: string;
+    description?: string;
+    period?: string;
+    keyResults: KeyResult[];
+}
+export interface KeyResult {
+    id: string;
+    title: string;
+    targetValue?: number;
+    currentValue?: number;
+    status: string;
+}
+export interface Workspace {
+    id: string;
+    name: string;
+    slug: string;
+}
+export declare class ExponentialAPI {
+    private apiKey;
+    private baseUrl;
+    constructor(config: ExponentialConfig);
+    private request;
+    private trpcQuery;
+    private trpcMutation;
+    getWorkspaces(): Promise<Workspace[]>;
+    getProjects(workspaceId?: string): Promise<Project[]>;
+    getProject(id: string): Promise<Project>;
+    getActions(params?: {
+        projectId?: string;
+        status?: string;
+    }): Promise<Action[]>;
+    createAction(data: {
+        name: string;
+        description?: string;
+        projectId?: string;
+        priority?: string;
+        dueDate?: string;
+    }): Promise<Action>;
+    updateAction(id: string, data: {
+        name?: string;
+        status?: string;
+        priority?: string;
+        dueDate?: string;
+    }): Promise<Action>;
+    completeAction(id: string): Promise<Action>;
+    getGoals(workspaceId?: string): Promise<Goal[]>;
+    getGoal(id: number): Promise<Goal>;
+    quickCreateAction(text: string): Promise<Action>;
+    search(query: string): Promise<{
+        projects: Project[];
+        actions: Action[];
+        goals: Goal[];
+    }>;
+}

package/dist/api.js

@@ -0,0 +1,82 @@
+/**
+ * Exponential API Client
+ * Handles authenticated requests to the Exponential API
+ */
+const DEFAULT_BASE_URL = 'https://www.exponential.im';
+export class ExponentialAPI {
+    apiKey;
+    baseUrl;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Exponential API error (${response.status}): ${error}`);
+        }
+        return response.json();
+    }
+    // tRPC-style calls
+    async trpcQuery(procedure, input) {
+        const inputStr = input ? encodeURIComponent(JSON.stringify(input)) : '';
+        const url = `/api/trpc/${procedure}${inputStr ? `?input=${inputStr}` : ''}`;
+        return this.request(url).then(r => r.result.data);
+    }
+    async trpcMutation(procedure, input) {
+        const url = `/api/trpc/${procedure}`;
+        return this.request(url, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        }).then(r => r.result.data);
+    }
+    // === Workspace ===
+    async getWorkspaces() {
+        return this.trpcQuery('workspace.list');
+    }
+    // === Projects ===
+    async getProjects(workspaceId) {
+        return this.trpcQuery('project.list', { workspaceId });
+    }
+    async getProject(id) {
+        return this.trpcQuery('project.get', { id });
+    }
+    // === Actions ===
+    async getActions(params) {
+        return this.trpcQuery('action.list', params);
+    }
+    async createAction(data) {
+        return this.trpcMutation('action.create', data);
+    }
+    async updateAction(id, data) {
+        return this.trpcMutation('action.update', { id, ...data });
+    }
+    async completeAction(id) {
+        return this.updateAction(id, { status: 'COMPLETED' });
+    }
+    // === Goals (OKRs) ===
+    async getGoals(workspaceId) {
+        return this.trpcQuery('goal.list', { workspaceId });
+    }
+    async getGoal(id) {
+        return this.trpcQuery('goal.get', { id });
+    }
+    // === Quick Actions ===
+    async quickCreateAction(text) {
+        // Uses natural language parsing (dates, project names, etc.)
+        return this.trpcMutation('action.quickCreate', { text });
+    }
+    // === Search ===
+    async search(query) {
+        return this.trpcQuery('search.global', { query });
+    }
+}

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 };
 }
 /**
@@ -267,7 +311,7 @@ async function main() {
     const trpcClient = client.client;
     const server = new Server({
         name: 'exponential-mcp',
-        version: '0.1.0',
+        version: PKG_VERSION,
     }, {
         capabilities: {
             tools: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exponential-mcp",
-  "version": "0.3.0",
+  "version": "0.4.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.11.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {