@oyasmi/pipiclaw 0.6.1 → 0.6.3

package/dist/log.js

@@ -1,4 +1,7 @@
-import chalk from "chalk";
+import { styleText } from "node:util";
+function color(style, text) {
+    return styleText(style, text);
+}
 function timestamp() {
     const now = new Date();
     const hh = String(now.getHours()).padStart(2, "0");
@@ -50,91 +53,91 @@ function formatToolArgs(args) {
 }
 // User messages
 export function logUserMessage(ctx, text) {
-    console.log(chalk.green(`${timestamp()} ${formatContext(ctx)} ${text}`));
+    console.log(color("green", `${timestamp()} ${formatContext(ctx)} ${text}`));
 }
 // Tool execution
 export function logToolStart(ctx, toolName, label, args) {
     const formattedArgs = formatToolArgs(args);
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ↳ ${toolName}: ${label}`));
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} ↳ ${toolName}: ${label}`));
     if (formattedArgs) {
         const indented = formattedArgs
             .split("\n")
             .map((line) => `           ${line}`)
             .join("\n");
-        console.log(chalk.dim(indented));
+        console.log(color("dim", indented));
     }
 }
 export function logToolSuccess(ctx, toolName, durationMs, result) {
     const duration = (durationMs / 1000).toFixed(1);
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ✓ ${toolName} (${duration}s)`));
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} ✓ ${toolName} (${duration}s)`));
     const truncated = truncate(result, 1000);
     if (truncated) {
         const indented = truncated
             .split("\n")
             .map((line) => `           ${line}`)
             .join("\n");
-        console.log(chalk.dim(indented));
+        console.log(color("dim", indented));
     }
 }
 export function logToolError(ctx, toolName, durationMs, error) {
     const duration = (durationMs / 1000).toFixed(1);
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ✗ ${toolName} (${duration}s)`));
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} ✗ ${toolName} (${duration}s)`));
     const truncated = truncate(error, 1000);
     const indented = truncated
         .split("\n")
         .map((line) => `           ${line}`)
         .join("\n");
-    console.log(chalk.dim(indented));
+    console.log(color("dim", indented));
 }
 // Response streaming
 export function logResponseStart(ctx) {
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} → Streaming response...`));
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} → Streaming response...`));
 }
 export function logThinking(ctx, thinking) {
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} 💭 Thinking`));
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} 💭 Thinking`));
     const truncated = truncate(thinking, 1000);
     const indented = truncated
         .split("\n")
         .map((line) => `           ${line}`)
         .join("\n");
-    console.log(chalk.dim(indented));
+    console.log(color("dim", indented));
 }
 export function logResponse(ctx, text) {
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} 💬 Response`));
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} 💬 Response`));
     const truncated = truncate(text, 1000);
     const indented = truncated
         .split("\n")
         .map((line) => `           ${line}`)
         .join("\n");
