@nanhara/hara 0.128.0 → 0.130.0

package/dist/serve/server.js

@@ -32,12 +32,12 @@ import { disposeTodoScope, onTodosChange, restoreTodos, serializeTodos } from ".
 import { INTERJECT_PREFIX, disposeReminderScope } from "../agent/reminders.js";
 import { SessionHub, realStore } from "./sessions.js";
 import { parseFrame, rpcResult, rpcError, rpcNotify, ERR, PROTOCOL_VERSION } from "./protocol.js";
-import { taskLifecycleEvent } from "./task-events.js";
+import { taskLifecycleEvent, } from "./task-events.js";
 import { readModelContextFileSync } from "../fs-read.js";
 import { optionalPosixOpenFlag } from "../fs-open-flags.js";
 import { sameOpenedFileIdentity } from "../fs-identity.js";
 import { redactSensitiveText, redactSensitiveValue } from "../security/secrets.js";
-import { ArtifactStoreError, getArtifact, importArtifact, listArtifactRevisions, listArtifacts, } from "../artifacts/store.js";
+import { ArtifactStoreError, commitArtifact, getArtifact, importArtifact, listArtifactRevisions, listArtifacts, revertArtifact, } from "../artifacts/store.js";
 import { consumePendingTaskSteering, createTaskExecution, continueTaskExecution, finishTaskExecution, newSteerInteraction, newTurnInteraction, recordTaskSteering, requestsTaskContinuation, taskExecutionContext, } from "../session/task.js";
 const APPROVAL_TIMEOUT_MS = 300_000; // an unanswered approval denies after 5 min (never hangs a turn)
 const COMPACT_TIMEOUT_MS = 60_000;
