@tarquinen/opencode-dcp 3.1.12 → 3.1.13

package/lib/hooks.ts

@@ -0,0 +1,375 @@
+import type { SessionState, WithParts } from "./state"
+import type { Logger } from "./logger"
+import type { PluginConfig } from "./config"
+import { assignMessageRefs } from "./message-ids"
+import {
+    buildPriorityMap,
+    buildToolIdList,
+    injectCompressNudges,
+    injectExtendedSubAgentResults,
+    injectMessageIds,
+    prune,
+    stripHallucinations,
+    stripHallucinationsFromString,
+    stripStaleMetadata,
+    syncCompressionBlocks,
+} from "./messages"
+import { renderSystemPrompt, type PromptStore } from "./prompts"
+import { buildProtectedToolsExtension } from "./prompts/extensions/system"
+import {
+    applyPendingCompressionDurations,
+    buildCompressionTimingKey,
+    consumeCompressionStart,
+    resolveCompressionDuration,
+} from "./compress/timing"
+import { filterMessages, filterMessagesInPlace } from "./messages/shape"
+import {
+    applyPendingManualTrigger,
+    handleContextCommand,
+    handleDecompressCommand,
+    handleHelpCommand,
+    handleManualToggleCommand,
+    handleManualTriggerCommand,
+    handleRecompressCommand,
+    handleStatsCommand,
+    handleSweepCommand,
+} from "./commands"
+import { type HostPermissionSnapshot } from "./host-permissions"
+import { compressPermission, syncCompressPermissionState } from "./compress-permission"
+import { checkSession, ensureSessionInitialized, saveSessionState, syncToolCache } from "./state"
+import { cacheSystemPromptTokens } from "./ui/utils"
+
+const INTERNAL_AGENT_SIGNATURES = [
+    "You are a title generator",
+    "You are a helpful AI assistant tasked with summarizing conversations",
+    "You are an anchored context summarization assistant for coding sessions",
+    "Summarize what was done in this conversation",
+]
+
+export function createSystemPromptHandler(
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    prompts: PromptStore,
+) {
+    return async (
+        input: { sessionID?: string; model: { limit: { context: number } } },
+        output: { system: string[] },
+    ) => {
+        if (input.model?.limit?.context) {
+            state.modelContextLimit = input.model.limit.context
+            logger.debug("Cached model context limit", { limit: state.modelContextLimit })
+        }
+
+        if (state.isSubAgent && !config.experimental.allowSubAgents) {
+            return
+        }
+
+        const systemText = output.system.join("\n")
+        if (INTERNAL_AGENT_SIGNATURES.some((sig) => systemText.includes(sig))) {
+            logger.info("Skipping DCP system prompt injection for internal agent")
+            return
+        }
+
+        const effectivePermission =
+            input.sessionID && state.sessionId === input.sessionID
+                ? compressPermission(state, config)
+                : config.compress.permission
+
+        if (effectivePermission === "deny") {
+            return
+        }
+
+        prompts.reload()
+        const runtimePrompts = prompts.getRuntimePrompts()
+        const newPrompt = renderSystemPrompt(
+            runtimePrompts,
+            buildProtectedToolsExtension(config.compress.protectedTools),
+            !!state.manualMode,
+            state.isSubAgent && config.experimental.allowSubAgents,
+        )
+        if (output.system.length > 0) {
+            output.system[output.system.length - 1] += "\n\n" + newPrompt
+        } else {
+            output.system.push(newPrompt)
+        }
+    }
+}
+
+export function createChatMessageTransformHandler(
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    prompts: PromptStore,
+    hostPermissions: HostPermissionSnapshot,
+) {
+    return async (input: {}, output: { messages: WithParts[] }) => {
+        const receivedMessages = Array.isArray(output.messages) ? output.messages.length : 0
+        const messages = filterMessagesInPlace(output.messages)
+        if (messages.length !== receivedMessages) {
+            logger.warn("Skipping messages with unexpected shape during chat transform", {
+                received: receivedMessages,
+                usable: messages.length,
+            })
+        }
+
+        await checkSession(client, state, logger, output.messages, config.manualMode.enabled)
+
+        syncCompressPermissionState(state, config, hostPermissions, output.messages)
+
+        if (state.isSubAgent && !config.experimental.allowSubAgents) {
+            return
+        }
+
+        stripHallucinations(output.messages)
+        cacheSystemPromptTokens(state, output.messages)
+        assignMessageRefs(state, output.messages)
+        syncCompressionBlocks(state, logger, output.messages)
+        syncToolCache(state, config, logger, output.messages)
+        buildToolIdList(state, output.messages)
+        prune(state, logger, config, output.messages)
+        await injectExtendedSubAgentResults(
+            client,
+            state,
+            logger,
+            output.messages,
+            config.experimental.allowSubAgents,
+        )
+        const compressionPriorities = buildPriorityMap(config, state, output.messages)
+        prompts.reload()
+        injectCompressNudges(
+            state,
+            config,
+            logger,
+            output.messages,
+            prompts.getRuntimePrompts(),
+            compressionPriorities,
+        )
+        injectMessageIds(state, config, output.messages, compressionPriorities)
+        applyPendingManualTrigger(state, output.messages, logger)
+        stripStaleMetadata(output.messages)
+
+        if (state.sessionId) {
+            await logger.saveContext(state.sessionId, output.messages)
+        }
+    }
+}
+
+export function createCommandExecuteHandler(
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    workingDirectory: string,
+    hostPermissions: HostPermissionSnapshot,
+) {
+    return async (
+        input: { command: string; sessionID: string; arguments: string },
+        output: { parts: any[] },
+    ) => {
+        if (!config.commands.enabled) {
+            return
+        }
+
+        if (input.command === "dcp" || input.command === "dcp-compress") {
+            const messagesResponse = await client.session.messages({
+                path: { id: input.sessionID },
+            })
+            const messages = filterMessages(messagesResponse.data || messagesResponse)
+
+            await ensureSessionInitialized(
+                client,
+                state,
+                input.sessionID,
+                logger,
+                messages,
+                config.manualMode.enabled,
+            )
+
+            syncCompressPermissionState(state, config, hostPermissions, messages)
+
+            const effectivePermission = compressPermission(state, config)
+            if (effectivePermission === "deny") {
+                return
+            }
+
+            const args = (input.arguments || "").trim().split(/\s+/).filter(Boolean)
+            const isCompressCommand = input.command === "dcp-compress"
+            const subcommand = isCompressCommand ? "compress" : args[0]?.toLowerCase() || ""
+            const subArgs = isCompressCommand ? args : args.slice(1)
+
+            const commandCtx = {
+                client,
+                state,
+                config,
+                logger,
+                sessionId: input.sessionID,
+                messages,
+            }
+
+            if (subcommand === "context") {
+                await handleContextCommand(commandCtx)
+                return
+            }
+
+            if (subcommand === "stats") {
+                await handleStatsCommand(commandCtx)
+                return
+            }
+
+            if (subcommand === "sweep") {
+                await handleSweepCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                    workingDirectory,
+                })
+                return
+            }
+
+            if (subcommand === "manual") {
+                await handleManualToggleCommand(commandCtx, subArgs[0]?.toLowerCase())
+                return
+            }
+
+            if (subcommand === "compress") {
+                const userFocus = subArgs.join(" ").trim()
+                const prompt = await handleManualTriggerCommand(commandCtx, "compress", userFocus)
+                if (!prompt) {
+                    throw new Error("__DCP_MANUAL_TRIGGER_BLOCKED__")
+                }
+
+                state.manualMode = "compress-pending"
+                state.pendingManualTrigger = {
+                    sessionId: input.sessionID,
+                    prompt,
+                }
+                const rawArgs = (input.arguments || "").trim()
+                output.parts.length = 0
+                output.parts.push({
+                    type: "text",
+                    text: isCompressCommand
+                        ? rawArgs
+                            ? `/dcp-compress ${rawArgs}`
+                            : "/dcp-compress"
+                        : rawArgs
+                          ? `/dcp ${rawArgs}`
+                          : `/dcp ${subcommand}`,
+                })
+                return
+            }
+
+            if (subcommand === "decompress") {
+                await handleDecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                return
+            }
+
+            if (subcommand === "recompress") {
+                await handleRecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                return
+            }
+
+            await handleHelpCommand(commandCtx)
+            return
+        }
+    }
+}
+
+export function createTextCompleteHandler() {
+    return async (
+        _input: { sessionID: string; messageID: string; partID: string },
+        output: { text: string },
+    ) => {
+        output.text = stripHallucinationsFromString(output.text)
+    }
+}
+
+export function createEventHandler(state: SessionState, logger: Logger) {
+    return async (input: { event: any }) => {
+        const eventTime =
+            typeof input.event?.time === "number" && Number.isFinite(input.event.time)
+                ? input.event.time
+                : typeof input.event?.properties?.time === "number" &&
+                    Number.isFinite(input.event.properties.time)
+                  ? input.event.properties.time
+                  : undefined
+
+        if (input.event.type !== "message.part.updated") {
+            return
+        }
+
+        const part = input.event.properties?.part
+        if (part?.type !== "tool" || part.tool !== "compress") {
+            return
+        }
+
+        if (part.state.status === "pending") {
+            if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
+                return
+            }
+
+            const startedAt = eventTime ?? Date.now()
+            const key = buildCompressionTimingKey(part.messageID, part.callID)
+            if (state.compressionTiming.startsByCallId.has(key)) {
+                return
+            }
+            state.compressionTiming.startsByCallId.set(key, startedAt)
+            logger.debug("Recorded compression start", {
+                messageID: part.messageID,
+                callID: part.callID,
+                startedAt,
+            })
+            return
+        }
+
+        if (part.state.status === "completed") {
+            if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
+                return
+            }
+
+            const key = buildCompressionTimingKey(part.messageID, part.callID)
+            const start = consumeCompressionStart(state, part.messageID, part.callID)
+            const durationMs = resolveCompressionDuration(start, eventTime, part.state.time)
+            if (typeof durationMs !== "number") {
+                return
+            }
+
+            state.compressionTiming.pendingByCallId.set(key, {
+                messageId: part.messageID,
+                callId: part.callID,
+                durationMs,
+            })
+
+            const updates = applyPendingCompressionDurations(state)
+            if (updates === 0) {
+                return
+            }
+
+            await saveSessionState(state, logger)
+
+            logger.info("Attached compression time to blocks", {
+                messageID: part.messageID,
+                callID: part.callID,
+                blocks: updates,
+                durationMs,
+            })
+            return
+        }
+
+        if (part.state.status === "running") {
+            return
+        }
+
+        if (typeof part.callID === "string" && typeof part.messageID === "string") {
+            state.compressionTiming.startsByCallId.delete(
+                buildCompressionTimingKey(part.messageID, part.callID),
+            )
+        }
+    }
+}

