npm - @ezmodo/mcp-server - Versions diffs - 0.13.4 → 0.14.0 - Mend

@ezmodo/mcp-server 0.13.4 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/handlers/auth.js +160 -0
package/handlers/index.js +2 -0
package/http.js +11 -3
package/index.js +21 -52
package/lib/auth-guidance.js +67 -0
package/lib/cli-credential.js +3 -12
package/lib/create-server.js +79 -7
package/lib/credentials.js +106 -0
package/lib/git-helpers.js +115 -52
package/lib/http-client.js +19 -6
package/lib/instructions.generated.js +14 -0
package/lib/instructions.js +37 -0
package/lib/oauth-config.js +98 -0
package/lib/oauth.js +353 -0
package/lib/remote-tools.js +157 -0
package/lib/token-store.js +136 -0
package/lib/user-paths.js +41 -0
package/lib/version.js +1 -1
package/package.json +9 -6
package/prompts/commands.generated.js +52 -0
package/prompts/index.js +62 -29
package/scripts/build-instructions.mjs +76 -0
package/scripts/build-prompts.mjs +144 -0
package/tools/auth.js +34 -0
package/tools/index.js +4 -0
package/prompts/ai-workflow-automation.js +0 -96
package/prompts/zephly-usage-guide.js +0 -119

package/lib/oauth.js ADDED Viewed

