@oyasmi/pipiclaw 0.6.2 → 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/runtime/bootstrap.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 };
 }

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oyasmi/pipiclaw",
-	"version": "0.6.2",
+	"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"
 	},