@takibeiy/moltbot_cn 2026.1.28 → 2026.2.1-beta.1

package/dist/hooks/gmail-setup-utils.js

@@ -8,10 +8,12 @@ let cachedPythonPath;
 const MAX_OUTPUT_CHARS = 800;
 function trimOutput(value) {
     const trimmed = value.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return "";
-    if (trimmed.length <= MAX_OUTPUT_CHARS)
+    }
+    if (trimmed.length <= MAX_OUTPUT_CHARS) {
         return trimmed;
+    }
     return `${trimmed.slice(0, MAX_OUTPUT_CHARS)}…`;
 }
 function formatCommandFailure(command, result) {
@@ -21,10 +23,12 @@ function formatCommandFailure(command, result) {
     const stderr = trimOutput(result.stderr);
     const stdout = trimOutput(result.stdout);
     const lines = [`${command} failed (code=${code}${signal}${killed})`];
-    if (stderr)
+    if (stderr) {
         lines.push(`stderr: ${stderr}`);
-    if (stdout)
+    }
+    if (stdout) {
         lines.push(`stdout: ${stdout}`);
+    }
     return lines.join("\n");
 }
 function formatCommandResult(command, result) {
@@ -34,10 +38,12 @@ function formatCommandResult(command, result) {
     const stderr = trimOutput(result.stderr);
     const stdout = trimOutput(result.stdout);
     const lines = [`${command} exited (code=${code}${signal}${killed})`];
-    if (stderr)
+    if (stderr) {
         lines.push(`stderr: ${stderr}`);
-    if (stdout)
+    }
+    if (stdout) {
         lines.push(`stdout: ${stdout}`);
+    }
     return lines.join("\n");
 }
 function formatJsonParseFailure(command, result, err) {
@@ -55,8 +61,9 @@ function findExecutablesOnPath(bins) {
     for (const part of parts) {
         for (const bin of bins) {
             const candidate = path.join(part, bin);
-            if (seen.has(candidate))
+            if (seen.has(candidate)) {
                 continue;
+            }
             try {
                 fs.accessSync(candidate, fs.constants.X_OK);
                 matches.push(candidate);
@@ -72,14 +79,16 @@ function findExecutablesOnPath(bins) {
 function ensurePathIncludes(dirPath, position) {
     const pathEnv = process.env.PATH ?? "";
     const parts = pathEnv.split(path.delimiter).filter(Boolean);
-    if (parts.includes(dirPath))
+    if (parts.includes(dirPath)) {
         return;
+    }
     const next = position === "prepend" ? [dirPath, ...parts] : [...parts, dirPath];
     process.env.PATH = next.join(path.delimiter);
 }
 function ensureGcloudOnPath() {
-    if (hasBinary("gcloud"))
+    if (hasBinary("gcloud")) {
         return true;
+    }
     const candidates = [
         "/opt/homebrew/share/google-cloud-sdk/bin/gcloud",
         "/usr/local/share/google-cloud-sdk/bin/gcloud",
@@ -105,11 +114,13 @@ export async function resolvePythonExecutablePath() {
     const candidates = findExecutablesOnPath(["python3", "python"]);
     for (const candidate of candidates) {
         const res = await runCommandWithTimeout([candidate, "-c", "import os, sys; print(os.path.realpath(sys.executable))"], { timeoutMs: 2_000 });
-        if (res.code !== 0)
+        if (res.code !== 0) {
             continue;
+        }
         const resolved = res.stdout.trim().split(/\s+/)[0];
-        if (!resolved)
+        if (!resolved) {
             continue;
+        }
         try {
             fs.accessSync(resolved, fs.constants.X_OK);
             cachedPythonPath = resolved;
@@ -123,11 +134,13 @@ export async function resolvePythonExecutablePath() {
     return undefined;
 }
 async function gcloudEnv() {
-    if (process.env.CLOUDSDK_PYTHON)
+    if (process.env.CLOUDSDK_PYTHON) {
         return undefined;
+    }
     const pythonPath = await resolvePythonExecutablePath();
-    if (!pythonPath)
+    if (!pythonPath) {
         return undefined;
+    }
     return { CLOUDSDK_PYTHON: pythonPath };
 }
 async function runGcloudCommand(args, timeoutMs) {
@@ -137,10 +150,12 @@ async function runGcloudCommand(args, timeoutMs) {
     });
 }
 export async function ensureDependency(bin, brewArgs) {
-    if (bin === "gcloud" && ensureGcloudOnPath())
+    if (bin === "gcloud" && ensureGcloudOnPath()) {
         return;
-    if (hasBinary(bin))
+    }
+    if (hasBinary(bin)) {
         return;
+    }
     if (process.platform !== "darwin") {
         throw new Error(`${bin} not installed; install it and retry`);
     }
@@ -161,8 +176,9 @@ export async function ensureDependency(bin, brewArgs) {
 }
 export async function ensureGcloudAuth() {
     const res = await runGcloudCommand(["auth", "list", "--filter", "status:ACTIVE", "--format", "value(account)"], 30_000);
-    if (res.code === 0 && res.stdout.trim())
+    if (res.code === 0 && res.stdout.trim()) {
         return;
+    }
     const login = await runGcloudCommand(["auth", "login"], 600_000);
     if (login.code !== 0) {
         throw new Error(login.stderr || "gcloud auth login failed");
@@ -177,8 +193,9 @@ export async function runGcloud(args) {
 }
 export async function ensureTopic(projectId, topicName) {
     const describe = await runGcloudCommand(["pubsub", "topics", "describe", topicName, "--project", projectId], 30_000);
-    if (describe.code === 0)
+    if (describe.code === 0) {
         return;
+    }
     await runGcloud(["pubsub", "topics", "create", topicName, "--project", projectId]);
 }
 export async function ensureSubscription(projectId, subscription, topicName, pushEndpoint) {
@@ -210,8 +227,9 @@ export async function ensureSubscription(projectId, subscription, topicName, pus
     ]);
 }
 export async function ensureTailscaleEndpoint(params) {
-    if (params.mode === "off")
+    if (params.mode === "off") {
         return "";
+    }
     const statusArgs = ["status", "--json"];
     const statusCommand = formatCommand("tailscale", statusArgs);
     const status = await runCommandWithTimeout(["tailscale", ...statusArgs], {
@@ -225,7 +243,7 @@ export async function ensureTailscaleEndpoint(params) {
         parsed = JSON.parse(status.stdout);
     }
     catch (err) {
-        throw new Error(formatJsonParseFailure(statusCommand, status, err));
+        throw new Error(formatJsonParseFailure(statusCommand, status, err), { cause: err });
     }
     const dnsName = parsed.Self?.DNSName?.replace(/\.$/, "");
     if (!dnsName) {
@@ -255,15 +273,17 @@ export async function ensureTailscaleEndpoint(params) {
 export async function resolveProjectIdFromGogCredentials() {
     const candidates = gogCredentialsPaths();
     for (const candidate of candidates) {
-        if (!fs.existsSync(candidate))
+        if (!fs.existsSync(candidate)) {
             continue;
+        }
         try {
             const raw = fs.readFileSync(candidate, "utf-8");
             const parsed = JSON.parse(raw);
             const clientId = extractGogClientId(parsed);
             const projectNumber = extractProjectNumber(clientId);
-            if (!projectNumber)
+            if (!projectNumber) {
                 continue;
+            }
             const res = await runGcloudCommand([
                 "projects",
                 "list",
@@ -272,11 +292,13 @@ export async function resolveProjectIdFromGogCredentials() {
                 "--format",
                 "value(projectId)",
             ], 30_000);
-            if (res.code !== 0)
+            if (res.code !== 0) {
                 continue;
+            }
             const projectId = res.stdout.trim().split(/\s+/)[0];
-            if (projectId)
+            if (projectId) {
                 return projectId;
+            }
         }
         catch {
             // keep scanning
@@ -303,8 +325,9 @@ function extractGogClientId(parsed) {
     return typeof candidate === "string" ? candidate : null;
 }
 function extractProjectNumber(clientId) {
-    if (!clientId)
+    if (!clientId) {
         return null;
+    }
     const match = clientId.match(/^(\d+)-/);
     return match?.[1] ?? null;
 }

package/dist/hooks/gmail-watcher.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Gmail Watcher Service
+ *
+ * Automatically starts `gog gmail watch serve` when the gateway starts,
+ * if hooks.gmail is configured with an account.
+ */
+import type { OpenClawConfig } from "../config/config.js";
+export declare function isAddressInUseError(line: string): boolean;
+export type GmailWatcherStartResult = {
+    started: boolean;
+    reason?: string;
+};
+/**
+ * Start the Gmail watcher service.
+ * Called automatically by the gateway if hooks.gmail is configured.
+ */
+export declare function startGmailWatcher(cfg: OpenClawConfig): Promise<GmailWatcherStartResult>;
+/**
+ * Stop the Gmail watcher service.
+ */
+export declare function stopGmailWatcher(): Promise<void>;
+/**
+ * Check if the Gmail watcher is running.
+ */
+export declare function isGmailWatcherRunning(): boolean;

package/dist/hooks/gmail-watcher.js

@@ -8,8 +8,8 @@ import { spawn } from "node:child_process";
 import { hasBinary } from "../agents/skills.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { buildGogWatchServeArgs, buildGogWatchStartArgs, resolveGmailHookRuntimeConfig, } from "./gmail.js";
 import { ensureTailscaleEndpoint } from "./gmail-setup-utils.js";
+import { buildGogWatchServeArgs, buildGogWatchStartArgs, resolveGmailHookRuntimeConfig, } from "./gmail.js";
 const log = createSubsystemLogger("gmail-watcher");
 const ADDRESS_IN_USE_RE = /address already in use|EADDRINUSE/i;
 export function isAddressInUseError(line) {
@@ -58,13 +58,15 @@ function spawnGogServe(cfg) {
     });
     child.stdout?.on("data", (data) => {
         const line = data.toString().trim();
-        if (line)
+        if (line) {
             log.info(`[gog] ${line}`);
+        }
     });
     child.stderr?.on("data", (data) => {
         const line = data.toString().trim();
-        if (!line)
+        if (!line) {
             return;
+        }
         if (isAddressInUseError(line)) {
             addressInUse = true;
         }
@@ -74,19 +76,21 @@ function spawnGogServe(cfg) {
         log.error(`gog process error: ${String(err)}`);
     });
     child.on("exit", (code, signal) => {
-        if (shuttingDown)
+        if (shuttingDown) {
             return;
+        }
         if (addressInUse) {
             log.warn("gog serve failed to bind (address already in use); stopping restarts. " +
-                "Another watcher is likely running. Set CLAWDBOT_SKIP_GMAIL_WATCHER=1 or stop the other process.");
+                "Another watcher is likely running. Set OPENCLAW_SKIP_GMAIL_WATCHER=1 or stop the other process.");
             watcherProcess = null;
             return;
         }
         log.warn(`gog exited (code=${code}, signal=${signal}); restarting in 5s`);
         watcherProcess = null;
         setTimeout(() => {
-            if (shuttingDown || !currentConfig)
+            if (shuttingDown || !currentConfig) {
                 return;
+            }
             watcherProcess = spawnGogServe(currentConfig);
         }, 5000);
     });
@@ -146,8 +150,9 @@ export async function startGmailWatcher(cfg) {
     // Set up renewal interval
     const renewMs = runtimeConfig.renewEveryMinutes * 60_000;
     renewInterval = setInterval(() => {
-        if (shuttingDown)
+        if (shuttingDown) {
             return;
+        }
         void startGmailWatch(runtimeConfig);
     }, renewMs);
     log.info(`gmail watcher started for ${runtimeConfig.account} (renew every ${runtimeConfig.renewEveryMinutes}m)`);

package/dist/hooks/gmail.d.ts

@@ -0,0 +1,69 @@
+import { type OpenClawConfig, type HooksGmailTailscaleMode } from "../config/config.js";
+export declare const DEFAULT_GMAIL_LABEL = "INBOX";
+export declare const DEFAULT_GMAIL_TOPIC = "gog-gmail-watch";
+export declare const DEFAULT_GMAIL_SUBSCRIPTION = "gog-gmail-watch-push";
+export declare const DEFAULT_GMAIL_SERVE_BIND = "127.0.0.1";
+export declare const DEFAULT_GMAIL_SERVE_PORT = 8788;
+export declare const DEFAULT_GMAIL_SERVE_PATH = "/gmail-pubsub";
+export declare const DEFAULT_GMAIL_MAX_BYTES = 20000;
+export declare const DEFAULT_GMAIL_RENEW_MINUTES: number;
+export declare const DEFAULT_HOOKS_PATH = "/hooks";
+export type GmailHookOverrides = {
+    account?: string;
+    label?: string;
+    topic?: string;
+    subscription?: string;
+    pushToken?: string;
+    hookToken?: string;
+    hookUrl?: string;
+    includeBody?: boolean;
+    maxBytes?: number;
+    renewEveryMinutes?: number;
+    serveBind?: string;
+    servePort?: number;
+    servePath?: string;
+    tailscaleMode?: HooksGmailTailscaleMode;
+    tailscalePath?: string;
+    tailscaleTarget?: string;
+};
+export type GmailHookRuntimeConfig = {
+    account: string;
+    label: string;
+    topic: string;
+    subscription: string;
+    pushToken: string;
+    hookToken: string;
+    hookUrl: string;
+    includeBody: boolean;
+    maxBytes: number;
+    renewEveryMinutes: number;
+    serve: {
+        bind: string;
+        port: number;
+        path: string;
+    };
+    tailscale: {
+        mode: HooksGmailTailscaleMode;
+        path: string;
+        target?: string;
+    };
+};
+export declare function generateHookToken(bytes?: number): string;
+export declare function mergeHookPresets(existing: string[] | undefined, preset: string): string[];
+export declare function normalizeHooksPath(raw?: string): string;
+export declare function normalizeServePath(raw?: string): string;
+export declare function buildDefaultHookUrl(hooksPath?: string, port?: number): string;
+export declare function resolveGmailHookRuntimeConfig(cfg: OpenClawConfig, overrides: GmailHookOverrides): {
+    ok: true;
+    value: GmailHookRuntimeConfig;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function buildGogWatchStartArgs(cfg: Pick<GmailHookRuntimeConfig, "account" | "label" | "topic">): string[];
+export declare function buildGogWatchServeArgs(cfg: GmailHookRuntimeConfig): string[];
+export declare function buildTopicPath(projectId: string, topicName: string): string;
+export declare function parseTopicPath(topic: string): {
+    projectId: string;
+    topicName: string;
+} | null;

package/dist/hooks/gmail.js

@@ -19,8 +19,9 @@ export function mergeHookPresets(existing, preset) {
 }
 export function normalizeHooksPath(raw) {
     const base = raw?.trim() || DEFAULT_HOOKS_PATH;
-    if (base === "/")
+    if (base === "/") {
         return DEFAULT_HOOKS_PATH;
+    }
     const withSlash = base.startsWith("/") ? base : `/${base}`;
     return withSlash.replace(/\/+$/, "");
 }
@@ -28,8 +29,9 @@ export function normalizeServePath(raw) {
     const base = raw?.trim() || DEFAULT_GMAIL_SERVE_PATH;
     // Tailscale funnel/serve strips the set-path prefix before proxying.
     // To accept requests at /<path> externally, gog must listen on "/".
-    if (base === "/")
+    if (base === "/") {
         return "/";
+    }
     const withSlash = base.startsWith("/") ? base : `/${base}`;
     return withSlash.replace(/\/+$/, "");
 }
@@ -166,8 +168,9 @@ export function buildTopicPath(projectId, topicName) {
 }
 export function parseTopicPath(topic) {
     const match = topic.trim().match(/^projects\/([^/]+)\/topics\/([^/]+)$/i);
-    if (!match)
+    if (!match) {
         return null;
+    }
     return { projectId: match[1] ?? "", topicName: match[2] ?? "" };
 }
 function joinUrl(base, path) {

package/dist/hooks/hooks-status.d.ts

@@ -0,0 +1,57 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { HookEligibilityContext, HookEntry, HookInstallSpec } from "./types.js";
+export type HookStatusConfigCheck = {
+    path: string;
+    value: unknown;
+    satisfied: boolean;
+};
+export type HookInstallOption = {
+    id: string;
+    kind: HookInstallSpec["kind"];
+    label: string;
+    bins: string[];
+};
+export type HookStatusEntry = {
+    name: string;
+    description: string;
+    source: string;
+    pluginId?: string;
+    filePath: string;
+    baseDir: string;
+    handlerPath: string;
+    hookKey: string;
+    emoji?: string;
+    homepage?: string;
+    events: string[];
+    always: boolean;
+    disabled: boolean;
+    eligible: boolean;
+    managedByPlugin: boolean;
+    requirements: {
+        bins: string[];
+        anyBins: string[];
+        env: string[];
+        config: string[];
+        os: string[];
+    };
+    missing: {
+        bins: string[];
+        anyBins: string[];
+        env: string[];
+        config: string[];
+        os: string[];
+    };
+    configChecks: HookStatusConfigCheck[];
+    install: HookInstallOption[];
+};
+export type HookStatusReport = {
+    workspaceDir: string;
+    managedHooksDir: string;
+    hooks: HookStatusEntry[];
+};
+export declare function buildWorkspaceHookStatus(workspaceDir: string, opts?: {
+    config?: OpenClawConfig;
+    managedHooksDir?: string;
+    entries?: HookEntry[];
+    eligibility?: HookEligibilityContext;
+}): HookStatusReport;

package/dist/hooks/hooks-status.js

@@ -7,8 +7,9 @@ function resolveHookKey(entry) {
 }
 function normalizeInstallOptions(entry) {
     const install = entry.metadata?.install ?? [];
-    if (install.length === 0)
+    if (install.length === 0) {
         return [];
+    }
     // For hooks, we just list all install options
     return install.map((spec, index) => {
         const id = (spec.id ?? `${spec.kind}-${index}`).trim();
@@ -16,7 +17,7 @@ function normalizeInstallOptions(entry) {
         let label = (spec.label ?? "").trim();
         if (!label) {
             if (spec.kind === "bundled") {
-                label = "Bundled with Moltbot";
+                label = "Bundled with OpenClaw";
             }
             else if (spec.kind === "npm" && spec.package) {
                 label = `Install ${spec.package} (npm)`;
@@ -34,7 +35,7 @@ function normalizeInstallOptions(entry) {
 function buildHookStatus(entry, config, eligibility) {
     const hookKey = resolveHookKey(entry);
     const hookConfig = resolveHookConfig(config, hookKey);
-    const managedByPlugin = entry.hook.source === "moltbot-plugin";
+    const managedByPlugin = entry.hook.source === "openclaw-plugin";
     const disabled = managedByPlugin ? false : hookConfig?.enabled === false;
     const always = entry.metadata?.always === true;
     const emoji = entry.metadata?.emoji ?? entry.frontmatter.emoji;
@@ -50,10 +51,12 @@ function buildHookStatus(entry, config, eligibility) {
     const requiredConfig = entry.metadata?.requires?.config ?? [];
     const requiredOs = entry.metadata?.os ?? [];
     const missingBins = requiredBins.filter((bin) => {
-        if (hasBinary(bin))
+        if (hasBinary(bin)) {
             return false;
-        if (eligibility?.remote?.hasBin?.(bin))
+        }
+        if (eligibility?.remote?.hasBin?.(bin)) {
             return false;
+        }
         return true;
     });
     const missingAnyBins = requiredAnyBins.length > 0 &&
@@ -68,10 +71,12 @@ function buildHookStatus(entry, config, eligibility) {
         : [];
     const missingEnv = [];
     for (const envName of requiredEnv) {
-        if (process.env[envName])
+        if (process.env[envName]) {
             continue;
-        if (hookConfig?.env?.[envName])
+        }
+        if (hookConfig?.env?.[envName]) {
             continue;
+        }
         missingEnv.push(envName);
     }
     const configChecks = requiredConfig.map((pathStr) => {

package/dist/hooks/hooks.d.ts

@@ -0,0 +1,5 @@
+export * from "./internal-hooks.js";
+export type HookEventType = import("./internal-hooks.js").InternalHookEventType;
+export type HookEvent = import("./internal-hooks.js").InternalHookEvent;
+export type HookHandler = import("./internal-hooks.js").InternalHookHandler;
+export { registerInternalHook as registerHook, unregisterInternalHook as unregisterHook, clearInternalHooks as clearHooks, getRegisteredEventKeys as getRegisteredHookEventKeys, triggerInternalHook as triggerHook, createInternalHookEvent as createHookEvent, } from "./internal-hooks.js";

package/dist/hooks/install.d.ts

@@ -0,0 +1,42 @@
+export type HookInstallLogger = {
+    info?: (message: string) => void;
+    warn?: (message: string) => void;
+};
+export type InstallHooksResult = {
+    ok: true;
+    hookPackId: string;
+    hooks: string[];
+    targetDir: string;
+    version?: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function resolveHookInstallDir(hookId: string, hooksDir?: string): string;
+export declare function installHooksFromArchive(params: {
+    archivePath: string;
+    hooksDir?: string;
+    timeoutMs?: number;
+    logger?: HookInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+    expectedHookPackId?: string;
+}): Promise<InstallHooksResult>;
+export declare function installHooksFromNpmSpec(params: {
+    spec: string;
+    hooksDir?: string;
+    timeoutMs?: number;
+    logger?: HookInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+    expectedHookPackId?: string;
+}): Promise<InstallHooksResult>;
+export declare function installHooksFromPath(params: {
+    path: string;
+    hooksDir?: string;
+    timeoutMs?: number;
+    logger?: HookInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+    expectedHookPackId?: string;
+}): Promise<InstallHooksResult>;

package/dist/hooks/install.js

@@ -1,36 +1,38 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { LEGACY_MANIFEST_KEY } from "../compat/legacy-names.js";
+import { MANIFEST_KEY } from "../compat/legacy-names.js";
+import { extractArchive, fileExists, readJsonFile, resolveArchiveKind, resolvePackedRootDir, } from "../infra/archive.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
-import { extractArchive, fileExists, readJsonFile, resolveArchiveKind, resolvePackedRootDir, } from "../infra/archive.js";
 import { parseFrontmatter } from "./frontmatter.js";
 const defaultLogger = {};
 function unscopedPackageName(name) {
     const trimmed = name.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return trimmed;
+    }
     return trimmed.includes("/") ? (trimmed.split("/").pop() ?? trimmed) : trimmed;
 }
 function safeDirName(input) {
     const trimmed = input.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return trimmed;
+    }
     return trimmed.replaceAll("/", "__");
 }
 export function resolveHookInstallDir(hookId, hooksDir) {
     const hooksBase = hooksDir ? resolveUserPath(hooksDir) : path.join(CONFIG_DIR, "hooks");
     return path.join(hooksBase, safeDirName(hookId));
 }
-async function ensureMoltbotHooks(manifest) {
-    const hooks = manifest.moltbot?.hooks ?? manifest[LEGACY_MANIFEST_KEY]?.hooks;
+async function ensureOpenClawHooks(manifest) {
+    const hooks = manifest[MANIFEST_KEY]?.hooks;
     if (!Array.isArray(hooks)) {
-        throw new Error("package.json missing moltbot.hooks");
+        throw new Error("package.json missing openclaw.hooks");
     }
     const list = hooks.map((e) => (typeof e === "string" ? e.trim() : "")).filter(Boolean);
     if (list.length === 0) {
-        throw new Error("package.json moltbot.hooks is empty");
+        throw new Error("package.json openclaw.hooks is empty");
     }
     return list;
 }
@@ -72,7 +74,7 @@ async function installHookPackageFromDir(params) {
     }
     let hookEntries;
     try {
-        hookEntries = await ensureMoltbotHooks(manifest);
+        hookEntries = await ensureOpenClawHooks(manifest);
     }
     catch (err) {
         return { ok: false, error: String(err) };
@@ -209,7 +211,7 @@ export async function installHooksFromArchive(params) {
     if (!resolveArchiveKind(archivePath)) {
         return { ok: false, error: `unsupported archive: ${archivePath}` };
     }
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-hook-"));
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-hook-"));
     const extractDir = path.join(tmpDir, "extract");
     await fs.mkdir(extractDir, { recursive: true });
     logger.info?.(`Extracting ${archivePath}…`);
@@ -254,9 +256,10 @@ export async function installHooksFromNpmSpec(params) {
     const dryRun = params.dryRun ?? false;
     const expectedHookPackId = params.expectedHookPackId;
     const spec = params.spec.trim();
-    if (!spec)
+    if (!spec) {
         return { ok: false, error: "missing npm spec" };
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-hook-pack-"));
+    }
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-hook-pack-"));
     logger.info?.(`Downloading ${spec}…`);
     const res = await runCommandWithTimeout(["npm", "pack", spec], {
         timeoutMs: Math.max(timeoutMs, 300_000),

package/dist/hooks/installs.d.ts

@@ -0,0 +1,6 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { HookInstallRecord } from "../config/types.hooks.js";
+export type HookInstallUpdate = HookInstallRecord & {
+    hookId: string;
+};
+export declare function recordHookInstall(cfg: OpenClawConfig, update: HookInstallUpdate): OpenClawConfig;