-    console.log(chalk.dim(indented));
+    console.log(color("dim", indented));
 }
 // Control
 export function logStopRequest(ctx) {
-    console.log(chalk.green(`${timestamp()} ${formatContext(ctx)} stop`));
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ⊗ Stop requested - aborting`));
+    console.log(color("green", `${timestamp()} ${formatContext(ctx)} stop`));
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} ⊗ Stop requested - aborting`));
 }
 // System
 export function logInfo(message) {
-    console.log(chalk.blue(`${timestamp()} [system] ${message}`));
+    console.log(color("blue", `${timestamp()} [system] ${message}`));
 }
 export function logWarning(message, details) {
-    console.log(chalk.yellow(`${timestamp()} [system] ⚠ ${message}`));
+    console.log(color("yellow", `${timestamp()} [system] ⚠ ${message}`));
     if (details) {
         const indented = details
             .split("\n")
             .map((line) => `           ${line}`)
             .join("\n");
-        console.log(chalk.dim(indented));
+        console.log(color("dim", indented));
     }
 }
 export function logAgentError(ctx, error) {
     const context = ctx === "system" ? "[system]" : formatContext(ctx);
-    console.log(chalk.yellow(`${timestamp()} ${context} ✗ Agent error`));
+    console.log(color("yellow", `${timestamp()} ${context} ✗ Agent error`));
     const indented = error
         .split("\n")
         .map((line) => `           ${line}`)
         .join("\n");
-    console.log(chalk.dim(indented));
+    console.log(color("dim", indented));
 }
 // Usage summary
 export function logUsageSummary(ctx, usage, contextTokens, contextWindow) {
@@ -164,8 +167,8 @@ export function logUsageSummary(ctx, usage, contextTokens, contextWindow) {
     lines.push(`**Total: $${usage.cost.total.toFixed(4)}**`);
     const summary = lines.join("\n");
     // Log to console
-    console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} 💰 Usage`));
-    console.log(chalk.dim(`           ${usage.input.toLocaleString()} in + ${usage.output.toLocaleString()} out` +
+    console.log(color("yellow", `${timestamp()} ${formatContext(ctx)} 💰 Usage`));
+    console.log(color("dim", `           ${usage.input.toLocaleString()} in + ${usage.output.toLocaleString()} out` +
         (usage.cacheRead > 0 || usage.cacheWrite > 0
             ? ` (${usage.cacheRead.toLocaleString()} cache read, ${usage.cacheWrite.toLocaleString()} cache write)`
             : "") +

package/dist/memory/files.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { dirname, join } from "path";
@@ -62,7 +63,7 @@ function normalizeContent(content) {
 }
 async function writeAtomically(path, content) {
     await mkdir(dirname(path), { recursive: true });
-    const tempPath = `${path}.tmp`;
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
     await writeFile(tempPath, content, "utf-8");
     await rename(tempPath, path);
 }

package/dist/memory/lifecycle.d.ts

@@ -14,7 +14,7 @@ export interface MemoryLifecycleOptions {
 }
 export declare class MemoryLifecycle {
     private options;
-    private backgroundQueue;
+    private durableMemoryQueue;
     private sessionRefreshQueue;
     private turnsSinceSessionUpdate;
     private toolCallsSinceSessionUpdate;
@@ -39,12 +39,14 @@ export declare class MemoryLifecycle {
     private refreshSessionMemory;
     private runSessionRefreshSerial;
     private requestThresholdSessionRefresh;
-    private enqueueBackgroundJob;
+    private runDurableMemoryJobSerial;
+    private enqueueDurableMemoryJob;
     private hasPendingAssistantSnapshot;
     private markDurableConsolidationCheckpoint;
     private logConsolidationResult;
     private scheduleIdleConsolidation;
     private runPreflightConsolidation;
+    private runPreflightConsolidationNow;
     private handleSessionBeforeCompact;
     private handleSessionCompact;
     private handleSessionBeforeSwitch;

package/dist/memory/lifecycle.js

@@ -5,7 +5,7 @@ const IDLE_CONSOLIDATION_DELAY_MS = 60_000;
 export class MemoryLifecycle {
     constructor(options) {
         this.options = options;
-        this.backgroundQueue = Promise.resolve();
+        this.durableMemoryQueue = Promise.resolve();
         this.sessionRefreshQueue = Promise.resolve();
         this.turnsSinceSessionUpdate = 0;
         this.toolCallsSinceSessionUpdate = 0;
@@ -75,15 +75,16 @@ export class MemoryLifecycle {
     }
     async flushForShutdown() {
         this.clearIdleConsolidationTimer();
-        const run = async () => {
+        await this.runDurableMemoryJobSerial(async () => {
             if (!this.hasPendingAssistantSnapshot()) {
                 return;
             }
-            await this.runPreflightConsolidation("shutdown");
-        };
-        const resultPromise = this.backgroundQueue.then(run, run);
-        this.backgroundQueue = resultPromise.then(() => undefined, () => undefined);
-        await resultPromise;
+            const messageSnapshot = [...this.options.getMessages()];
+            const sessionEntrySnapshot = [...this.options.getSessionEntries()];
+            const revisionSnapshot = this.durableRevision;
+            const settings = this.options.getSessionMemorySettings();
+            await this.runPreflightConsolidationNow("shutdown", messageSnapshot, sessionEntrySnapshot, revisionSnapshot, settings);
+        });
     }
     clearIdleConsolidationTimer() {
         if (!this.idleConsolidationTimer) {
@@ -152,8 +153,13 @@ export class MemoryLifecycle {
             this.thresholdRefreshQueued = false;
         });
     }
-    enqueueBackgroundJob(job, failureMessage) {
-        this.backgroundQueue = this.backgroundQueue.then(job).catch((error) => {
+    runDurableMemoryJobSerial(job) {
+        const resultPromise = this.durableMemoryQueue.then(job, job);
+        this.durableMemoryQueue = resultPromise.then(() => undefined, () => undefined);
+        return resultPromise;
+    }
+    enqueueDurableMemoryJob(job, failureMessage) {
+        void this.runDurableMemoryJobSerial(job).catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             log.logWarning(failureMessage, message);
         });
@@ -186,7 +192,7 @@ export class MemoryLifecycle {
             const messageSnapshot = [...this.options.getMessages()];
             const sessionEntrySnapshot = [...this.options.getSessionEntries()];
             const revisionSnapshot = this.durableRevision;
-            this.enqueueBackgroundJob(async () => {
+            this.enqueueDurableMemoryJob(async () => {
                 try {
                     log.logInfo(`[${this.options.channelId}] Memory consolidation starting (idle)`);
                     const result = await runInlineConsolidation(this.buildRunOptions(messageSnapshot, sessionEntrySnapshot));
@@ -210,6 +216,11 @@ export class MemoryLifecycle {
         const sessionEntrySnapshot = sessionEntries ? [...sessionEntries] : [...this.options.getSessionEntries()];
         const revisionSnapshot = this.durableRevision;
         const settings = this.options.getSessionMemorySettings();
+        await this.runDurableMemoryJobSerial(async () => {
+            await this.runPreflightConsolidationNow(reason, messageSnapshot, sessionEntrySnapshot, revisionSnapshot, settings);
+        });
+    }
+    async runPreflightConsolidationNow(reason, messageSnapshot, sessionEntrySnapshot, revisionSnapshot = this.durableRevision, settings = this.options.getSessionMemorySettings()) {
         if (this.shouldForceRefreshFor(reason, settings)) {
             await this.runSessionRefreshSerial({
                 reason,
@@ -246,7 +257,7 @@ export class MemoryLifecycle {
         this.enqueueBackgroundMaintenance();
     }
     enqueueBackgroundMaintenance() {
-        this.enqueueBackgroundJob(async () => {
+        this.enqueueDurableMemoryJob(async () => {
             const result = await runBackgroundMaintenance(this.buildRunOptions([], []));
             this.logBackgroundResult(result);
         }, `[${this.options.channelId}] Background memory maintenance failed`);

package/dist/runtime/bootstrap.d.ts

@@ -1,4 +1,4 @@
-import { type SandboxConfig } from "../sandbox.js";
+import { type Executor, type SandboxConfig } from "../sandbox.js";
 import { DingTalkBot, type DingTalkConfig, type DingTalkHandler } from "./dingtalk.js";
 import { ChannelStore } from "./store.js";
 export interface BootstrapPaths {
@@ -55,7 +55,7 @@ interface RuntimeContextOptions {
     sandbox: SandboxConfig;
     dingtalkConfig: DingTalkConfig;
     createBot?: (handler: DingTalkHandler, config: DingTalkConfig) => DingTalkBot;
-    createEventsWatcher?: (workspaceDir: string, bot: DingTalkBot) => {
+    createEventsWatcher?: (workspaceDir: string, bot: DingTalkBot, executor: Executor) => {
         start(): void;
         stop(): void;
     };

package/dist/runtime/bootstrap.js

@@ -6,7 +6,7 @@ import { resetRunner } from "../agent/runner-factory.js";
 import * as log from "../log.js";
 import { ensureChannelMemoryFilesSync } from "../memory/files.js";
 import { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "../paths.js";
-import { parseSandboxArg, validateSandbox } from "../sandbox.js";
+import { createExecutor, parseSandboxArg, validateSandbox } from "../sandbox.js";
 import { loadSecurityConfigWithDiagnostics } from "../security/config.js";
 import { PipiclawSettingsManager } from "../settings.js";
 import { formatConfigDiagnostic } from "../shared/config-diagnostics.js";
@@ -160,6 +160,15 @@ export class BootstrapExitError extends Error {
 export function isBootstrapExitError(error) {
     return error instanceof BootstrapExitError;
 }
+function readCliVersion() {
+    try {
+        const raw = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+        return typeof raw.version === "string" && raw.version.trim() ? raw.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
 function writeTextFileIfMissing(path, content, label, created) {
     if (existsSync(path)) {
         return false;
@@ -283,11 +292,16 @@ export function parseArgs(argv, paths = DEFAULT_BOOTSTRAP_PATHS, io = console) {
             io.log("Options:");
             io.log("  --sandbox=host              Run tools on host (default)");
             io.log("  --sandbox=docker:<name>     Run tools in Docker container");
+            io.log("  --version                   Print the current version and exit");
             io.log("");
             io.log(`Config:    ${paths.channelConfigPath}`);
             io.log(`Workspace: ${paths.workspaceDir}`);
             throw new BootstrapExitError(0);
         }
+        else if (arg === "--version") {
+            io.log(readCliVersion());
+            throw new BootstrapExitError(0);
+        }
     }
     return { sandbox };
 }
@@ -450,9 +464,10 @@ export function createRuntimeContext(options) {
     const bot = options.createBot
         ? options.createBot(handler, options.dingtalkConfig)
         : new DingTalkBot(handler, options.dingtalkConfig);
+    const executor = createExecutor(options.sandbox);
     const eventsWatcher = options.createEventsWatcher
-        ? options.createEventsWatcher(options.paths.workspaceDir, bot)
-        : createEventsWatcher(options.paths.workspaceDir, bot, loadSecurityConfigWithDiagnostics(options.paths.appHomeDir).config.commandGuard);
+        ? options.createEventsWatcher(options.paths.workspaceDir, bot, executor)
+        : createEventsWatcher(options.paths.workspaceDir, bot, executor, loadSecurityConfigWithDiagnostics(options.paths.appHomeDir).config.commandGuard);
     const shutdownWithReason = async (reason = "manual") => {
         if (shutdownPromise) {
             return shutdownPromise;

package/dist/runtime/dingtalk.d.ts

@@ -78,7 +78,13 @@ export declare class DingTalkBot {
     private clearKeepAliveTimer;
     private clearReconnectTimer;
     private clearAllTimers;
+    private sleep;
     private waitForDelay;
+    private waitForSocketState;
+    private markClientDisconnected;
+    private clearClientSocketReference;
+    private cleanupSocket;
+    private connectWithTimeout;
     private scheduleReconnect;
     start(): Promise<void>;
     private handleRawMessage;

package/dist/runtime/dingtalk.js

@@ -54,6 +54,13 @@ class ChannelQueue {
 // ============================================================================
 const DINGTALK_API = "https://api.dingtalk.com";
 const TOKEN_REFRESH_SECS = 90 * 60; // 1.5 hours (tokens expire after 2 hours)
+const CONNECT_ATTEMPT_TIMEOUT_MS = 10_000;
+const SOCKET_CLOSE_GRACE_MS = 1_000;
+const SOCKET_TERMINATE_GRACE_MS = 250;
+const SOCKET_STATE_CONNECTING = 0;
+const SOCKET_STATE_OPEN = 1;
+const SOCKET_STATE_CLOSING = 2;
+const SOCKET_STATE_CLOSED = 3;
 // ============================================================================
 // DingTalkBot
 // ============================================================================
@@ -140,6 +147,12 @@ export class DingTalkBot {
         this.clearKeepAliveTimer();
         this.clearReconnectTimer();
     }
+    async sleep(delayMs) {
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, delayMs);
+            timer.unref?.();
+        });
+    }
     async waitForDelay(delayMs) {
         await new Promise((resolve) => {
             this.reconnectTimer = this.setTrackedTimeout(() => {
@@ -148,6 +161,81 @@ export class DingTalkBot {
             }, delayMs);
         });
     }
+    async waitForSocketState(socket, expectedState, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while ((socket.readyState ?? SOCKET_STATE_CLOSED) !== expectedState && Date.now() < deadline) {
+            await this.sleep(25);
+        }
+        return (socket.readyState ?? SOCKET_STATE_CLOSED) === expectedState;
+    }
+    markClientDisconnected() {
+        if (!this.client) {
+            return;
+        }
+        Reflect.set(this.client, "connected", false);
+        Reflect.set(this.client, "registered", false);
+        Reflect.set(this.client, "reconnecting", false);
+    }
+    clearClientSocketReference() {
+        if (!this.client) {
+            return;
+        }
+        Reflect.set(this.client, "socket", undefined);
+    }
+    async cleanupSocket(reason) {
+        const socket = this.getSocket();
+        this.markClientDisconnected();
+        if (!socket) {
+            this.clearClientSocketReference();
+            return;
+        }
+        socket.removeAllListeners?.();
+        if ((socket.readyState ?? SOCKET_STATE_CLOSED) !== SOCKET_STATE_CLOSED) {
+            try {
+                socket.close?.();
+            }
+            catch (err) {
+                log.logWarning(`DingTalk: socket close failed during ${reason}`, err instanceof Error ? err.message : String(err));
+            }
+            const closed = await this.waitForSocketState(socket, SOCKET_STATE_CLOSED, SOCKET_CLOSE_GRACE_MS);
+            if (!closed) {
+                log.logWarning(`DingTalk: forcing socket termination during ${reason}`);
+                try {
+                    socket.terminate?.();
+                }
+                catch (err) {
+                    log.logWarning(`DingTalk: socket terminate failed during ${reason}`, err instanceof Error ? err.message : String(err));
+                }
+                await this.waitForSocketState(socket, SOCKET_STATE_CLOSED, SOCKET_TERMINATE_GRACE_MS);
+            }
+        }
+        this.clearClientSocketReference();
+    }
+    async connectWithTimeout() {
+        if (!this.client) {
+            throw new Error("DingTalk client is not initialized");
+        }
+        const connectPromise = Promise.resolve(this.client.connect());
+        let timeoutHandle = null;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                reject(new Error(`connect timed out after ${CONNECT_ATTEMPT_TIMEOUT_MS}ms`));
+            }, CONNECT_ATTEMPT_TIMEOUT_MS);
+            timeoutHandle.unref?.();
+        });
+        try {
+            await Promise.race([connectPromise, timeoutPromise]);
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
+        const socket = this.getSocket();
+        if (!socket || socket.readyState !== SOCKET_STATE_OPEN) {
+            throw new Error("stream socket did not reach open state");
+        }
+    }
     scheduleReconnect(delayMs, immediate) {
         if (this.isStopped) {
             return;
@@ -173,11 +261,13 @@ export class DingTalkBot {
         }
         log.logInfo(`DingTalk: initializing stream (clientId=${this.config.clientId.substring(0, 8)}…)`);
         this.clearAllTimers();
-        this.client = new DWClient({
+        const clientOptions = {
             clientId: this.config.clientId,
             clientSecret: this.config.clientSecret,
+            autoReconnect: false,
             keepAlive: false,
-        });
+        };
+        this.client = new DWClient(clientOptions);
         this.client.registerCallbackListener(TOPIC_ROBOT, (msg) => {
             return this.handleRawMessage(msg);
         });
@@ -220,6 +310,8 @@ export class DingTalkBot {
         this.isReconnecting = true;
         let connectionFailed = false;
         let connected = false;
+        this.clearReconnectTimer();
+        this.clearKeepAliveTimer();
         if (!immediate && this.reconnectAttempts > 0) {
             const delay = Math.min(1000 * 2 ** this.reconnectAttempts + Math.random() * 1000, 30000);
             log.logInfo(`DingTalk: waiting ${Math.round(delay / 1000)}s before reconnecting...`);
@@ -231,10 +323,14 @@ export class DingTalkBot {
         }
         try {
             const socket = this.getSocket();
-            if (socket?.readyState === 1 || socket?.readyState === 3) {
-                await Promise.resolve(this.client.disconnect());
-            }
-            await this.client.connect();
+            const readyState = socket?.readyState;
+            if (readyState === SOCKET_STATE_CONNECTING ||
+                readyState === SOCKET_STATE_OPEN ||
+                readyState === SOCKET_STATE_CLOSING ||
+                readyState === SOCKET_STATE_CLOSED) {
+                await this.cleanupSocket("reconnect");
+            }
+            await this.connectWithTimeout();
             this.lastSocketAvailableTime = Date.now();
             this.reconnectAttempts = 0; // Success, reset backoff
             log.logInfo("DingTalk: connected to stream.");
@@ -289,6 +385,7 @@ export class DingTalkBot {
             });
         }
         catch (err) {
+            await this.cleanupSocket("reconnect failure");
             this.reconnectAttempts++;
             connectionFailed = true;
             log.logWarning("DingTalk: connection failed", err instanceof Error ? err.message : String(err));
@@ -311,7 +408,7 @@ export class DingTalkBot {
         }
         if (this.client) {
             try {
-                await Promise.resolve(this.client.disconnect());
+                await this.cleanupSocket("stop");
             }
             catch (err) {
                 log.logWarning("DingTalk: failed to disconnect cleanly", err instanceof Error ? err.message : String(err));

package/dist/runtime/events.d.ts

@@ -1,3 +1,4 @@
+import type { Executor } from "../sandbox.js";
 import type { SecurityConfig } from "../security/types.js";
 import type { DingTalkBot } from "./dingtalk.js";
 export interface EventAction {
@@ -30,6 +31,7 @@ export type ScheduledEvent = ImmediateEvent | OneShotEvent | PeriodicEvent;
 export declare class EventsWatcher {
     private eventsDir;
     private bot;
+    private executor;
     private commandGuardConfig?;
     private timers;
     private crons;
@@ -37,7 +39,7 @@ export declare class EventsWatcher {
     private startTime;
     private watcher;
     private knownFiles;
-    constructor(eventsDir: string, bot: DingTalkBot, commandGuardConfig?: SecurityConfig["commandGuard"] | undefined);
+    constructor(eventsDir: string, bot: DingTalkBot, executor: Executor, commandGuardConfig?: SecurityConfig["commandGuard"] | undefined);
     start(): void;
     stop(): void;
     private debounce;
@@ -62,4 +64,4 @@ export declare class EventsWatcher {
 /**
  * Create and start an events watcher.
  */
-export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot, commandGuardConfig?: SecurityConfig["commandGuard"]): EventsWatcher;
+export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot, executor: Executor, commandGuardConfig?: SecurityConfig["commandGuard"]): EventsWatcher;

package/dist/runtime/events.js

@@ -1,4 +1,3 @@
-import { exec } from "child_process";
 import { Cron } from "croner";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, watch, writeFileSync } from "fs";
 import { readFile } from "fs/promises";
@@ -13,9 +12,10 @@ const MAX_RETRIES = 3;
 const RETRY_BASE_MS = 100;
 const MAX_TIMEOUT_MS = 2_147_483_647;
 export class EventsWatcher {
-    constructor(eventsDir, bot, commandGuardConfig) {
+    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();
@@ -314,24 +314,20 @@ export class EventsWatcher {
             }
         }
     }
-    runPreAction(action, filename) {
+    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}`);
-                return Promise.reject(new Error(`guard: ${guardResult.reason}`));
+                throw new Error(`guard: ${guardResult.reason}`);
             }
         }
