@oyasmi/pipiclaw 0.5.1 → 0.5.3

package/dist/paths.js

@@ -9,4 +9,3 @@ export const CHANNEL_CONFIG_PATH = join(APP_HOME_DIR, "channel.json");
 export const AUTH_CONFIG_PATH = join(APP_HOME_DIR, "auth.json");
 export const MODELS_CONFIG_PATH = join(APP_HOME_DIR, "models.json");
 export const SETTINGS_CONFIG_PATH = join(APP_HOME_DIR, "settings.json");
-//# sourceMappingURL=paths.js.map

package/dist/prompt-builder.d.ts

@@ -3,4 +3,3 @@ export interface AppendSystemPromptOptions {
     subAgentList?: string;
 }
 export declare function buildAppendSystemPrompt(workspacePath: string, channelId: string, sandboxConfig: SandboxConfig, options?: AppendSystemPromptOptions): string;
-//# sourceMappingURL=prompt-builder.d.ts.map

package/dist/prompt-builder.js

@@ -143,4 +143,3 @@ Important rules:
 - Use temporary inline sub-agents only when that extra flexibility is genuinely useful`);
     return sections.join("\n\n");
 }
-//# sourceMappingURL=prompt-builder.js.map

package/dist/runtime/bootstrap.d.ts

@@ -0,0 +1,47 @@
+import { type SandboxConfig } from "../sandbox.js";
+import { DingTalkBot, type DingTalkConfig } from "./dingtalk.js";
+import { ChannelStore } from "./store.js";
+export interface BootstrapPaths {
+    appName: string;
+    appHomeDir: string;
+    workspaceDir: string;
+    authConfigPath: string;
+    channelConfigPath: string;
+    modelsConfigPath: string;
+    settingsConfigPath: string;
+}
+export interface BootstrapIO {
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export interface BootstrapOptions {
+    env?: NodeJS.ProcessEnv;
+    io?: BootstrapIO;
+    paths?: BootstrapPaths;
+    registerSignalHandlers?: boolean;
+    startServices?: boolean;
+}
+export interface ParsedArgs {
+    sandbox: SandboxConfig;
+}
+export interface BootstrapResult {
+    created: string[];
+    channelTemplateCreated: boolean;
+}
+export interface AppContext {
+    bot: DingTalkBot;
+    store: ChannelStore;
+    shutdown: () => Promise<void>;
+}
+export declare const DEFAULT_BOOTSTRAP_PATHS: BootstrapPaths;
+export declare class BootstrapExitError extends Error {
+    readonly code: number;
+    constructor(code: number, message?: string);
+}
+export declare function isBootstrapExitError(error: unknown): error is BootstrapExitError;
+export declare function sanitizeProxyEnv(env: NodeJS.ProcessEnv): void;
+export declare function bootstrapAppHome(paths?: BootstrapPaths): BootstrapResult;
+export declare function printBootstrapSummary(result: BootstrapResult, io?: BootstrapIO, paths?: BootstrapPaths): void;
+export declare function loadConfig(paths?: BootstrapPaths, io?: BootstrapIO): DingTalkConfig;
+export declare function parseArgs(argv: string[], paths?: BootstrapPaths, io?: BootstrapIO): ParsedArgs;
+export declare function bootstrap(argv: string[], options?: BootstrapOptions): Promise<AppContext>;

package/dist/runtime/bootstrap.js

@@ -0,0 +1,450 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { getOrCreateRunner } from "../agent.js";
+import { parseBuiltInCommand } from "../commands.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, SETTINGS_CONFIG_PATH, WORKSPACE_DIR, } from "../paths.js";
+import { parseSandboxArg, validateSandbox } from "../sandbox.js";
+import { createDingTalkContext } from "./delivery.js";
+import { DingTalkBot, } from "./dingtalk.js";
+import { createEventsWatcher } from "./events.js";
+import { ChannelStore } from "./store.js";
+const DEFAULT_SOUL = `# SOUL.md
+
+Configure Pipiclaw's identity, voice, and communication style here.
+
+Suggested sections:
+
+- Who the assistant is
+- Default language
+- Tone and personality
+- Reply style
+- Formatting preferences
+
+Example topics you may want to define:
+
+- "Answer in Chinese by default."
+- "Be concise and direct."
+- "Prefer Markdown."
+- "Act as an engineering assistant for our team."
+
+Replace this template with your actual identity prompt.
+`;
+const DEFAULT_AGENT = `# AGENTS.md
+
+Configure Pipiclaw's operating rules here.
+
+This file should define behavior and workflow. Identity, tone, and personality belong in \`SOUL.md\`.
+
+Suggested sections:
+
+- Tool usage policy
+- Security constraints
+- Scheduling/reminder policy
+- Project-specific workflows
+- Things the assistant must always or never do
+
+Replace this template with your actual operating instructions.
+`;
+const DEFAULT_MEMORY = `# Workspace Memory
+
+This file stores stable workspace-level memory.
+
+- It is intended to be managed by a human administrator.
+- It is not automatically rewritten by normal runtime consolidation.
+- Store durable shared background here when it should apply across channels.
+- Keep this file focused on stable facts, policies, and shared context, not transient conversation history.
+
+## Shared Context
+
+<!-- Put team-wide or workspace-wide background here. -->
+
+## Tooling And Environment
+
+<!-- Put durable tool usage rules, environment assumptions, or shared operational conventions here. -->
+
+## Project Notes
+
+<!-- Put long-lived project facts here. -->
+`;
+const CHANNEL_CONFIG_TEMPLATE = {
+    clientId: "your-dingtalk-client-id",
+    clientSecret: "your-dingtalk-client-secret",
+    robotCode: "your-robot-code",
+    cardTemplateId: "your-card-template-id",
+    cardTemplateKey: "content",
+    allowFrom: ["your-staff-id"],
+};
+const MODELS_CONFIG_TEMPLATE = { providers: {} };
+const SHUTDOWN_WAIT_MS = 15000;
+const SHUTDOWN_ABORT_WAIT_MS = 5000;
+export const DEFAULT_BOOTSTRAP_PATHS = {
+    appName: APP_NAME,
+    appHomeDir: APP_HOME_DIR,
+    workspaceDir: WORKSPACE_DIR,
+    authConfigPath: AUTH_CONFIG_PATH,
+    channelConfigPath: CHANNEL_CONFIG_PATH,
+    modelsConfigPath: MODELS_CONFIG_PATH,
+    settingsConfigPath: SETTINGS_CONFIG_PATH,
+};
+export class BootstrapExitError extends Error {
+    constructor(code, message) {
+        super(message ?? `Bootstrap requested exit with code ${code}`);
+        this.code = code;
+        this.name = "BootstrapExitError";
+    }
+}
+export function isBootstrapExitError(error) {
+    return error instanceof BootstrapExitError;
+}
+export function sanitizeProxyEnv(env) {
+    if (env.DINGTALK_FORCE_PROXY !== "true") {
+        delete env.http_proxy;
+        delete env.https_proxy;
+        delete env.all_proxy;
+        delete env.HTTP_PROXY;
+        delete env.HTTPS_PROXY;
+        delete env.ALL_PROXY;
+    }
+}
+function writeTextFileIfMissing(path, content, label, created) {
+    if (existsSync(path)) {
+        return false;
+    }
+    writeFileSync(path, content, "utf-8");
+    created.push(label);
+    return true;
+}
+function writeJsonFileIfMissing(path, value, label, created) {
+    return writeTextFileIfMissing(path, `${JSON.stringify(value, null, 2)}\n`, label, created);
+}
+export function bootstrapAppHome(paths = DEFAULT_BOOTSTRAP_PATHS) {
+    const created = [];
+    if (!existsSync(paths.appHomeDir)) {
+        mkdirSync(paths.appHomeDir, { recursive: true });
+        created.push("app home");
+    }
+    if (!existsSync(paths.workspaceDir)) {
+        mkdirSync(paths.workspaceDir, { recursive: true });
+        created.push("workspace/");
+    }
+    for (const dir of ["skills", "events", "sub-agents"]) {
+        const dirPath = join(paths.workspaceDir, dir);
+        if (!existsSync(dirPath)) {
+            mkdirSync(dirPath, { recursive: true });
+            created.push(`workspace/${dir}/`);
+        }
+    }
+    writeTextFileIfMissing(join(paths.workspaceDir, "SOUL.md"), DEFAULT_SOUL, "workspace/SOUL.md", created);
+    writeTextFileIfMissing(join(paths.workspaceDir, "AGENTS.md"), DEFAULT_AGENT, "workspace/AGENTS.md", created);
+    writeTextFileIfMissing(join(paths.workspaceDir, "MEMORY.md"), DEFAULT_MEMORY, "workspace/MEMORY.md", created);
+    const channelTemplateCreated = writeJsonFileIfMissing(paths.channelConfigPath, CHANNEL_CONFIG_TEMPLATE, "channel.json", created);
+    writeJsonFileIfMissing(paths.authConfigPath, {}, "auth.json", created);
+    writeJsonFileIfMissing(paths.modelsConfigPath, MODELS_CONFIG_TEMPLATE, "models.json", created);
+    writeJsonFileIfMissing(paths.settingsConfigPath, {}, "settings.json", created);
+    return { created, channelTemplateCreated };
+}
+function isPlaceholderString(value) {
+    return value.trim().startsWith("your-");
+}
+function listChannelConfigIssues(config) {
+    const issues = [];
+    if (!config.clientId) {
+        issues.push("Missing required field `clientId`.");
+    }
+    else if (isPlaceholderString(config.clientId)) {
+        issues.push("Replace placeholder value for `clientId`.");
+    }
+    if (!config.clientSecret) {
+        issues.push("Missing required field `clientSecret`.");
+    }
+    else if (isPlaceholderString(config.clientSecret)) {
+        issues.push("Replace placeholder value for `clientSecret`.");
+    }
+    if (config.robotCode && isPlaceholderString(config.robotCode)) {
+        issues.push("Replace placeholder value for `robotCode`, or set it to an empty string to reuse `clientId`.");
+    }
+    if (config.cardTemplateId && isPlaceholderString(config.cardTemplateId)) {
+        issues.push("Replace placeholder value for `cardTemplateId`, or set it to an empty string to disable AI Card streaming.");
+    }
+    if (Array.isArray(config.allowFrom) && config.allowFrom.some((value) => isPlaceholderString(value))) {
+        issues.push("Replace placeholder values in `allowFrom`, or set it to an empty array to allow all users.");
+    }
+    return issues;
+}
+export function printBootstrapSummary(result, io = console, paths = DEFAULT_BOOTSTRAP_PATHS) {
+    if (result.created.length === 0) {
+        return;
+    }
+    io.log(`Initialized ${paths.appName} under ${paths.appHomeDir}:`);
+    for (const item of result.created) {
+        io.log(`  - ${item}`);
+    }
+    io.log("");
+}
+export function loadConfig(paths = DEFAULT_BOOTSTRAP_PATHS, io = console) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(paths.channelConfigPath, "utf-8"));
+    }
+    catch (err) {
+        io.error(`Failed to parse configuration: ${paths.channelConfigPath}`);
+        io.error(err instanceof Error ? err.message : String(err));
+        throw new BootstrapExitError(1);
+    }
+    const issues = listChannelConfigIssues(parsed);
+    if (issues.length > 0) {
+        io.error(`Configuration is not ready: ${paths.channelConfigPath}`);
+        for (const issue of issues) {
+            io.error(`  - ${issue}`);
+        }
+        io.error("");
+        io.error(`Fill in ${paths.channelConfigPath} and run \`${paths.appName}\` again.`);
+        throw new BootstrapExitError(1);
+    }
+    parsed.cardTemplateKey = parsed.cardTemplateKey || "content";
+    parsed.robotCode = parsed.robotCode?.trim() ? parsed.robotCode : parsed.clientId;
+    if (Array.isArray(parsed.allowFrom)) {
+        parsed.allowFrom = parsed.allowFrom.filter((value) => value.trim().length > 0);
+    }
+    return parsed;
+}
+export function parseArgs(argv, paths = DEFAULT_BOOTSTRAP_PATHS, io = console) {
+    const args = argv.slice(2);
+    let sandbox = { type: "host" };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg.startsWith("--sandbox=")) {
+            sandbox = parseSandboxArg(arg.slice("--sandbox=".length));
+        }
+        else if (arg === "--sandbox") {
+            sandbox = parseSandboxArg(args[index + 1] || "");
+            index += 1;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            io.log(`Usage: ${paths.appName} [options]`);
+            io.log("");
+            io.log("Options:");
+            io.log("  --sandbox=host              Run tools on host (default)");
+            io.log("  --sandbox=docker:<name>     Run tools in Docker container");
+            io.log("");
+            io.log(`Config:    ${paths.channelConfigPath}`);
+            io.log(`Workspace: ${paths.workspaceDir}`);
+            throw new BootstrapExitError(0);
+        }
+    }
+    return { sandbox };
+}
+function waitForTasks(tasks, timeoutMs) {
+    if (tasks.length === 0) {
+        return Promise.resolve(true);
+    }
+    return Promise.race([
+        Promise.allSettled(tasks).then(() => true),
+        new Promise((resolve) => {
+            setTimeout(() => resolve(false), timeoutMs);
+        }),
+    ]);
+}
+export async function bootstrap(argv, options = {}) {
+    const env = options.env ?? process.env;
+    const io = options.io ?? console;
+    const paths = options.paths ?? DEFAULT_BOOTSTRAP_PATHS;
+    const registerSignalHandlers = options.registerSignalHandlers ?? true;
+    const startServices = options.startServices ?? true;
+    sanitizeProxyEnv(env);
+    const parsedArgs = parseArgs(argv, paths, io);
+    const sandbox = parsedArgs.sandbox;
+    const bootstrapResult = bootstrapAppHome(paths);
+    printBootstrapSummary(bootstrapResult, io, paths);
+    if (bootstrapResult.channelTemplateCreated) {
+        io.error(`Fill in ${paths.channelConfigPath} and run \`${paths.appName}\` again.`);
+        throw new BootstrapExitError(1);
+    }
+    const dingtalkConfig = loadConfig(paths, io);
+    dingtalkConfig.stateDir = paths.workspaceDir;
+    await validateSandbox(sandbox);
+    const store = new ChannelStore({ workingDir: paths.workspaceDir });
+    const channelStates = new Map();
+    const activeTasks = new Set();
+    let shuttingDown = false;
+    let shutdownPromise = null;
+    const getState = (channelId) => {
+        let state = channelStates.get(channelId);
+        if (!state) {
+            const channelDir = join(paths.workspaceDir, channelId);
+            ensureChannelMemoryFilesSync(channelDir);
+            state = {
+                running: false,
+                runner: getOrCreateRunner(sandbox, channelId, channelDir),
+                stopRequested: false,
+            };
+            channelStates.set(channelId, state);
+        }
+        return state;
+    };
+    const handler = {
+        isRunning(channelId) {
+            const state = channelStates.get(channelId);
+            return state?.running ?? false;
+        },
+        async handleStop(channelId, _bot) {
+            const state = channelStates.get(channelId);
+            if (state?.running) {
+                state.stopRequested = true;
+                void state.runner.abort().catch((err) => {
+                    log.logWarning(`[${channelId}] Failed to abort run`, err instanceof Error ? err.message : String(err));
+                });
+                log.logInfo(`[${channelId}] Stop requested`);
+            }
+        },
+        async handleBusyMessage(event, bot, mode, queueText) {
+            if (shuttingDown) {
+                return;
+            }
+            const state = getState(event.channelId);
+            const trimmedQueueText = queueText.trim();
+            await store.logMessage(event.channelId, {
+                date: new Date().toISOString(),
+                ts: event.ts,
+                user: event.user,
+                userName: event.userName,
+                text: event.text,
+                isBot: false,
+                deliveryMode: mode,
+                skipContextSync: true,
+            });
+            try {
+                if (mode === "followUp") {
+                    await state.runner.queueFollowUp(trimmedQueueText, event.userName);
+                }
+                else {
+                    await state.runner.queueSteer(trimmedQueueText, event.userName);
+                }
+                const confirmation = mode === "followUp"
+                    ? "Queued as follow-up. I’ll handle it after the current task completes."
+                    : event.text.trim().startsWith("/")
+                        ? "Queued as steer. I’ll apply it after the current tool step finishes."
+                        : "Queued as steer. I’ll apply this after the current tool step finishes. Use `/followup <message>` to queue it after completion.";
+                await bot.sendPlain(event.channelId, confirmation);
+                log.logInfo(`[${event.channelId}] Queued ${mode}: ${trimmedQueueText.substring(0, 80)}`);
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                log.logWarning(`[${event.channelId}] Failed to queue ${mode}`, errMsg);
+                await bot.sendPlain(event.channelId, `Could not queue this message: ${errMsg}`);
+            }
+        },
+        async handleEvent(event, bot, _isEvent) {
+            if (shuttingDown) {
+                log.logInfo(`[${event.channelId}] Ignoring event during shutdown`);
+                return;
+            }
+            const state = getState(event.channelId);
+            const task = (async () => {
+                state.running = true;
+                state.stopRequested = false;
+                await store.logMessage(event.channelId, {
+                    date: new Date().toISOString(),
+                    ts: event.ts,
+                    user: event.user,
+                    userName: event.userName,
+                    text: event.text,
+                    isBot: false,
+                });
+                try {
+                    const ctx = createDingTalkContext(event, bot, store);
+                    const builtInCommand = parseBuiltInCommand(event.text);
+                    if (builtInCommand) {
+                        log.logInfo(`[${event.channelId}] Executing command: ${builtInCommand.rawText}`);
+                        await state.runner.handleBuiltinCommand(ctx, builtInCommand);
+                        return;
+                    }
+                    log.logInfo(`[${event.channelId}] Starting run: ${event.text.substring(0, 50)}`);
+                    const result = await state.runner.run(ctx, store);
+                    if (result.stopReason === "aborted" && state.stopRequested) {
+                        log.logInfo(`[${event.channelId}] Stopped`);
+                    }
+                }
+                catch (err) {
+                    log.logWarning(`[${event.channelId}] Run error`, err instanceof Error ? err.message : String(err));
+                }
+                finally {
+                    state.running = false;
+                }
+            })();
+            activeTasks.add(task);
+            try {
+                await task;
+            }
+            finally {
+                activeTasks.delete(task);
+            }
+        },
+    };
+    log.logStartup(paths.workspaceDir, sandbox.type === "host" ? "host" : `docker:${sandbox.container}`);
+    const bot = new DingTalkBot(handler, dingtalkConfig);
+    const eventsWatcher = createEventsWatcher(paths.workspaceDir, bot);
+    const shutdownWithReason = async (reason) => {
+        if (shutdownPromise) {
+            return shutdownPromise;
+        }
+        shutdownPromise = (async () => {
+            shuttingDown = true;
+            log.logInfo(`Shutting down (${reason})...`);
+            eventsWatcher.stop();
+            await bot.stop();
+            const runningTasks = Array.from(activeTasks);
+            if (runningTasks.length > 0) {
+                log.logInfo(`Waiting for ${runningTasks.length} active task(s) to finish`);
+                const completed = await waitForTasks(runningTasks, SHUTDOWN_WAIT_MS);
+                if (!completed) {
+                    log.logWarning(`Shutdown grace period exceeded ${SHUTDOWN_WAIT_MS}ms, aborting active runs`);
+                    const aborts = [];
+                    for (const [channelId, state] of channelStates) {
+                        if (!state.running)
+                            continue;
+                        state.stopRequested = true;
+                        log.logInfo(`[${channelId}] Aborting active run for shutdown`);
+                        aborts.push(state.runner.abort().catch((err) => {
+                            log.logWarning(`[${channelId}] Failed to abort run during shutdown`, err instanceof Error ? err.message : String(err));
+                        }));
+                    }
+                    await Promise.allSettled(aborts);
+                    const remainingTasks = Array.from(activeTasks);
+                    if (remainingTasks.length > 0) {
+                        const abortedCompleted = await waitForTasks(remainingTasks, SHUTDOWN_ABORT_WAIT_MS);
+                        if (!abortedCompleted) {
+                            log.logWarning(`Shutdown forced exit with ${remainingTasks.length} task(s) still active`);
+                        }
+                    }
+                }
+            }
+        })();
+        return shutdownPromise;
+    };
+    if (registerSignalHandlers) {
+        process.once("SIGINT", () => {
+            void shutdownWithReason("SIGINT").finally(() => {
+                process.exit(0);
+            });
+        });
+        process.once("SIGTERM", () => {
+            void shutdownWithReason("SIGTERM").finally(() => {
+                process.exit(0);
+            });
+        });
+    }
+    if (startServices) {
+        eventsWatcher.start();
+        void bot.start();
+    }
+    return {
+        bot,
+        store,
+        shutdown: async () => {
+            await shutdownWithReason("manual");
+        },
+    };
+}

