@a1hvdy/cc-openclaw 0.24.0 → 0.25.1

package/dist/src/channels/telegram-mirror/failure/pool-exhausted-fallback.js

@@ -0,0 +1,24 @@
+/**
+ * failure/pool-exhausted-fallback.ts — v0.25.0 M12.
+ *
+ * Mode: pool-exhausted-fallback. The SubprocessPool (v0.16+ / M1
+ * v0.24.0) is saturated — incoming turn falls back to direct CLI spawn.
+ * The user surface is informational only; the engine completes the turn
+ * regardless. Tracked so soak instrumentation can flag if it fires often.
+ */
+export const META = {
+    mode: 'pool-exhausted-fallback',
+    glyph: 'ℹ️',
+    severity: 'info',
+};
+export const handle = (ctx, info) => {
+    const sz = info?.poolSize && Number.isFinite(info.poolSize) ? ` (${info.poolSize} slots in use)` : '';
+    return [
+        {
+            type: 'sendMessage',
+            chat_id: ctx.chatId,
+            text: `${META.glyph} Subprocess pool full${sz} — running this turn via direct CLI.`,
+        },
+    ];
+};
+//# sourceMappingURL=pool-exhausted-fallback.js.map

package/dist/src/channels/telegram-mirror/failure/pool-exhausted-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-exhausted-fallback.js","sourceRoot":"","sources":["../../../../../src/channels/telegram-mirror/failure/pool-exhausted-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,CAAC,MAAM,IAAI,GAAsB;IACrC,IAAI,EAAE,yBAAyB;IAC/B,KAAK,EAAE,IAAI;IACX,QAAQ,EAAE,MAAM;CACjB,CAAC;AAOF,MAAM,CAAC,MAAM,MAAM,GAAsC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;IACrE,MAAM,EAAE,GAAG,IAAI,EAAE,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,QAAQ,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;IACtG,OAAO;QACL;YACE,IAAI,EAAE,aAAa;YACnB,OAAO,EAAE,GAAG,CAAC,MAAM;YACnB,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,wBAAwB,EAAE,sCAAsC;SACpF;KACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/src/channels/telegram-mirror/failure/rate-limit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * failure/rate-limit.ts — v0.25.0 M12.
+ *
+ * Mode: rate-limit. Telegram bot API 429 or Anthropic 429 hit. Caller
+ * supplies the upstream retry-after hint when known; default surface is
+ * a transparent back-off advisory without prompting user action.
+ */
+import type { FailureHandler, FailureModuleMeta } from './types.js';
+export declare const META: FailureModuleMeta;
+export interface RateLimitInfo {
+    /** Source of the limit — "telegram" or "anthropic". */
+    source?: 'telegram' | 'anthropic';
+    /** Server-advertised retry-after seconds, when available. */
+    retryAfterSec?: number;
+}
+export declare const handle: FailureHandler<RateLimitInfo>;

package/dist/src/channels/telegram-mirror/failure/rate-limit.js

@@ -0,0 +1,26 @@
+/**
+ * failure/rate-limit.ts — v0.25.0 M12.
+ *
+ * Mode: rate-limit. Telegram bot API 429 or Anthropic 429 hit. Caller
+ * supplies the upstream retry-after hint when known; default surface is
+ * a transparent back-off advisory without prompting user action.
+ */
+export const META = {
+    mode: 'rate-limit',
+    glyph: '🟧',
+    severity: 'warn',
+};
+export const handle = (ctx, info) => {
+    const src = info?.source ?? 'upstream';
+    const after = info?.retryAfterSec && Number.isFinite(info.retryAfterSec)
+        ? ` Retrying in ${info.retryAfterSec}s.`
+        : '';
+    return [
+        {
+            type: 'sendMessage',
+            chat_id: ctx.chatId,
+            text: `${META.glyph} Rate-limited by ${src}.${after} Auto-backing off.`,
+        },
+    ];
+};
+//# sourceMappingURL=rate-limit.js.map

