lark-remote 0.5.4 → 0.5.5

package/dist/session/dsh/sessions.js

@@ -3,14 +3,15 @@
  *
  * 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)
+ * `spawnSync('curl', ...)` for its unary calls (session/list / session/page)
  * — 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
+ * 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).
+ * readSessionContent: session/projections → session/page → map SessionEvents +
+ *   session-wide usage accumulation (assistant/message.usage)；本 run 的 flow
+ *   字段 = 末个 turn（turn/start–turn/end）内所有采样之和，与 codex 同口径。
  */
 import { spawnProcessSync } from '../../platform/spawn.js';
 import { cumulativeUsageFields } from '../common/usage-accumulator.js';
@@ -18,22 +19,25 @@ import { sortByRecencyDesc } from '../common/recency.js';
 import { getLogger } from '../../logger/index.js';
 import { DEFAULT_DSH_HOST } from '../../config/index.js';
 import { samePath } from '../../platform/path.js';
+import { isWin32 } from '../../platform/select.js';
+import { dshArgs, extractDshToken } from '../../runner/dsh/client.js';
+import { DSH_COOKIE_LIFETIME_MS, isDshCredentialsNotFound, mintDshBrowserCookie, readDshBrowserSecretSync, resolveDshCredentialsFile, } from '../../runner/dsh/auth.js';
 import { capEvents, paginate } from '../common/pagination.js';
 import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
 /**
- * history 拉取上限。DSH session.history 的 maxMessages 同时限制返回条数，
+ * history 拉取上限。DSH session/page 的 maxMessages 同时限制返回条数，
  * 若用它同时充当展示截断，>50 事件的会话累计 usage 会少算。这里拉取一个足够大的
  * 上限保证 usage 累加覆盖整个会话；展示仍由 capEvents(opts?.maxEvents ?? 50) 截断。
  * （若 DSH 支持分页 cursor 可改成分页，当前用有界大拉取）
  */
 const DSH_HISTORY_FETCH_LIMIT = 10_000;
 /** Synchronous unary POST via curl (the reader interface is synchronous). */
