@foxden-app/foxclaw 0.2.0

package/dist/controller/session_observer.js

@@ -0,0 +1,259 @@
+import { classifyAgentOutput, inferToolActivityState, } from './activity.js';
+export function splitJsonlChunk(remainder, chunk) {
+    const text = `${remainder}${chunk}`;
+    if (text.length === 0) {
+        return { lines: [], remainder: '' };
+    }
+    const parts = text.split('\n');
+    const nextRemainder = text.endsWith('\n') ? '' : parts.pop() ?? '';
+    return {
+        lines: parts.filter(line => line.trim().length > 0),
+        remainder: nextRemainder,
+    };
+}
+export function bootstrapSessionLog(lines) {
+    const records = parseRecords(lines);
+    let activeTurnId = null;
+    let nextMessageIndex = 0;
+    let events = [];
+    for (const record of records) {
+        const next = applySessionRecord(record, { activeTurnId, nextMessageIndex });
+        if (next.startedTurnId) {
+            activeTurnId = next.startedTurnId;
+            nextMessageIndex = 0;
+            events = [];
+            continue;
+        }
+        if (!activeTurnId) {
+            continue;
+        }
+        if (next.turnCompleted) {
+            activeTurnId = null;
+            nextMessageIndex = 0;
+            events = [];
+            continue;
+        }
+        events.push(...next.events);
+        activeTurnId = next.cursor.activeTurnId;
+        nextMessageIndex = next.cursor.nextMessageIndex;
+    }
+    return {
+        cursor: { activeTurnId, nextMessageIndex },
+        events,
+        startedTurnId: activeTurnId,
+    };
+}
+export function applySessionLog(lines, cursor) {
+    const records = parseRecords(lines);
+    let state = { ...cursor };
+    const events = [];
+    const startedTurnIds = [];
+    for (const record of records) {
+        const next = applySessionRecord(record, state);
+        if (next.startedTurnId) {
+            state = {
+                activeTurnId: next.startedTurnId,
+                nextMessageIndex: 0,
+            };
+            startedTurnIds.push(next.startedTurnId);
+            continue;
+        }
+        events.push(...next.events);
+        state = next.cursor;
+    }
+    return {
+        cursor: state,
+        events,
+        startedTurnIds,
+    };
+}
+function parseRecords(lines) {
+    const records = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed && typeof parsed.type === 'string') {
+                records.push(parsed);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return records;
+}
+function applySessionRecord(record, cursor) {
+    const { type, payload } = record;
+    if (type === 'event_msg' && payload?.type === 'task_started' && typeof payload.turn_id === 'string') {
+        return {
+            cursor: { activeTurnId: payload.turn_id, nextMessageIndex: 0 },
+            events: [],
+            startedTurnId: payload.turn_id,
+            turnCompleted: false,
+        };
+    }
+    const activeTurnId = cursor.activeTurnId;
+    if (!activeTurnId) {
+        return {
+            cursor,
+            events: [],
+            startedTurnId: null,
+            turnCompleted: false,
+        };
+    }
+    if (type === 'event_msg' && payload?.type === 'agent_message' && typeof payload.message === 'string') {
+        return createSessionTextEvents(activeTurnId, cursor, payload.message, typeof payload.phase === 'string' ? payload.phase : null, false);
+    }
+    if (type === 'response_item' && payload?.type === 'plan' && typeof payload.text === 'string') {
+        return createSessionTextEvents(activeTurnId, cursor, payload.text, 'commentary', true, true);
+    }
+    if (type === 'event_msg' && payload?.type === 'user_message' && typeof payload.message === 'string') {
+        const text = payload.message.trim();
+        if (!text) {
+            return { cursor, events: [], startedTurnId: null, turnCompleted: false };
+        }
+        return {
+            cursor,
+            events: [{
+                    kind: 'user_message',
+                    turnId: activeTurnId,
+                    text,
+                }],
+            startedTurnId: null,
+            turnCompleted: false,
+        };
+    }
+    if (type === 'response_item' && payload?.type === 'function_call' && payload?.name === 'exec_command') {
+        const exec = createExecStartEvent(activeTurnId, payload);
+        if (!exec) {
+            return { cursor, events: [], startedTurnId: null, turnCompleted: false };
+        }
+        return {
+            cursor,
+            events: [{
+                    kind: 'tool_started',
+                    turnId: activeTurnId,
+                    exec,
+                    state: inferToolActivityState(exec),
+                }],
+            startedTurnId: null,
+            turnCompleted: false,
+        };
+    }
+    if (type === 'event_msg' && payload?.type === 'exec_command_end' && payload?.turn_id === activeTurnId) {
+        const exec = createExecEndEvent(payload);
+        if (!exec) {
+            return { cursor, events: [], startedTurnId: null, turnCompleted: false };
+        }
+        return {
+            cursor,
+            events: [{
+                    kind: 'tool_completed',
+                    turnId: activeTurnId,
+                    exec,
+                    state: inferToolActivityState(exec),
+                }],
+            startedTurnId: null,
+            turnCompleted: false,
+        };
+    }
+    if (type === 'event_msg' && payload?.type === 'task_complete' && payload?.turn_id === activeTurnId) {
+        return {
+            cursor: { activeTurnId: null, nextMessageIndex: 0 },
+            events: [{
+                    kind: 'turn_completed',
+                    turnId: activeTurnId,
+                    state: 'completed',
+                }],
+            startedTurnId: null,
+            turnCompleted: true,
+        };
+    }
+    return {
+        cursor,
+        events: [],
+        startedTurnId: null,
+        turnCompleted: false,
+    };
+}
+function buildSessionItemId(turnId, index) {
+    return `${turnId}:session:${index}`;
+}
+function createSessionTextEvents(activeTurnId, cursor, text, phase, forceCommentary, isPlan = false) {
+    const itemId = buildSessionItemId(activeTurnId, cursor.nextMessageIndex + 1);
+    const outputKind = forceCommentary ? 'commentary' : classifyAgentOutput(phase, true);
+    const streamOutputKind = forceCommentary ? 'commentary' : classifyAgentOutput(phase, false);
+    return {
+        cursor: {
+            activeTurnId,
+            nextMessageIndex: cursor.nextMessageIndex + 1,
+        },
+        events: [
+            {
+                kind: 'agent_message_started',
+                turnId: activeTurnId,
+                itemId,
+                phase,
+                outputKind: streamOutputKind,
+                isPlan,
+            },
+            {
+                kind: 'agent_message_delta',
+                turnId: activeTurnId,
+                itemId,
+                delta: text,
+                outputKind: streamOutputKind,
+                isPlan,
+            },
+            {
+                kind: 'agent_message_completed',
+                turnId: activeTurnId,
+                itemId,
+                phase,
+                text,
+                outputKind,
+                isPlan,
+            },
+        ],
+        startedTurnId: null,
+        turnCompleted: false,
+    };
+}
+function createExecStartEvent(turnId, payload) {
+    const callId = typeof payload.call_id === 'string' ? payload.call_id : null;
+    if (!callId) {
+        return null;
+    }
+    let args = null;
+    if (typeof payload.arguments === 'string') {
+        try {
+            args = JSON.parse(payload.arguments);
+        }
+        catch {
+            args = null;
+        }
+    }
+    const commandText = typeof args?.cmd === 'string' ? args.cmd : null;
+    const cwd = typeof args?.workdir === 'string' ? args.workdir : null;
+    return {
+        callId,
+        turnId,
+        command: commandText ? ['/bin/bash', '-lc', commandText] : [],
+        cwd,
+        parsedCmd: [],
+    };
+}
+function createExecEndEvent(payload) {
+    const callId = typeof payload.call_id === 'string' ? payload.call_id : null;
+    const turnId = typeof payload.turn_id === 'string' ? payload.turn_id : null;
+    if (!callId || !turnId) {
+        return null;
+    }
+    return {
+        callId,
+        turnId,
+        command: Array.isArray(payload.command) ? payload.command.map((entry) => String(entry)) : [],
+        cwd: typeof payload.cwd === 'string' ? payload.cwd : null,
+        parsedCmd: Array.isArray(payload.parsed_cmd) ? payload.parsed_cmd : [],
+    };
+}

