lark-remote 0.1.7 → 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/workspace/index.d.ts

@@ -11,6 +11,10 @@ export interface WorkspaceEntry {
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the bridge can still start.
  *
+ * lastUsedAt 语义（2026-08-19 语义对齐）：保存（save）与使用（use/touch）
+ * 都会把时间戳更新为当前时间。save 内部调用 touch，保证「最近使用」排序
+ * 对新保存的 workspace 同样生效（新条目应排在列表最前，而非沉底）。
+ *
  * Data migration: old format `{ alias: "path" }` is normalized to
  * `{ alias: { path, lastUsedAt: 0 } }` on first load and persisted.
  */

package/dist/workspace/index.js

@@ -10,6 +10,10 @@ import { getLogger } from '../logger/index.js';
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the bridge can still start.
  *
+ * lastUsedAt 语义（2026-08-19 语义对齐）：保存（save）与使用（use/touch）
+ * 都会把时间戳更新为当前时间。save 内部调用 touch，保证「最近使用」排序
+ * 对新保存的 workspace 同样生效（新条目应排在列表最前，而非沉底）。
+ *
  * Data migration: old format `{ alias: "path" }` is normalized to
  * `{ alias: { path, lastUsedAt: 0 } }` on first load and persisted.
  */
@@ -60,8 +64,11 @@ export class WorkspaceStore {
         atomicWriteJson(this.filePath, obj);
     }
     save(name, dirPath) {
+        // 保存即视为使用（语义对齐）：新建/覆盖的 workspace 都应拿到当前
+        // lastUsedAt，而不是 0，否则「最近使用」排序下新条目会沉底。
+        // touch() 负责统一写入时间戳并 persist，消除 save 写 0 / use 写 now 的不对称。
         this.data.set(name, { path: dirPath, lastUsedAt: 0 });
-        this.persist();
+        this.touch(name);
     }
     get(name) {
         return this.data.get(name)?.path;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,6 +47,7 @@
     "test:opencode": "vitest run --project agent-opencode",
     "test:pi": "vitest run --project agent-pi",
     "test:kimi": "vitest run --project agent-kimi",
+    "test:dsh": "vitest run --project agent-dsh",
     "test:bash": "vitest run --project agent-bash",
     "test:infra": "vitest run --project 'infra-*'",
     "test:agents": "vitest run --project 'agent-*'",