opencode-claude-tailguard 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cabbage Lettuce
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# opencode-claude-tailguard
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.11. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const ClaudeTailguardPlugin: Plugin;

package/dist/index.js

@@ -0,0 +1,8 @@
+import { transformMessages } from "./transform";
+export const ClaudeTailguardPlugin = async (_ctx) => {
+    return {
+        "experimental.chat.messages.transform": async (_input, output) => {
+            transformMessages(output.messages);
+        },
+    };
+};

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+export declare const logger: {
+    log(...args: unknown[]): void;
+};

package/dist/logger.js

@@ -0,0 +1,25 @@
+import { createWriteStream } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { stdout } from "process";
+const defaultLogPath = join(homedir(), ".local", "share", "opencode", "claude-tailguard-plugin.log");
+function createLogger(options) {
+    const combinedOptions = {
+        stderr: true,
+        logfile: defaultLogPath,
+        ...options,
+    };
+    const stream = combinedOptions.logfile
+        ? createWriteStream(combinedOptions.logfile)
+        : null;
+    return {
+        log(...args) {
+            const line = `[${new Date().toISOString()}] ${args.join(' ')}\n`;
+            if (combinedOptions.stderr)
+                stdout.write(line);
+            if (stream)
+                stream.write(line);
+        }
+    };
+}
+export const logger = createLogger();

package/dist/transform.d.ts

@@ -0,0 +1,8 @@
+import type { Message, Part } from "@opencode-ai/sdk";
+export type MessageEntry = {
+    info: Message;
+    parts: Part[];
+};
+export declare function isTargetModel(modelID: string): boolean;
+export declare function hasContent(part: Part): boolean;
+export declare function transformMessages(messages: MessageEntry[]): void;

package/dist/transform.js

@@ -0,0 +1,102 @@
+import { logger } from "./logger";
+// Matches Claude 4.5/4.6 variants where prefill is not supported
+// Handles separators: -, ., _ between major.minor version
+const TARGET_PATTERN = /claude-(opus|sonnet|haiku)-4[._-][56]/;
+export function isTargetModel(modelID) {
+    return TARGET_PATTERN.test(modelID);
+}
+// Returns true if a part carries meaningful content
+// Structure-only parts (step-start, step-finish, etc.) return false
+export function hasContent(part) {
+    switch (part.type) {
+        case "text":
+            return part.text.length > 0;
+        case "reasoning":
+            return (part.text.length > 0 ||
+                (part.metadata !== undefined && Object.keys(part.metadata).length > 0));
+        case "tool":
+        case "file":
+            return true;
+        case "agent":
+            return part.source !== undefined;
+        default:
+            return false;
+    }
+}
+function isEmptyAssistantMessage(entry) {
+    return entry.info.role === "assistant" && !entry.parts.some(hasContent);
+}
+function findLatestUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg !== undefined && msg.info.role === "user") {
+            return msg;
+        }
+    }
+    return undefined;
+}
+function createSyntheticUserMessage(sessionID, agent, model) {
+    const id = crypto.randomUUID();
+    const info = {
+        role: "user",
+        id,
+        sessionID,
+        time: { created: Date.now() },
+        agent,
+        model,
+    };
+    const part = {
+        id: crypto.randomUUID(),
+        sessionID,
+        messageID: id,
+        type: "text",
+        text: "Continue.",
+    };
+    return { info, parts: [part] };
+}
+// Transforms the message array in-place to ensure it ends with a user message
+// when targeting Claude 4.6 models.
+//
+// Algorithm:
+// 1. No-op if last message is not assistant
+// 2. No-op if latest user message is not a target model
+// 3. Pop consecutive empty assistant messages from tail
+// 4. If tail is still assistant (has content), append synthetic "Continue." user message
+export function transformMessages(messages) {
+    logger.log("transform called:", messages.length, "messages");
+    const last = messages[messages.length - 1];
+    if (!last || last.info.role !== "assistant") {
+        logger.log("skip: last message is not assistant");
+        return;
+    }
+    const latestUser = findLatestUserMessage(messages);
+    if (!latestUser) {
+        logger.log("skip: no user message found");
+        return;
+    }
+    if (!isTargetModel(latestUser.info.model.modelID)) {
+        logger.log("skip: non-target model:", latestUser.info.model.modelID);
+        return;
+    }
+    logger.log("target model:", latestUser.info.model.modelID);
+    let removed = 0;
+    while (messages.length > 0) {
+        const tail = messages[messages.length - 1];
+        if (!tail || !isEmptyAssistantMessage(tail))
+            break;
+        messages.pop();
+        removed++;
+    }
+    if (removed > 0) {
+        logger.log("removed", removed, "empty assistant message(s)");
+    }
+    const newLast = messages[messages.length - 1];
+    if (newLast && newLast.info.role === "assistant") {
+        logger.log("appending synthetic 'Continue.' user message");
+        messages.push(createSyntheticUserMessage(newLast.info.sessionID, latestUser.info.agent, latestUser.info.model));
+    }
+    else if (removed > 0) {
+        logger.log("no synthetic message needed: empty assistant(s) removed");
+    }
+    logger.log("transform complete:", messages.length, "messages");
+}