package/dist/controller/status.d.ts

@@ -0,0 +1,10 @@
+import type { AppLocale, PendingApprovalRecord } from '../types.js';
+export interface ActiveTurnStatusSnapshot {
+    interruptRequested: boolean;
+    pendingApprovalKinds: ReadonlySet<PendingApprovalRecord['kind']>;
+    toolStatusText: string | null;
+    reasoningActive: boolean;
+    hasStreamingReply: boolean;
+}
+export declare function renderActiveTurnStatus(locale: AppLocale, snapshot: ActiveTurnStatusSnapshot): string;
+export declare function formatApprovalKinds(locale: AppLocale, kinds: ReadonlySet<PendingApprovalRecord['kind']>): string;

package/dist/controller/status.js

@@ -0,0 +1,28 @@
+import { t } from '../i18n.js';
+export function renderActiveTurnStatus(locale, snapshot) {
+    if (snapshot.interruptRequested) {
+        return t(locale, 'interrupt_requested_waiting');
+    }
+    if (snapshot.pendingApprovalKinds.size > 0) {
+        return t(locale, 'approval_requested', { kind: formatApprovalKinds(locale, snapshot.pendingApprovalKinds) });
+    }
+    if (snapshot.toolStatusText) {
+        return snapshot.toolStatusText;
+    }
+    if (snapshot.reasoningActive) {
+        return locale === 'zh' ? '正在思考...' : 'Thinking...';
+    }
+    if (snapshot.hasStreamingReply) {
+        return locale === 'zh' ? '正在回复...' : 'Streaming reply...';
+    }
+    return locale === 'zh' ? '正在思考...' : 'Thinking...';
+}
+export function formatApprovalKinds(locale, kinds) {
+    const values = [...kinds].map(kind => locale === 'zh'
+        ? kind === 'fileChange' ? '文件修改' : kind === 'permissions' ? '权限扩展' : '命令执行'
+        : kind === 'fileChange' ? 'file change' : kind === 'permissions' ? 'permissions' : 'command');
+    if (values.length === 0) {
+        return locale === 'zh' ? '审批' : 'approval';
+    }
+    return values.join(locale === 'zh' ? '、' : ', ');
+}

