termdock 1.4.97 → 1.4.98

package/dist/server/agent/collaborationStore.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+const MAX_MESSAGES = 2_000;
+const MESSAGE_KINDS = new Set(['message', 'ask', 'reply', 'task', 'handoff', 'done']);
+export class CollaborationStore {
+    filePath;
+    document = { version: 2, groups: [], messages: [] };
+    constructor(filePath) {
+        this.filePath = filePath;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            if (Array.isArray(parsed.groups)) {
+                this.document.groups = parsed.groups.filter((group) => group && typeof group.id === 'string' && Array.isArray(group.sessionIds));
+            }
+            if (Array.isArray(parsed.messages)) {
+                this.document.messages = parsed.messages.filter((message) => message && typeof message.id === 'string' && typeof message.toSessionId === 'string' && MESSAGE_KINDS.has(message.kind)).slice(-MAX_MESSAGES);
+            }
+        }
+        catch { /* first run */ }
+    }
+    list() {
+        return [...this.document.groups].sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    getGroup(id) {
+        return this.document.groups.find((group) => group.id === id) ?? null;
+    }
+    save(input) {
+        const now = Date.now();
+        const existing = input.id ? this.document.groups.find((group) => group.id === input.id) : null;
+        const group = {
+            id: existing?.id ?? crypto.randomUUID(),
+            name: input.name.trim(),
+            sessionIds: Array.from(new Set(input.sessionIds.map((id) => id.trim()).filter(Boolean))),
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        };
+        this.document.groups = existing
+            ? this.document.groups.map((candidate) => candidate.id === group.id ? group : candidate)
+            : [...this.document.groups, group];
+        this.persist();
+        return group;
+    }
+    remove(id) {
+        const before = this.document.groups.length;
+        this.document.groups = this.document.groups.filter((group) => group.id !== id);
+        if (before === this.document.groups.length)
+            return false;
+        this.document.messages = this.document.messages.filter((message) => message.groupId !== id);
+        this.persist();
+        return true;
+    }
+    removeSession(sessionId) {
+        const affected = this.document.groups.filter((group) => group.sessionIds.includes(sessionId));
+        if (affected.length === 0)
+            return { updatedGroups: 0, dissolvedGroups: 0 };
+        const dissolvedIds = new Set(affected.filter((group) => group.sessionIds.length <= 2).map((group) => group.id));
+        const now = Date.now();
+        this.document.groups = this.document.groups.flatMap((group) => {
+            if (!group.sessionIds.includes(sessionId))
+                return [group];
+            if (dissolvedIds.has(group.id))
+                return [];
+            return [{ ...group, sessionIds: group.sessionIds.filter((id) => id !== sessionId), updatedAt: now }];
+        });
+        this.document.messages = this.document.messages.filter((message) => !dissolvedIds.has(message.groupId)
+            && message.fromSessionId !== sessionId
+            && message.toSessionId !== sessionId);
+        this.persist();
+        return { updatedGroups: affected.length - dissolvedIds.size, dissolvedGroups: dissolvedIds.size };
+    }
+    clear() {
+        if (this.document.groups.length === 0 && this.document.messages.length === 0)
+            return;
+        this.document = { version: 2, groups: [], messages: [] };
+        this.persist();
+    }
+    groupsForSession(sessionId) {
+        return this.document.groups.filter((group) => group.sessionIds.includes(sessionId));
+    }
+    send(input) {
+        const group = this.getGroup(input.groupId);
+        if (!group)
+            throw new Error('协作组不存在');
+        if (!MESSAGE_KINDS.has(input.kind))
+            throw new Error('消息类型无效');
+        const content = input.content.trim();
+        if (!content)
+            throw new Error('消息不能为空');
+        const recipients = Array.from(new Set(input.toSessionIds)).filter((id) => group.sessionIds.includes(id) && id !== input.fromSessionId);
+        if (recipients.length === 0)
+            throw new Error('没有有效的接收会话');
+        const now = Date.now();
+        const threadId = input.threadId?.trim() || crypto.randomUUID();
+        const messages = recipients.map((toSessionId) => ({
+            id: crypto.randomUUID(), groupId: group.id, fromSessionId: input.fromSessionId,
+            toSessionId, kind: input.kind, content, threadId,
+            replyTo: input.replyTo?.trim() || null, status: 'pending', createdAt: now,
+            deliveredAt: null, readAt: null,
+        }));
+        this.document.messages = [...this.document.messages, ...messages].slice(-MAX_MESSAGES);
+        this.persist();
+        return messages;
+    }
+    listMessages(groupId, limit = 200) {
+        return this.document.messages.filter((message) => message.groupId === groupId).slice(-Math.max(1, Math.min(limit, 500)));
+    }
+    getMessage(id) {
+        return this.document.messages.find((message) => message.id === id) ?? null;
+    }
+    inbox(sessionId, options = {}) {
+        return this.document.messages
+            .filter((message) => message.toSessionId === sessionId && (!options.pendingOnly || message.status === 'pending'))
+            .slice(-Math.max(1, Math.min(options.limit ?? 50, 200)));
+    }
+    markDelivered(messageIds) {
+        return this.updateStatus(messageIds, 'delivered');
+    }
+    markRead(messageIds) {
+        return this.updateStatus(messageIds, 'read');
+    }
+    updateStatus(messageIds, status) {
+        const ids = new Set(messageIds);
+        const now = Date.now();
+        const changed = [];
+        this.document.messages = this.document.messages.map((message) => {
+            if (!ids.has(message.id))
+                return message;
+            const updated = status === 'read'
+                ? { ...message, status, deliveredAt: message.deliveredAt ?? now, readAt: now }
+                : message.status === 'pending' ? { ...message, status, deliveredAt: now } : message;
+            changed.push(updated);
+            return updated;
+        });
+        if (changed.length > 0)
+            this.persist();
+        return changed;
+    }
+    persist() {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        const temporaryPath = `${this.filePath}.${process.pid}.tmp`;
+        fs.writeFileSync(temporaryPath, JSON.stringify(this.document, null, 2), { mode: 0o600 });
+        fs.renameSync(temporaryPath, this.filePath);
+    }
+}