-        return new Promise((resolve, reject) => {
-            const child = exec(action.command, { timeout: action.timeout ?? 10_000 });
-            child.on("close", (code) => {
-                if (code === 0)
-                    resolve();
-                else
-                    reject(new Error(`exit ${code}`));
-            });
-            child.on("error", reject);
-        });
+        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);
@@ -376,7 +372,7 @@ export class EventsWatcher {
 /**
  * Create and start an events watcher.
  */
-export function createEventsWatcher(workspaceDir, bot, commandGuardConfig) {
+export function createEventsWatcher(workspaceDir, bot, executor, commandGuardConfig) {
     const eventsDir = join(workspaceDir, "events");
-    return new EventsWatcher(eventsDir, bot, commandGuardConfig);
+    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/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.1",
+	"version": "0.6.3",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {
@@ -21,8 +21,8 @@
 		"LICENSE"
 	],
 	"scripts": {
-		"clean": "shx rm -rf dist coverage",
-		"build": "tsc -p tsconfig.build.json && shx chmod +x dist/main.js",
+		"clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('coverage', { recursive: true, force: true });\"",
+		"build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/main.js', 0o755)\"",
 		"dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
 		"lint": "biome check .",
 		"typecheck": "tsc --noEmit -p tsconfig.json",
@@ -39,7 +39,6 @@
 		"@mozilla/readability": "^0.6.0",
 		"@sinclair/typebox": "^0.34.0",
 		"axios": "^1.7.0",
-		"chalk": "^5.6.2",
 		"croner": "^9.1.0",
 		"diff": "^8.0.2",
 		"dingtalk-stream": "^2.1.4",
@@ -51,11 +50,9 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.3.5",
-		"@types/diff": "^7.0.2",
 		"@types/jsdom": "^28.0.1",
 		"@types/node": "^24.3.0",
 		"@vitest/coverage-v8": "^3.2.4",
-		"shx": "^0.4.0",
 		"typescript": "^5.7.3",
 		"vitest": "^3.2.4"
 	},