package/dist/src/channels/telegram-mirror/failure/rate-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.js","sourceRoot":"","sources":["../../../../../src/channels/telegram-mirror/failure/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,CAAC,MAAM,IAAI,GAAsB;IACrC,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,IAAI;IACX,QAAQ,EAAE,MAAM;CACjB,CAAC;AASF,MAAM,CAAC,MAAM,MAAM,GAAkC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;IACjE,MAAM,GAAG,GAAG,IAAI,EAAE,MAAM,IAAI,UAAU,CAAC;IACvC,MAAM,KAAK,GAAG,IAAI,EAAE,aAAa,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC;QACtE,CAAC,CAAC,gBAAgB,IAAI,CAAC,aAAa,IAAI;QACxC,CAAC,CAAC,EAAE,CAAC;IACP,OAAO;QACL;YACE,IAAI,EAAE,aAAa;YACnB,OAAO,EAAE,GAAG,CAAC,MAAM;YACnB,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,oBAAoB,GAAG,IAAI,KAAK,oBAAoB;SACxE;KACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/src/channels/telegram-mirror/failure/returning-after-24h.d.ts

@@ -0,0 +1,14 @@
+/**
+ * failure/returning-after-24h.ts — v0.25.0 M12.
+ *
+ * Mode: returning-after-24h. The chat last had inbound activity more
+ * than 24 hours ago. Surfaces a friendly welcome-back + status hint so
+ * the user can decide whether to resume vs start fresh.
+ */
+import type { FailureHandler, FailureModuleMeta } from './types.js';
+export declare const META: FailureModuleMeta;
+export interface ReturningAfter24hInfo {
+    /** Hours since the last inbound activity, rounded to nearest integer. */
+    hoursAgo?: number;
+}
+export declare const handle: FailureHandler<ReturningAfter24hInfo>;

package/dist/src/channels/telegram-mirror/failure/returning-after-24h.js

@@ -0,0 +1,33 @@
+/**
+ * failure/returning-after-24h.ts — v0.25.0 M12.
+ *
+ * Mode: returning-after-24h. The chat last had inbound activity more
+ * than 24 hours ago. Surfaces a friendly welcome-back + status hint so
+ * the user can decide whether to resume vs start fresh.
+ */
+export const META = {
+    mode: 'returning-after-24h',
+    glyph: '👋',
+    severity: 'info',
+};
+function formatHoursAgo(h) {
+    if (h >= 168)
+        return `${Math.floor(h / 168)}w ago`;
+    if (h >= 24)
+        return `${Math.floor(h / 24)}d ago`;
+    return `${h}h ago`;
+}
+export const handle = (ctx, info) => {
+    const ago = info?.hoursAgo && Number.isFinite(info.hoursAgo)
+        ? formatHoursAgo(info.hoursAgo)
+        : '24h+ ago';
+    return [
+        {
+            type: 'sendMessage',
+            chat_id: ctx.chatId,
+            text: `${META.glyph} Welcome back — last activity ${ago}. ` +
+                `Type /status to inspect sessions or /sessions to switch.`,
+        },
+    ];
+};
+//# sourceMappingURL=returning-after-24h.js.map

