@kanvas/openclaw-plugin 0.1.0

package/dist/index.js

@@ -0,0 +1,179 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { Type } from "@sinclair/typebox";
+import { KanvasClient } from "./client/kanvas-client.js";
+import { CrmService } from "./domains/crm/index.js";
+import { InventoryService } from "./domains/inventory/index.js";
+import { OrdersService } from "./domains/orders/index.js";
+import { SocialService } from "./domains/social/index.js";
+import { registerCrmTools } from "./tools/crm.js";
+import { registerInventoryTools } from "./tools/inventory.js";
+import { registerOrdersTools } from "./tools/orders.js";
+import { registerSocialTools } from "./tools/social.js";
+import { toolResult } from "./tools/helpers.js";
+const DEFAULT_API_URL = "https://graphapi.kanvas.dev/graphql";
+function resolveConfig(pluginConfig) {
+    const cfg = pluginConfig ?? {};
+    const apiUrl = cfg.apiUrl || process.env.KANVAS_API_URL || DEFAULT_API_URL;
+    const xKanvasApp = cfg.xKanvasApp || process.env.KANVAS_X_APP;
+    if (!xKanvasApp)
+        throw new Error("Kanvas plugin: xKanvasApp is required (config or KANVAS_X_APP env)");
+    const email = cfg.email || process.env.KANVAS_EMAIL;
+    const password = cfg.password || process.env.KANVAS_PASSWORD;
+    const bearerToken = cfg.bearerToken || process.env.KANVAS_BEARER_TOKEN;
+    const xKanvasKey = cfg.xKanvasKey || process.env.KANVAS_X_KEY;
+    // Determine auth mode: email/password → bearer (after login), explicit bearer, or app-key
+    let authMode;
+    if (email && password) {
+        authMode = "bearer"; // will authenticate at first use
+    }
+    else {
+        authMode = (cfg.authMode || process.env.KANVAS_AUTH_MODE || "bearer");
+    }
+    return {
+        apiUrl,
+        xKanvasApp,
+        xKanvasLocation: cfg.xKanvasLocation || process.env.KANVAS_X_LOCATION,
+        authMode,
+        bearerToken,
+        xKanvasKey,
+        email,
+        password,
+        timeoutMs: cfg.timeoutMs || (process.env.KANVAS_TIMEOUT_MS ? Number(process.env.KANVAS_TIMEOUT_MS) : 15000),
+    };
+}
+/**
+ * Creates a guard that ensures the client is authenticated before any tool executes.
+ * If email/password are configured, logs in once and caches the session.
+ * If a bearer token is already set, does nothing.
+ */
+function createAuthGuard(client, config, logger) {
+    let authPromise = null;
+    return function ensureAuth() {
+        if (authPromise)
+            return authPromise;
+        if (config.email && config.password && !config.bearerToken) {
+            authPromise = client.login(config.email, config.password).then((session) => {
+                logger.info(`Kanvas: authenticated as user ${session.uuid}`);
+            });
+        }
+        else {
+            authPromise = Promise.resolve();
+        }
+        return authPromise;
+    };
+}
+export default definePluginEntry({
+    id: "kanvas",
+    name: "Kanvas CRM",
+    description: "Connects agents to Kanvas — your company's nervous system for CRM, inventory, orders, and messaging.",
+    register(api) {
+        const config = resolveConfig(api.pluginConfig);
+        const client = new KanvasClient(config);
+        const ensureAuth = createAuthGuard(client, config, api.logger);
+        const crm = new CrmService(client);
+        const inventory = new InventoryService(client);
+        const orders = new OrdersService(client);
+        const social = new SocialService(client);
+        registerCrmTools(api, crm, ensureAuth);
+        registerInventoryTools(api, inventory, ensureAuth);
+        registerOrdersTools(api, orders, ensureAuth);
+        registerSocialTools(api, social, ensureAuth);
+        api.registerTool({
+            name: "kanvas_test_connection",
+            label: "Test Connection",
+            description: "Test the connection to the Kanvas GraphQL API.",
+            parameters: Type.Object({}),
+            async execute() {
+                await ensureAuth();
+                return toolResult(await client.testConnection());
+            },
+        });
+        // Inject Kanvas context into the agent's system prompt so it knows
+        // what these tools are for and how to use them together.
+        api.on("before_prompt_build", () => ({
+            appendSystemContext: KANVAS_SYSTEM_CONTEXT,
+        }));
+        // Register `openclaw kanvas setup` CLI command for interactive configuration.
+        api.registerCli((ctx) => {
+            ctx.program
+                .command("setup")
+                .description("Interactive setup — configure Kanvas credentials and test the connection")
+                .action(async () => {
+                const { runSetup } = await import("./cli/setup.js");
+                await runSetup();
+            });
+        }, { commands: ["setup"] });
+        api.logger.info("Kanvas plugin registered — 41 tools loaded");
+    },
+});
+const KANVAS_SYSTEM_CONTEXT = `
+## Kanvas Plugin
+
+You have access to Kanvas — the company's nervous system. Kanvas is the operational engine that connects all business data, tools, and workflows. Through the \`kanvas_*\` tools you can directly operate on CRM, inventory, orders, and messaging. Don't just describe what you'd do — use these tools to actually do it.
+
+### Domains & When to Use
+
+**CRM (Leads)**
+Use when the user asks about leads, prospects, sales pipeline, contacts, or follow-ups.
+- \`kanvas_search_leads\` → find leads by name, email, or keyword
+- \`kanvas_get_lead\` → full lead detail (pipeline stage, owner, receiver, participants, files, events, messages)
+- \`kanvas_create_lead\` → new lead (requires: title, pipeline_stage_id, people with firstname/lastname)
+- \`kanvas_update_lead\` → edit lead fields (requires: id, branch_id, people_id)
+- \`kanvas_mark_lead_outcome\` → close a lead as Won, Lost, or Close
+- \`kanvas_change_lead_owner\` / \`kanvas_change_lead_receiver\` → reassign leads
+- \`kanvas_add_lead_participant\` / \`kanvas_remove_lead_participant\` → manage related people
+- \`kanvas_follow_lead\` / \`kanvas_unfollow_lead\` → subscribe to lead updates
+- \`kanvas_delete_lead\` / \`kanvas_restore_lead\` → soft-delete and restore
+
+**CRM Support Data** — call these first when creating/updating leads to get valid IDs:
+- \`kanvas_list_pipelines\` → pipelines and their stages (needed for pipeline_stage_id)
+- \`kanvas_list_lead_statuses\` → available statuses
+- \`kanvas_list_lead_sources\` → where leads come from
+- \`kanvas_list_lead_types\` → lead categories
+
+**Messages & Notes**
+Use when the user asks about notes, comments, conversations, or activity on a lead.
+- \`kanvas_add_lead_message\` → add a note to a lead channel (needs channel_slug)
+- \`kanvas_add_lead_note_by_lead_id\` → add a note by lead ID (auto-resolves channel)
+- \`kanvas_list_lead_messages\` → read conversation history for a lead channel
+- \`kanvas_get_lead_primary_channel_slug\` → find the main channel for a lead
+
+**Social / Messages (NoSQL-like storage)**
+Use when the user wants to store, query, or manage structured data as messages. The message field accepts any JSON.
+- \`kanvas_create_message\` → store any JSON document with a message_verb type and optional channel/entity linking
+- \`kanvas_get_message\` → retrieve a message with all metadata
+- \`kanvas_update_message\` → modify message content or metadata
+- \`kanvas_delete_message\` → soft-delete
+- \`kanvas_list_channel_messages\` → list messages in a channel
+- \`kanvas_search_messages\` → search/filter by type (verb), channel, or linked entity
+- \`kanvas_list_message_types\` → see available message verbs
+- \`kanvas_create_message_type\` → define a new verb with optional template
+
+**Email**
+- \`kanvas_send_anonymous_email\` → send email to any address using a template (no Kanvas account needed for recipient)
+
+**Inventory**
+Use when the user asks about products, stock, warehouses, or catalog.
+- \`kanvas_search_products\` → find products by keyword
+- \`kanvas_get_product\` → full product detail with variants, categories, warehouses
+- \`kanvas_list_variants\` → product variants with pricing, stock, attributes
+- \`kanvas_list_warehouses\` → stock locations
+- \`kanvas_list_channels\` → sales channels
+- \`kanvas_list_categories\` → product categories
+- \`kanvas_list_inventory_statuses\` → product statuses
+
+**Orders**
+Use when the user asks about orders, purchases, or sales.
+- \`kanvas_search_orders\` → find orders by number or keyword
+- \`kanvas_get_order\` → full order detail with items, customer, status
+
+**Diagnostics**
+- \`kanvas_test_connection\` → verify the API is reachable
+
+### Key Conventions
+- IDs are numeric strings. When a tool returns an ID, use it as-is in subsequent calls.
+- Leads live in pipelines with stages. Always check \`kanvas_list_pipelines\` to get valid stage IDs before creating leads.
+- Messages use \`message_verb\` to define their type (e.g. "comment", "note", "sms"). New verbs are auto-created.
+- The \`message\` field in social messages accepts arbitrary JSON — use it to store any structured data.
+- Filtering uses \`where: [{ column, operator, value }]\` format. Common operators: "EQ", "LIKE", "IN".
+`.trim();

