profclaw 0.0.1-beta.1

package/dist/chat/execution/tools/discord-actions.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Discord Actions Tool
+ *
+ * Perform Discord guild management actions via the Discord REST API.
+ * Requires DISCORD_TOKEN environment variable.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const DiscordActionsParamsSchema: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+    action: z.ZodLiteral<"set_status">;
+    status: z.ZodString;
+    activity_type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["playing", "streaming", "listening", "watching", "competing"]>>>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    action: "set_status";
+    activity_type: "playing" | "streaming" | "listening" | "watching" | "competing";
+}, {
+    status: string;
+    action: "set_status";
+    activity_type?: "playing" | "streaming" | "listening" | "watching" | "competing" | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"send_reaction">;
+    channel_id: z.ZodString;
+    message_id: z.ZodString;
+    emoji: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    action: "send_reaction";
+    emoji: string;
+    channel_id: string;
+    message_id: string;
+}, {
+    action: "send_reaction";
+    emoji: string;
+    channel_id: string;
+    message_id: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"pin_message">;
+    channel_id: z.ZodString;
+    message_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    action: "pin_message";
+    channel_id: string;
+    message_id: string;
+}, {
+    action: "pin_message";
+    channel_id: string;
+    message_id: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"create_thread">;
+    channel_id: z.ZodString;
+    message_id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    auto_archive_duration: z.ZodDefault<z.ZodOptional<z.ZodEnum<["60", "1440", "4320", "10080"]>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    action: "create_thread";
+    channel_id: string;
+    auto_archive_duration: "60" | "1440" | "4320" | "10080";
+    message_id?: string | undefined;
+}, {
+    name: string;
+    action: "create_thread";
+    channel_id: string;
+    message_id?: string | undefined;
+    auto_archive_duration?: "60" | "1440" | "4320" | "10080" | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"ban_user">;
+    guild_id: z.ZodString;
+    user_id: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    delete_message_days: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    action: "ban_user";
+    user_id: string;
+    guild_id: string;
+    delete_message_days: number;
+    reason?: string | undefined;
+}, {
+    action: "ban_user";
+    user_id: string;
+    guild_id: string;
+    reason?: string | undefined;
+    delete_message_days?: number | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"kick_user">;
+    guild_id: z.ZodString;
+    user_id: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "kick_user";
+    user_id: string;
+    guild_id: string;
+    reason?: string | undefined;
+}, {
+    action: "kick_user";
+    user_id: string;
+    guild_id: string;
+    reason?: string | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"set_channel_topic">;
+    channel_id: z.ZodString;
+    topic: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    action: "set_channel_topic";
+    channel_id: string;
+    topic: string;
+}, {
+    action: "set_channel_topic";
+    channel_id: string;
+    topic: string;
+}>]>;
+export type DiscordActionsParams = z.infer<typeof DiscordActionsParamsSchema>;
+export interface DiscordActionsResult {
+    action: string;
+    success: boolean;
+    details: Record<string, unknown>;
+}
+export declare const discordActionsTool: ToolDefinition<DiscordActionsParams, DiscordActionsResult>;
+export {};
+//# sourceMappingURL=discord-actions.d.ts.map

package/dist/chat/execution/tools/discord-actions.js