@@ -0,0 +1,353 @@
+/**
+ * Authorization Code + PKCE sign-in, run by the MCP server for itself (#2631).
+ *
+ * Ported from cli/src/lib/oauth-login.ts, oauth-callback-server.ts and
+ * token-refresh.ts rather than imported from them. This package is published to
+ * npm and launched with `npx @ezmodo/mcp-server`; it must not require the CLI
+ * to be installed. lib/cli-credential.js re-implements the CLI's credential
+ * read for the same reason, and records the same trade-off: when the CLI's
+ * formats move, a copy goes stale and stops working, which is the safe
+ * direction to fail in.
+ *
+ * WHAT IS DIFFERENT FROM THE CLI'S COPY, and why:
+ *
+ *   - An EPHEMERAL loopback port, not the CLI's fixed 19838. The `ezmodo-mcp`
+ *     client registers http://localhost/* and http://127.0.0.1/*, so any port
+ *     matches; a fixed port would collide with a concurrent `ezmodo auth
+ *     login`, which is precisely when someone is likely to be signing in.
+ *   - NOTHING is written to stdout. Over stdio, stdout IS the MCP protocol
+ *     channel — a stray console.log is a protocol violation that corrupts the
+ *     session. The CLI's copy prints progress freely because it owns its
+ *     terminal. Here, diagnostics go to the logger (stderr) and anything the
+ *     user must read is returned to the caller to surface (#2632).
+ *   - Refresh is single-flight. Tool calls run concurrently, so several can
+ *     find the same expired token at once; without this they would each burn a
+ *     refresh token and all but one would fail, because Keycloak rotates it.
+ */
+import { createHash, randomBytes } from 'crypto';
+import { createServer } from 'http';
+import fetch from 'node-fetch';
+import { getKeycloakEndpoints, getScopes } from './oauth-config.js';
+import { clearTokens, isExpired, readTokens, writeTokens } from './token-store.js';
+import { getLogger } from './logger.js';
+/** How long to wait for the user to finish in the browser before giving up. */
+const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
+// ============================================================
+// PKCE primitives (RFC 7636)
+// ============================================================
+function generateState() {
+  return randomBytes(32).toString('hex');
+}
+function generateCodeVerifier() {
+  return randomBytes(32)
+    .toString('base64url')
+    .replace(/[^a-zA-Z0-9\-._~]/g, '')
+    .substring(0, 128);
+}
+function generateCodeChallenge(verifier) {
+  return createHash('sha256').update(verifier).digest('base64url');
+}
+/**
+ * Read the `sub`, `email` and `exp` out of a JWT WITHOUT verifying it.
+ *
+ * Safe here, and only here: this token came from a TLS connection to the token
+ * endpoint moments ago, and nothing security-relevant is decided from these
+ * claims — they are stored so a human can be told which account is signed in.
+ * The API verifies the signature on every request, which is where that check
+ * belongs.
+ */
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 3) return {};
+    return JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+  } catch {
+    return {};
+  }
+}
+// ============================================================
+// Loopback callback capture
+// ============================================================
+const DONE_PAGE = (heading, detail) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>EzModo</title>
+<style>
+ body{font-family:system-ui,-apple-system,"Segoe UI",sans-serif;background:#0f1115;color:#e8eaed;
+      display:flex;align-items:center;justify-content:center;height:100vh;margin:0}
+ main{text-align:center;max-width:26rem;padding:2rem}
+ h1{font-size:1.25rem;font-weight:600;margin:0 0 .5rem}
+ p{color:#9aa0a6;line-height:1.5;margin:0}
+</style></head>
+<body><main><h1>${heading}</h1><p>${detail}</p></main></body></html>`;
+/**
+ * Listen on an ephemeral loopback port for the authorization redirect.
+ *
+ * Resolves with the code once one arrives. The redirect URI is returned before
+ * the code is, because the caller needs the port to build the authorize URL —
+ * hence the two-stage shape rather than a single promise.
+ *
+ * @param {string} expectedState
+ * @returns {Promise<{ redirectUri: string, code: Promise<string>, close: () => void }>}
+ */
+function startCallbackServer(expectedState) {
+  return new Promise((resolveReady, rejectReady) => {
+    let settle;
+    const code = new Promise((resolve, reject) => {
+      settle = { resolve, reject };
+    });
+    let finished = false;
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, 'http://127.0.0.1');
+      if (url.pathname === '/favicon.ico') {
+        res.writeHead(204).end();
+        return;
+      }
+      const fail = (message) => {
+        res.writeHead(400, { 'Content-Type': 'text/html' });
+        res.end(DONE_PAGE('Sign-in failed', message));
+        if (!finished) {
+          finished = true;
+          settle.reject(new Error(message));
+        }
+      };
+      const error = url.searchParams.get('error');
+      if (error) {
+        // Keycloak reports a refused consent here rather than by not
+        // redirecting, so this is the ordinary "user clicked Cancel" path.
+        const description = url.searchParams.get('error_description') || error;
+        fail(description);
+        return;
+      }
+      const received = url.searchParams.get('code');
+      const state = url.searchParams.get('state');
+      if (!received) {
+        fail('No authorization code in the callback.');
+        return;
+      }
+      if (state !== expectedState) {
+        // The CSRF check. A mismatch means this redirect was not the one we
+        // started, so the code must not be exchanged.
+        fail('State mismatch — this sign-in did not come from this request.');
+        return;
+      }
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(DONE_PAGE('You are signed in', 'You can close this tab and return to your editor.'));
+      if (!finished) {
+        finished = true;
+        settle.resolve(received);
+      }
+    });
+    server.on('error', (error) => {
+      if (!finished) {
+        finished = true;
+        settle.reject(error);
+      }
+      rejectReady(error);
+    });
+    const timer = setTimeout(() => {
+      if (!finished) {
+        finished = true;
+        settle.reject(new Error('Timed out waiting for the browser sign-in to complete.'));
+      }
+    }, CALLBACK_TIMEOUT_MS);
+    // Do not hold the process open purely to wait for a browser.
+    timer.unref?.();
+    const close = () => {
+      clearTimeout(timer);
+      server.close();
+    };
+    code.then(close, close);
+    // Port 0 = let the OS pick. 127.0.0.1 rather than a wildcard bind: this
+    // socket briefly accepts an authorization code, and it has no business
+    // being reachable from the network.
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      resolveReady({ redirectUri: `http://127.0.0.1:${port}/callback`, code, close });
+    });
+  });
+}
+// ============================================================
+// Token endpoint
+// ============================================================
+async function postToken(body) {
+  const endpoints = getKeycloakEndpoints();
+  const response = await fetch(endpoints.token, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams(body).toString(),
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    const error = new Error(`Token request failed (${response.status}): ${text}`);
+    error.status = response.status;
+    throw error;
+  }
+  return JSON.parse(text);
+}
+/** Turn a Keycloak token response into what the store holds. */
+function toStoredTokens(response) {
+  const claims = decodeJwtPayload(response.access_token);
+  return {
+    accessToken: response.access_token,
+    refreshToken: response.refresh_token,
+    expiresAt: new Date(Date.now() + (response.expires_in ?? 60) * 1000).toISOString(),
+    userId: claims.sub,
+    email: claims.email || claims.preferred_username,
+    scope: response.scope,
+    issuer: getKeycloakEndpoints().issuer,
+  };
+}
+// ============================================================
+// Sign-in
+// ============================================================
+/**
+ * Build the authorize URL and start listening for its redirect.
+ *
+ * Split from the wait deliberately: the caller needs the URL to hand to the
+ * user (in a tool result, or a browser it opened) BEFORE anyone can complete
+ * the flow. Returning both at once would mean the URL only became available
+ * after it was already too late to show it.
+ *
+ * @returns {Promise<{ authUrl: string, complete: () => Promise<StoredTokens>, cancel: () => void }>}
+ */
+export async function beginLogin() {
+  const endpoints = getKeycloakEndpoints();
+  const state = generateState();
+  const verifier = generateCodeVerifier();
+  const challenge = generateCodeChallenge(verifier);
+  const { redirectUri, code, close } = await startCallbackServer(state);
+  const authUrl = new URL(endpoints.authorization);
+  authUrl.searchParams.set('response_type', 'code');
+  authUrl.searchParams.set('client_id', endpoints.clientId);
+  authUrl.searchParams.set('redirect_uri', redirectUri);
+  authUrl.searchParams.set('scope', getScopes());
+  authUrl.searchParams.set('state', state);
+  authUrl.searchParams.set('code_challenge', challenge);
+  authUrl.searchParams.set('code_challenge_method', 'S256');
+  getLogger().debug('OAuth sign-in started', { redirectUri, environment: endpoints.environment });
+  const complete = async () => {
+    const authorizationCode = await code;
+    const response = await postToken({
+      grant_type: 'authorization_code',
+      client_id: endpoints.clientId,
+      code: authorizationCode,
+      redirect_uri: redirectUri,
+      code_verifier: verifier,
+    });
+    const tokens = toStoredTokens(response);
+    writeTokens(tokens);
+    getLogger().info('OAuth sign-in complete', { email: tokens.email });
+    return tokens;
+  };
+  return { authUrl: authUrl.toString(), complete, cancel: close };
+}
+// ============================================================
+// Refresh
+// ============================================================
+/**
+ * In-flight refresh, shared by every caller that arrives while it runs.
+ *
+ * Keycloak ROTATES refresh tokens: the old one dies the moment the new one is
+ * issued. Two concurrent refreshes therefore do not merely waste a round trip,
+ * they race to invalidate each other, and the loser signs the user out. One
+ * promise, awaited by all.
+ */
+let refreshInFlight = null;
+async function refreshTokens(tokens) {
+  const endpoints = getKeycloakEndpoints();
+  try {
+    const response = await postToken({
+      grant_type: 'refresh_token',
+      client_id: endpoints.clientId,
+      refresh_token: tokens.refreshToken,
+    });
+    const refreshed = toStoredTokens(response);
+    // Keycloak may omit a new refresh token; keep the old one when it does,
+    // or the next refresh has nothing to present.
+    if (!refreshed.refreshToken) refreshed.refreshToken = tokens.refreshToken;
+    writeTokens(refreshed);
+    return refreshed;
+  } catch (error) {
+    // 400 from the token endpoint on a refresh means the grant is dead —
+    // expired, revoked, or already rotated. Keeping it would retry forever
+    // against something that can never succeed, so drop it and let the caller
+    // ask for a fresh sign-in.
+    if (error.status === 400) {
+      getLogger().info('Refresh token no longer valid; signing out', { error: error.message });
+      clearTokens();
+      return null;
+    }
+    // Anything else (network, 5xx) is plausibly transient. Leave the stored
+    // tokens alone so a later call can try again.
+    getLogger().warn('Token refresh failed', { error: error.message });
+    return null;
+  }
+}
+/**
+ * A usable access token, refreshing if needed, or null when a sign-in is due.
+ *
+ * Null is the ONLY failure mode: every caller is on the path of a tool call,
+ * and "you need to sign in" is a message the agent can act on, whereas a thrown
+ * error is one it cannot.
+ *
+ * @returns {Promise<string|null>}
+ */
+export async function getAccessToken() {
+  const tokens = readTokens();
+  if (!tokens) return null;
+  if (!isExpired(tokens)) return tokens.accessToken;
+  if (!tokens.refreshToken) return null;
+  if (!refreshInFlight) {
+    refreshInFlight = refreshTokens(tokens).finally(() => {
+      refreshInFlight = null;
+    });
+  }
+  const refreshed = await refreshInFlight;
+  return refreshed?.accessToken ?? null;
+}
+/** Who is signed in, for diagnostics. Null when nobody is. */
+export function getSignedInIdentity() {
+  const tokens = readTokens();
+  if (!tokens) return null;
+  return { email: tokens.email, userId: tokens.userId, scope: tokens.scope };
+}
+/** Forget the stored tokens. */
+export function signOut() {
+  return clearTokens();
+}

