bacluc-opencode-completion-check-command 0.4.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bacluc-opencode-completion-check-command",
-  "version": "v0.4.1",
+  "version": "v0.6.0",
   "description": "",
   "keywords": [
     "opencode",

package/src/completion-check-command.ts

@@ -1,6 +1,7 @@
 import type { Hooks, Plugin, PluginInput } from '@opencode-ai/plugin'
 import type { Event } from '@opencode-ai/sdk'
 import { promises as fs } from 'fs'
+import { exec } from 'child_process'
 
 export const DEFAULT_MAX_RETRIES = 10
 
@@ -78,21 +79,34 @@ export interface CommandResult {
   stderr: string
 }
 
-export async function executeCommand($: PluginInput['$'], command: string, cwd: string): Promise<CommandResult> {
-  try {
-    const result = await $`${command}`.nothrow().quiet().cwd(cwd)
-    return {
-      exitCode: result.exitCode,
-      stdout: result.text(),
-      stderr: result.stderr.toString(),
-    }
-  } catch (error) {
-    return {
-      exitCode: 1,
-      stdout: '',
-      stderr: error instanceof Error ? error.message : String(error),
-    }
-  }
+/**
+ * Runs the completion check command in a real system shell (`/bin/sh -c`).
+ *
+ * The previous implementation used opencode's built-in Bun shell via
+ * `` $`${command}` ``. Bun interpolates the whole command string as a single
+ * quoted argument and resolves binaries against its own restricted PATH, which
+ * breaks commands such as `docker compose run ...` with errors like
+ * "Bun: command not found: docker" even though `docker` is on the user's PATH.
+ *
+ * Using `child_process.exec` runs the command through the real `/bin/sh`, so
+ * the command line is parsed normally and binaries are resolved against the
+ * inherited PATH exactly like in a normal terminal (including `/sbin`,
+ * `/usr/sbin`, etc.).
+ */
+export async function executeCommand(command: string, cwd: string): Promise<CommandResult> {
+  return new Promise((resolve) => {
+    exec(command, { cwd, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      let exitCode = 0
+      if (error) {
+        exitCode = typeof error.code === 'number' ? error.code : 1
+      }
+      resolve({
+        exitCode,
+        stdout: stdout.toString(),
+        stderr: stderr.toString(),
+      })
+    })
+  })
 }
 
 export function buildFailureMessage(result: CommandResult): string {
@@ -109,6 +123,60 @@ export function buildFailureMessage(result: CommandResult): string {
   return message
 }
 
+/**
+ * Detects whether an error attached to an assistant message means the provider's
+ * usage limit was used up (rate limit, quota or credits exhausted). When that
+ * happens the agent did not actually finish its task — it was cut off — so the
+ * completion check must not run and the agent must not be re-prompted (which
+ * would immediately hit the same limit again and burn the retry budget).
+ */
+export function isUsageLimitError(error: unknown): boolean {
+  if (!error || typeof error !== 'object') {
+    return false
+  }
+  const { name, data } = error as { name?: string; data?: Record<string, unknown> }
+  const statusCode = typeof data?.statusCode === 'number' ? data.statusCode : undefined
+
+  // HTTP 429 from the provider always means rate / usage limit reached.
+  if (name === 'APIError' && statusCode === 429) {
+    return true
+  }
+
+  // Otherwise fall back to matching the human-readable message / response body,
+  // which is how quota/credit exhaustion surfaces across providers.
+  const message = typeof data?.message === 'string' ? data.message : ''
+  const responseBody = typeof data?.responseBody === 'string' ? data.responseBody : ''
+  const haystack = `${message} ${responseBody}`.toLowerCase()
+
+  return /usage limit|rate limit|quota|too many requests|credit balance|out of credits|insufficient (?:credit|balance|funds|quota)/.test(
+    haystack,
+  )
+}
+
+/**
+ * Returns true when the session's most recent assistant message ended with a
+ * usage-limit error, i.e. the model ran out of usage rather than finishing.
+ */
+export async function sessionHitUsageLimit(client: PluginInput['client'], sessionID: string): Promise<boolean> {
+  try {
+    const response = await client.session.messages({ path: { id: sessionID } })
+    const messages = response?.data
+    if (!Array.isArray(messages)) {
+      return false
+    }
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const info = messages[i]?.info
+      if (info?.role === 'assistant') {
+        return isUsageLimitError(info.error)
+      }
+    }
+    return false
+  } catch {
+    // If we cannot determine the state, fall back to the normal behaviour.
+    return false
+  }
+}
+
 export async function readDefaultCommandFromAgentsMd(directory: string): Promise<string | null> {
   try {
     const content = await fs.readFile(`${directory}/AGENTS.md`, 'utf-8')
@@ -123,7 +191,7 @@ export async function readDefaultCommandFromAgentsMd(directory: string): Promise
 }
 
 export const CompletionCheckCommandPlugin: Plugin = async (input, options) => {
-  const { client, $ } = input
+  const { client } = input
   const maxRetries = typeof options?.maxRetries === 'number' ? options.maxRetries : DEFAULT_MAX_RETRIES
   const store = new CompletionCheckStore(maxRetries)
 
@@ -225,7 +293,27 @@ export const CompletionCheckCommandPlugin: Plugin = async (input, options) => {
       processing.add(sessionID)
 
       try {
-        const result = await executeCommand($, command, input.directory)
+        if (await sessionHitUsageLimit(client, sessionID)) {
+          // The agent was cut off by the provider's usage limit rather than
+          // finishing. Skip the completion check (and the re-prompt) so we don't
+          // immediately hit the limit again. The command stays registered, so the
+          // check still runs once the session is able to continue.
+          try {
+            await client.tui.showToast({
+              body: {
+                title: 'Completion Check',
+                message: 'Skipped the completion check because the usage limit was reached.',
+                variant: 'warning',
+                duration: 10000,
+              },
+            })
+          } catch {
+            // Ignore feedback errors
+          }
+          return
+        }
+
+        const result = await executeCommand(command, input.directory)
 
         if (result.exitCode === 0) {
           store.delete(sessionID)

package/src/index.ts

@@ -5,5 +5,7 @@ export {
   CompletionCheckStore,
   executeCommand,
   buildFailureMessage,
+  isUsageLimitError,
+  sessionHitUsageLimit,
 } from './completion-check-command.js'
 export type { CommandResult } from './completion-check-command.js'