mcp-intervals 1.1.0 → 1.2.0

package/README.md

@@ -14,11 +14,14 @@ npx mcp-intervals init
 ```
 
 This will:
-1. Detect installed MCP clients (Claude Code, Claude Desktop, Cursor, Windsurf)
-2. Let you select which clients to configure
-3. Prompt for your Intervals API token
-4. Validate the token with your Intervals account
-5. Save the configuration automatically
+1. Detect your shell (zsh, bash, or PowerShell)
+2. Store your API token securely in your shell profile (not in config files)
+3. Detect installed MCP clients (Claude Code, Claude Desktop, Cursor, Windsurf)
+4. Configure the selected clients
+
+### Security
+
+The installer stores your API token as an environment variable in your shell profile (`~/.zshrc`, `~/.bashrc`, or PowerShell profile), keeping it out of project files that might be committed to git. MCP config files only contain the command reference, not the token.
 
 ## Manual Setup
 
@@ -28,37 +31,43 @@ This will:
 2. Go to **Options** (bottom-left) > **My Account** > **API Access**
 3. Copy your **API token**
 
-### 2. Install in Claude Code
+### 2. Add the token to your shell profile
 
+Add the following line to your shell profile:
+
+**macOS/Linux (zsh)** - Add to `~/.zshrc`:
 ```bash
-# Available in all your projects (recommended)
-claude mcp add intervals --scope user -e INTERVALS_API_TOKEN=YOUR_TOKEN -- npx -y mcp-intervals
+export INTERVALS_API_TOKEN="YOUR_TOKEN"
+```
 
-# Only in the current project, shared with team via .mcp.json (committed to git)
-claude mcp add intervals --scope project -e INTERVALS_API_TOKEN=YOUR_TOKEN -- npx -y mcp-intervals
+**macOS/Linux (bash)** - Add to `~/.bashrc` or `~/.bash_profile`:
+```bash
+export INTERVALS_API_TOKEN="YOUR_TOKEN"
+```
 
-# Only for you in the current project (default)
-claude mcp add intervals -e INTERVALS_API_TOKEN=YOUR_TOKEN -- npx -y mcp-intervals
+**Windows (PowerShell)** - Add to your PowerShell profile:
+```powershell
+$env:INTERVALS_API_TOKEN = "YOUR_TOKEN"
 ```
 
-Replace `YOUR_TOKEN` with your actual API token.
+Then reload your shell or restart your terminal.
 
-### 3. Install in Claude Desktop
+### 3. Configure MCP clients
 
-Add this to your config file:
+Add this to your MCP config file (token is read from environment):
 
-- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+**Claude Code:**
+```bash
+claude mcp add intervals --scope user -- npx -y mcp-intervals
+```
 
+**Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
 ```json
 {
   "mcpServers": {
     "intervals": {
       "command": "npx",
-      "args": ["-y", "mcp-intervals"],
-      "env": {
-        "INTERVALS_API_TOKEN": "YOUR_TOKEN"
-      }
+      "args": ["-y", "mcp-intervals"]
     }
   }
 }
@@ -67,17 +76,14 @@ Add this to your config file:
 <details>
 <summary><strong>Cursor</strong></summary>
 