@@ -46,12 +46,18 @@ const SOCKET_CLOSE_GRACE_MS = 250;
 const DISCOVERY_LOCK_WAIT_MS = 2_000;
 const artifactRpcError = (id, error, action) => {
     if (error instanceof ArtifactStoreError) {
-        const code = error.code === "ARTIFACT_CORRUPT" ? ERR.INTERNAL : ERR.PARAMS;
+        const code = error.code === "ARTIFACT_CORRUPT"
+            ? ERR.INTERNAL
+            : error.code === "ARTIFACT_CONFLICT"
+                ? ERR.CONFLICT
+                : ERR.PARAMS;
         return rpcError(id, code, error.message);
     }
-    return rpcError(id, ERR.INTERNAL, action === "import"
-        ? "Artifact import failed safely; the source file was not modified"
-        : `Artifact ${action} failed safely; local Artifact data was not changed`);
+    return rpcError(id, ERR.INTERNAL, action === "import" || action === "commit"
+        ? `Artifact ${action} failed safely; the source file was not modified`
+        : action === "revert"
+            ? "Artifact revert failed safely; no current revision was replaced"
+            : `Artifact ${action} failed safely; local Artifact data was not changed`);
 };
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const isPidAlive = (pid) => {
@@ -289,6 +295,7 @@ export async function startServe(opts, deps) {
     // Physical provider/tool work can outlive its logical timeout. Keep a process-level ledger independent
     // of SessionHub membership so detach/delete cannot make an updater believe the old engine is quiescent.
     const activeOperations = new Set();
+    let taskEventSequence = 0;
     let closing = false;
     let closePromise = null;
     const trackActiveOperation = (operation) => {
@@ -352,10 +359,23 @@ export async function startServe(opts, deps) {
             if (ws.readyState === ws.OPEN)
                 ws.send(frame);
     };
+    const nextTaskEventCursor = () => {
+        const sequence = taskEventSequence + 1;
+        if (!Number.isSafeInteger(sequence)) {
+            throw new Error("task lifecycle event sequence exhausted");
+        }
+        return { streamId: instanceId, sequence };
+    };
+    const publishTaskState = (event) => {
+        // Commit the cursor immediately before the synchronous broadcast. Dedupe paths never consume one,
+        // while every published event has a unique position in this server-wide stream.
+        taskEventSequence = event.sequence;
+        broadcast("event.task_state", { ...event });
+    };
     const broadcastTaskState = (session, activity) => {
         if (!session.task)
             return;
-        broadcast("event.task_state", { ...taskLifecycleEvent(session.meta.id, session.task, session.meta.todos ?? [], activity) });
+        publishTaskState(taskLifecycleEvent(session.meta.id, session.task, session.meta.todos ?? [], activity, nextTaskEventCursor()));
     };
     // Discovery file — the desktop shell reads this to find the running server (like a pid/port file).
     const discoveryDir = join(deps.discoveryHome ?? homedir(), ".hara");
@@ -442,13 +462,13 @@ export async function startServe(opts, deps) {
         const emitTaskState = (activity, todos = s.meta.todos ?? []) => {
             if (!s.task)
                 return;
-            const event = taskLifecycleEvent(sessionId, s.task, todos, activity);
-            const { at: _at, ...stableEvent } = event;
+            const event = taskLifecycleEvent(sessionId, s.task, todos, activity, nextTaskEventCursor());
+            const { at: _at, streamId: _streamId, sequence: _sequence, ...stableEvent } = event;
             const signature = JSON.stringify(stableEvent);
             if (signature === lastTaskStateSignature)
                 return;
             lastTaskStateSignature = signature;
-            broadcast("event.task_state", { ...event });
+            publishTaskState(event);
         };
         broadcast("event.turn_start", { sessionId, taskId: s.task.id, turnId: s.task.turnId });
         emitTaskState({ state: "running", phase: "starting" });
@@ -742,7 +762,8 @@ export async function startServe(opts, deps) {
                             "approval.reply", "plugins.list", "plugins.set", "skills.list", "models.list", "files.search", "project.panels",
                             "settings.providers.list", "settings.providers.test", "settings.providers.save",
                             "automation.list", "automation.add", "automation.toggle", "automation.delete",
-                            "artifact.import", "artifact.list", "artifact.get", "artifact.revisions",
+                            "artifact.import", "artifact.commit", "artifact.revert",
+                            "artifact.list", "artifact.get", "artifact.revisions",
                             "tasks.list", "approvals.list", "approvals.resolve",
                         ];
                         const runtime = runtimeInfo();
@@ -1162,6 +1183,63 @@ export async function startServe(opts, deps) {
                                 return reply(artifactRpcError(id, error, "import"));
                             }
                         }
+                        case "artifact.commit": {
+                            if (typeof p.artifactId !== "string"
+                                || typeof p.baseRevisionId !== "string"
+                                || typeof p.sourcePath !== "string"
+                                || !p.sourcePath) {
+                                return reply(rpcError(id, ERR.PARAMS, "artifactId, baseRevisionId, and sourcePath required"));
+                            }
+                            if (p.actor !== undefined) {
+                                return reply(rpcError(id, ERR.PARAMS, "actor is assigned by the authenticated host"));
+                            }
+                            if (p.taskRunId !== undefined && typeof p.taskRunId !== "string") {
+                                return reply(rpcError(id, ERR.PARAMS, "taskRunId must be a string"));
+                            }
+                            if (p.changedPaths !== undefined && !Array.isArray(p.changedPaths)) {
+                                return reply(rpcError(id, ERR.PARAMS, "changedPaths must be an array"));
+                            }
+                            try {
+                                const details = await commitArtifact(artifactHome, {
+                                    artifactId: p.artifactId,
+                                    baseRevisionId: p.baseRevisionId,
+                                    sourcePath: p.sourcePath,
+                                    actor: "user",
+                                    ...(p.taskRunId !== undefined ? { taskRunId: p.taskRunId } : {}),
+                                    ...(p.changedPaths !== undefined ? { changedPaths: p.changedPaths } : {}),
+                                });
+                                return reply(rpcResult(id, details));
+                            }
+                            catch (error) {
+                                return reply(artifactRpcError(id, error, "commit"));
+                            }
+                        }
+                        case "artifact.revert": {
+                            if (typeof p.artifactId !== "string"
+                                || typeof p.baseRevisionId !== "string"
+                                || typeof p.targetRevisionId !== "string") {
+                                return reply(rpcError(id, ERR.PARAMS, "artifactId, baseRevisionId, and targetRevisionId required"));
+                            }
+                            if (p.actor !== undefined) {
+                                return reply(rpcError(id, ERR.PARAMS, "actor is assigned by the authenticated host"));
+                            }
+                            if (p.taskRunId !== undefined && typeof p.taskRunId !== "string") {
+                                return reply(rpcError(id, ERR.PARAMS, "taskRunId must be a string"));
+                            }
+                            try {
+                                const details = revertArtifact(artifactHome, {
+                                    artifactId: p.artifactId,
+                                    baseRevisionId: p.baseRevisionId,
+                                    targetRevisionId: p.targetRevisionId,
+                                    actor: "user",
+                                    ...(p.taskRunId !== undefined ? { taskRunId: p.taskRunId } : {}),
+                                });
+                                return reply(rpcResult(id, details));
+                            }
+                            catch (error) {
+                                return reply(artifactRpcError(id, error, "revert"));
+                            }
+                        }
                         case "artifact.list": {
                             try {
                                 return reply(rpcResult(id, listArtifacts(artifactHome)));

package/dist/serve/task-events.js

@@ -5,7 +5,14 @@ function bounded(value, max) {
 }
 /** Build the single task-state shape consumed by Desktop, IDE clients, and the companion. Conversation
  * streaming remains separate; this event is the authoritative execution/status plane. */
-export function taskLifecycleEvent(sessionId, task, todos = [], activity, at = new Date().toISOString()) {
+export function taskLifecycleEvent(sessionId, task, todos = [], activity, cursor, at = new Date().toISOString()) {
+    const streamId = cursor.streamId.trim();
+    if (!streamId || streamId.length > 128) {
+        throw new Error("task lifecycle streamId must contain 1-128 characters");
+    }
+    if (!Number.isSafeInteger(cursor.sequence) || cursor.sequence <= 0) {
+        throw new Error("task lifecycle sequence must be a positive safe integer");
+    }
     const current = todos.find((todo) => todo.status === "in_progress")
         ?? todos.find((todo) => todo.status === "pending");
     const detail = bounded(activity.detail, 500);
@@ -22,6 +29,8 @@ export function taskLifecycleEvent(sessionId, task, todos = [], activity, at = n
         : task.status;
     return {
         version: TASK_LIFECYCLE_EVENT_VERSION,
+        streamId,
+        sequence: cursor.sequence,
         sessionId,
         taskId: task.id,
         turnId: task.turnId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.128.0",
+  "version": "0.130.0",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "runtime-bootstrap.cjs"