@tarquinen/opencode-dcp 3.2.5-beta0 → 3.2.6-beta0

package/lib/hooks.ts

@@ -0,0 +1,378 @@
+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 {
+    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",
+    "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[] }) => {
+        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") {
+            const messagesResponse = await client.session.messages({
+                path: { id: input.sessionID },
+            })
+            const messages = (messagesResponse.data || messagesResponse) as WithParts[]
+
+            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 subcommand = args[0]?.toLowerCase() || ""
+            const subArgs = args.slice(1)
+
+            const commandCtx = {
+                client,
+                state,
+                config,
+                logger,
+                sessionId: input.sessionID,
+                messages,
+            }
+
+            if (subcommand === "context") {
+                await handleContextCommand(commandCtx)
+                throw new Error("__DCP_CONTEXT_HANDLED__")
+            }
+
+            if (subcommand === "stats") {
+                await handleStatsCommand(commandCtx)
+                throw new Error("__DCP_STATS_HANDLED__")
+            }
+
+            if (subcommand === "sweep") {
+                await handleSweepCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                    workingDirectory,
+                })
+                throw new Error("__DCP_SWEEP_HANDLED__")
+            }
+
+            if (subcommand === "manual") {
+                await handleManualToggleCommand(commandCtx, subArgs[0]?.toLowerCase())
+                throw new Error("__DCP_MANUAL_HANDLED__")
+            }
+
+            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: rawArgs ? `/dcp ${rawArgs}` : `/dcp ${subcommand}`,
+                })
+                return
+            }
+
+            if (subcommand === "decompress") {
+                await handleDecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                throw new Error("__DCP_DECOMPRESS_HANDLED__")
+            }
+
+            if (subcommand === "recompress") {
+                await handleRecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                throw new Error("__DCP_RECOMPRESS_HANDLED__")
+            }
+
+            await handleHelpCommand(commandCtx)
+            throw new Error("__DCP_HELP_HANDLED__")
+        }
+    }
+}
+
+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),
+            )
+        }
+    }
+}
+
+export function createChatMessageHandler(
+    state: SessionState,
+    logger: Logger,
+    _config: PluginConfig,
+    _hostPermissions: HostPermissionSnapshot,
+) {
+    return async (
+        input: {
+            sessionID: string
+            agent?: string
+            model?: { providerID: string; modelID: string }
+            messageID?: string
+            variant?: string
+        },
+        _output: any,
+    ) => {
+        state.variant = input.variant
+        logger.debug("Cached variant from chat.message hook", { variant: input.variant })
+    }
+}

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
+}