@vellumai/cli 0.11.2 → 0.11.3-staging.2

package/src/lib/local.ts

@@ -8,9 +8,19 @@ import {
   writeFileSync,
 } from "fs";
 import { createRequire } from "module";
+import { Socket } from "net";
 import { homedir, networkInterfaces, platform, tmpdir } from "os";
 import { basename, dirname, join } from "path";
 
+import {
+  findAssistantCommand,
+  isRepoCheckoutPath,
+} from "@vellumai/environments";
+import {
+  isNamedPipePath,
+  removeIpcEndpointFile,
+  resolveIpcEndpoint,
+} from "@vellumai/ipc-server-utils";
 import { isValidReleaseVersion } from "@vellumai/local-mode";
 
 import {
@@ -134,11 +144,13 @@ function resolveBunExecutable(): string {
 
 function envWithBunPath(
   env: Record<string, string | undefined>,
+  commandDirs: string[] = [],
 ): Record<string, string | undefined> {
   const bunPath = resolveBunExecutable();
   const basePath = env.PATH || "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
   const extraDirs = [
     bunPath.includes("/") ? dirname(bunPath) : "",
+    ...commandDirs,
     join(homedir(), ".bun", "bin"),
     join(homedir(), ".local", "bin"),
   ].filter((dir) => dir && !basePath.split(":").includes(dir));
@@ -675,9 +687,15 @@ async function startDaemonFromSource(
     ...process.env,
     RUNTIME_HTTP_PORT: process.env.RUNTIME_HTTP_PORT || "7821",
     VELLUM_CLOUD: "local",
-    VELLUM_DEV: "1",
     VELLUM_ENVIRONMENT: process.env.VELLUM_ENVIRONMENT || "local",
   };
+  // "From source" covers both a developer's checkout and the npm-installed
+  // runtime the desktop app runs. Only the former is a dev run: marking an
+  // installed runtime as dev suppresses its telemetry and skips the
+  // `assistant` command install. An inherited VELLUM_DEV is left alone.
+  if (isRepoCheckoutPath(assistantIndex)) {
+    env.VELLUM_DEV = "1";
+  }
   applyDaemonEnvOverrides(env, resources, options);
 
   // Write a sentinel PID file before spawning so concurrent hatch() calls
@@ -685,7 +703,11 @@ async function startDaemonFromSource(
   writeFileSync(pidFile, "starting", "utf-8");
 
   const bunPath = resolveBunExecutable();
-  const spawnEnv = envWithBunPath(env);
+  const assistantCommand = findAssistantCommand(assistantIndex);
+  const spawnEnv = envWithBunPath(
+    env,
+    assistantCommand ? [dirname(assistantCommand)] : [],
+  );
   const child = foreground
     ? spawn(bunPath, ["run", daemonMainPath], {
         stdio: "inherit",
@@ -855,26 +877,55 @@ function resolveCesDir(resources?: LocalInstanceResources): string {
 }
 
 /**
- * Resolve the Unix socket path the CLI-launched CES sibling binds and the
- * daemon connects to. Both sides read `CES_LOCAL_SOCKET`, which the CLI sets to
- * this exact path so they agree. On macOS, long workspace paths are relocated
- * to a short tmpdir override (the same one the IPC sockets use) to stay under
- * the AF_UNIX path limit.
+ * Resolve the local IPC endpoint shared by the CLI-launched CES sibling and
+ * assistant. Windows uses a named pipe. POSIX uses a Unix socket, including
+ * the existing short macOS fallback.
  */
-function resolveCesSocketPath(resources?: LocalInstanceResources): string {
+export function resolveCesSocketPath(
+  resources?: LocalInstanceResources,
+  hostPlatform: NodeJS.Platform = platform(),
+): string {
   const workspaceDir = resources
     ? join(resources.instanceDir, ".vellum", "workspace")
     : join(homedir(), ".vellum", "workspace");
+  if (hostPlatform === "win32") {
+    return resolveIpcEndpoint("ces", {
+      workspaceDir,
+      platform: hostPlatform,
+    }).path;
+  }
   const override = computeIpcSocketDirOverride(workspaceDir);
   const socketDir = override ?? workspaceDir;
   mkdirSync(socketDir, { recursive: true });
   return join(socketDir, "ces.sock");
 }
 
+async function isIpcEndpointReady(endpointPath: string): Promise<boolean> {
+  if (!isNamedPipePath(endpointPath)) {
+    return existsSync(endpointPath);
+  }
+  return new Promise((resolve) => {
+    const socket = new Socket();
+    let settled = false;
+    const finish = (ready: boolean): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(ready);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    const timer = setTimeout(() => finish(false), 100);
+    socket.connect(endpointPath);
+  });
+}
+
 /**
- * Launch the local CES sibling over a Unix socket. The sibling model is now
- * the default topology for local (non-containerized) instances, matching how
- * containerized homes already run CES.
+ * Launch the local CES sibling over a local IPC endpoint. This is the default
+ * topology for local instances and matches the containerized CES layout.
  *
  * The sibling runs as an independent process with its lifecycle anchored to
  * SIGTERM, mirroring the gateway: a CLI-owned process with a PID file under
@@ -898,11 +949,7 @@ export async function startCes(
   const socketPath = resolveCesSocketPath(resources);
   // A stale socket file from an unclean shutdown blocks re-bind; CES unlinks it
   // on startup, but remove it here too so a leftover never masks a launch bug.
-  try {
-    unlinkSync(socketPath);
-  } catch {
-    /* no stale socket — fine */
-  }
+  removeIpcEndpointFile(socketPath);
 
   const securityDir = resources
     ? join(resources.instanceDir, ".vellum", "protected")
@@ -957,14 +1004,18 @@ export async function startCes(
     writeFileSync(cesPidFile, String(ces.pid), "utf-8");
   }
 
-  // Wait for the socket to appear so the daemon's discovery finds it on the
+  // Wait for the endpoint so the daemon's discovery finds it on the
   // first probe rather than burning its retry budget.
   const deadline = Date.now() + 10_000;
+  let endpointReady = false;
   while (Date.now() < deadline) {
-    if (existsSync(socketPath)) break;
+    endpointReady = await isIpcEndpointReady(socketPath);
+    if (endpointReady) {
+      break;
+    }
     await new Promise((r) => setTimeout(r, 50));
   }
-  if (!existsSync(socketPath)) {
+  if (!endpointReady) {
     console.warn(
       "⚠ credential-executor started but its socket did not appear within 10s",
     );
@@ -1394,7 +1445,13 @@ export async function startLocalDaemon(
       const localBinDir = join(home, ".local", "bin");
       const basePath =
         process.env.PATH || "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
-      const extraDirs = [bunBinDir, localBinDir].filter(
+      // The compiled `assistant` ships beside the daemon binary, so its
+      // directory is what puts `assistant …` on PATH for agent-run commands.
+      const daemonBinaryDir = dirname(daemonBinary);
+      const assistantBinaryDir = existsSync(join(daemonBinaryDir, "assistant"))
+        ? [daemonBinaryDir]
+        : [];
+      const extraDirs = [...assistantBinaryDir, bunBinDir, localBinDir].filter(
         (d) => !basePath.split(":").includes(d),
       );
       const daemonEnv: Record<string, string> = {