@haposoft/cafekit 0.8.17 → 0.9.1

package/src/opencode/plugins/privacy-block.ts

@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * OpenCode Plugin — privacy-block.ts
+ *
+ * Port of .claude/hooks/privacy-block.cjs to OpenCode plugin protocol.
+ *
+ * Behavior:
+ * - Match tool input paths against RESTRICTED_PATTERNS.
+ * - For `bash`: log warning and allow (caller may have user approval already).
+ * - For other tools: throw with @@PRIVACY_PROMPT_START@@ marker payload so the
+ *   assistant prompts the user before retrying via bash cat.
+ *
+ * Disable via `.opencode/runtime.json` { "privacyBlock": false }.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import { existsSync, readFileSync, mkdirSync, appendFileSync } from "node:fs";
+import { join, basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const RESTRICTED_PATTERNS: RegExp[] = [
+  /^\.env(\.|$)/i,
+  /^credentials/i,
+  /secrets?\.(ya?ml|json)$/i,
+  /\.pem$/i,
+  /\.key$/i,
+  /\.p12$/i,
+  /\.pfx$/i,
+  /^id_(rsa|ed25519|ecdsa|dsa)$/i,
+  /\.netrc$/i,
+  /\.pgpass$/i,
+  /kubeconfig/i,
+  /\.keystore$/i,
+  /\.jks$/i,
+  /auth\.json$/i,
+  /token(s)?\.json$/i,
+];
+
+const ALLOWED_EXEMPTIONS: RegExp[] = [/\.env\.(example|sample|template|test)$/i];
+
+const GATED_TOOLS = new Set(["read", "write", "edit", "glob", "grep", "bash"]);
+
+const PLUGIN_DIR = dirname(fileURLToPath(import.meta.url));
+
+function readRuntime(cwd: string): Record<string, unknown> {
+  try {
+    const file = join(cwd, ".opencode", "runtime.json");
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+  } catch {
+    return {};
+  }
+}
+
+function isSafe(filePath: string): boolean {
+  const base = basename(filePath);
+  return ALLOWED_EXEMPTIONS.some((rule) => rule.test(base) || rule.test(filePath));
+}
+
+function isSensitive(filePath: string): boolean {
+  const base = basename(filePath);
+  return RESTRICTED_PATTERNS.some((rule) => rule.test(base) || rule.test(filePath));
+}
+
+function extractBashPaths(command: string): string[] {
+  const paths: string[] = [];
+  const regex = /(?:cat|less|more|head|tail|source|\.)\s+(?:"([^"]+)"|'([^']+)'|([^\s]+))/g;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(command)) !== null) {
+    const value = match[1] || match[2] || match[3];
+    if (value) paths.push(value);
+  }
+  return paths;
+}
+
+function extractPaths(tool: string, args: Record<string, unknown>): string[] {
+  const paths: string[] = [];
+  if (!args) return paths;
+
+  const filePath = typeof args.filePath === "string" ? args.filePath.trim() : "";
+  if (filePath) paths.push(filePath);
+
+  const path = typeof args.path === "string" ? args.path.trim() : "";
+  if (path) paths.push(path);
+
+  if (tool === "bash" && typeof args.command === "string") {
+    paths.push(...extractBashPaths(args.command));
+  }
+
+  return paths.filter(Boolean);
+}
+
+function formatBlockMessage(filePath: string): string {
+  const fileBase = basename(filePath);
+  const promptData = {
+    type: "PRIVACY_PROMPT",
+    file: filePath,
+    basename: fileBase,
+    question: {
+      header: "File Access",
+      text: `I need to read "${fileBase}" which may contain sensitive data (API keys, passwords, tokens). Do you approve?`,
+      options: [
+        {
+          label: "Yes, approve access",
+          description: `Allow reading ${fileBase} this time`,
+        },
+        {
+          label: "No, skip this file",
+          description: "Continue without accessing this file",
+        },
+      ],
+    },
+  };
+
+  return [
+    "NOTE: This is not an error. This block protects sensitive data.",
+    "",
+    "PRIVACY BLOCK: Sensitive file access requires user approval",
+    `File: ${filePath}`,
+    "",
+    "@@PRIVACY_PROMPT_START@@",
+    JSON.stringify(promptData, null, 2),
+    "@@PRIVACY_PROMPT_END@@",
+    "",
+    "OpenCode follow-up:",
+    `- If approved: use bash to read: cat "${filePath}"`,
+    "- If denied: continue without this file",
+  ].join("\n");
+}
+
+function logCrash(error: unknown): void {
+  try {
+    const logDir = join(PLUGIN_DIR, ".logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    appendFileSync(
+      join(logDir, "hook-log.jsonl"),
+      JSON.stringify({
+        ts: new Date().toISOString(),
+        hook: "privacy-block",
+        status: "crash",
+        error: error instanceof Error ? error.message : String(error),
+      }) + "\n",
+    );
+  } catch {
+    // fail-open
+  }
+}
+
+export const PrivacyBlock: Plugin = async ({ directory }) => ({
+  "tool.execute.before": async (input, output) => {
+    try {
+      if (!GATED_TOOLS.has(input.tool)) return;
+
+      const runtime = readRuntime(directory);
+      if (runtime.privacyBlock === false) return;
+
+      const args = (output.args ?? {}) as Record<string, unknown>;
+      const paths = extractPaths(input.tool, args);
+      if (paths.length === 0) return;
+
+      for (const filePath of paths) {
+        if (isSafe(filePath)) continue;
+        if (!isSensitive(filePath)) continue;
+
+        if (input.tool === "bash") {
+          console.error(
+            `WARN: Privacy-sensitive file access via bash allowed for approved follow-up: ${basename(filePath)}`,
+          );
+          return;
+        }
+
+        throw new Error(formatBlockMessage(filePath));
+      }
+    } catch (error) {
+      // Re-throw the privacy block error (intentional); only swallow programming errors.
+      if (error instanceof Error && error.message.includes("@@PRIVACY_PROMPT_START@@")) {
+        throw error;
+      }
+      logCrash(error);
+    }
+  },
+});