package/lib/host-permissions.ts

@@ -0,0 +1,101 @@
+export type PermissionAction = "ask" | "allow" | "deny"
+
+export type PermissionValue = PermissionAction | Record<string, PermissionAction>
+
+export type PermissionConfig = Record<string, PermissionValue> | undefined
+
+export interface HostPermissionSnapshot {
+    global: PermissionConfig
+    agents: Record<string, PermissionConfig>
+}
+
+type PermissionRule = {
+    permission: string
+    pattern: string
+    action: PermissionAction
+}
+
+const findLastMatchingRule = (
+    rules: PermissionRule[],
+    predicate: (rule: PermissionRule) => boolean,
+): PermissionRule | undefined => {
+    for (let index = rules.length - 1; index >= 0; index -= 1) {
+        const rule = rules[index]
+        if (rule && predicate(rule)) {
+            return rule
+        }
+    }
+
+    return undefined
+}
+
+const wildcardMatch = (value: string, pattern: string): boolean => {
+    const normalizedValue = value.replaceAll("\\", "/")
+    let escaped = pattern
+        .replaceAll("\\", "/")
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".")
+
+    if (escaped.endsWith(" .*")) {
+        escaped = escaped.slice(0, -3) + "( .*)?"
+    }
+
+    const flags = process.platform === "win32" ? "si" : "s"
+    return new RegExp(`^${escaped}$`, flags).test(normalizedValue)
+}
+
+const getPermissionRules = (permissionConfigs: PermissionConfig[]): PermissionRule[] => {
+    const rules: PermissionRule[] = []
+    for (const permissionConfig of permissionConfigs) {
+        if (!permissionConfig) {
+            continue
+        }
+
+        for (const [permission, value] of Object.entries(permissionConfig)) {
+            if (value === "ask" || value === "allow" || value === "deny") {
+                rules.push({ permission, pattern: "*", action: value })
+                continue
+            }
+
+            for (const [pattern, action] of Object.entries(value)) {
+                if (action === "ask" || action === "allow" || action === "deny") {
+                    rules.push({ permission, pattern, action })
+                }
+            }
+        }
+    }
+    return rules
+}
+
+export const compressDisabledByOpencode = (...permissionConfigs: PermissionConfig[]): boolean => {
+    const match = findLastMatchingRule(getPermissionRules(permissionConfigs), (rule) =>
+        wildcardMatch("compress", rule.permission),
+    )
+
+    return match?.pattern === "*" && match.action === "deny"
+}
+
+export const resolveEffectiveCompressPermission = (
+    basePermission: PermissionAction,
+    hostPermissions: HostPermissionSnapshot,
+    agentName?: string,
+): PermissionAction => {
+    if (basePermission === "deny") {
+        return "deny"
+    }
+
+    return compressDisabledByOpencode(
+        hostPermissions.global,
+        agentName ? hostPermissions.agents[agentName] : undefined,
+    )
+        ? "deny"
+        : basePermission
+}
+
+export const hasExplicitToolPermission = (
+    permissionConfig: PermissionConfig,
+    tool: string,
+): boolean => {
+    return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool) : false
+}

