@nanhara/hara 0.127.2 → 0.129.0

package/dist/serve/server.js

@@ -37,12 +37,28 @@ 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, 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;
 const SHUTDOWN_GRACE_MS = 2_000;
 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
+            : error.code === "ARTIFACT_CONFLICT"
+                ? ERR.CONFLICT
+                : ERR.PARAMS;
+        return rpcError(id, code, error.message);
+    }
+    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) => {
     if (!Number.isSafeInteger(pid) || pid <= 0)
@@ -349,6 +365,7 @@ export async function startServe(opts, deps) {
     };
     // Discovery file — the desktop shell reads this to find the running server (like a pid/port file).
     const discoveryDir = join(deps.discoveryHome ?? homedir(), ".hara");
+    const artifactHome = deps.artifactHome ?? homedir();
     const discoveryPath = join(discoveryDir, "serve.json");
     const discovery = { host: opts.host, port, token, pid: process.pid, version: deps.version, instanceId };
     if (!deps.quietDiscovery) {
@@ -731,6 +748,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.commit", "artifact.revert",
+                            "artifact.list", "artifact.get", "artifact.revisions",
                             "tasks.list", "approvals.list", "approvals.resolve",
                         ];
                         const runtime = runtimeInfo();
@@ -1126,6 +1145,118 @@ export async function startServe(opts, deps) {
                                 return reply(rpcError(id, ERR.PARAMS, `no job ${p.id}`));
                             return reply(rpcResult(id, { id: p.id, deleted: true }));
                         }
+                        case "artifact.import": {
+                            if (typeof p.sourcePath !== "string" || !p.sourcePath) {
+                                return reply(rpcError(id, ERR.PARAMS, "sourcePath required"));
+                            }
+                            if (p.kind !== undefined
+                                && p.kind !== "presentation"
+                                && p.kind !== "spreadsheet"
+                                && p.kind !== "document")
+                                return reply(rpcError(id, ERR.PARAMS, "kind must be presentation, spreadsheet, or document"));
+                            if (p.title !== undefined && typeof p.title !== "string") {
+                                return reply(rpcError(id, ERR.PARAMS, "title must be a string"));
+                            }
+                            try {
+                                const details = await importArtifact(artifactHome, {
+                                    sourcePath: p.sourcePath,
+                                    ...(p.title !== undefined ? { title: p.title } : {}),
+                                    ...(p.kind !== undefined ? { kind: p.kind } : {}),
+                                });
+                                return reply(rpcResult(id, details));
+                            }
+                            catch (error) {
+                                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)));
+                            }
+                            catch (error) {
+                                return reply(artifactRpcError(id, error, "list"));
+                            }
+                        }
+                        case "artifact.get": {
+                            if (typeof p.artifactId !== "string") {
+                                return reply(rpcError(id, ERR.PARAMS, "artifactId required"));
+                            }
+                            try {
+                                return reply(rpcResult(id, getArtifact(artifactHome, p.artifactId)));
+                            }
+                            catch (error) {
+                                return reply(artifactRpcError(id, error, "open"));
+                            }
+                        }
+                        case "artifact.revisions": {
+                            if (typeof p.artifactId !== "string") {
+                                return reply(rpcError(id, ERR.PARAMS, "artifactId required"));
+                            }
+                            try {
+                                const revisions = listArtifactRevisions(artifactHome, p.artifactId);
+                                return reply(rpcResult(id, { artifactId: p.artifactId, revisions }));
+                            }
+                            catch (error) {
+                                return reply(artifactRpcError(id, error, "list revisions"));
+                            }
+                        }
                         case "skills.list": {
                             const cwd = typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd;
                             return reply(rpcResult(id, { skills: loadSkillIndex(cwd).map((s) => ({ id: s.id, description: s.description, source: s.source })) }));

package/package.json

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