-function defaultSyncRequest(baseUrl, method, payload) {
+function defaultSyncRequest(baseUrl, method, payload, cookie) {
     const body = JSON.stringify({
         type: 'client-request',
         rpcId: `rpc-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
         method,
-        payload,
+        payload: { args: dshArgs(method, payload) },
     });
     const res = spawnProcessSync('curl', [
         '-s',
@@ -42,6 +46,7 @@ function defaultSyncRequest(baseUrl, method, payload) {
         `${baseUrl}/api/${method}`,
         '-H',
         'content-type: application/json',
+        ...(cookie ? ['-H', `Cookie: ${cookie}`] : []),
         '--data',
         body,
     ], { encoding: 'utf-8', timeout: 15_000, maxBuffer: 64 * 1024 * 1024 });
@@ -62,25 +67,105 @@ function defaultSyncRequest(baseUrl, method, payload) {
     }
     return parsed.result.value;
 }
+/** Synchronous index bootstrap; returns the v1 `name=value` cookie pair. */
+function defaultSyncConnect(baseUrl, token) {
+    const url = `${baseUrl}/?token=${encodeURIComponent(token)}`;
+    const res = spawnProcessSync('curl', ['-sS', '-D', '-', '-o', isWin32() ? 'NUL' : '/dev/null', '--max-time', '5', url], { encoding: 'utf-8', timeout: 10_000, maxBuffer: 1024 * 1024 });
+    if (res.error || res.status !== 0) {
+        throw new Error(`DSH auth failed: ${(res.error?.message ?? res.stderr) || 'unknown'}`);
+    }
+    const header = String(res.stdout);
+    const match = header.match(/^set-cookie:\s*(.+)$/im);
+    const cookie = match?.[1]?.split(';')[0]?.trim();
+    if (!cookie)
+        throw new Error('DSH auth failed: index handshake did not return a cookie');
+    return cookie;
+}
 export class DshSessionReader {
     hostProvider;
+    dshHomeProvider;
+    tokenProvider;
+    credentialsFileProvider;
+    readCredentials;
+    now;
+    cookieLifetimeMs;
     syncRequest;
+    syncConnect;
+    cookieCache = new Map();
     constructor(opts = {}) {
         const fixed = (opts.host ?? DEFAULT_DSH_HOST).replace(/\/$/, '');
         this.hostProvider = opts.hostProvider ?? (() => fixed);
+        this.dshHomeProvider = opts.dshHomeProvider ?? (() => undefined);
+        const fixedToken = opts.token;
+        this.tokenProvider = opts.tokenProvider ?? (() => fixedToken);
+        const fixedCredentialsFile = opts.credentialsFile;
+        this.credentialsFileProvider = opts.credentialsFileProvider ?? (() => fixedCredentialsFile);
+        this.readCredentials = opts.readCredentials ?? readDshBrowserSecretSync;
+        this.now = opts.now ?? Date.now;
+        this.cookieLifetimeMs = opts.cookieLifetimeMs ?? DSH_COOKIE_LIFETIME_MS;
         this.syncRequest = opts.syncRequest ?? defaultSyncRequest;
+        this.syncConnect = opts.syncConnect ?? defaultSyncConnect;
     }
     /** 解析当前 host（hostProvider 优先，允许 /config 热改 host）。 */
     resolveBaseUrl() {
         const host = this.hostProvider();
         return (host && host.length > 0 ? host : DEFAULT_DSH_HOST).replace(/\/$/, '');
     }
+    resolveCredentialsFile() {
+        return (this.credentialsFileProvider()?.trim() ||
+            resolveDshCredentialsFile(process.env, this.dshHomeProvider()));
+    }
     unary(method, payload) {
-        return this.syncRequest(this.resolveBaseUrl(), method, payload);
+        const baseUrl = this.resolveBaseUrl();
+        try {
+            return this.syncRequest(baseUrl, method, payload, this.resolveCookie());
+        }
+        catch {
+            // DSH may have restarted while lark-remote cached a token-derived cookie.
+            // Re-read the credentials file and retry once with a fresh cookie.
+            this.cookieCache.clear();
+            return this.syncRequest(baseUrl, method, payload, this.resolveCookie());
+        }
+    }
+    /** Mint from the durable secret, or bootstrap and cache a token cookie. */
+    resolveCookie() {
+        const baseUrl = this.resolveBaseUrl();
+        const fromCredentials = this.cookieFromCredentials(baseUrl);
+        if (fromCredentials)
+            return fromCredentials;
+        const token = extractDshToken(this.tokenProvider());
+        if (!token)
+            return undefined;
+        const key = `${baseUrl}\u0000${token}`;
+        const cached = this.cookieCache.get(key);
+        if (cached)
+            return cached;
+        const cookie = this.syncConnect(baseUrl, token);
+        this.cookieCache.set(key, cookie);
+        return cookie;
+    }
+    cookieFromCredentials(baseUrl) {
+        const credentialsFile = this.resolveCredentialsFile();
+        try {
+            const secret = this.readCredentials(credentialsFile);
+            return mintDshBrowserCookie(baseUrl, secret, this.now(), this.cookieLifetimeMs);
+        }
+        catch (err) {
+            if (isDshCredentialsNotFound(err))
+                return undefined;
+            if (extractDshToken(this.tokenProvider())) {
+                getLogger().warn(`[dsh-session-reader] cannot use DSH credentials file ${credentialsFile}: ` +
+                    `${err.message}; falling back to the launch token`);
+                return undefined;
+            }
+            throw new Error(`DSH auth credentials file ${credentialsFile}: ${err.message}`, {
+                cause: err,
+            });
+        }
     }
     listSessions(cwd, opts) {
         try {
-            const value = this.unary('session.list', {});
+            const value = this.unary('session/list', {});
             const items = value.items ?? [];
             const filtered = items
                 .filter((i) => i.cwd !== undefined && samePath(i.cwd, cwd))
@@ -88,7 +173,7 @@ export class DshSessionReader {
                 sessionId: String(i.sessionId),
                 summary: '',
                 mtime: i.updatedAt,
-                ...(i.agentPreset ? { agentPreset: i.agentPreset } : {}),
+                ...sessionPreset(i),
             }));
             sortByRecencyDesc(filtered, (i) => i.mtime, (i) => i.sessionId);
             const { items: page, total } = paginate(filtered, opts ?? {});
@@ -102,10 +187,21 @@ export class DshSessionReader {
     getNewestSession(cwd) {
         return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
     }
-    readSessionContent(sessionId, _cwd, opts) {
+    readSessionContent(sessionId, cwd, opts) {
         try {
-            const value = this.unary('session.history', {
-                sessionId,
+            // cwd 守卫：sessionId 可能属于另一个 workspace。
+            // 只按 id 查 history 会让 /resume 把 cwd A 的卡片绑到 cwd B 的会话上，
+            // agent 实际在 B 操作文件、resume.compact 还会压缩别人的会话。与
+            // Claude/Kimi/Pi 的 cwd 守卫同口径：找不到同 cwd 的会话 → 空内容（fail-closed）。
+            const session = this.resolveSession(sessionId, cwd);
+            if (!session) {
+                getLogger().warn(`[dsh-session-reader] readSessionContent: session ${sessionId} not found in cwd ${cwd}, refusing cross-workspace read`);
+                return { events: [] };
+            }
+            const throughSeq = this.resolveThroughSeq(sessionId, session);
+            const value = this.unary('session/page', {
+                address: { kind: 'session', sessionId },
+                throughSeq,
                 maxMessages: DSH_HISTORY_FETCH_LIMIT,
             });
             const events = [];
@@ -115,10 +211,25 @@ export class DshSessionReader {
             let cumCacheRead = 0;
             let cumCacheWrite = 0;
             let lastUsage;
-            for (const entry of value.events ?? []) {
+            // 末个 turn 内各采样用量之和（"本 run / 末轮" scope）。DSH 每次模型调用
+            // 一条 usage，工具往返的 turn 会写多条 assistant/message；只取末条会把
+            // 多步 run 低报（实测 231/689 显示成整轮真实消耗）。turn 边界取
+            // turn/start–turn/end，与 codex `task_started` 汇总同一口径（§9.21）。
+            // null = 历史里没有 turn 标记（旧数据/截断）→ 退回末条 usage 语义。
+            let turnUsage = null;
+            let lastTurnUsage = null;
+            for (const entry of value.records ?? []) {
                 const ev = entry.event;
                 if (!ev)
                     continue;
+                if (ev.type === 'turn/start') {
+                    turnUsage = emptyUsageTotals();
+                }
+                else if (ev.type === 'turn/end') {
+                    if (turnUsage)
+                        lastTurnUsage = turnUsage;
+                    turnUsage = null;
+                }
                 const contentEvents = mapEvent(ev);
                 events.push(...contentEvents.events);
                 if (contentEvents.title)
@@ -130,26 +241,35 @@ export class DshSessionReader {
                     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.
+                    // 本 run 的 flow 字段 = 末个 turn 的采样之和；contextLength 用末次采样
+                    // 的窗口占用（input + cacheRead + cacheWrite，不含 output）。
+                    if (turnUsage) {
+                        turnUsage.input += u.inputTokens ?? 0;
+                        turnUsage.output += u.outputTokens ?? 0;
+                        turnUsage.cacheRead += u.cacheReadTokens ?? 0;
+                        turnUsage.cacheWrite += u.cacheWriteTokens ?? 0;
+                    }
                     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;
+                const flow = lastTurnUsage ?? {
+                    input,
+                    output: lastUsage.outputTokens ?? 0,
+                    cacheRead,
+                    cacheWrite,
+                };
                 sessionUsage = {
-                    inputTokens: input,
-                    outputTokens: output,
+                    inputTokens: flow.input,
+                    outputTokens: flow.output,
                     contextLength: input + cacheRead + cacheWrite,
-                    cacheReadTokens: cacheRead,
-                    cacheCreationTokens: cacheWrite,
-                    totalTokens: input + output + cacheRead + cacheWrite,
+                    cacheReadTokens: flow.cacheRead,
+                    cacheCreationTokens: flow.cacheWrite,
+                    totalTokens: flow.input + flow.output + flow.cacheRead + flow.cacheWrite,
                     ...cumulativeUsageFields({
                         input: cumInput,
                         output: cumOutput,
@@ -173,15 +293,39 @@ export class DshSessionReader {
     }
     isSessionActive(sessionId, cwd) {
         try {
-            const value = this.unary('session.list', {});
-            const found = (value.items ?? []).find((i) => String(i.sessionId) === sessionId && i.cwd !== undefined && samePath(i.cwd, cwd));
-            return found?.running === true;
+            return this.resolveSession(sessionId, cwd)?.running === true;
         }
         catch (error) {
             getLogger().error(`[dsh-session-reader] isSessionActive error: ${error.message}`);
             return false;
         }
     }
+    /**
+     * Find the session row in `session/list` that matches BOTH id and cwd.
+     * Returns undefined when the id belongs to another workspace (or is unknown) —
+     * every caller treats that as "not usable here".
+     */
+    resolveSession(sessionId, cwd) {
+        const value = this.unary('session/list', {});
+        return (value.items ?? []).find((i) => String(i.sessionId) === sessionId && i.cwd !== undefined && samePath(i.cwd, cwd));
+    }
+    /** `session/page` needs an inclusive cursor; projections carry the watermark. */
+    resolveThroughSeq(sessionId, known) {
+        const projection = this.unary('session/projections', { sessionId });
+        if (typeof projection?.asOfSeq === 'number')
+            return projection.asOfSeq;
+        const row = known ??
+            this.unary('session/list', {}).items?.find((item) => String(item.sessionId) === sessionId);
+        return typeof row?.projections?.asOfSeq === 'number' ? row.projections.asOfSeq : -1;
+    }
+}
+/** Preset moved from the summary top level to projections in DSH 0.2.x. */
+function sessionPreset(item) {
+    const preset = item.projections?.values?.agentPreset ?? item.agentPreset;
+    return preset ? { agentPreset: preset } : {};
+}
+function emptyUsageTotals() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
 /** Map one DSH SessionEvent to display content events (+ title/usage side effects). */
 function mapEvent(ev) {

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

@@ -1,10 +1,12 @@
 /**
- * OpencodeSessionReader: CLI-based session reader using `opencode session list` and `opencode export`.
+ * OpencodeSessionReader: CLI-based session reader using `opencode session list`
+ * and `opencode session export` (v2) / `opencode export` (v1).
  *
  * Design:
  * - Uses official CLI commands instead of HTTP API.
  * - `opencode session list --format json` returns sessions with `directory` field (first-class citizen).
- * - `opencode export <sessionID>` returns full session content.
+ * - `opencode session export <sessionID>` (v2) or `opencode export <sessionID>`
+ *   (v1) returns full session content.
  * - Independent of runner (no setRunner circular dependency).
  *
  * Key features:
@@ -15,10 +17,12 @@
  */
 import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
 interface OpencodeSessionReaderOptions {
+    /** Path to the opencode binary. Defaults to `opencode`. */
+    binary?: string;
     /** Cache TTL for session list (ms). Default: 10_000. */
     cacheTtlMs?: number;
     /**
-     * Override the raw `opencode export <id>` capture (returns the JSON string).
+     * Override the raw export capture (returns the JSON string).
      * Default routes stdout to a temp file fd to bypass opencode's ~128KB pipe
      * truncation on large sessions. Injectable for testing.
      */
@@ -54,6 +58,12 @@ export declare class OpencodeSessionReader implements AgentSessionReader {
     readSessionContent(sessionId: string, cwd: string, opts?: {
         maxEvents?: number;
     }): SessionContent;
+    /**
+     * v2 export: messages are flat (`type` + `text`/`content`) and assistant
+     * usage lives on the message instead of a `step-finish` part. Keep this
+     * mapping isolated from the v1 parser so v1 behaviour stays unchanged.
+     */
+    private readV2SessionContent;
     /**
      * Check if a session is active (updated within 1 hour).
      * Passes cwd to fetchSessionList so it returns sessions for the correct directory.
@@ -63,18 +73,19 @@ export declare class OpencodeSessionReader implements AgentSessionReader {
     realpath(cwd: string): string;
     private fetchSessionList;
     /**
-     * Capture raw `opencode export <sessionId>` output (JSON string). Injectable
+     * Capture raw export output (JSON string). Injectable
      * via the constructor; the default routes stdout to a temp file fd to bypass
      * opencode's ~128KB pipe truncation on large sessions.
      */
     /** 导出会话内容（public：测试直接调用，替代 as unknown as）。 */
     captureExport(sessionId: string): string;
     /**
-     * default transport: run `opencode export` with stdout pointed at a
+     * default transport: run the version-appropriate export command with stdout
+     * pointed at a
      * regular-file fd (NOT a pipe). opencode truncates piped stdout at ~128KB for
      * large sessions (huge tool_results), breaking JSON.parse; a file fd receives
-     * the full output (verified: 1.3MB parses OK). execFileSync returns null when
-     * stdout is not a pipe, so we read the file instead.
+     * the full output (verified: 1.3MB parses OK). spawnProcessSync returns null
+     * stdout when it is redirected to a file fd, so we read the file instead.
      */
     private captureExportViaFileFd;
 }