package/dist/server/agent/installers.js

@@ -371,7 +371,7 @@ function grokHooksJson() {
  *  from that directory — so the plugin bridges its events onto the same
  *  emitter. Inert outside termdock (both the JS guard and the emitter check
  *  TERMDOCK). */
-function opencodePluginJs() {
+export function opencodePluginJs() {
     const prefix = JSON.stringify(`"${process.execPath}" "${resolveHookScript().script}" agent-hook opencode `);
     return `// termdock agent-hook opencode bridge — generated by termdock, do not edit.
 // Bridges OpenCode plugin events onto the termdock agent-hook emitter,
@@ -379,26 +379,64 @@ function opencodePluginJs() {
 export const TermdockPresence = async ({ $ }) => {
   if (!process.env["TERMDOCK"]) return {}
   const cmd = ${prefix}
-  const emit = (event) => $\`sh -c \${cmd + event}\`.quiet().nothrow()
-
-  // Plugin load = the agent is running in this pane.
-  await emit("session-start")
+  const announced = new Set()
+  const childSessions = new Set()
+  const emit = (event, sessionID) => {
+    const payload = JSON.stringify(sessionID ? { session_id: sessionID } : {})
+    return $\`printf "%s" \${payload} | sh -c \${cmd + event}\`.quiet().nothrow()
+  }
+  const ensureSession = async (sessionID) => {
+    if (!sessionID || childSessions.has(sessionID) || announced.has(sessionID)) return false
+    announced.add(sessionID)
+    await emit("session-start", sessionID)
+    return true
+  }
+  const observeSessionInfo = async (info) => {
+    const sessionID = info?.id
+    if (!sessionID) return
+    if (info.parentID) {
+      childSessions.add(sessionID)
+      announced.delete(sessionID)
+      return
+    }
+    await ensureSession(sessionID)
+  }
 
   return {
     dispose: async () => {
-      await emit("session-end")
+      await Promise.all([...announced].map((sessionID) => emit("session-end", sessionID)))
     },
-    "tool.execute.before": async () => {
-      await emit("prompt-submit")
+    "chat.message": async ({ sessionID }) => {
+      await ensureSession(sessionID)
+      if (!childSessions.has(sessionID)) await emit("prompt-submit", sessionID)
     },
-    "permission.ask": async () => {
-      await emit("permission-request")
+    "tool.execute.before": async ({ sessionID }) => {
+      await ensureSession(sessionID)
+      if (!childSessions.has(sessionID)) await emit("prompt-submit", sessionID)
+    },
+    "permission.ask": async ({ sessionID }) => {
+      await ensureSession(sessionID)
+      if (!childSessions.has(sessionID)) await emit("permission-request", sessionID)
     },
     event: async ({ event }) => {
+      if (event.type === "session.created" || event.type === "session.updated") {
+        await observeSessionInfo(event.properties?.info)
+        return
+      }
+      if (event.type === "session.deleted") {
+        const deletedSessionID = event.properties?.info?.id
+        if (announced.has(deletedSessionID)) await emit("session-end", deletedSessionID)
+        announced.delete(deletedSessionID)
+        childSessions.delete(deletedSessionID)
+        return
+      }
+      const sessionID = event.properties?.sessionID
+      await ensureSession(sessionID)
+      if (!sessionID || childSessions.has(sessionID)) return
       if (event.type === "session.idle") {
-        await emit("stop")
+        await emit("stop", sessionID)
       } else if (event.type === "permission.replied") {
-        await emit("prompt-submit")
+        await emit("prompt-submit", sessionID)
       }
     },
   }

package/dist/server/agent/plugins.js

@@ -158,6 +158,12 @@ export function validateManifest(raw, dir) {
         || !aliases.every((a) => typeof a === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(a))) {
         errors.push('aliases must contain 1-16 safe command names');
     }
+    const capabilities = m.capabilities;
+    if (capabilities !== undefined && (!Array.isArray(capabilities) || capabilities.length > 32
+        || !capabilities.every((capability) => typeof capability === 'string'
+            && /^[A-Za-z0-9\p{L}][A-Za-z0-9\p{L}\p{N}:._ -]{0,63}$/u.test(capability.trim())))) {
+        errors.push('capabilities must contain at most 32 short capability names');
+    }
     const accentColor = m.accentColor;
     if (typeof accentColor !== 'string' || !HEX_COLOR_RE.test(accentColor)) {
         errors.push('accentColor must be a 6-digit hex color (e.g. "#4385BE")');
@@ -397,6 +403,9 @@ export function validateManifest(raw, dir) {
             slug: slug,
             displayName: displayName.trim(),
             aliases: aliases.map((a) => a.trim().toLowerCase()),
+            capabilities: Array.isArray(capabilities)
+                ? [...new Set(capabilities.map((capability) => capability.trim()))]
+                : undefined,
             accentColor: accentColor,
             iconMode: iconMode,
             statuses,

package/dist/server/agent/registry.js

@@ -273,6 +273,7 @@ export function registerPluginAgents(plugins) {
             slug: manifest.slug,
             displayName: manifest.displayName,
             aliases: manifest.aliases,
+            capabilities: manifest.capabilities,
             accentColor: manifest.accentColor,
             // Plugins use their slug as the frontend icon key only when icon.svg exists.
             // Otherwise AgentBrandAvatar must receive null so it can render its Bot fallback.

package/dist/server/agent/resumeHistory.js

@@ -0,0 +1,100 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { normalizePersistedAgentResumeInfo } from './resumePersistence.js';
+const MAX_TITLE_LENGTH = 240;
+const MAX_CWD_LENGTH = 8_192;
+function normalizeEntry(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const candidate = input;
+    const id = typeof candidate.id === 'string' ? candidate.id.trim() : '';
+    const title = typeof candidate.title === 'string' ? candidate.title.trim().slice(0, MAX_TITLE_LENGTH) : '';
+    const cwd = typeof candidate.cwd === 'string' ? candidate.cwd.trim().slice(0, MAX_CWD_LENGTH) : '';
+    const agent = normalizePersistedAgentResumeInfo(candidate.agent);
+    if (!id || !title || !cwd || !agent)
+        return null;
+    return {
+        id,
+        title,
+        titleSource: candidate.titleSource === 'custom' || candidate.titleSource === 'auto'
+            ? candidate.titleSource
+            : 'default',
+        agent,
+        cwd,
+        closedAt: typeof candidate.closedAt === 'number' && Number.isFinite(candidate.closedAt)
+            ? Math.floor(candidate.closedAt)
+            : Date.now(),
+        reason: candidate.reason === 'exited' ? 'exited' : 'closed',
+    };
+}
+export class AgentResumeHistoryStore {
+    filePath;
+    maxEntries;
+    entries = [];
+    constructor(filePath, maxEntries = 30) {
+        this.filePath = filePath;
+        this.maxEntries = maxEntries;
+        this.load();
+    }
+    list() {
+        return this.entries.map((entry) => ({
+            ...entry,
+            agent: { ...entry.agent, launchArgv: entry.agent.launchArgv ? [...entry.agent.launchArgv] : null },
+        }));
+    }
+    get(id) {
+        return this.entries.find((entry) => entry.id === id) ?? null;
+    }
+    archive(input) {
+        const normalized = normalizeEntry({ ...input, id: randomUUID(), closedAt: input.closedAt ?? Date.now() });
+        if (!normalized)
+            return null;
+        const sameConversation = (entry) => entry.agent.slug === normalized.agent.slug
+            && entry.agent.sessionId === normalized.agent.sessionId;
+        const previous = this.entries.find(sameConversation);
+        const next = previous ? { ...normalized, id: previous.id } : normalized;
+        this.entries = [next, ...this.entries.filter((entry) => !sameConversation(entry))]
+            .sort((a, b) => b.closedAt - a.closedAt)
+            .slice(0, this.maxEntries);
+        this.persist();
+        return next;
+    }
+    remove(id) {
+        const next = this.entries.filter((entry) => entry.id !== id);
+        if (next.length === this.entries.length)
+            return false;
+        this.entries = next;
+        this.persist();
+        return true;
+    }
+    clear() {
+        if (this.entries.length === 0)
+            return;
+        this.entries = [];
+        this.persist();
+    }
+    load() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
+            this.entries = Array.isArray(parsed.entries)
+                ? parsed.entries.map(normalizeEntry).filter((entry) => entry !== null)
+                    .sort((a, b) => b.closedAt - a.closedAt)
+                    .slice(0, this.maxEntries)
+                : [];
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.warn('[agent-resume-history] failed to load:', error.message);
+            }
+            this.entries = [];
+        }
+    }
+    persist() {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        const tempPath = `${this.filePath}.tmp-${process.pid}`;
+        const document = { version: 1, entries: this.entries };
+        fs.writeFileSync(tempPath, JSON.stringify(document, null, 2), { encoding: 'utf8', mode: 0o600 });
+        fs.renameSync(tempPath, this.filePath);
+    }
+}

package/dist/server/agent/resumePersistence.js

@@ -0,0 +1,35 @@
+const SAFE_AGENT_SLUG = /^[A-Za-z0-9._-]+$/;
+const SAFE_SESSION_ID = /^[A-Za-z0-9._-]+$/;
+/** Normalize the last-known Agent conversation before it reaches disk again. */
+export function normalizePersistedAgentResumeInfo(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const candidate = input;
+    const slug = typeof candidate.slug === 'string' ? candidate.slug.trim() : '';
+    const sessionId = typeof candidate.sessionId === 'string' ? candidate.sessionId.trim() : '';
+    if (!slug || !SAFE_AGENT_SLUG.test(slug) || !sessionId || !SAFE_SESSION_ID.test(sessionId)) {
+        return null;
+    }
+    const launchArgv = candidate.launchArgv === null || candidate.launchArgv === undefined
+        ? null
+        : Array.isArray(candidate.launchArgv)
+            && candidate.launchArgv.length <= 256
+            && candidate.launchArgv.every((value) => typeof value === 'string' && value.length <= 8_192)
+            ? [...candidate.launchArgv]
+            : null;
+    return {
+        slug,
+        sessionId,
+        launchArgv,
+        updatedAt: typeof candidate.updatedAt === 'number' && Number.isFinite(candidate.updatedAt)
+            ? Math.floor(candidate.updatedAt)
+            : Date.now(),
+    };
+}
+/** A dead shell is worth rebuilding only when it can restore an Agent conversation. */
+export function canRestoreDeadAgentShell(input) {
+    return typeof input.cwd === 'string'
+        && input.cwd.trim().length > 0
+        && typeof input.agentResume?.sessionId === 'string'
+        && input.agentResume.sessionId.length > 0;
+}

package/dist/server/agent/sessionSearchStore.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const MAX_LOG_BYTES = 2 * 1024 * 1024;
+const ANSI_PATTERN = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+function clean(value) {
+    return value
+        .replace(ANSI_PATTERN, '')
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '')
+        .replace(/\r/g, '')
+        .replace(/\n{4,}/g, '\n\n\n');
+}
+export class SessionSearchStore {
+    directory;
+    metadata = new Map();
+    pending = new Map();
+    flushTimer = null;
+    constructor(directory) {
+        this.directory = directory;
+        this.loadMetadata();
+    }
+    append(metadata, output) {
+        const text = clean(output);
+        this.metadata.set(metadata.sessionId, { ...metadata, updatedAt: Date.now() });
+        if (text.trim())
+            this.pending.set(metadata.sessionId, [...(this.pending.get(metadata.sessionId) ?? []), text]);
+        if (!this.flushTimer)
+            this.flushTimer = setTimeout(() => this.flush(), 750);
+    }
+    update(metadata) {
+        this.metadata.set(metadata.sessionId, { ...metadata, updatedAt: Date.now() });
+        if (!this.flushTimer)
+            this.flushTimer = setTimeout(() => this.flush(), 750);
+    }
+    search(query, limit = 30) {
+        this.flush();
+        const needle = query.trim().toLocaleLowerCase();
+        if (!needle)
+            return [];
+        const results = [];
+        for (const metadata of this.metadata.values()) {
+            let text = '';
+            try {
+                text = fs.readFileSync(this.logPath(metadata.sessionId), 'utf8');
+            }
+            catch { /* no output yet */ }
+            const searchable = `${metadata.title}\n${metadata.cwd}\n${metadata.agentSlug ?? ''}\n${text}`;
+            const lower = searchable.toLocaleLowerCase();
+            const first = lower.indexOf(needle);
+            if (first < 0)
+                continue;
+            let count = 0;
+            let cursor = 0;
+            while ((cursor = lower.indexOf(needle, cursor)) >= 0 && count < 999) {
+                count += 1;
+                cursor += needle.length;
+            }
+            const sourceStart = Math.max(0, first - 100);
+            const sourceEnd = Math.min(searchable.length, first + needle.length + 180);
+            results.push({ ...metadata, snippet: searchable.slice(sourceStart, sourceEnd).replace(/\s+/g, ' ').trim(), matchCount: count });
+        }
+        return results.sort((a, b) => b.updatedAt - a.updatedAt).slice(0, Math.max(1, Math.min(limit, 100)));
+    }
+    flush() {
+        if (this.flushTimer)
+            clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+        if (this.metadata.size === 0 && this.pending.size === 0)
+            return;
+        fs.mkdirSync(this.directory, { recursive: true });
+        for (const [sessionId, chunks] of this.pending) {
+            const logPath = this.logPath(sessionId);
+            fs.appendFileSync(logPath, chunks.join(''), { mode: 0o600 });
+            const stats = fs.statSync(logPath);
+            if (stats.size > MAX_LOG_BYTES) {
+                const buffer = fs.readFileSync(logPath);
+                fs.writeFileSync(logPath, buffer.subarray(buffer.length - MAX_LOG_BYTES), { mode: 0o600 });
+            }
+        }
+        this.pending.clear();
+        const temporaryPath = `${this.metadataPath()}.${process.pid}.tmp`;
+        fs.writeFileSync(temporaryPath, JSON.stringify({ version: 1, sessions: [...this.metadata.values()] }, null, 2), { mode: 0o600 });
+        fs.renameSync(temporaryPath, this.metadataPath());
+    }
+    loadMetadata() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.metadataPath(), 'utf8'));
+            for (const item of parsed.sessions ?? []) {
+                if (item && typeof item.sessionId === 'string')
+                    this.metadata.set(item.sessionId, item);
+            }
+        }
+        catch { /* first run */ }
+    }
+    metadataPath() { return path.join(this.directory, 'sessions.json'); }
+    logPath(sessionId) { return path.join(this.directory, `${encodeURIComponent(sessionId)}.log`); }
+}