package/lib/remote-tools.js ADDED Viewed

@@ -0,0 +1,157 @@
+/**
+ * Which tools may be served over the REMOTE transport (#2614).
+ *
+ * The HTTP entry point and the stdio entry point deliberately build the same
+ * server (lib/create-server.js) so their tool surfaces cannot drift. That is
+ * right for almost everything — and wrong for the handful of tools that are
+ * not network operations at all.
+ *
+ * `detect_git_repository`, `manage_worktree`, `rebuild_manifest` and friends
+ * read and write the LOCAL machine: the working directory, `.ezmodo/`, the git
+ * repository. Over stdio that is the whole point — the server runs inside the
+ * user's checkout, at their request, as them. On a hosted server there is no
+ * checkout, so at best they fail confusingly.
+ *
+ * At worst they are dangerous. lib/git-helpers.js `execGit` passes its command
+ * to `execSync` — a shell — and callers interpolate tool arguments into it:
+ *
+ *     execGit(`git branch ${branchName} ${baseBranch}`, repoPath)
+ *
+ * On a user's own machine the blast radius is their own shell, which is why
+ * this has been tolerable. Reachable over the internet it is arbitrary command
+ * execution in the container. So these tools are not hardened for remote use —
+ * they are not served remotely at all, because they have no meaning there and
+ * hardening would leave a shell-executing surface exposed for no benefit.
+ *
+ * ── The list is an ALLOWLIST, deliberately ───────────────────────────────────
+ *
+ * A denylist would mean every tool added from now on is exposed remotely by
+ * default, and the mistake would be invisible: the tool simply works, until one
+ * of them turns out to touch the filesystem. Listing what is safe means a new
+ * tool is refused remotely until someone decides otherwise, and
+ * remote-tools.test.js fails loudly when a tool is unclassified rather than
+ * letting it through.
+ *
+ * Note some tools do local work as a SIDE EFFECT and are still fine here:
+ * manage_task writes `.ezmodo/active-session.json`, and lib/active-session.js
+ * already skips that when no config directory exists — which is exactly the
+ * case in a container. Likewise get_context and resolve_concepts read a local
+ * manifest when there is one and fall back to the API when there is not.
+ */
+/** Tools that operate on the local machine and are never served remotely. */
+export const LOCAL_ONLY_TOOLS = Object.freeze([
+  // Not a filesystem tool, but local for the same reason: over the connector
+  // Claude completes its own OAuth before any tool call, so a second sign-in
+  // offered there would be inert and confusing (#2632). It also opens a
+  // browser and binds a loopback port, neither of which means anything in a
+  // container.
+  'authenticate',
+  'detect_git_repository',
+  'get_current_project_context',
+  'initialize_project_context',
+  'list_project_worktrees',
+  'manage_worktree',
+  'rebuild_manifest',
+]);
+/** Tools safe to serve over the remote transport. */
+export const REMOTE_SAFE_TOOLS = Object.freeze([
+  'accept_agent_suggestion',
+  'configure_agent',
+  'create_tasks',
+  'delete_attachment',
+  'estimate_task',
+  'evaluate_feature_flag',
+  'get_access',
+  'get_ai_insights',
+  'get_attachment_url',
+  'get_catalog',
+  'get_catalog_diff',
+  'get_context',
+  'get_decision',
+  'get_design',
+  'get_design_system',
+  'get_document',
+  'get_document_template',
+  'get_epic',
+  'get_feature',
+  'get_feature_flag',
+  'get_goal',
+  'get_graph',
+  'get_manifest_schema',
+  'get_milestone',
+  'get_org_areas',
+  'get_organization',
+  'get_project',
+  'get_project_changes',
+  'get_project_story',
+  'get_task',
+  'get_testing_summary',
+  'infer_dependencies',
+  'list_agent_suggestions',
+  'list_attachments',
+  'list_catalog_items',
+  'list_catalogs',
+  'list_components',
+  'list_designs',
+  'list_epics',
+  'list_facts',
+  'list_feature_flags',
+  'list_folders',
+  'list_links',
+  'list_notifications',
+  'list_org_documents',
+  'list_repositories',
+  'list_tags',
+  'list_test_cases',
+  'list_test_suites',
+  'list_todos',
+  'list_watched',
+  'manage_access',
+  'manage_catalog',
+  'manage_component',
+  'manage_decision',
+  'manage_design',
+  'manage_document',
+  'manage_document_template',
+  'manage_environment',
+  'manage_epic',
+  'manage_fact',
+  'manage_feature',
+  'manage_feature_flag',
+  'manage_folder',
+  'manage_goal',
+  'manage_link',
+  'manage_milestone',
+  'manage_project',
+  'manage_pull_request',
+  'manage_recurring_task',
+  'manage_tag',
+  'manage_task',
+  'manage_team',
+  'manage_test_case',
+  'manage_test_suite',
+  'manage_todo',
+  'manage_watch',
+  'manage_work_template',
+  'preview_links',
+  'reject_agent_suggestion',
+  'report_untracked_work',
+  'resolve_concepts',
+  'resolve_link_suggestions',
+  'resolve_links',
+  'run_agent_now',
+  'search_epics',
+  'search_features',
+  'search_tasks',
+  'update_manifest_entries',
+  'validate_manifest',
+]);
+const remoteSafe = new Set(REMOTE_SAFE_TOOLS);
+/** Whether a tool may be served over the remote transport. */
+export function isRemoteSafe(toolName) {
+  return remoteSafe.has(toolName);
+}

package/lib/token-store.js ADDED Viewed

@@ -0,0 +1,136 @@
+/**
+ * On-disk store for the OAuth tokens this server obtains for itself (#2631).
+ *
+ * Lives at <config dir>/mcp-oauth.json, beside the CLI's own `credentials`
+ * file. A DISTINCT filename on purpose: the CLI owns `credentials` and
+ * `oauth.json`, and two programs writing one file is how a working login
+ * disappears the next time the other one runs. This server only ever reads the
+ * CLI's files (see lib/cli-credential.js) and only ever writes its own.
+ *
+ * Three properties this module is responsible for:
+ *
+ *   1. It never throws. It sits on the path every tool call takes to resolve a
+ *      credential. A malformed or unreadable file must degrade to "not signed
+ *      in" — which prompts a fresh sign-in and fixes itself — rather than
+ *      taking down the server, which does not.
+ *   2. It writes 0600, and creates the directory 0700. These are bearer
+ *      tokens for the user's whole account; a world-readable file in a shared
+ *      home directory hands the account over.
+ *   3. It writes atomically, via a temp file in the same directory and a
+ *      rename. A torn write here is indistinguishable from corruption, and
+ *      corruption logs a user out.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { configDir } from './user-paths.js';
+import { getLogger } from './logger.js';
+const FILENAME = 'mcp-oauth.json';
+/**
+ * Treat a token as expired this many milliseconds BEFORE it actually expires.
+ *
+ * Without a margin, a token that passes the check can still be rejected by the
+ * time the request lands — clock skew between this machine and Keycloak, plus
+ * the request's own flight time. Thirty seconds costs nothing (the refresh is
+ * one round trip) and removes a class of intermittent 401 that would look like
+ * a server bug rather than a clock.
+ */
+const EXPIRY_MARGIN_MS = 30_000;
+function tokenPath() {
+  return join(configDir(), FILENAME);
+}
+/**
+ * @typedef {object} StoredTokens
+ * @property {string} accessToken
+ * @property {string} [refreshToken]
+ * @property {string} expiresAt   ISO 8601
+ * @property {string} [userId]
+ * @property {string} [email]
+ * @property {string} [scope]
+ * @property {string} [issuer]    Which Keycloak issued these
+ */
+/**
+ * Read the stored tokens, or null if there are none to read.
+ *
+ * @returns {StoredTokens|null}
+ */
+export function readTokens() {
+  const path = tokenPath();
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+    if (!parsed || typeof parsed.accessToken !== 'string' || !parsed.accessToken.trim()) {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    // Malformed, truncated, or unreadable. Reporting "not signed in" sends the
+    // user through a sign-in that overwrites it; throwing would strand them.
+    getLogger().warn('Ignoring unreadable OAuth token file', { path, error: error.message });
+    return null;
+  }
+}
+/**
+ * Persist tokens, replacing whatever was there.
+ *
+ * @param {StoredTokens} tokens
+ * @returns {boolean} whether the write landed
+ */
+export function writeTokens(tokens) {
+  const dir = configDir();
+  const path = tokenPath();
+  const temp = `${path}.${process.pid}.tmp`;
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(temp, JSON.stringify(tokens, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    renameSync(temp, path);
+    return true;
+  } catch (error) {
+    getLogger().warn('Could not persist OAuth tokens', { path, error: error.message });
+    try {
+      if (existsSync(temp)) unlinkSync(temp);
+    } catch {
+      // Nothing useful to do about a leftover temp file.
+    }
+    return false;
+  }
+}
+/** Forget the stored tokens. Used by sign-out and by an unrecoverable refresh. */
+export function clearTokens() {
+  const path = tokenPath();
+  try {
+    if (existsSync(path)) unlinkSync(path);
+    return true;
+  } catch (error) {
+    getLogger().warn('Could not clear OAuth tokens', { path, error: error.message });
+    return false;
+  }
+}
+/**
+ * Whether an access token is past use, margin included.
+ *
+ * Missing or unparseable expiry counts as expired: if we cannot tell, the safe
+ * answer is the one that triggers a refresh rather than the one that sends a
+ * possibly-dead token to the API.
+ *
+ * @param {StoredTokens|null} tokens
+ */
+export function isExpired(tokens) {
+  if (!tokens?.expiresAt) return true;
+  const expiry = Date.parse(tokens.expiresAt);
+  if (Number.isNaN(expiry)) return true;
+  return Date.now() >= expiry - EXPIRY_MARGIN_MS;
+}
+/** The path tokens are stored at, for diagnostics and messages. */
+export function getTokenPath() {
+  return tokenPath();
+}

package/lib/user-paths.js ADDED Viewed

@@ -0,0 +1,41 @@
+/**
+ * Where this server keeps per-user state on disk.
+ *
+ * Extracted so the credential reader and the OAuth token store cannot disagree
+ * about where "the ezmodo config directory" is. They had better not: the two
+ * files live side by side, and a writer that picks a different directory from
+ * the reader produces a login that appears to succeed and then is never found
+ * again.
+ *
+ * `.config/ezmodo` is current, `.config/zephly` the pre-rebrand name still
+ * present in older installs. Current always wins; legacy is READ-ONLY. Nothing
+ * here ever writes to the legacy directory — migrating it is the CLI's job
+ * (cli/src/lib/user-paths.ts owns that), and a second migrator racing the first
+ * over the same files is worse than not migrating at all.
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+/**
+ * Every directory to SEARCH, current first.
+ *
+ * @returns {string[]}
+ */
+export function configDirs() {
+  const home = homedir();
+  if (process.platform === 'win32') {
+    const base = process.env.APPDATA || home;
+    return [join(base, 'ezmodo'), join(base, 'zephly')];
+  }
+  return [join(home, '.config', 'ezmodo'), join(home, '.config', 'zephly')];
+}
+/**
+ * The single directory to WRITE to. Always the current name.
+ *
+ * @returns {string}
+ */
+export function configDir() {
+  return configDirs()[0];
+}

package/lib/version.js CHANGED Viewed

@@ -7,4 +7,4 @@
  *
  * Update this when bumping the version in package.json.
  */
-export const MCP_VERSION = '0.13.4';
+export const MCP_VERSION = '0.14.0';