opencode-agent-skill 15.1.0 → 15.1.2

package/lib/model-config.mjs

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs"
-import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises"
 import path from "node:path"
 import { defaultModelPolicy, resolveModel } from "./model-policy.mjs"
 import { normalizeCapabilityProfile } from "./capability-registry.mjs"
@@ -7,6 +7,70 @@ import { normalizePerformanceHistory, recordPerformanceOutcome } from "./model-p
 
 const TIERS = new Set(["light", "standard", "heavy"])
 
+const MODEL_POLICY_WRITE_TAILS = new Map()
+const MODEL_POLICY_LOCK_STALE_MS = 15_000
+const MODEL_POLICY_LOCK_WAIT_MS = 20_000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function modelPolicyLockDir(configDir) {
+  return modelPolicyFile(configDir) + ".lock"
+}
+
+async function withCrossProcessModelPolicyLock(configDir, fn) {
+  const lockDir = modelPolicyLockDir(configDir)
+  await mkdir(path.dirname(lockDir), { recursive: true })
+  const deadline = Date.now() + MODEL_POLICY_LOCK_WAIT_MS
+  let delayMs = 8
+  while (true) {
+    try {
+      await mkdir(lockDir)
+      break
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error
+      const info = await stat(lockDir).catch(() => null)
+      if (info && Date.now() - info.mtimeMs > MODEL_POLICY_LOCK_STALE_MS) {
+        const confirmed = await stat(lockDir).catch(() => null)
+        if (
+          confirmed &&
+          confirmed.ino === info.ino &&
+          confirmed.mtimeMs === info.mtimeMs
+        ) {
+          await rm(lockDir, { recursive: true, force: true }).catch(() => {})
+          continue
+        }
+      }
+      if (Date.now() >= deadline) throw new Error("Timed out waiting for model-policy write lock")
+      await sleep(delayMs)
+      delayMs = Math.min(100, delayMs * 2)
+    }
+  }
+  try {
+    return await fn()
+  } finally {
+    await rm(lockDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+async function withModelPolicyWriteLock(configDir, fn) {
+  const key = path.resolve(configDir)
+  const previous = MODEL_POLICY_WRITE_TAILS.get(key) || Promise.resolve()
+  let release
+  const barrier = new Promise((resolve) => { release = resolve })
+  const tail = previous.catch(() => {}).then(() => barrier)
+  MODEL_POLICY_WRITE_TAILS.set(key, tail)
+
+  await previous.catch(() => {})
+  try {
+    return await withCrossProcessModelPolicyLock(configDir, fn)
+  } finally {
+    release()
+    if (MODEL_POLICY_WRITE_TAILS.get(key) === tail) MODEL_POLICY_WRITE_TAILS.delete(key)
+  }
+}
+
 function validModelID(value) {
   return typeof value === "string" && /^[^\s/]+\/[^\s#]+(?:#[^\s]+)?$/.test(value)
 }
@@ -61,8 +125,7 @@ export async function readModelPolicy(configDir) {
   }
 }
 
-export async function writeModelPolicy(configDir, patch = {}) {
-  const current = await readModelPolicy(configDir)
+async function persistModelPolicy(configDir, current, patch = {}) {
   const merged = normalize({
     ...current,
     ...patch,
@@ -73,10 +136,24 @@ export async function writeModelPolicy(configDir, patch = {}) {
   })
   const file = modelPolicyFile(configDir)
   await mkdir(path.dirname(file), { recursive: true })
-  await writeFile(file, JSON.stringify(merged, null, 2) + "\n", "utf8")
+  const temp = file + "." + process.pid + "." + Date.now() + ".tmp"
+  await writeFile(temp, JSON.stringify(merged, null, 2) + "\n", "utf8")
+  try {
+    await rename(temp, file)
+  } catch (error) {
+    await rm(temp, { force: true }).catch(() => {})
+    throw error
+  }
   return { ...merged, file }
 }
 
+export async function writeModelPolicy(configDir, patch = {}) {
+  return withModelPolicyWriteLock(configDir, async () => {
+    const current = await readModelPolicy(configDir)
+    return persistModelPolicy(configDir, current, patch)
+  })
+}
+
 export function validateModelID(value) {
   return validModelID(value)
 }
@@ -102,7 +179,9 @@ export function applyConfiguredModel(source, role, policy) {
 }
 
 export async function recordModelPerformance(configDir, outcome = {}) {
-  const current = await readModelPolicy(configDir)
-  const performance = recordPerformanceOutcome(current.performance || {}, outcome)
-  return writeModelPolicy(configDir, { performance })
+  return withModelPolicyWriteLock(configDir, async () => {
+    const current = await readModelPolicy(configDir)
+    const performance = recordPerformanceOutcome(current.performance || {}, outcome)
+    return persistModelPolicy(configDir, current, { performance })
+  })
 }

package/lib/performance-fabric.mjs

@@ -91,6 +91,73 @@ function gitDiffRows(source, limit = 140) {
   ], limit)
 }
 
+function gitStatusRows(source, limit = 120) {
+  return matchingLines(source, [
+    /^##\s+/,
+    /^On branch\s+/i,
+    /^Your branch\s+/i,
+    /^Changes to be committed:/i,
+    /^Changes not staged for commit:/i,
+    /^Untracked files:/i,
+    /^Unmerged paths:/i,
+    /^\s*(?:nothing to commit|working tree clean)/i,
+    /^[ MARCUD?!]{1,2}\s+\S+/,
+  ], limit)
+}
+
+function gitLogRows(source, limit = 100) {
+  return matchingLines(source, [
+    /^commit\s+[0-9a-f]{7,40}\b/i,
+    /^Author:\s+/i,
+    /^Date:\s+/i,
+    /^Merge:\s+/i,
+    /^\s{4}\S+/,
+    /^fatal:/i,
+    /^error:/i,
+  ], limit)
+}
+
+function verificationTestRows(source, limit = 120) {
+  return matchingLines(source, [
+    /^(?:ok|FAIL)\s+\S+/,
+    /^---\s+(?:PASS|FAIL):\s+/,
+    /^test result:\s+(?:ok|FAILED)\b/i,
+    /^failures?:/i,
+    /^running\s+\d+\s+tests?/i,
+    /^Finished\s+test\b/i,
+    /^Total tests:\s*\d+/i,
+    /^\s*(?:Passed|Failed|Skipped):\s*\d+/i,
+    /\b(?:panic|assertion failed|FAILED|FAILURE|ERROR)\b/i,
+    /\berror\[E\d+\]/,
+    /\bBUILD\s+(?:SUCCESS|FAILURE)\b/i,
+    /\bTests run:\s*\d+/i,
+  ], limit)
+}
+
+function pythonLintRows(source, limit = 120) {
+  return matchingLines(source, [
+    /^.+:\d+:\d+:\s+[A-Z]+\d+\s+/,
+    /^.+:\d+:\d+:\s+(?:error|warning)\b/i,
+    /^Found\s+\d+\s+errors?/i,
+    /^All checks passed!?$/i,
+    /^\d+\s+files?\s+(?:reformatted|left unchanged)/i,
+    /\b(?:error|warning|failed)\b/i,
+  ], limit)
+}
+
+function packageInstallRows(source, limit = 120) {
+  return matchingLines(source, [
+    /\b(?:added|removed|changed)\s+\d+\s+packages?\b/i,
+    /\baudited\s+\d+\s+packages?\b/i,
+    /\b\d+\s+packages?\s+(?:are\s+)?looking for funding\b/i,
+    /\b\d+\s+vulnerabilit(?:y|ies)\b/i,
+    /\b(?:deprecated|warning|warn|error|ERR!|ELIFECYCLE|ERR_)\b/i,
+    /^Packages:\s+[+-]?\d+/i,
+    /^Progress:\s+/i,
+    /^Done in\s+/i,
+  ], limit)
+}
+
 function rgRows(source, limit = 100) {
   const lines = String(source || "").split(/\r?\n/).filter(Boolean)
   const matched = []
@@ -213,6 +280,16 @@ const REDUCERS = Object.freeze([
     match: (hint) => /\b(?:pytest|py\.test)\b/.test(hint),
     rows: pytestRows,
   },
+  {
+    family: "git-status",
+    match: (hint) => /\bgit\s+status\b/.test(hint),
+    rows: gitStatusRows,
+  },
+  {
+    family: "git-log",
+    match: (hint) => /\bgit\s+log\b/.test(hint),
+    rows: gitLogRows,
+  },
   {
     family: "git-diff",
     match: (hint) => /\bgit\s+(?:diff|show)\b/.test(hint),
@@ -248,6 +325,21 @@ const REDUCERS = Object.freeze([
     match: (hint) => /\bprisma\b|schema\.prisma/.test(hint),
     rows: prismaRows,
   },
+  {
+    family: "package-install",
+    match: (hint) => /(?:^|\s)(?:npm\s+(?:i|install|ci)|pnpm\s+(?:i|install|add)|yarn\s+(?:install|add))(?:\s|$)/.test(hint),
+    rows: packageInstallRows,
+  },
+  {
+    family: "verification-test",
+    match: (hint) => /\b(?:go\s+test|cargo\s+test|dotnet\s+test|mvn\s+test|gradle\s+test)\b/.test(hint),
+    rows: verificationTestRows,
+  },
+  {
+    family: "python-lint",
+    match: (hint) => /\b(?:ruff|flake8|pylint)\b/.test(hint),
+    rows: pythonLintRows,
+  },
   {
     family: "build",
     match: (hint) => /\b(?:compile|build|gradle|maven|mvn|cargo\s+check|dotnet\s+build)\b/.test(hint),

package/lib/permission-policy.mjs

@@ -0,0 +1,232 @@
+import { readFile, stat } from "node:fs/promises"
+
+const EFFECTS = new Set(["allow", "deny", "ask"])
+
+function normalizeSlashes(value) {
+  return String(value || "").replaceAll("\\", "/")
+}
+
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+.\-]/g, "\\$&")
+}
+
+function wildcardRegex(pattern, { caseInsensitive = false, shell = false } = {}) {
+  let value = normalizeSlashes(pattern)
+  const shellBare = shell && value.endsWith(" *")
+    ? value.slice(0, -2)
+    : null
+  const compile = (input) => {
+    let source = ""
+    for (const char of input) {
+      if (char === "*") source += ".*"
+      else if (char === "?") source += "."
+      else source += escapeRegex(char)
+    }
+    return source
+  }
+  const alternatives = shellBare === null
+    ? [compile(value)]
+    : [compile(value), compile(shellBare)]
+  return new RegExp(`^(?:${alternatives.join("|")})$`, caseInsensitive ? "i" : "")
+}
+
+export function permissionPatternMatches(pattern, value, options = {}) {
+  return wildcardRegex(String(pattern || ""), options).test(normalizeSlashes(value))
+}
+
+export function normalizePermissionRules(value) {
+  const rules = Array.isArray(value) ? value : []
+  return rules.map((rule, index) => {
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+      throw new Error(`permission rule ${index} must be an object`)
+    }
+    const action = String(rule.action || "").trim()
+    const resource = String(rule.resource || "").trim()
+    const effect = String(rule.effect || "").trim().toLowerCase()
+    if (!action || !resource || !EFFECTS.has(effect)) {
+      throw new Error(`permission rule ${index} requires action, resource and effect=allow|deny|ask`)
+    }
+    return { action, resource, effect }
+  })
+}
+
+function resourceValue(action, value) {
+  if (["read", "edit", "external_directory"].includes(String(action || ""))) {
+    return normalizeSlashes(value)
+  }
+  return String(value || "")
+}
+
+function matchRule(rule, request, platform) {
+  const caseInsensitive = platform === "win32"
+  const actionMatches = permissionPatternMatches(rule.action, request.action, { caseInsensitive })
+  if (!actionMatches) return false
+  return permissionPatternMatches(
+    rule.resource,
+    resourceValue(request.action, request.resource),
+    { caseInsensitive, shell: request.action === "shell" },
+  )
+}
+
+export function evaluatePermissionRules(rules, request = {}, options = {}) {
+  const normalized = normalizePermissionRules(rules)
+  const action = String(request.action || "").trim()
+  const resources = (Array.isArray(request.resources) ? request.resources : [request.resource])
+    .filter((value) => value !== undefined && value !== null)
+    .map((value) => String(value))
+  const platform = String(options.platform || process.platform)
+  const defaultEffect = EFFECTS.has(options.defaultEffect) ? options.defaultEffect : "allow"
+  if (!action) throw new Error("permission request requires action")
+  if (!resources.length) resources.push("*")
+
+  const decisions = resources.map((resource) => {
+    let matchedRule = null
+    for (let index = 0; index < normalized.length; index += 1) {
+      const rule = normalized[index]
+      if (matchRule(rule, { action, resource }, platform)) {
+        matchedRule = { ...rule, index }
+      }
+    }
+    return {
+      resource,
+      effect: matchedRule?.effect || defaultEffect,
+      matchedRule,
+    }
+  })
+
+  const effect = decisions.some((item) => item.effect === "deny")
+    ? "deny"
+    : decisions.some((item) => item.effect === "ask")
+      ? "ask"
+      : "allow"
+
+  return {
+    schemaVersion: 1,
+    action,
+    effect,
+    defaultEffect,
+    decisions,
+  }
+}
+
+export function toolPermissionRequest(toolName, input = {}) {
+  const name = String(toolName || "").trim()
+  const lower = name.toLowerCase()
+  if (lower === "bash" || lower === "powershell") {
+    return { action: "shell", resources: [String(input.command || "")] }
+  }
+  if (lower === "read") {
+    return { action: "read", resources: [String(input.path || input.file || input.filePath || "*")] }
+  }
+  if (["edit", "write", "write_file", "apply_patch", "ues_code_edit"].includes(lower)) {
+    return { action: "edit", resources: [String(input.path || input.file || input.filePath || input.target || "*")] }
+  }
+  if (lower === "grep") {
+    return { action: "grep", resources: [String(input.pattern || input.query || "*")] }
+  }
+  if (lower === "find" || lower === "glob") {
+    return { action: "glob", resources: [String(input.pattern || input.glob || input.query || "*")] }
+  }
+  if (lower === "ues_dispatch") {
+    return { action: "subagent", resources: [String(input.agent || input.target || "*")] }
+  }
+  if (lower === "ues_session") {
+    return { action: "session", resources: [String(input.action || "*")] }
+  }
+  const action = lower.replace(/[^a-z0-9_]+/g, "_") || "tool"
+  return { action, resources: ["*"] }
+}
+
+export function permissionRecoveryHint(request = {}, decision = null, options = {}) {
+  const action = String(request.action || decision?.action || "tool").trim() || "tool"
+  const resources = (
+    Array.isArray(request.resources)
+      ? request.resources
+      : request.resource !== undefined
+        ? [request.resource]
+        : []
+  ).map((value) => String(value)).filter(Boolean)
+  const denied = Array.isArray(decision?.decisions)
+    ? decision.decisions.filter((item) => item?.effect === "deny" || item?.effect === "ask")
+    : []
+  const resource = String(denied[0]?.resource || resources[0] || "*")
+  const effect = String(options.effect || decision?.effect || "deny")
+  const prefix = effect === "ask"
+    ? "UES approval was not granted for this action."
+    : "UES policy denied this action."
+
+  return [
+    prefix,
+    `Do not repeat the same blocked ${action} request for ${resource}.`,
+    "Continue by choosing the narrowest allowed, reversible alternative that still advances the task.",
+    "Prefer read-only inspection or a less-privileged resource when possible.",
+    "If no allowed path can satisfy the task, report the blocker with evidence instead of bypassing the guard.",
+  ].join(" ")
+}
+
+function normalizedConfig(parsed) {
+  if (Array.isArray(parsed)) {
+    return { permissions: normalizePermissionRules(parsed), agents: {}, defaultEffect: "allow" }
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("permission config must be an array or object")
+  }
+  const permissions = normalizePermissionRules(parsed.permissions || [])
+  const agents = {}
+  for (const [agent, value] of Object.entries(parsed.agents || {})) {
+    const rules = Array.isArray(value) ? value : value?.permissions
+    agents[String(agent)] = normalizePermissionRules(rules || [])
+  }
+  const defaultEffect = EFFECTS.has(parsed.defaultEffect) ? parsed.defaultEffect : "allow"
+  return { permissions, agents, defaultEffect }
+}
+
+export class PermissionPolicyStore {
+  constructor(file) {
+    this.file = String(file || "")
+    this.cacheKey = null
+    this.cached = null
+  }
+
+  async load() {
+    if (!this.file) return { configured: false, config: null }
+    const info = await stat(this.file).catch((error) => {
+      if (error?.code === "ENOENT") return null
+      throw error
+    })
+    if (!info?.isFile()) {
+      this.cacheKey = null
+      this.cached = null
+      return { configured: false, config: null }
+    }
+
+    const cacheKey = `${info.mtimeMs}:${info.size}`
+    if (this.cached && this.cacheKey === cacheKey) {
+      return { configured: true, config: this.cached, cached: true }
+    }
+
+    const parsed = JSON.parse(await readFile(this.file, "utf8"))
+    const config = normalizedConfig(parsed)
+    this.cacheKey = cacheKey
+    this.cached = config
+    return { configured: true, config, cached: false }
+  }
+
+  async evaluate(request, options = {}) {
+    const loaded = await this.load()
+    if (!loaded.configured) return { configured: false, decision: null }
+    const agent = String(options.agent || "")
+    const agentRules = agent ? (loaded.config.agents[agent] || []) : []
+    const rules = [...loaded.config.permissions, ...agentRules]
+    const decision = evaluatePermissionRules(rules, request, {
+      platform: options.platform,
+      defaultEffect: loaded.config.defaultEffect,
+    })
+    return {
+      configured: true,
+      decision,
+      agent: agent || null,
+      cached: loaded.cached === true,
+    }
+  }
+}