@oyasmi/pipiclaw 0.6.1 → 0.6.2

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";
@@ -450,9 +450,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/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.2",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {