pi-webdesk 0.1.0

package/dist/apps/daemon/src/event-hub.js

@@ -0,0 +1,155 @@
+// apps/daemon/src/event-hub.ts
+import {
+  PROTOCOL_VERSION,
+  taskEventsErrorSchema,
+  taskEventsReplaySchema
+} from "../../../packages/protocol/src/index.js";
+import { TaskRuntimeOperationError } from "./task-runtime.js";
+var DEFAULT_EVENT_BUFFER_CAPACITY = 512;
+var DEFAULT_TASK_BUFFER_LIMIT = 64;
+function createTaskEventHub(options) {
+  const capacity = options.bufferCapacity ?? DEFAULT_EVENT_BUFFER_CAPACITY;
+  const taskBufferLimit = options.taskBufferLimit ?? DEFAULT_TASK_BUFFER_LIMIT;
+  if (!Number.isSafeInteger(capacity) || capacity < 1) {
+    throw new Error("Event buffer capacity must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(taskBufferLimit) || taskBufferLimit < 1) {
+    throw new Error("Task buffer limit must be a positive safe integer");
+  }
+  const buffers = /* @__PURE__ */ new Map();
+  const snapshotsInFlight = /* @__PURE__ */ new Map();
+  const connections = /* @__PURE__ */ new Set();
+  function record(event) {
+    const buffer = buffers.get(event.taskId);
+    if (buffer === void 0 || event.runtimeGeneration > buffer.generation) {
+      if (buffer === void 0 && buffers.size >= taskBufferLimit) {
+        const oldestTaskId = buffers.keys().next().value;
+        if (oldestTaskId !== void 0) buffers.delete(oldestTaskId);
+      }
+      if (buffer !== void 0) buffers.delete(event.taskId);
+      buffers.set(event.taskId, {
+        generation: event.runtimeGeneration,
+        events: [event]
+      });
+      return;
+    }
+    if (event.runtimeGeneration < buffer.generation) return;
+    buffer.events.push(event);
+    if (buffer.events.length > capacity) buffer.events.shift();
+    buffers.delete(event.taskId);
+    buffers.set(event.taskId, buffer);
+  }
+  function sharedSnapshot(taskId) {
+    const existing = snapshotsInFlight.get(taskId);
+    if (existing !== void 0) return existing;
+    const created = options.snapshot(taskId);
+    snapshotsInFlight.set(taskId, created);
+    void created.finally(() => {
+      if (snapshotsInFlight.get(taskId) === created) {
+        snapshotsInFlight.delete(taskId);
+      }
+    }).catch(() => void 0);
+    return created;
+  }
+  function replayableRange(taskId, cursor) {
+    const buffer = buffers.get(taskId);
+    if (buffer === void 0 || buffer.generation !== cursor.runtimeGeneration) {
+      return null;
+    }
+    const first = buffer.events[0];
+    const last = buffer.events[buffer.events.length - 1];
+    if (first === void 0 || last === void 0) return null;
+    if (first.sequence > cursor.lastSequence + 1) return null;
+    if (cursor.lastSequence > last.sequence) return null;
+    return buffer.events.filter((event) => event.sequence > cursor.lastSequence);
+  }
+  function deliver(state, event) {
+    const subscription = state.subscription;
+    if (subscription === null || subscription.taskId !== event.taskId) return;
+    if (subscription.mode === "live") {
+      state.send(event);
+      return;
+    }
+    subscription.queue.push(event);
+    if (subscription.queue.length > capacity) subscription.queue.shift();
+  }
+  return {
+    publish(event) {
+      record(event);
+      for (const state of connections) deliver(state, event);
+    },
+    connect(send) {
+      const state = { send, subscription: null, closed: false };
+      connections.add(state);
+      return {
+        subscribe(message) {
+          if (state.closed) return;
+          state.subscription = null;
+          if (message.cursor !== null) {
+            const replayed = replayableRange(message.taskId, message.cursor);
+            if (replayed !== null) {
+              const lastReplayed = replayed[replayed.length - 1];
+              state.send(
+                taskEventsReplaySchema.parse({
+                  protocol: PROTOCOL_VERSION,
+                  type: "task-events-replay",
+                  taskId: message.taskId,
+                  runtimeGeneration: message.cursor.runtimeGeneration,
+                  afterSequence: message.cursor.lastSequence,
+                  lastSequence: lastReplayed?.sequence ?? message.cursor.lastSequence
+                })
+              );
+              for (const event of replayed) state.send(event);
+              state.subscription = { taskId: message.taskId, mode: "live" };
+              return;
+            }
+          }
+          const pending = {
+            taskId: message.taskId,
+            mode: "pending",
+            queue: []
+          };
+          state.subscription = pending;
+          void sharedSnapshot(message.taskId).then(
+            (snapshot) => {
+              if (state.closed || state.subscription !== pending) return;
+              state.send(snapshot);
+              const coveredSequence = snapshot.lastSequence ?? -1;
+              for (const event of pending.queue) {
+                if (event.runtimeGeneration < snapshot.runtimeGeneration) continue;
+                if (event.runtimeGeneration === snapshot.runtimeGeneration && event.sequence <= coveredSequence) {
+                  continue;
+                }
+                state.send(event);
+              }
+              state.subscription = { taskId: message.taskId, mode: "live" };
+            },
+            (error) => {
+              if (state.closed || state.subscription !== pending) return;
+              state.subscription = null;
+              state.send(
+                taskEventsErrorSchema.parse({
+                  protocol: PROTOCOL_VERSION,
+                  type: "task-events-error",
+                  taskId: message.taskId,
+                  code: error instanceof TaskRuntimeOperationError && error.code === "task-not-found" ? "task-not-found" : "snapshot-failed",
+                  message: error instanceof TaskRuntimeOperationError && error.code === "task-not-found" ? "The selected task no longer exists." : "Webdesk could not synchronize this task. It will retry automatically."
+                })
+              );
+            }
+          );
+        },
+        close() {
+          state.closed = true;
+          state.subscription = null;
+          connections.delete(state);
+        }
+      };
+    }
+  };
+}
+export {
+  DEFAULT_EVENT_BUFFER_CAPACITY,
+  DEFAULT_TASK_BUFFER_LIMIT,
+  createTaskEventHub
+};

package/dist/apps/daemon/src/index.js

@@ -0,0 +1,102 @@
+// apps/daemon/src/index.ts
+import {
+  DaemonConfigError,
+  createDaemonServer
+} from "./server.js";
+import {
+  SESSION_COOKIE_NAME,
+  createSessionToken,
+  generateBootstrapToken,
+  readCookie,
+  tokensMatch,
+  verifySessionToken
+} from "./auth.js";
+import {
+  DaemonStateError,
+  SESSION_SECRET_FILE,
+  loadOrCreateSessionSecret,
+  sessionSecretPath
+} from "./secret.js";
+import { DaemonStateLockError, acquireDaemonStateLock } from "./state-lock.js";
+import {
+  RuntimeProcessRecoveryError,
+  captureRuntimeProcess,
+  createRuntimeProcessInspector,
+  recoverRuntimeProcess
+} from "./runtime-process.js";
+import {
+  WorkspaceStateError,
+  WORKSPACE_STATE_FILE,
+  createWorkspaceStore
+} from "./workspace-store.js";
+import {
+  DEFAULT_PITA_APPEARANCE,
+  PITA_PREFERENCES_FILE,
+  PitaPreferencesOperationError,
+  createPitaPreferencesService
+} from "./appearance-preferences.js";
+import {
+  WorkspaceOperationError,
+  createWorkspaceService
+} from "./workspace.js";
+import {
+  TaskReviewOperationError,
+  createTaskReviewService
+} from "./task-review.js";
+import {
+  TaskRuntimeOperationError,
+  createTaskRuntimeCoordinator
+} from "./task-runtime.js";
+import { createPiTaskRuntimeFactory } from "./pi-runtime-factory.js";
+import {
+  PiAuthOperationError,
+  createPiAuthCoordinator
+} from "./pi-auth.js";
+import {
+  PiConfigurationOperationError,
+  createPiConfigurationService
+} from "./pi-resources.js";
+import {
+  PiSessionCatalogOperationError,
+  createPiSessionCatalogService
+} from "./pi-sessions.js";
+export {
+  DEFAULT_PITA_APPEARANCE,
+  DaemonConfigError,
+  DaemonStateError,
+  DaemonStateLockError,
+  PITA_PREFERENCES_FILE,
+  PiAuthOperationError,
+  PiConfigurationOperationError,
+  PiSessionCatalogOperationError,
+  PitaPreferencesOperationError,
+  RuntimeProcessRecoveryError,
+  SESSION_COOKIE_NAME,
+  SESSION_SECRET_FILE,
+  TaskReviewOperationError,
+  TaskRuntimeOperationError,
+  WORKSPACE_STATE_FILE,
+  WorkspaceOperationError,
+  WorkspaceStateError,
+  acquireDaemonStateLock,
+  captureRuntimeProcess,
+  createDaemonServer,
+  createPiAuthCoordinator,
+  createPiConfigurationService,
+  createPiSessionCatalogService,
+  createPiTaskRuntimeFactory,
+  createPitaPreferencesService,
+  createRuntimeProcessInspector,
+  createSessionToken,
+  createTaskReviewService,
+  createTaskRuntimeCoordinator,
+  createWorkspaceService,
+  createWorkspaceStore,
+  generateBootstrapToken,
+  loadOrCreateSessionSecret,
+  readCookie,
+  recoverRuntimeProcess,
+  sessionSecretPath,
+  tokensMatch,
+  verifySessionToken
+};

package/dist/apps/daemon/src/launcher-control.js

@@ -0,0 +1,114 @@
+// apps/daemon/src/launcher-control.ts
+import { chmodSync, lstatSync, unlinkSync } from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { z } from "zod";
+var launcherCommandSchema = z.enum(["open", "status", "stop"]);
+var replySchema = z.object({
+  version: z.literal(1),
+  status: z.enum(["running", "stopping"]),
+  origin: z.string().url().refine((value) => {
+    const url = new URL(value);
+    return url.protocol === "http:" && ["127.0.0.1", "localhost"].includes(url.hostname) && url.origin === value;
+  }),
+  token: z.string().regex(/^[A-Za-z0-9_-]{32,128}$/).optional()
+}).strict();
+function controlSocketPath(stateDir) {
+  return path.join(stateDir, "launcher-v1.sock");
+}
+async function listenLauncherControl(stateDir, handle, stop) {
+  const socketPath = controlSocketPath(stateDir);
+  try {
+    if (!lstatSync(socketPath).isSocket()) throw new Error(`Expected a local socket at ${socketPath}`);
+    unlinkSync(socketPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const clients = /* @__PURE__ */ new Set();
+  const server = net.createServer((socket) => {
+    clients.add(socket);
+    socket.once("close", () => clients.delete(socket));
+    socket.on("error", () => socket.destroy());
+    socket.setTimeout(2e3, () => socket.destroy());
+    socket.setEncoding("utf8");
+    let input = "";
+    let handled = false;
+    socket.on("data", (chunk) => {
+      if (handled) return;
+      input += chunk;
+      if (input.length > 64) {
+        socket.destroy();
+        return;
+      }
+      if (!input.endsWith("\n")) return;
+      handled = true;
+      const command = launcherCommandSchema.safeParse(input.trim());
+      if (!command.success) {
+        socket.destroy();
+        return;
+      }
+      try {
+        const reply = replySchema.parse(handle(command.data));
+        socket.end(`${JSON.stringify(reply)}
+`, () => {
+          if (command.data === "stop") stop();
+        });
+      } catch {
+        socket.destroy();
+      }
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  chmodSync(socketPath, 384);
+  return () => new Promise((resolve, reject) => {
+    for (const socket of clients) socket.destroy();
+    server.close((error) => error ? reject(error) : resolve());
+  });
+}
+async function requestLauncherControl(stateDir, command) {
+  try {
+    const state = lstatSync(stateDir);
+    if (!state.isDirectory() || state.isSymbolicLink() || (state.mode & 63) !== 0) {
+      throw new Error(`Webdesk state must be a private directory (mode 700): ${stateDir}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(controlSocketPath(stateDir));
+    socket.setEncoding("utf8");
+    socket.setTimeout(2e3, () => socket.destroy(new Error("Webdesk's local control socket did not respond.")));
+    let response = "";
+    socket.once("connect", () => socket.write(`${command}
+`));
+    socket.on("data", (chunk) => {
+      response += chunk;
+      if (response.length > 4096) socket.destroy(new Error("Invalid Webdesk control response."));
+    });
+    socket.once("error", (error) => {
+      if (error.code === "ENOENT" || error.code === "ECONNREFUSED") resolve(null);
+      else reject(error);
+    });
+    socket.once("end", () => {
+      socket.destroy();
+      try {
+        resolve(replySchema.parse(JSON.parse(response)));
+      } catch {
+        reject(new Error("Invalid Webdesk control response."));
+      }
+    });
+  });
+}
+export {
+  controlSocketPath,
+  launcherCommandSchema,
+  listenLauncherControl,
+  requestLauncherControl
+};

package/dist/apps/daemon/src/launcher.js

@@ -0,0 +1,73 @@
+// apps/daemon/src/launcher.ts
+import { spawn } from "node:child_process";
+import { closeSync, constants, fstatSync, openSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { requestLauncherControl } from "./launcher-control.js";
+import { loadOrCreateSessionSecret } from "./secret.js";
+function launcherStateDir() {
+  return path.resolve(process.env.PITA_STATE_DIR ?? path.join(os.homedir(), ".pita"));
+}
+function bootstrapUrl(reply) {
+  if (!reply.token) throw new Error("Webdesk did not return a browser login link.");
+  return `${reply.origin}/?pita_bootstrap=${reply.token}`;
+}
+async function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : "xdg-open";
+  return new Promise((resolve) => {
+    const child = spawn(command, [url], { stdio: "ignore" });
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve(false);
+    }, 5e3);
+    const finish = (success) => {
+      clearTimeout(timeout);
+      resolve(success);
+    };
+    child.once("error", () => finish(false));
+    child.once("exit", (code) => finish(code === 0));
+  });
+}
+async function launchPita(stateDir = launcherStateDir()) {
+  const existing = await requestLauncherControl(stateDir, "open");
+  if (existing) return existing;
+  loadOrCreateSessionSecret(stateDir);
+  const logPath = path.join(stateDir, "daemon.log");
+  const log = openSync(logPath, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW, 384);
+  let child;
+  try {
+    const info = fstatSync(log);
+    if (!info.isFile() || (info.mode & 63) !== 0) throw new Error(`Webdesk log must be a private regular file: ${logPath}`);
+    const cli = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./cli.ts" : "./cli.js", import.meta.url));
+    child = spawn(process.execPath, [cli, "serve", "--no-browser"], {
+      cwd: process.cwd(),
+      env: { ...process.env, PITA_STATE_DIR: stateDir, PITA_BACKGROUND: "1" },
+      detached: true,
+      stdio: ["ignore", log, log]
+    });
+  } finally {
+    closeSync(log);
+  }
+  let failure;
+  child.once("error", (error) => {
+    failure = error;
+  });
+  child.unref();
+  const deadline = Date.now() + 2e4;
+  while (Date.now() < deadline) {
+    const reply = await requestLauncherControl(stateDir, "open");
+    if (reply) return reply;
+    if (failure || child.exitCode !== null || child.signalCode !== null) break;
+    await delay(100);
+  }
+  child.kill("SIGTERM");
+  throw new Error(`Webdesk could not start. Check ${logPath} for the startup error.`);
+}
+export {
+  bootstrapUrl,
+  launchPita,
+  launcherStateDir,
+  openBrowser
+};