package/dist/transform.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transform.test.js

@@ -0,0 +1,297 @@
+import { describe, expect, test } from "bun:test";
+import { hasContent, isTargetModel, transformMessages } from "./transform";
+const SESSION_ID = "test-session";
+const AGENT = "test-agent";
+let _idCounter = 0;
+function nextId() {
+    return `id-${++_idCounter}`;
+}
+function makeUserEntry(modelID = "claude-opus-4-6") {
+    return {
+        info: {
+            role: "user",
+            id: nextId(),
+            sessionID: SESSION_ID,
+            time: { created: Date.now() },
+            agent: AGENT,
+            model: { providerID: "anthropic", modelID },
+        },
+        parts: [],
+    };
+}
+function makeAssistantEntry(parts) {
+    return {
+        info: {
+            role: "assistant",
+            id: nextId(),
+            sessionID: SESSION_ID,
+            parentID: nextId(),
+            modelID: "claude-opus-4-6",
+            providerID: "anthropic",
+            mode: "chat",
+            path: { cwd: "/", root: "/" },
+            cost: 0,
+            tokens: {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                cache: { read: 0, write: 0 },
+            },
+            time: { created: Date.now() },
+        },
+        parts,
+    };
+}
+function makeTextPart(text) {
+    return {
+        id: nextId(),
+        sessionID: SESSION_ID,
+        messageID: nextId(),
+        type: "text",
+        text,
+    };
+}
+function makeReasoningPart(text, metadata) {
+    return {
+        id: nextId(),
+        sessionID: SESSION_ID,
+        messageID: nextId(),
+        type: "reasoning",
+        text,
+        metadata,
+        time: { start: Date.now() },
+    };
+}
+function makeToolPart() {
+    return {
+        id: nextId(),
+        sessionID: SESSION_ID,
+        messageID: nextId(),
+        type: "tool",
+        callID: nextId(),
+        tool: "bash",
+        state: {
+            status: "completed",
+            input: {},
+            output: "ok",
+            title: "bash",
+            metadata: {},
+            time: { start: 0, end: 1 },
+        },
+    };
+}
+function makeStepStartPart() {
+    return {
+        id: nextId(),
+        sessionID: SESSION_ID,
+        messageID: nextId(),
+        type: "step-start",
+    };
+}
+function makeStepFinishPart() {
+    return {
+        id: nextId(),
+        sessionID: SESSION_ID,
+        messageID: nextId(),
+        type: "step-finish",
+        reason: "end_turn",
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    };
+}
+// ─── isTargetModel ─────────────────────────────────────────────────────────
+describe("isTargetModel", () => {
+    test("matches claude-opus-4-6 (hyphen separator)", () => {
+        expect(isTargetModel("claude-opus-4-6")).toBe(true);
+    });
+    test("matches claude-opus-4.6 (dot separator)", () => {
+        expect(isTargetModel("claude-opus-4.6")).toBe(true);
+    });
+    test("matches claude-sonnet-4-6", () => {
+        expect(isTargetModel("claude-sonnet-4-6")).toBe(true);
+    });
+    test("matches claude-haiku-4-5", () => {
+        expect(isTargetModel("claude-haiku-4-5")).toBe(true);
+    });
+    test("matches claude-sonnet-4.5", () => {
+        expect(isTargetModel("claude-sonnet-4.5")).toBe(true);
+    });
+    test("does not match claude-3-opus", () => {
+        expect(isTargetModel("claude-3-opus")).toBe(false);
+    });
+    test("does not match gpt-4", () => {
+        expect(isTargetModel("gpt-4")).toBe(false);
+    });
+    test("does not match claude-opus-4-4", () => {
+        expect(isTargetModel("claude-opus-4-4")).toBe(false);
+    });
+});
+// ─── hasContent ─────────────────────────────────────────────────────────────
+describe("hasContent", () => {
+    test("TextPart with content returns true", () => {
+        expect(hasContent(makeTextPart("hello"))).toBe(true);
+    });
+    test("TextPart with empty string returns false", () => {
+        expect(hasContent(makeTextPart(""))).toBe(false);
+    });
+    test("ReasoningPart with text returns true", () => {
+        expect(hasContent(makeReasoningPart("thinking..."))).toBe(true);
+    });
+    test("ReasoningPart with empty text and no metadata returns false", () => {
+        expect(hasContent(makeReasoningPart(""))).toBe(false);
+    });
+    test("ReasoningPart with empty text and signature in metadata returns true", () => {
+        expect(hasContent(makeReasoningPart("", { signature: "abc123" }))).toBe(true);
+    });
+    test("ReasoningPart with empty text and empty metadata returns false", () => {
+        expect(hasContent(makeReasoningPart("", {}))).toBe(false);
+    });
+    test("ToolPart always returns true", () => {
+        expect(hasContent(makeToolPart())).toBe(true);
+    });
+    test("StepStartPart returns false", () => {
+        expect(hasContent(makeStepStartPart())).toBe(false);
+    });
+    test("StepFinishPart returns false", () => {
+        expect(hasContent(makeStepFinishPart())).toBe(false);
+    });
+});
+// ─── transformMessages ──────────────────────────────────────────────────────
+describe("transformMessages", () => {
+    test("empty array: no-op", () => {
+        const messages = [];
+        transformMessages(messages);
+        expect(messages).toHaveLength(0);
+    });
+    test("last message is user: no-op", () => {
+        const messages = [makeUserEntry()];
+        transformMessages(messages);
+        expect(messages).toHaveLength(1);
+        expect(messages[0]?.info.role).toBe("user");
+    });
+    test("non-target model: no-op", () => {
+        const messages = [
+            makeUserEntry("gpt-4o"),
+            makeAssistantEntry([makeTextPart("hello")]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(2);
+    });
+    test("no user message at all: no-op", () => {
+        const messages = [makeAssistantEntry([makeTextPart("hello")])];
+        transformMessages(messages);
+        expect(messages).toHaveLength(1);
+    });
+    // Pattern 1: [U, A(text+thinking)] → [U, A(text+thinking), U("Continue.")]
+    test("pattern 1: content-bearing assistant → append Continue", () => {
+        const messages = [
+            makeUserEntry(),
+            makeAssistantEntry([
+                makeTextPart("hello"),
+                makeReasoningPart("thinking"),
+            ]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(3);
+        expect(messages[2]?.info.role).toBe("user");
+        expect(messages[2]?.parts[0]).toMatchObject({
+            type: "text",
+            text: "Continue.",
+        });
+    });
+    // Pattern 2: [U, A(text+thinking), A(empty)] → [U, A(text+thinking), U("Continue.")]
+    test("pattern 2: empty assistant after content-bearing → remove empty + append Continue", () => {
+        const messages = [
+            makeUserEntry(),
+            makeAssistantEntry([
+                makeTextPart("hello"),
+                makeReasoningPart("thinking"),
+            ]),
+            makeAssistantEntry([makeStepStartPart(), makeStepFinishPart()]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(3);
+        expect(messages[1]?.parts).toHaveLength(2);
+        expect(messages[2]?.info.role).toBe("user");
+        expect(messages[2]?.parts[0]).toMatchObject({
+            type: "text",
+            text: "Continue.",
+        });
+    });
+    // Pattern 3: [U, A(empty)] → [U]
+    test("pattern 3: single empty assistant → remove only", () => {
+        const messages = [
+            makeUserEntry(),
+            makeAssistantEntry([makeStepStartPart(), makeStepFinishPart()]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(1);
+        expect(messages[0]?.info.role).toBe("user");
+    });
+    // Pattern 4: [U, A(empty), A(empty)] → [U]
+    test("pattern 4: multiple empty assistants → remove all", () => {
+        const messages = [
+            makeUserEntry(),
+            makeAssistantEntry([makeStepStartPart()]),
+            makeAssistantEntry([makeStepFinishPart()]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(1);
+        expect(messages[0]?.info.role).toBe("user");
+    });
+    // Pattern 5: [U, A(reasoning with signature, text="")] → [U, A, U("Continue.")]
+    test("pattern 5: signed reasoning with empty text → preserve assistant + append Continue", () => {
+        const messages = [
+            makeUserEntry(),
+            makeAssistantEntry([makeReasoningPart("", { signature: "abc123" })]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(3);
+        expect(messages[1]?.info.role).toBe("assistant");
+        expect(messages[2]?.info.role).toBe("user");
+        expect(messages[2]?.parts[0]).toMatchObject({
+            type: "text",
+            text: "Continue.",
+        });
+    });
+    // Pattern 6: [U, A(tool+thinking)] → [U, A(tool+thinking), U("Continue.")]
+    test("pattern 6: assistant with tool + reasoning → append Continue", () => {
+        const messages = [
+            makeUserEntry(),
+            makeAssistantEntry([makeToolPart(), makeReasoningPart("thinking")]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(3);
+        expect(messages[2]?.info.role).toBe("user");
+        expect(messages[2]?.parts[0]).toMatchObject({
+            type: "text",
+            text: "Continue.",
+        });
+    });
+    test("synthetic message sessionID matches last assistant", () => {
+        const assistant = makeAssistantEntry([makeTextPart("hello")]);
+        const messages = [makeUserEntry(), assistant];
+        const assistantSessionID = assistant.info.sessionID;
+        transformMessages(messages);
+        expect(messages[2]?.info.sessionID).toBe(assistantSessionID);
+    });
+    test("synthetic message agent and model come from latest user message", () => {
+        const user = makeUserEntry("claude-sonnet-4-6");
+        const messages = [user, makeAssistantEntry([makeTextPart("hello")])];
+        transformMessages(messages);
+        const synthetic = messages[2]?.info;
+        expect(synthetic.agent).toBe(AGENT);
+        expect(synthetic.model.modelID).toBe("claude-sonnet-4-6");
+    });
+    test("synthetic text part has messageID matching synthetic message id", () => {
+        const messages = [
+            makeUserEntry(),
+            makeAssistantEntry([makeTextPart("hello")]),
+        ];
+        transformMessages(messages);
+        expect(messages).toHaveLength(3);
+        const syntheticMsg = messages[2];
+        const syntheticPart = syntheticMsg.parts[0];
+        expect(syntheticPart.messageID).toBe(syntheticMsg.info.id);
+    });
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "opencode-claude-tailguard",
+  "version": "0.0.0",
+  "keywords": [
+    "opencode",
+    "plugin"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Cabbage Lettuce",
+    "url": "https://github.com/pycabbage/",
+    "email": "33714346+pycabbage@users.noreply.github.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pycabbage/opencode-claude-tailguard/"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "lint": "biome check"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.9",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5",
+    "@opencode-ai/plugin": "^1.3.3"
+  }
+}