lark-remote 0.1.6 → 0.1.8

package/dist/session/dsh/sessions.js

@@ -0,0 +1,237 @@
+/**
+ * DshSessionReader — AgentSessionReader backed by the DSH Web Host over HTTP.
+ *
+ * The AgentSessionReader contract is fully synchronous (file-style readers),
+ * but DSH exposes only async HTTP. The reader therefore bridges with
+ * `spawnSync('curl', ...)` for its unary calls (session.list / session.history)
+ * — a synchronous HTTP round-trip to the local DSH host. This keeps the
+ * router/bridge interface contract intact without touching any upstream logic.
+ *
+ * listSessions: session.list → filter by cwd → sort by updatedAt desc → local
+ *   pagination (DSH v1 has no cursor pagination).
+ * readSessionContent: session.history → map SessionEvents to display events +
+ *   session-wide usage accumulation (assistant/message.usage).
+ */
+import { spawnSync } from 'node:child_process';
+import { getLogger } from '../../logger/index.js';
+import { DEFAULT_DSH_HOST } from '../../config/index.js';
+import { capEvents, paginate } from '../common/pagination.js';
+import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
+/** Synchronous unary POST via curl (the reader interface is synchronous). */
+function defaultSyncRequest(baseUrl, method, payload) {
+    const body = JSON.stringify({
+        type: 'client-request',
+        rpcId: `rpc-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+        method,
+        payload,
+    });
+    const res = spawnSync('curl', [
+        '-s',
+        '-X',
+        'POST',
+        `${baseUrl}/api/${method}`,
+        '-H',
+        'content-type: application/json',
+        '--data',
+        body,
+    ], { encoding: 'utf-8', timeout: 15_000, maxBuffer: 64 * 1024 * 1024 });
+    if (res.error || res.status !== 0) {
+        throw new Error(`DSH ${method} failed: ${(res.error?.message ?? res.stderr) || 'unknown'}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(res.stdout);
+    }
+    catch (err) {
+        throw new Error(`DSH ${method} returned non-JSON: ${err.message}`, {
+            cause: err,
+        });
+    }
+    if (parsed.result?.ok !== true) {
+        throw new Error(parsed.result?.error?.message ?? `DSH ${method} failed`);
+    }
+    return parsed.result.value;
+}
+export class DshSessionReader {
+    baseUrl;
+    syncRequest;
+    constructor(opts = {}) {
+        this.baseUrl = (opts.host ?? DEFAULT_DSH_HOST).replace(/\/$/, '');
+        this.syncRequest = opts.syncRequest ?? defaultSyncRequest;
+    }
+    unary(method, payload) {
+        return this.syncRequest(this.baseUrl, method, payload);
+    }
+    listSessions(cwd, opts) {
+        try {
+            const value = this.unary('session.list', {});
+            const items = value.items ?? [];
+            const filtered = items
+                .filter((i) => i.cwd === cwd)
+                .sort((a, b) => b.updatedAt - a.updatedAt || String(a.sessionId).localeCompare(String(b.sessionId)))
+                .map((i) => ({
+                sessionId: String(i.sessionId),
+                summary: '',
+                mtime: i.updatedAt,
+                ...(i.agentPreset ? { agentPreset: i.agentPreset } : {}),
+            }));
+            const { items: page, total } = paginate(filtered, opts ?? {});
+            return { sessions: page, total };
+        }
+        catch (error) {
+            getLogger().error(`[dsh-session-reader] listSessions error: ${error.message}`);
+            return { sessions: [], total: 0 };
+        }
+    }
+    getNewestSession(cwd) {
+        return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
+    }
+    readSessionContent(sessionId, cwd, opts) {
+        try {
+            const value = this.unary('session.history', {
+                sessionId,
+                maxMessages: opts?.maxEvents ?? 50,
+            });
+            const events = [];
+            let displayTitle;
+            let cumInput = 0;
+            let cumOutput = 0;
+            let cumCacheRead = 0;
+            let cumCacheWrite = 0;
+            let lastUsage;
+            for (const entry of value.events ?? []) {
+                const ev = entry.event;
+                if (!ev)
+                    continue;
+                const contentEvents = mapEvent(ev);
+                events.push(...contentEvents.events);
+                if (contentEvents.title)
+                    displayTitle = contentEvents.title;
+                const u = contentEvents.usage;
+                if (u) {
+                    // Cumulative (session-wide): sum across ALL assistant/message usage.
+                    cumInput += u.inputTokens ?? 0;
+                    cumOutput += u.outputTokens ?? 0;
+                    cumCacheRead += u.cacheReadTokens ?? 0;
+                    cumCacheWrite += u.cacheWriteTokens ?? 0;
+                    // Per-turn "current window" fields reflect the LAST assistant/message
+                    // with usage (ccusage/`last_token_usage` 口径, AGENTS.md §9.21) — a
+                    // multi-turn session's current context water-mark is the last turn's,
+                    // not the accumulated total.
+                    lastUsage = u;
+                }
+            }
+            let sessionUsage;
+            if (lastUsage) {
+                const input = lastUsage.inputTokens ?? 0;
+                const output = lastUsage.outputTokens ?? 0;
+                const cacheRead = lastUsage.cacheReadTokens ?? 0;
+                const cacheWrite = lastUsage.cacheWriteTokens ?? 0;
+                sessionUsage = {
+                    inputTokens: input,
+                    outputTokens: output,
+                    contextLength: input + cacheRead + cacheWrite,
+                    cacheReadTokens: cacheRead,
+                    cacheCreationTokens: cacheWrite,
+                    totalTokens: input + output + cacheRead + cacheWrite,
+                    cumulativeTotalTokens: cumInput + cumOutput + cumCacheRead + cumCacheWrite,
+                    cumulativeInputTokens: cumInput,
+                    cumulativeOutputTokens: cumOutput,
+                    cumulativeCacheReadTokens: cumCacheRead,
+                    cumulativeCacheCreationTokens: cumCacheWrite,
+                };
+            }
+            return {
+                events: capEvents(events, opts?.maxEvents),
+                ...(sessionUsage ? { usage: sessionUsage } : {}),
+                ...(displayTitle ? { displayTitle } : {}),
+            };
+        }
+        catch (error) {
+            getLogger().error(`[dsh-session-reader] readSessionContent error: ${error.message}`);
+            return { events: [] };
+        }
+    }
+    isSessionActive(sessionId, cwd) {
+        try {
+            const value = this.unary('session.list', {});
+            const found = (value.items ?? []).find((i) => String(i.sessionId) === sessionId && i.cwd === cwd);
+            return found?.running === true;
+        }
+        catch (error) {
+            getLogger().error(`[dsh-session-reader] isSessionActive error: ${error.message}`);
+            return false;
+        }
+    }
+}
+/** Map one DSH SessionEvent to display content events (+ title/usage side effects). */
+function mapEvent(ev) {
+    const out = { events: [] };
+    switch (ev.type) {
+        case 'user/message': {
+            const content = ev.data.content ?? [];
+            const text = content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text ?? '')
+                .join('');
+            out.events.push({ type: 'user', content: text, timestamp: new Date(ev.time).toISOString() });
+            break;
+        }
+        case 'assistant/message': {
+            const content = ev.data.message
+                ?.content ?? [];
+            const text = content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text ?? '')
+                .join('');
+            if (text)
+                out.events.push({
+                    type: 'assistant',
+                    content: text,
+                    timestamp: new Date(ev.time).toISOString(),
+                });
+            const usage = ev.data.usage;
+            if (usage && typeof usage === 'object')
+                out.usage = usage;
+            break;
+        }
+        case 'tool/call': {
+            const name = String(ev.data.name ?? '');
+            const args = typeof ev.data.arguments === 'string' ? ev.data.arguments : '';
+            out.events.push({
+                type: 'tool_use',
+                content: `${name}(${truncateUtf8(args, 200)})`,
+                timestamp: new Date(ev.time).toISOString(),
+            });
+            break;
+        }
+        case 'tool/result': {
+            const msg = ev.data.message;
+            const raw = stringifyContent(msg?.content);
+            out.events.push({
+                type: 'tool_result',
+                content: truncateUtf8(raw, TOOL_RESULT_MAX_BYTES),
+                timestamp: new Date(ev.time).toISOString(),
+            });
+            break;
+        }
+        default:
+            break;
+    }
+    return out;
+}
+function stringifyContent(content) {
+    if (content == null)
+        return '[tool result]';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c) => c && typeof c === 'object' && 'text' in c
+            ? String(c.text)
+            : JSON.stringify(c))
+            .join('');
+    }
+    return JSON.stringify(content);
+}
+//# sourceMappingURL=sessions.js.map