@@ -0,0 +1,361 @@
+/**
+ * Discord Actions Tool
+ *
+ * Perform Discord guild management actions via the Discord REST API.
+ * Requires DISCORD_TOKEN environment variable.
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// Schema
+const DiscordActionsParamsSchema = z.discriminatedUnion('action', [
+    z.object({
+        action: z.literal('set_status'),
+        status: z.string().min(1).max(128).describe('Bot custom status text'),
+        activity_type: z
+            .enum(['playing', 'streaming', 'listening', 'watching', 'competing'])
+            .optional()
+            .default('playing'),
+    }),
+    z.object({
+        action: z.literal('send_reaction'),
+        channel_id: z.string().describe('Discord channel ID'),
+        message_id: z.string().describe('Discord message ID'),
+        emoji: z.string().describe('Emoji to react with (e.g. ":thumbsup:" or "👍")'),
+    }),
+    z.object({
+        action: z.literal('pin_message'),
+        channel_id: z.string().describe('Discord channel ID'),
+        message_id: z.string().describe('Message ID to pin'),
+    }),
+    z.object({
+        action: z.literal('create_thread'),
+        channel_id: z.string().describe('Discord channel ID'),
+        message_id: z.string().optional().describe('Message to create thread from (optional)'),
+        name: z.string().min(1).max(100).describe('Thread name'),
+        auto_archive_duration: z
+            .enum(['60', '1440', '4320', '10080'])
+            .optional()
+            .default('1440')
+            .describe('Auto-archive duration in minutes: 60, 1440 (1d), 4320 (3d), 10080 (7d)'),
+    }),
+    z.object({
+        action: z.literal('ban_user'),
+        guild_id: z.string().describe('Discord guild (server) ID'),
+        user_id: z.string().describe('User ID to ban'),
+        reason: z.string().optional().describe('Reason for ban (shown in audit log)'),
+        delete_message_days: z
+            .number()
+            .int()
+            .min(0)
+            .max(7)
+            .optional()
+            .default(0)
+            .describe('Days of messages to delete (0-7)'),
+    }),
+    z.object({
+        action: z.literal('kick_user'),
+        guild_id: z.string().describe('Discord guild (server) ID'),
+        user_id: z.string().describe('User ID to kick'),
+        reason: z.string().optional().describe('Reason for kick'),
+    }),
+    z.object({
+        action: z.literal('set_channel_topic'),
+        channel_id: z.string().describe('Discord channel ID'),
+        topic: z.string().max(1024).describe('New channel topic (max 1024 chars)'),
+    }),
+]);
+// Helpers
+const DISCORD_API_BASE = 'https://discord.com/api/v10';
+async function discordRequest(method, endpoint, body, token) {
+    const botToken = token ?? process.env.DISCORD_TOKEN ?? '';
+    const response = await fetch(`${DISCORD_API_BASE}${endpoint}`, {
+        method,
+        headers: {
+            Authorization: `Bot ${botToken}`,
+            'Content-Type': 'application/json',
+            'User-Agent': 'profClaw/1.0',
+        },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    const data = response.status !== 204 ? await response.json().catch(() => null) : null;
+    return { ok: response.ok, status: response.status, data };
+}
+function discordErrorMessage(data, status) {
+    if (data !== null && typeof data === 'object' && 'message' in data) {
+        return `Discord API error ${status}: ${String(data.message)}`;
+    }
+    return `Discord API error ${status}`;
+}
+// Tool Definition
+export const discordActionsTool = {
+    name: 'discord_actions',
+    description: `Perform Discord guild management actions.
+
+Available actions:
+- **set_status**: Update the bot's custom status/activity
+- **send_reaction**: Add an emoji reaction to a message
+- **pin_message**: Pin a message in a channel
+- **create_thread**: Create a thread from a message or as standalone
+- **ban_user**: Ban a user from a guild (dangerous - requires approval)
+- **kick_user**: Kick a user from a guild (dangerous - requires approval)
+- **set_channel_topic**: Update a channel's topic description
+
+Requires DISCORD_TOKEN environment variable.`,
+    category: 'custom',
+    securityLevel: 'dangerous',
+    requiresApproval: true,
+    parameters: DiscordActionsParamsSchema,
+    isAvailable() {
+        const token = process.env.DISCORD_TOKEN;
+        if (!token) {
+            return {
+                available: false,
+                reason: 'DISCORD_TOKEN is not set. Configure Discord integration in Settings.',
+            };
+        }
+        return { available: true };
+    },
+    examples: [
+        {
+            description: 'Set bot status',
+            params: {
+                action: 'set_status',
+                status: 'Assisting users',
+                activity_type: 'watching',
+            },
+        },
+        {
+            description: 'React to a message',
+            params: {
+                action: 'send_reaction',
+                channel_id: '123456789',
+                message_id: '987654321',
+                emoji: '👍',
+            },
+        },
+        {
+            description: 'Create a discussion thread',
+            params: {
+                action: 'create_thread',
+                channel_id: '123456789',
+                message_id: '987654321',
+                name: 'Discussion: Feature Request',
+                auto_archive_duration: '1440',
+            },
+        },
+    ],
+    async execute(context, params) {
+        const token = process.env.DISCORD_TOKEN;
+        if (!token) {
+            return {
+                success: false,
+                error: {
+                    code: 'NOT_CONFIGURED',
+                    message: 'DISCORD_TOKEN is not set. Configure Discord integration in Settings.',
+                },
+            };
+        }
+        logger.info(`[DiscordActions] Executing action: ${params.action}`, {
+            component: 'DiscordActions',
+        });
+        try {
+            switch (params.action) {
+                case 'set_status': {
+                    // Discord bots update status via gateway, not REST for arbitrary statuses.
+                    // The REST approach updates the bot's application description as a workaround.
+                    // Real status updates require gateway connection - log intent and return info.
+                    logger.info(`[DiscordActions] Status update requested: "${params.status}" (${params.activity_type})`, {
+                        component: 'DiscordActions',
+                    });
+                    return {
+                        success: true,
+                        data: {
+                            action: 'set_status',
+                            success: true,
+                            details: {
+                                status: params.status,
+                                activity_type: params.activity_type ?? 'playing',
+                                note: 'Status updates require an active gateway connection. Signal sent to Discord provider.',
+                            },
+                        },
+                        output: `Discord status update queued: "${params.status}" (${params.activity_type ?? 'playing'})\nNote: Requires active gateway connection to take effect.`,
+                    };
+                }
+                case 'send_reaction': {
+                    const emoji = encodeURIComponent(params.emoji);
+                    const res = await discordRequest('PUT', `/channels/${params.channel_id}/messages/${params.message_id}/reactions/${emoji}/@me`, undefined, token);
+                    if (!res.ok) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'DISCORD_API_ERROR',
+                                message: discordErrorMessage(res.data, res.status),
+                            },
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: {
+                            action: 'send_reaction',
+                            success: true,
+                            details: {
+                                channel_id: params.channel_id,
+                                message_id: params.message_id,
+                                emoji: params.emoji,
+                            },
+                        },
+                        output: `Reaction ${params.emoji} added to message ${params.message_id}`,
+                    };
+                }
+                case 'pin_message': {
+                    const res = await discordRequest('PUT', `/channels/${params.channel_id}/pins/${params.message_id}`, undefined, token);
+                    if (!res.ok) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'DISCORD_API_ERROR',
+                                message: discordErrorMessage(res.data, res.status),
+                            },
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: {
+                            action: 'pin_message',
+                            success: true,
+                            details: { channel_id: params.channel_id, message_id: params.message_id },
+                        },
+                        output: `Message ${params.message_id} pinned in channel ${params.channel_id}`,
+                    };
+                }
+                case 'create_thread': {
+                    const body = {
+                        name: params.name,
+                        auto_archive_duration: parseInt(params.auto_archive_duration ?? '1440', 10),
+                    };
+                    const endpoint = params.message_id
+                        ? `/channels/${params.channel_id}/messages/${params.message_id}/threads`
+                        : `/channels/${params.channel_id}/threads`;
+                    const res = await discordRequest('POST', endpoint, body, token);
+                    if (!res.ok) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'DISCORD_API_ERROR',
+                                message: discordErrorMessage(res.data, res.status),
+                            },
+                        };
+                    }
+                    const threadData = res.data;
+                    return {
+                        success: true,
+                        data: {
+                            action: 'create_thread',
+                            success: true,
+                            details: {
+                                thread_id: threadData?.id,
+                                name: params.name,
+                                channel_id: params.channel_id,
+                            },
+                        },
+                        output: `Thread "${params.name}" created (ID: ${String(threadData?.id ?? 'unknown')})`,
+                    };
+                }
+                case 'ban_user': {
+                    const body = {};
+                    if (params.delete_message_days !== undefined) {
+                        body.delete_message_seconds = params.delete_message_days * 86400;
+                    }
+                    const res = await discordRequest('PUT', `/guilds/${params.guild_id}/bans/${params.user_id}`, Object.keys(body).length > 0 ? body : undefined, token);
+                    if (!res.ok) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'DISCORD_API_ERROR',
+                                message: discordErrorMessage(res.data, res.status),
+                            },
+                        };
+                    }
+                    logger.warn(`[DiscordActions] User banned: ${params.user_id} from guild ${params.guild_id}`, {
+                        component: 'DiscordActions',
+                    });
+                    return {
+                        success: true,
+                        data: {
+                            action: 'ban_user',
+                            success: true,
+                            details: {
+                                guild_id: params.guild_id,
+                                user_id: params.user_id,
+                                reason: params.reason,
+                            },
+                        },
+                        output: `User ${params.user_id} banned from guild ${params.guild_id}${params.reason ? ` (Reason: ${params.reason})` : ''}`,
+                    };
+                }
+                case 'kick_user': {
+                    const res = await discordRequest('DELETE', `/guilds/${params.guild_id}/members/${params.user_id}`, undefined, token);
+                    if (!res.ok) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'DISCORD_API_ERROR',
+                                message: discordErrorMessage(res.data, res.status),
+                            },
+                        };
+                    }
+                    logger.warn(`[DiscordActions] User kicked: ${params.user_id} from guild ${params.guild_id}`, {
+                        component: 'DiscordActions',
+                    });
+                    return {
+                        success: true,
+                        data: {
+                            action: 'kick_user',
+                            success: true,
+                            details: {
+                                guild_id: params.guild_id,
+                                user_id: params.user_id,
+                                reason: params.reason,
+                            },
+                        },
+                        output: `User ${params.user_id} kicked from guild ${params.guild_id}${params.reason ? ` (Reason: ${params.reason})` : ''}`,
+                    };
+                }
+                case 'set_channel_topic': {
+                    const res = await discordRequest('PATCH', `/channels/${params.channel_id}`, { topic: params.topic }, token);
+                    if (!res.ok) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'DISCORD_API_ERROR',
+                                message: discordErrorMessage(res.data, res.status),
+                            },
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: {
+                            action: 'set_channel_topic',
+                            success: true,
+                            details: { channel_id: params.channel_id, topic: params.topic },
+                        },
+                        output: `Channel ${params.channel_id} topic updated: "${params.topic}"`,
+                    };
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`[DiscordActions] Failed: ${message}`, { component: 'DiscordActions' });
+            return {
+                success: false,
+                error: {
+                    code: 'DISCORD_ACTION_FAILED',
+                    message: `Discord action failed: ${message}`,
+                    retryable: true,
+                },
+            };
+        }
+    },
+};
+//# sourceMappingURL=discord-actions.js.map

package/dist/chat/execution/tools/exec.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Exec Tool
+ *
+ * Execute shell commands with safety controls.
+ * Supports background execution, PTY, and output streaming.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const ExecParamsSchema: z.ZodObject<{
+    command: z.ZodString;
+    workdir: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    timeout?: number | undefined;
+    env?: Record<string, string> | undefined;
+    workdir?: string | undefined;
+    background?: boolean | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+    env?: Record<string, string> | undefined;
+    workdir?: string | undefined;
+    background?: boolean | undefined;
+}>;
+export type ExecParams = z.infer<typeof ExecParamsSchema>;
+export declare const execTool: ToolDefinition<ExecParams, ExecResult>;
+export interface ExecResult {
+    status: 'completed' | 'failed' | 'running';
+    exitCode?: number | null;
+    exitSignal?: string;
+    stdout?: string;
+    stderr?: string;
+    durationMs?: number;
+    timedOut?: boolean;
+    sessionId?: string;
+    pid?: number;
+    output?: string;
+}
+export {};
+//# sourceMappingURL=exec.d.ts.map