@aku11i/phantom 0.1.0

package/src/commands/exec.test.ts

@@ -0,0 +1,256 @@
+import { strictEqual } from "node:assert";
+import { before, describe, it, mock } from "node:test";
+
+describe("execInGarden", () => {
+  let spawnMock: ReturnType<typeof mock.fn>;
+  let whereGardenMock: ReturnType<typeof mock.fn>;
+  let execInGarden: typeof import("./exec.ts").execInGarden;
+
+  before(async () => {
+    spawnMock = mock.fn();
+    whereGardenMock = mock.fn();
+
+    mock.module("node:child_process", {
+      namedExports: {
+        spawn: spawnMock,
+      },
+    });
+
+    mock.module("../gardens/commands/where.ts", {
+      namedExports: {
+        whereGarden: whereGardenMock,
+      },
+    });
+
+    ({ execInGarden } = await import("./exec.ts"));
+  });
+
+  it("should return error when garden name is not provided", async () => {
+    const result = await execInGarden("", ["echo", "test"]);
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error: garden name required");
+  });
+
+  it("should return error when command is not provided", async () => {
+    const result = await execInGarden("test-garden", []);
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error: command required");
+  });
+
+  it("should return error when garden does not exist", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: false,
+        message: "Error: Garden 'nonexistent' does not exist",
+      }),
+    );
+
+    const result = await execInGarden("nonexistent", ["echo", "test"]);
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error: Garden 'nonexistent' does not exist");
+  });
+
+  it("should execute command successfully with exit code 0", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock successful command execution
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            // Simulate successful command (exit code 0)
+            setTimeout(() => callback(0, null), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await execInGarden("test-garden", ["echo", "hello"]);
+
+    strictEqual(result.success, true);
+    strictEqual(result.exitCode, 0);
+
+    // Verify spawn was called with correct arguments
+    strictEqual(spawnMock.mock.calls.length, 1);
+    const [cmd, args, options] = spawnMock.mock.calls[0].arguments as [
+      string,
+      string[],
+      { cwd: string; stdio: string },
+    ];
+    strictEqual(cmd, "echo");
+    strictEqual(args[0], "hello");
+    strictEqual(options.cwd, "/test/repo/.git/phantom/gardens/test-garden");
+    strictEqual(options.stdio, "inherit");
+  });
+
+  it("should handle command execution failure with non-zero exit code", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock failed command execution
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            // Simulate failed command (exit code 1)
+            setTimeout(() => callback(1, null), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await execInGarden("test-garden", ["false"]);
+
+    strictEqual(result.success, false);
+    strictEqual(result.exitCode, 1);
+  });
+
+  it("should handle command execution error", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock command execution error
+    const mockChildProcess = {
+      on: mock.fn((event: string, callback: (error: Error) => void) => {
+        if (event === "error") {
+          setTimeout(() => callback(new Error("Command not found")), 0);
+        }
+      }),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await execInGarden("test-garden", ["nonexistent-command"]);
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error executing command: Command not found");
+  });
+
+  it("should handle signal termination", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock signal termination
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            // Simulate signal termination
+            setTimeout(() => callback(null, "SIGTERM"), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await execInGarden("test-garden", ["long-running-command"]);
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Command terminated by signal: SIGTERM");
+    strictEqual(result.exitCode, 143); // 128 + 15 (SIGTERM)
+  });
+
+  it("should parse complex commands with multiple arguments", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock successful command execution
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            setTimeout(() => callback(0, null), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await execInGarden("test-garden", [
+      "npm",
+      "run",
+      "test",
+      "--",
+      "--verbose",
+    ]);
+
+    strictEqual(result.success, true);
+    strictEqual(result.exitCode, 0);
+
+    // Verify spawn was called with correct arguments
+    const [cmd, args] = spawnMock.mock.calls[0].arguments as [
+      string,
+      string[],
+      object,
+    ];
+    strictEqual(cmd, "npm");
+    strictEqual(args.length, 4);
+    strictEqual(args[0], "run");
+    strictEqual(args[1], "test");
+    strictEqual(args[2], "--");
+    strictEqual(args[3], "--verbose");
+  });
+});

package/src/commands/exec.ts

