opencode-immune 1.0.49 → 1.0.52

package/dist/plugin.js

@@ -1,19 +1,19 @@
-"use strict";
 // .opencode/plugin.ts — opencode-immune plugin
 // Hybrid single-file architecture with factory functions, explicit state, error boundaries
 // See: memory-bank/creative/creative-plugin-architecture.md (Option C)
-Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("@opencode-ai/sdk/v2/client");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const crypto_1 = require("crypto");
-const os_1 = require("os");
-const child_process_1 = require("child_process");
+import { createOpencodeClient as createOpencodeClientV2 } from "@opencode-ai/sdk/v2/client";
+import { appendFile, mkdir, readFile, unlink, writeFile, stat, rm, rename, readdir, copyFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { execFile } from "child_process";
 // ═══════════════════════════════════════════════════════════════════════════════
 // PLUGIN VERSION CHECK
 // ═══════════════════════════════════════════════════════════════════════════════
-const PLUGIN_VERSION = "1.0.49";
+const PLUGIN_VERSION = "1.0.52";
 const PLUGIN_PACKAGE_NAME = "opencode-immune";
+const PLUGIN_DIRNAME = dirname(fileURLToPath(import.meta.url));
 /**
  * Read plugin version from package.json at runtime.
  * Falls back to PLUGIN_VERSION constant if read fails.
@@ -24,12 +24,12 @@ async function getPluginVersion() {
         // dist/plugin.js → ../package.json
         // Also try direct path for when loaded from npm cache.
         const candidates = [
-            (0, path_1.join)(__dirname, "..", "package.json"),
-            (0, path_1.join)(__dirname, "package.json"),
+            join(PLUGIN_DIRNAME, "..", "package.json"),
+            join(PLUGIN_DIRNAME, "package.json"),
         ];
         for (const pkgPath of candidates) {
             try {
-                const content = await (0, promises_1.readFile)(pkgPath, "utf-8");
+                const content = await readFile(pkgPath, "utf-8");
                 const pkg = JSON.parse(content);
                 if (pkg.version)
                     return pkg.version;
@@ -77,7 +77,7 @@ function createState(input) {
     const { client: _client, ...runtimeInput } = input;
     return {
         input: runtimeInput,
-        client: (0, client_1.createOpencodeClient)({
+        client: createOpencodeClientV2({
             baseUrl: input.serverUrl.toString(),
             directory: input.directory,
         }),
@@ -87,8 +87,8 @@ function createState(input) {
         providerRetryWatchdogs: new Map(),
         childFallbackRequests: new Map(),
         sessionErrorRetryCount: new Map(),
-        ultraworkMarkerPath: (0, path_1.join)(input.directory, ".opencode", "state", "ultrawork-active.json"),
-        diagnosticsLogPath: (0, path_1.join)(input.directory, ".opencode", "state", "opencode-immune-debug.log"),
+        ultraworkMarkerPath: join(input.directory, ".opencode", "state", "ultrawork-active.json"),
+        diagnosticsLogPath: join(input.directory, ".opencode", "state", "opencode-immune-debug.log"),
         lastEditAttempt: null,
         toolCallCount: 0,
         todoWriteUsed: false,
@@ -122,6 +122,7 @@ const DIAGNOSTIC_LOG_MAX_BYTES = 5 * 1024 * 1024;
 let activeLogDirectory = null;
 const MANAGED_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const PROVIDER_RETRY_WATCHDOG_MS = 30_000;
+const RETRY_PROMPT_DELIVERY_ATTEMPTS = 3;
 const CHILD_FALLBACK_REQUEST_TTL_MS = 10 * 60 * 1000;
 const RATE_LIMIT_FALLBACK_MODEL = {
     providerID: "codexsale",
@@ -154,7 +155,7 @@ async function createManagedUltraworkSession(state, title) {
     return sessionID;
 }
 async function promptManagedSession(state, sessionID, text, options = {}) {
-    await state.client.session.promptAsync({
+    const result = await state.client.session.promptAsync({
         directory: state.input.directory,
         sessionID,
         ...(options.model ? { model: options.model } : {}),
@@ -166,6 +167,9 @@ async function promptManagedSession(state, sessionID, text, options = {}) {
             },
         ],
     });
+    if (result.error || !result.response.ok) {
+        throw new Error(`prompt_async failed with status ${result.response.status}: ${JSON.stringify(result.error ?? null)}`);
+    }
 }
 async function abortManagedSession(state, sessionID) {
     await state.client.session.abort({
@@ -188,11 +192,11 @@ function pruneExpiredManagedSessions(state, now = Date.now()) {
 }
 async function writeDiagnosticLog(state, event, data = {}) {
     try {
-        const cacheDir = (0, path_1.join)(state.input.directory, ".opencode", "state");
-        await (0, promises_1.mkdir)(cacheDir, { recursive: true });
+        const cacheDir = join(state.input.directory, ".opencode", "state");
+        await mkdir(cacheDir, { recursive: true });
         await rotateDiagnosticLogIfNeeded(state.diagnosticsLogPath);
         const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data });
-        await (0, promises_1.appendFile)(state.diagnosticsLogPath, `${line}\n`, "utf-8");
+        await appendFile(state.diagnosticsLogPath, `${line}\n`, "utf-8");
     }
     catch {
         // diagnostics must never affect runtime behavior
@@ -200,12 +204,12 @@ async function writeDiagnosticLog(state, event, data = {}) {
 }
 async function rotateDiagnosticLogIfNeeded(logPath) {
     try {
-        const current = await (0, promises_1.stat)(logPath);
+        const current = await stat(logPath);
         if (current.size < DIAGNOSTIC_LOG_MAX_BYTES)
             return;
         const rotatedPath = `${logPath}.1`;
-        await (0, promises_1.rm)(rotatedPath, { force: true });
-        await (0, promises_1.rename)(logPath, rotatedPath);
+        await rm(rotatedPath, { force: true });
+        await rename(logPath, rotatedPath);
     }
     catch {
         // missing log or rotation failure must never affect runtime behavior
@@ -228,10 +232,10 @@ function writePluginLog(state, level, message, extra = {}) {
     });
 }
 function writePluginLogForDirectory(directory, level, message, extra = {}) {
-    const diagnosticsLogPath = (0, path_1.join)(directory, ".opencode", "state", "opencode-immune-debug.log");
+    const diagnosticsLogPath = join(directory, ".opencode", "state", "opencode-immune-debug.log");
     void (async () => {
         try {
-            await (0, promises_1.mkdir)((0, path_1.dirname)(diagnosticsLogPath), { recursive: true });
+            await mkdir(dirname(diagnosticsLogPath), { recursive: true });
             await rotateDiagnosticLogIfNeeded(diagnosticsLogPath);
             const line = JSON.stringify({
                 ts: new Date().toISOString(),
@@ -239,7 +243,7 @@ function writePluginLogForDirectory(directory, level, message, extra = {}) {
                 message,
                 ...extra,
             });
-            await (0, promises_1.appendFile)(diagnosticsLogPath, `${line}\n`, "utf-8");
+            await appendFile(diagnosticsLogPath, `${line}\n`, "utf-8");
         }
         catch {
             // file logging must never affect runtime behavior
@@ -263,13 +267,13 @@ const pluginLog = {
 // ── Ultrawork Marker File ──
 async function writeUltraworkMarker(state) {
     try {
-        const dir = (0, path_1.join)(state.input.directory, ".opencode", "state");
-        await (0, promises_1.mkdir)(dir, { recursive: true });
+        const dir = join(state.input.directory, ".opencode", "state");
+        await mkdir(dir, { recursive: true });
         const payload = JSON.stringify({
             active: true,
             updatedAt: new Date().toISOString(),
         });
-        await (0, promises_1.writeFile)(state.ultraworkMarkerPath, payload, "utf-8");
+        await writeFile(state.ultraworkMarkerPath, payload, "utf-8");
     }
     catch {
         // marker write must never affect runtime
@@ -277,7 +281,7 @@ async function writeUltraworkMarker(state) {
 }
 async function clearUltraworkMarker(state) {
     try {
-        await (0, promises_1.unlink)(state.ultraworkMarkerPath);
+        await unlink(state.ultraworkMarkerPath);
     }
     catch {
         // file may not exist — that's fine
@@ -285,7 +289,7 @@ async function clearUltraworkMarker(state) {
 }
 async function isUltraworkMarkerActive(state) {
     try {
-        const raw = await (0, promises_1.readFile)(state.ultraworkMarkerPath, "utf-8");
+        const raw = await readFile(state.ultraworkMarkerPath, "utf-8");
         const parsed = JSON.parse(raw);
         return parsed?.active === true;
     }
@@ -673,12 +677,30 @@ function scheduleManagedSessionRetry(state, sessionID, options) {
                 abortBeforePrompt: options.abortBeforePrompt,
             });
         }
-        catch {
+        catch (err) {
             if (options.countAgainstBudget) {
                 state.sessionErrorRetryCount.set(sessionID, Math.max((state.sessionErrorRetryCount.get(sessionID) ?? 1) - 1, 0));
             }
+            const deliveryAttempt = options.deliveryAttempt ?? 1;
+            await writeDiagnosticLog(state, "session-retry:prompt-delivery-failed", {
+                sessionID,
+                reason: options.reason,
+                deliveryAttempt,
+                error: err instanceof Error ? err.message : String(err),
+            });
             writePluginLog(state, "warn", `[opencode-immune] Retry prompt failed for session ${sessionID}. ` +
-                `Will wait for the next retry signal.`);
+                (deliveryAttempt < RETRY_PROMPT_DELIVERY_ATTEMPTS
+                    ? `Retrying delivery attempt ${deliveryAttempt + 1}/${RETRY_PROMPT_DELIVERY_ATTEMPTS}.`
+                    : `Delivery attempts exhausted; will wait for the next retry signal.`));
+            if (deliveryAttempt < RETRY_PROMPT_DELIVERY_ATTEMPTS) {
+                scheduleManagedSessionRetry(state, sessionID, {
+                    ...options,
+                    delayMs: Math.min(options.delayMs * 2, 15_000),
+                    countAgainstBudget: false,
+                    abortBeforePrompt: false,
+                    deliveryAttempt: deliveryAttempt + 1,
+                });
+            }
         }
     }, options.delayMs);
     state.sessionRetryTimers.set(sessionID, timer);
@@ -742,8 +764,8 @@ function compositeChatMessage(handlers) {
  */
 async function parseTasksFile(directory) {
     try {
-        const tasksPath = (0, path_1.join)(directory, "memory-bank", "tasks.md");
-        const content = await (0, promises_1.readFile)(tasksPath, "utf-8");
+        const tasksPath = join(directory, "memory-bank", "tasks.md");
+        const content = await readFile(tasksPath, "utf-8");
         // Check for active task
         if (!content.includes("## Active Task") ||
             content.includes("No active tasks")) {
@@ -815,7 +837,7 @@ const DEFAULT_HARNESS_REPO = "gendoor/opencode-immune-harness";
 async function parseDotEnv(filePath) {
     const result = {};
     try {
-        const content = await (0, promises_1.readFile)(filePath, "utf-8");
+        const content = await readFile(filePath, "utf-8");
         for (const line of content.split("\n")) {
             const trimmed = line.trim();
             if (!trimmed || trimmed.startsWith("#"))
@@ -849,13 +871,13 @@ async function resolveEnvValue(directory, key) {
     if (process.env[key])
         return process.env[key];
     // 2. Per-project .env
-    const projectEnv = await parseDotEnv((0, path_1.join)(directory, ".env"));
+    const projectEnv = await parseDotEnv(join(directory, ".env"));
     if (projectEnv[key])
         return projectEnv[key];
     // 3. Global config
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (home) {
-        const globalEnv = await parseDotEnv((0, path_1.join)(home, ".config", "opencode-immune", ".env"));
+        const globalEnv = await parseDotEnv(join(home, ".config", "opencode-immune", ".env"));
         if (globalEnv[key])
             return globalEnv[key];
     }
@@ -913,8 +935,8 @@ async function fetchLatestHarnessRelease(directory, repo, token) {
  */
 async function readLocalHarnessVersion(directory) {
     try {
-        const versionPath = (0, path_1.join)(directory, ".opencode", HARNESS_VERSION_FILE);
-        const content = await (0, promises_1.readFile)(versionPath, "utf-8");
+        const versionPath = join(directory, ".opencode", HARNESS_VERSION_FILE);
+        const content = await readFile(versionPath, "utf-8");
         return content.trim() || null;
     }
     catch {
@@ -938,8 +960,8 @@ async function downloadHarnessAsset(assetUrl, token) {
         throw new Error(`Download failed: ${resp.status} ${resp.statusText}`);
     }
     const buffer = Buffer.from(await resp.arrayBuffer());
-    const tempPath = (0, path_1.join)((0, os_1.tmpdir)(), `harness-${Date.now()}.tar.gz`);
-    await (0, promises_1.writeFile)(tempPath, buffer);
+    const tempPath = join(tmpdir(), `harness-${Date.now()}.tar.gz`);
+    await writeFile(tempPath, buffer);
     return tempPath;
 }
 /**
@@ -948,7 +970,7 @@ async function downloadHarnessAsset(assetUrl, token) {
  */
 function extractTarGz(archivePath, destDir) {
     return new Promise((resolve, reject) => {
-        (0, child_process_1.execFile)("tar", ["xzf", archivePath, "-C", destDir], (err) => {
+        execFile("tar", ["xzf", archivePath, "-C", destDir], (err) => {
             if (err)
                 reject(err);
             else
@@ -963,22 +985,22 @@ function extractTarGz(archivePath, destDir) {
  */
 async function copyDirRecursive(src, dest, skipRootFiles, rootDest) {
     const effectiveRoot = rootDest ?? dest;
-    const entries = await (0, promises_1.readdir)(src, { withFileTypes: true });
-    await (0, promises_1.mkdir)(dest, { recursive: true });
+    const entries = await readdir(src, { withFileTypes: true });
+    await mkdir(dest, { recursive: true });
     for (const entry of entries) {
         // Skip files only at the root destination level
         if (skipRootFiles && dest === effectiveRoot && entry.name === ".gitignore") {
             pluginLog.info(`[opencode-immune] Harness sync: skipping root .gitignore`);
             continue;
         }
-        const srcPath = (0, path_1.join)(src, entry.name);
-        const destPath = (0, path_1.join)(dest, entry.name);
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
         if (entry.isDirectory()) {
             await copyDirRecursive(srcPath, destPath, skipRootFiles, effectiveRoot);
         }
         else {
-            await (0, promises_1.mkdir)((0, path_1.dirname)(destPath), { recursive: true });
-            await (0, promises_1.copyFile)(srcPath, destPath);
+            await mkdir(dirname(destPath), { recursive: true });
+            await copyFile(srcPath, destPath);
         }
     }
 }
@@ -987,8 +1009,8 @@ async function copyDirRecursive(src, dest, skipRootFiles, rootDest) {
  */
 async function fileHash(filePath) {
     try {
-        const content = await (0, promises_1.readFile)(filePath);
-        return (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+        const content = await readFile(filePath);
+        return createHash("sha256").update(content).digest("hex");
     }
     catch {
         return "";
@@ -1030,13 +1052,13 @@ async function syncHarness(state) {
         }
         pluginLog.info(`[opencode-immune] Harness sync: updating ${localVersion ?? "(none)"} → ${release.tagName}`);
         // 3. Hash opencode.json before update
-        const configPath = (0, path_1.join)(state.input.directory, "opencode.json");
+        const configPath = join(state.input.directory, "opencode.json");
         const hashBefore = await fileHash(configPath);
         // 4. Download asset
         const archivePath = await downloadHarnessAsset(release.assetUrl, token);
         // 5. Extract to temp dir
-        const extractDir = (0, path_1.join)((0, os_1.tmpdir)(), `harness-extract-${Date.now()}`);
-        await (0, promises_1.mkdir)(extractDir, { recursive: true });
+        const extractDir = join(tmpdir(), `harness-extract-${Date.now()}`);
+        await mkdir(extractDir, { recursive: true });
         try {
             await extractTarGz(archivePath, extractDir);
             // 6. Copy extracted files to project root (skip .gitignore — project owns its own)
@@ -1044,9 +1066,9 @@ async function syncHarness(state) {
             const SKIP_ROOT_FILES = new Set([".gitignore"]);
             await copyDirRecursive(extractDir, state.input.directory, SKIP_ROOT_FILES);
             // 7. Write version marker
-            const versionDir = (0, path_1.join)(state.input.directory, ".opencode");
-            await (0, promises_1.mkdir)(versionDir, { recursive: true });
-            await (0, promises_1.writeFile)((0, path_1.join)(versionDir, HARNESS_VERSION_FILE), release.tagName + "\n", "utf-8");
+            const versionDir = join(state.input.directory, ".opencode");
+            await mkdir(versionDir, { recursive: true });
+            await writeFile(join(versionDir, HARNESS_VERSION_FILE), release.tagName + "\n", "utf-8");
             // 8. Check if opencode.json changed
             const hashAfter = await fileHash(configPath);
             if (hashBefore && hashAfter && hashBefore !== hashAfter) {
@@ -1063,11 +1085,11 @@ async function syncHarness(state) {
         finally {
             // 9. Cleanup temp files
             try {
-                await (0, promises_1.unlink)(archivePath);
+                await unlink(archivePath);
             }
             catch { /* ignore */ }
             try {
-                await (0, promises_1.rm)(extractDir, { recursive: true, force: true });
+                await rm(extractDir, { recursive: true, force: true });
             }
             catch { /* ignore */ }
         }
@@ -1598,22 +1620,22 @@ const ALL_CYCLES_COMPLETE_MARKER = "0-ULTRAWORK: ALL_CYCLES_COMPLETE";
  * Skips silently if progress.md doesn't exist or is trivially empty.
  */
 async function archiveProgress(directory) {
-    const progressPath = (0, path_1.join)(directory, "memory-bank", "progress.md");
+    const progressPath = join(directory, "memory-bank", "progress.md");
     try {
-        const content = await (0, promises_1.readFile)(progressPath, "utf-8");
+        const content = await readFile(progressPath, "utf-8");
         // Skip if empty or trivially empty
         if (!content.trim() || content.trim() === "# Progress") {
             pluginLog.info("[opencode-immune] Archive progress: nothing to archive (empty).");
             return;
         }
-        const archiveDir = (0, path_1.join)(directory, "memory-bank", "archive");
-        await (0, promises_1.mkdir)(archiveDir, { recursive: true });
+        const archiveDir = join(directory, "memory-bank", "archive");
+        await mkdir(archiveDir, { recursive: true });
         const now = new Date();
         const dateStr = now.toISOString().slice(0, 10); // YYYY-MM-DD
         const ts = Math.floor(now.getTime() / 1000);
         const archiveName = `progress-${dateStr}-${ts}.md`;
-        const archivePath = (0, path_1.join)(archiveDir, archiveName);
-        await (0, promises_1.rename)(progressPath, archivePath);
+        const archivePath = join(archiveDir, archiveName);
+        await rename(progressPath, archivePath);
         pluginLog.info(`[opencode-immune] Archive progress: moved to ${archiveName}`);
     }
     catch (err) {
@@ -1664,17 +1686,17 @@ async function buildCommitMessage(directory, diffStat) {
 function runGitCommit(directory) {
     return new Promise((resolve) => {
         // Stage all changes
-        (0, child_process_1.execFile)("git", ["add", "-A"], { cwd: directory }, (addErr) => {
+        execFile("git", ["add", "-A"], { cwd: directory }, (addErr) => {
             if (addErr) {
                 pluginLog.error("[opencode-immune] git add failed:", addErr.message);
                 resolve(false);
                 return;
             }
             // Get diff stat for commit body
-            (0, child_process_1.execFile)("git", ["diff", "--cached", "--stat"], { cwd: directory }, async (_diffErr, diffOut) => {
+            execFile("git", ["diff", "--cached", "--stat"], { cwd: directory }, async (_diffErr, diffOut) => {
                 const stat = (diffOut ?? "").trim();
                 const message = await buildCommitMessage(directory, stat);
-                (0, child_process_1.execFile)("git", ["commit", "-m", message], { cwd: directory }, (commitErr, stdout, stderr) => {
+                execFile("git", ["commit", "-m", message], { cwd: directory }, (commitErr, stdout, stderr) => {
                     if (commitErr) {
                         if (stderr?.includes("nothing to commit") || stdout?.includes("nothing to commit")) {
                             pluginLog.info("[opencode-immune] git commit: nothing to commit (clean tree).");
@@ -1897,8 +1919,8 @@ async function server(input) {
         else {
             // No active task — check if backlog has pending work to start a new cycle
             try {
-                const backlogPath = (0, path_1.join)(state.input.directory, "memory-bank", "backlog.md");
-                const backlogContent = await (0, promises_1.readFile)(backlogPath, "utf-8");
+                const backlogPath = join(state.input.directory, "memory-bank", "backlog.md");
+                const backlogContent = await readFile(backlogPath, "utf-8");
                 const hasPendingTasks = /- \[ \]/.test(backlogContent);
                 if (hasPendingTasks) {
                     state.autoResumeAttempted = true;
@@ -1960,7 +1982,7 @@ async function server(input) {
         "permission.ask": withErrorBoundary(state, "permission.ask", createPermissionAskHandler(state)),
     };
 }
-exports.default = {
+export default {
     id: "opencode-immune",
     server,
 };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "opencode-immune",
-  "version": "1.0.49",
+  "version": "1.0.52",
+  "type": "module",
   "description": "OpenCode plugin: session recovery, auto-retry, multi-cycle automation, context monitoring",
   "exports": {
     "./server": "./dist/plugin.js"