aiquila-mcp 0.3.18 → 0.3.20

package/dist/tool-registry.js

@@ -17,6 +17,7 @@ import { deckTools } from './tools/apps/deck.js';
 import { notesTools } from './tools/apps/notes.js';
 import { newsTools } from './tools/apps/news.js';
 import { aiquilaTools } from './tools/apps/aiquila.js';
+import { coworkTools } from './tools/apps/cowork.js';
 import { usersTools } from './tools/apps/users.js';
 import { groupsTools } from './tools/apps/groups.js';
 import { circlesTools } from './tools/apps/circles.js';
@@ -63,6 +64,7 @@ export const TOOL_REGISTRY = [
     { category: 'security', appIds: ['aiquila'], tools: securityTools },
     { category: 'occ', appIds: ['aiquila'], tools: occTools },
     { category: 'projects', appIds: ['aiquila'], tools: projectsTools },
+    { category: 'cowork', appIds: ['aiquila'], tools: coworkTools },
     // Requires specific Nextcloud apps
     { category: 'calendar', appIds: ['calendar'], tools: calendarTools },
     { category: 'tasks', appIds: ['tasks'], tools: tasksTools },

package/dist/tools/apps/cowork.js

@@ -0,0 +1,259 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchAiquilaAPI } from '../../client/aiquila.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function err(action, error) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Error ${action}: ${error instanceof Error ? error.message : String(error)}`,
+            },
+        ],
+        isError: true,
+    };
+}
+function text(body) {
+    return { content: [{ type: 'text', text: body }] };
+}
+function fmtTime(epoch) {
+    return epoch ? new Date(epoch * 1000).toISOString() : '—';
+}
+function formatCoworker(c) {
+    const state = !c.isActive ? 'disabled' : c.paused ? 'paused' : 'active';
+    const lines = [
+        `- **${c.title}** (ID: ${c.id}) — ${state}`,
+        `  task: ${c.taskType} | provider: ${c.model ?? 'default'} | input: ${c.inputPath ?? '/'}`,
+        `  schedule: ${c.cronSchedule} | next run: ${fmtTime(c.nextRunAt)} | last run: ${fmtTime(c.lastRunAt)}${c.lastStatus ? ` (${c.lastStatus})` : ''}`,
+    ];
+    if (c.lastError)
+        lines.push(`  ⚠ last error: ${c.lastError}`);
+    return lines.join('\n');
+}
+// ── Tools ────────────────────────────────────────────────────────────────────
+export const listCoworkersTool = {
+    name: 'list_coworkers',
+    description: "List the current user's coworkers (persistent scheduled AI tasks) with their status, provider, schedule and last run.",
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const coworkers = await fetchAiquilaAPI('/coworkers');
+            if (coworkers.length === 0) {
+                return text('No coworkers configured. Use create_coworker (optionally with a templateId) to add one.');
+            }
+            return text(coworkers.map(formatCoworker).join('\n\n'));
+        }
+        catch (error) {
+            return err('listing coworkers', error);
+        }
+    },
+};
+export const listCoworkerTemplatesTool = {
+    name: 'list_coworker_templates',
+    description: 'List built-in coworker templates (e.g. image classification via Claude vision or Mistral Pixtral) and available task types.',
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const data = await fetchAiquilaAPI('/coworkers/templates');
+            const tpls = data.templates
+                .map((t) => `- **${t.title}** (id: ${t.id})${t.description ? ` — ${t.description}` : ''}`)
+                .join('\n');
+            const types = data.taskTypes.map((t) => `- ${t.id} (${t.family}) — ${t.label}`).join('\n');
+            return text(`Templates:\n${tpls}\n\nTask types:\n${types}`);
+        }
+        catch (error) {
+            return err('listing templates', error);
+        }
+    },
+};
+export const getCoworkerTool = {
+    name: 'get_coworker',
+    description: 'Get a single coworker by ID, including its schedule and last run status.',
+    inputSchema: z.object({ id: z.number().describe('Coworker ID') }),
+    handler: async (args) => {
+        try {
+            const c = await fetchAiquilaAPI(`/coworkers/${args.id}`);
+            return text(formatCoworker(c));
+        }
+        catch (error) {
+            return err('getting coworker', error);
+        }
+    },
+};
+export const createCoworkerTool = {
+    name: 'create_coworker',
+    description: 'Create a coworker. Provide templateId to start from a built-in template (e.g. "classify-images-claude" or "classify-images-pixtral"), and/or explicit fields to configure a custom one. Fields override template defaults.',
+    inputSchema: z.object({
+        templateId: z
+            .string()
+            .optional()
+            .describe('Built-in template id (see list_coworker_templates)'),
+        title: z.string().optional(),
+        taskType: z.string().optional().describe('Task type id, e.g. "vision:classify"'),
+        model: z
+            .string()
+            .optional()
+            .describe('Provider id: "anthropic" (Claude) or "mistral" (Pixtral)'),
+        inputPath: z.string().optional().describe('Folder to process, e.g. "/Photos"'),
+        cronSchedule: z.string().optional().describe('5-field cron, e.g. "0 3 * * *"'),
+        maxTags: z.number().optional().describe('Max tags per image (vision:classify)'),
+        recursive: z.boolean().optional().describe('Include sub-folders'),
+        isActive: z.boolean().optional().describe('Whether the coworker is enabled'),
+    }),
+    handler: async (args) => {
+        try {
+            const body = {};
+            if (args.title !== undefined)
+                body.title = args.title;
+            if (args.taskType !== undefined)
+                body.task_type = args.taskType;
+            if (args.model !== undefined)
+                body.model = args.model;
+            if (args.inputPath !== undefined) {
+                body.input_type = 'folder';
+                body.input_path = args.inputPath;
+            }
+            if (args.cronSchedule !== undefined)
+                body.cron_schedule = args.cronSchedule;
+            if (args.isActive !== undefined)
+                body.is_active = args.isActive;
+            const options = {};
+            if (args.maxTags !== undefined)
+                options.maxTags = args.maxTags;
+            if (args.recursive !== undefined)
+                options.recursive = args.recursive;
+            if (Object.keys(options).length > 0)
+                body.options = options;
+            const endpoint = args.templateId ? '/coworkers/templates' : '/coworkers';
+            if (args.templateId)
+                body.templateId = args.templateId;
+            const c = await fetchAiquilaAPI(endpoint, { method: 'POST', body });
+            return text(`Coworker created:\n${formatCoworker(c)}`);
+        }
+        catch (error) {
+            return err('creating coworker', error);
+        }
+    },
+};
+export const updateCoworkerTool = {
+    name: 'update_coworker',
+    description: "Update a coworker's configuration (title, provider, input folder, schedule, options).",
+    inputSchema: z.object({
+        id: z.number().describe('Coworker ID'),
+        title: z.string().optional(),
+        model: z.string().optional().describe('"anthropic" or "mistral"'),
+        inputPath: z.string().optional(),
+        cronSchedule: z.string().optional(),
+        maxTags: z.number().optional(),
+        recursive: z.boolean().optional(),
+    }),
+    handler: async (args) => {
+        try {
+            const body = {};
+            if (args.title !== undefined)
+                body.title = args.title;
+            if (args.model !== undefined)
+                body.model = args.model;
+            if (args.inputPath !== undefined) {
+                body.input_type = 'folder';
+                body.input_path = args.inputPath;
+            }
+            if (args.cronSchedule !== undefined)
+                body.cron_schedule = args.cronSchedule;
+            const options = {};
+            if (args.maxTags !== undefined)
+                options.maxTags = args.maxTags;
+            if (args.recursive !== undefined)
+                options.recursive = args.recursive;
+            if (Object.keys(options).length > 0)
+                body.options = options;
+            const c = await fetchAiquilaAPI(`/coworkers/${args.id}`, { method: 'PUT', body });
+            return text(`Coworker updated:\n${formatCoworker(c)}`);
+        }
+        catch (error) {
+            return err('updating coworker', error);
+        }
+    },
+};
+export const deleteCoworkerTool = {
+    name: 'delete_coworker',
+    description: 'Delete a coworker and its run history.',
+    inputSchema: z.object({ id: z.number().describe('Coworker ID') }),
+    handler: async (args) => {
+        try {
+            await fetchAiquilaAPI(`/coworkers/${args.id}`, { method: 'DELETE' });
+            return text(`Coworker ${args.id} deleted.`);
+        }
+        catch (error) {
+            return err('deleting coworker', error);
+        }
+    },
+};
+function stateTool(name, description, action) {
+    return {
+        name,
+        description,
+        inputSchema: z.object({ id: z.number().describe('Coworker ID') }),
+        handler: async (args) => {
+            try {
+                if (action === 'run') {
+                    const run = await fetchAiquilaAPI(`/coworkers/${args.id}/run`, {
+                        method: 'POST',
+                    });
+                    return text(`Run finished: ${run.status} — processed ${run.itemsProcessed}/${run.itemsTotal}.` +
+                        (run.summary ? `\n${run.summary}` : '') +
+                        (run.error ? `\n⚠ ${run.error}` : ''));
+                }
+                const c = await fetchAiquilaAPI(`/coworkers/${args.id}/${action}`, {
+                    method: 'POST',
+                });
+                return text(`Coworker ${action}d:\n${formatCoworker(c)}`);
+            }
+            catch (error) {
+                return err(`${action} coworker`, error);
+            }
+        },
+    };
+}
+export const enableCoworkerTool = stateTool('enable_coworker', 'Enable a coworker so it runs on its schedule.', 'enable');
+export const disableCoworkerTool = stateTool('disable_coworker', 'Disable a coworker so it stops running on its schedule.', 'disable');
+export const pauseCoworkerTool = stateTool('pause_coworker', 'Temporarily pause a coworker without disabling it.', 'pause');
+export const resumeCoworkerTool = stateTool('resume_coworker', 'Resume a paused coworker.', 'resume');
+export const runCoworkerTool = stateTool('run_coworker', 'Run a coworker immediately (synchronously) and return the run result.', 'run');
+export const getCoworkerRunsTool = {
+    name: 'get_coworker_runs',
+    description: 'Get recent run history (progress, status, summary) for a coworker.',
+    inputSchema: z.object({
+        id: z.number().describe('Coworker ID'),
+        limit: z.number().optional().describe('Max runs to return (default 20)'),
+    }),
+    handler: async (args) => {
+        try {
+            const runs = await fetchAiquilaAPI(`/coworkers/${args.id}/runs`, {
+                queryParams: args.limit ? { limit: String(args.limit) } : undefined,
+            });
+            if (runs.length === 0)
+                return text('No runs yet for this coworker.');
+            const lines = runs.map((r) => `- #${r.id} ${r.status} — ${r.itemsProcessed}/${r.itemsTotal} — ${fmtTime(r.startedAt)}` +
+                (r.error ? ` — ⚠ ${r.error}` : r.summary ? ` — ${r.summary.split('\n')[0]}` : ''));
+            return text(lines.join('\n'));
+        }
+        catch (error) {
+            return err('getting coworker runs', error);
+        }
+    },
+};
+export const coworkTools = [
+    listCoworkersTool,
+    listCoworkerTemplatesTool,
+    getCoworkerTool,
+    createCoworkerTool,
+    updateCoworkerTool,
+    deleteCoworkerTool,
+    enableCoworkerTool,
+    disableCoworkerTool,
+    pauseCoworkerTool,
+    resumeCoworkerTool,
+    runCoworkerTool,
+    getCoworkerRunsTool,
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiquila-mcp",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "description": "Nextcloud MCP server — files, calendar, contacts, mail, maps, notes, tasks & 120+ more tools",
   "type": "module",
   "main": "dist/index.js",