@tarquinen/opencode-dcp 3.1.11 → 3.1.13

package/lib/protected-patterns.ts

@@ -0,0 +1,128 @@
+function normalizePath(input: string): string {
+    return input.replaceAll("\\\\", "/")
+}
+
+function escapeRegExpChar(ch: string): string {
+    return /[\\.^$+{}()|\[\]]/.test(ch) ? `\\${ch}` : ch
+}
+
+export function matchesGlob(inputPath: string, pattern: string): boolean {
+    if (!pattern) return false
+
+    const input = normalizePath(inputPath)
+    const pat = normalizePath(pattern)
+
+    let regex = "^"
+
+    for (let i = 0; i < pat.length; i++) {
+        const ch = pat[i]
+
+        if (ch === "*") {
+            const next = pat[i + 1]
+            if (next === "*") {
+                const after = pat[i + 2]
+                if (after === "/") {
+                    // **/  (zero or more directories)
+                    regex += "(?:.*/)?"
+                    i += 2
+                    continue
+                }
+
+                // **
+                regex += ".*"
+                i++
+                continue
+            }
+
+            // *
+            regex += "[^/]*"
+            continue
+        }
+
+        if (ch === "?") {
+            regex += "[^/]"
+            continue
+        }
+
+        if (ch === "/") {
+            regex += "/"
+            continue
+        }
+
+        regex += escapeRegExpChar(ch)
+    }
+
+    regex += "$"
+
+    return new RegExp(regex).test(input)
+}
+
+export function getFilePathsFromParameters(tool: string, parameters: unknown): string[] {
+    if (typeof parameters !== "object" || parameters === null) {
+        return []
+    }
+
+    const paths: string[] = []
+    const params = parameters as Record<string, any>
+
+    // 1. apply_patch uses patchText with embedded paths
+    if (tool === "apply_patch" && typeof params.patchText === "string") {
+        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g
+        let match
+        while ((match = pathRegex.exec(params.patchText)) !== null) {
+            paths.push(match[1].trim())
+        }
+    }
+
+    // 2. multiedit uses top-level filePath and nested edits array
+    if (tool === "multiedit") {
+        if (typeof params.filePath === "string") {
+            paths.push(params.filePath)
+        }
+        if (Array.isArray(params.edits)) {
+            for (const edit of params.edits) {
+                if (edit && typeof edit.filePath === "string") {
+                    paths.push(edit.filePath)
+                }
+            }
+        }
+    }
+
+    // 3. Default check for common filePath parameter (read, write, edit, etc)
+    if (typeof params.filePath === "string") {
+        paths.push(params.filePath)
+    }
+
+    // Return unique non-empty paths
+    return [...new Set(paths)].filter((p) => p.length > 0)
+}
+
+export function isFilePathProtected(filePaths: string[], patterns: string[]): boolean {
+    if (!filePaths || filePaths.length === 0) return false
+    if (!patterns || patterns.length === 0) return false
+
+    return filePaths.some((path) => patterns.some((pattern) => matchesGlob(path, pattern)))
+}
+
+const GLOB_CHARS = /[*?]/
+
+export function isToolNameProtected(toolName: string, patterns: string[]): boolean {
+    if (!toolName || !patterns || patterns.length === 0) return false
+
+    const exactPatterns: Set<string> = new Set()
+    const globPatterns: string[] = []
+
+    for (const pattern of patterns) {
+        if (GLOB_CHARS.test(pattern)) {
+            globPatterns.push(pattern)
+        } else {
+            exactPatterns.add(pattern)
+        }
+    }
+
+    if (exactPatterns.has(toolName)) {
+        return true
+    }
+
+    return globPatterns.some((pattern) => matchesGlob(toolName, pattern))
+}

package/lib/state/index.ts

@@ -0,0 +1,4 @@
+export * from "./persistence"
+export * from "./types"
+export * from "./state"
+export * from "./tool-cache"

package/lib/state/persistence.ts

