npm - happy2 - Versions diffs - 0.0.13 → 0.0.15 - Mend

happy2 0.0.13 → 0.0.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (300) hide show

package/packages/happy2-server/dist/web/index.html CHANGED Viewed

@@ -13,8 +13,8 @@
                 background: #131217;
             }
         </style>
-      <script type="module" crossorigin src="/assets/index-BnhFxR3U.js"></script>
-      <link rel="stylesheet" crossorigin href="/assets/index-BaPUPGPe.css">
+      <script type="module" crossorigin src="/assets/index-BT_VezYx.js"></script>
+      <link rel="stylesheet" crossorigin href="/assets/index-Dys3sWv8.css">
     </head>
     <body>
         <div id="root"></div>

package/packages/happy2-server/drizzle/0028_plugin_api_permissions.sql ADDED Viewed

	@@ -0,0 +1 @@
1	+ ALTER TABLE `plugin_installations` ADD `granted_permissions_json` text DEFAULT '[]' NOT NULL;

package/packages/happy2-server/drizzle/0029_plugin_management_requests.sql ADDED Viewed

@@ -0,0 +1,35 @@
+CREATE TABLE `plugin_management_requests` (
+	`id` text PRIMARY KEY NOT NULL,
+	`action` text NOT NULL,
+	`status` text DEFAULT 'pending' NOT NULL,
+	`chat_id` text NOT NULL,
+	`actor_user_id` text,
+	`agent_user_id` text,
+	`requester_installation_id` text,
+	`call_id` text NOT NULL,
+	`display_name` text NOT NULL,
+	`short_name` text NOT NULL,
+	`description` text NOT NULL,
+	`reason` text,
+	`source_kind` text,
+	`source_reference` text,
+	`package_digest` text,
+	`package_directory` text,
+	`target_installation_id` text,
+	`installation_id` text,
+	`resolved_by_user_id` text,
+	`resolved_at` text,
+	`last_error` text,
+	`sync_sequence` integer DEFAULT 0 NOT NULL,
+	`created_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	`updated_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	FOREIGN KEY (`chat_id`) REFERENCES `chats`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`actor_user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE set null,
+	FOREIGN KEY (`agent_user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE set null,
+	FOREIGN KEY (`requester_installation_id`) REFERENCES `plugin_installations`(`id`) ON UPDATE no action ON DELETE set null,
+	FOREIGN KEY (`resolved_by_user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE set null
+);
+--> statement-breakpoint
+CREATE INDEX `plugin_management_requests_chat_index` ON `plugin_management_requests` (`chat_id`,`created_at`);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `plugin_management_requests_call_unique` ON `plugin_management_requests` (`requester_installation_id`,`call_id`,`action`);

package/packages/happy2-server/drizzle/0030_personal_synced_drafts.sql ADDED Viewed

@@ -0,0 +1,11 @@
+CREATE TABLE `drafts` (
+	`user_id` text NOT NULL,
+	`chat_id` text NOT NULL,
+	`text` text DEFAULT '' NOT NULL,
+	`sync_sequence` integer DEFAULT 0 NOT NULL,
+	`created_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	`updated_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	PRIMARY KEY(`user_id`, `chat_id`),
+	FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`chat_id`) REFERENCES `chats`(`id`) ON UPDATE no action ON DELETE cascade
+);

package/packages/happy2-server/drizzle/0031_agent_image_deactivation.sql ADDED Viewed

	@@ -0,0 +1 @@
1	+ ALTER TABLE `agent_images` ADD `deleted_at` text;

package/packages/happy2-server/drizzle/meta/_journal.json CHANGED Viewed

@@ -197,6 +197,34 @@
             "when": 1784427000000,
             "tag": "0027_chat_agent_effort",
             "breakpoints": true
+        },
+        {
+            "idx": 28,
+            "version": "6",
+            "when": 1784430000000,
+            "tag": "0028_plugin_api_permissions",
+            "breakpoints": true
+        },
+        {
+            "idx": 29,
+            "version": "6",
+            "when": 1784433600000,
+            "tag": "0029_plugin_management_requests",
+            "breakpoints": true
+        },
+        {
+            "idx": 30,
+            "version": "6",
+            "when": 1784437200000,
+            "tag": "0030_personal_synced_drafts",
+            "breakpoints": true
+        },
+        {
+            "idx": 31,
+            "version": "6",
+            "when": 1784444400000,
+            "tag": "0031_agent_image_deactivation",
+            "breakpoints": true
         }
     ]
 }

package/packages/happy2-server/plugins/README.md CHANGED Viewed

@@ -4,6 +4,12 @@ Each child directory is one immutable, built-in plugin package. See
 [`../PLUGINS.md`](../PLUGINS.md) for the manifest and package contract.
 `hello` is the minimal built-in example with both a skill and a bundled stdio MCP
-tool. `chat-management` demonstrates a chat-scoped Plugin API capability without
-accepting a chat identifier from tool arguments. Product plugins should be added
-here as separate, reviewable changes.
+tool. `chat-management` demonstrates installation-bound chat and referenced-user
+capabilities: it updates the current chat, manages channel membership, and creates
+private channels with either an informational opening message or an agent-triggering
+prompt. `environment-management` lets agents inspect, build, select, and safely
+deactivate Dockerfile-backed agent environments while retaining their manifests.
+`plugin-developer` provides Happy2 plugin authoring/install documentation
+and chat-scoped MCP tools that request administrator approval for linked install
+or uninstall actions. Product plugins should be added here as separate,
+reviewable changes.

package/packages/happy2-server/plugins/chat-management/plugin.json CHANGED Viewed

@@ -1,13 +1,13 @@
 {
     "schemaVersion": 1,
-    "version": "1.0.0",
+    "version": "1.1.0",
     "displayName": "Chat Management",
     "shortName": "chat-management",
-    "description": "Lets an agent update the title and description of its current chat.",
+    "description": "Lets an agent update its current chat, manage channel members, and create new channels with an initial people or agent message.",
     "variables": [],
     "container": {
         "dockerfile": "container/Dockerfile",
-        "permissions": ["chats:update"]
+        "permissions": ["chats:update", "channels:manage"]
     },
     "mcp": {
         "type": "stdio",

package/packages/happy2-server/plugins/chat-management/server.mjs CHANGED Viewed

@@ -1,6 +1,8 @@
 import { createInterface } from "node:readline";
+import { randomUUID } from "node:crypto";
 const CHAT_META_KEY = "happy2/chat";
+const USERS_META_KEY = "happy2/users";
 const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
 for await (const line of lines) {
@@ -32,7 +34,7 @@ async function handle(request) {
             result: {
                 protocolVersion: request.params?.protocolVersion ?? "2025-06-18",
                 capabilities: { tools: {} },
-                serverInfo: { name: "happy2-chat-management", version: "1.0.0" },
+                serverInfo: { name: "happy2-chat-management", version: "1.1.0" },
             },
         };
     }
@@ -66,48 +68,213 @@ async function handle(request) {
                             additionalProperties: false,
                         },
                     },
+                    {
+                        name: "channel_members_update",
+                        title: "Add or remove channel members",
+                        description:
+                            "Adds or removes users from the current channel. This never changes direct-message membership. Identify users by the @username shown in the triggering conversation; only users supplied in Happy's signed metadata are available.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                addUsers: {
+                                    type: "array",
+                                    maxItems: 100,
+                                    uniqueItems: true,
+                                    items: { type: "string", minLength: 1 },
+                                    description: "Usernames (with or without @) to add.",
+                                },
+                                removeUsers: {
+                                    type: "array",
+                                    maxItems: 100,
+                                    uniqueItems: true,
+                                    items: { type: "string", minLength: 1 },
+                                    description: "Usernames (with or without @) to remove.",
+                                },
+                            },
+                            anyOf: [{ required: ["addUsers"] }, { required: ["removeUsers"] }],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: "channel_create",
+                        title: "Create a channel",
+                        description:
+                            "Creates a private channel owned by the user who triggered this turn, adds selected referenced users, and optionally posts an initial message. An agents message starts the current agent working; a people message only shares context and does not trigger inference.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    minLength: 1,
+                                    maxLength: 100,
+                                    description: "Channel title.",
+                                },
+                                description: {
+                                    type: "string",
+                                    minLength: 1,
+                                    maxLength: 500,
+                                    description: "Optional channel description.",
+                                },
+                                members: {
+                                    type: "array",
+                                    maxItems: 100,
+                                    uniqueItems: true,
+                                    items: { type: "string", minLength: 1 },
+                                    description:
+                                        "Referenced usernames (with or without @) to add. The triggering user is already the owner.",
+                                },
+                                initialMessage: {
+                                    type: "object",
+                                    properties: {
+                                        text: {
+                                            type: "string",
+                                            minLength: 1,
+                                            maxLength: 40000,
+                                            description:
+                                                "A copied or rephrased opening prompt or informational message.",
+                                        },
+                                        audience: {
+                                            type: "string",
+                                            enum: ["agents", "people"],
+                                            description:
+                                                "agents starts the current agent; people posts without inference.",
+                                        },
+                                    },
+                                    required: ["text", "audience"],
+                                    additionalProperties: false,
+                                },
+                            },
+                            required: ["name"],
+                            additionalProperties: false,
+                        },
+                    },
                 ],
             },
         };
     }
     if (request.method === "tools/call" && request.params?.name === "chat_update")
         return { result: await updateChat(request.params) };
+    if (request.method === "tools/call" && request.params?.name === "channel_members_update")
+        return { result: await updateChannelMembers(request.params) };
+    if (request.method === "tools/call" && request.params?.name === "channel_create")
+        return { result: await createChannel(request.params) };
     return {
         error: { code: -32601, message: `Method not found: ${String(request.method)}` },
     };
 }
 async function updateChat(params) {
+    const { chat } = capabilityContext(params);
+    const input = params.arguments;
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("A chat update is required.");
+    const result = await callHost("/chats/updateChat", chat.token, input);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Updated chat ${result.chat.id}.`,
+            },
+        ],
+        structuredContent: { chat: result.chat },
+    };
+}
+async function updateChannelMembers(params) {
+    const { chat, users } = capabilityContext(params);
+    const input = params.arguments;
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("A channel membership update is required.");
+    const add = resolveUsers(input.addUsers ?? [], users, "addUsers");
+    const remove = resolveUsers(input.removeUsers ?? [], users, "removeUsers");
+    if (!add.length && !remove.length)
+        throw new Error("At least one user must be added or removed.");
+    const result = await callHost("/channels/updateMembers", chat.token, { add, remove });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Updated members of channel ${result.chatId}: added ${result.addedUserIds.length}, removed ${result.removedUserIds.length}.`,
+            },
+        ],
+        structuredContent: result,
+    };
+}
+async function createChannel(params) {
+    const { chat, users } = capabilityContext(params);
+    const input = params.arguments;
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("A channel definition is required.");
+    const members = resolveUsers(input.members ?? [], users, "members");
+    const result = await callHost("/channels/createChannel", chat.token, {
+        ...input,
+        members,
+        idempotencyKey: randomUUID(),
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Created channel ${result.chat.id}${result.initialMessage ? " and posted its initial message" : ""}.`,
+            },
+        ],
+        structuredContent: result,
+    };
+}
+function capabilityContext(params) {
     const chat = params?._meta?.[CHAT_META_KEY];
     if (!chat || typeof chat.id !== "string" || typeof chat.token !== "string")
         throw new Error("This tool must be called from an active Happy chat.");
+    const users = params?._meta?.[USERS_META_KEY];
+    if (!Array.isArray(users)) throw new Error("Happy did not provide referenced-user metadata.");
+    return { chat, users };
+}
+function resolveUsers(selectors, users, name) {
+    if (!Array.isArray(selectors)) throw new Error(`${name} must be an array.`);
+    const resolved = selectors.map((selector) => {
+        if (typeof selector !== "string" || !selector.trim())
+            throw new Error(`${name} must contain usernames.`);
+        const normalized = selector.trim().replace(/^@/, "").toLowerCase();
+        const matches = users.filter(
+            (user) =>
+                user &&
+                typeof user === "object" &&
+                (user.id === selector.trim() ||
+                    (typeof user.username === "string" &&
+                        user.username.toLowerCase() === normalized)),
+        );
+        if (matches.length !== 1)
+            throw new Error(`User ${selector} is not uniquely available in this turn.`);
+        const user = matches[0];
+        if (typeof user.id !== "string" || typeof user.token !== "string")
+            throw new Error(`User ${selector} has malformed capability metadata.`);
+        return { id: user.id, token: user.token };
+    });
+    if (new Set(resolved.map(({ id }) => id)).size !== resolved.length)
+        throw new Error(`${name} contains a duplicate user.`);
+    return resolved;
+}
+async function callHost(path, chatToken, body) {
     const apiUrl = process.env.HAPPY2_PLUGIN_API_URL;
     const runtimeToken = process.env.HAPPY2_PLUGIN_API_TOKEN;
     if (!apiUrl || !runtimeToken) throw new Error("The Happy Plugin API is unavailable.");
-    const input = params.arguments;
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("A chat update is required.");
-    const response = await fetch(`${apiUrl}/chats/updateChat`, {
+    const response = await fetch(`${apiUrl}${path}`, {
         method: "POST",
         headers: {
             authorization: `Bearer ${runtimeToken}`,
             "content-type": "application/json",
-            "x-happy2-chat-token": chat.token,
+            "x-happy2-chat-token": chatToken,
         },
-        body: JSON.stringify(input),
+        body: JSON.stringify(body),
     });
     const result = await response.json().catch(() => undefined);
     if (!response.ok)
         throw new Error(
-            typeof result?.message === "string" ? result.message : "The chat could not be updated.",
+            typeof result?.message === "string" ? result.message : "The chat action failed.",
         );
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Updated chat ${result.chat.id}.`,
-            },
-        ],
-        structuredContent: { chat: result.chat },
-    };
+    return result;
 }

package/packages/happy2-server/plugins/environment-management/container/Dockerfile ADDED Viewed

@@ -0,0 +1,6 @@
+FROM node:22-alpine
+WORKDIR /plugin
+COPY server.mjs /plugin/server.mjs
+CMD ["sleep", "infinity"]

package/packages/happy2-server/plugins/environment-management/plugin.json ADDED Viewed

@@ -0,0 +1,17 @@
+{
+    "schemaVersion": 1,
+    "version": "1.0.0",
+    "displayName": "Environment Management",
+    "shortName": "environment-management",
+    "description": "Lets an agent inspect, create, select, and safely deactivate Happy agent environments.",
+    "variables": [],
+    "container": {
+        "dockerfile": "container/Dockerfile",
+        "permissions": ["environments:read", "environments:manage", "environments:deactivate"]
+    },
+    "mcp": {
+        "type": "stdio",
+        "command": "node",
+        "args": ["/plugin/server.mjs"]
+    }
+}

package/packages/happy2-server/plugins/environment-management/plugin.png ADDED Viewed

Binary file

package/packages/happy2-server/plugins/environment-management/server.mjs ADDED Viewed

@@ -0,0 +1,234 @@
+import { createInterface } from "node:readline";
+const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+for await (const line of lines) {
+    if (!line.trim()) continue;
+    let request;
+    try {
+        request = JSON.parse(line);
+    } catch {
+        continue;
+    }
+    if (request.id === undefined) continue;
+    const response = await handle(request).catch((error) => ({
+        result: {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text:
+                        error instanceof Error
+                            ? error.message
+                            : "The environment operation failed.",
+                },
+            ],
+        },
+    }));
+    process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id: request.id, ...response })}\n`);
+}
+async function handle(request) {
+    if (request.method === "initialize") {
+        return {
+            result: {
+                protocolVersion: request.params?.protocolVersion ?? "2025-06-18",
+                capabilities: { tools: {} },
+                serverInfo: { name: "happy2-environment-management", version: "1.0.0" },
+            },
+        };
+    }
+    if (request.method === "ping") return { result: {} };
+    if (request.method === "tools/list") return { result: { tools: toolDefinitions() } };
+    if (request.method !== "tools/call")
+        return {
+            error: { code: -32601, message: `Method not found: ${String(request.method)}` },
+        };
+    const input = request.params?.arguments ?? {};
+    switch (request.params?.name) {
+        case "happy2_environments_list":
+            return { result: await listEnvironments() };
+        case "happy2_environment_get_dockerfile":
+            return { result: await getDockerfile(input) };
+        case "happy2_environment_create":
+            return { result: await createEnvironment(input) };
+        case "happy2_environment_set_default":
+            return { result: await setDefaultEnvironment(input) };
+        case "happy2_environment_deactivate":
+            return { result: await deactivateEnvironment(input) };
+        default:
+            return {
+                error: {
+                    code: -32601,
+                    message: `Tool not found: ${String(request.params?.name)}`,
+                },
+            };
+    }
+}
+function toolDefinitions() {
+    const environmentId = {
+        type: "string",
+        minLength: 1,
+        maxLength: 128,
+        description: "The environment ID returned by happy2_environments_list or creation.",
+    };
+    return [
+        {
+            name: "happy2_environments_list",
+            title: "List agent environments",
+            description:
+                "Lists active and inactive Happy agent environments, their build status, and the current default environment.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "happy2_environment_get_dockerfile",
+            title: "Read an environment Dockerfile",
+            description:
+                "Returns the retained immutable Dockerfile and active state for one Happy agent environment.",
+            inputSchema: {
+                type: "object",
+                properties: { environmentId },
+                required: ["environmentId"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "happy2_environment_create",
+            title: "Create or reactivate an agent environment",
+            description:
+                "Creates an immutable Happy agent environment and queues its Docker image build. The exact definition of an inactive environment is reactivated under the same ID and rebuilt. Creation returns before the build is ready.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 100,
+                        description: "A concise human-readable environment name.",
+                    },
+                    dockerfile: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 262144,
+                        description: "The complete Dockerfile used to build the environment.",
+                    },
+                },
+                required: ["name", "dockerfile"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "happy2_environment_set_default",
+            title: "Set the default agent environment",
+            description:
+                "Selects a ready environment as the default for agents created in the future. Existing agents keep their assigned environment.",
+            inputSchema: {
+                type: "object",
+                properties: { environmentId },
+                required: ["environmentId"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "happy2_environment_deactivate",
+            title: "Deactivate an unused agent environment",
+            description:
+                "Deactivates a custom environment only when it is unused. Happy permanently retains its manifest and Dockerfile so the same definition can be reactivated and rebuilt later.",
+            inputSchema: {
+                type: "object",
+                properties: { environmentId },
+                required: ["environmentId"],
+                additionalProperties: false,
+            },
+        },
+    ];
+}
+async function listEnvironments() {
+    const result = await callHost("/environments");
+    return toolResult(
+        `Found ${result.environments.length} agent environment${result.environments.length === 1 ? "" : "s"}.`,
+        result,
+    );
+}
+async function getDockerfile(input) {
+    const environmentId = requiredString(input, "environmentId");
+    const result = await callHost(`/environments/${encodeURIComponent(environmentId)}/dockerfile`);
+    return toolResult(`Read the Dockerfile for ${result.environment.name}.`, result);
+}
+async function createEnvironment(input) {
+    const name = requiredString(input, "name");
+    const dockerfile = requiredString(input, "dockerfile", false);
+    const result = await callHost("/environments/createEnvironment", {
+        method: "POST",
+        body: { name, dockerfile },
+    });
+    return toolResult(
+        `Environment ${result.environment.name} is active; its image build is ${result.environment.status}.`,
+        result,
+    );
+}
+async function setDefaultEnvironment(input) {
+    const environmentId = requiredString(input, "environmentId");
+    const result = await callHost(
+        `/environments/${encodeURIComponent(environmentId)}/setDefaultEnvironment`,
+        { method: "POST", body: {} },
+    );
+    return toolResult(`Set ${result.environment.name} as the default environment.`, result);
+}
+async function deactivateEnvironment(input) {
+    const environmentId = requiredString(input, "environmentId");
+    const result = await callHost(
+        `/environments/${encodeURIComponent(environmentId)}/deactivateEnvironment`,
+        { method: "POST", body: {} },
+    );
+    return toolResult(`Deactivated environment ${result.environmentId}.`, result);
+}
+function requiredString(input, name, trim = true) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("Tool arguments must be an object.");
+    const value = input[name];
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${name} must be a non-empty string.`);
+    return trim ? value.trim() : value;
+}
+function toolResult(text, structuredContent) {
+    return {
+        content: [{ type: "text", text }],
+        structuredContent,
+    };
+}
+async function callHost(path, options = {}) {
+    const apiUrl = process.env.HAPPY2_PLUGIN_API_URL;
+    const token = process.env.HAPPY2_PLUGIN_API_TOKEN;
+    if (!apiUrl || !token) throw new Error("Happy did not provide plugin host credentials.");
+    const response = await fetch(new URL(path, `${apiUrl}/`), {
+        method: options.method ?? "GET",
+        headers: {
+            authorization: `Bearer ${token}`,
+            ...(options.body === undefined ? {} : { "content-type": "application/json" }),
+        },
+        ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
+    });
+    const payload = await response.json().catch(() => undefined);
+    if (!response.ok) {
+        const message =
+            payload && typeof payload.message === "string"
+                ? payload.message
+                : `Happy environment API returned HTTP ${response.status}.`;
+        throw new Error(message);
+    }
+    return payload;
+}