package/src/opencode/plugins/rules.ts

@@ -0,0 +1,163 @@
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * OpenCode Plugin — rules.ts
+ *
+ * Port of .claude/hooks/rules.cjs adapted to OpenCode.
+ *
+ * Claude's version injects a per-prompt rules reminder via stdout into
+ * the UserPromptSubmit hook. OpenCode has no equivalent per-prompt
+ * injection channel, so this plugin renders the same dynamic rules
+ * (paths, docs.maxLoc, locale) on every session.created and upserts a
+ * managed block inside the project AGENTS.md. OpenCode auto-loads
+ * AGENTS.md as instructions on each session, so the rules reach the
+ * model context at session start instead of per prompt.
+ *
+ * Static rules content already lives in AGENTS.md base template — this
+ * plugin only refreshes the dynamic block so paths/locale stay in sync
+ * with runtime.json.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_DIR = dirname(fileURLToPath(import.meta.url));
+const RULES_BLOCK_START = "<!-- CAFEKIT DYNAMIC RULES START -->";
+const RULES_BLOCK_END = "<!-- CAFEKIT DYNAMIC RULES END -->";
+
+function resolveProjectDir(directory?: string): string {
+  if (directory && existsSync(directory)) return directory;
+  return dirname(dirname(PLUGIN_DIR));
+}
+
+function readRuntime(cwd: string): Record<string, any> {
+  try {
+    const file = join(cwd, ".opencode", "runtime.json");
+    if (existsSync(file)) {
+      return JSON.parse(readFileSync(file, "utf8"));
+    }
+  } catch {
+    /* fail-open */
+  }
+  return {};
+}
+
+function renderDynamicRules(cwd: string): string {
+  const runtime = readRuntime(cwd);
+  const thinkLang: string = runtime?.locale?.thinkingLanguage || "";
+  const respondLang: string = runtime?.locale?.responseLanguage || "";
+  const effectThink = thinkLang || (respondLang ? "en" : "");
+  const plansPath = join(cwd, runtime?.paths?.plans || "plans");
+  const docsPath = join(cwd, runtime?.paths?.docs || "docs");
+  const maxLoc: number = runtime?.docs?.maxLoc || 800;
+
+  const lines: string[] = [];
+  lines.push(RULES_BLOCK_START);
+  lines.push("");
+  lines.push("## CafeKit Session Rules (auto-refreshed)");
+  lines.push("");
+
+  const hasThink = effectThink && effectThink !== respondLang;
+  if (hasThink || respondLang) {
+    lines.push("### Language");
+    if (hasThink) lines.push(`- Thinking: Use ${effectThink} for reasoning.`);
+    if (respondLang) lines.push(`- Response: Respond in ${respondLang}.`);
+    lines.push("");
+  }
+
+  lines.push("### Rules");
+  lines.push(`- Markdown files: Plans → "${plansPath}/" | Docs → "${docsPath}/"`);
+  lines.push(
+    "- **DO NOT** create markdown files outside of those directories unless explicitly asked.",
+  );
+  lines.push(`- docs.maxLoc: ${maxLoc} lines max per doc file`);
+  lines.push("- Follow **YAGNI · KISS · DRY** principles");
+  lines.push(
+    "- Sacrifice grammar for concision in reports. List unresolved Qs at end.",
+  );
+  lines.push("- Ensure token efficiency while maintaining high quality.");
+  lines.push("");
+
+  lines.push("### Skill Routing");
+  lines.push(
+    "- Choose skills from intent using `.opencode/rules/skill-workflow-routing.md` and `.opencode/rules/skill-domain-routing.md`.",
+  );
+  lines.push(
+    "- Use the OpenCode slash commands installed under `.opencode/commands/` (no `hapo:` prefix).",
+  );
+  lines.push(
+    "- Explicit user commands and direct-answer requests override routing suggestions.",
+  );
+  lines.push("");
+
+  lines.push("### Modularization");
+  lines.push("- If a file exceeds 200 lines, consider splitting it");
+  lines.push("- Check existing modules before creating new ones");
+  lines.push(
+    "- Prefer kebab-case (JS/TS/Python/shell); PascalCase (C#/Java); snake_case (Go/Rust)",
+  );
+  lines.push(
+    "- Skip modularization for: markdown, plain text, bash scripts, config files, .env files",
+  );
+  lines.push("");
+  lines.push(RULES_BLOCK_END);
+
+  return lines.join("\n");
+}
+
+function upsertBlock(filePath: string, block: string): boolean {
+  if (!existsSync(filePath)) return false;
+  let content: string;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return false;
+  }
+
+  const startIdx = content.indexOf(RULES_BLOCK_START);
+  const endIdx = content.indexOf(RULES_BLOCK_END);
+
+  let next: string;
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = content.slice(0, startIdx);
+    const after = content.slice(endIdx + RULES_BLOCK_END.length);
+    next = `${before}${block}${after}`;
+  } else {
+    const sep = content.endsWith("\n") ? "" : "\n";
+    next = `${content}${sep}\n${block}\n`;
+  }
+
+  if (next === content) return false;
+  try {
+    writeFileSync(filePath, next);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export const RulesPlugin: Plugin = async ({ directory }) => {
+  const cwd = resolveProjectDir(directory);
+
+  const refresh = () => {
+    const agentsFile = join(cwd, "AGENTS.md");
+    const block = renderDynamicRules(cwd);
+    upsertBlock(agentsFile, block);
+  };
+
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        refresh();
+      }
+    },
+  };
+};
+
+export default RulesPlugin;