package/dist/tools/crm.js

@@ -0,0 +1,343 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+export function registerCrmTools(api, service, ensureAuth) {
+    api.registerTool({
+        name: "kanvas_search_leads",
+        label: "Search Leads",
+        description: "Search leads by keyword in the Kanvas CRM.",
+        parameters: Type.Object({
+            search: Type.String({ description: "Search keyword" }),
+            first: Type.Optional(Type.Number({ description: "Max results (default 10)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.searchLeads(params.search, params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_lead",
+        label: "Get Lead",
+        description: "Get full details for a single lead by ID, including channels, participants, events, and files.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Lead ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getLead(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_create_lead",
+        label: "Create Lead",
+        description: "Create a new lead in the Kanvas CRM.",
+        parameters: Type.Object({
+            title: Type.String({ description: "Lead title" }),
+            pipeline_stage_id: Type.Number({ description: "Pipeline stage ID" }),
+            people: Type.Object({
+                firstname: Type.String(),
+                lastname: Type.String(),
+                contacts: Type.Optional(Type.Array(Type.Object({
+                    value: Type.String(),
+                    contacts_types_id: Type.Number(),
+                    weight: Type.Optional(Type.Number()),
+                }))),
+            }, { description: "Contact person details" }),
+            branch_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            leads_owner_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            receiver_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            status_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            type_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            source_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            description: Type.Optional(Type.String()),
+            reason_lost: Type.Optional(Type.String()),
+            organization: Type.Optional(Type.Object({ name: Type.String() })),
+            custom_fields: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createLead(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_update_lead",
+        label: "Update Lead",
+        description: "Update an existing lead's fields.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Lead ID" }),
+            input: Type.Object({
+                branch_id: Type.Union([Type.String(), Type.Number()]),
+                people_id: Type.Union([Type.String(), Type.Number()]),
+                title: Type.Optional(Type.String()),
+                leads_owner_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+                organization_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+                receiver_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+                status_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+                type_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+                source_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+                description: Type.Optional(Type.String()),
+                reason_lost: Type.Optional(Type.String()),
+                pipeline_stage_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+                custom_fields: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
+            }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.updateLead(params.id, params.input));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_change_lead_owner",
+        label: "Change Lead Owner",
+        description: "Change the owner of a lead.",
+        parameters: Type.Object({
+            leadId: Type.Union([Type.String(), Type.Number()], { description: "Lead ID" }),
+            branch_id: Type.Union([Type.String(), Type.Number()]),
+            people_id: Type.Union([Type.String(), Type.Number()]),
+            title: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            leads_owner_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "New owner ID" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.changeLeadOwner(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_change_lead_receiver",
+        label: "Change Lead Receiver",
+        description: "Change the receiver of a lead.",
+        parameters: Type.Object({
+            leadId: Type.Union([Type.String(), Type.Number()], { description: "Lead ID" }),
+            branch_id: Type.Union([Type.String(), Type.Number()]),
+            people_id: Type.Union([Type.String(), Type.Number()]),
+            title: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            receiver_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "New receiver ID" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.changeLeadReceiver(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_add_lead_participant",
+        label: "Add Lead Participant",
+        description: "Add a participant to a lead.",
+        parameters: Type.Object({
+            lead_id: Type.Number({ description: "Lead ID" }),
+            people_id: Type.Number({ description: "Person ID" }),
+            relationship_id: Type.Number({ description: "Relationship type ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.addLeadParticipant(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_remove_lead_participant",
+        label: "Remove Lead Participant",
+        description: "Remove a participant from a lead.",
+        parameters: Type.Object({
+            lead_id: Type.Number({ description: "Lead ID" }),
+            people_id: Type.Number({ description: "Person ID" }),
+            relationship_id: Type.Number({ description: "Relationship type ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.removeLeadParticipant(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_follow_lead",
+        label: "Follow Lead",
+        description: "Follow a lead to receive updates.",
+        parameters: Type.Object({
+            entity_id: Type.String({ description: "Lead entity ID" }),
+            user_id: Type.Union([Type.String(), Type.Number()], { description: "User ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.followLead(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_unfollow_lead",
+        label: "Unfollow Lead",
+        description: "Unfollow a lead to stop receiving updates.",
+        parameters: Type.Object({
+            entity_id: Type.String({ description: "Lead entity ID" }),
+            user_id: Type.Union([Type.String(), Type.Number()], { description: "User ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.unFollowLead(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_delete_lead",
+        label: "Delete Lead",
+        description: "Soft-delete a lead.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Lead ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.deleteLead(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_restore_lead",
+        label: "Restore Lead",
+        description: "Restore a previously deleted lead.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Lead ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.restoreLead(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_mark_lead_outcome",
+        label: "Mark Lead Outcome",
+        description: "Mark a lead as Won, Lost, or Closed.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Lead ID" }),
+            status: Type.Union([Type.Literal("Won"), Type.Literal("Lost"), Type.Literal("Close")], {
+                description: "Outcome status",
+            }),
+            reason_lost: Type.Optional(Type.String({ description: "Reason for losing (if status is Lost)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.markLeadOutcome(params.id, params.status, params.reason_lost));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_create_lead_appointment",
+        label: "Create Lead Appointment",
+        description: "Create a calendar event/appointment linked to a lead.",
+        parameters: Type.Object({
+            name: Type.String({ description: "Appointment name" }),
+            description: Type.Optional(Type.String()),
+            resources: Type.Array(Type.Object({
+                resources_id: Type.Union([Type.String(), Type.Number()]),
+                resources_type: Type.String(),
+                custom_fields: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
+            })),
+            dates: Type.Array(Type.Object({
+                date: Type.String({ description: "Date (YYYY-MM-DD)" }),
+                start_time: Type.String({ description: "Start time (HH:MM)" }),
+                end_time: Type.String({ description: "End time (HH:MM)" }),
+            })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.createLeadAppointment(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_add_lead_message",
+        label: "Add Lead Message",
+        description: "Add a message/note to a lead's channel by channel slug.",
+        parameters: Type.Object({
+            channel_slug: Type.String({ description: "Channel slug" }),
+            message: Type.String({ description: "Message text" }),
+            parent_id: Type.Optional(Type.Union([Type.String(), Type.Number()], { description: "Parent message ID for threading" })),
+            is_public: Type.Optional(Type.Number({ description: "1 = public, 0 = internal" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.addLeadMessage(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_add_lead_note_by_lead_id",
+        label: "Add Lead Note by Lead ID",
+        description: "Add a message/note to a lead by lead ID. Automatically resolves the primary channel.",
+        parameters: Type.Object({
+            leadId: Type.Union([Type.String(), Type.Number()], { description: "Lead ID" }),
+            message: Type.String({ description: "Message text" }),
+            parent_id: Type.Optional(Type.Union([Type.String(), Type.Number()])),
+            is_public: Type.Optional(Type.Number({ description: "1 = public, 0 = internal" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.addLeadMessageByLeadId(params));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_lead_messages",
+        label: "List Lead Messages",
+        description: "List messages/notes in a lead's channel.",
+        parameters: Type.Object({
+            channel_slug: Type.String({ description: "Channel slug" }),
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+            page: Type.Optional(Type.Number({ description: "Page number (default 1)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listLeadMessages(params.channel_slug, params.first, params.page));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_lead_primary_channel_slug",
+        label: "Get Lead Primary Channel",
+        description: "Get the primary channel slug for a lead.",
+        parameters: Type.Object({
+            leadId: Type.String({ description: "Lead ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getLeadPrimaryChannelSlug(params.leadId));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_pipelines",
+        label: "List Pipelines",
+        description: "List all pipelines and their stages.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listPipelines(params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_lead_statuses",
+        label: "List Lead Statuses",
+        description: "List available lead statuses.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listLeadStatuses(params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_lead_sources",
+        label: "List Lead Sources",
+        description: "List available lead sources.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listLeadSources(params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_lead_types",
+        label: "List Lead Types",
+        description: "List available lead types.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listLeadTypes(params.first));
+        },
+    });
+}

package/dist/tools/helpers.js

@@ -0,0 +1,7 @@
+/** Wraps any service response into the AgentToolResult shape OpenClaw expects. */
+export function toolResult(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        details: data,
+    };
+}

package/dist/tools/inventory.js

@@ -0,0 +1,99 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+const WhereClause = Type.Optional(Type.Array(Type.Object({
+    column: Type.String(),
+    operator: Type.String({ description: 'e.g. "EQ", "LIKE"' }),
+    value: Type.Unknown(),
+}), { description: "Filter conditions" }));
+export function registerInventoryTools(api, service, ensureAuth) {
+    api.registerTool({
+        name: "kanvas_search_products",
+        label: "Search Products",
+        description: "Search products by keyword in the Kanvas inventory.",
+        parameters: Type.Object({
+            search: Type.String({ description: "Search keyword" }),
+            first: Type.Optional(Type.Number({ description: "Max results (default 10)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.searchProducts(params.search, params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_product",
+        label: "Get Product",
+        description: "Get full details for a product by ID, including variants and warehouses.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Product ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getProduct(params.id));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_variants",
+        label: "List Variants",
+        description: "List product variants with optional filtering.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 25)" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listVariants(params.first, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_warehouses",
+        label: "List Warehouses",
+        description: "List warehouses with optional filtering.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listWarehouses(params.first, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_channels",
+        label: "List Sales Channels",
+        description: "List sales channels with optional filtering.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listChannels(params.first, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_categories",
+        label: "List Categories",
+        description: "List product categories with optional filtering.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listCategories(params.first, params.where));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_list_inventory_statuses",
+        label: "List Inventory Statuses",
+        description: "List inventory statuses with optional filtering.",
+        parameters: Type.Object({
+            first: Type.Optional(Type.Number({ description: "Max results (default 50)" })),
+            where: WhereClause,
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.listStatuses(params.first, params.where));
+        },
+    });
+}

package/dist/tools/orders.js

@@ -0,0 +1,29 @@
+import { Type } from "@sinclair/typebox";
+import { toolResult } from "./helpers.js";
+export function registerOrdersTools(api, service, ensureAuth) {
+    api.registerTool({
+        name: "kanvas_search_orders",
+        label: "Search Orders",
+        description: "Search orders by keyword.",
+        parameters: Type.Object({
+            search: Type.String({ description: "Search keyword" }),
+            first: Type.Optional(Type.Number({ description: "Max results (default 10)" })),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.searchOrders(params.search, params.first));
+        },
+    });
+    api.registerTool({
+        name: "kanvas_get_order",
+        label: "Get Order",
+        description: "Get full details for an order by ID, including items and customer info.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Order ID" }),
+        }),
+        async execute(_id, params) {
+            await ensureAuth();
+            return toolResult(await service.getOrder(params.id));
+        },
+    });
+}