aiquila-mcp 0.3.17 → 0.3.20

package/dist/client/news.js

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+import { getNextcloudConfig } from '../tools/types.js';
+import { logger } from '../logger.js';
+import { ApiError } from './aiquila.js';
+/**
+ * Make an authenticated request to the Nextcloud News REST API v1-3.
+ *
+ * Base path: /index.php/apps/news/api/v1-3
+ *
+ * Returns plain JSON (no OCS envelope), like the Notes API.
+ */
+export async function fetchNewsAPI(endpoint, options = {}) {
+    const config = getNextcloudConfig();
+    const auth = Buffer.from(`${config.user}:${config.password}`).toString('base64');
+    let url = `${config.url}/index.php/apps/news/api/v1-3${endpoint}`;
+    if (options.queryParams) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options.queryParams)) {
+            if (value !== undefined)
+                params.append(key, String(value));
+        }
+        const qs = params.toString();
+        if (qs)
+            url += `?${qs}`;
+    }
+    const headers = {
+        Authorization: `Basic ${auth}`,
+        'OCS-APIRequest': 'true',
+        Accept: 'application/json',
+    };
+    let body;
+    if (options.body !== undefined) {
+        body = JSON.stringify(options.body);
+        headers['Content-Type'] = 'application/json';
+    }
+    const method = options.method ?? 'GET';
+    const t0 = Date.now();
+    const response = await fetch(url, { method, headers, body });
+    logger.trace({ method, url, status: response.status, ms: Date.now() - t0 }, '[news] HTTP');
+    if (!response.ok) {
+        const text = await response.text();
+        throw new ApiError(response.status, response.statusText, text);
+    }
+    if (response.status === 200 &&
+        response.headers.get('content-type')?.includes('application/json')) {
+        return (await response.json());
+    }
+    return undefined;
+}

package/dist/tool-registry.js

@@ -15,7 +15,9 @@ import { calendarTools } from './tools/apps/calendar.js';
 import { cookbookTools } from './tools/apps/cookbook.js';
 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';
@@ -62,11 +64,13 @@ 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 },
     { category: 'contacts', appIds: ['contacts'], tools: contactsTools },
     { category: 'notes', appIds: ['notes'], tools: notesTools },
+    { category: 'news', appIds: ['news'], tools: newsTools },
     { category: 'mail', appIds: ['mail'], tools: mailTools },
     { category: 'deck', appIds: ['deck'], tools: deckTools },
     { category: 'cookbook', appIds: ['cookbook'], tools: cookbookTools },

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/dist/tools/apps/news.js