@@ -0,0 +1,305 @@
+/**
+ * State persistence module for DCP plugin.
+ * Persists pruned tool IDs across sessions so they survive OpenCode restarts.
+ * Storage location: ~/.local/share/opencode/storage/plugin/dcp/{sessionId}.json
+ */
+
+import * as fs from "fs/promises"
+import { existsSync } from "fs"
+import { homedir } from "os"
+import { join } from "path"
+import type { CompressionBlock, PrunedMessageEntry, SessionState, SessionStats } from "./types"
+import type { Logger } from "../logger"
+import { serializePruneMessagesState } from "./utils"
+
+/** Prune state as stored on disk */
+export interface PersistedPruneMessagesState {
+    byMessageId: Record<string, PrunedMessageEntry>
+    blocksById: Record<string, CompressionBlock>
+    activeBlockIds: number[]
+    activeByAnchorMessageId: Record<string, number>
+    nextBlockId: number
+    nextRunId: number
+}
+
+export interface PersistedPrune {
+    tools?: Record<string, number>
+    messages?: PersistedPruneMessagesState
+}
+
+export interface PersistedNudges {
+    contextLimitAnchors: string[]
+    turnNudgeAnchors?: string[]
+    iterationNudgeAnchors?: string[]
+}
+
+export interface PersistedSessionState {
+    sessionName?: string
+    manualMode?: boolean
+    prune: PersistedPrune
+    nudges: PersistedNudges
+    stats: SessionStats
+    lastUpdated: string
+}
+
+const STORAGE_DIR = join(
+    process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"),
+    "opencode",
+    "storage",
+    "plugin",
+    "dcp",
+)
+
+async function ensureStorageDir(): Promise<void> {
+    if (!existsSync(STORAGE_DIR)) {
+        await fs.mkdir(STORAGE_DIR, { recursive: true })
+    }
+}
+
+function getSessionFilePath(sessionId: string): string {
+    return join(STORAGE_DIR, `${sessionId}.json`)
+}
+
+async function writePersistedSessionState(
+    sessionId: string,
+    state: PersistedSessionState,
+    logger: Logger,
+): Promise<void> {
+    await ensureStorageDir()
+
+    const filePath = getSessionFilePath(sessionId)
+    const content = JSON.stringify(state, null, 2)
+    await fs.writeFile(filePath, content, "utf-8")
+
+    logger.info("Saved session state to disk", {
+        sessionId,
+        totalTokensSaved: state.stats.totalPruneTokens,
+    })
+}
+
+export async function saveSessionState(
+    sessionState: SessionState,
+    logger: Logger,
+    sessionName?: string,
+): Promise<void> {
+    try {
+        if (!sessionState.sessionId) {
+            return
+        }
+
+        const state: PersistedSessionState = {
+            sessionName: sessionName,
+            manualMode: !!sessionState.manualMode,
+            prune: {
+                tools: Object.fromEntries(sessionState.prune.tools),
+                messages: serializePruneMessagesState(sessionState.prune.messages),
+            },
+            nudges: {
+                contextLimitAnchors: Array.from(sessionState.nudges.contextLimitAnchors),
+                turnNudgeAnchors: Array.from(sessionState.nudges.turnNudgeAnchors),
+                iterationNudgeAnchors: Array.from(sessionState.nudges.iterationNudgeAnchors),
+            },
+            stats: sessionState.stats,
+            lastUpdated: new Date().toISOString(),
+        }
+
+        await writePersistedSessionState(sessionState.sessionId, state, logger)
+    } catch (error: any) {
+        logger.error("Failed to save session state", {
+            sessionId: sessionState.sessionId,
+            error: error?.message,
+        })
+    }
+}
+
+export async function loadSessionState(
+    sessionId: string,
+    logger: Logger,
+): Promise<PersistedSessionState | null> {
+    try {
+        const filePath = getSessionFilePath(sessionId)
+
+        if (!existsSync(filePath)) {
+            return null
+        }
+
+        const content = await fs.readFile(filePath, "utf-8")
+        const state = JSON.parse(content) as PersistedSessionState
+
+        const hasPruneTools = state?.prune?.tools && typeof state.prune.tools === "object"
+        const hasPruneMessages = state?.prune?.messages && typeof state.prune.messages === "object"
+        const hasNudgeFormat = state?.nudges && typeof state.nudges === "object"
+        if (
+            !state ||
+            !state.prune ||
+            !hasPruneTools ||
+            !hasPruneMessages ||
+            !state.stats ||
+            !hasNudgeFormat
+        ) {
+            logger.warn("Invalid session state file, ignoring", {
+                sessionId: sessionId,
+            })
+            return null
+        }
+
+        const rawContextLimitAnchors = Array.isArray(state.nudges.contextLimitAnchors)
+            ? state.nudges.contextLimitAnchors
+            : []
+        const validAnchors = rawContextLimitAnchors.filter(
+            (entry): entry is string => typeof entry === "string",
+        )
+        const dedupedAnchors = [...new Set(validAnchors)]
+        if (validAnchors.length !== rawContextLimitAnchors.length) {
+            logger.warn("Filtered out malformed contextLimitAnchors entries", {
+                sessionId: sessionId,
+                original: rawContextLimitAnchors.length,
+                valid: validAnchors.length,
+            })
+        }
+        state.nudges.contextLimitAnchors = dedupedAnchors
+
+        const rawTurnNudgeAnchors = Array.isArray(state.nudges.turnNudgeAnchors)
+            ? state.nudges.turnNudgeAnchors
+            : []
+        const validSoftAnchors = rawTurnNudgeAnchors.filter(
+            (entry): entry is string => typeof entry === "string",
+        )
+        const dedupedSoftAnchors = [...new Set(validSoftAnchors)]
+        if (validSoftAnchors.length !== rawTurnNudgeAnchors.length) {
+            logger.warn("Filtered out malformed turnNudgeAnchors entries", {
+                sessionId: sessionId,
+                original: rawTurnNudgeAnchors.length,
+                valid: validSoftAnchors.length,
+            })
+        }
+        state.nudges.turnNudgeAnchors = dedupedSoftAnchors
+
+        const rawIterationNudgeAnchors = Array.isArray(state.nudges.iterationNudgeAnchors)
+            ? state.nudges.iterationNudgeAnchors
+            : []
+        const validIterationAnchors = rawIterationNudgeAnchors.filter(
+            (entry): entry is string => typeof entry === "string",
+        )
+        const dedupedIterationAnchors = [...new Set(validIterationAnchors)]
+        if (validIterationAnchors.length !== rawIterationNudgeAnchors.length) {
+            logger.warn("Filtered out malformed iterationNudgeAnchors entries", {
+                sessionId: sessionId,
+                original: rawIterationNudgeAnchors.length,
+                valid: validIterationAnchors.length,
+            })
+        }
+        state.nudges.iterationNudgeAnchors = dedupedIterationAnchors
+
+        logger.info("Loaded session state from disk", {
+            sessionId: sessionId,
+        })
+
+        return state
+    } catch (error: any) {
+        logger.warn("Failed to load session state", {
+            sessionId: sessionId,
+            error: error?.message,
+        })
+        return null
+    }
+}
+
+function emptyPersistedState(manualMode: boolean): PersistedSessionState {
+    return {
+        manualMode,
+        prune: {
+            tools: {},
+            messages: {
+                byMessageId: {},
+                blocksById: {},
+                activeBlockIds: [],
+                activeByAnchorMessageId: {},
+                nextBlockId: 1,
+                nextRunId: 1,
+            },
+        },
+        nudges: {
+            contextLimitAnchors: [],
+            turnNudgeAnchors: [],
+            iterationNudgeAnchors: [],
+        },
+        stats: {
+            pruneTokenCounter: 0,
+            totalPruneTokens: 0,
+        },
+        lastUpdated: new Date().toISOString(),
+    }
+}
+
+export async function loadManualModeSetting(
+    sessionId: string,
+    logger: Logger,
+): Promise<boolean | undefined> {
+    const state = await loadSessionState(sessionId, logger)
+    return typeof state?.manualMode === "boolean" ? state.manualMode : undefined
+}
+
+export async function saveManualModeSetting(
+    sessionId: string,
+    manualMode: boolean,
+    logger: Logger,
+): Promise<void> {
+    const existing = await loadSessionState(sessionId, logger)
+    const state = existing ?? emptyPersistedState(manualMode)
+    state.manualMode = manualMode
+    state.lastUpdated = new Date().toISOString()
+    await writePersistedSessionState(sessionId, state, logger)
+}
+
+export interface AggregatedStats {
+    totalTokens: number
+    totalTools: number
+    totalMessages: number
+    sessionCount: number
+}
+
+export async function loadAllSessionStats(logger: Logger): Promise<AggregatedStats> {
+    const result: AggregatedStats = {
+        totalTokens: 0,
+        totalTools: 0,
+        totalMessages: 0,
+        sessionCount: 0,
+    }
+
+    try {
+        if (!existsSync(STORAGE_DIR)) {
+            return result
+        }
+
+        const files = await fs.readdir(STORAGE_DIR)
+        const jsonFiles = files.filter((f) => f.endsWith(".json"))
+
+        for (const file of jsonFiles) {
+            try {
+                const filePath = join(STORAGE_DIR, file)
+                const content = await fs.readFile(filePath, "utf-8")
+                const state = JSON.parse(content) as PersistedSessionState
+
+                if (state?.stats?.totalPruneTokens && state?.prune) {
+                    result.totalTokens += state.stats.totalPruneTokens
+                    result.totalTools += state.prune.tools
+                        ? Object.keys(state.prune.tools).length
+                        : 0
+                    result.totalMessages += state.prune.messages?.byMessageId
+                        ? Object.keys(state.prune.messages.byMessageId).length
+                        : 0
+                    result.sessionCount++
+                }
+            } catch {
+                // Skip invalid files
+            }
+        }
+
+        logger.debug("Loaded all-time stats", result)
+    } catch (error: any) {
+        logger.warn("Failed to load all-time stats", { error: error?.message })
+    }
+
+    return result
+}

