pi-webdesk 0.1.0

package/dist/apps/daemon/src/session-projection.js

@@ -0,0 +1,117 @@
+// apps/daemon/src/session-projection.ts
+import { sanitizeApprovalDisplayText } from "../../../packages/pi-bridge/src/index.js";
+import {
+  MAX_SESSION_TRANSCRIPT_ITEMS,
+  MAX_SESSION_TRANSCRIPT_TEXT_CHARS
+} from "../../../packages/protocol/src/index.js";
+var PREVIEW_LIMIT = 160;
+function clip(text, limit) {
+  return text.length > limit ? `${text.slice(0, limit - 1)}\u2026` : text;
+}
+function buildTranscript(session) {
+  const byId = new Map(session.entries.map((entry) => [entry.id, entry]));
+  const branch = [];
+  const visited = /* @__PURE__ */ new Set();
+  let cursor = session.leafId;
+  while (cursor !== null && !visited.has(cursor)) {
+    visited.add(cursor);
+    const entry = byId.get(cursor);
+    if (entry === void 0) break;
+    branch.push(entry);
+    cursor = entry.parentId;
+  }
+  branch.reverse();
+  const activePath = [];
+  const calls = /* @__PURE__ */ new Map();
+  for (const entry of branch) {
+    if ((entry.role === "user" || entry.role === "assistant") && entry.text) {
+      const rawPrefix = entry.text.slice(0, MAX_SESSION_TRANSCRIPT_TEXT_CHARS);
+      const safeText = sanitizeApprovalDisplayText(rawPrefix);
+      activePath.push({
+        id: entry.id,
+        role: entry.role,
+        text: safeText.slice(0, MAX_SESSION_TRANSCRIPT_TEXT_CHARS),
+        omittedChars: entry.text.length - rawPrefix.length + Math.max(0, safeText.length - MAX_SESSION_TRANSCRIPT_TEXT_CHARS)
+      });
+    }
+    for (const tool of entry.toolCalls ?? []) {
+      calls.set(tool.toolCallId, activePath.length);
+      activePath.push({ id: tool.toolCallId, role: "tool", tool: { ...tool, status: "incomplete" } });
+    }
+    if (entry.toolResult) {
+      const result = entry.toolResult;
+      const index = calls.get(result.toolCallId);
+      const existing = index === void 0 ? void 0 : activePath[index];
+      const tool = {
+        ...existing?.role === "tool" ? existing.tool : {
+          toolCallId: result.toolCallId,
+          name: result.name,
+          input: "",
+          inputOmittedChars: 0
+        },
+        status: result.isError ? "failed" : "succeeded",
+        output: result.output,
+        outputOmittedChars: result.omittedChars
+      };
+      const item = { id: result.toolCallId, role: "tool", tool };
+      if (index === void 0) activePath.push(item);
+      else activePath[index] = item;
+    }
+  }
+  const omittedItems = Math.max(
+    0,
+    activePath.length - MAX_SESSION_TRANSCRIPT_ITEMS
+  );
+  return { items: activePath.slice(omittedItems), omittedItems };
+}
+function buildSessionTree(tree) {
+  const parents = /* @__PURE__ */ new Map();
+  const pendingParents = [...tree.roots];
+  while (pendingParents.length > 0) {
+    const node = pendingParents.pop();
+    parents.set(node.entry.id, node.entry.parentId);
+    for (const child of node.children) pendingParents.push(child);
+  }
+  const activeIds = /* @__PURE__ */ new Set();
+  let cursor = tree.leafId;
+  while (cursor !== null && !activeIds.has(cursor)) {
+    activeIds.add(cursor);
+    cursor = parents.get(cursor) ?? null;
+  }
+  const makeNode = (node) => ({
+    id: node.entry.id,
+    parentId: node.entry.parentId,
+    kind: sanitizeApprovalDisplayText(node.entry.type).slice(0, 100),
+    ...node.entry.role === void 0 ? {} : { role: sanitizeApprovalDisplayText(node.entry.role).slice(0, 100) },
+    ...node.label === void 0 ? {} : { label: clip(sanitizeApprovalDisplayText(node.label), 500) },
+    ...node.entry.text === void 0 || node.entry.text === "" ? {} : {
+      preview: clip(
+        sanitizeApprovalDisplayText(node.entry.text.slice(0, PREVIEW_LIMIT)),
+        PREVIEW_LIMIT
+      )
+    },
+    onActivePath: activeIds.has(node.entry.id),
+    children: []
+  });
+  const roots = tree.roots.map(makeNode);
+  const pendingNodes = tree.roots.map((source, index) => ({ source, target: roots[index] }));
+  while (pendingNodes.length > 0) {
+    const { source, target } = pendingNodes.pop();
+    target.children = source.children.map(makeNode);
+    for (let index = 0; index < source.children.length; index++) {
+      pendingNodes.push({
+        source: source.children[index],
+        target: target.children[index]
+      });
+    }
+  }
+  return {
+    roots,
+    leafId: tree.leafId,
+    truncated: tree.truncated
+  };
+}
+export {
+  buildSessionTree,
+  buildTranscript
+};

