@loicngr/kobo 1.11.44 → 2.1.0

package/dist/mcp-server/kobo-tasks-server.js

@@ -6,6 +6,8 @@ import { getDb } from '../server/db/index.js';
 import { WORKSPACE_DIALOGUE_TOOLS } from '../shared/workspace-dialogue-tools.js';
 import { createTaskHandler, cronListHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getTicketSourcesHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, listWorkspacesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, readWorkspaceEventsCsvHandler, setWorkspaceAgentDescriptionHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
 import { callWorkspaceDialogueTool } from './workspace-dialogue-client.js';
+const handoffId = process.env.KOBO_HANDOFF_ID;
+const handoffToken = process.env.KOBO_HANDOFF_TOKEN;
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
 const settingsPath = process.env.KOBO_SETTINGS_PATH;
@@ -146,6 +148,16 @@ const TASK_ORDER_PROPERTIES = {
     },
 };
 const WORKSPACE_SCOPED_TOOLS = [
+    {
+        name: 'submit_session_handoff',
+        description: 'Submit the final Markdown handoff requested by Kōbō for this generation turn, then end your turn. Only available during a backend-owned session transfer; does not launch or stop sessions.',
+        inputSchema: {
+            type: 'object',
+            properties: { report: { type: 'string', minLength: 1, maxLength: 24000 } },
+            required: ['report'],
+        },
+        annotations: { destructiveHint: false, openWorldHint: false },
+    },
     {
         name: 'list_tasks',
         description: 'CALL FIRST on any non-trivial turn to know what the user wants done and what is already completed. Returns every task and acceptance criterion for the current workspace with its id, status, sort_order, role, and verification evidence. Re-call periodically (before marking something done, or after the user asks for a status) to stay in sync with user-added or external updates.',
@@ -412,13 +424,13 @@ const WORKSPACE_SCOPED_TOOLS = [
     // ── Knowledge / context tools ─────────────────────────────────────────────
     {
         name: 'list_documents',
-        description: 'CALL EARLY on a new session to discover plans, specs, and thoughts previously written for this workspace. Recursively lists every .md under docs/plans/, docs/superpowers/, and .ai/thoughts/. Before writing a new plan, check if one already exists.',
+        description: 'CALL EARLY on a new session to discover plans, specs, and thoughts previously written for this workspace. Recursively lists every .md under docs/plans/, docs/superpowers/, .ai/thoughts/, and .ai/handoffs/. Before writing a new plan, check if one already exists.',
         inputSchema: { type: 'object', properties: {}, required: [] },
         annotations: { readOnlyHint: true, openWorldHint: false },
     },
     {
         name: 'read_document',
-        description: 'CALL AFTER list_documents when a file title looks relevant to the current task. Returns the full markdown content. Scoped to docs/plans/, docs/superpowers/, .ai/thoughts/ — reject anything else.',
+        description: 'CALL AFTER list_documents when a file title looks relevant to the current task. Returns the full markdown content. Scoped to docs/plans/, docs/superpowers/, .ai/thoughts/, .ai/handoffs/ — reject anything else.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -609,9 +621,13 @@ const GLOBAL_TOOLS = [
  * one of the ~35 workspace-scoped branches.
  */
 const GLOBAL_TOOL_NAMES = new Set(GLOBAL_TOOLS.map((t) => t.name));
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: workspaceId ? [...WORKSPACE_SCOPED_TOOLS, ...GLOBAL_TOOLS] : GLOBAL_TOOLS,
-}));
+function availableTools() {
+    const tools = workspaceId ? [...WORKSPACE_SCOPED_TOOLS, ...GLOBAL_TOOLS] : GLOBAL_TOOLS;
+    return tools.filter((tool) => handoffId && handoffToken
+        ? tool.name === 'submit_session_handoff' || tool.annotations?.readOnlyHint === true
+        : tool.name !== 'submit_session_handoff');
+}
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: availableTools() }));
 /** Wrap a successful result as an MCP tool response with JSON text content. */
 function ok(data) {
     return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
@@ -641,6 +657,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return fail(`Tool '${name}' requires a workspace-bound MCP session (KOBO_WORKSPACE_ID not set).`);
     }
     try {
+        if (handoffId && handoffToken && !availableTools().some((tool) => tool.name === name))
+            return fail('This turn is reserved for a handoff report. Only read tools and submit_session_handoff are available.');
+        if (name === 'submit_session_handoff') {
+            if (!workspaceId || !handoffId || !handoffToken)
+                return fail('No handoff generation is active for this MCP invocation.');
+            return ok(await backendRequest('POST', `/api/workspaces/${workspaceId}/session-handoffs/${handoffId}/report`, {
+                token: handoffToken,
+                report: a.report,
+            }));
+        }
         if (WORKSPACE_DIALOGUE_TOOLS.some((tool) => tool.name === name)) {
             if (workspaceId && a.workspace_id === workspaceId && name === 'send_workspace_message')
                 return fail('Use the normal conversation to communicate in your own workspace.');

package/dist/server/db/migrations.js

@@ -3,6 +3,7 @@ import { initMcpMessageSchema } from './mcp-message-schema.js';
 import { initReviewReturnSchema } from './review-return-schema.js';
 import { initSchema } from './schema.js';
 import { initSearchSchema } from './search-schema.js';
+import { initSessionHandoffSchema } from './session-handoff-schema.js';
 /** Ordered registry of all schema migrations. Append new entries at the end. */
 export const migrations = [
     {
@@ -748,6 +749,42 @@ export const migrations = [
     { version: 43, name: 'durable-mcp-message-requests', migrate: initMcpMessageSchema },
     { version: 44, name: 'review-session-returns', migrate: initReviewReturnSchema },
     { version: 45, name: 'durable-auto-loop', migrate: initAutoLoopSchema },
+    { version: 46, name: 'session-handoffs', migrate: initSessionHandoffSchema },
+    {
+        version: 47,
+        name: 'session-activation-order',
+        migrate(db) {
+            const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'agent_sessions'").get();
+            if (!table)
+                return;
+            const columns = db.prepare('PRAGMA table_info(agent_sessions)').all();
+            if (!columns.some((column) => column.name === 'activation_order'))
+                db.exec('ALTER TABLE agent_sessions ADD COLUMN activation_order INTEGER NOT NULL DEFAULT 0');
+        },
+    },
+    {
+        version: 48,
+        name: 'workspace-workflow-preferences',
+        migrate(db) {
+            if (!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='workspaces'").get())
+                return;
+            const columns = db.prepare('PRAGMA table_info(workspaces)').all();
+            if (!columns.some((column) => column.name === 'workflow_policy')) {
+                db.exec('ALTER TABLE workspaces ADD COLUMN workflow_policy TEXT');
+            }
+        },
+    },
+    {
+        version: 49,
+        name: 'preserve-wakeup-deadline-on-retry',
+        migrate(db) {
+            if (!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='pending_wakeups'").get())
+                return;
+            const columns = db.prepare('PRAGMA table_info(pending_wakeups)').all();
+            if (!columns.some((column) => column.name === 'retry_at'))
+                db.exec('ALTER TABLE pending_wakeups ADD COLUMN retry_at TEXT');
+        },
+    },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -2,6 +2,7 @@ import { initAutoLoopSchema } from './auto-loop-schema.js';
 import { initMcpMessageSchema } from './mcp-message-schema.js';
 import { initReviewReturnSchema } from './review-return-schema.js';
 import { initSearchSchema } from './search-schema.js';
+import { initSessionHandoffSchema } from './session-handoff-schema.js';
 /** Create all tables and indexes for a fresh install. Not used for upgrades -- see migrations.ts. */
 export function initSchema(db) {
     db.exec(`
@@ -34,6 +35,7 @@ export function initSchema(db) {
       auto_loop_session_mode TEXT NOT NULL DEFAULT 'per_task',
       no_progress_streak INTEGER NOT NULL DEFAULT 0,
       permission_profile TEXT NOT NULL DEFAULT 'bypass',
+      workflow_policy TEXT,
       agent_permission_mode TEXT NOT NULL DEFAULT 'bypass',
       description TEXT,
       agent_description TEXT,
@@ -70,7 +72,8 @@ export function initSchema(db) {
       ended_at TEXT,
       name TEXT,
       task_progress_baseline TEXT,
-      end_reason TEXT
+      end_reason TEXT,
+      activation_order INTEGER NOT NULL DEFAULT 0
     );
 
     CREATE TABLE IF NOT EXISTS ws_events (
@@ -149,6 +152,7 @@ export function initSchema(db) {
     CREATE TABLE IF NOT EXISTS pending_wakeups (
       workspace_id     TEXT PRIMARY KEY REFERENCES workspaces(id) ON DELETE CASCADE,
       target_at        TEXT NOT NULL,
+      retry_at         TEXT,
       prompt           TEXT NOT NULL,
       reason           TEXT,
       created_at       TEXT NOT NULL,
@@ -229,4 +233,5 @@ export function initSchema(db) {
     initMcpMessageSchema(db);
     initReviewReturnSchema(db);
     initAutoLoopSchema(db);
+    initSessionHandoffSchema(db);
 }

package/dist/server/db/session-handoff-schema.js

@@ -0,0 +1,24 @@
+export function initSessionHandoffSchema(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS session_handoffs (
+    id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+    request_id TEXT NOT NULL,
+    request_fingerprint TEXT NOT NULL,
+    source_session_id TEXT,
+    target_session_id TEXT,
+    source_configuration TEXT NOT NULL,
+    target_configuration TEXT NOT NULL,
+    source_model TEXT,
+    generate_summary INTEGER NOT NULL,
+    state TEXT NOT NULL,
+    report TEXT,
+    report_path TEXT,
+    generation_token TEXT,
+    error TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(workspace_id, request_id)
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS session_handoffs_pending
+    ON session_handoffs(workspace_id) WHERE state NOT IN ('completed', 'cancelled');`);
+}

package/dist/server/index.js

@@ -13,11 +13,13 @@ import changelogRouter from './routes/changelog.js';
 import devServerRouter from './routes/dev-server.js';
 import documentsRouter from './routes/documents.js';
 import { enginesRouter } from './routes/engines.js';
+import environmentRouter from './routes/environment.js';
 import exportRouter from './routes/export.js';
 import fsRouter from './routes/fs.js';
 import gitRouter from './routes/git.js';
 import healthRouter from './routes/health.js';
 import imagesRouter from './routes/images.js';
+import integrationsRouter from './routes/integrations.js';
 import mcpRouter from './routes/mcp.js';
 import { migrationRouter } from './routes/migration.js';
 import notionRouter from './routes/notion.js';
@@ -25,6 +27,7 @@ import pullRequestsRouter from './routes/pull-requests.js';
 import searchRouter from './routes/search.js';
 import sentryRouter from './routes/sentry.js';
 import settingsRouter from './routes/settings.js';
+import soundsRouter from './routes/sounds.js';
 import templatesRouter from './routes/templates.js';
 import usageRoutes from './routes/usage.js';
 import voiceRouter from './routes/voice.js';
@@ -43,6 +46,7 @@ import { startPrWatcher, stopPrWatcher } from './services/pr-watcher-service.js'
 import * as quotaBackoffService from './services/quota-backoff-service.js';
 import { reconcileReviewReturns } from './services/review-return-service.js';
 import { startSearchIndex, stopSearchIndex } from './services/search-service.js';
+import { reconcileSessionHandoffs } from './services/session-handoff-service.js';
 import { getGlobalSettings, updateNetworkAccessSettings } from './services/settings-service.js';
 import { reloadDefaultTemplates } from './services/templates-service.js';
 import { createTerminal, destroyAllTerminals, getTerminal } from './services/terminal-service.js';
@@ -118,6 +122,7 @@ const dailyBackupScheduler = startDailyDbBackupScheduler(async () => {
 // Initialize process cleanup, agent watchdog, PR watcher, and wakeup rehydration
 reconcileOrphanSessions();
 reconcileReviewReturns();
+reconcileSessionHandoffs();
 // Deliver any new default prompt templates to existing installs (seed-once via the
 // seededDefaultSlugs watermark; never overwrites or re-adds deleted defaults).
 try {
@@ -164,6 +169,9 @@ app.route('/api/workspaces', exportRouter);
 app.route('/api/search', searchRouter);
 app.route('/api/health', healthRouter);
 app.route('/api/engines', enginesRouter);
+app.route('/api/environment', environmentRouter);
+app.route('/api/integrations', integrationsRouter);
+app.route('/api/sounds', soundsRouter);
 app.route('/api/migration', migrationRouter);
 app.route('/api/voice', voiceRouter);
 // Skills endpoint

package/dist/server/routes/documents.js

@@ -1,6 +1,7 @@
 import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import { Hono } from 'hono';
+import { DOCUMENT_DIRS } from '../../shared/document-roots.js';
 import * as workspaceService from '../services/workspace-service.js';
 import { isPathInside, resolveExistingPathInside } from '../utils/safe-path.js';
 /** Hono sub-router for workspace document browsing (read-only). */
@@ -13,7 +14,6 @@ const app = new Hono();
  * Kept intentionally narrow to avoid leaking unrelated project docs
  * (README, product specs, …) into the panel.
  */
-const DOCUMENT_DIRS = ['docs/plans', 'docs/superpowers', '.ai/thoughts'];
 /** Only .md files are listed. */
 const MD_EXT = '.md';
 /** Depth cap to keep recursion bounded even on pathological symlink loops. */

package/dist/server/routes/environment.js

@@ -0,0 +1,18 @@
+import { Hono } from 'hono';
+import { getEnvironmentReport } from '../services/environment-check-service.js';
+const app = new Hono();
+app.get('/', async (c) => {
+    const engine = c.req.query('engine') ?? 'claude-code';
+    const projectPath = c.req.query('projectPath')?.trim();
+    if (!['claude-code', 'codex'].includes(engine) ||
+        (projectPath && (projectPath.length > 4096 || projectPath.includes('\0')))) {
+        return c.json({ error: 'Invalid environment check request' }, 400);
+    }
+    try {
+        return c.json(await getEnvironmentReport({ engine: engine, projectPath }));
+    }
+    catch {
+        return c.json({ error: 'Environment check unavailable; retry shortly' }, 503);
+    }
+});
+export default app;

package/dist/server/routes/health.js

@@ -5,6 +5,7 @@ import { Hono } from 'hono';
 import { getDb } from '../db/index.js';
 import { SCHEMA_VERSION } from '../db/migrations.js';
 import { resolveCodexBinary } from '../services/agent/engines/codex/spawn.js';
+import { hasIntegrationMcpConfig } from '../services/agent/integration-mcp.js';
 import { getGlobalSettings, getProjectSettings, SETTINGS_SCHEMA_VERSION } from '../services/settings-service.js';
 import { readRecentLogs } from '../utils/logger.js';
 import { getDbPath, getKoboHome, getPackageVersion } from '../utils/paths.js';
@@ -12,6 +13,14 @@ import { slugifyProjectName } from '../utils/project-slug.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 const app = new Hono();
 const execFileAsync = promisify(execFileCb);
+function integrationConfigured(integration, key) {
+    try {
+        return hasIntegrationMcpConfig(integration, key);
+    }
+    catch {
+        return false;
+    }
+}
 async function checkCli(binary) {
     try {
         const { stdout } = await execFileAsync(binary, ['--version'], { encoding: 'utf-8', timeout: 2_000 });
@@ -182,8 +191,14 @@ app.get('/report', async (c) => {
         },
         agentSessions: { orphaned },
         integrations: {
-            notion: { configured: Boolean(healthGlobalSettings.notionMcpKey), enabled: healthGlobalSettings.notionEnabled },
-            sentry: { configured: Boolean(healthGlobalSettings.sentryMcpKey), enabled: healthGlobalSettings.sentryEnabled },
+            notion: {
+                configured: integrationConfigured('notion', healthGlobalSettings.notionMcpKey),
+                enabled: healthGlobalSettings.notionEnabled,
+            },
+            sentry: {
+                configured: integrationConfigured('sentry', healthGlobalSettings.sentryMcpKey),
+                enabled: healthGlobalSettings.sentryEnabled,
+            },
             editor: { configured: Boolean(healthGlobalSettings.editorCommand) },
         },
         active: {

package/dist/server/routes/integrations.js

@@ -0,0 +1,29 @@
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { getIntegrationStatus, saveIntegrationConfig, } from '../services/integration-config-service.js';
+const app = new Hono();
+app.use('*', bodyLimit({ maxSize: 64 * 1024 }));
+app.use('/:integration', async (c, next) => {
+    if (!['notion', 'sentry'].includes(c.req.param('integration') ?? ''))
+        return c.json({ error: 'Unknown integration' }, 404);
+    await next();
+});
+app.get('/:integration', (c) => {
+    try {
+        return c.json(getIntegrationStatus(c.req.param('integration')));
+    }
+    catch {
+        return c.json({ error: 'Integration configuration is unavailable' }, 503);
+    }
+});
+app.put('/:integration', async (c) => {
+    try {
+        const value = await c.req.json();
+        saveIntegrationConfig(c.req.param('integration'), value);
+        return c.json(getIntegrationStatus(c.req.param('integration')));
+    }
+    catch {
+        return c.json({ error: 'Cannot save integration configuration; check the connection fields and local storage' }, 400);
+    }
+});
+export default app;

package/dist/server/routes/settings.js

@@ -1,5 +1,6 @@
 import { Hono } from 'hono';
 import { isValidSkillSuite } from '../../shared/skill-suite-prompts.js';
+import { isWorkflowPolicy } from '../../shared/workflow-policy.js';
 import { getDb } from '../db/index.js';
 import { getBackendPort } from '../services/agent/orchestrator.js';
 import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, } from '../services/initial-prompt-template-service.js';
@@ -163,6 +164,8 @@ app.put('/global', async (c) => {
         // must answer 400 rather than do that.
         if (!body)
             return c.json({ error: 'Invalid JSON body' }, 400);
+        if (body.workflowPolicy !== undefined && !isWorkflowPolicy(body.workflowPolicy))
+            return c.json({ error: 'Invalid workflowPolicy' }, 400);
         const updated = settingsService.updateGlobalSettings(body);
         // The client assigns this response straight into its store, so echoing the
         // real credentials back would undo the masking on GET the first time
@@ -211,6 +214,8 @@ app.put('/projects/:encodedPath', async (c) => {
         // `{}` CREATES a project entry with defaults; a malformed body must not.
         if (!body)
             return c.json({ error: 'Invalid JSON body' }, 400);
+        if (body.workflowPolicy !== undefined && !isWorkflowPolicy(body.workflowPolicy))
+            return c.json({ error: 'Invalid workflowPolicy' }, 400);
         const project = settingsService.upsertProject(projectPath, body);
         return c.json(project);
     }

package/dist/server/routes/sounds.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { MAX_CUSTOM_SOUND_BYTES } from '../../shared/notification-assets.js';
+import { CustomSoundError, deleteCustomSound, listCustomSounds, readCustomSound, saveCustomSound, } from '../services/custom-sound-service.js';
+/** Multipart framing and the field name add a small, bounded overhead. */
+const MAX_REQUEST_BYTES = MAX_CUSTOM_SOUND_BYTES + 64 * 1024;
+const app = new Hono();
+// `listCustomSounds` degrades a damaged manifest to an empty list; it never throws.
+app.get('/', (c) => c.json({ sounds: listCustomSounds() }));
+app.post('/', bodyLimit({ maxSize: MAX_REQUEST_BYTES }), async (c) => {
+    let form;
+    try {
+        form = await c.req.raw.formData();
+    }
+    catch {
+        return c.json({ error: 'Invalid multipart body' }, 400);
+    }
+    const files = form.getAll('sound');
+    if (files.length !== 1 || !(files[0] instanceof File))
+        return c.json({ error: 'Expected one sound file' }, 400);
+    try {
+        return c.json(await saveCustomSound(files[0]), 201);
+    }
+    catch (error) {
+        // Only the stable code crosses the boundary: a filesystem error may carry
+        // the layout of the user's home directory.
+        if (error instanceof CustomSoundError)
+            return c.json({ error: 'Invalid sound file', code: error.code }, 400);
+        return c.json({ error: 'Cannot store the sound file' }, 500);
+    }
+});
+app.delete('/:id', (c) => {
+    try {
+        return deleteCustomSound(c.req.param('id')) ? c.body(null, 204) : c.json({ error: 'Sound not found' }, 404);
+    }
+    catch {
+        return c.json({ error: 'Cannot remove the sound file' }, 500);
+    }
+});
+// An unknown or deleted sound answers 404; the client then falls back to a bundled tone.
+app.get('/:id/file', async (c) => {
+    const sound = readCustomSound(c.req.param('id'));
+    if (!sound)
+        return c.json({ error: 'Sound not found' }, 404);
+    let content;
+    try {
+        content = await fs.promises.readFile(sound.filePath);
+    }
+    catch {
+        // The file vanished between the manifest lookup and the read.
+        return c.json({ error: 'Sound not found' }, 404);
+    }
+    c.header('Content-Type', sound.contentType);
+    // Content-addressed by a generated id: the bytes behind an id never change.
+    c.header('Cache-Control', 'private, max-age=3600, immutable');
+    c.header('X-Content-Type-Options', 'nosniff');
+    return c.body(new Uint8Array(content));
+});
+export default app;