@questionbase/deskfree 0.3.0-alpha.2 → 0.3.0-alpha.21

package/skills/deskfree/references/tools.md

@@ -0,0 +1,144 @@
+# DeskFree Tools — Full Parameter Reference
+
+## Orchestrator Tools (10)
+
+### `deskfree_state`
+Get full workspace snapshot — all tasks, recently done tasks, active initiatives, current ways of working, and pending evaluations.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| *(none)* | — | — | — |
+
+**Returns:**
+- `tasks` — active tasks array
+- `recentlyDone` — recently completed tasks
+- `waysOfWorking` — global ways of working (string or null)
+- `pendingEvaluations` — array of `{taskId, taskNumber, title, initiativeId?}`
+- `initiatives` — active initiatives with `{id, title, status, content, contentVersion, taskCount, activeTaskCount}`
+
+---
+
+### `deskfree_start_task`
+Claim a `bot` task → moves to `bot` (is_working=true). Returns full context.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | Task UUID to claim |
+
+**Returns:** Full task context — instructions, current deliverable, message history, and `parentContext` (title, deliverable, instructions of the parent task if this was suggested by another task). Use this to populate sub-agent spawn prompts.
+
+**Errors:** 404 if task not `bot` or doesn't exist. 409 if already claimed.
+
+---
+
+### `deskfree_update_deliverable`
+Update task deliverable. Build incrementally as you work.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | Task UUID |
+| `deliverable` | string | Yes | Full markdown deliverable content (replaces previous) |
+
+**Note:** Each call replaces the entire deliverable. Always send the complete current version, not just new additions.
+
+---
+
+### `deskfree_complete_task`
+Finish a task → moves to `human`.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | Task UUID |
+| `outcome` | string | Yes | `done` (work complete) or `blocked` (need human input) |
+
+**Important:** If `blocked`, send a message explaining WHY before calling this.
+
+---
+
+### `deskfree_send_message`
+Send a message in the task thread (progress update, question, status report).
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `content` | string | No | Message content. Required unless `suggestions` is provided. |
+| `taskId` | string | No | Task UUID (optional — auto-threaded to active task if omitted) |
+| `suggestions` | array | No | List of tasks to suggest for human review (1-10). Prefer `deskfree_suggest_tasks` for richer suggestions with estimatedTokens and dependencies. |
+
+---
+
+### `deskfree_suggest_tasks`
+Suggest tasks for human approval. Creates tasks with `suggested` status. Can also propose new initiatives.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `suggestions` | array | Yes | Array of task suggestions (1-20) |
+| `suggestions[].title` | string | Yes | Task title — short, action-oriented (max 200 chars) |
+| `suggestions[].instructions` | string | No | Detailed instructions: what to do, why, what done looks like, constraints |
+| `suggestions[].estimatedTokens` | number | No | Estimated token cost for completing this task |
+| `suggestions[].dependsOn` | string[] | No | Task IDs this depends on (blocks claiming until those are done) |
+| `suggestions[].initiativeId` | string | No | Link task to an existing active initiative |
+| `initiativeSuggestions` | array | No | Propose new initiatives (0-5) |
+| `initiativeSuggestions[].title` | string | Yes | Initiative title (max 200 chars) |
+| `initiativeSuggestions[].content` | string | Yes | Initial initiative content (markdown — current state, approach, next priorities) |
+| `initiativeSuggestions[].taskRefs` | number[] | No | Indexes into `suggestions[]` to auto-link when approved |
+| `parentTaskId` | string | No | Parent task ID — set when suggesting follow-ups from within a task |
+
+**Returns:** `{ suggestionIds: string[], initiativeSuggestionIds?: string[] }`
+
+---
+
+### `deskfree_complete_and_suggest`
+Complete the current task AND suggest follow-up tasks in one atomic call.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | Task UUID to complete |
+| `outcome` | string | Yes | `done` or `blocked` |
+| `suggestions` | array | No | Follow-up task suggestions (0-20) |
+| `suggestions[].title` | string | Yes | Task title (max 200 chars) |
+| `suggestions[].instructions` | string | No | Detailed instructions |
+| `suggestions[].estimatedTokens` | number | No | Estimated token cost |
+| `suggestions[].dependsOnTaskIds` | string[] | No | Task IDs this depends on |
+| `suggestions[].initiativeId` | string | No | Link to existing initiative |
+| `initiativeSuggestions` | array | No | Propose new initiatives (same schema as deskfree_suggest_tasks) |
+
+**Returns:** Updated task object + `suggestionIds` array (if suggestions were created) + `initiativeSuggestionIds` (if initiatives were suggested).
+
+**Note:** Deliverable required for outcome `done`. Task moves to `human` for review.
+
+---
+
+### `deskfree_claim_evaluation`
+Claim a pending evaluation. Atomically sets `isWorking=true` where `evaluationPending=true` and `isWorking=false`. Returns null if already claimed.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | Task UUID from `pendingEvaluations` list |
+
+**Returns:** `{ task, waysOfWorking, currentVersion, messages, initiative? }` — full evaluation context including initiative data (if task is linked to one), or `null` if already claimed.
+
+---
+
+### `deskfree_submit_evaluation`
+Submit the result of an evaluation. Supports dual output: global ways of working + initiative content. Always call this after `deskfree_claim_evaluation`.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `taskId` | string | Yes | Task UUID being evaluated |
+| `reasoning` | string | Yes | Explanation of your analysis — what you learned |
+| `globalWoW` | object | Yes | Global ways of working update |
+| `globalWoW.hasChanges` | boolean | Yes | Whether global WoW should be updated |
+| `globalWoW.updatedContent` | string | No | Full updated global WoW markdown (required if hasChanges=true) |
+| `initiative` | object | No | Initiative content update (only if task has initiative_id) |
+| `initiative.hasChanges` | boolean | Yes | Whether initiative content should be updated |
+| `initiative.updatedContent` | string | No | Full updated initiative content markdown (required if hasChanges=true) |
+
+**Returns:** `{ success, globalVersion?, initiativeVersion? }`
+
+---
+
+## Worker Tools (4 — sub-agents only)
+
+Sub-agents receive: `deskfree_update_deliverable`, `deskfree_complete_task`, `deskfree_send_message`, `deskfree_submit_evaluation`
+
+They **cannot** use: `deskfree_state`, `deskfree_suggest_tasks`, `deskfree_start_task`, `deskfree_claim_evaluation`

