skimpyclaw 0.3.10 → 0.3.14

package/dist/channels/discord/utils.js

@@ -0,0 +1,161 @@
+import { resolveAllowedPaths } from '../../config.js';
+import * as sessions from '../../sessions.js';
+import { BOT_COMMANDS, MAX_HISTORY_PAIRS } from './types.js';
+// ── State ───────────────────────────────────────────────────────────
+const chatHistory = new Map();
+const loadedFromDisk = new Set();
+// ── History ─────────────────────────────────────────────────────────
+export async function getHistory(key) {
+    if (!loadedFromDisk.has(key)) {
+        loadedFromDisk.add(key);
+        const diskHistory = await sessions.loadHistory('discord', key).catch(() => []);
+        if (diskHistory.length > 0 && !chatHistory.has(key)) {
+            chatHistory.set(key, diskHistory);
+        }
+    }
+    return chatHistory.get(key) || [];
+}
+export async function addToHistory(key, userMsg, assistantMsg) {
+    const history = await getHistory(key);
+    history.push({ role: 'user', content: userMsg });
+    history.push({ role: 'assistant', content: assistantMsg });
+    while (history.length > MAX_HISTORY_PAIRS * 2) {
+        history.shift();
+        history.shift();
+    }
+    chatHistory.set(key, history);
+    sessions.saveExchange('discord', key, userMsg, assistantMsg).catch(() => { });
+}
+export async function clearHistory(key) {
+    chatHistory.delete(key);
+    loadedFromDisk.delete(key);
+    await sessions.clearHistory('discord', key).catch(() => { });
+}
+/** Replace history with a compact summary (used by /compact). */
+export function replaceHistory(key, summary) {
+    chatHistory.set(key, [
+        { role: 'user', content: 'Summary of our previous conversation:' },
+        { role: 'assistant', content: summary },
+    ]);
+    loadedFromDisk.add(key);
+}
+// ── Tool config ─────────────────────────────────────────────────────
+export function getDiscordToolConfig(cfg) {
+    const discord = cfg.channels.discord;
+    if (discord?.tools) {
+        return {
+            ...discord.tools,
+            allowedPaths: discord.tools.allowedPaths?.length
+                ? discord.tools.allowedPaths
+                : resolveAllowedPaths(cfg),
+        };
+    }
+    return {
+        enabled: true,
+        allowedPaths: resolveAllowedPaths(cfg),
+        maxIterations: 100,
+        bashTimeout: 15000,
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+export function conversationKey(message) {
+    if (message.channel.isDMBased()) {
+        return `dm:${message.author.id}`;
+    }
+    return `channel:${message.channelId}`;
+}
+export function getDiscordRunContext(message) {
+    return {
+        userId: message.author.id,
+        sessionId: message.channel.id,
+        channel: 'discord',
+        trigger: 'discord',
+        metadata: {
+            username: message.author.username,
+        },
+    };
+}
+export function buildHelpText(cfg) {
+    const agentConfig = cfg.agents.list[cfg.agents.default];
+    const emoji = agentConfig?.identity?.emoji || '🦞';
+    const name = agentConfig?.identity?.name || 'SkimpyClaw';
+    const commandList = BOT_COMMANDS.map(c => `/${c.command} - ${c.description}`).join('\n');
+    return `${emoji} ${name} online.\n\nSend a message to chat, or use a command:\n\n${commandList}`;
+}
+export function splitToChunks(text, maxLength) {
+    if (text.length <= maxLength)
+        return [text];
+    const chunks = [];
+    let current = '';
+    for (const paragraph of text.split('\n\n')) {
+        if (current.length + paragraph.length + 2 > maxLength) {
+            if (current)
+                chunks.push(current.trim());
+            if (paragraph.length > maxLength) {
+                const lines = paragraph.split('\n');
+                let lineBuf = '';
+                for (const line of lines) {
+                    if (lineBuf.length + line.length + 1 > maxLength) {
+                        if (lineBuf)
+                            chunks.push(lineBuf.trim());
+                        if (line.length > maxLength) {
+                            for (let i = 0; i < line.length; i += maxLength) {
+                                chunks.push(line.slice(i, i + maxLength));
+                            }
+                            lineBuf = '';
+                        }
+                        else {
+                            lineBuf = line;
+                        }
+                    }
+                    else {
+                        lineBuf += (lineBuf ? '\n' : '') + line;
+                    }
+                }
+                current = lineBuf;
+            }
+            else {
+                current = paragraph;
+            }
+        }
+        else {
+            current += (current ? '\n\n' : '') + paragraph;
+        }
+    }
+    if (current)
+        chunks.push(current.trim());
+    return chunks.filter(c => c.length > 0);
+}
+export async function sendLongText(message, text) {
+    const chunks = splitToChunks(text, 1900);
+    for (const chunk of chunks) {
+        await message.reply(chunk);
+    }
+}
+export function startTypingIndicator(message) {
+    const maxDurationMs = 90_000;
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(interval);
+        clearTimeout(watchdog);
+    };
+    const channel = message.channel;
+    if (typeof channel.sendTyping === 'function') {
+        void channel.sendTyping().catch(() => { });
+    }
+    const interval = setInterval(() => {
+        if (stopped)
+            return;
+        if (typeof channel.sendTyping === 'function') {
+            void channel.sendTyping().catch(() => { });
+        }
+    }, 4000);
+    const watchdog = setTimeout(() => {
+        console.warn('[discord] Typing indicator watchdog reached; auto-stopping.');
+        stop();
+    }, maxDurationMs);
+    return stop;
+}

package/dist/channels/telegram/utils.d.ts

@@ -12,7 +12,7 @@ export declare function getHistory(chatId: number): Promise<ChatMessage[]>;
 export declare function addToHistory(chatId: number, userMsg: string, assistantMsg: string): Promise<void>;
 export declare function clearHistory(chatId: number): Promise<void>;
 export declare function getRunContext(ctx: Context): AgentRunContext;
-export declare function getDefaultTelegramToolConfig(cfg: Config): ToolConfig | undefined;
+export declare function getDefaultTelegramToolConfig(cfg: Config): ToolConfig;
 /** Get Telegram default chat ID from config */
 export declare function getTelegramDefaultChatId(cfg: Config): number | null;
 /** Send a long message by splitting it into chunks */

package/dist/channels/telegram/utils.js

@@ -2,6 +2,7 @@
 import { existsSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { resolveAllowedPaths } from '../../config.js';
 import { state, MAX_HISTORY_PAIRS, BOT_COMMANDS } from './types.js';
 import * as sessions from '../../sessions.js';
 /** Keep sending "typing..." every 4s until the returned stop function is called. */
@@ -102,20 +103,17 @@ export function getRunContext(ctx) {
 // Default tool config for Telegram — gives the agent file/bash access
 export function getDefaultTelegramToolConfig(cfg) {
     if (cfg.channels.telegram.tools) {
-        return cfg.channels.telegram.tools;
-    }
-    if (cfg.channels.telegram.defaultAllowedPaths?.length) {
         return {
-            enabled: true,
-            allowedPaths: cfg.channels.telegram.defaultAllowedPaths,
-            maxIterations: 100,
-            bashTimeout: 15000,
+            ...cfg.channels.telegram.tools,
+            allowedPaths: cfg.channels.telegram.tools.allowedPaths?.length
+                ? cfg.channels.telegram.tools.allowedPaths
+                : resolveAllowedPaths(cfg),
         };
     }
     return {
         enabled: true,
-        allowedPaths: [join(homedir(), '.skimpyclaw')],
-        maxIterations: 30,
+        allowedPaths: resolveAllowedPaths(cfg),
+        maxIterations: 100,
         bashTimeout: 15000,
     };
 }

package/dist/channels.js

@@ -38,7 +38,7 @@ async function loadAdapter(channel) {
             resolveDefaultTarget: telegram.getTelegramDefaultChatId,
         };
     }
-    const discord = await import('./discord.js');
+    const discord = await import('./channels/discord/index.js');
     return {
         init: discord.initDiscord,
         start: discord.startDiscord,

package/dist/cli.js

@@ -4,12 +4,13 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { spawn, spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
-import { loadConfig, loadRawConfig, getConfigPath, saveConfig } from './config.js';
+import { loadConfig, loadRawConfig, getConfigPath, saveConfig, resolveAllowedPaths } from './config.js';
 import { startRuntime } from './service.js';
 import { runSetup, renderGatewayPlist } from './setup.js';
 import { runDoctor as runDoctorCommand } from './doctor/index.js';
 import { executeTool, getToolDefinitions, BUILTIN_TOOL_DEFINITIONS, BROWSER_TOOL_DEFINITION } from './tools.js';
 import { formatModelSelectionError, getModelSelectionUsage, resolveModelSelection } from './model-selection.js';
+import { detectSandboxRuntime, isSandboxRuntimeRunning, sandboxNetworkExists, defaultSandboxNetwork, sandboxImageExists, } from './sandbox-utils.js';
 const APP_NAME = 'skimpyclaw';
 const DEFAULT_PORT = 18790;
 const LAUNCHD_LABEL = 'com.skimpyclaw.gateway';
@@ -102,19 +103,17 @@ function hasFlag(args, flag) {
     return args.includes(flag);
 }
 function getCliToolConfig(config) {
-    if (config.channels.telegram.tools)
-        return config.channels.telegram.tools;
-    if (config.channels.telegram.defaultAllowedPaths?.length) {
+    if (config.channels.telegram.tools) {
         return {
-            enabled: true,
-            allowedPaths: config.channels.telegram.defaultAllowedPaths,
-            maxIterations: 100,
-            bashTimeout: 15000,
+            ...config.channels.telegram.tools,
+            allowedPaths: config.channels.telegram.tools.allowedPaths?.length
+                ? config.channels.telegram.tools.allowedPaths
+                : resolveAllowedPaths(config),
         };
     }
     return {
         enabled: true,
-        allowedPaths: [join(homedir(), '.skimpyclaw')],
+        allowedPaths: resolveAllowedPaths(config),
         maxIterations: 100,
         bashTimeout: 15000,
     };
@@ -771,40 +770,6 @@ const SANDBOX_CLI_BY_PROFILE = {
     dev: ['bash', 'curl', 'git', 'gh', 'jq', 'python3', 'rg', 'pnpm', 'gcc', 'g++', 'make'],
     full: ['bash', 'curl', 'git', 'gh', 'jq', 'python3', 'rg', 'pnpm', 'gcc', 'g++', 'make', 'pip3', 'sqlite3'],
 };
-function defaultSandboxNetwork(runtime) {
-    return runtime === 'container' ? 'default' : 'bridge';
-}
-function detectSandboxRuntime(preferred) {
-    if (preferred === 'container' || preferred === 'docker') {
-        return spawnSync(preferred, ['--version'], { encoding: 'utf-8' }).status === 0 ? preferred : null;
-    }
-    if (spawnSync('container', ['--version'], { encoding: 'utf-8' }).status === 0) {
-        return 'container';
-    }
-    if (spawnSync('docker', ['--version'], { encoding: 'utf-8' }).status === 0) {
-        return 'docker';
-    }
-    return null;
-}
-function isSandboxRuntimeRunning(runtime) {
-    if (runtime === 'container') {
-        return spawnSync('container', ['system', 'status'], { encoding: 'utf-8' }).status === 0;
-    }
-    return spawnSync('docker', ['info'], { encoding: 'utf-8' }).status === 0;
-}
-function sandboxNetworkExists(runtime, network) {
-    if (runtime === 'container') {
-        const result = spawnSync('container', ['network', 'ls'], { encoding: 'utf-8' });
-        if (result.status !== 0)
-            return false;
-        return result.stdout.split('\n').some((line) => line.trim().split(/\s+/)[0] === network);
-    }
-    const result = spawnSync('docker', ['network', 'inspect', network], { encoding: 'utf-8' });
-    return result.status === 0;
-}
-function sandboxImageExists(runtime, image) {
-    return spawnSync(runtime, ['image', 'inspect', image], { encoding: 'utf-8' }).status === 0;
-}
 function resolveSandboxDir() {
     // 1. Check CWD (user is in repo root)
     const cwdSandbox = join(process.cwd(), 'sandbox');

package/dist/code-agents/parser.js

@@ -184,9 +184,14 @@ export function parseCodexOutput(stdout) {
     for (const line of lines) {
         try {
             const obj = JSON.parse(line);
+            // Standard output_text events
             if (obj.type === 'output_text' || obj.output_text) {
                 outputs.push(obj.output_text || obj.text || '');
             }
+            // Codex stream-json: item.completed with agent_message
+            else if (obj.type === 'item.completed' && obj.item?.type === 'agent_message' && obj.item?.text) {
+                outputs.push(obj.item.text);
+            }
         }
         catch {
             if (line.trim())

package/dist/config.d.ts

@@ -17,4 +17,11 @@ export declare function listMemoryFiles(agentId: string): {
     date: string;
     size: number;
 }[];
+/**
+ * Resolve allowed paths for a given context. Priority:
+ * 1. Explicit toolConfig.allowedPaths (if provided)
+ * 2. Config top-level allowedPaths
+ * 3. Fallback: ~/.skimpyclaw only
+ */
+export declare function resolveAllowedPaths(config: Config, overridePaths?: string[]): string[];
 export declare function readMemoryFile(agentId: string, filename: string): string;

package/dist/config.js

@@ -109,6 +109,19 @@ export function listMemoryFiles(agentId) {
         };
     }).sort((a, b) => b.date.localeCompare(a.date));
 }
+/**
+ * Resolve allowed paths for a given context. Priority:
+ * 1. Explicit toolConfig.allowedPaths (if provided)
+ * 2. Config top-level allowedPaths
+ * 3. Fallback: ~/.skimpyclaw only
+ */
+export function resolveAllowedPaths(config, overridePaths) {
+    if (overridePaths?.length)
+        return overridePaths;
+    if (config.allowedPaths?.length)
+        return config.allowedPaths;
+    return [join(homedir(), '.skimpyclaw')];
+}
 export function readMemoryFile(agentId, filename) {
     if (!isValidAgentId(agentId)) {
         throw new Error('Invalid agent ID');

package/dist/cron.js

@@ -3,7 +3,7 @@ import { Cron } from 'croner';
 import { exec } from 'child_process';
 import { existsSync, mkdirSync, appendFileSync, readFileSync, watch } from 'fs';
 import { join } from 'path';
-import { getLogsDir, getConfigPath, loadConfig } from './config.js';
+import { getLogsDir, getConfigPath, loadConfig, resolveAllowedPaths } from './config.js';
 import { homedir } from 'node:os';
 import { runAgentTurn } from './agent.js';
 import { startTrace, addEvent, endTrace } from './audit.js';
@@ -152,11 +152,14 @@ async function executeJobPayload(jobDef, config) {
             appendCronLogLine(jobDef.id, `Agent turn started (prompt: ${message.slice(0, 100)}...)`);
             const defaultTools = {
                 enabled: true,
-                allowedPaths: [`${homedir()}/.skimpyclaw`],
+                allowedPaths: resolveAllowedPaths(config),
                 maxIterations: 30,
                 bashTimeout: 15000,
             };
-            const response = await runAgentTurn(config.agents.default, message, config, jobDef.model, jobDef.payload.tools || defaultTools, undefined, {
+            const tools = jobDef.payload.tools
+                ? { ...jobDef.payload.tools, allowedPaths: jobDef.payload.tools.allowedPaths?.length ? jobDef.payload.tools.allowedPaths : resolveAllowedPaths(config) }
+                : defaultTools;
+            const response = await runAgentTurn(config.agents.default, message, config, jobDef.model, tools, undefined, {
                 channel: getActiveChannelId() || 'telegram',
                 trigger: 'cron',
                 sessionId: jobDef.id,

package/dist/heartbeat.js

@@ -6,30 +6,26 @@
 import { join } from 'path';
 import { homedir } from 'os';
 import { runAgentTurn } from './agent.js';
+import { resolveAllowedPaths } from './config.js';
 import { pruneIdle, SANDBOX_DEFAULTS } from './sandbox/index.js';
 import { getActiveChannelId, isActiveChannelSilenced, sendActiveChannelProactiveMessage, } from './channels.js';
 let heartbeatTimer = null;
 let running = false;
-const DEFAULT_HEARTBEAT_TOOLS = {
-    enabled: true,
-    allowedPaths: [join(homedir(), '.skimpyclaw')],
-    maxIterations: 100,
-    bashTimeout: 15000,
-};
 function getHeartbeatTools(config) {
     if (config.heartbeat.tools) {
-        return config.heartbeat.tools;
-    }
-    const defaultAllowedPaths = config.channels.active === 'discord'
-        ? config.channels.discord?.defaultAllowedPaths
-        : config.channels.telegram.defaultAllowedPaths || config.channels.discord?.defaultAllowedPaths;
-    if (defaultAllowedPaths?.length) {
         return {
-            ...DEFAULT_HEARTBEAT_TOOLS,
-            allowedPaths: defaultAllowedPaths,
+            ...config.heartbeat.tools,
+            allowedPaths: config.heartbeat.tools.allowedPaths?.length
+                ? config.heartbeat.tools.allowedPaths
+                : resolveAllowedPaths(config),
         };
     }
-    return DEFAULT_HEARTBEAT_TOOLS;
+    return {
+        enabled: true,
+        allowedPaths: resolveAllowedPaths(config),
+        maxIterations: 100,
+        bashTimeout: 15000,
+    };
 }
 function getHeartbeatFilePath(config) {
     return join(homedir(), '.skimpyclaw', 'agents', config.agents.default, 'HEARTBEAT.md');

package/dist/providers/anthropic.js

@@ -152,7 +152,13 @@ export async function chatWithToolsAnthropic(params) {
             };
         }
         // Compact old tool results if context is growing large
-        const messagesForApi = compactAnthropicMessages(apiMessages, toolConfig.contextManagement, i + 1);
+        const compactionResult = await compactAnthropicMessages(apiMessages, toolConfig.contextManagement, i + 1, config);
+        const messagesForApi = compactionResult.messages;
+        if (compactionResult.compacted) {
+            const method = compactionResult.method === 'llm' ? 'LLM summary' : 'truncation';
+            const detail = `~${Math.round((compactionResult.tokensBefore || 0) / 1000)}k → ~${Math.round((compactionResult.tokensAfter || 0) / 1000)}k tokens`;
+            toolLog.push(`[context compacted via ${method}: ${detail}]`);
+        }
         const anthropicParams = {
             model: modelId,
             max_tokens: options.maxTokens || 16384,

package/dist/providers/codex.js

@@ -265,7 +265,7 @@ export async function chatCodex(params) {
     }
 }
 export async function chatWithToolsCodex(params) {
-    const { messages, options, toolConfig, toolContext } = params;
+    const { messages, options, config, toolConfig, toolContext } = params;
     const modelId = stripProvider(options.model);
     const maxIterations = toolConfig.maxIterations || 100;
     // Build input — system messages go to `instructions`, rest to `input`
@@ -308,7 +308,13 @@ export async function chatWithToolsCodex(params) {
             };
         }
         // Compact old tool results if context is growing large
-        const inputForApi = compactCodexMessages(input, toolConfig.contextManagement, i + 1);
+        const compactionResult = await compactCodexMessages(input, toolConfig.contextManagement, i + 1, config);
+        const inputForApi = compactionResult.messages;
+        if (compactionResult.compacted) {
+            const method = compactionResult.method === 'llm' ? 'LLM summary' : 'truncation';
+            const detail = `~${Math.round((compactionResult.tokensBefore || 0) / 1000)}k → ~${Math.round((compactionResult.tokensAfter || 0) / 1000)}k tokens`;
+            toolLog.push(`[context compacted via ${method}: ${detail}]`);
+        }
         const body = {
             model: modelId,
             instructions,

package/dist/providers/context-manager.d.ts

@@ -1,22 +1,53 @@
 import type { ContextManagementConfig } from './types.js';
+import type { Config } from '../types.js';
 export type { ContextManagementConfig };
+/** Result of a compaction attempt, including metadata about what happened. */
+export interface CompactionResult<T> {
+    messages: T[];
+    /** Whether any compaction was performed */
+    compacted: boolean;
+    /** 'llm' if LLM summarized, 'truncation' if mechanically truncated, undefined if no compaction */
+    method?: 'llm' | 'truncation';
+    /** The summary text (only when method === 'llm') */
+    summary?: string;
+    /** Estimated tokens before compaction */
+    tokensBefore?: number;
+    /** Estimated tokens after compaction */
+    tokensAfter?: number;
+}
 /** Rough token estimate: 1 token ≈ 4 chars of JSON. */
 export declare function estimateTokens(data: any[]): number;
+/**
+ * Serialize Anthropic-format messages into a human-readable conversation transcript
+ * suitable for LLM summarization.
+ */
+declare function serializeAnthropicMessages(messages: any[]): string;
+/**
+ * Serialize OpenAI-format messages into a human-readable transcript.
+ */
+declare function serializeOpenAIMessages(messages: any[]): string;
+/**
+ * Serialize Codex-format input items into a human-readable transcript.
+ */
+declare function serializeCodexMessages(items: any[]): string;
 /**
  * Compact Anthropic-format apiMessages when over threshold.
- * Truncates content of old tool_result blocks; leaves last KEEP_TAIL messages intact.
+ * Uses LLM summarization for old messages; falls back to truncation on failure.
  * Does NOT mutate the input array — returns a new array.
  */
-export declare function compactAnthropicMessages(messages: any[], config?: ContextManagementConfig, iteration?: number): any[];
+export declare function compactAnthropicMessages(messages: any[], config?: ContextManagementConfig, iteration?: number, fullConfig?: Config): Promise<CompactionResult<any>>;
 /**
  * Compact OpenAI-format apiMessages when over threshold.
- * Truncates content of old `role: 'tool'` messages; leaves last KEEP_TAIL messages intact.
+ * Uses LLM summarization for old messages; falls back to truncation on failure.
  * Does NOT mutate the input array — returns a new array.
  */
-export declare function compactOpenAIMessages(messages: any[], config?: ContextManagementConfig, iteration?: number): any[];
+export declare function compactOpenAIMessages(messages: any[], config?: ContextManagementConfig, iteration?: number, fullConfig?: Config): Promise<CompactionResult<any>>;
 /**
  * Compact Codex-format input items when over threshold.
- * Truncates output of old function_call_output items; leaves last KEEP_TAIL items intact.
+ * Uses LLM summarization for old items; falls back to truncation on failure.
  * Does NOT mutate the input array — returns a new array.
  */
-export declare function compactCodexMessages(input: any[], config?: ContextManagementConfig, iteration?: number): any[];
+export declare function compactCodexMessages(input: any[], config?: ContextManagementConfig, iteration?: number, fullConfig?: Config): Promise<CompactionResult<any>>;
+export { serializeAnthropicMessages, serializeOpenAIMessages, serializeCodexMessages };
+/** Reset compaction markers (for testing). */
+export declare function resetCompactionState(): void;