@oyasmi/pipiclaw 0.6.0 → 0.6.2

package/dist/runtime/events.js

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, watch, writeF
 import { readFile } from "fs/promises";
 import { join } from "path";
 import * as log from "../log.js";
+import { guardCommand } from "../security/command-guard.js";
 // ============================================================================
 // EventsWatcher
 // ============================================================================
@@ -11,9 +12,11 @@ const MAX_RETRIES = 3;
 const RETRY_BASE_MS = 100;
 const MAX_TIMEOUT_MS = 2_147_483_647;
 export class EventsWatcher {
-    constructor(eventsDir, bot) {
+    constructor(eventsDir, bot, executor, commandGuardConfig) {
         this.eventsDir = eventsDir;
         this.bot = bot;
+        this.executor = executor;
+        this.commandGuardConfig = commandGuardConfig;
         this.timers = new Map();
         this.crons = new Map();
         this.debounceTimers = new Map();
@@ -145,19 +148,39 @@ export class EventsWatcher {
                 break;
         }
     }
+    parsePreAction(data, filename) {
+        if (!data.preAction)
+            return undefined;
+        if (typeof data.preAction !== "object" || data.preAction === null) {
+            throw new Error(`Invalid 'preAction' field in ${filename}, expected an object`);
+        }
+        const action = data.preAction;
+        if (action.type !== "bash") {
+            throw new Error(`Unsupported preAction type '${String(action.type)}' in ${filename}, only 'bash' is supported`);
+        }
+        if (typeof action.command !== "string" || action.command.trim().length === 0) {
+            throw new Error(`Missing or empty 'preAction.command' in ${filename}`);
+        }
+        return {
+            type: "bash",
+            command: action.command,
+            ...(typeof action.timeout === "number" ? { timeout: action.timeout } : {}),
+        };
+    }
     parseEvent(content, filename) {
         const data = JSON.parse(content);
         if (!data.type || !data.channelId || !data.text) {
             throw new Error(`Missing required fields (type, channelId, text) in ${filename}`);
         }
+        const preAction = this.parsePreAction(data, filename);
         switch (data.type) {
             case "immediate":
-                return { type: "immediate", channelId: data.channelId, text: data.text };
+                return { type: "immediate", channelId: data.channelId, text: data.text, preAction };
             case "one-shot":
                 if (!data.at) {
                     throw new Error(`Missing 'at' field for one-shot event in ${filename}`);
                 }
-                return { type: "one-shot", channelId: data.channelId, text: data.text, at: data.at };
+                return { type: "one-shot", channelId: data.channelId, text: data.text, at: data.at, preAction };
             case "periodic":
                 if (!data.schedule) {
                     throw new Error(`Missing 'schedule' field for periodic event in ${filename}`);
@@ -171,12 +194,13 @@ export class EventsWatcher {
                     text: data.text,
                     schedule: data.schedule,
                     timezone: data.timezone,
+                    preAction,
                 };
             default:
                 throw new Error(`Unknown event type '${data.type}' in ${filename}`);
         }
     }
-    handleImmediate(filename, event) {
+    async handleImmediate(filename, event) {
         const filePath = join(this.eventsDir, filename);
         try {
             const stat = statSync(filePath);
@@ -190,7 +214,7 @@ export class EventsWatcher {
             return;
         }
         log.logInfo(`Executing immediate event: ${filename}`);
-        this.execute(filename, event);
+        await this.execute(filename, event);
     }
     handleOneShot(filename, event) {
         const atTime = new Date(event.at).getTime();
@@ -212,18 +236,28 @@ export class EventsWatcher {
             return;
         }
         log.logInfo(`Scheduling one-shot event: ${filename} in ${Math.round(delay / 1000)}s`);
-        const timer = setTimeout(() => {
+        const timer = setTimeout(async () => {
             this.timers.delete(filename);
-            log.logInfo(`Executing one-shot event: ${filename}`);
-            this.execute(filename, event);
+            try {
+                log.logInfo(`Executing one-shot event: ${filename}`);
+                await this.execute(filename, event);
+            }
+            catch (err) {
+                log.logWarning(`One-shot event execution failed: ${filename}`, String(err));
+            }
         }, delay);
         this.timers.set(filename, timer);
     }
     handlePeriodic(filename, event) {
         try {
-            const cron = new Cron(event.schedule, { timezone: event.timezone }, () => {
-                log.logInfo(`Executing periodic event: ${filename}`);
-                this.execute(filename, event, false);
+            const cron = new Cron(event.schedule, { timezone: event.timezone }, async () => {
+                try {
+                    log.logInfo(`Executing periodic event: ${filename}`);
+                    await this.execute(filename, event, false);
+                }
+                catch (err) {
+                    log.logWarning(`Periodic event execution failed: ${filename}`, String(err));
+                }
             });
             this.crons.set(filename, cron);
             const next = cron.nextRun();
@@ -234,7 +268,17 @@ export class EventsWatcher {
             this.markInvalid(filename, `Invalid cron schedule: ${event.schedule}\n${String(err)}`);
         }
     }
-    execute(filename, event, deleteAfter = true) {
+    async execute(filename, event, deleteAfter = true) {
+        if (event.preAction) {
+            try {
+                await this.runPreAction(event.preAction, filename);
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                log.logInfo(`Pre-action gate blocked event: ${filename} (${reason})`);
+                return;
+            }
+        }
         let scheduleInfo;
         switch (event.type) {
             case "immediate":
@@ -270,6 +314,21 @@ export class EventsWatcher {
             }
         }
     }
+    async runPreAction(action, filename) {
+        if (this.commandGuardConfig?.enabled) {
+            const guardResult = guardCommand(action.command, this.commandGuardConfig);
+            if (!guardResult.allowed) {
+                log.logWarning(`Pre-action command blocked by guard for ${filename}: ${guardResult.reason}`);
+                throw new Error(`guard: ${guardResult.reason}`);
+            }
+        }
+        const timeoutMs = action.timeout ?? 10_000;
+        const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1000));
+        const result = await this.executor.exec(action.command, { timeout: timeoutSeconds });
+        if (result.code !== 0) {
+            throw new Error(`exit ${result.code}`);
+        }
+    }
     deleteFile(filename) {
         const filePath = join(this.eventsDir, filename);
         try {
@@ -313,7 +372,7 @@ export class EventsWatcher {
 /**
  * Create and start an events watcher.
  */
-export function createEventsWatcher(workspaceDir, bot) {
+export function createEventsWatcher(workspaceDir, bot, executor, commandGuardConfig) {
     const eventsDir = join(workspaceDir, "events");
-    return new EventsWatcher(eventsDir, bot);
+    return new EventsWatcher(eventsDir, bot, executor, commandGuardConfig);
 }

package/dist/settings.js

@@ -194,13 +194,13 @@ export class PipiclawSettingsManager {
     }
     // Compaction details
     getCompactionReserveTokens() {
-        return DEFAULT_COMPACTION.reserveTokens;
+        return this.getCompactionSettings().reserveTokens;
     }
     getCompactionKeepRecentTokens() {
-        return DEFAULT_COMPACTION.keepRecentTokens;
+        return this.getCompactionSettings().keepRecentTokens;
     }
     getBranchSummarySettings() {
-        return { reserveTokens: 16384 };
+        return { reserveTokens: this.getCompactionSettings().reserveTokens };
     }
     getBranchSummarySkipPrompt() {
         return false;

package/dist/subagents/tool.d.ts

@@ -1,5 +1,6 @@
 import { type AgentEvent, type AgentMessage, type AgentTool } from "@mariozechner/pi-agent-core";
 import type { Api, Model } from "@mariozechner/pi-ai";
+import type { MemoryCandidateStore } from "../memory/candidates.js";
 import type { Executor } from "../sandbox.js";
 import type { SecurityConfig } from "../security/types.js";
 import type { PipiclawMemoryRecallSettings } from "../settings.js";
@@ -44,6 +45,7 @@ export interface SubAgentToolOptions {
     channelDir: string;
     getSubAgentDiscovery?: () => SubAgentDiscoveryResult;
     getMemoryRecallSettings?: () => PipiclawMemoryRecallSettings;
+    memoryCandidateStore?: MemoryCandidateStore;
     securityConfig?: SecurityConfig;
     webConfig?: PipiclawWebToolsConfig;
     runtimeContext: {

package/dist/subagents/tool.js

@@ -1,7 +1,6 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { convertToLlm } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { createMemoryCandidateCache } from "../memory/candidates.js";
 import { readChannelSession } from "../memory/files.js";
 import { recallRelevantMemory } from "../memory/recall.js";
 import { formatModelReference } from "../models/utils.js";
@@ -187,7 +186,7 @@ function stripRuntimeContextWrapper(renderedText) {
         .replace(/\s*<\/runtime_context>$/i, "")
         .trim();
 }
-async function buildContextualBlocks(task, config, options, currentModel, candidateCache = createMemoryCandidateCache()) {
+async function buildContextualBlocks(task, config, options, currentModel) {
     if (config.contextMode !== "contextual") {
         return [];
     }
@@ -226,7 +225,7 @@ async function buildContextualBlocks(task, config, options, currentModel, candid
         model: currentModel,
         resolveApiKey: options.resolveApiKey,
         allowedSources: ["workspace-memory", "channel-memory", "channel-history"],
-        candidateCache,
+        candidateStore: options.memoryCandidateStore,
     });
     const recalledText = stripRuntimeContextWrapper(recalled.renderedText);
     if (recalledText) {

package/dist/tools/index.d.ts

@@ -1,5 +1,6 @@
 import type { AgentTool } from "@mariozechner/pi-agent-core";
 import type { Api, Model } from "@mariozechner/pi-ai";
+import type { MemoryCandidateStore } from "../memory/candidates.js";
 import type { Executor, SandboxConfig } from "../sandbox.js";
 import type { SecurityConfig, SecurityRuntimeContext } from "../security/types.js";
 import type { PipiclawMemoryRecallSettings } from "../settings.js";
@@ -17,6 +18,7 @@ export interface CreatePipiclawToolsOptions {
     sandboxConfig: SandboxConfig;
     getSubAgentDiscovery: () => SubAgentDiscoveryResult;
     getMemoryRecallSettings: () => PipiclawMemoryRecallSettings;
+    memoryCandidateStore: MemoryCandidateStore;
     securityConfig?: SecurityConfig;
     toolsConfig?: PipiclawToolsConfig;
 }

package/dist/tools/index.js

@@ -65,6 +65,7 @@ export function createPipiclawTools(options) {
             channelDir: options.channelDir,
             getSubAgentDiscovery: options.getSubAgentDiscovery,
             getMemoryRecallSettings: options.getMemoryRecallSettings,
+            memoryCandidateStore: options.memoryCandidateStore,
             securityConfig,
             webConfig: toolsConfig.tools.web,
             runtimeContext: {

package/dist/tools/read.js

@@ -28,6 +28,12 @@ const readSchema = Type.Object({
     offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
 });
+function countTextLines(content) {
+    if (content.length === 0) {
+        return 0;
+    }
+    return content.endsWith("\n") ? content.split("\n").length - 1 : content.split("\n").length;
+}
 function formatPathBlockMessage(resolvedPath, category, reason) {
     const lines = [`Path blocked${category ? ` [${category}]` : ""}`];
     if (reason) {
@@ -84,16 +90,17 @@ export function createReadTool(executor, options = {}) {
                 };
             }
             // Get total line count first
-            const countResult = await executor.exec(`wc -l < ${shellEscapePath(path)}`, { signal });
+            const countResult = await executor.exec(`awk 'END { print NR }' ${shellEscapePath(path)}`, { signal });
             if (countResult.code !== 0) {
                 throw new Error(countResult.stderr || `Failed to read file: ${path}`);
             }
-            const totalFileLines = Number.parseInt(countResult.stdout.trim(), 10) + 1; // wc -l counts newlines, not lines
+            const totalFileLines = Number.parseInt(countResult.stdout.trim(), 10);
             // Apply offset if specified (1-indexed)
             const startLine = offset ? Math.max(1, offset) : 1;
             const startLineDisplay = startLine;
             // Check if offset is out of bounds
-            if (startLine > totalFileLines) {
+            if ((totalFileLines === 0 && offset !== undefined && startLine > 1) ||
+                (totalFileLines > 0 && startLine > totalFileLines)) {
                 throw new Error(`Offset ${offset} is beyond end of file (${totalFileLines} lines total)`);
             }
             // Read content with offset
@@ -113,7 +120,7 @@ export function createReadTool(executor, options = {}) {
             // Apply user limit if specified
             if (limit !== undefined) {
                 const lines = selectedContent.split("\n");
-                const endLine = Math.min(limit, lines.length);
+                const endLine = Math.min(limit, countTextLines(selectedContent));
                 selectedContent = lines.slice(0, endLine).join("\n");
                 userLimitedLines = endLine;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oyasmi/pipiclaw",
-	"version": "0.6.0",
+	"version": "0.6.2",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {