@alfe.ai/mcp-server 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,777 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ChangelogEntry, EncryptedEnvelopeV1, FieldEnvelope, FieldFormat, FieldSensitivity, GeneratedDataKey, IntegrationConfigResult, IntegrationInstall, RegistryEntry, ScopeInfo, SecretAggregate, SecretCategory, SecretMetadata, SecretScope } from "@alfe/types";
+
+//#region ../agent-api-client/dist/index.d.ts
+//#region src/index.d.ts
+interface AgentApiClientConfig {
+  apiKey: string;
+  apiUrl: string;
+}
+interface SyncAgentInfo {
+  agentId: string;
+  tenantId: string;
+  displayName: string;
+  s3Prefix: string;
+  status: "stale" | "syncing" | "synced";
+  fileCount?: number;
+  totalSize?: number;
+  lastSync?: string;
+}
+interface SyncManifestEntry {
+  hash: string;
+  size: number;
+  modified: string;
+  etag?: string;
+  storageClass?: string;
+  compressed?: boolean;
+}
+interface SyncManifest {
+  version: 1;
+  agentId: string;
+  lastSync: string;
+  files: Record<string, SyncManifestEntry>;
+}
+interface SyncPresignedUrl {
+  path: string;
+  url: string;
+  expiresAt: string;
+}
+interface SyncConfirmedUpload {
+  filePath: string;
+  hash: string;
+  size: number;
+  storageClass: "STANDARD" | "GLACIER_IR";
+  syncedAt: string;
+}
+interface SyncReconstructFile {
+  path: string;
+  size: number;
+  url: string;
+  storageClass?: string;
+  compressed?: boolean;
+}
+interface SyncReconstructBundle {
+  agentId: string;
+  mode: "full" | "active" | "memory";
+  fileCount: number;
+  totalSize: number;
+  files: SyncReconstructFile[];
+  expiresAt: string;
+}
+interface SyncAgentStats {
+  agentId: string;
+  standardBytes: number;
+  glacierBytes: number;
+  fileCount: number;
+  lastSyncAt: string | null;
+}
+interface SyncFileEntry {
+  filePath: string;
+  size: number;
+  modified: string;
+  contentHash: string;
+  storageClass?: string;
+  compressed?: boolean;
+}
+interface SyncSessionEntry {
+  sessionId: string;
+  size: number;
+  lastModified: string;
+  storageClass?: string;
+  isArchived: boolean;
+}
+interface SyncSessionContent {
+  sessionId: string;
+  content: string;
+  compressed: boolean;
+}
+interface SharedFileEntry {
+  filePath: string;
+  fileName: string;
+  size: number;
+  contentType?: string;
+}
+declare class AgentApiClient {
+  private readonly apiKey;
+  private readonly apiUrl;
+  constructor(config: AgentApiClientConfig);
+  private request;
+  syncRegister(args?: {
+    displayName?: string;
+  }): Promise<{
+    agent: SyncAgentInfo;
+  }>;
+  syncGetManifest(): Promise<SyncManifest>;
+  syncPresign(args: {
+    files: {
+      path: string;
+      operation: "put" | "get";
+      contentType?: string;
+    }[];
+  }): Promise<{
+    urls: SyncPresignedUrl[];
+  }>;
+  syncConfirmUpload(args: {
+    filePath: string;
+    hash: string;
+    size: number;
+    storageClass?: "STANDARD" | "GLACIER_IR";
+  }): Promise<SyncConfirmedUpload>;
+  syncReconstruct(args: {
+    mode: "full" | "active" | "memory";
+  }): Promise<SyncReconstructBundle>;
+  syncGetStats(): Promise<SyncAgentStats>;
+  syncListFiles(args?: {
+    prefix?: string;
+  }): Promise<{
+    files: SyncFileEntry[];
+  }>;
+  syncListSessions(): Promise<{
+    sessions: SyncSessionEntry[];
+  }>;
+  syncGetSession(sessionId: string): Promise<SyncSessionContent>;
+  syncDeleteFile(filePath: string): Promise<{
+    removed: boolean;
+  }>;
+  sharedListFiles(args: {
+    scope: "org" | "team" | "project";
+    scopeId: string;
+  }): Promise<{
+    files: SharedFileEntry[];
+    nextCursor: string | null;
+  }>;
+  sharedDownloadUrl(args: {
+    scope: "org" | "team" | "project";
+    scopeId: string;
+    filePath: string;
+  }): Promise<{
+    downloadUrl: string;
+    expiresIn: number;
+  }>;
+  listIntegrations(): Promise<IntegrationInstall[]>;
+  getIntegrationConfig(integrationId: string): Promise<IntegrationConfigResult>;
+  updateIntegrationConfig(integrationId: string, config: Record<string, unknown>): Promise<void>;
+  installIntegration(integrationId: string, options?: {
+    version?: string;
+    config?: Record<string, unknown>;
+  }): Promise<IntegrationInstall>;
+  removeIntegration(integrationId: string): Promise<IntegrationInstall>;
+  getOAuthUrl(provider: string, scopes?: string[]): Promise<{
+    url: string;
+    provider: string;
+    expiresIn: number;
+  }>;
+  getOAuthStatus(provider: string): Promise<{
+    provider: string;
+    connected: boolean;
+    config?: Record<string, string>;
+  }>;
+  getRegistry(): Promise<{
+    integrations: RegistryEntry[];
+  }>;
+  /**
+   * Returns every connected Google account for the agent. Multi-account by
+   * design — the openclaw-google plugin requires the LLM to pass `email`
+   * explicitly to `google_run_command` so an account is always selected
+   * deliberately.
+   *
+   * 2026-05-14 (connections-redesign PR 1): the legacy flat shape (`email`,
+   * `refreshToken`, `accessToken`, etc., populated from the default account)
+   * is gone. Iterate over `accounts`.
+   */
+  getGoogleCredentials(): Promise<{
+    accounts: {
+      email: string;
+      refreshToken: string;
+      clientId: string;
+      clientSecret: string;
+      displayName?: string;
+      connectedAt?: string;
+    }[];
+  }>;
+  disconnectGoogleAccount(email: string): Promise<{
+    accounts: {
+      email: string;
+      displayName?: string;
+      connectedAt?: string;
+    }[];
+  }>;
+  getGoogleChatCredentials(): Promise<{
+    email: string;
+    refreshToken: string;
+    clientId: string;
+    clientSecret: string;
+    displayName?: string;
+  }>;
+  getGithubCredentials(): Promise<{
+    login: string;
+    accessToken: string;
+  }>;
+  getXeroCredentials(): Promise<{
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    xeroTenantId: string;
+  }>;
+  refreshXeroToken(): Promise<{
+    accessToken: string;
+    expiresAt: string;
+  }>;
+  getNotionCredentials(): Promise<{
+    accessToken: string;
+    workspaceId: string;
+    workspaceName: string;
+  }>;
+  getAtlassianCredentials(): Promise<{
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpiresAt: string;
+    cloudId: string;
+    siteName: string;
+    siteUrl: string;
+    email: string;
+    enabledProducts: string[];
+    clientId: string;
+    clientSecret: string;
+  }>;
+  refreshAtlassianToken(): Promise<{
+    accessToken: string;
+    expiresAt: string;
+  }>;
+  getMYOBCredentials(): Promise<{
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    myobBusinessId: string;
+    clientId: string;
+  }>;
+  refreshMYOBToken(): Promise<{
+    accessToken: string;
+    expiresAt: string;
+  }>;
+  getTeamsCredentials(): Promise<{
+    agentId: string;
+    tenantId: string;
+    azureAppId: string;
+    azureBotId: string;
+    azureClientSecret: string;
+    botDisplayName?: string;
+    teamsTenantId?: string;
+    serviceUrl?: string;
+  }>;
+  sendTeamsMessage(data: {
+    conversationId: string;
+    text?: string;
+    adaptiveCard?: Record<string, unknown>;
+  }): Promise<{
+    ok: boolean;
+    activityId: string;
+  }>;
+  listTeamsChannels(): Promise<{
+    channels: {
+      id: string;
+      name: string;
+      description?: string;
+    }[];
+  }>;
+  presignAttachments(files: {
+    filename: string;
+    mimeType: string;
+    size: number;
+  }[]): Promise<{
+    attachments: {
+      id: string;
+      uploadUrl: string;
+      downloadUrl: string;
+      s3Key: string;
+      expiresAt: string;
+    }[];
+  }>;
+  recordActivity(data: {
+    userId?: string;
+    channel: string;
+    role: "user" | "assistant";
+  }): Promise<{
+    recorded: boolean;
+  }>;
+  /**
+   * Mint a fresh AES-256 data key for a specific (secret, field) pair. The
+   * encryption context is rebuilt server-side from `auth.tenantId` + the body
+   * fields including `fieldKey`; the agent cannot forge context for a scope
+   * or field it doesn't own. Legacy single-envelope secrets are migrated to
+   * `field#value` rows by the data migration, so call with `fieldKey: "value"`
+   * to reach them.
+   */
+  generateSecretDataKey(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    fieldKey: string;
+  }): Promise<GeneratedDataKey>;
+  /**
+   * Unwrap a wrapped data key so the agent can decrypt the envelope locally.
+   * `fieldKey` MUST match the value supplied when the data key was generated
+   * (it's bound into KMS encryption context); mismatch fails with
+   * `InvalidCiphertextException`.
+   */
+  decryptSecretDataKey(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    fieldKey: string;
+    dataKeyCiphertext: string;
+  }): Promise<{
+    plaintextKey: string;
+  }>;
+  /**
+   * Create a new secret with one or more fields. Encrypted fields must arrive
+   * pre-sealed (the agent has already obtained per-field data keys via
+   * `generateSecretDataKey({ ..., fieldKey })` and AES-encrypted locally).
+   * Plaintext fields ship the value inline.
+   */
+  createSecret(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    secretName: string;
+    category?: SecretCategory;
+    description?: string;
+    tags?: string[];
+    fields: {
+      key: string;
+      format?: FieldFormat;
+      sensitivity: FieldSensitivity;
+      value?: string;
+      envelope?: EncryptedEnvelopeV1;
+    }[];
+    reason?: string;
+  }): Promise<SecretAggregate>;
+  /** Fetch the secret aggregate plus per-field encrypted envelopes. */
+  getSecret(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+  }): Promise<{
+    aggregate: SecretAggregate;
+    envelopes: FieldEnvelope[];
+  }>;
+  /** Fetch one field. Plaintext: value inline. Encrypted: envelope. */
+  getSecretField(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    fieldKey: string;
+  }): Promise<{
+    key: string;
+    sensitivity: FieldSensitivity;
+    format?: FieldFormat;
+    value?: string;
+    envelope?: EncryptedEnvelopeV1;
+    rotatedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /** Add OR rotate one field. */
+  setSecretField(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    fieldKey: string;
+    sensitivity: FieldSensitivity;
+    format?: FieldFormat;
+    value?: string;
+    envelope?: EncryptedEnvelopeV1;
+    reason?: string;
+  }): Promise<{
+    fieldKey: string;
+    rotated: boolean;
+  }>;
+  /** Remove one field. */
+  removeSecretField(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    fieldKey: string;
+  }): Promise<void>;
+  /** Update secret-level metadata (name/description/tags/category). */
+  updateSecretMetadata(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    secretName?: string;
+    description?: string;
+    tags?: string[];
+    category?: SecretCategory;
+    reason?: string;
+  }): Promise<SecretAggregate>;
+  /** List metadata for secrets in a scope. Optional filters route through the byFacet GSI. */
+  listSecrets(args: {
+    scope: SecretScope;
+    scopeId: string;
+    category?: SecretCategory;
+    tag?: string;
+    fieldKey?: string;
+  }): Promise<SecretMetadata[]>;
+  /** Bounded changelog read — metadata-only audit entries. */
+  getSecretHistory(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<{
+    entries: ChangelogEntry[];
+    nextCursor?: string;
+  }>;
+  /** Delete a secret (and all its field rows + tag rows + changelog rows). */
+  deleteSecret(args: {
+    scope: SecretScope;
+    scopeId: string;
+    secretId: string;
+  }): Promise<void>;
+  /** Enumerate scopes (org/team/project/agent) this agent can access. */
+  listSecretScopes(): Promise<ScopeInfo[]>;
+  /**
+   * Returns the calling agent's own identity context — `{ agentId, tenantId }`
+   * decoded server-side from the agent API token. Used by the
+   * `@alfe.ai/openclaw-identity` plugin to bootstrap context when the
+   * OpenClaw daemon doesn't plumb `ctx.agentId` through to plugin hooks.
+   * Plugins should cache this for the daemon's lifetime (single-agent-per-
+   * process invariant). One HTTP round-trip per process activate; not for
+   * per-call use.
+   */
+  whoami(): Promise<{
+    agentId: string;
+    tenantId: string;
+  }>;
+  resolveIdentity(args: {
+    provider: string;
+    platformId: string;
+    kind?: "user" | "agent" | "service" | "bot" | "workspace";
+    displayName?: string;
+  }): Promise<{
+    identityId: string | null;
+    status: string;
+    created?: boolean;
+    reason?: string;
+    /**
+     * Flattened auriclabs permission strings for the resolved identity
+     * (scope-prefixed where applicable). Empty array on miss / org service
+     * outage — the runtime gate fails closed in that case.
+     */
+    permissions: string[];
+  }>;
+  searchIdentities(args?: {
+    q?: string;
+    status?: string;
+    limit?: number;
+  }): Promise<{
+    identities: unknown[];
+  }>;
+  getIdentityContext(identityId: string): Promise<{
+    context: unknown;
+  }>;
+  mergeIdentities(survivorId: string, args: {
+    mergedId: string;
+    changedBy: {
+      type: string;
+      id: string;
+      name?: string;
+    };
+  }): Promise<{
+    ok: boolean;
+    error?: string;
+  }>;
+  unmergeIdentity(identityId: string, args: {
+    changedBy: {
+      type: string;
+      id: string;
+      name?: string;
+    };
+  }): Promise<{
+    ok: boolean;
+    error?: string;
+  }>;
+  addIdentityNote(identityId: string, args: {
+    content: string;
+    category?: string;
+    changedBy: {
+      type: string;
+      id: string;
+      name?: string;
+    };
+  }): Promise<{
+    noteId: string | null;
+  }>;
+  tagIdentity(identityId: string, args: {
+    tag: string;
+    action: "add" | "remove";
+    changedBy: {
+      type: string;
+      id: string;
+      name?: string;
+    };
+  }): Promise<{
+    ok: boolean;
+  }>;
+  getIdentityChangelog(identityId: string, args?: {
+    limit?: number;
+  }): Promise<{
+    entries: unknown[];
+  }>;
+  rollbackIdentity(identityId: string, args: {
+    targetVersion: number;
+    changedBy: {
+      type: string;
+      id: string;
+      name?: string;
+    };
+  }): Promise<{
+    ok: boolean;
+    entry?: unknown;
+  }>;
+  requestIdentityVerification(args: {
+    claimedIdentityId: string;
+    requestingIdentityId: string;
+    requestingProvider: string;
+    requestingPlatformId: string;
+    preferredChannel?: "mobile" | "email";
+    /**
+     * Phase 2: agent-supplied contact endpoint. When provided, the top-level
+     * `preferredChannel` is ignored — the contact's channel wins.
+     */
+    contact?: {
+      channel: "email" | "mobile";
+      value: string;
+    };
+  }): Promise<{
+    verificationId: string;
+    channel: string;
+    deliveredTo: string;
+    expiresAt: string;
+    availableChannels: {
+      channel: string;
+      deliveredTo: string;
+    }[];
+  } | {
+    error: string;
+  }>;
+  confirmIdentityVerification(args: {
+    claimedIdentityId: string;
+    verificationId: string;
+    phrase: string;
+  }): Promise<{
+    verified: boolean;
+    identityId?: string;
+    /** Phase 2: how the confirm resolved — Scenario A vs B. */
+    action?: "merged" | "contact_verified";
+    error?: string;
+  }>;
+  /**
+   * Update display-shape fields on an Identity. Body excludes `email` /
+   * `phone` / `title` / `company` / `metadata` per Section D4 — contacts go
+   * via the verify flow, title/company live on OrgMembership, metadata is
+   * not agent-writable.
+   */
+  updateIdentity(identityId: string, args: {
+    name?: string;
+    avatarUrl?: string;
+    timezone?: string;
+    locale?: string;
+  }): Promise<{
+    ok: boolean;
+  }>;
+  /**
+   * Phase 2 (Section H): server-side verification of a Google Chat sender via
+   * the agent's existing Google OAuth credentials. Returns the resolved
+   * identity (created or matched via Scenario-B email enrichment).
+   */
+  resolveGoogleChatSender(args: {
+    senderUserId: string;
+    spaceId?: string;
+  }): Promise<{
+    identityId: string | null;
+    status: string;
+  }>;
+  memorySearch(query: string, opts?: {
+    limit?: number;
+    topic?: string;
+    subtopic?: string;
+    tag?: string;
+    includeKnowledge?: boolean;
+  }): Promise<{
+    facts: {
+      subject: string;
+      predicate: string;
+      object: string;
+      since: string;
+      confidence: number;
+    }[];
+    memories: {
+      id: string;
+      text: string;
+      topic: string;
+      subtopic: string;
+      tag: string;
+      importance: number;
+      timestamp: number;
+      score: number;
+    }[];
+  }>;
+  memoryStore(text: string, opts?: {
+    topic?: string;
+    subtopic?: string;
+    tag?: string;
+    importance?: number;
+  }): Promise<{
+    memoryId: string;
+  }>;
+  memoryIngest(sessionKey: string, messages: {
+    role: string;
+    content: string;
+    index: number;
+    timestamp?: string;
+  }[], metadata?: {
+    channelId?: string;
+    userId?: string;
+    userName?: string;
+  }): Promise<{
+    queued: boolean;
+    messageCount: number;
+  }>;
+  memoryLoadContext(tier?: number, topicHint?: string): Promise<{
+    formatted: string;
+    [key: string]: unknown;
+  }>;
+  memoryLookupEntity(subject: string): Promise<{
+    subject: string;
+    triples: {
+      tripleId: string;
+      predicate: string;
+      object: string;
+      validFrom: string;
+      validTo?: string;
+      confidence: number;
+    }[];
+  }>;
+  memoryNavigate(): Promise<{
+    topics: {
+      name: string;
+      tripleCount: number;
+      subtopics: string[];
+    }[];
+    cursor: string | null;
+  }>;
+  memoryDelete(memoryId: string): Promise<{
+    deleted: boolean;
+  }>;
+  memoryStats(): Promise<{
+    vectorCount: number;
+    tripleCount: number;
+    storageEstimateBytes: number;
+    lastIngestionAt?: string;
+  }>;
+  memoryLearn(args: {
+    text: string;
+    source?: string;
+    sourceType?: "file" | "url" | "inline";
+    metadata?: {
+      sessionId?: string;
+      channelId?: string;
+      userName?: string;
+    };
+  }): Promise<{
+    memoriesStored: number;
+    triplesStored: number;
+    chunks: number;
+    source?: string;
+  }>;
+  memoryBootstrapStatus(): Promise<{
+    synced: boolean;
+    syncedAt?: string;
+  }>;
+  memoryBootstrapStatusMark(): Promise<{
+    synced: true;
+    syncedAt: string;
+  }>;
+  searchWeb(params: {
+    query: string;
+    count?: number;
+    offset?: number;
+    country?: string;
+    freshness?: string;
+  }): Promise<unknown>;
+  searchImages(params: {
+    query: string;
+    count?: number;
+  }): Promise<unknown>;
+  searchNews(params: {
+    query: string;
+    count?: number;
+    freshness?: string;
+  }): Promise<unknown>;
+  registerDatabaseCredentials(): Promise<{
+    connectionString: string;
+    username: string;
+    password: string;
+    databases: string[];
+  }>;
+  reportDatabaseAudit(entry: {
+    database: string;
+    collection: string;
+    operation: string;
+    summary?: string;
+  }): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map
+//#endregion
+//#endregion
+//#region src/index.d.ts
+/**
+ * Wire shape the bundler advertises this server as — must match the
+ * key the CLI registers (`alfe-platform`) so namespacing is consistent
+ * across components.
+ */
+declare const SERVER_NAME = "alfe-platform";
+/**
+ * Single source of truth for the server's own version, read straight
+ * from package.json so it can't drift with bumps. The CLI's
+ * version-drift hook compares this against the entry stored in
+ * `~/.alfe/mcp/servers.json` and re-resolves the command path when
+ * they diverge (e.g. after an `npm install -g @alfe.ai/cli`).
+ */
+declare const SERVER_VERSION: string;
+interface ServerOptions {
+  /**
+   * Optional override for the API client — tests inject a fake so the
+   * server can be exercised end-to-end without real network I/O.
+   */
+  client?: AgentApiClient;
+  /** Pre-resolved context fields. If omitted, the server calls `whoami()` itself. */
+  identity?: {
+    agentId: string;
+    tenantId: string;
+  };
+  /** Override apiUrl reported in the ToolContext. Defaults to the resolved CLI config. */
+  apiUrl?: string;
+}
+/**
+ * Build a configured `McpServer` with all thin-slice tools registered.
+ * Pure construction — does not connect a transport. Callers (the bin
+ * entry, or tests) attach `StdioServerTransport` or any other transport.
+ *
+ * `resolveConfig()` is only called when neither `client` nor `apiUrl`
+ * is provided — tests can fully construct the server without touching
+ * `~/.alfe/config.toml`.
+ */
+declare function createServer(opts?: ServerOptions): Promise<McpServer>;
+/**
+ * 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>;
+//# sourceMappingURL=index.d.ts.map
+
+//#endregion
+export { SERVER_NAME, SERVER_VERSION, ServerOptions, createServer, main };
+//# sourceMappingURL=index.d.ts.map