@oyasmi/pipiclaw 0.6.0 → 0.6.2

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/memory/recall.d.ts

@@ -1,5 +1,5 @@
 import type { Api, Model } from "@mariozechner/pi-ai";
-import { type MemoryCandidate, type MemoryCandidateCache } from "./candidates.js";
+import { type MemoryCandidate, type MemoryCandidateStore } from "./candidates.js";
 export interface RecallRequest {
     query: string;
     workspaceDir: string;
@@ -12,7 +12,7 @@ export interface RecallRequest {
     autoRerank?: boolean;
     model: Model<Api>;
     resolveApiKey: (model: Model<Api>) => Promise<string>;
-    candidateCache?: MemoryCandidateCache;
+    candidateStore?: MemoryCandidateStore;
 }
 export interface RecalledMemory {
     source: MemoryCandidate["source"];

package/dist/memory/recall.js

@@ -1,6 +1,6 @@
 import { parseJsonObject } from "../shared/llm-json.js";
 import { HAN_REGEX } from "../shared/text-utils.js";
-import { buildMemoryCandidates } from "./candidates.js";
+import { buildMemoryCandidates, createMemoryCandidateStore, } from "./candidates.js";
 import { COMMON_CHINESE_WORDS } from "./chinese-words.js";
 import { runSidecarTask } from "./sidecar-worker.js";
 const RERANK_SYSTEM_PROMPT = `You are selecting which memory snippets are most relevant to the current user turn.
@@ -466,8 +466,7 @@ export async function recallRelevantMemory(request) {
     const candidates = await buildMemoryCandidates({
         workspaceDir: request.workspaceDir,
         channelDir: request.channelDir,
-        cache: request.candidateCache,
-    });
+    }, request.candidateStore ?? createMemoryCandidateStore());
     const filteredCandidates = request.allowedSources?.length
         ? candidates.filter((candidate) => request.allowedSources?.includes(candidate.source))
         : candidates;

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";
@@ -137,7 +137,7 @@ const SECURITY_CONFIG_TEMPLATE = {
     },
 };
 const SHUTDOWN_WAIT_MS = 15000;
-const SHUTDOWN_FLUSH_WAIT_MS = 25000;
+const SHUTDOWN_FLUSH_WAIT_MS = 45000;
 const SHUTDOWN_ABORT_WAIT_MS = 5000;
 export const DEFAULT_BOOTSTRAP_PATHS = {
     appName: APP_NAME,
@@ -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);
+        ? 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/delivery.js

@@ -6,7 +6,9 @@ class ChannelDeliveryController {
         this.event = event;
         this.bot = bot;
         this.store = store;
-        this.progressText = "";
+        this.progressSegments = [];
+        this.cachedProgressText = "";
+        this.progressTextDirty = false;
         this.mode = "progress";
         this.desiredRevision = 0;
         this.appliedRevision = 0;
@@ -20,6 +22,9 @@ class ChannelDeliveryController {
         this.timer = null;
         this.cardWarmupTimer = null;
         this.flushWaiters = [];
+        this.sentProgressChars = 0;
+        this.replayRequired = false;
+        this.finalReplacementText = "";
     }
     buildContext() {
         return {
@@ -86,7 +91,11 @@ class ChannelDeliveryController {
         if (this.closed || this.finalResponseDelivered || !text.trim())
             return;
         this.clearCardWarmup();
-        this.progressText = this.progressText ? `${this.progressText}\n\n${text}` : text;
+        if (this.progressSegments.length > 0) {
+            this.progressSegments.push("\n\n");
+        }
+        this.progressSegments.push(text);
+        this.progressTextDirty = true;
         if (this.progressWindowStartedAt === 0) {
             this.progressWindowStartedAt = Date.now();
         }
@@ -116,7 +125,7 @@ class ChannelDeliveryController {
         if (this.closed || this.finalResponseDelivered)
             return;
         this.clearCardWarmup();
-        this.progressText = text;
+        this.finalReplacementText = text;
         this.mode = "finalize-with-fallback";
         this.bumpRevision(true);
     }
@@ -159,6 +168,7 @@ class ChannelDeliveryController {
         try {
             while (this.appliedRevision < this.desiredRevision) {
                 const mode = this.mode;
+                const progressText = this.getProgressText();
                 const throttleBaseAt = this.lastDeliveredAt > 0 ? this.lastDeliveredAt : this.progressWindowStartedAt;
                 if (mode === "progress" && throttleBaseAt > 0) {
                     const remaining = MIN_UPDATE_INTERVAL_MS - (Date.now() - throttleBaseAt);
@@ -171,31 +181,48 @@ class ChannelDeliveryController {
                     }
                 }
                 const revision = this.desiredRevision;
-                const content = this.progressText.trim();
+                const content = progressText.trim();
+                const replacementText = this.finalReplacementText;
                 let touchedRemote = false;
                 try {
                     if (mode === "progress") {
                         if (content) {
-                            touchedRemote = await this.bot.streamToCard(this.event.channelId, this.progressText);
+                            const nextSentChars = progressText.length;
+                            if (this.replayRequired) {
+                                touchedRemote = await this.bot.replaceCard(this.event.channelId, progressText);
+                            }
+                            else {
+                                const delta = progressText.slice(this.sentProgressChars);
+                                touchedRemote = delta ? await this.bot.appendToCard(this.event.channelId, delta) : true;
+                            }
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
+                                this.replayRequired = true;
+                            }
+                            else {
+                                this.sentProgressChars = nextSentChars;
+                                this.replayRequired = false;
                             }
                         }
                     }
                     else if (mode === "finalize-existing") {
                         if (content || this.cardWarmupTriggered) {
-                            touchedRemote = await this.bot.finalizeExistingCard(this.event.channelId, content ? this.progressText : NO_CONTENT);
+                            touchedRemote = await this.bot.replaceCard(this.event.channelId, content ? progressText : NO_CONTENT, true);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
+                            else {
+                                this.sentProgressChars = progressText.length;
+                                this.replayRequired = false;
+                            }
                         }
                         else {
                             this.bot.discardCard(this.event.channelId);
                         }
                     }
                     else if (mode === "finalize-with-fallback") {
-                        if (content) {
-                            touchedRemote = await this.bot.finalizeCard(this.event.channelId, this.progressText);
+                        if (replacementText.trim()) {
+                            touchedRemote = await this.bot.finalizeCard(this.event.channelId, replacementText);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
@@ -206,7 +233,7 @@ class ChannelDeliveryController {
                     }
                     else if (mode === "silent") {
                         if (this.cardWarmupTriggered) {
-                            touchedRemote = await this.bot.finalizeExistingCard(this.event.channelId, NO_CONTENT);
+                            touchedRemote = await this.bot.replaceCard(this.event.channelId, NO_CONTENT, true);
                         }
                         if (!touchedRemote) {
                             this.bot.discardCard(this.event.channelId);
@@ -216,6 +243,9 @@ class ChannelDeliveryController {
                 catch (err) {
                     log.logWarning(`[${this.event.channelId}] Delivery sync failed`, err instanceof Error ? err.message : String(err));
                     this.bot.discardCard(this.event.channelId);
+                    if (mode === "progress") {
+                        this.replayRequired = true;
+                    }
                 }
                 if (touchedRemote) {
                     this.lastDeliveredAt = Date.now();
@@ -262,6 +292,14 @@ class ChannelDeliveryController {
         this.clearCardWarmup();
         await this.flush();
     }
+    getProgressText() {
+        if (!this.progressTextDirty) {
+            return this.cachedProgressText;
+        }
+        this.cachedProgressText = this.progressSegments.join("");
+        this.progressTextDirty = false;
+        return this.cachedProgressText;
+    }
 }
 export function createDingTalkContext(event, bot, store) {
     return new ChannelDeliveryController(event, bot, store).buildContext();

package/dist/runtime/dingtalk.d.ts

@@ -94,7 +94,15 @@ export declare class DingTalkBot {
      */
     ensureCard(channelId: string): Promise<void>;
     /**
-     * Stream content to the active AI Card for a channel.
+     * Replace the active card content with a full snapshot.
+     */
+    replaceCard(channelId: string, content: string, finalize?: boolean, failed?: boolean): Promise<boolean>;
+    /**
+     * Append a delta to the active card transcript.
+     */
+    appendToCard(channelId: string, content: string, finalize?: boolean, failed?: boolean): Promise<boolean>;
+    /**
+     * Stream content to the active AI Card for a channel using full replacement semantics.
      */
     streamToCard(channelId: string, content: string, finalize?: boolean): Promise<boolean>;
     /**

package/dist/runtime/dingtalk.js

@@ -362,48 +362,80 @@ export class DingTalkBot {
         await this.createCard(channelId);
     }
     /**
-     * Stream content to the active AI Card for a channel.
+     * Replace the active card content with a full snapshot.
      */
-    async streamToCard(channelId, content, finalize = false) {
+    async replaceCard(channelId, content, finalize = false, failed = false) {
         let card = this.activeCards.get(channelId);
-        if ((!card || card.finished) && !finalize && this.config.cardTemplateId && content.trim()) {
+        if ((!card || card.finished) && this.config.cardTemplateId && (content.trim() || !finalize || failed)) {
             await this.ensureCard(channelId);
             card = this.activeCards.get(channelId);
         }
         if (!card || card.finished) {
-            if (finalize) {
+            if (finalize && content.trim()) {
                 return this.sendPlain(channelId, content);
             }
             return false;
         }
-        const streamed = await this.streamCard(card, content, finalize);
-        if (!streamed) {
+        const streamed = await this.streamCard(card, content, {
+            append: false,
+            finalize,
+            failed,
+        });
+        if (!streamed || finalize || failed) {
             this.activeCards.delete(channelId);
         }
         return streamed;
     }
     /**
-     * Finalize the active card for a channel without falling back to a plain message.
-     * Returns true if a card was finalized, false if no active card existed.
+     * Append a delta to the active card transcript.
      */
-    async finalizeExistingCard(channelId, content) {
+    async appendToCard(channelId, content, finalize = false, failed = false) {
+        if (!content && !finalize && !failed) {
+            return true;
+        }
         let card = this.activeCards.get(channelId);
-        if ((!card || card.finished) && this.config.cardTemplateId && content.trim()) {
+        if ((!card || card.finished) && !finalize && !failed && this.config.cardTemplateId && content.trim()) {
             await this.ensureCard(channelId);
             card = this.activeCards.get(channelId);
         }
         if (!card || card.finished) {
+            if (finalize && content.trim()) {
+                return this.sendPlain(channelId, content);
+            }
             return false;
         }
-        const finalized = await this.streamCard(card, content, true);
-        this.activeCards.delete(channelId);
-        return finalized;
+        const streamed = await this.streamCard(card, content, {
+            append: true,
+            finalize,
+            failed,
+        });
+        if (!streamed || finalize || failed) {
+            this.activeCards.delete(channelId);
+        }
+        return streamed;
+    }
+    /**
+     * Stream content to the active AI Card for a channel using full replacement semantics.
+     */
+    async streamToCard(channelId, content, finalize = false) {
+        return this.replaceCard(channelId, content, finalize, false);
+    }
+    /**
+     * Finalize the active card for a channel without falling back to a plain message.
+     * Returns true if a card was finalized, false if no active card existed.
+     */
+    async finalizeExistingCard(channelId, content) {
+        const finalized = await this.replaceCard(channelId, content, true, false);
+        if (!finalized) {
+            return false;
+        }
+        return true;
     }
     /**
      * Finalize and remove the active card for a channel.
      */
     async finalizeCard(channelId, content) {
-        const finalized = await this.finalizeExistingCard(channelId, content);
+        const finalized = await this.replaceCard(channelId, content, true, false);
         if (!finalized) {
             return this.sendPlain(channelId, content);
         }
@@ -529,7 +561,7 @@ export class DingTalkBot {
         this.activeCards.set(channelId, card);
         return card;
     }
-    async streamCard(card, content, finalize = false) {
+    async streamCard(card, content, options) {
         // Refresh token if needed
         const ageSecs = Date.now() / 1000 - card.createdAt;
         if (ageSecs > TOKEN_REFRESH_SECS) {
@@ -543,9 +575,12 @@ export class DingTalkBot {
             guid: `${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
             key: card.templateKey,
             content,
-            isFull: true,
-            isFinalize: finalize,
-            isError: false,
+            append: options.append,
+            finished: options.finalize,
+            failed: options.failed,
+            isFull: !options.append,
+            isFinalize: options.finalize,
+            isError: options.failed,
         };
         const start = Date.now();
         try {
@@ -560,8 +595,8 @@ export class DingTalkBot {
                 log.logWarning(`DingTalk Card: streaming request took ${duration}ms (slow)`);
             }
             card.lastUpdated = Date.now() / 1000;
-            card.content = content;
-            if (finalize) {
+            card.content = options.append ? `${card.content}${content}` : content;
+            if (options.finalize || options.failed) {
                 card.finished = true;
             }
             return true;

package/dist/runtime/events.d.ts

@@ -1,14 +1,23 @@
+import type { Executor } from "../sandbox.js";
+import type { SecurityConfig } from "../security/types.js";
 import type { DingTalkBot } from "./dingtalk.js";
+export interface EventAction {
+    type: "bash";
+    command: string;
+    timeout?: number;
+}
 export interface ImmediateEvent {
     type: "immediate";
     channelId: string;
     text: string;
+    preAction?: EventAction;
 }
 export interface OneShotEvent {
     type: "one-shot";
     channelId: string;
     text: string;
     at: string;
+    preAction?: EventAction;
 }
 export interface PeriodicEvent {
     type: "periodic";
@@ -16,18 +25,21 @@ export interface PeriodicEvent {
     text: string;
     schedule: string;
     timezone: string;
+    preAction?: EventAction;
 }
 export type ScheduledEvent = ImmediateEvent | OneShotEvent | PeriodicEvent;
 export declare class EventsWatcher {
     private eventsDir;
     private bot;
+    private executor;
+    private commandGuardConfig?;
     private timers;
     private crons;
     private debounceTimers;
     private startTime;
     private watcher;
     private knownFiles;
-    constructor(eventsDir: string, bot: DingTalkBot);
+    constructor(eventsDir: string, bot: DingTalkBot, executor: Executor, commandGuardConfig?: SecurityConfig["commandGuard"] | undefined);
     start(): void;
     stop(): void;
     private debounce;
@@ -36,11 +48,13 @@ export declare class EventsWatcher {
     private handleDelete;
     private cancelScheduled;
     private handleFile;
+    private parsePreAction;
     private parseEvent;
     private handleImmediate;
     private handleOneShot;
     private handlePeriodic;
     private execute;
+    private runPreAction;
     private deleteFile;
     private getInvalidMarkerPath;
     private markInvalid;
@@ -50,4 +64,4 @@ export declare class EventsWatcher {
 /**
  * Create and start an events watcher.
  */
-export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot): EventsWatcher;
+export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot, executor: Executor, commandGuardConfig?: SecurityConfig["commandGuard"]): EventsWatcher;