@alfe.ai/mcp-server 0.1.19 → 0.2.1

package/dist/bin.cjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+const require_index = require("./index.cjs");
 //#region src/bin.ts
-require("./index.cjs").main();
+require_index.main({ profile: require_index.parseProfileArg(process.argv.slice(2)) });
 //#endregion

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { main } from "./index.js";
+import { main, parseProfileArg } from "./index.js";
 //#region src/bin.ts
-main();
+main({ profile: parseProfileArg(process.argv.slice(2)) });
 //#endregion
 export {};
 

package/dist/bin.js.map

@@ -1 +1 @@
-{"version":3,"file":"bin.js","names":[],"sources":["../src/bin.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { main } from './index.js';\n\nvoid main();\n"],"mappings":";;;AAGK,MAAM"}
+{"version":3,"file":"bin.js","names":[],"sources":["../src/bin.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { main, parseProfileArg } from './index.js';\n\n// The OpenClaw daemon bundler launches this bin with no args → `default`\n// profile (integrations only, unchanged). The Alfe CLI launches it as\n// `node <bin> --profile claude-code` for a Claude Code session → memory +\n// voice + messaging tools on top.\nvoid main({ profile: parseProfileArg(process.argv.slice(2)) });\n"],"mappings":";;;AAOK,KAAK,EAAE,SAAS,gBAAgB,QAAQ,KAAK,MAAM,EAAE,CAAC,EAAE,CAAC"}

package/dist/index.cjs

