@unlinearity/cli-wechat-bridge 1.1.4 → 1.1.6

package/dist/core/bridge-control.js

@@ -0,0 +1,32 @@
+/** Parse the canonical control command grammar shared by all channels. */
+export function parseBridgeControlCommand(text) {
+    const [rawCommand, ...rest] = text.trim().split(/\s+/);
+    if (!rawCommand?.startsWith("/")) {
+        return null;
+    }
+    const command = rawCommand.toLowerCase();
+    const argument = rest.join(" ").trim();
+    switch (command) {
+        case "/status":
+            return { type: "status" };
+        case "/resume":
+            return argument ? { type: "resume", target: argument } : { type: "resume" };
+        case "/new":
+        case "/new-session":
+            return { type: "new_session" };
+        case "/stop":
+            return { type: "stop" };
+        case "/reset":
+            return { type: "reset" };
+        case "/confirm":
+        case "/yes":
+            return { type: "confirm" };
+        case "/deny":
+        case "/no":
+            return { type: "deny" };
+        case "/answer":
+            return argument ? { type: "answer", raw: argument } : null;
+        default:
+            return null;
+    }
+}

package/dist/core/bridge-event-forwarder.js

@@ -0,0 +1,50 @@
+/** Dispatch a BridgeEvent without importing any channel or transport code. */
+export async function forwardBridgeEvent(event, handlers) {
+    switch (event.type) {
+        case "stdout":
+            await handlers.stdout?.(event);
+            return;
+        case "stderr":
+            await handlers.stderr?.(event);
+            return;
+        case "final_reply":
+            await handlers.finalReply?.(event);
+            return;
+        case "status":
+            await handlers.status?.(event);
+            return;
+        case "notice":
+            await handlers.notice?.(event);
+            return;
+        case "thinking":
+            await handlers.thinking?.(event);
+            return;
+        case "approval_required":
+            await handlers.approvalRequired?.(event);
+            return;
+        case "user_input_required":
+            await handlers.userInputRequired?.(event);
+            return;
+        case "mirrored_user_input":
+            await handlers.mirroredUserInput?.(event);
+            return;
+        case "session_switched":
+            await handlers.sessionSwitched?.(event);
+            return;
+        case "thread_switched":
+            await handlers.threadSwitched?.(event);
+            return;
+        case "task_complete":
+            await handlers.taskComplete?.(event);
+            return;
+        case "task_failed":
+            await handlers.taskFailed?.(event);
+            return;
+        case "fatal_error":
+            await handlers.fatalError?.(event);
+            return;
+        case "shutdown_requested":
+            await handlers.shutdownRequested?.(event);
+            return;
+    }
+}

package/dist/core/bridge-message-router.js

@@ -0,0 +1,32 @@
+/**
+ * Common, channel-neutral ordering for an inbound bridge message.
+ * Channel-specific parsing and daemon slot selection stay outside this
+ * function and are supplied through callbacks.
+ */
+export async function routeBridgeMessage(context) {
+    if (!context.authorized) {
+        await context.onUnauthorized();
+        return { kind: "handled" };
+    }
+    if (context.command && await context.handleCommand(context.command)) {
+        return { kind: "handled" };
+    }
+    if (context.hasPendingApproval) {
+        await context.remindPendingApproval();
+        return { kind: "handled" };
+    }
+    if (context.hasPendingUserInput || context.adapterState.status === "awaiting_input") {
+        await context.remindPendingUserInput();
+        return { kind: "handled" };
+    }
+    if (context.shouldDefer) {
+        await context.defer();
+        return { kind: "deferred" };
+    }
+    if (context.adapterState.status === "busy" ||
+        context.adapterState.status === "awaiting_approval") {
+        await context.remindBusy();
+        return { kind: "handled" };
+    }
+    return { kind: "dispatched", result: await context.dispatch() };
+}

package/dist/core/channel-types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/text-utils.js

@@ -0,0 +1,63 @@
+const ANSI_ESCAPE_RE = 
+// eslint-disable-next-line no-control-regex
+/\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function stripAnsi(text) {
+    return text.replace(ANSI_ESCAPE_RE, "");
+}
+export function normalizeOutput(text) {
+    return stripAnsi(text)
+        // eslint-disable-next-line no-control-regex
+        .replace(/\u0000/g, "")
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n");
+}
+export function truncatePreview(text, maxLength = 140) {
+    const normalized = normalizeOutput(text).trim().replace(/\s+/g, " ");
+    if (!normalized) {
+        return "(empty)";
+    }
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+export function buildOneTimeCode(length = 6) {
+    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+    let code = "";
+    while (code.length < length) {
+        code += alphabet[Math.floor(Math.random() * alphabet.length)];
+    }
+    return code;
+}
+export function buildInstanceId() {
+    return `bridge-${Date.now().toString(36)}-${buildOneTimeCode(6).toLowerCase()}`;
+}
+export function formatDuration(durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs < 0) {
+        return "0s";
+    }
+    const totalSeconds = Math.floor(durationMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (!minutes) {
+        return `${seconds}s`;
+    }
+    return `${minutes}m ${seconds}s`;
+}
+export function summarizeOutput(text, maxLength = 280) {
+    const normalized = normalizeOutput(text)
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (!normalized.length) {
+        return "(no output)";
+    }
+    const summary = normalized.slice(-6).join("\n");
+    if (summary.length <= maxLength) {
+        return summary;
+    }
+    return summary.slice(summary.length - maxLength);
+}