package/dist/apps/daemon/src/state-lock.js

@@ -0,0 +1,31 @@
+// apps/daemon/src/state-lock.ts
+import path from "node:path";
+import { lock } from "proper-lockfile";
+var LOCK_DIRECTORY = "daemon.lock";
+var STALE_LOCK_MS = 3e4;
+var LOCK_HEARTBEAT_MS = 5e3;
+var DaemonStateLockError = class extends Error {
+  name = "DaemonStateLockError";
+};
+async function acquireDaemonStateLock(stateDir) {
+  const resolvedStateDir = path.resolve(stateDir);
+  try {
+    return await lock(resolvedStateDir, {
+      lockfilePath: path.join(resolvedStateDir, LOCK_DIRECTORY),
+      realpath: true,
+      stale: STALE_LOCK_MS,
+      update: LOCK_HEARTBEAT_MS,
+      retries: 0
+    });
+  } catch (error) {
+    const code = error !== null && typeof error === "object" && "code" in error ? String(error.code) : null;
+    throw new DaemonStateLockError(
+      code === "ELOCKED" ? `Another Webdesk daemon is already using ${resolvedStateDir}. Stop it before starting a daemon with the same state directory.` : `Webdesk could not claim exclusive ownership of ${resolvedStateDir}. Check the state directory and daemon output before retrying.`,
+      { cause: error }
+    );
+  }
+}
+export {
+  DaemonStateLockError,
+  acquireDaemonStateLock
+};

package/dist/apps/daemon/src/static-web.js

@@ -0,0 +1,53 @@
+// apps/daemon/src/static-web.ts
+import { readFile, realpath, stat } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+function createStaticWebHandler(directory) {
+  const root = realpathSync(directory);
+  return async (req, res) => {
+    if (req.method !== "GET" && req.method !== "HEAD") return false;
+    let pathname;
+    try {
+      pathname = decodeURIComponent((req.url ?? "/").split("?")[0]);
+    } catch {
+      return false;
+    }
+    if (!pathname.startsWith("/") || pathname.includes("\\") || pathname.includes("\0")) return false;
+    const parts = pathname.split("/");
+    if (parts.some((part) => part.startsWith("."))) return false;
+    if (pathname !== "/" && pathname !== "/pi" && pathname !== "/index.html" && !pathname.startsWith("/assets/")) return false;
+    const base = root;
+    try {
+      const file = await realpath(path.join(base, pathname === "/" || pathname === "/pi" ? "index.html" : pathname));
+      const relative = path.relative(base, file);
+      if (relative.startsWith("..") || path.isAbsolute(relative)) return false;
+      const type = CONTENT_TYPES[path.extname(file)];
+      if (!type || !(await stat(file)).isFile()) return false;
+      const body = await readFile(file);
+      res.writeHead(200, {
+        "content-type": type,
+        "content-length": body.length,
+        "cache-control": "no-store",
+        "referrer-policy": "no-referrer",
+        "x-content-type-options": "nosniff"
+      });
+      res.end(req.method === "HEAD" ? void 0 : body);
+      return true;
+    } catch (error) {
+      if (["ENOENT", "ENOTDIR", "EACCES"].includes(error.code ?? "")) return false;
+      throw error;
+    }
+  };
+}
+export {
+  createStaticWebHandler
+};

package/dist/apps/daemon/src/task-archive.js