package/lib/state/state.ts

@@ -0,0 +1,208 @@
+import type { SessionState, ToolParameterEntry, WithParts } from "./types"
+import type { Logger } from "../logger"
+import { applyPendingCompressionDurations } from "../compress/timing"
+import { loadManualModeSetting, loadSessionState, saveSessionState } from "./persistence"
+import {
+    isSubAgentSession,
+    findLastCompactionTimestamp,
+    countTurns,
+    resetOnCompaction,
+    createPruneMessagesState,
+    loadPruneMessagesState,
+    loadPruneMap,
+    collectTurnNudgeAnchors,
+} from "./utils"
+import { getLastUserMessage } from "../messages/query"
+
+export const checkSession = async (
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+    manualModeDefault: boolean,
+): Promise<void> => {
+    const lastUserMessage = getLastUserMessage(messages)
+    if (!lastUserMessage) {
+        return
+    }
+
+    const lastSessionId = lastUserMessage.info.sessionID
+
+    if (state.sessionId === null || state.sessionId !== lastSessionId) {
+        logger.info(`Session changed: ${state.sessionId} -> ${lastSessionId}`)
+        try {
+            await ensureSessionInitialized(
+                client,
+                state,
+                lastSessionId,
+                logger,
+                messages,
+                manualModeDefault,
+            )
+        } catch (err: any) {
+            logger.error("Failed to initialize session state", { error: err.message })
+        }
+    }
+
+    const lastCompactionTimestamp = findLastCompactionTimestamp(messages)
+    if (lastCompactionTimestamp > state.lastCompaction) {
+        state.lastCompaction = lastCompactionTimestamp
+        resetOnCompaction(state)
+        logger.info("Detected compaction - reset stale state", {
+            timestamp: lastCompactionTimestamp,
+        })
+
+        saveSessionState(state, logger).catch((error) => {
+            logger.warn("Failed to persist state reset after compaction", {
+                error: error instanceof Error ? error.message : String(error),
+            })
+        })
+    }
+
+    state.currentTurn = countTurns(state, messages)
+    await refreshManualMode(state, lastSessionId, logger, manualModeDefault)
+}
+
+export function createSessionState(): SessionState {
+    return {
+        sessionId: null,
+        isSubAgent: false,
+        manualMode: false,
+        compressPermission: undefined,
+        pendingManualTrigger: null,
+        prune: {
+            tools: new Map<string, number>(),
+            messages: createPruneMessagesState(),
+        },
+        nudges: {
+            contextLimitAnchors: new Set<string>(),
+            turnNudgeAnchors: new Set<string>(),
+            iterationNudgeAnchors: new Set<string>(),
+        },
+        stats: {
+            pruneTokenCounter: 0,
+            totalPruneTokens: 0,
+        },
+        compressionTiming: {
+            startsByCallId: new Map<string, number>(),
+            pendingByCallId: new Map(),
+        },
+        toolParameters: new Map<string, ToolParameterEntry>(),
+        subAgentResultCache: new Map<string, string>(),
+        toolIdList: [],
+        messageIds: {
+            byRawId: new Map<string, string>(),
+            byRef: new Map<string, string>(),
+            nextRef: 1,
+        },
+        lastCompaction: 0,
+        currentTurn: 0,
+        modelContextLimit: undefined,
+        systemPromptTokens: undefined,
+    }
+}
+
+export function resetSessionState(state: SessionState): void {
+    state.sessionId = null
+    state.isSubAgent = false
+    state.manualMode = false
+    state.compressPermission = undefined
+    state.pendingManualTrigger = null
+    state.prune = {
+        tools: new Map<string, number>(),
+        messages: createPruneMessagesState(),
+    }
+    state.nudges = {
+        contextLimitAnchors: new Set<string>(),
+        turnNudgeAnchors: new Set<string>(),
+        iterationNudgeAnchors: new Set<string>(),
+    }
+    state.stats = {
+        pruneTokenCounter: 0,
+        totalPruneTokens: 0,
+    }
+    state.toolParameters.clear()
+    state.subAgentResultCache.clear()
+    state.toolIdList = []
+    state.messageIds = {
+        byRawId: new Map<string, string>(),
+        byRef: new Map<string, string>(),
+        nextRef: 1,
+    }
+    state.lastCompaction = 0
+    state.currentTurn = 0
+    state.modelContextLimit = undefined
+    state.systemPromptTokens = undefined
+}
+
+export async function ensureSessionInitialized(
+    client: any,
+    state: SessionState,
+    sessionId: string,
+    logger: Logger,
+    messages: WithParts[],
+    manualModeEnabled: boolean,
+): Promise<void> {
+    if (state.sessionId === sessionId) {
+        return
+    }
+
+    // logger.info("session ID = " + sessionId)
+    // logger.info("Initializing session state", { sessionId: sessionId })
+
+    resetSessionState(state)
+    state.manualMode = manualModeEnabled ? "active" : false
+    state.sessionId = sessionId
+
+    const isSubAgent = await isSubAgentSession(client, sessionId)
+    state.isSubAgent = isSubAgent
+    // logger.info("isSubAgent = " + isSubAgent)
+
+    state.lastCompaction = findLastCompactionTimestamp(messages)
+    state.currentTurn = countTurns(state, messages)
+    state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages)
+
+    const persisted = await loadSessionState(sessionId, logger)
+    if (persisted === null) {
+        return
+    }
+
+    if (typeof persisted.manualMode === "boolean") {
+        state.manualMode = persisted.manualMode ? "active" : false
+    }
+
+    state.prune.tools = loadPruneMap(persisted.prune.tools)
+    state.prune.messages = loadPruneMessagesState(persisted.prune.messages)
+    state.nudges.contextLimitAnchors = new Set<string>(persisted.nudges.contextLimitAnchors || [])
+    state.nudges.turnNudgeAnchors = new Set<string>([
+        ...state.nudges.turnNudgeAnchors,
+        ...(persisted.nudges.turnNudgeAnchors || []),
+    ])
+    state.nudges.iterationNudgeAnchors = new Set<string>(
+        persisted.nudges.iterationNudgeAnchors || [],
+    )
+    state.stats = {
+        pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
+        totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+    }
+
+    const applied = applyPendingCompressionDurations(state)
+    if (applied > 0) {
+        await saveSessionState(state, logger)
+    }
+}
+
+export async function refreshManualMode(
+    state: SessionState,
+    sessionId: string,
+    logger: Logger,
+    manualModeDefault: boolean,
+): Promise<void> {
+    if (state.manualMode === "compress-pending") {
+        return
+    }
+
+    const persisted = await loadManualModeSetting(sessionId, logger)
+    const enabled = persisted ?? manualModeDefault
+    state.manualMode = enabled ? "active" : false
+}