astrocode-workflow 0.2.0 → 0.2.2

package/dist/index.js

@@ -9,6 +9,7 @@ import { createInjectProvider } from "./hooks/inject-provider";
 import { createToastManager } from "./ui/toasts";
 import { createAstroAgents } from "./agents/registry";
 import { info, warn } from "./shared/log";
+import { acquireRepoLock } from "./state/repo-lock";
 // Safe config cloning with structuredClone preference (fallback for older Node versions)
 // CONTRACT: Config is guaranteed JSON-serializable (enforced by loadAstrocodeConfig validation)
 const cloneConfig = (v) => {
@@ -37,6 +38,9 @@ const Astrocode = async (ctx) => {
         throw new Error("Astrocode requires ctx.directory to be a string repo root.");
     }
     const repoRoot = ctx.directory;
+    // Acquire exclusive repo lock to prevent multiple processes from corrupting the database
+    const lockPath = `${repoRoot}/.astro/astro.lock`;
+    const repoLock = acquireRepoLock(lockPath);
     // Always load config first - this provides defaults even in limited mode
     let pluginConfig;
     try {
@@ -280,6 +284,8 @@ const Astrocode = async (ctx) => {
         },
         // Best-effort cleanup
         close: async () => {
+            // Release repo lock first (important for process termination)
+            repoLock.release();
             if (db && typeof db.close === "function") {
                 try {
                     db.close();

package/dist/state/db.d.ts

@@ -4,7 +4,7 @@ export declare function openSqlite(dbPath: string, opts?: {
     busyTimeoutMs?: number;
 }): SqliteDb;
 export declare function configurePragmas(db: SqliteDb, pragmas: Record<string, any>): void;
-/** BEGIN IMMEDIATE transaction helper. */
+/** BEGIN IMMEDIATE transaction helper (re-entrant). */
 export declare function withTx<T>(db: SqliteDb, fn: () => T, opts?: {
     require?: boolean;
 }): T;

package/dist/state/db.js

@@ -46,7 +46,30 @@ export function configurePragmas(db, pragmas) {
     if (pragmas.temp_store)
         db.pragma(`temp_store = ${pragmas.temp_store}`);
 }
-/** BEGIN IMMEDIATE transaction helper. */
+/**
+ * Re-entrant transaction helper.
+ *
+ * SQLite rejects BEGIN inside BEGIN. We use:
+ * - depth=0: BEGIN IMMEDIATE ... COMMIT/ROLLBACK
+ * - depth>0: SAVEPOINT sp_n ... RELEASE / ROLLBACK TO + RELEASE
+ *
+ * This allows callers to safely nest withTx across layers (tools -> workflow -> state machine)
+ * without "cannot start a transaction within a transaction".
+ */
+const TX_DEPTH = new WeakMap();
+function getDepth(db) {
+    return TX_DEPTH.get(db) ?? 0;
+}
+function setDepth(db, depth) {
+    if (depth <= 0)
+        TX_DEPTH.delete(db);
+    else
+        TX_DEPTH.set(db, depth);
+}
+function savepointName(depth) {
+    return `sp_${depth}`;
+}
+/** BEGIN IMMEDIATE transaction helper (re-entrant). */
 export function withTx(db, fn, opts) {
     const adapter = createDatabaseAdapter();
     const available = adapter.isAvailable();
@@ -55,21 +78,56 @@ export function withTx(db, fn, opts) {
             throw new Error("Database adapter unavailable; transaction required.");
         return fn();
     }
-    db.exec("BEGIN IMMEDIATE");
+    const depth = getDepth(db);
+    if (depth === 0) {
+        db.exec("BEGIN IMMEDIATE");
+        setDepth(db, 1);
+        try {
+            const out = fn();
+            db.exec("COMMIT");
+            return out;
+        }
+        catch (e) {
+            try {
+                db.exec("ROLLBACK");
+            }
+            catch {
+                // ignore
+            }
+            throw e;
+        }
+        finally {
+            setDepth(db, 0);
+        }
+    }
+    // Nested: use SAVEPOINT
+    const nextDepth = depth + 1;
+    const sp = savepointName(nextDepth);
+    db.exec(`SAVEPOINT ${sp}`);
+    setDepth(db, nextDepth);
     try {
         const out = fn();
-        db.exec("COMMIT");
+        db.exec(`RELEASE SAVEPOINT ${sp}`);
         return out;
     }
     catch (e) {
         try {
-            db.exec("ROLLBACK");
+            db.exec(`ROLLBACK TO SAVEPOINT ${sp}`);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            db.exec(`RELEASE SAVEPOINT ${sp}`);
         }
         catch {
             // ignore
         }
         throw e;
     }
+    finally {
+        setDepth(db, depth);
+    }
 }
 export function getSchemaVersion(db) {
     try {

package/dist/state/repo-lock.d.ts

@@ -0,0 +1,3 @@
+export declare function acquireRepoLock(lockPath: string): {
+    release: () => void;
+};

package/dist/state/repo-lock.js

@@ -0,0 +1,29 @@
+// src/state/repo-lock.ts
+import fs from "node:fs";
+import path from "node:path";
+export function acquireRepoLock(lockPath) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    let fd;
+    try {
+        fd = fs.openSync(lockPath, "wx"); // exclusive create
+    }
+    catch (e) {
+        const msg = e?.code === "EEXIST"
+            ? `Astrocode lock is already held (${lockPath}). Another opencode process is running in this repo.`
+            : `Failed to acquire lock (${lockPath}): ${e?.message ?? String(e)}`;
+        throw new Error(msg);
+    }
+    fs.writeFileSync(fd, `${process.pid}\n`, "utf8");
+    return {
+        release: () => {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+            try {
+                fs.unlinkSync(lockPath);
+            }
+            catch { }
+        },
+    };
+}

package/dist/tools/workflow.d.ts

@@ -2,9 +2,9 @@ import { type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import type { StageKey } from "../state/types";
+import type { AgentConfig } from "@opencode-ai/sdk";
 export declare const STAGE_TO_AGENT_MAP: Record<string, string>;
 export declare function resolveAgentName(stageKey: StageKey, config: AstrocodeConfig, agents?: any, warnings?: string[]): string;
-import { AgentConfig } from "@opencode-ai/sdk";
 export declare function createAstroWorkflowProceedTool(opts: {
     ctx: any;
     config: AstrocodeConfig;