@@ -0,0 +1,152 @@
+// apps/daemon/src/task-archive.ts
+import { realpath as resolveRealpath } from "node:fs/promises";
+import { inspectRepository } from "../../../packages/git/src/index.js";
+import { WorkspaceOperationError } from "./workspace.js";
+import { TaskRuntimeOperationError } from "./task-runtime.js";
+function createTaskArchiveService(options) {
+  const inspect = options.inspectRepository ?? ((rootPath) => inspectRepository(rootPath));
+  const realpath = options.realpath ?? resolveRealpath;
+  const active = /* @__PURE__ */ new Set();
+  function claim(taskId) {
+    if (active.has(taskId)) {
+      throw new WorkspaceOperationError(
+        "task-busy",
+        "Another archive or restore operation is already active for this task.",
+        409
+      );
+    }
+    active.add(taskId);
+  }
+  function assertOtherLifecycleIdle(taskId, repositoryId) {
+    if (options.isRuntimeMutating(taskId) || options.isValidationRunning(taskId) || options.isCommitActive(taskId) || options.isMergeActive(taskId) || repositoryId !== void 0 && options.isMergeRepositoryActive(repositoryId)) {
+      throw new WorkspaceOperationError(
+        "task-busy",
+        "Wait for the active Pi, validation, commit, or merge operation to settle before changing this task's lifecycle.",
+        409
+      );
+    }
+  }
+  async function requireTask(taskId) {
+    const task = await options.getTask(taskId);
+    if (task === null) {
+      throw new WorkspaceOperationError(
+        "task-not-found",
+        "The selected task no longer exists.",
+        404
+      );
+    }
+    return task;
+  }
+  return {
+    isBusy(taskId) {
+      return active.has(taskId);
+    },
+    async archive(taskId) {
+      claim(taskId);
+      try {
+        assertOtherLifecycleIdle(taskId);
+        const task = await requireTask(taskId);
+        assertOtherLifecycleIdle(taskId, task.repositoryId);
+        if (task.status === "archived") return options.archiveTask(taskId);
+        if (task.status !== "ready") {
+          throw new WorkspaceOperationError(
+            "task-not-ready",
+            `Only a ready task can be archived; this task is ${task.status}.`,
+            409
+          );
+        }
+        const repository = await options.getRepository(task.repositoryId);
+        if (repository === null) {
+          throw new WorkspaceOperationError(
+            "task-recovery-required",
+            "The task's registered repository is unavailable, so it was not archived.",
+            409
+          );
+        }
+        if (repository.pendingMerge?.taskId === task.id) {
+          throw new WorkspaceOperationError(
+            "task-busy",
+            "Reconcile the task's interrupted merge before archiving it.",
+            409
+          );
+        }
+        try {
+          await options.disposeRuntime(taskId);
+        } catch (error) {
+          if (error instanceof TaskRuntimeOperationError) {
+            throw new WorkspaceOperationError(
+              error.code === "runtime-busy" ? "task-busy" : "task-recovery-required",
+              error.message,
+              error.status,
+              { cause: error }
+            );
+          }
+          throw error;
+        }
+        const stopped = await requireTask(taskId);
+        if (stopped.status !== "ready" || stopped.runtimeProcess !== void 0) {
+          throw new WorkspaceOperationError(
+            "task-recovery-required",
+            "Webdesk could not prove that the task runtime stopped cleanly, so the task was not archived.",
+            409
+          );
+        }
+        options.invalidateCommitPreflight(taskId);
+        options.invalidateMergePreflight(taskId);
+        return await options.archiveTask(taskId);
+      } finally {
+        active.delete(taskId);
+      }
+    },
+    async restore(taskId) {
+      claim(taskId);
+      try {
+        assertOtherLifecycleIdle(taskId);
+        const task = await requireTask(taskId);
+        assertOtherLifecycleIdle(taskId, task.repositoryId);
+        if (task.status === "ready") return options.restoreTask(taskId, 0);
+        if (task.status !== "archived") {
+          throw new WorkspaceOperationError(
+            "task-not-ready",
+            `Only an archived task can be restored; this task is ${task.status}.`,
+            409
+          );
+        }
+        const repository = await options.getRepository(task.repositoryId);
+        if (repository === null) {
+          throw new WorkspaceOperationError(
+            "task-recovery-required",
+            "The task's registered repository is unavailable, so it remains archived.",
+            409
+          );
+        }
+        let canonicalRoot;
+        let worktree;
+        try {
+          canonicalRoot = await realpath(task.worktreePath);
+          worktree = await inspect(canonicalRoot);
+        } catch (error) {
+          throw new WorkspaceOperationError(
+            "task-recovery-required",
+            "The archived task worktree is unavailable or no longer a valid Git worktree.",
+            409,
+            { cause: error }
+          );
+        }
+        if (canonicalRoot !== task.worktreePath || worktree.root !== canonicalRoot || worktree.commonDir !== repository.commonDir || worktree.branch !== task.branch) {
+          throw new WorkspaceOperationError(
+            "task-recovery-required",
+            "The archived worktree no longer matches its recorded path, repository, or branch, so it was not restored.",
+            409
+          );
+        }
+        return await options.restoreTask(taskId, task.archivedAtMs);
+      } finally {
+        active.delete(taskId);
+      }
+    }
+  };
+}
+export {
+  createTaskArchiveService
+};