crewpay-solana-agent-kit-plugin 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CrewPay / fxams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,36 @@
-# Temporary Holding Version
+# crewpay-solana-agent-kit-plugin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Solana Agent Kit v2 plugin for [CrewPay](https://crewpay.dev).
+
+```bash
+npm i crewpay-solana-agent-kit-plugin
+```
+
+```ts
+import { SolanaAgentKit } from 'solana-agent-kit'
+import { CrewPayPlugin } from 'crewpay-solana-agent-kit-plugin'
+
+const agent = new SolanaAgentKit(wallet, rpcUrl, config).use(CrewPayPlugin)
+await agent.methods.crewDryRun({ name: 'Desk Cat', ticker: 'DCAT', autoHire: { seats: 3 } })
+// human confirms with APPROVE_SOL_SPEND…
+await agent.methods.crewLaunch({
+  name: 'Desk Cat',
+  ticker: 'DCAT',
+  autoHire: { seats: 3 },
+  dryRunToken: '<from dry-run>',
+  humanConfirmed: true,
+  confirmPhrase: 'APPROVE_SOL_SPEND',
+})
+```
+
+## Safety
+
+- Dry-run first; launch needs `dryRunToken` + `humanConfirmed: true` + `confirmPhrase: "APPROVE_SOL_SPEND"`
+- Env keys only (`CREWPAY_API_KEY` / `CREW_AGENT_API_KEY`, `CREW_LAUNCHER_KEY`)
+- Fee map **60/15/25**; buyback cron not live yet
+- Prefer MCP: `npx -y crewpay-mcp@1.2.1` or https://mcp.crewpay.dev/mcp
+
+## Links
+
+- Source: https://github.com/fxams/solana-agent-kit-plugin-crewpay
+- Upstream kit: https://github.com/sendaifun/solana-agent-kit

package/dist/client.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Minimal CrewPay REST client for framework plugins.
+ * Keys from env only — never accept private keys as function arguments.
+ *
+ * Spend gates: dry-run issues a short-lived dryRunToken; launch/wire require that
+ * token (launch) plus the exact confirmPhrase APPROVE_SOL_SPEND (not a free-form
+ * boolean the model can invent from chat alone).
+ */
+export declare const DEFAULT_API_URL = "https://api.crewpay.dev";
+/** Exact phrase a human must supply for SOL-spending calls. */
+export declare const SOL_SPEND_CONFIRM_PHRASE = "APPROVE_SOL_SPEND";
+export type CrewPayEnv = {
+    apiUrl?: string;
+    apiKey?: string;
+    launcherKey?: string;
+};
+export declare function loadCrewPayEnv(overrides?: CrewPayEnv): Required<Pick<CrewPayEnv, 'apiUrl'>> & CrewPayEnv;
+/** Canonical hash of launch fields so dry-run and launch bodies must match. */
+export declare function hashLaunchBody(body: Record<string, unknown>): string;
+export declare class CrewPayClient {
+    private readonly env;
+    constructor(env?: ReturnType<typeof loadCrewPayEnv>);
+    private headers;
+    fetch(path: string, init?: RequestInit & {
+        auth?: boolean;
+        launcher?: boolean;
+    }): Promise<unknown>;
+    discover(): Promise<unknown>;
+    claimKey(body?: {
+        label?: string;
+        agentName?: string;
+        model?: string;
+    }): Promise<unknown>;
+    autohire(body: Record<string, unknown>): Promise<unknown>;
+    dryRun(body: Record<string, unknown>): Promise<{
+        dryRunToken: string;
+        confirmPhraseRequired: string;
+        tip: string;
+    }>;
+    /**
+     * Real launch — spends SOL. Requires a prior dryRunToken for this body plus
+     * humanConfirmed and confirmPhrase APPROVE_SOL_SPEND.
+     */
+    launch(body: Record<string, unknown>, opts: {
+        humanConfirmed: boolean;
+        confirmPhrase: string;
+        dryRunToken: string;
+    }): Promise<unknown>;
+    wireFees(body: {
+        mint: string;
+        mode?: string;
+        crew?: unknown[];
+    }, opts: {
+        humanConfirmed: boolean;
+        confirmPhrase: string;
+    }): Promise<unknown>;
+    crank(body: {
+        mint: string;
+    }): Promise<unknown>;
+    proof(): Promise<unknown>;
+}