package/dist/{delivery.d.ts → runtime/delivery.d.ts}

@@ -1,4 +1,3 @@
 import type { DingTalkBot, DingTalkContext, DingTalkEvent } from "./dingtalk.js";
 import type { ChannelStore } from "./store.js";
 export declare function createDingTalkContext(event: DingTalkEvent, bot: DingTalkBot, store: ChannelStore): DingTalkContext;
-//# sourceMappingURL=delivery.d.ts.map

package/dist/{delivery.js → runtime/delivery.js}

@@ -1,4 +1,4 @@
-import * as log from "./log.js";
+import * as log from "../log.js";
 const MIN_UPDATE_INTERVAL_MS = 800;
 class ChannelDeliveryController {
     constructor(event, bot, store) {
@@ -215,4 +215,3 @@ class ChannelDeliveryController {
 export function createDingTalkContext(event, bot, store) {
     return new ChannelDeliveryController(event, bot, store).buildContext();
 }
-//# sourceMappingURL=delivery.js.map

package/dist/{dingtalk.d.ts → runtime/dingtalk.d.ts}

@@ -57,6 +57,7 @@ export declare class DingTalkBot {
     private lastSocketAvailableTime;
     private activeMessageProcessing;
     private keepAliveTimer;
+    private reconnectTimer;
     private isReconnecting;
     private isStopped;
     private reconnectAttempts;
@@ -68,6 +69,15 @@ export declare class DingTalkBot {
      * Maintains a FIFO buffer of at most 200 entries.
      */
     private markProcessed;
+    private getSocket;
+    private isSocketLike;
+    private setTrackedTimeout;
+    private setTrackedInterval;
+    private clearKeepAliveTimer;
+    private clearReconnectTimer;
+    private clearAllTimers;
+    private waitForDelay;
+    private scheduleReconnect;
     start(): Promise<void>;
     private handleRawMessage;
     private doReconnect;
@@ -110,4 +120,3 @@ export declare class DingTalkBot {
     private setConversationMeta;
     private getConversationMetaPath;
 }
-//# sourceMappingURL=dingtalk.d.ts.map