@openclaw/crabline 0.1.11 → 0.1.13

package/dist/src/openclaw.js

@@ -1,21 +1,23 @@
 import { randomUUID } from "node:crypto";
 import { CRABLINE_SERVER_CHANNELS, isCrablineServerChannel, startCrablineServer, } from "./servers/index.js";
 import { SLACK_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/slack.js";
+import { DISCORD_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/discord.js";
 import { MATTERMOST_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/mattermost.js";
 import { MATRIX_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/matrix.js";
 import { SIGNAL_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/signal.js";
 import { TELEGRAM_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/telegram.js";
 import { WHATSAPP_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/whatsapp.js";
 import { ZALO_OPENCLAW_CRABLINE_PROVIDER_BRIDGE } from "./openclaw/bridges/zalo.js";
-import { OPENCLAW_CRABLINE_CHANNEL_CAPABILITY_MATRIX_PATH, OPENCLAW_CRABLINE_CHANNEL_SMOKE_PATH, OPENCLAW_CRABLINE_PROVIDER_READINESS_PATH, OPENCLAW_CRABLINE_DEFAULT_CHANNEL, OPENCLAW_CRABLINE_ARTIFACT_POINTER_PATH, OPENCLAW_CRABLINE_ARTIFACT_STORE_DIRECTORY, OPENCLAW_CRABLINE_MANIFEST_PATH, parseQaTarget, runOpenClawCrablineProviderProbe, } from "./openclaw/shared.js";
+import { OPENCLAW_CRABLINE_CHANNEL_CAPABILITY_MATRIX_PATH, OPENCLAW_CRABLINE_PROVIDER_READINESS_PATH, OPENCLAW_CRABLINE_DEFAULT_CHANNEL, OPENCLAW_CRABLINE_ARTIFACT_POINTER_PATH, OPENCLAW_CRABLINE_ARTIFACT_STORE_DIRECTORY, OPENCLAW_CRABLINE_MANIFEST_PATH, getUnsettledOpenClawCrablineProviderProbe, isRecord, parseQaTarget, runOpenClawCrablineProviderProbe, } from "./openclaw/shared.js";
 import { publishOpenClawCrablineArtifactGeneration } from "./openclaw/artifact-generation.js";
 import { isAcceptedOpenClawCrablineOutbound } from "./openclaw/outbound-contract.js";
-import { syncParentDirectory } from "./openclaw/private-file.js";
-import { acquireOpenClawCrablineSmokeRunLock, releaseOpenClawCrablineSmokeRunLock, } from "./openclaw/smoke-lock.js";
+import { securePrivateDirectory, syncParentDirectory, } from "./openclaw/private-file.js";
+import { acquireOpenClawCrablineProviderReadinessLock, releaseOpenClawCrablineProviderReadinessLock, } from "./openclaw/provider-readiness-lock.js";
 import fs from "node:fs/promises";
 import path from "node:path";
-export { OPENCLAW_CRABLINE_ARTIFACT_POINTER_PATH, OPENCLAW_CRABLINE_ARTIFACT_STORE_DIRECTORY, OPENCLAW_CRABLINE_CHANNEL_CAPABILITY_MATRIX_PATH, OPENCLAW_CRABLINE_CHANNEL_SMOKE_PATH, OPENCLAW_CRABLINE_PROVIDER_READINESS_PATH, OPENCLAW_CRABLINE_DEFAULT_CHANNEL, OPENCLAW_CRABLINE_MANIFEST_PATH, };
+export { OPENCLAW_CRABLINE_ARTIFACT_POINTER_PATH, OPENCLAW_CRABLINE_ARTIFACT_STORE_DIRECTORY, OPENCLAW_CRABLINE_CHANNEL_CAPABILITY_MATRIX_PATH, OPENCLAW_CRABLINE_PROVIDER_READINESS_PATH, OPENCLAW_CRABLINE_DEFAULT_CHANNEL, OPENCLAW_CRABLINE_MANIFEST_PATH, };
 const OPENCLAW_CRABLINE_PROVIDER_BRIDGES = {
+    discord: DISCORD_OPENCLAW_CRABLINE_PROVIDER_BRIDGE,
     mattermost: MATTERMOST_OPENCLAW_CRABLINE_PROVIDER_BRIDGE,
     matrix: MATRIX_OPENCLAW_CRABLINE_PROVIDER_BRIDGE,
     signal: SIGNAL_OPENCLAW_CRABLINE_PROVIDER_BRIDGE,
@@ -25,12 +27,93 @@ const OPENCLAW_CRABLINE_PROVIDER_BRIDGES = {
     zalo: ZALO_OPENCLAW_CRABLINE_PROVIDER_BRIDGE,
 };
 const OPENCLAW_CRABLINE_PROVIDER_BRIDGE_LIST = Object.values(OPENCLAW_CRABLINE_PROVIDER_BRIDGES);
-const RECORDER_TEMP_NAME_PATTERN = /^\.([a-z]+)-fake-provider\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl\.tmp$/iu;
+const RECORDER_TEMP_NAME_PATTERN = /^\.([a-z]+)-provider-server\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl\.tmp$/iu;
 const RECORDER_LOCK_REMOVAL_TOMBSTONE_PATTERN = /^\.(.+)\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.remove$/iu;
+const OPENCLAW_CRABLINE_PROVIDER_PROBE_CLEANUP_GRACE_MS = 250;
 function isOpenClawCrablineRecorderTemporary(name) {
     const channel = RECORDER_TEMP_NAME_PATTERN.exec(name)?.[1]?.toLowerCase();
     return channel !== undefined && isCrablineServerChannel(channel);
 }
+function hasStringRecordValues(value) {
+    return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function isOpenClawCrablineRecorderEvent(value) {
+    return (isRecord(value) &&
+        value.accepted === true &&
+        typeof value.at === "string" &&
+        Number.isFinite(Date.parse(value.at)) &&
+        typeof value.method === "string" &&
+        value.method.length > 0 &&
+        typeof value.path === "string" &&
+        value.path.startsWith("/") &&
+        hasStringRecordValues(value.query) &&
+        (value.type === "admin" || value.type === "api"));
+}
+function openClawCrablineProviderProbeRequest(manifest) {
+    switch (manifest.provider) {
+        case "discord":
+            return {
+                method: "GET",
+                path: new URL(`${manifest.endpoints.apiRoot}/v10/users/@me`).pathname,
+            };
+        case "mattermost":
+            return {
+                method: "GET",
+                path: new URL(`${manifest.endpoints.apiRoot}/users/me`).pathname,
+            };
+        case "matrix":
+            return {
+                method: "GET",
+                path: new URL(`${manifest.endpoints.clientApiRoot}/account/whoami`).pathname,
+            };
+        case "signal":
+            return {
+                method: "GET",
+                path: new URL("/api/v1/check", manifest.baseUrl).pathname,
+            };
+        case "slack":
+            return {
+                method: "POST",
+                path: new URL("auth.test", manifest.endpoints.apiRoot).pathname,
+            };
+        case "telegram":
+            return { method: "GET", path: "/bot<redacted>/getMe" };
+        case "whatsapp":
+            return {
+                method: "GET",
+                path: new URL(manifest.endpoints.phoneNumberUrl).pathname,
+            };
+        case "zalo":
+            return { method: "POST", path: "/bot<redacted>/getMe" };
+    }
+}
+function assertOpenClawCrablineRecorderEvidence(contents, manifest) {
+    const expectedRequest = openClawCrablineProviderProbeRequest(manifest);
+    let recorderEvidence = false;
+    for (const line of contents.split(/\r?\n/u)) {
+        if (!line.trim()) {
+            continue;
+        }
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error("OpenClaw Crabline provider probe produced no valid JSONL recorder evidence.", { cause: error });
+        }
+        if (!isOpenClawCrablineRecorderEvent(event)) {
+            throw new Error("OpenClaw Crabline provider probe produced no valid JSONL recorder evidence.");
+        }
+        if (event.type === "api" &&
+            event.method === expectedRequest.method &&
+            event.path === expectedRequest.path) {
+            recorderEvidence = true;
+        }
+    }
+    if (!recorderEvidence) {
+        throw new Error("OpenClaw Crabline provider probe produced no valid JSONL recorder evidence.");
+    }
+}
 function isOpenClawCrablineRecorderTemporaryLock(name) {
     return name.endsWith(".lock") && isOpenClawCrablineRecorderTemporary(name.slice(0, -5));
 }
@@ -80,8 +163,11 @@ async function reclaimOpenClawCrablineRecorderTemporaryLock(directoryPath, name,
     await fs.rm(quarantinePath, { force: true, recursive: true });
     await syncParentDirectory(quarantinePath);
 }
-async function reclaimOpenClawCrablineRecorderTemporaries(directoryPath, lock) {
+async function reclaimOpenClawCrablineRecorderTemporaries(directory, lock) {
+    const directoryPath = directory.directoryPath;
+    await directory.assertIdentityAt();
     for (const entry of await fs.readdir(directoryPath, { withFileTypes: true })) {
+        await directory.assertIdentityAt();
         const tombstoneBaseName = entry.isDirectory()
             ? openClawCrablineRecorderLockTombstoneBaseName(entry.name)
             : null;
@@ -99,7 +185,60 @@ async function reclaimOpenClawCrablineRecorderTemporaries(directoryPath, lock) {
         const temporaryPath = path.join(directoryPath, entry.name);
         await fs.rm(temporaryPath, { force: true });
         await syncParentDirectory(temporaryPath);
+        await directory.assertIdentityAt();
     }
+    await directory.assertIdentityAt();
+}
+function assertOwnedRecorderStats(stats, expected) {
+    const currentUserId = process.geteuid?.();
+    if (!stats.isFile() ||
+        stats.nlink !== 1n ||
+        stats.ino <= 0n ||
+        (currentUserId !== undefined && stats.uid !== BigInt(currentUserId)) ||
+        (expected !== undefined &&
+            (stats.dev !== expected.device ||
+                stats.ino !== expected.inode ||
+                stats.uid !== expected.userId))) {
+        throw new Error("OpenClaw Crabline recorder snapshot identity is invalid.");
+    }
+    return {
+        device: stats.dev,
+        inode: stats.ino,
+        userId: stats.uid,
+    };
+}
+async function readOwnedRecorderSnapshot(recorderPath, directory) {
+    await directory.assertIdentityAt();
+    const handle = await fs.open(recorderPath, "r");
+    try {
+        const identity = assertOwnedRecorderStats(await handle.stat({ bigint: true }));
+        assertOwnedRecorderStats(await fs.lstat(recorderPath, { bigint: true }), identity);
+        const contents = await handle.readFile("utf8");
+        await directory.assertIdentityAt();
+        assertOwnedRecorderStats(await fs.lstat(recorderPath, { bigint: true }), identity);
+        return { contents, identity };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function removeOwnedRecorderTemporary(params) {
+    await params.directory.assertIdentityAt();
+    let stats;
+    try {
+        stats = await fs.lstat(params.recorderPath, { bigint: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            await params.syncParent(params.recorderPath);
+            return;
+        }
+        throw error;
+    }
+    assertOwnedRecorderStats(stats, params.identity);
+    await fs.rm(params.recorderPath);
+    await params.directory.assertIdentityAt();
+    await params.syncParent(params.recorderPath);
 }
 function createOpenClawCrablineProviderAdapter(manifest) {
     const bridge = OPENCLAW_CRABLINE_PROVIDER_BRIDGE_LIST.find((candidate) => candidate.provider === manifest.provider);
@@ -133,7 +272,6 @@ export function resolveOpenClawCrablineChannelDriverSelection(params) {
         channelDriver: "crabline",
         capabilityMatrixPath: OPENCLAW_CRABLINE_CHANNEL_CAPABILITY_MATRIX_PATH,
         providerReadinessArtifactPath: OPENCLAW_CRABLINE_PROVIDER_READINESS_PATH,
-        smokeArtifactPath: OPENCLAW_CRABLINE_CHANNEL_SMOKE_PATH,
     };
 }
 export async function probeOpenClawCrablineProvider(manifest) {
@@ -189,20 +327,55 @@ export async function startOpenClawCrablineAdapter(params, dependencies = {}) {
         throw error;
     }
 }
+function attachOpenClawCrablineProbeCleanupFailure(probeFailure, cleanupError) {
+    const existingCause = probeFailure.cause;
+    try {
+        Object.defineProperty(probeFailure, "cause", {
+            configurable: true,
+            value: existingCause === undefined
+                ? cleanupError
+                : new AggregateError([existingCause, cleanupError], "OpenClaw Crabline provider probe cleanup also failed."),
+        });
+    }
+    catch {
+        // Some provider errors are frozen; preserving the primary failure is authoritative.
+    }
+}
+async function waitForOpenClawCrablineProbeCleanup(probeSettlement) {
+    let timeout;
+    try {
+        await Promise.race([
+            probeSettlement,
+            new Promise((resolve) => {
+                timeout = setTimeout(resolve, OPENCLAW_CRABLINE_PROVIDER_PROBE_CLEANUP_GRACE_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
 export async function runOpenClawCrablineProviderReadiness(params, dependencies = {}) {
     const outputDir = path.resolve(params.outputDir);
-    const releaseLock = dependencies.releaseLock ?? releaseOpenClawCrablineSmokeRunLock;
-    const smokeLock = await (dependencies.acquireLock ?? acquireOpenClawCrablineSmokeRunLock)({
+    const releaseLock = dependencies.releaseLock ?? releaseOpenClawCrablineProviderReadinessLock;
+    const syncRecorderParent = dependencies.syncParent ?? syncParentDirectory;
+    const providerReadinessLock = await (dependencies.acquireLock ?? acquireOpenClawCrablineProviderReadinessLock)({
         channel: params.selection.channel,
         outputDir,
     });
     let outcome;
+    let recorderDirectory;
+    let recorderIdentity;
     let recorderPath;
     try {
-        const recorderDirectory = path.join(outputDir, "artifacts", "crabline");
-        await fs.mkdir(recorderDirectory, { recursive: true });
-        await reclaimOpenClawCrablineRecorderTemporaries(recorderDirectory, smokeLock);
-        recorderPath = path.join(recorderDirectory, `.${params.selection.channel}-fake-provider.${randomUUID()}.jsonl.tmp`);
+        const artifactsDirectory = await securePrivateDirectory(path.join(outputDir, "artifacts"));
+        recorderDirectory = await securePrivateDirectory(path.join(artifactsDirectory.directoryPath, "crabline"));
+        await artifactsDirectory.assertIdentityAt();
+        await recorderDirectory.assertIdentityAt();
+        await reclaimOpenClawCrablineRecorderTemporaries(recorderDirectory, providerReadinessLock);
+        recorderPath = path.join(recorderDirectory.directoryPath, `.${params.selection.channel}-provider-server.${randomUUID()}.jsonl.tmp`);
         const adapter = await (dependencies.startAdapter ?? startOpenClawCrablineAdapter)({
             channel: params.selection.channel,
             openclawConfig: {},
@@ -211,55 +384,61 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
         let probe;
         let probeFailed = false;
         let probeFailure;
+        let probeSettlement;
         try {
             probe = await adapter.probe();
         }
         catch (error) {
             probeFailed = true;
             probeFailure = error;
+            probeSettlement = getUnsettledOpenClawCrablineProviderProbe(error);
         }
-        try {
-            await adapter.close();
-        }
-        catch (cleanupError) {
-            if (!probeFailed) {
-                throw cleanupError;
+        if (probeSettlement) {
+            await waitForOpenClawCrablineProbeCleanup(probeSettlement);
+            try {
+                await adapter.close();
             }
-            if (probeFailure instanceof Error) {
-                const existingCause = probeFailure.cause;
-                try {
-                    Object.defineProperty(probeFailure, "cause", {
-                        configurable: true,
-                        value: existingCause === undefined
-                            ? cleanupError
-                            : new AggregateError([existingCause, cleanupError], "OpenClaw Crabline provider probe cleanup also failed."),
+            catch (cleanupError) {
+                if (probeFailure instanceof Error) {
+                    attachOpenClawCrablineProbeCleanupFailure(probeFailure, cleanupError);
+                }
+                else {
+                    const combinedError = new Error("OpenClaw Crabline provider probe and cleanup both failed.", { cause: cleanupError });
+                    Object.defineProperty(combinedError, "errors", {
+                        value: [probeFailure, cleanupError],
                     });
+                    throw combinedError;
                 }
-                catch {
-                    // Some provider errors are frozen; preserving the primary failure is authoritative.
+            }
+        }
+        else {
+            try {
+                await adapter.close();
+            }
+            catch (cleanupError) {
+                if (!probeFailed) {
+                    throw cleanupError;
+                }
+                if (probeFailure instanceof Error) {
+                    attachOpenClawCrablineProbeCleanupFailure(probeFailure, cleanupError);
+                    throw probeFailure;
                 }
-                throw probeFailure;
+                const combinedError = new Error("OpenClaw Crabline provider probe and cleanup both failed.", {
+                    cause: cleanupError,
+                });
+                Object.defineProperty(combinedError, "errors", {
+                    value: [probeFailure, cleanupError],
+                });
+                throw combinedError;
             }
-            const combinedError = new Error("OpenClaw Crabline provider probe and cleanup both failed.", {
-                cause: cleanupError,
-            });
-            Object.defineProperty(combinedError, "errors", {
-                value: [probeFailure, cleanupError],
-            });
-            throw combinedError;
         }
         if (probeFailed) {
             throw probeFailure;
         }
-        let recorderSnapshotContents = "";
-        try {
-            recorderSnapshotContents = await fs.readFile(recorderPath, "utf8");
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-        }
+        const recorderSnapshot = await readOwnedRecorderSnapshot(recorderPath, recorderDirectory);
+        recorderIdentity = recorderSnapshot.identity;
+        const recorderSnapshotContents = recorderSnapshot.contents;
+        assertOpenClawCrablineRecorderEvidence(recorderSnapshotContents, adapter.manifest);
         const capabilityReport = {
             result: {
                 driver: "crabline",
@@ -280,19 +459,24 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
         };
         const generation = await (dependencies.publishGeneration ?? publishOpenClawCrablineArtifactGeneration)({
             capabilityReport,
-            lock: smokeLock,
+            lock: providerReadinessLock,
             manifest: adapter.manifest,
             outputDir,
             recorderSnapshot: {
                 contents: recorderSnapshotContents,
-                fileName: `${params.selection.channel}-fake-provider.jsonl`,
+                fileName: `${params.selection.channel}-provider-server.jsonl`,
             },
             selection: params.selection,
             providerReadiness,
         });
         let recorderCleanupWarning;
         try {
-            await fs.rm(recorderPath, { force: true });
+            await removeOwnedRecorderTemporary({
+                directory: recorderDirectory,
+                identity: recorderIdentity,
+                recorderPath,
+                syncParent: syncRecorderParent,
+            });
             recorderPath = undefined;
         }
         catch (error) {
@@ -309,8 +493,6 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
                 manifestPath: generation.manifestPath,
                 providerReadiness: generation.providerReadiness,
                 providerReadinessArtifactPath: generation.providerReadinessArtifactPath,
-                smoke: generation.providerReadiness,
-                smokeArtifactPath: generation.providerReadinessArtifactPath,
                 ...(generation.warnings || recorderCleanupWarning
                     ? {
                         warnings: [
@@ -324,9 +506,14 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
     }
     catch (error) {
         let primaryError = error;
-        if (recorderPath) {
+        if (recorderPath && recorderDirectory) {
             try {
-                await fs.rm(recorderPath, { force: true });
+                await removeOwnedRecorderTemporary({
+                    directory: recorderDirectory,
+                    ...(recorderIdentity ? { identity: recorderIdentity } : {}),
+                    recorderPath,
+                    syncParent: syncRecorderParent,
+                });
                 recorderPath = undefined;
             }
             catch (cleanupError) {
@@ -356,7 +543,7 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
         outcome = { committed: false, error: primaryError };
     }
     try {
-        await releaseLock(smokeLock);
+        await releaseLock(providerReadinessLock);
     }
     catch (cleanupError) {
         // The pointer switch is authoritative; lock removal cannot roll it back.
@@ -368,7 +555,7 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
                         configurable: true,
                         value: existingCause === undefined
                             ? cleanupError
-                            : new AggregateError([existingCause, cleanupError], "OpenClaw Crabline smoke failure cleanup also failed."),
+                            : new AggregateError([existingCause, cleanupError], "OpenClaw Crabline provider readiness failure cleanup also failed."),
                     });
                 }
                 catch {
@@ -376,7 +563,7 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
                 }
                 throw outcome.error;
             }
-            const combinedError = new Error("OpenClaw Crabline smoke and lock cleanup both failed.", {
+            const combinedError = new Error("OpenClaw Crabline provider readiness and lock cleanup both failed.", {
                 cause: cleanupError,
             });
             Object.defineProperty(combinedError, "errors", {
@@ -389,7 +576,7 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
             ...outcome.result,
             warnings: [
                 ...(outcome.result.warnings ?? []),
-                `OpenClaw Crabline smoke committed but lock cleanup failed: ${detail}`,
+                `OpenClaw Crabline provider readiness committed but lock cleanup failed: ${detail}`,
             ],
         };
     }
@@ -398,8 +585,6 @@ export async function runOpenClawCrablineProviderReadiness(params, dependencies
     }
     return outcome.result;
 }
-/** @deprecated Use runOpenClawCrablineProviderReadiness. */
-export const runOpenClawCrablineChannelDriverSmoke = runOpenClawCrablineProviderReadiness;
 export function createOpenClawCrablineChannelReportNotes(selection) {
     if (!selection) {
         return [];
@@ -408,7 +593,7 @@ export function createOpenClawCrablineChannelReportNotes(selection) {
         `Channel driver: ${selection.channelDriver} local provider for ${selection.channel}.`,
         `Channel artifact pointer: ${OPENCLAW_CRABLINE_ARTIFACT_POINTER_PATH}.`,
         `Generation capability filename: ${selection.capabilityMatrixPath}.`,
-        `Generation provider-readiness filename: ${selection.providerReadinessArtifactPath ?? selection.smokeArtifactPath}.`,
+        `Generation provider-readiness filename: ${selection.providerReadinessArtifactPath}.`,
         "Crabline verifies the local provider API is ready; OpenClaw channel behavior is proven separately by QA scenarios that run the real channel adapter.",
     ];
 }