@@ -44,39 +44,70 @@ const SERVER_BIN_PATH = (0, node_url.fileURLToPath)(new URL("./bin.js", require(
 * `~/.alfe/config.toml`.
 */
 async function createServer(opts = {}) {
+	const profile = opts.profile ?? "default";
 	let client = opts.client;
 	let apiUrl = opts.apiUrl;
-	if (!client || !apiUrl) {
+	let voiceClient = opts.voiceClient;
+	let voiceApiUrl = opts.voiceApiUrl;
+	if (!client || !apiUrl || profile === "claude-code" && !voiceClient && !voiceApiUrl) {
 		const cfg = (0, _alfe_ai_config.resolveConfig)();
 		client = client ?? new _alfe_ai_agent_api_client.AgentApiClient({
 			apiKey: cfg.apiKey,
 			apiUrl: cfg.apiUrl
 		});
 		apiUrl = apiUrl ?? cfg.apiUrl;
+		voiceApiUrl = voiceApiUrl ?? cfg.voiceServiceUrl;
+		voiceClient = voiceClient ?? new _alfe_ai_agent_api_client.AgentApiClient({
+			apiKey: cfg.apiKey,
+			apiUrl: cfg.voiceServiceUrl
+		});
 	}
 	const identity = opts.identity ?? await client.whoami();
 	const ctx = {
 		client,
 		apiUrl,
 		agentId: identity.agentId,
-		tenantId: identity.tenantId
+		tenantId: identity.tenantId,
+		voiceApiUrl,
+		voiceClient
 	};
 	const server = new _modelcontextprotocol_sdk_server_mcp_js.McpServer({
 		name: SERVER_NAME,
 		version: SERVER_VERSION
 	});
 	(0, _alfe_ai_mcp_tools.registerIntegrationsTools)(server, ctx);
+	if (profile === "claude-code") {
+		(0, _alfe_ai_mcp_tools.registerMemoryTools)(server, ctx);
+		(0, _alfe_ai_mcp_tools.registerVoiceTools)(server, ctx);
+		(0, _alfe_ai_mcp_tools.registerMessagingTools)(server, ctx);
+	}
 	return server;
 }
 /**
+* Parse the server profile out of a raw argv slice. Accepts both
+* `--profile claude-code` and `--profile=claude-code`. Unknown or missing
+* values resolve to `default`, so the OpenClaw bundler (which launches the
+* bin with no args) always gets the integrations-only surface.
+*/
+function parseProfileArg(argv) {
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		let value;
+		if (arg === "--profile") value = argv[i + 1];
+		else if (arg.startsWith("--profile=")) value = arg.slice(10);
+		if (value === "claude-code") return "claude-code";
+	}
+	return "default";
+}
+/**
 * Entry point — boot the server on stdio. Used by `bin.ts`. Any
 * startup failure is fatal: log and exit non-zero so the bundler's
 * connection attempt surfaces a clear error rather than a hung
 * handshake.
 */
-async function main() {
+async function main(opts = {}) {
 	try {
-		const server = await createServer();
+		const server = await createServer({ profile: opts.profile });
 		const transport = new _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport();
 		await server.connect(transport);
 	} catch (err) {
@@ -93,3 +124,4 @@ exports.SERVER_NAME = SERVER_NAME;
 exports.SERVER_VERSION = SERVER_VERSION;
 exports.createServer = createServer;
 exports.main = main;
+exports.parseProfileArg = parseProfileArg;

package/dist/index.d.cts

@@ -10,6 +10,26 @@ interface AgentApiClientConfig {
   apiKey: string;
   apiUrl: string;
 }
+/**
+ * The broad-news providers behind the metered `services/news` Lambda. The
+ * server validates this with a zod enum; a value outside the union is an
+ * unpriceable product, so keep the literal union in lockstep with the service.
+ */
+type NewsProvider = "apitube" | "newsdata";
+/** One normalized article. `sentiment` is provider-shaped (APITube supplies it). */
+interface NewsArticle {
+  title: string;
+  url: string;
+  source: string;
+  publishedAt: string;
+  snippet: string;
+  sentiment?: unknown;
+}
+/** Provider-agnostic result — the server normalizes every adapter to this. */
+interface NewsResult {
+  articles: NewsArticle[];
+  provider: string;
+}
 interface RemoteSessionInfo {
   sessionId: string;
   agentId: string;
@@ -424,23 +444,33 @@ declare class AgentApiClient {
    * Pattern A: multi-account credential fetch for cTrader.
    *
    * Unlike atlassian/salesforce (one Connection row per account/site), a
-   * single cTrader OAuth grant covers ALL of the user's trading accounts on
-   * one shared access token — only the `ctidTraderAccountId` and the
-   * protobuf socket `host` (live vs demo) differ per account. So this returns
-   * the flattened *trading accounts* array off the primary cTrader Connection
-   * (mirroring how atlassian exposes `availableSites`), with the shared app
-   * credentials (`clientId`/`clientSecret`) and the connection `accessToken`
-   * hoisted to the top level — the MCP server app-auths ONCE and account-auths
-   * per selected `ctidTraderAccountId`.
+   * cTrader is MULTI-grant per agent: an agent may connect several distinct
+   * cTrader logins, each its own Connection row keyed on `accountIdentifier =
+   * ctid:<userId>` (Phase 1). This aggregates the *trading accounts* across
+   * ALL of those Connection rows — each row contributes its `availableAccounts`
+   * flattened, and every account carries ITS OWN grant's `accessToken` (the
+   * token that authenticates that account against the cTrader Open API). One
+   * OAuth grant still covers all accounts under that single login on one shared
+   * token; only the `ctidTraderAccountId` and the protobuf socket `host` (live
+   * vs demo) differ within a grant. Across grants the tokens differ, so the
+   * token is now PER-ACCOUNT rather than hoisted to the top level.
    *
    * `host` per account is derived from the account's `isLive` flag
    * (`live.ctraderapi.com` / `demo.ctraderapi.com`) — the same mapping the
    * connect provider applies server-side when an account is auto-selected.
    *
-   * Only the primary (first, most-specific-scope) cTrader Connection is used;
-   * cTrader is single-grant, so there is normally exactly one. `clientId` /
-   * `clientSecret` are the SST-sourced global app credentials the connect
-   * endpoint injects — never persisted on the connection.
+   * `clientId` / `clientSecret` are the SST-sourced GLOBAL app credentials the
+   * connect endpoint injects — identical across every Connection row (one
+   * cTrader app), never persisted on a connection. We take them from the first
+   * row that carries them.
+   *
+   * Accounts are deduped on `ctidTraderAccountId` first-wins: Spotware ids are
+   * globally unique across logins, so a duplicate can only appear if the same
+   * account somehow surfaced under two grants — first-wins keeps it
+   * deterministic.
+   *
+   * `accounts` may be empty (no cTrader Connection at all), in which case we
+   * return empty creds rather than throwing.
    */
   getCTraderAccounts(): Promise<{
     accounts: {
@@ -449,10 +479,10 @@ declare class AgentApiClient {
       isLive: boolean;
       brokerName?: string;
       accountNumber?: string;
+      accessToken: string;
     }[];
     clientId: string;
     clientSecret: string;
-    accessToken: string;
   }>;
   /**
    * @deprecated Returns a single primary credential blob (legacy "pick-the-
@@ -491,6 +521,41 @@ declare class AgentApiClient {
       scopes: string;
     }[];
   }>;
+  /**
+   * Pattern A: provider-parameterized multi-account credential fetch for the
+   * social connectors (Bluesky, and the approval-gated backlog: X, Meta,
+   * Threads, LinkedIn, Pinterest, TikTok, Reddit, YouTube).
+   *
+   * Unlike the bespoke `getGithubAccounts()` / `getXeroAccounts()` shapes,
+   * this returns a UNIFORM normalized account shape so `@alfe.ai/social-mcp`'s
+   * shared driver can require a single `account` selector on every
+   * credential-touching tool regardless of platform. The backend
+   * `api-agents/{provider}/accounts` route is already provider-generic; this
+   * is the client-side normalization the plan (`do-we-need-any-moonlit-toucan`
+   * Phase 0, step 5) calls for.
+   *
+   * `accountIdentifier` is the stable per-account selector the LLM should
+   * pass back (for Bluesky: the account DID). `accessToken` carries whatever
+   * the provider's `buildCredentialsResponse` bundles (for Bluesky: the JSON
+   * session bundle — the driver parses the `accessJwt` out of it, or reads the
+   * top-level `accessJwt` from `providerMetadata`-adjacent fields). Everything
+   * else the driver needs for routing (handle, pdsHost, did, …) is on
+   * `providerMetadata`.
+   *
+   * Token refresh is delegated to connect (never done in-plugin) via
+   * `POST /agent/connect/{provider}/refresh` — not exposed here.
+   */
+  getSocialAccounts(provider: string): Promise<{
+    provider: string;
+    accounts: {
+      connectionId: string;
+      accountIdentifier: string;
+      displayName: string | null;
+      accessToken: string;
+      providerMetadata: Record<string, unknown>;
+      connectedAt: string;
+    }[];
+  }>;
   /**
    * @deprecated Returns a single primary credential blob (legacy "pick-the-
    * default-connection" shape). Use `getXeroAccounts()` for the multi-
@@ -1299,6 +1364,13 @@ declare class AgentApiClient {
     synced: true;
     syncedAt: string;
   }>;
+  sendSms(args: {
+    to: string;
+    body: string;
+  }): Promise<{
+    sent: boolean;
+    sid: string;
+  }>;
   searchWeb(params: {
     query: string;
     count?: number;
@@ -1315,6 +1387,25 @@ declare class AgentApiClient {
     count?: number;
     freshness?: string;
   }): Promise<unknown>;
+  /** Search news across the selected provider's corpus. → POST /agent/news/search */
+  newsSearch(params: {
+    query: string;
+    provider?: NewsProvider;
+    source?: string;
+    from?: string;
+    to?: string;
+    language?: string;
+    category?: string;
+    limit?: number;
+  }): Promise<NewsResult>;
+  /** Top headlines for the selected provider. → POST /agent/news/headlines */
+  newsHeadlines(params?: {
+    provider?: NewsProvider;
+    category?: string;
+    source?: string;
+    language?: string;
+    limit?: number;
+  }): Promise<NewsResult>;
   /**
    * Semantic search across the agent's member scopes. Fan-out is gated
    * server-side by `listScopes` set-inclusion (fail-closed). Pass
@@ -1465,6 +1556,20 @@ declare const SERVER_VERSION: string;
  * lives; consumers shouldn't have to crawl `package.json` for it.
  */
 declare const SERVER_BIN_PATH: string;
+/**
+ * Which tool surface the server exposes.
+ *
+ * - `default` (the OpenClaw daemon bundler's path — the bin is launched with
+ *   no `--profile`) registers ONLY the integrations tools. OpenClaw agents
+ *   consume this same server and already get `memory_*` from the
+ *   `@alfe.ai/openclaw-memory-cloud` plugin, so registering memory here would
+ *   DOUBLE their tool surface. Do not add tools to this profile without
+ *   confirming they don't already ship as an OpenClaw plugin.
+ * - `claude-code` additionally registers memory + voice + messaging tools —
+ *   for a Claude Code session that has no Alfe plugins and needs those
+ *   capabilities delivered via MCP.
+ */
+type ServerProfile = 'default' | 'claude-code';
 interface ServerOptions {
   /**
    * Optional override for the API client — tests inject a fake so the
@@ -1478,6 +1583,20 @@ interface ServerOptions {
   };
   /** Override apiUrl reported in the ToolContext. Defaults to the resolved CLI config. */
   apiUrl?: string;
+  /**
+   * Tool surface to register. Defaults to `default` (integrations only) so
+   * the OpenClaw bundler path is unchanged. `claude-code` adds memory + voice
+   * + messaging.
+   */
+  profile?: ServerProfile;
+  /**
+   * Optional override for the voice-service client — tests inject a fake.
+   * Only consumed by the `claude-code` profile's voice tools. When omitted
+   * (and not resolvable from config) the voice tools fall back to `client`.
+   */
+  voiceClient?: AgentApiClient;
+  /** Override voice-service apiUrl. Defaults to the resolved CLI config's `voiceServiceUrl`. */
+  voiceApiUrl?: string;
 }
 /**
  * Build a configured `McpServer` with all thin-slice tools registered.
@@ -1489,15 +1608,24 @@ interface ServerOptions {
  * `~/.alfe/config.toml`.
  */
 declare function createServer(opts?: ServerOptions): Promise<McpServer>;
+/**
+ * Parse the server profile out of a raw argv slice. Accepts both
+ * `--profile claude-code` and `--profile=claude-code`. Unknown or missing
+ * values resolve to `default`, so the OpenClaw bundler (which launches the
+ * bin with no args) always gets the integrations-only surface.
+ */
+declare function parseProfileArg(argv: string[]): ServerProfile;
 /**
  * Entry point — boot the server on stdio. Used by `bin.ts`. Any
  * startup failure is fatal: log and exit non-zero so the bundler's
  * connection attempt surfaces a clear error rather than a hung
  * handshake.
  */
-declare function main(): Promise<void>;
+declare function main(opts?: {
+  profile?: ServerProfile;
+}): Promise<void>;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { SERVER_BIN_PATH, SERVER_NAME, SERVER_VERSION, ServerOptions, createServer, main };
+export { SERVER_BIN_PATH, SERVER_NAME, SERVER_VERSION, ServerOptions, ServerProfile, createServer, main, parseProfileArg };
 //# sourceMappingURL=index.d.cts.map