package/dist/channel.d.ts

@@ -1,3 +0,0 @@
-import type { ChannelPlugin } from './types';
-export declare const deskFreePlugin: ChannelPlugin;
-//# sourceMappingURL=channel.d.ts.map

package/dist/channel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAGV,aAAa,EAId,MAAM,SAAS,CAAC;AAMjB,eAAO,MAAM,cAAc,EAAE,aAgjB5B,CAAC"}

package/dist/channel.js

@@ -1,505 +0,0 @@
-import { DeskFreeClient } from './client';
-import { getActiveTaskId, startDeskFreeConnection } from './gateway';
-import { CHANNEL_HINTS, CHANNEL_META, STATUS_MESSAGES, } from './llm-definitions';
-import { getDeskFreeRuntime } from './runtime';
-function getChannelConfig(cfg) {
-    return cfg?.channels?.deskfree ?? null;
-}
-export const deskFreePlugin = {
-    id: 'deskfree',
-    meta: CHANNEL_META,
-    capabilities: {
-        text: true,
-        media: false,
-        reactions: false,
-        threads: true,
-        editing: false,
-    },
-    config: {
-        listAccountIds(cfg) {
-            const ch = getChannelConfig(cfg);
-            if (!ch)
-                return [];
-            if (ch.accounts && Object.keys(ch.accounts).length > 0) {
-                return Object.keys(ch.accounts);
-            }
-            return ['default'];
-        },
-        resolveAccount(cfg, accountId) {
-            const ch = getChannelConfig(cfg);
-            if (!ch) {
-                return {
-                    accountId: accountId ?? 'default',
-                    botToken: '',
-                    apiUrl: '',
-                    wsUrl: '',
-                    userId: '',
-                    enabled: false,
-                };
-            }
-            const id = accountId ?? 'default';
-            const acct = id !== 'default' && ch.accounts?.[id] ? ch.accounts[id] : ch;
-            return {
-                accountId: id,
-                botToken: acct.botToken ?? '',
-                apiUrl: acct.apiUrl ?? '',
-                wsUrl: acct.wsUrl ?? '',
-                userId: acct.userId ?? '',
-                enabled: acct.enabled !== false,
-                botName: acct.botName,
-                humanName: acct.humanName,
-            };
-        },
-        isConfigured(account) {
-            return Boolean(account.botToken && account.apiUrl);
-        },
-        isEnabled(account) {
-            return account.enabled;
-        },
-        describeAccount(account) {
-            const isConfigured = Boolean(account.botToken && account.apiUrl);
-            return {
-                accountId: account.accountId,
-                enabled: account.enabled,
-                configured: isConfigured,
-            };
-        },
-    },
-    outbound: {
-        deliveryMode: 'direct',
-        chunkerMode: 'markdown',
-        textChunkLimit: 2000,
-        resolveTarget(_target, { cfg, accountId }) {
-            // Resolve to the userId configured for this account
-            const acct = deskFreePlugin.config.resolveAccount(cfg, accountId);
-            if (!acct.userId)
-                return null;
-            return { to: acct.userId };
-        },
-        async sendText(ctx) {
-            const runtime = getDeskFreeRuntime();
-            const cfg = runtime.config.loadConfig();
-            const ch = getChannelConfig(cfg);
-            if (!ch) {
-                return { channel: 'deskfree', success: false };
-            }
-            const acct = deskFreePlugin.config.resolveAccount(cfg, ctx.accountId);
-            const client = new DeskFreeClient(acct.botToken, acct.apiUrl);
-            const log = runtime.logging.createLogger('deskfree');
-            try {
-                // Use explicit threadId if present, otherwise auto-thread
-                // into the active task
-                const taskId = ctx.threadId
-                    ? String(ctx.threadId)
-                    : (getActiveTaskId() ?? undefined);
-                await client.sendMessage({
-                    content: ctx.text,
-                    taskId,
-                });
-                return {
-                    channel: 'deskfree',
-                    success: true,
-                    threadId: taskId,
-                };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                log.error(`Failed to send message: ${message}`);
-                return {
-                    channel: 'deskfree',
-                    success: false,
-                    error: message,
-                };
-            }
-        },
-    },
-    gateway: {
-        async startAccount(ctx) {
-            return startDeskFreeConnection(ctx);
-        },
-        async stopAccount(ctx) {
-            const log = ctx.log ?? getDeskFreeRuntime().logging.createLogger('deskfree');
-            log.info(`Stopping DeskFree account ${ctx.accountId}`);
-            ctx.setStatus({ running: false, lastStopAt: Date.now() });
-        },
-        async logoutAccount(ctx) {
-            const log = ctx.log ?? getDeskFreeRuntime().logging.createLogger('deskfree');
-            const runtime = ctx.runtime;
-            // Clone config immutably
-            const config = JSON.parse(JSON.stringify(ctx.cfg));
-            const channels = (config.channels ?? {});
-            const deskfree = (channels.deskfree ?? {});
-            if (ctx.accountId === 'default') {
-                delete deskfree.botToken;
-            }
-            else {
-                const accounts = (deskfree.accounts ?? {});
-                if (accounts[ctx.accountId]) {
-                    delete accounts[ctx.accountId].botToken;
-                }
-            }
-            channels.deskfree = deskfree;
-            config.channels = channels;
-            await runtime.config.writeConfigFile(config);
-            log.info(`Cleared bot token for account ${ctx.accountId}`);
-            return { cleared: true, loggedOut: true };
-        },
-    },
-    setup: {
-        applyAccountConfig(params) {
-            const { cfg, accountId, input } = params;
-            const config = cfg;
-            const channels = (config.channels ?? {});
-            const deskfree = (channels.deskfree ?? {});
-            if (accountId === 'default') {
-                deskfree.botToken = input.botToken;
-                deskfree.apiUrl = input.apiUrl;
-                deskfree.wsUrl = input.wsUrl;
-                deskfree.userId = input.userId;
-            }
-            else {
-                const accounts = (deskfree.accounts ?? {});
-                accounts[accountId] = {
-                    botToken: input.botToken,
-                    apiUrl: input.apiUrl,
-                    wsUrl: input.wsUrl,
-                    userId: input.userId,
-                    enabled: true,
-                };
-                deskfree.accounts = accounts;
-            }
-            // Always set top-level channel enabled
-            deskfree.enabled = true;
-            channels.deskfree = deskfree;
-            config.channels = channels;
-            // Register plugin entry with channel ID to prevent auto-enable
-            // from creating a phantom disabled entry under the NPM package ID
-            const plugins = (config.plugins ?? {});
-            const entries = (plugins.entries ?? {});
-            const existing = (entries.deskfree ?? {});
-            entries.deskfree = { ...existing, enabled: true };
-            plugins.entries = entries;
-            config.plugins = plugins;
-            return config;
-        },
-        validateInput(params) {
-            const { input } = params;
-            // Validate bot token
-            if (!input.botToken) {
-                return 'Bot token is required';
-            }
-            if (typeof input.botToken !== 'string') {
-                return 'Bot token must be a string';
-            }
-            const botTokenTrimmed = input.botToken.trim();
-            if (botTokenTrimmed !== input.botToken) {
-                return 'Bot token must not have leading or trailing whitespace';
-            }
-            if (!botTokenTrimmed.startsWith('bot_')) {
-                return 'Bot token must start with "bot_"';
-            }
-            if (botTokenTrimmed.length < 10) {
-                return 'Bot token appears to be too short (minimum 10 characters)';
-            }
-            if (botTokenTrimmed.length > 100) {
-                return 'Bot token appears to be too long (maximum 100 characters)';
-            }
-            if (!/^bot_[a-zA-Z0-9_-]+$/.test(botTokenTrimmed)) {
-                return 'Bot token contains invalid characters (only alphanumeric, underscore, and dash allowed after "bot_")';
-            }
-            // Validate API URL
-            if (!input.apiUrl) {
-                return 'API URL is required';
-            }
-            if (typeof input.apiUrl !== 'string') {
-                return 'API URL must be a string';
-            }
-            const apiUrlTrimmed = input.apiUrl.trim();
-            if (apiUrlTrimmed !== input.apiUrl) {
-                return 'API URL must not have leading or trailing whitespace';
-            }
-            try {
-                const apiUrl = new URL(apiUrlTrimmed);
-                if (apiUrl.protocol !== 'https:') {
-                    return 'API URL must use HTTPS protocol for security';
-                }
-                if (!apiUrl.hostname) {
-                    return 'API URL must have a valid hostname';
-                }
-                if (apiUrl.hostname === 'localhost' ||
-                    apiUrl.hostname === '127.0.0.1') {
-                    return 'API URL cannot use localhost (use a publicly accessible URL)';
-                }
-                if (apiUrl.pathname && !apiUrl.pathname.endsWith('/')) {
-                    // Warn if path doesn't end with slash but don't fail validation
-                    // since the client will normalize this
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : 'Invalid URL format';
-                return `API URL must be a valid URL: ${message}`;
-            }
-            // Validate WebSocket URL
-            if (!input.wsUrl) {
-                return 'WebSocket URL is required';
-            }
-            if (typeof input.wsUrl !== 'string') {
-                return 'WebSocket URL must be a string';
-            }
-            const wsUrlTrimmed = input.wsUrl.trim();
-            if (wsUrlTrimmed !== input.wsUrl) {
-                return 'WebSocket URL must not have leading or trailing whitespace';
-            }
-            try {
-                const wsUrl = new URL(wsUrlTrimmed);
-                if (!['ws:', 'wss:'].includes(wsUrl.protocol)) {
-                    return 'WebSocket URL must use ws:// or wss:// protocol';
-                }
-                if (!wsUrl.hostname) {
-                    return 'WebSocket URL must have a valid hostname';
-                }
-                if (wsUrl.hostname === 'localhost' || wsUrl.hostname === '127.0.0.1') {
-                    return 'WebSocket URL cannot use localhost (use a publicly accessible URL)';
-                }
-                // Recommend wss:// for security if using ws://
-                if (wsUrl.protocol === 'ws:' && wsUrl.hostname !== 'localhost') {
-                    // This is just a recommendation, not a hard failure
-                    // Most production deployments should use wss://
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : 'Invalid URL format';
-                return `WebSocket URL must be a valid URL: ${message}`;
-            }
-            // Validate User ID
-            if (!input.userId) {
-                return 'User ID is required';
-            }
-            if (typeof input.userId !== 'string') {
-                return 'User ID must be a string';
-            }
-            const userIdTrimmed = input.userId.trim().toUpperCase();
-            if (userIdTrimmed !== input.userId.toUpperCase()) {
-                return 'User ID must not have leading or trailing whitespace and should be uppercase';
-            }
-            if (!/^[UBPT][A-Z0-9]{10}$/.test(userIdTrimmed)) {
-                const prefix = userIdTrimmed.charAt(0);
-                if (!'UBPT'.includes(prefix)) {
-                    return 'User ID must start with U, B, P, or T (got: ' + prefix + ')';
-                }
-                if (userIdTrimmed.length !== 11) {
-                    return `User ID must be exactly 11 characters long (got: ${userIdTrimmed.length})`;
-                }
-                return 'User ID must be a valid DeskFree ID format: one letter (U/B/P/T) + 10 alphanumeric characters (e.g. U9QF3C6X1A)';
-            }
-            return null;
-        },
-    },
-    messaging: {
-        normalizeTarget(raw) {
-            const trimmed = raw.trim();
-            if (/^[UBPT][A-Z0-9]{10}$/i.test(trimmed))
-                return `user:${trimmed}`;
-            return undefined;
-        },
-        targetResolver: {
-            hint: CHANNEL_HINTS.targetResolver,
-            looksLikeId(raw) {
-                const t = raw.trim();
-                return /^[UBPT][A-Z0-9]{10}$/i.test(t) || /^user:/i.test(t);
-            },
-        },
-    },
-    security: {
-        resolveDmPolicy({ accountId }) {
-            const basePath = accountId && accountId !== 'default'
-                ? `channels.deskfree.accounts.${accountId}.dm.`
-                : 'channels.deskfree.dm.';
-            return {
-                policy: 'open',
-                allowFrom: ['*'],
-                allowFromPath: basePath,
-                approveHint: 'DeskFree uses bot token auth — no pairing needed.',
-            };
-        },
-    },
-    onboarding: {
-        channel: 'deskfree',
-        async getStatus(ctx) {
-            const ch = getChannelConfig(ctx.cfg);
-            const hasBotToken = Boolean(ch?.botToken);
-            const hasApiUrl = Boolean(ch?.apiUrl);
-            const hasUserId = Boolean(ch?.userId);
-            const configured = hasBotToken && hasApiUrl && hasUserId;
-            const statusLines = [];
-            if (configured) {
-                statusLines.push('Bot token: configured');
-                statusLines.push(`API URL: ${ch.apiUrl}`);
-                if (ch.wsUrl)
-                    statusLines.push(`WS URL: ${ch.wsUrl}`);
-            }
-            else {
-                statusLines.push('Not configured');
-            }
-            return {
-                channel: 'deskfree',
-                configured,
-                statusLines,
-                selectionHint: CHANNEL_HINTS.onboardingSelection,
-                quickstartScore: configured ? 0 : 50,
-            };
-        },
-        async configure(ctx) {
-            const ch = getChannelConfig(ctx.cfg);
-            const accountId = ctx.accountOverrides.accountId ?? 'default';
-            const botToken = await ctx.prompter.text({
-                message: 'Bot token',
-                initialValue: ch?.botToken ?? '',
-                placeholder: 'bot_xxxxxxxxxxxxxxxx',
-                validate: (v) => {
-                    if (!v)
-                        return 'Bot token is required';
-                    if (!v.startsWith('bot_'))
-                        return 'Must start with "bot_"';
-                    if (v.length < 10)
-                        return 'Bot token appears to be too short';
-                    return undefined;
-                },
-            });
-            const apiUrl = await ctx.prompter.text({
-                message: 'API URL',
-                initialValue: ch?.apiUrl ?? '',
-                placeholder: 'https://app.deskfree.ai/v1/bot',
-                validate: (v) => {
-                    if (!v)
-                        return 'API URL is required';
-                    try {
-                        const url = new URL(v);
-                        if (url.protocol !== 'https:')
-                            return 'Must use HTTPS protocol for security';
-                        return undefined;
-                    }
-                    catch {
-                        return 'Must be a valid HTTPS URL';
-                    }
-                },
-            });
-            const wsUrl = await ctx.prompter.text({
-                message: 'WebSocket URL',
-                initialValue: ch?.wsUrl ?? '',
-                placeholder: 'wss://ws.deskfree.ai',
-                validate: (v) => {
-                    if (!v)
-                        return 'WebSocket URL is required';
-                    try {
-                        const url = new URL(v);
-                        if (!['ws:', 'wss:'].includes(url.protocol)) {
-                            return 'Must use ws:// or wss:// protocol';
-                        }
-                        return undefined;
-                    }
-                    catch {
-                        return 'Must be a valid WebSocket URL';
-                    }
-                },
-            });
-            const userId = await ctx.prompter.text({
-                message: 'Your DeskFree User ID (shown in install instructions)',
-                initialValue: ch?.userId ?? '',
-                placeholder: 'U9QF3C6X1A',
-                validate: (v) => {
-                    if (!v)
-                        return 'User ID is required';
-                    if (!/^[UBPT][A-Z0-9]{10}$/i.test(v)) {
-                        return 'Must be a valid DeskFree ID (e.g. U9QF3C6X1A)';
-                    }
-                    return undefined;
-                },
-            });
-            const updatedCfg = deskFreePlugin.setup.applyAccountConfig({
-                cfg: ctx.cfg,
-                accountId,
-                input: { botToken, apiUrl, wsUrl, userId },
-            });
-            await ctx.prompter.note('DeskFree channel configured.', 'Done');
-            return { cfg: updatedCfg, accountId };
-        },
-        disable(cfg) {
-            const config = JSON.parse(JSON.stringify(cfg));
-            const channels = (config.channels ?? {});
-            const deskfree = (channels.deskfree ?? {});
-            deskfree.enabled = false;
-            channels.deskfree = deskfree;
-            config.channels = channels;
-            return config;
-        },
-    },
-    status: {
-        async probeAccount(params) {
-            const isConfigured = Boolean(params.account.botToken && params.account.apiUrl);
-            if (!isConfigured) {
-                return { ok: false, error: STATUS_MESSAGES.probeNotConfigured };
-            }
-            const client = new DeskFreeClient(params.account.botToken, params.account.apiUrl);
-            return client.probe(params.timeoutMs);
-        },
-        buildAccountSnapshot(params) {
-            const isConfigured = Boolean(params.account.botToken && params.account.apiUrl);
-            return {
-                accountId: params.account.accountId,
-                enabled: params.account.enabled,
-                configured: isConfigured,
-                running: params.runtime?.running,
-                lastStartAt: params.runtime?.lastStartAt,
-                lastStopAt: params.runtime?.lastStopAt,
-                lastError: params.runtime?.lastError,
-                probe: params.probe,
-            };
-        },
-        collectStatusIssues(accounts) {
-            const issues = [];
-            for (const snap of accounts) {
-                const id = snap.accountId ?? 'unknown';
-                if (!snap.configured) {
-                    issues.push({
-                        channel: 'deskfree',
-                        accountId: id,
-                        kind: 'config',
-                        message: STATUS_MESSAGES.notConfigured.message,
-                        fix: STATUS_MESSAGES.notConfigured.fix,
-                    });
-                    continue;
-                }
-                if (!snap.enabled) {
-                    issues.push({
-                        channel: 'deskfree',
-                        accountId: id,
-                        kind: 'config',
-                        message: STATUS_MESSAGES.disabled.message,
-                        fix: STATUS_MESSAGES.disabled.fix,
-                    });
-                    continue;
-                }
-                if (!snap.running) {
-                    issues.push({
-                        channel: 'deskfree',
-                        accountId: id,
-                        kind: 'runtime',
-                        message: STATUS_MESSAGES.notRunning.message,
-                    });
-                }
-                if (snap.probe && !snap.probe.ok) {
-                    issues.push({
-                        channel: 'deskfree',
-                        accountId: id,
-                        kind: 'auth',
-                        message: `Probe failed: ${snap.probe.error ?? 'unknown error'}`,
-                        fix: STATUS_MESSAGES.probeFailed.fix,
-                    });
-                }
-            }
-            return issues;
-        },
-    },
-};
-//# sourceMappingURL=channel.js.map