package/dist/client.js

@@ -0,0 +1,163 @@
+/**
+ * Minimal CrewPay REST client for framework plugins.
+ * Keys from env only — never accept private keys as function arguments.
+ *
+ * Spend gates: dry-run issues a short-lived dryRunToken; launch/wire require that
+ * token (launch) plus the exact confirmPhrase APPROVE_SOL_SPEND (not a free-form
+ * boolean the model can invent from chat alone).
+ */
+import { createHash, randomBytes } from 'node:crypto';
+export const DEFAULT_API_URL = 'https://api.crewpay.dev';
+/** Exact phrase a human must supply for SOL-spending calls. */
+export const SOL_SPEND_CONFIRM_PHRASE = 'APPROVE_SOL_SPEND';
+const pendingDryRuns = new Map();
+const DRY_RUN_TTL_MS = 30 * 60 * 1000;
+export function loadCrewPayEnv(overrides = {}) {
+    return {
+        apiUrl: (overrides.apiUrl || process.env.CREW_API_URL || DEFAULT_API_URL).replace(/\/$/, ''),
+        apiKey: overrides.apiKey ||
+            process.env.CREWPAY_API_KEY?.trim() ||
+            process.env.CREW_AGENT_API_KEY?.trim() ||
+            '',
+        launcherKey: overrides.launcherKey ||
+            process.env.CREW_LAUNCHER_KEY?.trim() ||
+            '',
+    };
+}
+/** Canonical hash of launch fields so dry-run and launch bodies must match. */
+export function hashLaunchBody(body) {
+    const pick = {
+        name: body.name,
+        ticker: body.ticker,
+        description: body.description ?? null,
+        mode: body.mode ?? 'agent',
+        initialBuySol: body.initialBuySol ?? 0,
+        imageUrl: body.imageUrl ?? null,
+        autoHire: body.autoHire ?? null,
+        crew: body.crew ?? null,
+        holderKol: body.holderKol ?? false,
+    };
+    return createHash('sha256').update(JSON.stringify(pick)).digest('hex');
+}
+function assertSpendConfirm(opts, action) {
+    if (opts.humanConfirmed !== true) {
+        throw new Error(`${action} blocked: humanConfirmed must be true after an explicit human approval`);
+    }
+    if (opts.confirmPhrase !== SOL_SPEND_CONFIRM_PHRASE) {
+        throw new Error(`${action} blocked: confirmPhrase must be exactly "${SOL_SPEND_CONFIRM_PHRASE}" (human-supplied; do not invent)`);
+    }
+}
+export class CrewPayClient {
+    env;
+    constructor(env = loadCrewPayEnv()) {
+        this.env = env;
+    }
+    headers(opts) {
+        const h = new Headers({ accept: 'application/json', 'content-type': 'application/json' });
+        if (this.env.apiKey)
+            h.set('x-crew-api-key', this.env.apiKey);
+        if (opts?.launcher) {
+            if (!this.env.launcherKey) {
+                throw new Error('Missing CREW_LAUNCHER_KEY in env — use a dedicated low-SOL burner. Never pass secrets as arguments.');
+            }
+            h.set('x-launcher-key', this.env.launcherKey);
+        }
+        return h;
+    }
+    async fetch(path, init) {
+        const headers = this.headers({ launcher: init?.launcher });
+        if (init?.auth && !this.env.apiKey) {
+            throw new Error('Missing CREWPAY_API_KEY / CREW_AGENT_API_KEY — claim via POST /api/agent/keys/claim');
+        }
+        const res = await fetch(`${this.env.apiUrl}${path}`, { ...init, headers });
+        const text = await res.text();
+        let json = null;
+        try {
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            json = { raw: text.slice(0, 500) };
+        }
+        if (!res.ok) {
+            const err = typeof json === 'object' && json && 'error' in json
+                ? String(json.error)
+                : text.slice(0, 300);
+            throw new Error(`CREW API ${res.status}: ${err}`);
+        }
+        return json;
+    }
+    discover() {
+        return this.fetch('/api/agent');
+    }
+    claimKey(body = {}) {
+        return this.fetch('/api/agent/keys/claim', {
+            method: 'POST',
+            body: JSON.stringify({ label: 'agent', ...body }),
+        });
+    }
+    autohire(body) {
+        return this.fetch('/api/agent/autohire', {
+            method: 'POST',
+            auth: true,
+            body: JSON.stringify(body),
+        });
+    }
+    async dryRun(body) {
+        const data = await this.fetch('/api/agent/launch/dry-run', {
+            method: 'POST',
+            auth: true,
+            body: JSON.stringify(body),
+        });
+        const dryRunToken = randomBytes(16).toString('hex');
+        pendingDryRuns.set(dryRunToken, {
+            bodyHash: hashLaunchBody(body),
+            expiresAt: Date.now() + DRY_RUN_TTL_MS,
+        });
+        return {
+            ...(typeof data === 'object' && data ? data : { result: data }),
+            dryRunToken,
+            confirmPhraseRequired: SOL_SPEND_CONFIRM_PHRASE,
+            tip: `To launch: pass the same body + dryRunToken + humanConfirmed:true + confirmPhrase:"${SOL_SPEND_CONFIRM_PHRASE}" (human must supply the phrase).`,
+        };
+    }
+    /**
+     * Real launch — spends SOL. Requires a prior dryRunToken for this body plus
+     * humanConfirmed and confirmPhrase APPROVE_SOL_SPEND.
+     */
+    launch(body, opts) {
+        assertSpendConfirm(opts, 'Launch');
+        const pending = pendingDryRuns.get(opts.dryRunToken);
+        if (!pending || pending.expiresAt < Date.now()) {
+            throw new Error('Launch blocked: missing/expired dryRunToken — call dryRun first and reuse its dryRunToken');
+        }
+        if (pending.bodyHash !== hashLaunchBody(body)) {
+            throw new Error('Launch blocked: body does not match the dry-run that issued dryRunToken');
+        }
+        pendingDryRuns.delete(opts.dryRunToken);
+        return this.fetch('/api/agent/launch', {
+            method: 'POST',
+            auth: true,
+            launcher: true,
+            body: JSON.stringify(body),
+        });
+    }
+    wireFees(body, opts) {
+        assertSpendConfirm(opts, 'Wire-fees');
+        return this.fetch('/api/agent/wire-fees', {
+            method: 'POST',
+            auth: true,
+            launcher: true,
+            body: JSON.stringify(body),
+        });
+    }
+    crank(body) {
+        return this.fetch('/api/agent/crank', {
+            method: 'POST',
+            auth: true,
+            body: JSON.stringify(body),
+        });
+    }
+    proof() {
+        return this.fetch('/api/proof');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,234 @@
+/**
+ * Solana Agent Kit v2 plugin scaffold for CrewPay.
+ * Docs: https://docs.sendai.fun/docs/v2/setup/quickstart
+ */
+import { z } from 'zod';
+export declare const CrewPayPlugin: {
+    name: string;
+    methods: {
+        crewDiscover: () => Promise<unknown>;
+        crewAutohire: (_agent: unknown, body: Record<string, unknown>) => Promise<unknown>;
+        crewDryRun: (_agent: unknown, body: Record<string, unknown>) => Promise<{
+            dryRunToken: string;
+            confirmPhraseRequired: string;
+            tip: string;
+        }>;
+        crewLaunch: (_agent: unknown, body: Record<string, unknown>) => Promise<unknown>;
+        crewWireFees: (_agent: unknown, body: {
+            mint: string;
+            mode?: string;
+            humanConfirmed?: boolean;
+            confirmPhrase?: string;
+        }) => Promise<unknown>;
+        crewCrank: (_agent: unknown, body: {
+            mint: string;
+        }) => Promise<unknown>;
+        crewProof: () => Promise<unknown>;
+    };
+    actions: ({
+        name: string;
+        similes: string[];
+        description: string;
+        schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        handler: () => Promise<{
+            status: string;
+            data: unknown;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        schema: z.ZodObject<{
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            seats: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            ticker: string;
+            description?: string | undefined;
+            seats?: number | undefined;
+        }, {
+            name: string;
+            ticker: string;
+            description?: string | undefined;
+            seats?: number | undefined;
+        }>;
+        handler: (_agent: unknown, input: Record<string, unknown>) => Promise<{
+            status: string;
+            data: unknown;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        schema: z.ZodObject<Omit<{
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<["split", "buyback", "raid", "agent"]>>;
+            initialBuySol: z.ZodOptional<z.ZodNumber>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            autoHire: z.ZodOptional<z.ZodObject<{
+                seats: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                seats?: number | undefined;
+            }, {
+                seats?: number | undefined;
+            }>>;
+            humanConfirmed: z.ZodOptional<z.ZodBoolean>;
+            confirmPhrase: z.ZodOptional<z.ZodString>;
+            dryRunToken: z.ZodOptional<z.ZodString>;
+        }, "humanConfirmed" | "confirmPhrase" | "dryRunToken">, "passthrough", z.ZodTypeAny, z.objectOutputType<Omit<{
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<["split", "buyback", "raid", "agent"]>>;
+            initialBuySol: z.ZodOptional<z.ZodNumber>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            autoHire: z.ZodOptional<z.ZodObject<{
+                seats: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                seats?: number | undefined;
+            }, {
+                seats?: number | undefined;
+            }>>;
+            humanConfirmed: z.ZodOptional<z.ZodBoolean>;
+            confirmPhrase: z.ZodOptional<z.ZodString>;
+            dryRunToken: z.ZodOptional<z.ZodString>;
+        }, "humanConfirmed" | "confirmPhrase" | "dryRunToken">, z.ZodTypeAny, "passthrough">, z.objectInputType<Omit<{
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<["split", "buyback", "raid", "agent"]>>;
+            initialBuySol: z.ZodOptional<z.ZodNumber>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            autoHire: z.ZodOptional<z.ZodObject<{
+                seats: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                seats?: number | undefined;
+            }, {
+                seats?: number | undefined;
+            }>>;
+            humanConfirmed: z.ZodOptional<z.ZodBoolean>;
+            confirmPhrase: z.ZodOptional<z.ZodString>;
+            dryRunToken: z.ZodOptional<z.ZodString>;
+        }, "humanConfirmed" | "confirmPhrase" | "dryRunToken">, z.ZodTypeAny, "passthrough">>;
+        handler: (_agent: unknown, input: Record<string, unknown>) => Promise<{
+            status: string;
+            data: {
+                dryRunToken: string;
+                confirmPhraseRequired: string;
+                tip: string;
+            };
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        schema: z.ZodObject<{
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<["split", "buyback", "raid", "agent"]>>;
+            initialBuySol: z.ZodOptional<z.ZodNumber>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            autoHire: z.ZodOptional<z.ZodObject<{
+                seats: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                seats?: number | undefined;
+            }, {
+                seats?: number | undefined;
+            }>>;
+            humanConfirmed: z.ZodOptional<z.ZodBoolean>;
+            confirmPhrase: z.ZodOptional<z.ZodString>;
+            dryRunToken: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<["split", "buyback", "raid", "agent"]>>;
+            initialBuySol: z.ZodOptional<z.ZodNumber>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            autoHire: z.ZodOptional<z.ZodObject<{
+                seats: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                seats?: number | undefined;
+            }, {
+                seats?: number | undefined;
+            }>>;
+            humanConfirmed: z.ZodOptional<z.ZodBoolean>;
+            confirmPhrase: z.ZodOptional<z.ZodString>;
+            dryRunToken: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            ticker: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<["split", "buyback", "raid", "agent"]>>;
+            initialBuySol: z.ZodOptional<z.ZodNumber>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            autoHire: z.ZodOptional<z.ZodObject<{
+                seats: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                seats?: number | undefined;
+            }, {
+                seats?: number | undefined;
+            }>>;
+            humanConfirmed: z.ZodOptional<z.ZodBoolean>;
+            confirmPhrase: z.ZodOptional<z.ZodString>;
+            dryRunToken: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>;
+        handler: (_agent: unknown, input: Record<string, unknown>) => Promise<{
+            status: string;
+            data: unknown;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        schema: z.ZodObject<{
+            mint: z.ZodString;
+            mode: z.ZodOptional<z.ZodString>;
+            humanConfirmed: z.ZodBoolean;
+            confirmPhrase: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            humanConfirmed: boolean;
+            confirmPhrase: string;
+            mint: string;
+            mode?: string | undefined;
+        }, {
+            humanConfirmed: boolean;
+            confirmPhrase: string;
+            mint: string;
+            mode?: string | undefined;
+        }>;
+        handler: (_agent: unknown, input: {
+            mint: string;
+            mode?: string;
+            humanConfirmed: boolean;
+            confirmPhrase: string;
+        }) => Promise<{
+            status: string;
+            data: unknown;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        schema: z.ZodObject<{
+            mint: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            mint: string;
+        }, {
+            mint: string;
+        }>;
+        handler: (_agent: unknown, input: {
+            mint: string;
+        }) => Promise<{
+            status: string;
+            data: unknown;
+        }>;
+    })[];
+    initialize(): void;
+};
+export default CrewPayPlugin;

package/dist/index.js

@@ -0,0 +1,134 @@
+/**
+ * Solana Agent Kit v2 plugin scaffold for CrewPay.
+ * Docs: https://docs.sendai.fun/docs/v2/setup/quickstart
+ */
+import { z } from 'zod';
+import { CrewPayClient, loadCrewPayEnv, SOL_SPEND_CONFIRM_PHRASE, } from './client.js';
+const launchBodySchema = z
+    .object({
+    name: z.string().min(2).max(32),
+    ticker: z.string().min(2).max(13),
+    description: z.string().max(204).optional(),
+    mode: z.enum(['split', 'buyback', 'raid', 'agent']).optional(),
+    initialBuySol: z.number().min(0).max(10).optional(),
+    imageUrl: z.string().url().optional(),
+    autoHire: z.object({ seats: z.number().int().min(1).max(10).optional() }).optional(),
+    humanConfirmed: z.boolean().optional(),
+    confirmPhrase: z.string().optional(),
+    dryRunToken: z.string().optional(),
+})
+    .passthrough();
+function api() {
+    return new CrewPayClient(loadCrewPayEnv());
+}
+function stripGateFields(body) {
+    const { humanConfirmed: _h, confirmPhrase: _c, dryRunToken: _d, ...rest } = body;
+    return rest;
+}
+export const CrewPayPlugin = {
+    name: 'crewpay',
+    methods: {
+        crewDiscover: async () => api().discover(),
+        crewAutohire: async (_agent, body) => api().autohire(body),
+        crewDryRun: async (_agent, body) => api().dryRun(body),
+        crewLaunch: async (_agent, body) => {
+            const parsed = launchBodySchema.parse(body);
+            return api().launch(stripGateFields(parsed), {
+                humanConfirmed: parsed.humanConfirmed === true,
+                confirmPhrase: parsed.confirmPhrase || '',
+                dryRunToken: parsed.dryRunToken || '',
+            });
+        },
+        crewWireFees: async (_agent, body) => api().wireFees({ mint: body.mint, mode: body.mode }, {
+            humanConfirmed: body.humanConfirmed === true,
+            confirmPhrase: body.confirmPhrase || '',
+        }),
+        crewCrank: async (_agent, body) => api().crank(body),
+        crewProof: async () => api().proof(),
+    },
+    actions: [
+        {
+            name: 'CREW_DISCOVER',
+            similes: ['crewpay discover', 'crew api info'],
+            description: 'Discover CrewPay agent API / fee map / MCP surfaces',
+            schema: z.object({}),
+            handler: async () => ({ status: 'success', data: await api().discover() }),
+        },
+        {
+            name: 'CREW_AUTOHIRE',
+            similes: ['autohire kols', 'hire crew'],
+            description: 'Preview Autohire KOL crew (no SOL)',
+            schema: z.object({
+                name: z.string(),
+                ticker: z.string(),
+                description: z.string().optional(),
+                seats: z.number().int().min(1).max(10).optional(),
+            }),
+            handler: async (_agent, input) => ({
+                status: 'success',
+                data: await api().autohire(input),
+            }),
+        },
+        {
+            name: 'CREW_LAUNCH_DRY_RUN',
+            similes: ['crew dry run', 'dry-run launch'],
+            description: 'Dry-run launch — returns dryRunToken required for CREW_LAUNCH',
+            schema: launchBodySchema.omit({ humanConfirmed: true, confirmPhrase: true, dryRunToken: true }),
+            handler: async (_agent, input) => ({
+                status: 'success',
+                data: await api().dryRun(input),
+            }),
+        },
+        {
+            name: 'CREW_LAUNCH',
+            similes: ['crew launch', 'launch pump coin'],
+            description: `Mainnet launch. Requires dryRunToken + humanConfirmed + confirmPhrase ${SOL_SPEND_CONFIRM_PHRASE}. Fee map 60/15/25; buyback not live.`,
+            schema: launchBodySchema,
+            handler: async (_agent, input) => {
+                const parsed = launchBodySchema.parse(input);
+                return {
+                    status: 'success',
+                    data: await api().launch(stripGateFields(parsed), {
+                        humanConfirmed: parsed.humanConfirmed === true,
+                        confirmPhrase: parsed.confirmPhrase || '',
+                        dryRunToken: parsed.dryRunToken || '',
+                    }),
+                };
+            },
+        },
+        {
+            name: 'CREW_WIRE_FEES',
+            similes: ['wire fees', 'lock fee shares'],
+            description: `Wire fee-shares (SOL). Requires humanConfirmed + confirmPhrase ${SOL_SPEND_CONFIRM_PHRASE}.`,
+            schema: z.object({
+                mint: z.string(),
+                mode: z.string().optional(),
+                humanConfirmed: z.boolean(),
+                confirmPhrase: z.string(),
+            }),
+            handler: async (_agent, input) => ({
+                status: 'success',
+                data: await api().wireFees({ mint: input.mint, mode: input.mode }, { humanConfirmed: input.humanConfirmed, confirmPhrase: input.confirmPhrase }),
+            }),
+        },
+        {
+            name: 'CREW_CRANK',
+            similes: ['crank remits', 'distribute creator fees'],
+            description: 'Crank distributeCreatorFeesV2 via POST /api/agent/crank',
+            schema: z.object({ mint: z.string() }),
+            handler: async (_agent, input) => ({
+                status: 'success',
+                data: await api().crank(input),
+            }),
+        },
+        {
+            name: 'CREW_PROOF',
+            similes: ['crew proof tape'],
+            description: 'Public proof tape GET /api/proof',
+            schema: z.object({}),
+            handler: async () => ({ status: 'success', data: await api().proof() }),
+        },
+    ],
+    initialize() { },
+};
+export default CrewPayPlugin;

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "crewpay-solana-agent-kit-plugin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Solana Agent Kit plugin for CrewPay — discover/autohire/dry-run/launch/wire/crank/proof. Fee map 60/15/25; buyback not live; dryRunToken + APPROVE_SOL_SPEND required.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "solana-agent-kit",
+    "crewpay",
+    "solana",
+    "pump.fun",
+    "kol",
+    "ai-agent"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fxams/solana-agent-kit-plugin-crewpay.git"
+  },
+  "homepage": "https://crewpay.dev/agents",
+  "peerDependencies": {
+    "solana-agent-kit": "*",
+    "zod": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0",
+    "zod": "^3.24.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}