-Add to `.cursor/mcp.json` in your project or `~/.cursor/mcp.json` globally:
+Add to `~/.cursor/mcp.json`:
 
 ```json
 {
   "mcpServers": {
     "intervals": {
       "command": "npx",
-      "args": ["-y", "mcp-intervals"],
-      "env": {
-        "INTERVALS_API_TOKEN": "YOUR_TOKEN"
-      }
+      "args": ["-y", "mcp-intervals"]
     }
   }
 }
@@ -95,10 +101,7 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
   "mcpServers": {
     "intervals": {
       "command": "npx",
-      "args": ["-y", "mcp-intervals"],
-      "env": {
-        "INTERVALS_API_TOKEN": "YOUR_TOKEN"
-      }
+      "args": ["-y", "mcp-intervals"]
     }
   }
 }

package/dist/cli/clients.d.ts

@@ -16,6 +16,6 @@ interface McpServerConfig {
 export declare function detectClients(): McpClient[];
 export declare function readConfig(configPath: string): McpConfig;
 export declare function writeConfig(configPath: string, config: McpConfig): void;
-export declare function configureClient(configPath: string, token: string): void;
+export declare function configureClient(configPath: string): void;
 export declare function hasExistingConfig(configPath: string): boolean;
 export {};

package/dist/cli/clients.js

@@ -111,17 +111,15 @@ export function writeConfig(configPath, config) {
     }
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
-export function configureClient(configPath, token) {
+export function configureClient(configPath) {
     const config = readConfig(configPath);
     if (!config.mcpServers) {
         config.mcpServers = {};
     }
+    // Don't include token in config - it's stored in shell profile
     config.mcpServers.intervals = {
         command: "npx",
         args: ["-y", "mcp-intervals"],
-        env: {
-            INTERVALS_API_TOKEN: token,
-        },
     };
     writeConfig(configPath, config);
 }

package/dist/cli/init.js

@@ -4,6 +4,7 @@ import pc from "picocolors";
 import { detectClients, configureClient, hasExistingConfig } from "./clients.js";
 import { validateToken } from "./api.js";
 import { searchMultiselect, cancelSymbol } from "./prompts/search-multiselect.js";
+import { detectShell, getProfilePath, findExistingToken, saveTokenToProfile, getReloadCommand, getManualInstruction, } from "./shell.js";
 // Logo ASCII art with gradient grays (256-color)
 const LOGO_LINES = [
     "██╗███╗   ██╗████████╗███████╗██████╗ ██╗   ██╗ █████╗ ██╗     ███████╗",
@@ -36,12 +37,107 @@ function shortenPath(fullPath) {
     }
     return fullPath;
 }
+function maskToken(token) {
+    if (token.length <= 6) {
+        return "***";
+    }
+    const start = token.slice(0, 4);
+    const end = token.slice(-3);
+    return `${start}***${end}`;
+}
 async function main() {
     showLogo();
     console.log();
     p.intro(pc.bgCyan(pc.black(" intervals ")));
     const spinner = p.spinner();
-    // Detect clients
+    // Step 1: Detect shell
+    spinner.start("Detecting shell...");
+    let shellInfo = detectShell();
+    spinner.stop(shellInfo.detected
+        ? `Detected ${shellInfo.type} shell`
+        : `Could not detect shell, assuming ${shellInfo.type}`);
+    // If shell not detected, ask user
+    if (!shellInfo.detected) {
+        console.log();
+        const selectedShell = await p.select({
+            message: "Which shell do you use?",
+            options: [
+                { value: "zsh", label: "zsh" },
+                { value: "bash", label: "bash" },
+                { value: "powershell", label: "PowerShell" },
+            ],
+        });
+        if (p.isCancel(selectedShell)) {
+            p.cancel("Installation cancelled");
+            process.exit(0);
+        }
+        shellInfo = {
+            type: selectedShell,
+            profilePath: getProfilePath(selectedShell),
+            detected: true,
+        };
+    }
+    // Step 2: Check for existing token
+    const existingToken = findExistingToken(shellInfo.profilePath, shellInfo.type);
+    let token;
+    if (existingToken.found && existingToken.value) {
+        console.log();
+        p.log.info(`Found existing token: ${pc.cyan(existingToken.partial)}`);
+        p.log.message(pc.dim(`  in ${shortenPath(shellInfo.profilePath)}`));
+        const replaceToken = await p.select({
+            message: "What do you want to do?",
+            options: [
+                { value: "keep", label: "Keep existing token" },
+                { value: "replace", label: "Replace with new token" },
+            ],
+        });
+        if (p.isCancel(replaceToken)) {
+            p.cancel("Installation cancelled");
+            process.exit(0);
+        }
+        if (replaceToken === "keep") {
+            token = existingToken.value;
+        }
+        else {
+            console.log();
+            token = await p.password({
+                message: "Enter your new Intervals API token:",
+            });
+        }
+    }
+    else {
+        // No existing token, ask for one
+        console.log();
+        token = await p.password({
+            message: "Enter your Intervals API token:",
+        });
+    }
+    if (p.isCancel(token) || !token || token.trim() === "") {
+        p.cancel("No token provided");
+        process.exit(1);
+    }
+    const finalToken = token.trim();
+    // Step 3: Validate token
+    spinner.start("Validating token...");
+    const validation = await validateToken(finalToken);
+    if (!validation.valid) {
+        spinner.stop(pc.red("Token validation failed"));
+        p.log.error(validation.error || "Invalid token");
+        p.log.message(pc.dim("  Find your API token at: https://[subdomain].myintervals.com/account/api/"));
+        console.log();
+        const continueAnyway = await p.confirm({
+            message: "Save configuration anyway (without validation)?",
+            initialValue: false,
+        });
+        if (p.isCancel(continueAnyway) || !continueAnyway) {
+            p.cancel("Installation cancelled");
+            process.exit(1);
+        }
+    }
+    else {
+        spinner.stop(`Token valid! Connected to "${validation.workspace}"`);
+    }
+    // Step 4: Detect MCP clients
     spinner.start("Detecting MCP clients...");
     const clients = detectClients();
     const detectedClients = clients.filter((c) => c.detected);
@@ -60,13 +156,13 @@ async function main() {
         p.cancel("No MCP clients detected. Install Claude Code, Claude Desktop, Cursor, or Windsurf first.");
         process.exit(1);
     }
-    // Select clients with search multiselect
+    // Step 5: Select clients
     const clientChoices = detectedClients.map((client) => {
         const hasExisting = hasExistingConfig(client.configPath);
         return {
             value: client.id,
             label: client.name,
-            hint: shortenPath(client.configPath) + (hasExisting ? " - will overwrite" : ""),
+            hint: shortenPath(client.configPath) + (hasExisting ? " - will update" : ""),
         };
     });
     // Pre-select clients that don't have existing config
@@ -85,41 +181,14 @@ async function main() {
         process.exit(0);
     }
     const selectedClients = detectedClients.filter((c) => Array.isArray(selectedIds) && selectedIds.includes(c.id));
-    // Get API token
+    // Step 6: Show summary and confirm
     console.log();
-    const token = await p.password({
-        message: "Enter your Intervals API token:",
-    });
-    if (p.isCancel(token) || !token || token.trim() === "") {
-        p.cancel("No token provided");
-        process.exit(1);
-    }
-    // Validate token
-    spinner.start("Validating token...");
-    const validation = await validateToken(token.trim());
-    if (!validation.valid) {
-        spinner.stop(pc.red("Token validation failed"));
-        p.log.error(validation.error || "Invalid token");
-        p.log.message(pc.dim("  Find your API token at: https://[subdomain].myintervals.com/account/api/"));
-        console.log();
-        const continueAnyway = await p.confirm({
-            message: "Save configuration anyway (without validation)?",
-            initialValue: false,
-        });
-        if (p.isCancel(continueAnyway) || !continueAnyway) {
-            p.cancel("Installation cancelled");
-            process.exit(1);
-        }
-    }
-    else {
-        spinner.stop(`Token valid! Connected to "${validation.workspace}"`);
-    }
-    // Show summary and confirm
-    console.log();
-    const summaryLines = [];
-    for (const client of selectedClients) {
-        summaryLines.push(`${pc.cyan(client.name)}  ${pc.dim(shortenPath(client.configPath))}`);
-    }
+    const summaryLines = [
+        `${pc.bold("Token:")} ${shortenPath(shellInfo.profilePath)}`,
+        "",
+        pc.bold("MCP clients:"),
+        ...selectedClients.map((c) => `  ${c.name}  ${pc.dim(shortenPath(c.configPath))}`),
+    ];
     p.note(summaryLines.join("\n"), "Will configure");
     const confirmed = await p.confirm({
         message: "Proceed with configuration?",
@@ -129,26 +198,42 @@ async function main() {
         p.cancel("Installation cancelled");
         process.exit(0);
     }
-    // Configure each client
-    spinner.start("Saving configuration...");
+    // Step 7: Save token to shell profile
+    spinner.start("Saving token to shell profile...");
+    const tokenResult = saveTokenToProfile(shellInfo.profilePath, shellInfo.type, finalToken);
+    if (!tokenResult.success) {
+        spinner.stop(pc.red("Failed to save token"));
+        console.log();
+        p.log.error(`Cannot write to ${shortenPath(shellInfo.profilePath)}`);
+        p.log.message("");
+        p.log.message(pc.bold("Add this line manually to your shell profile:"));
+        p.log.message("");
+        p.log.message(`  ${pc.cyan(getManualInstruction(finalToken, shellInfo.type))}`);
+        console.log();
+    }
+    else {
+        spinner.stop(`Token saved to ${shortenPath(shellInfo.profilePath)}`);
+    }
+    // Step 8: Configure MCP clients
+    spinner.start("Configuring MCP clients...");
     const results = [];
     for (const client of selectedClients) {
         try {
-            configureClient(client.configPath, token.trim());
+            configureClient(client.configPath);
             results.push({ client: client.name, success: true });
         }
         catch (error) {
             results.push({
                 client: client.name,
                 success: false,
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
         }
     }
     const successful = results.filter((r) => r.success);
     const failed = results.filter((r) => !r.success);
     spinner.stop("Configuration complete");
-    // Show results
+    // Step 9: Show results
     console.log();
     if (successful.length > 0) {
         const resultLines = successful.map((r) => {
@@ -164,6 +249,12 @@ async function main() {
             p.log.message(`  ${pc.red("✗")} ${r.client}: ${pc.dim(r.error)}`);
         }
     }
+    // Step 10: Show reload instructions
+    if (tokenResult.success) {
+        console.log();
+        const reloadCmd = getReloadCommand(shellInfo.profilePath, shellInfo.type);
+        p.note(`${pc.bold("To activate the token, run:")}\n\n  ${pc.cyan(reloadCmd)}\n\nOr restart your terminal.`, "Next step");
+    }
     console.log();
     p.outro(pc.green("Done! Restart your MCP clients to use mcp-intervals."));
 }

package/dist/cli/shell.d.ts

@@ -0,0 +1,39 @@
+export type ShellType = "zsh" | "bash" | "powershell";
+export interface ShellInfo {
+    type: ShellType;
+    profilePath: string;
+    detected: boolean;
+}
+export interface ExistingToken {
+    found: boolean;
+    value?: string;
+    partial?: string;
+    lineNumber?: number;
+}
+/**
+ * Detect the user's shell and return profile path
+ */
+export declare function detectShell(): ShellInfo;
+/**
+ * Get profile path for a specific shell type
+ */
+export declare function getProfilePath(shellType: ShellType): string;
+/**
+ * Check if token already exists in shell profile
+ */
+export declare function findExistingToken(profilePath: string, shellType: ShellType): ExistingToken;
+/**
+ * Save token to shell profile
+ */
+export declare function saveTokenToProfile(profilePath: string, shellType: ShellType, token: string): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * Get the command to reload the shell profile
+ */
+export declare function getReloadCommand(profilePath: string, shellType: ShellType): string;
+/**
+ * Get manual instruction line for when auto-save fails
+ */
+export declare function getManualInstruction(token: string, shellType: ShellType): string;

package/dist/cli/shell.js

@@ -0,0 +1,191 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const TOKEN_VAR_NAME = "INTERVALS_API_TOKEN";
+/**
+ * Detect the user's shell and return profile path
+ */
+export function detectShell() {
+    const platform = os.platform();
+    const home = os.homedir();
+    if (platform === "win32") {
+        // Windows: assume PowerShell
+        const profilePath = process.env.USERPROFILE
+            ? path.join(process.env.USERPROFILE, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1")
+            : path.join(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+        return {
+            type: "powershell",
+            profilePath,
+            detected: true,
+        };
+    }
+    // macOS/Linux: check $SHELL
+    const shellEnv = process.env.SHELL || "";
+    if (shellEnv.endsWith("zsh")) {
+        return {
+            type: "zsh",
+            profilePath: path.join(home, ".zshrc"),
+            detected: true,
+        };
+    }
+    if (shellEnv.endsWith("bash")) {
+        // On macOS, prefer .bash_profile for login shells
+        const bashProfile = path.join(home, ".bash_profile");
+        const bashrc = path.join(home, ".bashrc");
+        if (platform === "darwin" && fs.existsSync(bashProfile)) {
+            return {
+                type: "bash",
+                profilePath: bashProfile,
+                detected: true,
+            };
+        }
+        return {
+            type: "bash",
+            profilePath: bashrc,
+            detected: true,
+        };
+    }
+    // Default to zsh on macOS, bash on Linux
+    if (platform === "darwin") {
+        return {
+            type: "zsh",
+            profilePath: path.join(home, ".zshrc"),
+            detected: false,
+        };
+    }
+    return {
+        type: "bash",
+        profilePath: path.join(home, ".bashrc"),
+        detected: false,
+    };
+}
+/**
+ * Get profile path for a specific shell type
+ */
+export function getProfilePath(shellType) {
+    const platform = os.platform();
+    const home = os.homedir();
+    switch (shellType) {
+        case "zsh":
+            return path.join(home, ".zshrc");
+        case "bash":
+            if (platform === "darwin") {
+                const bashProfile = path.join(home, ".bash_profile");
+                if (fs.existsSync(bashProfile)) {
+                    return bashProfile;
+                }
+            }
+            return path.join(home, ".bashrc");
+        case "powershell":
+            return process.env.USERPROFILE
+                ? path.join(process.env.USERPROFILE, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1")
+                : path.join(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+    }
+}
+/**
+ * Create partial token for display (e.g., "7ni6***chj")
+ */
+function maskToken(token) {
+    if (token.length <= 6) {
+        return "***";
+    }
+    const start = token.slice(0, 4);
+    const end = token.slice(-3);
+    return `${start}***${end}`;
+}
+/**
+ * Check if token already exists in shell profile
+ */
+export function findExistingToken(profilePath, shellType) {
+    if (!fs.existsSync(profilePath)) {
+        return { found: false };
+    }
+    const content = fs.readFileSync(profilePath, "utf-8");
+    const lines = content.split("\n");
+    // Pattern depends on shell type
+    const pattern = shellType === "powershell"
+        ? /\$env:INTERVALS_API_TOKEN\s*=\s*["']([^"']+)["']/
+        : /export\s+INTERVALS_API_TOKEN\s*=\s*["']?([^"'\s]+)["']?/;
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(pattern);
+        if (match) {
+            const value = match[1];
+            return {
+                found: true,
+                value,
+                partial: maskToken(value),
+                lineNumber: i + 1,
+            };
+        }
+    }
+    return { found: false };
+}
+/**
+ * Format the export line for the given shell
+ */
+function formatExportLine(token, shellType) {
+    if (shellType === "powershell") {
+        return `$env:${TOKEN_VAR_NAME} = "${token}"`;
+    }
+    return `export ${TOKEN_VAR_NAME}="${token}"`;
+}
+/**
+ * Save token to shell profile
+ */
+export function saveTokenToProfile(profilePath, shellType, token) {
+    try {
+        const dir = path.dirname(profilePath);
+        // Create directory if it doesn't exist (for PowerShell profile)
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const exportLine = formatExportLine(token, shellType);
+        const existingToken = findExistingToken(profilePath, shellType);
+        if (!fs.existsSync(profilePath)) {
+            // Create new file
+            fs.writeFileSync(profilePath, exportLine + "\n", { mode: 0o644 });
+            return { success: true };
+        }
+        let content = fs.readFileSync(profilePath, "utf-8");
+        if (existingToken.found) {
+            // Replace existing line
+            const pattern = shellType === "powershell"
+                ? /\$env:INTERVALS_API_TOKEN\s*=\s*["'][^"']*["']/g
+                : /export\s+INTERVALS_API_TOKEN\s*=\s*["']?[^"'\s]*["']?/g;
+            content = content.replace(pattern, exportLine);
+        }
+        else {
+            // Append to file
+            const newline = content.endsWith("\n") ? "" : "\n";
+            content = content + newline + "\n# Intervals API token\n" + exportLine + "\n";
+        }
+        fs.writeFileSync(profilePath, content, { mode: 0o644 });
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Get the command to reload the shell profile
+ */
+export function getReloadCommand(profilePath, shellType) {
+    if (shellType === "powershell") {
+        return ". $PROFILE";
+    }
+    // Use ~ notation for display
+    const home = os.homedir();
+    const displayPath = profilePath.startsWith(home)
+        ? "~" + profilePath.slice(home.length)
+        : profilePath;
+    return `source ${displayPath}`;
+}
+/**
+ * Get manual instruction line for when auto-save fails
+ */
+export function getManualInstruction(token, shellType) {
+    return formatExportLine(token, shellType);
+}

package/dist/client.d.ts

@@ -33,5 +33,7 @@ export declare class IntervalsClient {
         datebegin?: string;
         dateend?: string;
     }): Promise<Record<string, unknown>>;
-    getMe(): Promise<Record<string, unknown>>;
+    getMe(): Promise<{
+        personid: number;
+    }>;
 }

package/dist/client.js

@@ -113,6 +113,7 @@ export class IntervalsClient {
     // --- Me (current user) ---
     async getMe() {
         const data = await this.request(`/me/`);
-        return data.me;
+        // Return the first user object with personid from the top-level response
+        return { ...data.me[0], personid: data.personid };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-intervals",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "MCP server for Intervals task management",
   "type": "module",
   "main": "dist/index.js",