@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/core/pi-progress-logging.js

@@ -0,0 +1,51 @@
+import { logger } from './logging.js';
+export function logPiProgressEvent({ event, messages, meta, logResponding = false, logTools = false, toolLogLevel = 'info', }) {
+    switch (event.type) {
+        case 'agent_start':
+            logger.info(messages.agentStart, meta);
+            return;
+        case 'agent_end':
+            logger.info(messages.agentEnd, meta);
+            return;
+        case 'thinking':
+            logger.info(messages.thinking, meta);
+            return;
+        case 'responding':
+            if (logResponding) {
+                logger.info(messages.responding, meta);
+            }
+            return;
+        // Callers that opt into execution limits handle this event with
+        // task-specific messages, severity, and metadata.
+        case 'limit_reached':
+            return;
+        case 'tool_start':
+            if (logTools) {
+                const log = toolLogLevel === 'warn' ? logger.warn : logger.info;
+                log(messages.toolStart, {
+                    ...meta,
+                    tool_name: event.toolName,
+                });
+            }
+            return;
+        case 'tool_update':
+            if (logTools) {
+                const log = toolLogLevel === 'warn' ? logger.warn : logger.info;
+                log(messages.toolUpdate, {
+                    ...meta,
+                    tool_name: event.toolName,
+                });
+            }
+            return;
+        case 'tool_end':
+            if (logTools) {
+                const log = toolLogLevel === 'warn' ? logger.warn : logger.info;
+                log(messages.toolEnd, {
+                    ...meta,
+                    tool_name: event.toolName,
+                    is_error: event.isError,
+                    duration_ms: event.durationMs,
+                });
+            }
+    }
+}

package/sandbox/dist/core/pi-tool-output-filter-extension.js

@@ -0,0 +1,65 @@
+import { safeToolOutput, writeToolRecord } from './tool-output.js';
+// Pi applies tool_result changes before sending the result to the model. Filter
+// all text tools so redirecting CLI output to a file cannot bypass filtering.
+// eslint-disable-next-line import/no-default-export
+export default function toolOutputFilterExtension(pi) {
+    function filterValue(value) {
+        if (typeof value === 'string')
+            return safeToolOutput(value);
+        if (Array.isArray(value))
+            return value.map(filterValue);
+        if (value && typeof value === 'object')
+            return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+                safeToolOutput(key),
+                filterValue(entry),
+            ]));
+        return value;
+    }
+    pi.on('tool_call', (event) => {
+        try {
+            writeToolRecord({
+                type: 'doistbot_tool_audit',
+                tool: event.toolName,
+                // Audit queries/commands, never service response bodies.
+                input: JSON.stringify(filterValue(event.input)).slice(0, 8_000),
+            });
+        }
+        catch {
+            return { block: true, reason: 'Tool query could not be safely recorded.' };
+        }
+        return undefined;
+    });
+    pi.on('tool_result', (event) => {
+        try {
+            const result = {
+                content: event.content.map((item) => item.type === 'text' ? { ...item, text: safeToolOutput(item.text) } : item),
+                details: filterValue(event.details ?? null),
+            };
+            if (process.env.DOISTBOT_AUTOFIX_RUNTIME) {
+                writeToolRecord({
+                    type: 'doistbot_tool_result',
+                    tool: event.toolName,
+                    toolCallId: event.toolCallId,
+                    isError: event.isError,
+                    output: result.content
+                        .filter((item) => item.type === 'text')
+                        .map((item) => item.text)
+                        .join('\n')
+                        .slice(-8000),
+                });
+            }
+            return result;
+        }
+        catch {
+            // Pi otherwise ignores extension errors and keeps the original
+            // result. Explicitly replace it so a filter failure cannot leak text.
+            return {
+                content: [
+                    { type: 'text', text: 'Tool output withheld: filtering failed.' },
+                ],
+                details: null,
+                isError: true,
+            };
+        }
+    });
+}