package/dist/core/bridge_scope.d.ts

@@ -0,0 +1,18 @@
+import { type TelegramScope } from '../telegram/scope.js';
+/** Prefix for Telegram-derived bridge session keys (stored in SQLite `chat_id` / `scope_id` columns). */
+export declare const BRIDGE_SCOPE_TELEGRAM_PREFIX = "telegram:";
+/** Weixin iLink scopes: `weixin:<accountId>:<from_user_id>`. */
+export declare const BRIDGE_SCOPE_WEIXIN_PREFIX = "weixin:";
+export interface WeixinBridgeScope {
+    accountId: string;
+    fromUserId: string;
+}
+export declare function isBridgeScopedKey(key: string): boolean;
+/** Wrap legacy Telegram inner scope (`chat::topic`) for storage and routing. */
+export declare function toTelegramBridgeScopeId(telegramInnerScopeId: string): string;
+/** Strip `telegram:` prefix; returns `null` if not a Telegram bridge scope. */
+export declare function telegramInnerScopeFromBridge(bridgeScopeId: string): string | null;
+export declare function parseTelegramTargetFromBridgeScope(bridgeScopeId: string): TelegramScope;
+/** Parse `weixin:<accountId>:<from_user_id>`; returns `null` if not a Weixin scope. */
+export declare function parseWeixinBridgeScope(bridgeScopeId: string): WeixinBridgeScope | null;
+export declare function toWeixinBridgeScopeId(accountId: string, fromUserId: string): string;