package/src/opencode/plugins/session.ts

@@ -0,0 +1,179 @@
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * OpenCode Plugin — session.ts
+ *
+ * Port of .claude/hooks/session.cjs (banner half only).
+ *
+ * Behavior:
+ * - On session.created: detect project type, package manager, framework, git
+ *   branch and write a one-line banner to .opencode/session-banner.md
+ *   alongside docs-sync's section. Also emit to stderr (server log).
+ * - On session.compacted: append compaction warning to the banner so the
+ *   next assistant turn is reminded to re-verify pending approvals.
+ *
+ * Note: Claude's CLAUDE_ENV_FILE writes are dropped — OpenCode does not
+ * expose an equivalent env-injection channel.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  appendFileSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const PLUGIN_DIR = dirname(fileURLToPath(import.meta.url));
+const SESSION_SECTION_START = "<!-- CAFEKIT SESSION START -->";
+const SESSION_SECTION_END = "<!-- CAFEKIT SESSION END -->";
+
+function run(cmd: string, cwd: string, fallback = ""): string {
+  try {
+    return execSync(cmd, {
+      cwd,
+      encoding: "utf8",
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    return fallback;
+  }
+}
+
+function readRuntime(cwd: string): Record<string, any> {
+  try {
+    const file = join(cwd, ".opencode", "runtime.json");
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+  } catch {
+    return {};
+  }
+}
+
+function detectProjectType(cwd: string): string {
+  if (existsSync(join(cwd, "pnpm-workspace.yaml")) || existsSync(join(cwd, "lerna.json"))) {
+    return "monorepo";
+  }
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    if (pkg.workspaces) return "monorepo";
+    if (pkg.main || pkg.exports || pkg.module) return "library";
+  } catch {
+    // ignore
+  }
+  return "app";
+}
+
+function detectPackageManager(cwd: string): string {
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join(cwd, "bun.lockb"))) return "bun";
+  if (existsSync(join(cwd, "package-lock.json"))) return "npm";
+  return "";
+}
+
+function detectFramework(cwd: string): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["next"]) return "next";
+    if (deps["nuxt"]) return "nuxt";
+    if (deps["@sveltejs/kit"]) return "sveltekit";
+    if (deps["react"]) return "react";
+    if (deps["vue"]) return "vue";
+    if (deps["svelte"]) return "svelte";
+    if (deps["express"]) return "express";
+    if (deps["fastify"]) return "fastify";
+    if (deps["hono"]) return "hono";
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+function resolveSetting(cwd: string, runtimeValue: unknown, detector: (c: string) => string): string {
+  if (runtimeValue === "auto" || runtimeValue == null) return detector(cwd);
+  return typeof runtimeValue === "string" ? runtimeValue : detector(cwd);
+}
+
+function writeBannerSection(cwd: string, content: string): void {
+  const target = join(cwd, ".opencode", "session-banner.md");
+  const dir = dirname(target);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const existing = existsSync(target) ? readFileSync(target, "utf8") : "";
+  const pattern = new RegExp(`${SESSION_SECTION_START}[\\s\\S]*?${SESSION_SECTION_END}\\n?`);
+  const cleaned = existing.replace(pattern, "").trimEnd();
+  const block = [SESSION_SECTION_START, content, SESSION_SECTION_END].join("\n");
+  const next = cleaned ? `${cleaned}\n\n${block}\n` : `${block}\n`;
+  writeFileSync(target, next);
+}
+
+function logCrash(error: unknown): void {
+  try {
+    const logDir = join(PLUGIN_DIR, ".logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    appendFileSync(
+      join(logDir, "hook-log.jsonl"),
+      JSON.stringify({
+        ts: new Date().toISOString(),
+        hook: "session",
+        status: "crash",
+        error: error instanceof Error ? error.message : String(error),
+      }) + "\n",
+    );
+  } catch {
+    // fail-open
+  }
+}
+
+function handleSessionCreated(cwd: string): void {
+  const runtime = readRuntime(cwd);
+
+  const projectType = resolveSetting(cwd, runtime.project?.type, detectProjectType);
+  const packageManager = resolveSetting(cwd, runtime.project?.packageManager, detectPackageManager);
+  const framework = resolveSetting(cwd, runtime.project?.framework, detectFramework);
+  const gitBranch = run("git branch --show-current", cwd);
+
+  const parts: string[] = [];
+  if (projectType) parts.push(`Type: ${projectType}`);
+  if (packageManager) parts.push(`PM: ${packageManager}`);
+  if (framework) parts.push(`Framework: ${framework}`);
+  if (gitBranch) parts.push(`Branch: ${gitBranch}`);
+
+  const summary = `Session started. ${parts.length ? parts.join(" | ") : "No project info detected."}`;
+  writeBannerSection(cwd, summary);
+  console.error(summary);
+}
+
+function handleSessionCompacted(cwd: string): void {
+  const lines = [
+    "🚨 SESSION COMPRESSED — VERIFY PENDING AUTHORIZATIONS:",
+    "Any pending confirmations requested via AskUserQuestion might have been lost.",
+    "Do not proceed without explicitly asking the user again to ensure safety.",
+    'Use AskUserQuestion: "The chat context was compressed. Do I still have permission to proceed?"',
+  ];
+  writeBannerSection(cwd, lines.join("\n"));
+  console.error(lines.join("\n"));
+}
+
+export const Session: Plugin = async ({ directory }) => ({
+  event: async ({ event }) => {
+    try {
+      if (event.type === "session.created") {
+        handleSessionCreated(directory);
+        return;
+      }
+      if (event.type === "session.compacted") {
+        handleSessionCompacted(directory);
+        return;
+      }
+    } catch (error) {
+      logCrash(error);
+    }
+  },
+});