astrocode-workflow 0.3.3 → 0.3.5-1

package/dist/src/astro/workflow-runner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This is the only place you should hold the repo lock.
+ * Everything that mutates the repo (tool calls, steps) runs inside this scope.
+ *
+ * Replace the internals with your actual astro/opencode driver loop.
+ */
+export declare function runAstroWorkflow(opts: {
+    lockPath: string;
+    repoRoot: string;
+    sessionId: string;
+    owner?: string;
+    proceedOneStep: () => Promise<{
+        done: boolean;
+    }>;
+}): Promise<void>;

package/dist/src/astro/workflow-runner.js

@@ -0,0 +1,25 @@
+// src/astro/workflow-runner.ts
+import { acquireRepoLock } from "../state/repo-lock";
+import { workflowRepoLock } from "../state/workflow-repo-lock";
+/**
+ * This is the only place you should hold the repo lock.
+ * Everything that mutates the repo (tool calls, steps) runs inside this scope.
+ *
+ * Replace the internals with your actual astro/opencode driver loop.
+ */
+export async function runAstroWorkflow(opts) {
+    await workflowRepoLock({ acquireRepoLock }, {
+        lockPath: opts.lockPath,
+        repoRoot: opts.repoRoot,
+        sessionId: opts.sessionId,
+        owner: opts.owner,
+        fn: async () => {
+            // ✅ Lock is held ONCE for the entire run. Tool calls can "rattle through".
+            while (true) {
+                const { done } = await opts.proceedOneStep();
+                if (done)
+                    return;
+            }
+        },
+    });
+}

package/dist/src/hooks/inject-provider.d.ts

@@ -4,6 +4,10 @@ type ChatMessageInput = {
     sessionID: string;
     agent: string;
 };
+type ToolExecuteAfterInput = {
+    tool: string;
+    sessionID?: string;
+};
 type RuntimeState = {
     db: SqliteDb | null;
     limitedMode: boolean;
@@ -18,5 +22,6 @@ export declare function createInjectProvider(opts: {
     runtime: RuntimeState;
 }): {
     onChatMessage(input: ChatMessageInput): Promise<void>;
+    onToolAfter(input: ToolExecuteAfterInput): Promise<void>;
 };
 export {};

package/dist/src/hooks/inject-provider.js

@@ -116,5 +116,15 @@ export function createInjectProvider(opts) {
             // Inject eligible injects before processing the user's message
             await injectEligibleInjects(input.sessionID);
         },
+        async onToolAfter(input) {
+            if (!config.inject?.enabled)
+                return;
+            // Extract sessionID (same pattern as continuation enforcer)
+            const sessionId = input.sessionID ?? ctx.sessionID;
+            if (!sessionId)
+                return;
+            // Inject eligible injects after tool execution
+            await injectEligibleInjects(sessionId);
+        },
     };
 }

package/dist/src/index.js

@@ -9,7 +9,6 @@ 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) => {
@@ -38,9 +37,12 @@ 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);
+    // NOTE: Repo locking is handled at the workflow level via workflowRepoLock.
+    // The workflow tool correctly acquires and holds the lock for the entire workflow execution.
+    // Plugin-level locking is unnecessary and architecturally incorrect since:
+    // - The lock would be held for the entire session lifecycle (too long)
+    // - Individual tools are designed to be called within workflow context where lock is held
+    // - Workflow-level locking with refcounting prevents lock churn during tool execution
     // Always load config first - this provides defaults even in limited mode
     let pluginConfig;
     try {
@@ -258,6 +260,10 @@ const Astrocode = async (ctx) => {
             return { args: nextArgs };
         },
         "tool.execute.after": async (input, output) => {
+            // Inject eligible injects after tool execution (not just on chat messages)
+            if (injectProvider && hookEnabled("inject-provider")) {
+                await injectProvider.onToolAfter(input);
+            }
             // Truncate huge tool outputs to artifacts
             if (truncatorHook && hookEnabled("tool-output-truncator")) {
                 await truncatorHook(input, output ?? null);
@@ -284,8 +290,7 @@ const Astrocode = async (ctx) => {
         },
         // Best-effort cleanup
         close: async () => {
-            // Release repo lock first (important for process termination)
-            repoLock.release();
+            // Close database connection
             if (db && typeof db.close === "function") {
                 try {
                     db.close();

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

@@ -1,3 +1,67 @@
-export declare function acquireRepoLock(lockPath: string): {
+/**
+ * Acquire a repo-scoped lock with:
+ * - ✅ process-local caching + refcount (efficient repeated tool calls)
+ * - ✅ heartbeat lease + stale recovery
+ * - ✅ atomic create (`wx`) + portable replace fallback
+ * - ✅ dead PID eviction + stale eviction
+ * - ✅ no live takeover (even same session) to avoid concurrency stomps
+ * - ✅ ABA-safe release via lease_id fencing
+ * - ✅ exponential backoff + jitter to reduce FS churn
+ */
+export declare function acquireRepoLock(opts: {
+    lockPath: string;
+    repoRoot: string;
+    sessionId?: string;
+    owner?: string;
+    retryMs?: number;
+    pollMs?: number;
+    pollMaxMs?: number;
+    staleMs?: number;
+    heartbeatMs?: number;
+    minWriteMs?: number;
+}): Promise<{
     release: () => void;
+}>;
+/**
+ * Helper wrapper: always releases lock.
+ */
+export declare function withRepoLock<T>(opts: {
+    lockPath: string;
+    repoRoot: string;
+    sessionId?: string;
+    owner?: string;
+    fn: () => Promise<T>;
+}): Promise<T>;
+/**
+ * Lock diagnostics and status information.
+ */
+export type LockStatus = {
+    exists: boolean;
+    path: string;
+    pid?: number;
+    pidAlive?: boolean;
+    instanceId?: string;
+    sessionId?: string;
+    owner?: string;
+    leaseId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    ageMs?: number;
+    isStale?: boolean;
+    repoRoot?: string;
+    version?: number;
+};
+/**
+ * Get lock file status and diagnostics.
+ * Returns detailed information about the current lock state.
+ */
+export declare function getLockStatus(lockPath: string, staleMs?: number): LockStatus;
+/**
+ * Attempt to remove a lock file if it's safe to do so.
+ * Only removes locks with dead PIDs or stale timestamps.
+ * Returns true if lock was removed, false if lock is still held.
+ */
+export declare function tryRemoveStaleLock(lockPath: string, staleMs?: number): {
+    removed: boolean;
+    reason: string;
 };