package/dist/core/bridge_scope.js

@@ -0,0 +1,46 @@
+import { parseTelegramScopeId } from '../telegram/scope.js';
+/** Prefix for Telegram-derived bridge session keys (stored in SQLite `chat_id` / `scope_id` columns). */
+export const BRIDGE_SCOPE_TELEGRAM_PREFIX = 'telegram:';
+/** Weixin iLink scopes: `weixin:<accountId>:<from_user_id>`. */
+export const BRIDGE_SCOPE_WEIXIN_PREFIX = 'weixin:';
+export function isBridgeScopedKey(key) {
+    return key.startsWith(BRIDGE_SCOPE_TELEGRAM_PREFIX) || key.startsWith(BRIDGE_SCOPE_WEIXIN_PREFIX);
+}
+/** Wrap legacy Telegram inner scope (`chat::topic`) for storage and routing. */
+export function toTelegramBridgeScopeId(telegramInnerScopeId) {
+    return `${BRIDGE_SCOPE_TELEGRAM_PREFIX}${telegramInnerScopeId}`;
+}
+/** Strip `telegram:` prefix; returns `null` if not a Telegram bridge scope. */
+export function telegramInnerScopeFromBridge(bridgeScopeId) {
+    if (!bridgeScopeId.startsWith(BRIDGE_SCOPE_TELEGRAM_PREFIX)) {
+        return null;
+    }
+    return bridgeScopeId.slice(BRIDGE_SCOPE_TELEGRAM_PREFIX.length);
+}
+export function parseTelegramTargetFromBridgeScope(bridgeScopeId) {
+    const inner = telegramInnerScopeFromBridge(bridgeScopeId);
+    if (inner === null) {
+        throw new Error(`Expected ${BRIDGE_SCOPE_TELEGRAM_PREFIX} scope, got: ${bridgeScopeId}`);
+    }
+    return parseTelegramScopeId(inner);
+}
+/** Parse `weixin:<accountId>:<from_user_id>`; returns `null` if not a Weixin scope. */
+export function parseWeixinBridgeScope(bridgeScopeId) {
+    if (!bridgeScopeId.startsWith(BRIDGE_SCOPE_WEIXIN_PREFIX)) {
+        return null;
+    }
+    const rest = bridgeScopeId.slice(BRIDGE_SCOPE_WEIXIN_PREFIX.length);
+    const firstColon = rest.indexOf(':');
+    if (firstColon === -1) {
+        return null;
+    }
+    const accountId = rest.slice(0, firstColon);
+    const fromUserId = rest.slice(firstColon + 1);
+    if (!accountId || !fromUserId) {
+        return null;
+    }
+    return { accountId, fromUserId };
+}
+export function toWeixinBridgeScopeId(accountId, fromUserId) {
+    return `${BRIDGE_SCOPE_WEIXIN_PREFIX}${accountId}:${fromUserId}`;
+}

package/dist/core/channel_port.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Opaque outbound message handle for the active UI surface (Telegram message id, Weixin id, etc.).
+ */
+export type ChannelMessageRef = number | string;
+export type ChannelInlineKeyboard = Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+/**
+ * Future: channel-agnostic outbound surface. Telegram uses {@link TelegramMessagingPort} today.
+ */
+export interface ChannelPort {
+    sendPlain(scopeId: string, text: string, keyboard?: ChannelInlineKeyboard): Promise<ChannelMessageRef>;
+    sendHtml(scopeId: string, text: string, keyboard?: ChannelInlineKeyboard): Promise<ChannelMessageRef>;
+}

package/dist/core/channel_port.js

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