pi-weave 0.2.4 → 0.3.0

package/src/web/client/graph/graph.model.ts

@@ -545,9 +545,10 @@ export interface ViewBox {
  * session: the node stays under the cursor, the canvas bounds the drag, and
  * `[fit]` re-frames onto whatever the current positions are.
  *
- * The box is the exact extent of the rendered positions — no padding of its
- * own, because sigma's `stagePadding` (in pixels) already insets the fit, and
- * the same box handed back on `fit()` re-frames dragged-apart graphs.
+ * Use the position extent, with a minimum span of four collision radii.
+ * A single node (or coincident nodes) has no extent; Sigma scales layout-unit
+ * node sizes by that span, so a near-zero box magnifies one node across the
+ * canvas. Pixel-based `stagePadding` cannot prevent that.
  *
  * `null` for an empty graph: there is nothing to frame, and the caller
  * clears the override so sigma falls back to its own behaviour.
@@ -567,7 +568,8 @@ export function frameBox(points: readonly Point[]): ViewBox | null {
     if (p.y > maxY) maxY = p.y;
   }
   if (seen === 0) return null;
-  return { x: [minX, maxX], y: [minY, maxY] };
+  const padding = Math.max(0, (COLLIDE_RADIUS * 4 - Math.max(maxX - minX, maxY - minY)) / 2);
+  return { x: [minX - padding, maxX + padding], y: [minY - padding, maxY + padding] };
 }
 
 /** The empty graph. What the column renders before the first payload lands. */

package/src/web/server/controller.ts

@@ -0,0 +1,79 @@
+import { platform as osPlatform } from "node:os";
+import { resolveVaultRoot, WorkspaceCache } from "../../core";
+import {
+  startWorkspaceServer,
+  type StartWorkspaceServerOptions,
+  type WorkspaceServer,
+} from "./server";
+
+export type StartServerFn = (opts: StartWorkspaceServerOptions) => Promise<WorkspaceServer>;
+
+export interface WorkspaceServerSession {
+  server: WorkspaceServer;
+  cache: WorkspaceCache;
+  cwd: string;
+}
+
+export interface WorkspaceServerControllerDeps {
+  startServer?: StartServerFn;
+  vaultRoot?: () => string;
+  onStateChange?: () => void;
+}
+
+/** Owns one browser-workspace server for one plugin instance. */
+export class WorkspaceServerController {
+  private session: WorkspaceServerSession | null = null;
+  private pending: Promise<void> = Promise.resolve();
+
+  constructor(private readonly deps: WorkspaceServerControllerDeps = {}) {}
+
+  port(): number | null {
+    return this.session?.server.port ?? null;
+  }
+
+  run(cwd: string): Promise<{ session: WorkspaceServerSession; started: boolean }> {
+    return this.enqueue(async () => {
+      const existing = this.session;
+      if (existing?.cwd === cwd) return { session: existing, started: false };
+      if (existing) await this.stop();
+      const session = await this.bootOnce(cwd);
+      this.session = session;
+      this.deps.onStateChange?.();
+      return { session, started: true };
+    });
+  }
+
+  close(): Promise<void> {
+    return this.enqueue(() => this.stop());
+  }
+
+  private enqueue<T>(task: () => Promise<T>): Promise<T> {
+    const result = this.pending.then(task);
+    this.pending = result.then(() => undefined, () => undefined);
+    return result;
+  }
+
+  private async stop(): Promise<void> {
+    const session = this.session;
+    if (!session) return;
+    this.session = null;
+    await session.server.close();
+    this.deps.onStateChange?.();
+  }
+
+  private async bootOnce(cwd: string): Promise<WorkspaceServerSession> {
+    const vaultRoot = (this.deps.vaultRoot ?? resolveVaultRoot)();
+    const cache = new WorkspaceCache({ cwd, vaultRoot });
+    const server = await (this.deps.startServer ?? startWorkspaceServer)({ cwd, vaultRoot, cache });
+    return { server, cache, cwd };
+  }
+}
+
+export function browserOpenCommand(
+  url: string,
+  os: NodeJS.Platform = osPlatform(),
+): { command: string; args: string[] } {
+  if (os === "darwin") return { command: "open", args: [url] };
+  if (os === "win32") return { command: "cmd", args: ["/c", "start", "", url] };
+  return { command: "xdg-open", args: [url] };
+}