package/dist/src/channels/telegram-mirror/failure/returning-after-24h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"returning-after-24h.js","sourceRoot":"","sources":["../../../../../src/channels/telegram-mirror/failure/returning-after-24h.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,CAAC,MAAM,IAAI,GAAsB;IACrC,IAAI,EAAE,qBAAqB;IAC3B,KAAK,EAAE,IAAI;IACX,QAAQ,EAAE,MAAM;CACjB,CAAC;AAOF,SAAS,cAAc,CAAC,CAAS;IAC/B,IAAI,CAAC,IAAI,GAAG;QAAE,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC;IACnD,IAAI,CAAC,IAAI,EAAE;QAAE,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC;IACjD,OAAO,GAAG,CAAC,OAAO,CAAC;AACrB,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAA0C,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;IACzE,MAAM,GAAG,GACP,IAAI,EAAE,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC9C,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC/B,CAAC,CAAC,UAAU,CAAC;IACjB,OAAO;QACL;YACE,IAAI,EAAE,aAAa;YACnB,OAAO,EAAE,GAAG,CAAC,MAAM;YACnB,IAAI,EACF,GAAG,IAAI,CAAC,KAAK,iCAAiC,GAAG,IAAI;gBACrD,0DAA0D;SAC7D;KACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/src/channels/telegram-mirror/failure/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * src/channels/telegram-mirror/failure/types.ts — v0.25.0 M12 shared types.
+ *
+ * Each failure mode lives in its own file per ADR-008 ("per-mode handlers
+ * make each response shape testable and grep-able"). This file holds the
+ * shared types so the 8 handler modules stay tight (each ~30-50 lines).
+ */
+import type { TelegramAction } from '../commands.js';
+export interface FailureContext {
+    chatId: string | number;
+}
+export type Severity = 'info' | 'warn' | 'error';
+/**
+ * Shape every failure handler exports. Handlers are pure functions:
+ * inputs are the chat context + an optional info payload; output is the
+ * array of TelegramAction the dispatch layer applies.
+ */
+export type FailureHandler<I = unknown> = (ctx: FailureContext, info?: I) => TelegramAction[];
+/**
+ * Registry-side metadata per failure module. Asserted by M13's chaos
+ * test against the file name + handler shape.
+ */
+export interface FailureModuleMeta {
+    /** Mode id, matches the file name without the .ts extension. */
+    mode: string;
+    /** Glyph that prefixes every emitted message for this mode. */
+    glyph: string;
+    /** Severity classification used by the chaos test + observability. */
+    severity: Severity;
+}

package/dist/src/channels/telegram-mirror/failure/types.js

@@ -0,0 +1,9 @@
+/**
+ * src/channels/telegram-mirror/failure/types.ts — v0.25.0 M12 shared types.
+ *
+ * Each failure mode lives in its own file per ADR-008 ("per-mode handlers
+ * make each response shape testable and grep-able"). This file holds the
+ * shared types so the 8 handler modules stay tight (each ~30-50 lines).
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/channels/telegram-mirror/failure/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/channels/telegram-mirror/failure/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/src/channels/telegram-mirror/inbound-handler.d.ts

@@ -0,0 +1,52 @@
+/**
+ * src/channels/telegram-mirror/inbound-handler.ts — v0.25.1 wire-up.
+ *
+ * The piece that was missing from v0.25.0: subscribes to OpenClaw's
+ * `before_dispatch` event, identifies mirror slash commands, routes
+ * through `dispatchCommand` (from commands.ts), and forwards the
+ * resulting TelegramAction list out via `telegram-bot-api`'s sendTg.
+ *
+ * Returns `{ handled: true }` on dispatch so OpenClaw's default model
+ * route (or any built-in command handler) doesn't ALSO respond — the
+ * legacy event-reducer's `/quota` / `/sessions` handlers used the same
+ * claim shape.
+ *
+ * Out-of-scope for v0.25.1 (deferred to v0.25.2+):
+ *   • Tool/text/turn stream-event subscription → mirror-card render.
+ *   • callback_query handling for inline-keyboard taps.
+ *   • Burst-accumulator + compose-buffer engine injection (the
+ *     ComposeBuffer + BurstAccumulator capture user text but the
+ *     concatenated payload from /send still needs to reach the engine
+ *     as a synthetic user message — that's a separate dispatch path).
+ *
+ * Single shared CallbackMap + ComposeBuffer per process so callback
+ * resolution and compose state survive across handler invocations.
+ */
+import { CallbackMap } from './callback-mapping.js';
+import { ComposeBuffer } from './compose-buffer.js';
+export interface InboundHandlerApi {
+    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
+    logger?: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+    };
+}
+/**
+ * Internal handler state — exported only for tests so they can inspect
+ * compose-buffer state + callback-map without going through Telegram.
+ */
+export interface HandlerState {
+    callbackMap: CallbackMap;
+    composeBuffer: ComposeBuffer;
+}
+export declare function createHandlerState(): HandlerState;
+/**
+ * Register the inbound dispatcher. Called by mirror's register() at boot.
+ *
+ * Hooked to `before_dispatch` — OpenClaw's name for the inbound-message
+ * event surface. We return `{ handled: true }` to claim the message when
+ * it's a known mirror slash command; `undefined` lets the event proceed
+ * to OpenClaw's default routing (which is what we want for non-slash
+ * user text destined for the model).
+ */
+export declare function registerInboundHandler(api: InboundHandlerApi, state?: HandlerState): HandlerState;

package/dist/src/channels/telegram-mirror/inbound-handler.js

@@ -0,0 +1,115 @@
+/**
+ * src/channels/telegram-mirror/inbound-handler.ts — v0.25.1 wire-up.
+ *
+ * The piece that was missing from v0.25.0: subscribes to OpenClaw's
+ * `before_dispatch` event, identifies mirror slash commands, routes
+ * through `dispatchCommand` (from commands.ts), and forwards the
+ * resulting TelegramAction list out via `telegram-bot-api`'s sendTg.
+ *
+ * Returns `{ handled: true }` on dispatch so OpenClaw's default model
+ * route (or any built-in command handler) doesn't ALSO respond — the
+ * legacy event-reducer's `/quota` / `/sessions` handlers used the same
+ * claim shape.
+ *
+ * Out-of-scope for v0.25.1 (deferred to v0.25.2+):
+ *   • Tool/text/turn stream-event subscription → mirror-card render.
+ *   • callback_query handling for inline-keyboard taps.
+ *   • Burst-accumulator + compose-buffer engine injection (the
+ *     ComposeBuffer + BurstAccumulator capture user text but the
+ *     concatenated payload from /send still needs to reach the engine
+ *     as a synthetic user message — that's a separate dispatch path).
+ *
+ * Single shared CallbackMap + ComposeBuffer per process so callback
+ * resolution and compose state survive across handler invocations.
+ */
+import { dispatchCommand, parseSlash, COMMAND_HANDLERS } from './commands.js';
+import { sendTg, editTg } from '../../lib/telegram-bot-api.js';
+import { CallbackMap } from './callback-mapping.js';
+import { ComposeBuffer } from './compose-buffer.js';
+const PLUGIN_TAG = '[cc-openclaw/telegram-mirror/inbound]';
+export function createHandlerState() {
+    return {
+        callbackMap: new CallbackMap(),
+        composeBuffer: new ComposeBuffer(),
+    };
+}
+/**
+ * The set of slash commands the mirror claims. Names match what
+ * dispatchCommand recognises (commands.ts COMMAND_HANDLERS keys).
+ */
+const MIRROR_COMMANDS = new Set(Object.keys(COMMAND_HANDLERS));
+/**
+ * Forward a single TelegramAction to the actual Telegram API. Returns
+ * the API response (or {ok:false} on failure). Pure I/O — no state
+ * mutation.
+ *
+ * editMessageText and sendDocument variants land in v0.25.2 when the
+ * render pipeline and plan-attachment dispatch wire up.
+ */
+async function forwardAction(action, threadId, logger) {
+    try {
+        if (action.type === 'sendMessage') {
+            await sendTg(String(action.chat_id), action.text, threadId !== undefined ? String(threadId) : undefined, action.reply_markup);
+            return;
+        }
+        if (action.type === 'editMessageText') {
+            await editTg(String(action.chat_id), action.message_id, action.text, action.reply_markup);
+            return;
+        }
+        // sendDocument: v0.25.2 — plan-mode attachment wire-up.
+        logger.warn(`${PLUGIN_TAG} action type "${action.type}" not yet forwarded (deferred to v0.25.2)`);
+    }
+    catch (err) {
+        logger.warn(`${PLUGIN_TAG} forwardAction failed: ${err.message}`);
+    }
+}
+/**
+ * Register the inbound dispatcher. Called by mirror's register() at boot.
+ *
+ * Hooked to `before_dispatch` — OpenClaw's name for the inbound-message
+ * event surface. We return `{ handled: true }` to claim the message when
+ * it's a known mirror slash command; `undefined` lets the event proceed
+ * to OpenClaw's default routing (which is what we want for non-slash
+ * user text destined for the model).
+ */
+export function registerInboundHandler(api, state = createHandlerState()) {
+    const logger = (api.logger ?? console);
+    api.on('before_dispatch', async (...args) => {
+        const event = args[0];
+        if (!event)
+            return undefined;
+        if (event.channel !== 'telegram')
+            return undefined;
+        // callback_query rides on `before_dispatch` too — deferred to v0.25.2.
+        if (event.raw?.callback_query)
+            return undefined;
+        const text = event.raw?.message?.text;
+        if (typeof text !== 'string')
+            return undefined;
+        const parsed = parseSlash(text);
+        if (!parsed)
+            return undefined;
+        if (!MIRROR_COMMANDS.has(parsed.cmd))
+            return undefined;
+        const chatRaw = event.raw?.message?.chat?.id;
+        const chatId = chatRaw !== undefined && chatRaw !== null ? String(chatRaw) : '';
+        if (!chatId)
+            return undefined;
+        const threadId = event.raw?.message?.message_thread_id;
+        const result = dispatchCommand(parsed, {
+            chatId,
+            callbackMap: state.callbackMap,
+            composeBuffer: state.composeBuffer,
+        });
+        if (!result)
+            return undefined;
+        for (const action of result.actions) {
+            await forwardAction(action, threadId, logger);
+        }
+        logger.info(`${PLUGIN_TAG} dispatched /${parsed.cmd}${parsed.args.length ? ' ' + parsed.args.join(' ') : ''} (chat=${chatId}, actions=${result.actions.length})`);
+        return { handled: true };
+    });
+    logger.info(`${PLUGIN_TAG} subscribed to before_dispatch — ${MIRROR_COMMANDS.size} commands armed.`);
+    return state;
+}
+//# sourceMappingURL=inbound-handler.js.map

package/dist/src/channels/telegram-mirror/inbound-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbound-handler.js","sourceRoot":"","sources":["../../../../src/channels/telegram-mirror/inbound-handler.ts"],"names":[],"mappings":"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"}

package/dist/src/channels/telegram-mirror/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * src/channels/telegram-mirror/index.ts — v0.25.0 Telegram Terminal Mirror entry.
+ *
+ * Parallel implementation per ADR-002. The legacy 14-module live card at
+ * src/channels/telegram/ is read-only observability; this mirror replaces it
+ * with a Telegram-native surface (sessions/plan/cost/compose/etc.) so A1 can
+ * drive cc-openclaw from phone without opening the laptop.
+ *
+ * M0 milestone (this file): empty register() stub gated by
+ * CC_OPENCLAW_TERMINAL_MIRROR=1. Subsequent milestones (M1..M16) wire each
+ * subsystem in dependency order. The flag picks which channel barrel loads
+ * at boot — legacy and mirror are mutually exclusive (no double-listener
+ * collisions). Roadmap + ADRs live at
+ * /home/a1xai/dev/cc-openclaw/PRPs/v0.25.0-telegram-terminal-mirror.md.
+ *
+ * ADRs touched at M0: ADR-002 (parallel impl, not in-place).
+ * Risks monitored: R-7 (parallel maintenance burden — re-evaluate at soak start).
+ */
+export interface PluginApi {
+    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
+    logger?: Console;
+}
+/**
+ * Mirror channel register — idempotent via defaultRegisterGuard.
+ *
+ * M0: empty stub. No api.on() wiring yet; subsequent milestones add handlers.
+ * The stub still completes successfully so M0's exit criterion ("Plugin boot
+ * succeeds in both flag states") holds end-to-end.
+ */
+export declare function register(api: PluginApi): void;

package/dist/src/channels/telegram-mirror/index.js

@@ -0,0 +1,49 @@
+/**
+ * src/channels/telegram-mirror/index.ts — v0.25.0 Telegram Terminal Mirror entry.
+ *
+ * Parallel implementation per ADR-002. The legacy 14-module live card at
+ * src/channels/telegram/ is read-only observability; this mirror replaces it
+ * with a Telegram-native surface (sessions/plan/cost/compose/etc.) so A1 can
+ * drive cc-openclaw from phone without opening the laptop.
+ *
+ * M0 milestone (this file): empty register() stub gated by
+ * CC_OPENCLAW_TERMINAL_MIRROR=1. Subsequent milestones (M1..M16) wire each
+ * subsystem in dependency order. The flag picks which channel barrel loads
+ * at boot — legacy and mirror are mutually exclusive (no double-listener
+ * collisions). Roadmap + ADRs live at
+ * /home/a1xai/dev/cc-openclaw/PRPs/v0.25.0-telegram-terminal-mirror.md.
+ *
+ * ADRs touched at M0: ADR-002 (parallel impl, not in-place).
+ * Risks monitored: R-7 (parallel maintenance burden — re-evaluate at soak start).
+ */
+import { defaultRegisterGuard } from '../../lib/register-guard.js';
+import { initBotTokenFromConfig } from '../../lib/telegram-bot-api.js';
+import { registerInboundHandler } from './inbound-handler.js';
+/**
+ * Mirror channel register — idempotent via defaultRegisterGuard.
+ *
+ * M0: empty stub. No api.on() wiring yet; subsequent milestones add handlers.
+ * The stub still completes successfully so M0's exit criterion ("Plugin boot
+ * succeeds in both flag states") holds end-to-end.
+ */
+export function register(api) {
+    defaultRegisterGuard.guard('cc-openclaw/telegram-mirror', api, () => {
+        const logger = api.logger || console;
+        logger.info('[cc-openclaw/telegram-mirror] register() — wiring inbound dispatcher (v0.25.1).');
+        // v0.25.0 M16 — initialise Telegram bot token (sourcing migrated
+        // out of the legacy live-card module into src/lib/telegram-bot-api).
+        // Same precedence as before: api.config first, then ~/.openclaw/openclaw.json.
+        initBotTokenFromConfig({
+            config: api.config,
+            logger: logger,
+        });
+        // v0.25.1 — subscribe before_dispatch and route mirror slash commands
+        // through dispatchCommand → telegram-bot-api. Without this, v0.25.0's
+        // handlers were unreachable from the live Telegram path.
+        registerInboundHandler({
+            on: api.on.bind(api),
+            logger: logger,
+        });
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/src/channels/telegram-mirror/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/channels/telegram-mirror/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAO9D;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAc;IACrC,oBAAoB,CAAC,KAAK,CAAC,6BAA6B,EAAE,GAAG,EAAE,GAAG,EAAE;QAClE,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI,OAAO,CAAC;QACrC,MAAM,CAAC,IAAI,CACT,iFAAiF,CAClF,CAAC;QACF,iEAAiE;QACjE,qEAAqE;QACrE,+EAA+E;QAC/E,sBAAsB,CAAC;YACrB,MAAM,EAAG,GAAuD,CAAC,MAAM;YACvE,MAAM,EAAE,MAAiF;SAC1F,CAAC,CAAC;QACH,sEAAsE;QACtE,sEAAsE;QACtE,yDAAyD;QACzD,sBAAsB,CAAC;YACrB,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;YACpB,MAAM,EAAE,MAAiF;SAC1F,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/channels/telegram-mirror/plan-attachment.d.ts

@@ -0,0 +1,120 @@
+/**
+ * src/channels/telegram-mirror/plan-attachment.ts — v0.25.0 M9.
+ *
+ * When Claude emits ExitPlanMode (the plan-mode tool call), the mirror
+ * uploads the plan body as a .md document attachment with two inline
+ * buttons (Approve / Reject). Decision: ADR-006 — sendDocument over
+ * editMessageMedia. Rationale: sendDocument is simpler, has the larger
+ * size limit, and matches A1's on-disk plan-file convention.
+ *
+ * Approve → callback payload `{ action: 'plan-approve', planId }` resolves
+ * to model input "approved" which the engine bridge feeds to the running
+ * session.
+ *
+ * Reject → two-phase. The first tap stashes a pending-reject for the chat;
+ * the next non-slash inbound message becomes the rejection feedback payload
+ * "<plan rejected>\n<feedback text>". A tap-then-tap-Reject again clears
+ * the pending state silently.
+ *
+ * Risk references: R-3 (callback_data 64-byte cap) — payloads here route
+ * through CallbackMap exactly like M3's keyboard.
+ */
+import type { CallbackMap } from './callback-mapping.js';
+import type { TelegramAction } from './commands.js';
+/**
+ * Shape of the ExitPlanMode tool_use event we care about. Mirrors the
+ * subset of the upstream stream-event shape — keep narrow so future
+ * upstream changes don't ripple here unnecessarily.
+ */
+export interface ExitPlanModeEvent {
+    /** Tool name; always "ExitPlanMode" for this handler. */
+    toolName: string;
+    /** Free-form plan body (Markdown). */
+    plan: string;
+    /** Optional project slug — used in the .md filename. */
+    slug?: string;
+    /** Optional caption to surface above the document on Telegram (kept short). */
+    caption?: string;
+}
+/**
+ * Compose the slug-prefixed plan filename. Sanitises non-filename chars
+ * so the Telegram upload always succeeds.
+ */
+export declare function planFilename(slug: string | undefined): string;
+/**
+ * Build a sendDocument action carrying the plan + the Approve/Reject
+ * inline keyboard. The callback ids are minted into the supplied
+ * CallbackMap; payloads include a fresh planId so multiple in-flight
+ * plans on the same chat don't collide.
+ */
+export declare function buildPlanAttachment(opts: {
+    chatId: string | number;
+    event: ExitPlanModeEvent;
+    callbackMap: CallbackMap;
+    /** Optional planId override for deterministic tests. */
+    planId?: string;
+}): {
+    action: Extract<TelegramAction, {
+        type: 'sendDocument';
+    }>;
+    planId: string;
+};
+interface RejectPending {
+    chatId: string;
+    planId: string;
+    pendingSince: number;
+}
+export interface RejectFeedbackTrackerOptions {
+    /** TTL after which a pending-reject silently expires (default 10 min). */
+    ttlMs?: number;
+    /** Clock for tests. */
+    now?: () => number;
+}
+/**
+ * Tracks the (chatId → pending-reject) state for two-phase rejection.
+ * The dispatch layer pokes startPending on a Reject tap and consumeFeedback
+ * on the next non-slash inbound. Pending-state TTL prevents a half-open
+ * rejection from corrupting later turns.
+ */
+export declare class RejectFeedbackTracker {
+    private readonly pending;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(opts?: RejectFeedbackTrackerOptions);
+    /**
+     * Mark a chat as having tapped Reject and waiting for feedback. If a
+     * prior pending exists, it is replaced (the user re-tapped on a newer plan).
+     */
+    startPending(chatId: string, planId: string): void;
+    /**
+     * Returns true when the chat has a non-stale pending-reject.
+     */
+    isPending(chatId: string): boolean;
+    /**
+     * Consume the next inbound text as the rejection feedback. Returns a
+     * formatted payload that the engine bridge feeds to openai-compat as a
+     * single user-message, or undefined when no pending state exists.
+     *
+     * Payload shape: "<plan rejected: planId>\n<feedback text>" — the
+     * "<plan rejected>" sentinel lets the model recognise this as
+     * rejection feedback (not a new turn).
+     */
+    consumeFeedback(chatId: string, feedback: string): string | undefined;
+    /**
+     * Drop the pending state without consuming feedback (e.g. user taps
+     * Reject twice, or types another slash command in the interim).
+     */
+    cancel(chatId: string): boolean;
+    /**
+     * Inspect pending without consuming. Filters expired entries.
+     */
+    peek(chatId: string): RejectPending | undefined;
+    clear(): void;
+}
+/**
+ * Helper: format the approve payload as engine input. Kept as a function
+ * (not a constant) so future variants — e.g. caching a planId reference —
+ * have a single place to extend.
+ */
+export declare function formatApprovePayload(planId: string): string;
+export {};