@dipertq/dsh-openviking-status 0.2.2 → 0.3.1

package/lib/index.js

@@ -899,9 +899,63 @@ function getCandidateSessionIds(sessionId) {
   }
   return Array.from(new Set(candidates));
 }
+var TASKS_LIMIT_CAP = 200;
+var SESSION_COMMIT_TASK_TYPE = "session_commit";
+function clampLimit(raw, fallback = TASKS_LIMIT_CAP) {
+  const n = typeof raw === "string" ? Number.parseInt(raw, 10) : Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.min(TASKS_LIMIT_CAP, Math.max(1, Math.floor(n)));
+}
+function extractTaskId(body) {
+  if (!body || typeof body !== "object") return null;
+  const containers = [
+    body,
+    body.result,
+    body.data
+  ];
+  for (const c of containers) {
+    if (!c || typeof c !== "object") continue;
+    const id = c.task_id ?? c.id;
+    if (typeof id === "string" && id.trim()) return id.trim();
+  }
+  return null;
+}
+function extractTaskItems(data) {
+  if (!data || typeof data !== "object") return [];
+  if (Array.isArray(data)) return data;
+  const obj = data;
+  if (Array.isArray(obj.result)) return obj.result;
+  if (Array.isArray(obj.items)) return obj.items;
+  if (Array.isArray(obj.tasks)) return obj.tasks;
+  if (obj.result && typeof obj.result === "object") {
+    const res = obj.result;
+    if (Array.isArray(res.items)) return res.items;
+    if (Array.isArray(res.tasks)) return res.tasks;
+  }
+  return [];
+}
+async function resolveResourceId(endpoint, headers, sessionId, cache) {
+  const key = sessionId.trim();
+  const cached = cache?.get(key);
+  if (cached) return cached;
+  for (const candidateId of getCandidateSessionIds(sessionId)) {
+    const daemonRes = await fetch(
+      `${endpoint}/api/v1/sessions/${encodeURIComponent(candidateId)}`,
+      { method: "GET", headers }
+    ).catch(() => null);
+    if (!daemonRes) continue;
+    if (daemonRes.status === 404) continue;
+    if (daemonRes.ok) {
+      cache?.set(key, candidateId);
+      return candidateId;
+    }
+  }
+  return null;
+}
 function apply(ctx, config) {
   let currentSettings = () => config ?? {};
   let settingsService = null;
+  const resourceIdCache = /* @__PURE__ */ new Map();
   ctx.inject?.(["settings"], (settingsCtx) => {
     settingsService = settingsCtx.settings;
     settingsCtx.settings?.installSection(
@@ -1176,7 +1230,13 @@ function apply(ctx, config) {
               sendJson(res, 200, { ok: false, error: String(errorMsg) });
               return;
             }
-            sendJson(res, 200, { ok: true });
+            const okBody = await daemonRes.json().catch(() => null);
+            const taskId = extractTaskId(okBody);
+            sendJson(res, 200, {
+              ok: true,
+              ...taskId ? { task_id: taskId } : {},
+              resource_id: candidateId
+            });
             return;
           }
           sendJson(res, 200, {
@@ -1189,6 +1249,118 @@ function apply(ctx, config) {
       }
     });
   }, "openviking-status: session commit proxy route");
+  ctx.effect?.(() => {
+    return ctx.webServer?.register({
+      kind: "exact",
+      path: `${API_PREFIX}/tasks`,
+      handler: async (req, res) => {
+        try {
+          const url = new URL(req.url || "/", "http://localhost");
+          const sessionId = url.searchParams.get("session");
+          if (!sessionId || !sessionId.trim()) {
+            sendJson(res, 400, { status: "missing", error: "Missing session" });
+            return;
+          }
+          const effective = resolveEffective();
+          const headers = getHeaders(effective.apiKey);
+          const resourceId = await resolveResourceId(
+            effective.endpoint,
+            headers,
+            sessionId.trim(),
+            resourceIdCache
+          );
+          if (!resourceId) {
+            sendJson(res, 200, { status: "missing", tasks: [] });
+            return;
+          }
+          const limit = clampLimit(url.searchParams.get("limit"));
+          const query = new URLSearchParams({
+            resource_id: resourceId,
+            task_type: SESSION_COMMIT_TASK_TYPE,
+            limit: String(limit)
+          });
+          const daemonRes = await fetch(
+            `${effective.endpoint}/api/v1/tasks?${query.toString()}`,
+            { method: "GET", headers }
+          ).catch(() => null);
+          if (!daemonRes) {
+            sendJson(res, 200, { status: "unreachable", tasks: [] });
+            return;
+          }
+          if (daemonRes.status === 401 || daemonRes.status === 403) {
+            sendJson(res, 200, { status: "unauthorized", tasks: [] });
+            return;
+          }
+          if (!daemonRes.ok) {
+            sendJson(res, 200, {
+              status: "error",
+              detail: `HTTP ${daemonRes.status}`,
+              tasks: []
+            });
+            return;
+          }
+          const data = await daemonRes.json().catch(() => ({}));
+          const items = extractTaskItems(data);
+          sendJson(res, 200, {
+            status: "ok",
+            resource_id: resourceId,
+            tasks: items
+          });
+        } catch (err) {
+          sendJson(res, 200, { status: "unreachable", detail: String(err) });
+        }
+      }
+    });
+  }, "openviking-status: tasks proxy route");
+  ctx.effect?.(() => {
+    return ctx.webServer?.register({
+      kind: "exact",
+      path: `${API_PREFIX}/task`,
+      handler: async (req, res) => {
+        try {
+          const url = new URL(req.url || "/", "http://localhost");
+          const taskId = url.searchParams.get("id");
+          if (!taskId || !taskId.trim()) {
+            sendJson(res, 400, { status: "missing", error: "Missing id" });
+            return;
+          }
+          const withEvents = url.searchParams.get("events") === "1" || url.searchParams.get("events") === "true";
+          const effective = resolveEffective();
+          const query = withEvents ? "?include_events=true" : "";
+          const daemonRes = await fetch(
+            `${effective.endpoint}/api/v1/tasks/${encodeURIComponent(
+              taskId.trim()
+            )}${query}`,
+            { method: "GET", headers: getHeaders(effective.apiKey) }
+          ).catch(() => null);
+          if (!daemonRes) {
+            sendJson(res, 200, { status: "unreachable" });
+            return;
+          }
+          if (daemonRes.status === 404) {
+            sendJson(res, 200, { status: "missing" });
+            return;
+          }
+          if (daemonRes.status === 401 || daemonRes.status === 403) {
+            sendJson(res, 200, { status: "unauthorized" });
+            return;
+          }
+          if (!daemonRes.ok) {
+            sendJson(res, 200, {
+              status: "error",
+              detail: `HTTP ${daemonRes.status}`
+            });
+            return;
+          }
+          const data = await daemonRes.json().catch(() => ({}));
+          const task = data?.result ?? data?.data ?? data;
+          sendJson(res, 200, { status: "ok", task });
+        } catch (err) {
+          sendJson(res, 200, { status: "unreachable", detail: String(err) });
+        }
+      }
+    });
+  }, "openviking-status: task detail proxy route");
 }
 export {
   Config,