@@ -0,0 +1,411 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchNewsAPI } from '../../client/news.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 }] };
+}
+/** Strip HTML tags and collapse whitespace, then truncate. */
+function stripHtml(html, max = 280) {
+    const plain = html
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return plain.length > max ? `${plain.slice(0, max)}…` : plain;
+}
+function formatFeed(f) {
+    const parts = [`- **${f.title || '(untitled)'}** — ${f.url}`];
+    parts.push(`  ID: ${f.id} | Folder: ${f.folderId} | Unread: ${f.unreadCount}`);
+    if (f.lastUpdateError)
+        parts.push(`  ⚠ Update error: ${f.lastUpdateError}`);
+    return parts.join('\n');
+}
+function formatItem(i) {
+    const flags = [i.unread ? 'unread' : 'read', i.starred ? 'starred' : null]
+        .filter(Boolean)
+        .join(', ');
+    const lines = [`- **${i.title || '(untitled)'}**  (ID: ${i.id}, feed: ${i.feedId}, ${flags})`];
+    lines.push(`  ${i.url}`);
+    if (i.author)
+        lines.push(`  by ${i.author} — ${new Date(i.pubDate * 1000).toISOString()}`);
+    else
+        lines.push(`  ${new Date(i.pubDate * 1000).toISOString()}`);
+    if (i.body)
+        lines.push(`  ${stripHtml(i.body)}`);
+    return lines.join('\n');
+}
+// ── Feed tools ──────────────────────────────────────────────────────────────
+export const listFeedsTool = {
+    name: 'list_feeds',
+    description: 'List all RSS feeds subscribed in the Nextcloud News app, with unread counts.',
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const result = await fetchNewsAPI('/feeds');
+            if (!result.feeds || result.feeds.length === 0) {
+                return text('No feeds subscribed.');
+            }
+            const formatted = result.feeds.map(formatFeed).join('\n');
+            return text(`Feeds (${result.feeds.length}):\n\n${formatted}`);
+        }
+        catch (error) {
+            return err('listing feeds', error);
+        }
+    },
+};
+export const addFeedTool = {
+    name: 'add_feed',
+    description: 'Subscribe to a new RSS feed by URL, optionally placing it in a folder.',
+    inputSchema: z.object({
+        url: z.string().describe('The RSS/Atom feed URL to subscribe to'),
+        folderId: z.number().optional().describe('Folder ID to place the feed in (omit for root)'),
+    }),
+    handler: async (args) => {
+        try {
+            const body = { url: args.url };
+            if (args.folderId !== undefined)
+                body.folderId = args.folderId;
+            const result = await fetchNewsAPI('/feeds', { method: 'POST', body });
+            const feed = result.feeds?.[0];
+            return text(feed
+                ? `Subscribed to feed "${feed.title}" (ID: ${feed.id}).`
+                : `Subscribed to feed: ${args.url}`);
+        }
+        catch (error) {
+            return err('adding feed', error);
+        }
+    },
+};
+export const deleteFeedTool = {
+    name: 'delete_feed',
+    description: 'Delete (unsubscribe from) a feed and all its items.',
+    inputSchema: z.object({
+        feedId: z.number().describe('The feed ID to delete'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/feeds/${args.feedId}`, { method: 'DELETE' });
+            return text(`Deleted feed ${args.feedId}.`);
+        }
+        catch (error) {
+            return err('deleting feed', error);
+        }
+    },
+};
+export const moveFeedTool = {
+    name: 'move_feed',
+    description: 'Move a feed into a different folder.',
+    inputSchema: z.object({
+        feedId: z.number().describe('The feed ID to move'),
+        folderId: z.number().describe('Destination folder ID (0 for root)'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/feeds/${args.feedId}/move`, {
+                method: 'POST',
+                body: { folderId: args.folderId },
+            });
+            return text(`Moved feed ${args.feedId} to folder ${args.folderId}.`);
+        }
+        catch (error) {
+            return err('moving feed', error);
+        }
+    },
+};
+export const renameFeedTool = {
+    name: 'rename_feed',
+    description: 'Rename a feed.',
+    inputSchema: z.object({
+        feedId: z.number().describe('The feed ID to rename'),
+        feedTitle: z.string().describe('The new feed title'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/feeds/${args.feedId}/rename`, {
+                method: 'POST',
+                body: { feedTitle: args.feedTitle },
+            });
+            return text(`Renamed feed ${args.feedId} to "${args.feedTitle}".`);
+        }
+        catch (error) {
+            return err('renaming feed', error);
+        }
+    },
+};
+export const markFeedReadTool = {
+    name: 'mark_feed_read',
+    description: 'Mark all items in a feed as read up to (and including) the given newest item ID.',
+    inputSchema: z.object({
+        feedId: z.number().describe('The feed ID'),
+        newestItemId: z.number().describe('Mark all items with ID <= this value as read'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/feeds/${args.feedId}/read`, {
+                method: 'POST',
+                body: { newestItemId: args.newestItemId },
+            });
+            return text(`Marked feed ${args.feedId} read up to item ${args.newestItemId}.`);
+        }
+        catch (error) {
+            return err('marking feed read', error);
+        }
+    },
+};
+// ── Folder tools ────────────────────────────────────────────────────────────
+export const listNewsFoldersTool = {
+    name: 'list_news_folders',
+    description: 'List all folders used to organize feeds in the Nextcloud News app.',
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const result = await fetchNewsAPI('/folders');
+            if (!result.folders || result.folders.length === 0) {
+                return text('No folders found.');
+            }
+            const formatted = result.folders.map((f) => `- **${f.name}** (ID: ${f.id})`).join('\n');
+            return text(`News folders (${result.folders.length}):\n\n${formatted}`);
+        }
+        catch (error) {
+            return err('listing folders', error);
+        }
+    },
+};
+export const createNewsFolderTool = {
+    name: 'create_news_folder',
+    description: 'Create a new folder for organizing feeds in the News app.',
+    inputSchema: z.object({
+        name: z.string().describe('The folder name'),
+    }),
+    handler: async (args) => {
+        try {
+            const result = await fetchNewsAPI('/folders', {
+                method: 'POST',
+                body: { name: args.name },
+            });
+            const folder = result.folders?.[0];
+            return text(folder
+                ? `Created folder "${folder.name}" (ID: ${folder.id}).`
+                : `Created folder "${args.name}".`);
+        }
+        catch (error) {
+            return err('creating folder', error);
+        }
+    },
+};
+export const renameNewsFolderTool = {
+    name: 'rename_news_folder',
+    description: 'Rename a News folder.',
+    inputSchema: z.object({
+        folderId: z.number().describe('The folder ID to rename'),
+        name: z.string().describe('The new folder name'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/folders/${args.folderId}`, {
+                method: 'PUT',
+                body: { name: args.name },
+            });
+            return text(`Renamed folder ${args.folderId} to "${args.name}".`);
+        }
+        catch (error) {
+            return err('renaming folder', error);
+        }
+    },
+};
+export const deleteNewsFolderTool = {
+    name: 'delete_news_folder',
+    description: 'Delete a News folder and all feeds it contains.',
+    inputSchema: z.object({
+        folderId: z.number().describe('The folder ID to delete'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/folders/${args.folderId}`, { method: 'DELETE' });
+            return text(`Deleted folder ${args.folderId}.`);
+        }
+        catch (error) {
+            return err('deleting folder', error);
+        }
+    },
+};
+export const markNewsFolderReadTool = {
+    name: 'mark_news_folder_read',
+    description: 'Mark all items in a folder as read up to (and including) the given newest item ID.',
+    inputSchema: z.object({
+        folderId: z.number().describe('The folder ID'),
+        newestItemId: z.number().describe('Mark all items with ID <= this value as read'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/folders/${args.folderId}/read`, {
+                method: 'POST',
+                body: { newestItemId: args.newestItemId },
+            });
+            return text(`Marked folder ${args.folderId} read up to item ${args.newestItemId}.`);
+        }
+        catch (error) {
+            return err('marking folder read', error);
+        }
+    },
+};
+// ── Item / article tools ────────────────────────────────────────────────────
+export const listNewsItemsTool = {
+    name: 'list_news_items',
+    description: 'List news articles (items). Filter by feed, folder, starred, or all; supports pagination and read/unread filtering.',
+    inputSchema: z.object({
+        type: z
+            .enum(['feed', 'folder', 'starred', 'all'])
+            .optional()
+            .describe('Scope of items to return (default "all")'),
+        id: z
+            .number()
+            .optional()
+            .describe('Feed or folder ID when type is "feed" or "folder" (default 0)'),
+        batchSize: z.number().optional().describe('Max items to return (default 20, -1 for all)'),
+        offset: z.number().optional().describe('Return items older than this item ID (pagination)'),
+        getRead: z.boolean().optional().describe('Include already-read items (default false)'),
+        oldestFirst: z
+            .boolean()
+            .optional()
+            .describe('Return oldest items first (default newest first)'),
+    }),
+    handler: async (args) => {
+        try {
+            const typeMap = { feed: 0, folder: 1, starred: 2, all: 3 };
+            const queryParams = {
+                type: typeMap[args.type ?? 'all'],
+                id: args.id ?? 0,
+                batchSize: args.batchSize ?? 20,
+                getRead: args.getRead ?? false,
+                oldestFirst: args.oldestFirst ?? false,
+            };
+            if (args.offset !== undefined)
+                queryParams.offset = args.offset;
+            const result = await fetchNewsAPI('/items', { queryParams });
+            if (!result.items || result.items.length === 0) {
+                return text('No items found.');
+            }
+            const formatted = result.items.map(formatItem).join('\n\n');
+            return text(`Items (${result.items.length}):\n\n${formatted}`);
+        }
+        catch (error) {
+            return err('listing items', error);
+        }
+    },
+};
+export const markItemReadTool = {
+    name: 'mark_item_read',
+    description: 'Mark a single news item as read.',
+    inputSchema: z.object({
+        itemId: z.number().describe('The item ID'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/items/${args.itemId}/read`, { method: 'POST' });
+            return text(`Marked item ${args.itemId} read.`);
+        }
+        catch (error) {
+            return err('marking item read', error);
+        }
+    },
+};
+export const markItemUnreadTool = {
+    name: 'mark_item_unread',
+    description: 'Mark a single news item as unread.',
+    inputSchema: z.object({
+        itemId: z.number().describe('The item ID'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/items/${args.itemId}/unread`, { method: 'POST' });
+            return text(`Marked item ${args.itemId} unread.`);
+        }
+        catch (error) {
+            return err('marking item unread', error);
+        }
+    },
+};
+export const starItemTool = {
+    name: 'star_item',
+    description: 'Star (favorite) a single news item.',
+    inputSchema: z.object({
+        itemId: z.number().describe('The item ID'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/items/${args.itemId}/star`, { method: 'POST' });
+            return text(`Starred item ${args.itemId}.`);
+        }
+        catch (error) {
+            return err('starring item', error);
+        }
+    },
+};
+export const unstarItemTool = {
+    name: 'unstar_item',
+    description: 'Remove the star from a single news item.',
+    inputSchema: z.object({
+        itemId: z.number().describe('The item ID'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI(`/items/${args.itemId}/unstar`, { method: 'POST' });
+            return text(`Unstarred item ${args.itemId}.`);
+        }
+        catch (error) {
+            return err('unstarring item', error);
+        }
+    },
+};
+export const markItemsReadTool = {
+    name: 'mark_items_read',
+    description: 'Mark multiple news items as read in one call.',
+    inputSchema: z.object({
+        itemIds: z.array(z.number()).describe('The item IDs to mark as read'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchNewsAPI('/items/read/multiple', {
+                method: 'POST',
+                body: { itemIds: args.itemIds },
+            });
+            return text(`Marked ${args.itemIds.length} item(s) read.`);
+        }
+        catch (error) {
+            return err('marking items read', error);
+        }
+    },
+};
+// ── Export ──────────────────────────────────────────────────────────────────
+export const newsTools = [
+    listFeedsTool,
+    addFeedTool,
+    deleteFeedTool,
+    moveFeedTool,
+    renameFeedTool,
+    markFeedReadTool,
+    listNewsFoldersTool,
+    createNewsFolderTool,
+    renameNewsFolderTool,
+    deleteNewsFolderTool,
+    markNewsFolderReadTool,
+    listNewsItemsTool,
+    markItemReadTool,
+    markItemUnreadTool,
+    starItemTool,
+    unstarItemTool,
+    markItemsReadTool,
+];

package/package.json

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