package/lib/logger.ts

@@ -0,0 +1,226 @@
+import { writeFile, mkdir } from "fs/promises"
+import { join } from "path"
+import { existsSync } from "fs"
+import { homedir } from "os"
+
+export class Logger {
+    private logDir: string
+    public enabled: boolean
+
+    constructor(enabled: boolean) {
+        this.enabled = enabled
+        const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
+        this.logDir = join(configHome, "opencode", "logs", "dcp")
+    }
+
+    private async ensureLogDir() {
+        if (!existsSync(this.logDir)) {
+            await mkdir(this.logDir, { recursive: true })
+        }
+    }
+
+    private formatData(data?: any): string {
+        if (!data) return ""
+
+        const parts: string[] = []
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined || value === null) continue
+
+            // Format arrays compactly
+            if (Array.isArray(value)) {
+                if (value.length === 0) continue
+                parts.push(
+                    `${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`,
+                )
+            } else if (typeof value === "object") {
+                const str = JSON.stringify(value)
+                if (str.length < 50) {
+                    parts.push(`${key}=${str}`)
+                }
+            } else {
+                parts.push(`${key}=${value}`)
+            }
+        }
+        return parts.join(" ")
+    }
+
+    private getCallerFile(skipFrames: number = 3): string {
+        const originalPrepareStackTrace = Error.prepareStackTrace
+        try {
+            const err = new Error()
+            Error.prepareStackTrace = (_, stack) => stack
+            const stack = err.stack as unknown as NodeJS.CallSite[]
+            Error.prepareStackTrace = originalPrepareStackTrace
+
+            // Skip specified number of frames to get to actual caller
+            for (let i = skipFrames; i < stack.length; i++) {
+                const filename = stack[i]?.getFileName()
+                if (filename && !filename.includes("/logger.")) {
+                    // Extract just the filename without path and extension
+                    const match = filename.match(/([^/\\]+)\.[tj]s$/)
+                    return match ? match[1] : filename
+                }
+            }
+            return "unknown"
+        } catch {
+            return "unknown"
+        }
+    }
+
+    private async write(level: string, component: string, message: string, data?: any) {
+        if (!this.enabled) return
+
+        try {
+            await this.ensureLogDir()
+
+            const timestamp = new Date().toISOString()
+            const dataStr = this.formatData(data)
+
+            const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? " | " + dataStr : ""}\n`
+
+            const dailyLogDir = join(this.logDir, "daily")
+            if (!existsSync(dailyLogDir)) {
+                await mkdir(dailyLogDir, { recursive: true })
+            }
+
+            const logFile = join(dailyLogDir, `${new Date().toISOString().split("T")[0]}.log`)
+            await writeFile(logFile, logLine, { flag: "a" })
+        } catch (error) {}
+    }
+
+    info(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("INFO", component, message, data)
+    }
+
+    debug(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("DEBUG", component, message, data)
+    }
+
+    warn(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("WARN", component, message, data)
+    }
+
+    error(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("ERROR", component, message, data)
+    }
+
+    /**
+     * Strips unnecessary metadata from messages for cleaner debug logs.
+     *
+     * Removed:
+     * - All IDs (id, sessionID, messageID, parentID)
+     * - summary, path, cost, model, agent, mode, finish, providerID, modelID
+     * - step-start and step-finish parts entirely
+     * - snapshot fields
+     * - ignored text parts
+     *
+     * Kept:
+     * - role, time (created only), tokens (input, output, reasoning, cache)
+     * - text, reasoning, tool parts with content
+     * - tool calls with: tool, callID, input, output, metadata
+     */
+    private minimizeForDebug(messages: any[]): any[] {
+        return messages.map((msg) => {
+            const minimized: any = {
+                role: msg.info?.role,
+            }
+
+            if (msg.info?.time?.created) {
+                minimized.time = msg.info.time.created
+            }
+
+            if (msg.info?.tokens) {
+                minimized.tokens = {
+                    input: msg.info.tokens.input,
+                    output: msg.info.tokens.output,
+                    reasoning: msg.info.tokens.reasoning,
+                    cache: msg.info.tokens.cache,
+                }
+            }
+
+            if (msg.parts) {
+                minimized.parts = msg.parts
+                    .map((part: any) => {
+                        if (part.type === "step-start" || part.type === "step-finish") {
+                            return null
+                        }
+
+                        if (part.type === "text") {
+                            if (part.ignored) return null
+                            const textPart: any = { type: "text", text: part.text }
+                            if (part.metadata) textPart.metadata = part.metadata
+                            return textPart
+                        }
+
+                        if (part.type === "reasoning") {
+                            const reasoningPart: any = { type: "reasoning", text: part.text }
+                            if (part.metadata) reasoningPart.metadata = part.metadata
+                            return reasoningPart
+                        }
+
+                        if (part.type === "tool") {
+                            const toolPart: any = {
+                                type: "tool",
+                                tool: part.tool,
+                                callID: part.callID,
+                            }
+
+                            if (part.state?.status) {
+                                toolPart.status = part.state.status
+                            }
+                            if (part.state?.input) {
+                                toolPart.input = part.state.input
+                            }
+                            if (part.state?.output) {
+                                toolPart.output = part.state.output
+                            }
+                            if (part.state?.error) {
+                                toolPart.error = part.state.error
+                            }
+                            if (part.metadata) {
+                                toolPart.metadata = part.metadata
+                            }
+                            if (part.state?.metadata) {
+                                toolPart.metadata = {
+                                    ...(toolPart.metadata || {}),
+                                    ...part.state.metadata,
+                                }
+                            }
+                            if (part.state?.title) {
+                                toolPart.title = part.state.title
+                            }
+
+                            return toolPart
+                        }
+
+                        return null
+                    })
+                    .filter(Boolean)
+            }
+
+            return minimized
+        })
+    }
+
+    async saveContext(sessionId: string, messages: any[]) {
+        if (!this.enabled) return
+
+        try {
+            const contextDir = join(this.logDir, "context", sessionId)
+            if (!existsSync(contextDir)) {
+                await mkdir(contextDir, { recursive: true })
+            }
+
+            const minimized = this.minimizeForDebug(messages).filter(
+                (msg) => msg.parts && msg.parts.length > 0,
+            )
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+            const contextFile = join(contextDir, `${timestamp}.json`)
+            await writeFile(contextFile, JSON.stringify(minimized, null, 2))
+        } catch (error) {}
+    }
+}