@vellumai/cli 0.4.41 → 0.4.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.4.41",
+  "version": "0.4.42",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/constants.test.ts

@@ -23,6 +23,7 @@ describe("constants", () => {
     expect(VALID_REMOTE_HOSTS).toContain("local");
     expect(VALID_REMOTE_HOSTS).toContain("gcp");
     expect(VALID_REMOTE_HOSTS).toContain("aws");
+    expect(VALID_REMOTE_HOSTS).toContain("docker");
     expect(VALID_REMOTE_HOSTS).toContain("custom");
   });
 

package/src/__tests__/multi-local.test.ts

@@ -39,7 +39,11 @@ import {
   saveAssistantEntry,
   type AssistantEntry,
 } from "../lib/assistant-config.js";
-import { DEFAULT_DAEMON_PORT } from "../lib/constants.js";
+import {
+  DEFAULT_DAEMON_PORT,
+  DEFAULT_GATEWAY_PORT,
+  DEFAULT_QDRANT_PORT,
+} from "../lib/constants.js";
 
 afterAll(() => {
   rmSync(testDir, { recursive: true, force: true });
@@ -91,40 +95,50 @@ describe("multi-local", () => {
   });
 
   describe("allocateLocalResources() produces non-conflicting ports", () => {
-    test("two instances get distinct ports and dirs when first instance ports are occupied", async () => {
-      // After the first allocation grabs its ports, simulate those ports
-      // being in-use so the second allocation must pick different ones.
-      const a = await allocateLocalResources("instance-a");
+    test("first instance returns default legacy resources", async () => {
+      // GIVEN no local assistants exist in the lockfile
+
+      // WHEN we allocate resources for the first instance
+      const res = await allocateLocalResources("instance-a");
+
+      // THEN it returns the default legacy layout (home dir, default ports)
+      expect(res.instanceDir).toBe(testDir);
+      expect(res.daemonPort).toBe(DEFAULT_DAEMON_PORT);
+      expect(res.gatewayPort).toBe(DEFAULT_GATEWAY_PORT);
+      expect(res.qdrantPort).toBe(DEFAULT_QDRANT_PORT);
+    });
+
+    test("second instance gets distinct ports and dir when first instance is saved", async () => {
+      // GIVEN a first local assistant already exists in the lockfile
+      saveAssistantEntry(makeEntry("instance-a"));
+
+      // AND the default ports are occupied
       const occupiedPorts = new Set([
-        a.daemonPort,
-        a.gatewayPort,
-        a.qdrantPort,
+        DEFAULT_DAEMON_PORT,
+        DEFAULT_GATEWAY_PORT,
+        DEFAULT_QDRANT_PORT,
       ]);
       probePortMock.mockImplementation((port: number) =>
         Promise.resolve(occupiedPorts.has(port)),
       );
 
+      // WHEN we allocate resources for a second instance
       const b = await allocateLocalResources("instance-b");
 
-      // All six ports must be unique across both instances
-      const allPorts = [
-        a.daemonPort,
-        a.gatewayPort,
-        a.qdrantPort,
-        b.daemonPort,
-        b.gatewayPort,
-        b.qdrantPort,
-      ];
-      expect(new Set(allPorts).size).toBe(6);
-
-      // Instance dirs must be distinct
-      expect(a.instanceDir).not.toBe(b.instanceDir);
-      expect(a.instanceDir).toContain("instance-a");
+      // THEN the second instance gets non-default ports
+      expect(occupiedPorts.has(b.daemonPort)).toBe(false);
+      expect(occupiedPorts.has(b.gatewayPort)).toBe(false);
+      expect(occupiedPorts.has(b.qdrantPort)).toBe(false);
+
+      // AND it gets its own dedicated instance directory
       expect(b.instanceDir).toContain("instance-b");
     });
 
     test("skips ports that probePort reports as in-use", async () => {
-      // Simulate the default ports being occupied
+      // GIVEN a first local assistant already exists in the lockfile
+      saveAssistantEntry(makeEntry("existing"));
+
+      // AND the default daemon ports are occupied
       const portsInUse = new Set([
         DEFAULT_DAEMON_PORT,
         DEFAULT_DAEMON_PORT + 1,
@@ -133,7 +147,10 @@ describe("multi-local", () => {
         Promise.resolve(portsInUse.has(port)),
       );
 
+      // WHEN we allocate resources for a new instance
       const res = await allocateLocalResources("probe-test");
+
+      // THEN the daemon port skips all occupied ports
       expect(res.daemonPort).toBeGreaterThan(DEFAULT_DAEMON_PORT + 1);
       expect(portsInUse.has(res.daemonPort)).toBe(false);
     });

package/src/commands/hatch.ts

@@ -201,7 +201,7 @@ function parseArgs(): HatchArgs {
       console.log("  -d                        Run in detached mode");
       console.log("  --name <name>             Custom instance name");
       console.log(
-        "  --remote <host>           Remote host (local, gcp, aws, custom)",
+        "  --remote <host>           Remote host (local, gcp, aws, docker, custom)",
       );
       console.log(
         "  --daemon-only             Start assistant only, skip gateway",
@@ -830,6 +830,11 @@ export async function hatch(): Promise<void> {
     return;
   }
 
+  if (remote === "docker") {
+    console.error("Error: Docker remote host is not yet implemented.");
+    process.exit(1);
+  }
+
   console.error(`Error: Remote host '${remote}' is not yet supported.`);
   process.exit(1);
 }

package/src/lib/constants.ts

@@ -8,7 +8,7 @@ export const DEFAULT_DAEMON_PORT = 7821;
 export const DEFAULT_GATEWAY_PORT = 7830;
 export const DEFAULT_QDRANT_PORT = 6333;
 
-export const VALID_REMOTE_HOSTS = ["local", "gcp", "aws", "custom"] as const;
+export const VALID_REMOTE_HOSTS = ["local", "gcp", "aws", "docker", "custom"] as const;
 export type RemoteHost = (typeof VALID_REMOTE_HOSTS)[number];
 export const VALID_SPECIES = ["openclaw", "vellum"] as const;
 export type Species = (typeof VALID_SPECIES)[number];