@@ -0,0 +1,81 @@
+import { spawn } from "node:child_process";
+import { exit } from "node:process";
+import { whereGarden } from "../gardens/commands/where.ts";
+
+export async function execInGarden(
+  gardenName: string,
+  command: string[],
+): Promise<{
+  success: boolean;
+  message?: string;
+  exitCode?: number;
+}> {
+  if (!gardenName) {
+    return { success: false, message: "Error: garden name required" };
+  }
+
+  if (!command || command.length === 0) {
+    return { success: false, message: "Error: command required" };
+  }
+
+  // Validate garden exists and get its path
+  const gardenResult = await whereGarden(gardenName);
+  if (!gardenResult.success) {
+    return { success: false, message: gardenResult.message };
+  }
+
+  const gardenPath = gardenResult.path as string;
+  const [cmd, ...args] = command;
+
+  return new Promise((resolve) => {
+    const childProcess = spawn(cmd, args, {
+      cwd: gardenPath,
+      stdio: "inherit",
+    });
+
+    childProcess.on("error", (error) => {
+      resolve({
+        success: false,
+        message: `Error executing command: ${error.message}`,
+      });
+    });
+
+    childProcess.on("exit", (code, signal) => {
+      if (signal) {
+        resolve({
+          success: false,
+          message: `Command terminated by signal: ${signal}`,
+          exitCode: 128 + (signal === "SIGTERM" ? 15 : 1),
+        });
+      } else {
+        const exitCode = code ?? 0;
+        resolve({
+          success: exitCode === 0,
+          exitCode,
+        });
+      }
+    });
+  });
+}
+
+export async function execHandler(args: string[]): Promise<void> {
+  if (args.length < 2) {
+    console.error("Usage: phantom exec <garden-name> <command> [args...]");
+    exit(1);
+  }
+
+  const gardenName = args[0];
+  const command = args.slice(1);
+
+  const result = await execInGarden(gardenName, command);
+
+  if (!result.success) {
+    if (result.message) {
+      console.error(result.message);
+    }
+    exit(result.exitCode ?? 1);
+  }
+
+  // For successful commands, exit with the same code as the child process
+  exit(result.exitCode ?? 0);
+}

package/src/commands/shell.test.ts

@@ -0,0 +1,248 @@
+import { strictEqual } from "node:assert";
+import { before, describe, it, mock } from "node:test";
+
+describe("shellInGarden", () => {
+  let spawnMock: ReturnType<typeof mock.fn>;
+  let whereGardenMock: ReturnType<typeof mock.fn>;
+  let shellInGarden: typeof import("./shell.ts").shellInGarden;
+  const originalEnv = process.env;
+
+  before(async () => {
+    spawnMock = mock.fn();
+    whereGardenMock = mock.fn();
+
+    mock.module("node:child_process", {
+      namedExports: {
+        spawn: spawnMock,
+      },
+    });
+
+    mock.module("../gardens/commands/where.ts", {
+      namedExports: {
+        whereGarden: whereGardenMock,
+      },
+    });
+
+    ({ shellInGarden } = await import("./shell.ts"));
+  });
+
+  it("should return error when garden name is not provided", async () => {
+    const result = await shellInGarden("");
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error: garden name required");
+  });
+
+  it("should return error when garden does not exist", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: false,
+        message: "Error: Garden 'nonexistent' does not exist",
+      }),
+    );
+
+    const result = await shellInGarden("nonexistent");
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error: Garden 'nonexistent' does not exist");
+  });
+
+  it("should start shell successfully with exit code 0", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock successful shell session
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            // Simulate successful shell exit
+            setTimeout(() => callback(0, null), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await shellInGarden("test-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(result.exitCode, 0);
+
+    // Verify spawn was called with correct arguments
+    strictEqual(spawnMock.mock.calls.length, 1);
+    const [shell, args, options] = spawnMock.mock.calls[0].arguments as [
+      string,
+      string[],
+      { cwd: string; stdio: string; env: NodeJS.ProcessEnv },
+    ];
+    strictEqual(shell, process.env.SHELL || "/bin/sh");
+    strictEqual(args.length, 0);
+    strictEqual(options.cwd, "/test/repo/.git/phantom/gardens/test-garden");
+    strictEqual(options.stdio, "inherit");
+    strictEqual(options.env.PHANTOM_GARDEN, "test-garden");
+    strictEqual(
+      options.env.PHANTOM_GARDEN_PATH,
+      "/test/repo/.git/phantom/gardens/test-garden",
+    );
+  });
+
+  it("should use /bin/sh when SHELL is not set", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Temporarily remove SHELL env var
+    const originalShell = process.env.SHELL;
+    // biome-ignore lint/performance/noDelete: Need to actually delete for test
+    delete process.env.SHELL;
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock successful shell session
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            setTimeout(() => callback(0, null), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    await shellInGarden("test-garden");
+
+    // Verify /bin/sh was used
+    const [shell] = spawnMock.mock.calls[0].arguments as [string, unknown];
+    strictEqual(shell, "/bin/sh");
+
+    // Restore SHELL env var
+    if (originalShell !== undefined) {
+      process.env.SHELL = originalShell;
+    }
+  });
+
+  it("should handle shell execution failure with non-zero exit code", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock failed shell session
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            // Simulate failed shell exit
+            setTimeout(() => callback(1, null), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await shellInGarden("test-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(result.exitCode, 1);
+  });
+
+  it("should handle shell startup error", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock shell startup error
+    const mockChildProcess = {
+      on: mock.fn((event: string, callback: (error: Error) => void) => {
+        if (event === "error") {
+          setTimeout(() => callback(new Error("Shell not found")), 0);
+        }
+      }),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await shellInGarden("test-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error starting shell: Shell not found");
+  });
+
+  it("should handle signal termination", async () => {
+    whereGardenMock.mock.resetCalls();
+    spawnMock.mock.resetCalls();
+
+    // Mock successful garden location
+    whereGardenMock.mock.mockImplementation(() =>
+      Promise.resolve({
+        success: true,
+        path: "/test/repo/.git/phantom/gardens/test-garden",
+      }),
+    );
+
+    // Mock signal termination
+    const mockChildProcess = {
+      on: mock.fn(
+        (
+          event: string,
+          callback: (code: number | null, signal: string | null) => void,
+        ) => {
+          if (event === "exit") {
+            // Simulate signal termination
+            setTimeout(() => callback(null, "SIGTERM"), 0);
+          }
+        },
+      ),
+    };
+
+    spawnMock.mock.mockImplementation(() => mockChildProcess);
+
+    const result = await shellInGarden("test-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Shell terminated by signal: SIGTERM");
+    strictEqual(result.exitCode, 143); // 128 + 15 (SIGTERM)
+  });
+});

