shennian 0.2.6 → 0.2.8

package/dist/src/native-fusion/service.d.ts

@@ -0,0 +1,25 @@
+import type { CliRelayClient } from '../relay/client.js';
+export declare class NativeSessionFusionService {
+    private client;
+    private timer;
+    private scanPromise;
+    private pendingClaims;
+    private suppressionWindows;
+    constructor(client: CliRelayClient);
+    start(): void;
+    stop(): void;
+    handleConnected(): void;
+    registerManagedSend(params: {
+        sessionId: string;
+        agentType: string;
+        canonicalMessageId?: string | null;
+        sourceSessionKey?: string | null;
+        text: string;
+    }): void;
+    noteManagedSourceSession(sessionId: string, agentType: string, sourceSessionKey: string | null): void;
+    private pruneState;
+    scanNow(): Promise<void>;
+    private runScan;
+    private tryClaimManagedEcho;
+    private isSuppressed;
+}

package/dist/src/native-fusion/service.js

@@ -0,0 +1,176 @@
+// @arch docs/architecture/cli/native-session-fusion.md
+// @test src/__tests__/native-fusion-parsers.test.ts
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import { listClaudeTranscriptFiles, listCodexRolloutFiles, parseClaudeTranscriptChunk, parseCodexRolloutChunk, } from './parsers.js';
+import { loadNativeScannerState, saveNativeScannerState } from './state.js';
+const SCAN_INTERVAL_MS = 60_000;
+const CLAIM_TTL_MS = SCAN_INTERVAL_MS * 2;
+const MANAGED_RUN_SUPPRESSION_TTL_MS = 30 * 60_000;
+const MAX_BATCH_SIZE = 20;
+function normalizeText(text) {
+    return text.replace(/\r\n/g, '\n').trim();
+}
+export class NativeSessionFusionService {
+    client;
+    timer = null;
+    scanPromise = null;
+    pendingClaims = new Map();
+    suppressionWindows = new Map();
+    constructor(client) {
+        this.client = client;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.scanNow().catch((error) => {
+                console.error('[native-fusion] periodic scan failed', error);
+            });
+        }, SCAN_INTERVAL_MS);
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    handleConnected() {
+        this.start();
+    }
+    registerManagedSend(params) {
+        if (!params.canonicalMessageId)
+            return;
+        if (params.agentType !== 'codex' && params.agentType !== 'claude')
+            return;
+        this.pendingClaims.set(params.sessionId, {
+            sessionId: params.sessionId,
+            agentType: params.agentType,
+            canonicalMessageId: params.canonicalMessageId,
+            text: normalizeText(params.text),
+            createdAt: Date.now(),
+            expiresAt: Date.now() + CLAIM_TTL_MS,
+            sourceSessionKey: params.sourceSessionKey ?? null,
+        });
+    }
+    noteManagedSourceSession(sessionId, agentType, sourceSessionKey) {
+        if (!sourceSessionKey)
+            return;
+        const claim = this.pendingClaims.get(sessionId);
+        if (claim && claim.agentType === agentType) {
+            claim.sourceSessionKey = sourceSessionKey;
+        }
+    }
+    pruneState() {
+        const now = Date.now();
+        for (const [sessionId, claim] of this.pendingClaims.entries()) {
+            if (claim.expiresAt <= now)
+                this.pendingClaims.delete(sessionId);
+        }
+        for (const [key, window] of this.suppressionWindows.entries()) {
+            if (window.endsAt <= now)
+                this.suppressionWindows.delete(key);
+        }
+    }
+    async scanNow() {
+        if (this.client.getState() !== 'connected')
+            return;
+        if (this.scanPromise)
+            return this.scanPromise;
+        this.scanPromise = this.runScan().finally(() => {
+            this.scanPromise = null;
+        });
+        return this.scanPromise;
+    }
+    async runScan() {
+        this.pruneState();
+        const state = loadNativeScannerState();
+        const nextFilesState = { ...state.files };
+        const batches = [];
+        const files = [...listCodexRolloutFiles(), ...listClaudeTranscriptFiles()];
+        for (const filePath of files) {
+            const stat = fs.statSync(filePath);
+            const current = state.files[filePath];
+            const startOffset = current?.offset ?? 0;
+            const parsed = filePath.includes('/.codex/sessions/')
+                ? parseCodexRolloutChunk(filePath, startOffset)
+                : parseClaudeTranscriptChunk(filePath, startOffset);
+            nextFilesState[filePath] = {
+                offset: parsed.nextOffset,
+                mtimeMs: stat.mtimeMs,
+            };
+            for (const event of parsed.events) {
+                const claimed = this.tryClaimManagedEcho(event);
+                if (claimed) {
+                    batches.push(claimed);
+                    continue;
+                }
+                if (this.isSuppressed(event))
+                    continue;
+                batches.push(event);
+            }
+        }
+        for (let index = 0; index < batches.length; index += MAX_BATCH_SIZE) {
+            const chunk = batches.slice(index, index + MAX_BATCH_SIZE);
+            if (chunk.length === 0)
+                continue;
+            await this.client.sendBufferedEvent({
+                type: 'event',
+                event: 'native.session.events',
+                id: `native-fusion-${randomUUID()}`,
+                payload: { events: chunk },
+            }, 60_000);
+        }
+        state.files = nextFilesState;
+        saveNativeScannerState(state);
+    }
+    tryClaimManagedEcho(event) {
+        const now = Date.now();
+        for (const [sessionId, claim] of this.pendingClaims.entries()) {
+            if (claim.agentType !== event.agentType)
+                continue;
+            if (claim.expiresAt <= now)
+                continue;
+            if (event.role !== 'user')
+                continue;
+            if (!claim.sourceSessionKey)
+                continue;
+            if (claim.sourceSessionKey !== event.sourceSessionKey)
+                continue;
+            if (Math.abs(event.ts - claim.createdAt) > CLAIM_TTL_MS)
+                continue;
+            if (normalizeText(event.payload) !== claim.text)
+                continue;
+            this.pendingClaims.delete(sessionId);
+            this.suppressionWindows.set(`${event.agentType}:${event.sourceSessionKey}`, {
+                sessionId,
+                agentType: event.agentType,
+                sourceSessionKey: event.sourceSessionKey,
+                startedAt: event.ts,
+                endsAt: Math.max(now, event.ts) + MANAGED_RUN_SUPPRESSION_TTL_MS,
+            });
+            return {
+                ...event,
+                sourceMode: 'managed_echo_claim',
+                claimCanonicalMessageId: claim.canonicalMessageId,
+            };
+        }
+        return null;
+    }
+    isSuppressed(event) {
+        const key = `${event.agentType}:${event.sourceSessionKey}`;
+        const window = this.suppressionWindows.get(key);
+        if (!window)
+            return false;
+        if (event.ts < window.startedAt)
+            return false;
+        if (event.ts > window.endsAt) {
+            this.suppressionWindows.delete(key);
+            return false;
+        }
+        if (event.role === 'user') {
+            this.suppressionWindows.delete(key);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/src/native-fusion/state.d.ts

@@ -0,0 +1,3 @@
+import type { NativeScannerState } from './types.js';
+export declare function loadNativeScannerState(): NativeScannerState;
+export declare function saveNativeScannerState(state: NativeScannerState): void;

package/dist/src/native-fusion/state.js

@@ -0,0 +1,22 @@
+// @arch docs/architecture/cli/native-session-fusion.md
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveShennianPath } from '../config/index.js';
+const STATE_FILE = resolveShennianPath('native-fusion-state.json');
+export function loadNativeScannerState() {
+    try {
+        const raw = fs.readFileSync(STATE_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.files && typeof parsed.files === 'object') {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore missing or malformed state
+    }
+    return { files: {} };
+}
+export function saveNativeScannerState(state) {
+    fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}

package/dist/src/native-fusion/types.d.ts

@@ -0,0 +1,24 @@
+import type { NativeSessionEventPayload } from '@shennian/wire';
+export type NativeScannerState = {
+    files: Record<string, {
+        offset: number;
+        mtimeMs: number;
+    }>;
+};
+export type ParsedNativeEvent = NativeSessionEventPayload;
+export type PendingManagedClaim = {
+    sessionId: string;
+    agentType: 'codex' | 'claude';
+    canonicalMessageId: string;
+    text: string;
+    createdAt: number;
+    expiresAt: number;
+    sourceSessionKey?: string | null;
+};
+export type ManagedSuppressionWindow = {
+    sessionId: string;
+    agentType: 'codex' | 'claude';
+    sourceSessionKey: string;
+    startedAt: number;
+    endsAt: number;
+};

package/dist/src/native-fusion/types.js

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

package/dist/src/region.d.ts

@@ -0,0 +1,15 @@
+export type Region = 'cn' | 'global';
+export declare const SERVERS: Record<Region, {
+    url: string;
+    label: string;
+}>;
+/**
+ * Detect the best server region and return its URL.
+ *
+ * Strategy: timezone as primary signal, IP geolocation as supplement.
+ * - Chinese timezone → cn immediately (covers servers with UTC too via IP fallback).
+ * - Non-Chinese timezone → try IP to detect if physically in China.
+ */
+export declare function detectAndChooseServer(): Promise<string>;
+export declare function urlToRegion(url: string): Region;
+export declare function regionToUrl(region: Region): string;

package/dist/src/region.js

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+export const SERVERS = {
+    cn: { url: 'https://shennian.net', label: 'China  (shennian.net)' },
+    global: { url: 'https://shennian.ai', label: 'Global (shennian.ai)' },
+};
+const CN_TIMEZONES = [
+    'Asia/Shanghai', 'Asia/Chongqing', 'Asia/Chungking',
+    'Asia/Harbin', 'Asia/Urumqi', 'PRC',
+];
+function inferRegionByTimezone() {
+    try {
+        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (CN_TIMEZONES.includes(tz))
+            return 'cn';
+    }
+    catch { /* Intl unavailable */ }
+    return 'global';
+}
+async function detectRegionByIP(timeoutMs = 1500) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await Promise.any([
+            fetch(`${SERVERS.cn.url}/geo`, { signal: controller.signal }),
+            fetch(`${SERVERS.global.url}/geo`, { signal: controller.signal }),
+        ]);
+        const data = await res.json();
+        return data.country === 'CN' ? 'cn' : 'global';
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function verifyReachable(url, timeoutMs = 3000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        await fetch(`${url}/health`, { signal: controller.signal });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Detect the best server region and return its URL.
+ *
+ * Strategy: timezone as primary signal, IP geolocation as supplement.
+ * - Chinese timezone → cn immediately (covers servers with UTC too via IP fallback).
+ * - Non-Chinese timezone → try IP to detect if physically in China.
+ */
+export async function detectAndChooseServer() {
+    console.log(chalk.gray('  Detecting best server...'));
+    const tzRegion = inferRegionByTimezone();
+    if (tzRegion === 'cn') {
+        const reachable = await verifyReachable(SERVERS.cn.url);
+        if (reachable) {
+            console.log(chalk.gray(`  Using ${SERVERS.cn.label} (timezone: China)`));
+            return SERVERS.cn.url;
+        }
+        const fallback = await verifyReachable(SERVERS.global.url);
+        if (fallback) {
+            console.log(chalk.gray(`  Using ${SERVERS.global.label} (cn unreachable, fallback)`));
+            return SERVERS.global.url;
+        }
+        console.error(chalk.red('  Error: cannot reach any server.'));
+        process.exit(1);
+    }
+    // Non-CN timezone: check IP to catch servers in China with UTC timezone
+    const ipRegion = await detectRegionByIP();
+    const region = ipRegion ?? tzRegion;
+    const reachable = await verifyReachable(SERVERS[region].url);
+    if (reachable) {
+        const source = ipRegion ? 'IP geolocation' : 'timezone';
+        console.log(chalk.gray(`  Using ${SERVERS[region].label} (${source})`));
+        return SERVERS[region].url;
+    }
+    // Fallback to the other server
+    const other = region === 'cn' ? 'global' : 'cn';
+    const fallback = await verifyReachable(SERVERS[other].url);
+    if (fallback) {
+        console.log(chalk.gray(`  Using ${SERVERS[other].label} (fallback)`));
+        return SERVERS[other].url;
+    }
+    console.error(chalk.red('  Error: cannot reach any server.'));
+    process.exit(1);
+}
+export function urlToRegion(url) {
+    return url.includes('shennian.net') ? 'cn' : 'global';
+}
+export function regionToUrl(region) {
+    return SERVERS[region].url;
+}

package/dist/src/relay/client.d.ts

@@ -0,0 +1,62 @@
+import type { ReqFrame, ResFrame, EventFrame } from '@shennian/wire';
+export type CliRelayOptions = {
+    serverUrl: string;
+    machineToken: string;
+    cliVersion?: string;
+    agentList?: string[];
+    onReq?: (req: ReqFrame) => void;
+    onConnected?: () => void;
+    onDisconnected?: (info: CliRelayDisconnectInfo) => void;
+};
+export type CliRelayState = 'connecting' | 'connected' | 'disconnected';
+export type CliRelayDisconnectInfo = {
+    code?: number;
+    reason?: string;
+    error?: string;
+    phase: 'connecting' | 'connected' | 'disconnected';
+    trigger?: 'connect-timeout' | 'pong-timeout' | 'heartbeat-timeout' | 'socket-error' | 'socket-close';
+    reconnectAttempt: number;
+};
+export declare class CliRelayClient {
+    private options;
+    private ws;
+    private state;
+    private reconnectAttempts;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private connectTimer;
+    private pingTimer;
+    private pongTimer;
+    private disposed;
+    private closeTrigger;
+    private lastSocketError;
+    /** Buffered agent events awaiting server ack, keyed by event id */
+    private sendBuffer;
+    private pendingAcks;
+    constructor(options: CliRelayOptions);
+    connect(): void;
+    disconnect(): void;
+    sendRes(res: ResFrame): void;
+    sendEvent(event: EventFrame): void;
+    sendBufferedEvent(event: EventFrame, timeoutMs?: number): Promise<void>;
+    /**
+     * Send an agent event with at-least-once delivery guarantee.
+     * The event is buffered until the server acknowledges it.
+     * On reconnect, all unacked events are resent in order.
+     */
+    sendAgentEvent(event: EventFrame): void;
+    getState(): CliRelayState;
+    private handleFrame;
+    /** Resend all buffered agent events after reconnect, in insertion order */
+    private flushSendBuffer;
+    private bufferEvent;
+    private clearConnectTimer;
+    private startPing;
+    private clearPing;
+    private clearPongTimer;
+    private startHeartbeat;
+    private resetHeartbeat;
+    private clearHeartbeat;
+    private scheduleReconnect;
+    private cleanup;
+}