@socialproof/memory-mcp 0.1.1

package/dist/signers.js

@@ -0,0 +1,323 @@
+import { createPrivateKey, createPublicKey, sign as nodeSign, } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { Ed25519Keypair } from "@socialproof/myso/keypairs/ed25519";
+import { McpRuntimeError } from "./errors.js";
+export class KmsSessionAgentSigner {
+    policy;
+    provider;
+    authorizer;
+    kind = "kms-session";
+    keyId;
+    active = true;
+    constructor(policy, provider, authorizer) {
+        this.policy = policy;
+        this.provider = provider;
+        this.authorizer = authorizer;
+        if (!policy.sessionId.trim() || !policy.keyId.trim()) {
+            throw new McpRuntimeError("INVALID_CONFIGURATION", "KMS session and key identifiers are required.");
+        }
+        if (!/^0x[0-9a-fA-F]{1,64}$/.test(policy.expectedAddress)) {
+            throw new McpRuntimeError("INVALID_CONFIGURATION", "KMS session expectedAddress is invalid.");
+        }
+        this.keyId = policy.keyId;
+    }
+    async getPublicKey() {
+        await this.guard("http-auth");
+        const key = Uint8Array.from(await this.provider.getPublicKey(this.keyId));
+        if (key.byteLength !== 32) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "KMS returned an invalid Ed25519 public key.");
+        }
+        return key;
+    }
+    async sign(message) {
+        await this.guard("http-auth");
+        const signature = Uint8Array.from(await this.provider.signEd25519(this.keyId, message.slice()));
+        if (signature.byteLength !== 64) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "KMS returned an invalid Ed25519 signature.");
+        }
+        return signature;
+    }
+    async getMySoAddress() {
+        await this.guard("http-auth");
+        return this.policy.expectedAddress;
+    }
+    async signTransaction(transactionBytes) {
+        await this.guard("transaction");
+        const signature = await this.provider.signTransaction(this.keyId, transactionBytes.slice());
+        if (typeof signature !== "string" || !signature.trim()) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "KMS returned an invalid transaction signature.");
+        }
+        return signature;
+    }
+    destroy() {
+        this.active = false;
+    }
+    async guard(operation) {
+        if (!this.active) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "The KMS signing session has been destroyed.");
+        }
+        if (Date.now() >= this.policy.expiresAtMs) {
+            throw new McpRuntimeError("AUTHENTICATION_FAILED", "The KMS signing session expired.");
+        }
+        await this.authorizer.assertActive(this.policy, operation);
+    }
+}
+/** HTTP adapter for a private KMS/HSM signing service. No private key is returned. */
+export class RemoteKmsSigningProvider {
+    options;
+    baseUrl;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        if (!this.baseUrl.startsWith("https://") && !this.baseUrl.startsWith("http://localhost")) {
+            throw new McpRuntimeError("INVALID_CONFIGURATION", "Remote KMS must use HTTPS.");
+        }
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+    }
+    async getPublicKey(keyId) {
+        const response = await this.request(`/v1/keys/${encodeURIComponent(keyId)}/public-key`, {});
+        return decodeBase64Field(response, "publicKey");
+    }
+    async signEd25519(keyId, message) {
+        const response = await this.request(`/v1/keys/${encodeURIComponent(keyId)}/sign`, {
+            purpose: "http-auth",
+            message: Buffer.from(message).toString("base64"),
+        });
+        return decodeBase64Field(response, "signature");
+    }
+    async signTransaction(keyId, transactionBytes) {
+        const response = await this.request(`/v1/keys/${encodeURIComponent(keyId)}/sign`, {
+            purpose: "myso-transaction",
+            transactionBytes: Buffer.from(transactionBytes).toString("base64"),
+        });
+        if (typeof response.signature !== "string" || !response.signature.trim()) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "Remote KMS response omitted signature.");
+        }
+        return response.signature;
+    }
+    async request(pathname, body) {
+        const token = await this.options.bearerToken();
+        const response = await this.fetchImpl(`${this.baseUrl}${pathname}`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", `Remote KMS rejected signing (${response.status}).`);
+        }
+        return response.json();
+    }
+}
+export class HttpKmsSessionAuthorizer {
+    options;
+    baseUrl;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+    }
+    async assertActive(policy, operation) {
+        const token = await this.options.bearerToken();
+        const response = await this.fetchImpl(`${this.baseUrl}/v1/signer-sessions/${encodeURIComponent(policy.sessionId)}/authorize`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+            body: JSON.stringify({
+                operation,
+                keyId: policy.keyId,
+                accountId: policy.accountId,
+                agentObjectId: policy.agentObjectId,
+            }),
+        });
+        if (!response.ok) {
+            throw new McpRuntimeError("AUTHENTICATION_FAILED", "KMS session is revoked or unauthorized.");
+        }
+        const result = await response.json();
+        if (result.active !== true || !Number.isSafeInteger(result.expiresAtMs) || result.expiresAtMs <= Date.now()) {
+            throw new McpRuntimeError("AUTHENTICATION_FAILED", "KMS session is inactive or expired.");
+        }
+    }
+}
+function decodeBase64Field(value, field) {
+    const encoded = value[field];
+    if (typeof encoded !== "string" || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) {
+        throw new McpRuntimeError("SIGNER_UNAVAILABLE", `Remote KMS response omitted ${field}.`);
+    }
+    return Uint8Array.from(Buffer.from(encoded, "base64"));
+}
+const ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+function decodeSecret(value, source) {
+    const normalized = value.trim().replace(/^0x/, "");
+    if (!/^[0-9a-fA-F]{64}$/.test(normalized)) {
+        throw new McpRuntimeError("INVALID_CONFIGURATION", `${source} must contain exactly one 32-byte Ed25519 secret encoded as hex.`);
+    }
+    return Uint8Array.from(Buffer.from(normalized, "hex"));
+}
+function privateKeyFromSeed(seed) {
+    return createPrivateKey({
+        key: Buffer.concat([ED25519_PKCS8_PREFIX, Buffer.from(seed)]),
+        format: "der",
+        type: "pkcs8",
+    });
+}
+export class LocalEd25519Signer {
+    kind;
+    keyId;
+    secretKey;
+    privateKey;
+    publicKey;
+    constructor(kind, keyId, secretKey) {
+        if (secretKey.byteLength !== 32) {
+            throw new McpRuntimeError("INVALID_CONFIGURATION", "Ed25519 signers require a 32-byte secret.");
+        }
+        this.kind = kind;
+        this.keyId = keyId;
+        this.secretKey = secretKey.slice();
+        this.privateKey = privateKeyFromSeed(this.secretKey);
+        const der = createPublicKey(this.privateKey).export({ format: "der", type: "spki" });
+        this.publicKey = Uint8Array.from(Buffer.from(der).subarray(-32));
+    }
+    async getPublicKey() {
+        this.assertActive();
+        return this.publicKey.slice();
+    }
+    async sign(message) {
+        this.assertActive();
+        return Uint8Array.from(nodeSign(null, Buffer.from(message), this.privateKey));
+    }
+    async withLocalSecret(callback) {
+        this.assertActive();
+        const temporary = this.secretKey.slice();
+        try {
+            return await callback(temporary);
+        }
+        finally {
+            temporary.fill(0);
+        }
+    }
+    async getMySoAddress() {
+        return this.withLocalSecret((secret) => Ed25519Keypair.fromSecretKey(secret).toMySoAddress());
+    }
+    async signTransaction(transactionBytes) {
+        return this.withLocalSecret(async (secret) => {
+            const keypair = Ed25519Keypair.fromSecretKey(secret);
+            const signed = await keypair.signTransaction(transactionBytes.slice());
+            return signed.signature;
+        });
+    }
+    destroy() {
+        this.secretKey?.fill(0);
+        this.publicKey.fill(0);
+        this.secretKey = null;
+        this.privateKey = null;
+    }
+    assertActive() {
+        if (!this.secretKey || !this.privateKey) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "The configured signer has been destroyed.");
+        }
+    }
+}
+export class InjectedAgentSigner {
+    kind = "injected";
+    keyId;
+    callbacks;
+    constructor(callbacks) {
+        if (!callbacks.keyId.trim()) {
+            throw new McpRuntimeError("INVALID_CONFIGURATION", "Injected signer keyId is required.");
+        }
+        this.keyId = callbacks.keyId;
+        this.callbacks = callbacks;
+    }
+    async getPublicKey() {
+        const key = Uint8Array.from(await this.callbacks.getPublicKey());
+        if (key.byteLength !== 32) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "Injected signer returned an invalid public key.");
+        }
+        return key;
+    }
+    async sign(message) {
+        const signature = Uint8Array.from(await this.callbacks.sign(message.slice()));
+        if (signature.byteLength !== 64) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "Injected signer returned an invalid signature.");
+        }
+        return signature;
+    }
+    async getMySoAddress() {
+        const address = await this.callbacks.getMySoAddress();
+        if (!/^0x[0-9a-fA-F]{1,64}$/.test(address)) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "Injected signer returned an invalid MySo address.");
+        }
+        return address;
+    }
+    async signTransaction(transactionBytes) {
+        const signature = await this.callbacks.signTransaction(transactionBytes.slice());
+        if (typeof signature !== "string" || !signature.trim()) {
+            throw new McpRuntimeError("SIGNER_UNAVAILABLE", "Injected signer returned an invalid transaction signature.");
+        }
+        return signature;
+    }
+    destroy() {
+        this.callbacks.destroy?.();
+    }
+}
+function expandHome(filePath) {
+    return filePath === "~" || filePath.startsWith("~/")
+        ? path.join(os.homedir(), filePath.slice(2))
+        : filePath;
+}
+function loadDevelopmentSecret(reference) {
+    if (process.env.MEMORY_MCP_ALLOW_INSECURE_DEV_FILE !== "1") {
+        throw new McpRuntimeError("INVALID_CONFIGURATION", "Development-file signing is disabled. Set MEMORY_MCP_ALLOW_INSECURE_DEV_FILE=1 only for local development.");
+    }
+    const resolved = path.resolve(expandHome(reference.path));
+    let stat;
+    try {
+        stat = fs.lstatSync(resolved);
+    }
+    catch (error) {
+        throw new McpRuntimeError("SIGNER_UNAVAILABLE", "The configured development signer file could not be read.", { cause: error });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new McpRuntimeError("INVALID_CONFIGURATION", "The development signer path must be a regular file.");
+    }
+    if ((stat.mode & 0o077) !== 0) {
+        throw new McpRuntimeError("INVALID_CONFIGURATION", "The development signer file must have mode 0600 or stricter.");
+    }
+    return decodeSecret(fs.readFileSync(resolved, "utf8"), "Development signer file");
+}
+function loadKeychainSecret(reference) {
+    if (process.platform !== "darwin") {
+        throw new McpRuntimeError("SIGNER_UNAVAILABLE", "macOS Keychain signing is available only on macOS; inject a signer on other platforms.");
+    }
+    try {
+        const value = execFileSync("/usr/bin/security", ["find-generic-password", "-w", "-s", reference.service, "-a", reference.account], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        return decodeSecret(value, "Keychain item");
+    }
+    catch (error) {
+        if (error instanceof McpRuntimeError)
+            throw error;
+        throw new McpRuntimeError("SIGNER_UNAVAILABLE", `No usable macOS Keychain item was found for service ${reference.service} and account ${reference.account}.`, { cause: error });
+    }
+}
+export function createCliSigner(reference) {
+    if (reference.type === "keychain") {
+        const secret = loadKeychainSecret(reference);
+        try {
+            return new LocalEd25519Signer("keychain", `${reference.service}/${reference.account}`, secret);
+        }
+        finally {
+            secret.fill(0);
+        }
+    }
+    const secret = loadDevelopmentSecret(reference);
+    try {
+        return new LocalEd25519Signer("development-file", path.resolve(expandHome(reference.path)), secret);
+    }
+    finally {
+        secret.fill(0);
+    }
+}

package/dist/social-gateway.d.ts

@@ -0,0 +1,195 @@
+import { type SocialActionId, type SocialChainConfig, type EditCommentParams, type EditPostParams, type ProfileRelationParams, type RemoveCommentReactionParams, type RemovePostReactionParams, type RemoveRepostParams, type SendMessageParams, type CreateMessagingGroupParams, type OrganizationInvitationDecisionParams, type RegisterChildAgentParams, type UpdateManagedAgentParams, type ManagedAgentParams } from "@socialproof/social";
+import type { AgentSigner } from "./signers.js";
+export interface CreatePostInput {
+    content: string;
+    idempotencyKey: string;
+}
+export interface CreateCommentInput {
+    postId: string;
+    content: string;
+    parentCommentId?: string;
+    idempotencyKey: string;
+}
+export interface ReactToPostInput {
+    postId: string;
+    reaction: string;
+    idempotencyKey: string;
+}
+export interface ReactToCommentInput {
+    commentId: string;
+    reaction: string;
+    idempotencyKey: string;
+}
+export interface CreateRepostInput {
+    originalPostId: string;
+    content?: string;
+    idempotencyKey: string;
+}
+export interface DeleteCommentInput {
+    postId: string;
+    commentId: string;
+}
+type IdempotentInput<T> = T & {
+    idempotencyKey: string;
+};
+export interface ActionApprovalInput {
+    registryAction: SocialActionId;
+    parameters: unknown;
+    idempotencyKey: string;
+    expiresInSeconds?: number;
+}
+export interface ActionApprovalDecisionInput {
+    approvalId: string;
+    walletSignature: string;
+}
+export interface ApprovedActionPrepareInput extends ActionApprovalInput {
+    approvalId: string;
+}
+export interface ApprovedActionSubmitInput {
+    registryAction: SocialActionId;
+    idempotencyKey: string;
+    approvalId: string;
+    digest: string;
+    walletSignature: string;
+}
+export interface SocialGateway {
+    readonly supportedToolNames: readonly string[];
+    listActions(): Promise<unknown>;
+    createPost(input: CreatePostInput): Promise<unknown>;
+    createComment(input: CreateCommentInput): Promise<unknown>;
+    reactToPost(input: ReactToPostInput): Promise<unknown>;
+    reactToComment(input: ReactToCommentInput): Promise<unknown>;
+    createRepost(input: CreateRepostInput): Promise<unknown>;
+    removePostReaction(input: IdempotentInput<RemovePostReactionParams>): Promise<unknown>;
+    removeCommentReaction(input: IdempotentInput<RemoveCommentReactionParams>): Promise<unknown>;
+    editPost(input: IdempotentInput<EditPostParams>): Promise<unknown>;
+    editComment(input: IdempotentInput<EditCommentParams>): Promise<unknown>;
+    removeRepost(input: IdempotentInput<RemoveRepostParams>): Promise<unknown>;
+    followProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    unfollowProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    blockProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    unblockProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    sendMessage(input: IdempotentInput<SendMessageParams>): Promise<unknown>;
+    createMessagingGroup(input: IdempotentInput<CreateMessagingGroupParams>): Promise<unknown>;
+    acceptOrganizationInvitation(input: IdempotentInput<OrganizationInvitationDecisionParams>): Promise<unknown>;
+    declineOrganizationInvitation(input: IdempotentInput<OrganizationInvitationDecisionParams>): Promise<unknown>;
+    registerChildAgent(input: IdempotentInput<Omit<RegisterChildAgentParams, "parentAgentObjectId"> & {
+        parentAgentObjectId?: string;
+    }>): Promise<unknown>;
+    updateChildAgent(input: IdempotentInput<UpdateManagedAgentParams>): Promise<unknown>;
+    deactivateChildAgent(input: IdempotentInput<ManagedAgentParams>): Promise<unknown>;
+    revokeChildAgent(input: IdempotentInput<ManagedAgentParams>): Promise<unknown>;
+    getOrganizationControl(organizationId: string): Promise<unknown>;
+    listInbox(input: {
+        limit?: number;
+        offset?: number;
+        groupId?: string;
+        afterCreatedAtMs?: number;
+        afterSeq?: number;
+    }): Promise<unknown>;
+    waitForMessage(input: {
+        timeoutMs?: number;
+        groupId?: string;
+        afterCreatedAtMs?: number;
+        afterSeq?: number;
+    }): Promise<unknown>;
+    deletePost(postId: string): Promise<unknown>;
+    deleteComment(input: DeleteCommentInput): Promise<unknown>;
+    getActionStatus(digest: string): Promise<unknown>;
+    requestActionApproval(input: ActionApprovalInput): Promise<unknown>;
+    approveAction(input: ActionApprovalDecisionInput): Promise<unknown>;
+    prepareApprovedAction(input: ApprovedActionPrepareInput): Promise<unknown>;
+    submitApprovedAction(input: ApprovedActionSubmitInput): Promise<unknown>;
+}
+type MySoNetwork = "mainnet" | "testnet" | "devnet" | "localnet";
+export interface AuthenticatedSocialExecutionContext {
+    network: MySoNetwork;
+    rpcUrl: string;
+    chain: SocialChainConfig;
+}
+export interface SponsoredSocialGatewayOptions {
+    signer: AgentSigner;
+    accountId: string;
+    serverUrl: string;
+    platformId?: string;
+    /** Optional deployment pin checked against authenticated agent context. */
+    network?: MySoNetwork;
+    /** Optional deployment pin checked against authenticated agent context. */
+    rpcUrl?: string;
+    /** Optional object-id pins checked against authenticated agent context. */
+    chain?: Partial<SocialChainConfig>;
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * Executes only hard-coded, versioned Tier 1A/1B action-registry entries.
+ * There is no arbitrary action name, Move target, PTB, or direct-sign fallback
+ * in the public MCP path. Tier 3 owner actions remain disabled until the
+ * wallet-approval workflow is available.
+ */
+export declare class SponsoredSocialGateway implements SocialGateway {
+    readonly supportedToolNames: readonly ["chain_list_actions", "social_create_post", "social_create_comment", "social_react_post", "social_react_comment", "social_create_repost", "social_remove_post_reaction", "social_remove_comment_reaction", "social_edit_post", "social_edit_comment", "social_remove_repost", "social_follow_profile", "social_unfollow_profile", "social_block_profile", "social_unblock_profile", "messaging_send_message", "messaging_create_group", "messaging_list_inbox", "messaging_wait_for_message", "organization_get_control", "organization_accept_invitation", "organization_decline_invitation", "agent_register_child", "agent_update_child", "agent_deactivate_child", "agent_revoke_child", "organization_create", "organization_update_metadata", "organization_update_category", "organization_deactivate", "organization_ensure_memory_group", "organization_define_role", "organization_assign_role", "organization_revoke_role", "organization_create_invitation", "agent_provision_signer", "agent_register_root", "chain_get_action_status", "chain_request_action_approval", "chain_approve_action", "chain_prepare_approved_action", "chain_submit_approved_action"];
+    private readonly signer;
+    private readonly accountId;
+    private readonly serverUrl;
+    private platformId?;
+    private readonly networkPin?;
+    private readonly rpcUrlPin?;
+    private readonly chainPins?;
+    private readonly fetchImpl;
+    constructor(options: SponsoredSocialGatewayOptions);
+    listActions(): Promise<unknown>;
+    reactToPost(input: ReactToPostInput): Promise<unknown>;
+    createPost(input: CreatePostInput): Promise<unknown>;
+    createComment(input: CreateCommentInput): Promise<unknown>;
+    reactToComment(input: ReactToCommentInput): Promise<unknown>;
+    createRepost(input: CreateRepostInput): Promise<unknown>;
+    private executeInput;
+    removePostReaction(input: IdempotentInput<RemovePostReactionParams>): Promise<unknown>;
+    removeCommentReaction(input: IdempotentInput<RemoveCommentReactionParams>): Promise<unknown>;
+    editPost(input: IdempotentInput<EditPostParams>): Promise<unknown>;
+    editComment(input: IdempotentInput<EditCommentParams>): Promise<unknown>;
+    removeRepost(input: IdempotentInput<RemoveRepostParams>): Promise<unknown>;
+    followProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    unfollowProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    blockProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    unblockProfile(input: IdempotentInput<ProfileRelationParams>): Promise<unknown>;
+    sendMessage(input: IdempotentInput<SendMessageParams>): Promise<unknown>;
+    createMessagingGroup(input: IdempotentInput<CreateMessagingGroupParams>): Promise<unknown>;
+    acceptOrganizationInvitation(input: IdempotentInput<OrganizationInvitationDecisionParams>): Promise<unknown>;
+    declineOrganizationInvitation(input: IdempotentInput<OrganizationInvitationDecisionParams>): Promise<unknown>;
+    registerChildAgent(input: IdempotentInput<Omit<RegisterChildAgentParams, "parentAgentObjectId"> & {
+        parentAgentObjectId?: string;
+    }>): Promise<unknown>;
+    updateChildAgent(input: IdempotentInput<UpdateManagedAgentParams>): Promise<unknown>;
+    deactivateChildAgent(input: IdempotentInput<ManagedAgentParams>): Promise<unknown>;
+    revokeChildAgent(input: IdempotentInput<ManagedAgentParams>): Promise<unknown>;
+    getOrganizationControl(organizationId: string): Promise<unknown>;
+    listInbox(input: {
+        limit?: number;
+        offset?: number;
+        groupId?: string;
+        afterCreatedAtMs?: number;
+        afterSeq?: number;
+    }): Promise<unknown>;
+    waitForMessage(input: {
+        timeoutMs?: number;
+        groupId?: string;
+        afterCreatedAtMs?: number;
+        afterSeq?: number;
+    }): Promise<unknown>;
+    deletePost(_postId: string): Promise<unknown>;
+    deleteComment(_input: DeleteCommentInput): Promise<unknown>;
+    getActionStatus(digest: string): Promise<unknown>;
+    requestActionApproval(input: ActionApprovalInput): Promise<unknown>;
+    approveAction(input: ActionApprovalDecisionInput): Promise<unknown>;
+    prepareApprovedAction(input: ApprovedActionPrepareInput): Promise<unknown>;
+    submitApprovedAction(input: ApprovedActionSubmitInput): Promise<unknown>;
+    private validateApprovalInput;
+    private assertActionInAuthenticatedCatalog;
+    private executeRegisteredAction;
+    private approvalUnavailable;
+    private ensureDeploymentPlatform;
+    private signedJson;
+    private requestJson;
+}
+export {};