package/src/commands/shell.ts

@@ -0,0 +1,91 @@
+import { spawn } from "node:child_process";
+import { exit } from "node:process";
+import { whereGarden } from "../gardens/commands/where.ts";
+
+export async function shellInGarden(gardenName: string): Promise<{
+  success: boolean;
+  message?: string;
+  exitCode?: number;
+}> {
+  if (!gardenName) {
+    return { success: false, message: "Error: garden name required" };
+  }
+
+  // Validate garden exists and get its path
+  const gardenResult = await whereGarden(gardenName);
+  if (!gardenResult.success) {
+    return { success: false, message: gardenResult.message };
+  }
+
+  const gardenPath = gardenResult.path as string;
+  // Use user's preferred shell or fallback to /bin/sh
+  const shell = process.env.SHELL || "/bin/sh";
+
+  return new Promise((resolve) => {
+    const childProcess = spawn(shell, [], {
+      cwd: gardenPath,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        // Add environment variable to indicate we're in a phantom garden
+        PHANTOM_GARDEN: gardenName,
+        PHANTOM_GARDEN_PATH: gardenPath,
+      },
+    });
+
+    childProcess.on("error", (error) => {
+      resolve({
+        success: false,
+        message: `Error starting shell: ${error.message}`,
+      });
+    });
+
+    childProcess.on("exit", (code, signal) => {
+      if (signal) {
+        resolve({
+          success: false,
+          message: `Shell terminated by signal: ${signal}`,
+          exitCode: 128 + (signal === "SIGTERM" ? 15 : 1),
+        });
+      } else {
+        const exitCode = code ?? 0;
+        resolve({
+          success: exitCode === 0,
+          exitCode,
+        });
+      }
+    });
+  });
+}
+
+export async function shellHandler(args: string[]): Promise<void> {
+  if (args.length < 1) {
+    console.error("Usage: phantom shell <garden-name>");
+    exit(1);
+  }
+
+  const gardenName = args[0];
+
+  // Get garden path for display
+  const gardenResult = await whereGarden(gardenName);
+  if (!gardenResult.success) {
+    console.error(gardenResult.message);
+    exit(1);
+  }
+
+  // Display entering message
+  console.log(`Entering garden '${gardenName}' at ${gardenResult.path}`);
+  console.log("Type 'exit' to return to your original directory\n");
+
+  const result = await shellInGarden(gardenName);
+
+  if (!result.success) {
+    if (result.message) {
+      console.error(result.message);
+    }
+    exit(result.exitCode ?? 1);
+  }
+
+  // Exit with the same code as the shell
+  exit(result.exitCode ?? 0);
+}