package/dist/session/index.d.ts

@@ -5,3 +5,4 @@ export { CodexSessionReader } from './codex/index.js';
 export { OpencodeSessionReader } from './opencode/index.js';
 export { PiSessionReader } from './pi/index.js';
 export { KimiSessionReader } from './kimi/index.js';
+export { DshSessionReader } from './dsh/index.js';

package/dist/session/index.js

@@ -8,4 +8,5 @@ export { CodexSessionReader } from './codex/index.js';
 export { OpencodeSessionReader } from './opencode/index.js';
 export { PiSessionReader } from './pi/index.js';
 export { KimiSessionReader } from './kimi/index.js';
+export { DshSessionReader } from './dsh/index.js';
 //# sourceMappingURL=index.js.map

package/dist/session/kimi/sessions.d.ts

@@ -9,6 +9,25 @@ export interface KimiSessionState {
     cwd?: string;
     lastPrompt?: string;
 }
+/**
+ * Compaction completion record in wire.jsonl (§6.3 / kimi-code wire-manifest).
+ *
+ * REAL shape (2026-08-16 实弹 wire.jsonl + kimi-code 源码)：
+ * - `context.apply_compaction`：带 `compactedCount` / `tokensBefore` /
+ *   `tokensAfter`（以及 summary 等）；
+ * - `full_compaction.complete`：只有 `{type, time}`。
+ * `messagesCompacted` 是死字段，真实 record 里不存在——禁止再写。
+ */
+export interface KimiCompactionRecord {
+    type: 'full_compaction.complete' | 'context.apply_compaction';
+    /** 压缩掉的消息条数（仅 context.apply_compaction 携带）。 */
+    compactedCount?: number;
+    /** 压缩前上下文 token 水位（仅 context.apply_compaction 携带）。 */
+    tokensBefore?: number;
+    /** 压缩后上下文 token 水位（仅 context.apply_compaction 携带）。 */
+    tokensAfter?: number;
+    time: number;
+}
 /** Detect schema version from state.json content */
 export declare function detectSchemaVersion(state: KimiSessionState): 1 | 2;
 /**
@@ -76,8 +95,22 @@ export declare class KimiSessionReader implements AgentSessionReader {
     readSessionContent(sessionId: string, cwd: string, opts?: {
         maxEvents?: number;
     }): SessionContent;
+    /**
+     * Read the compaction records (context.apply_compaction /
+     * full_compaction.complete) from a session's wire.jsonl.
+     *
+     * Same cwd guard as readSessionContent. Used by KimiAcpRunner.runCompact
+     * (R2) to wait for the background compaction to land before ending the run.
+     */
+    readCompactionRecords(sessionId: string, cwd: string): KimiCompactionRecord[];
+    /**
+     * Resolve the main wire.jsonl path for a session after passing the cwd
+     * guard (state.json + session index fallback). Returns null when the
+     * session is unknown, fails the guard, or has no wire file.
+     */
+    private resolveSessionWirePath;
     /**
      * Check if a session is currently active
      */
-    isSessionActive(sessionId: string, _cwd: string): boolean;
+    isSessionActive(sessionId: string, cwd: string): boolean;
 }