podman 0.1.6 → 0.2.0

package/README.md

@@ -14,8 +14,11 @@ npm i podman
 ```ts
 import * as podman from 'podman'
 
-await podman.startMachine()  // podman-machine-default
-await podman.startMachine('your-machine-name')
+await podman.forceStartMachine()  // podman-machine-default
+await podman.forceStartMachine('your-machine-name')
+
+const machines = await podman.listMachines()
+console.log(machines.map((machine) => machine.Name))
 
 const imageId = await podman.build({
   context: '.',

package/dist/commands/build.d.ts

@@ -211,7 +211,8 @@ type PodmanBuildOptions = {
 /**
  * Builds a container image using podman build.
  *
- * Use [`startMachine`]{@link startMachine} first when running against a Podman VM.
+ * Use [`forceStartMachine`]{@link forceStartMachine} (or [`isMachineRunning`]{@link isMachineRunning} + [`startMachine`]{@link startMachine})
+ * first when running against a Podman VM.
  *
  * @param options Build options for podman build.
  * @returns Resolves with the built image ID (sha256 hash).
@@ -226,9 +227,9 @@ type PodmanBuildOptions = {
  *
  * @example
  * ```ts
- * import {startMachine, build} from 'podman'
+ * import {forceStartMachine, build} from 'podman'
  *
- * await startMachine()
+ * await forceStartMachine()
  * const imageId = await build({file: './Containerfile', tag: 'my-app:dev'})
  * console.log(imageId)
  * ```

package/dist/commands/start-machine.d.ts

@@ -1,17 +1,79 @@
+type PodmanMachine = {
+    Name: string;
+    Default: boolean;
+    Created: string;
+    Running: boolean;
+    Starting: boolean;
+    LastUp: string;
+    Stream: string;
+    VMType: string;
+    CPUs: number;
+    Memory: string;
+    Swap: string;
+    DiskSize: string;
+    Port: number;
+    RemoteUsername: string;
+    IdentityPath: string;
+    UserModeNetworking: boolean;
+};
 /**
- * Ensures the Podman machine is running.
+ * Lists Podman machines from `podman machine list --format json`.
+ *
+ * @returns Resolves with the list of machines.
+ *
+ * @example
+ * ```ts
+ * import {listMachines} from 'podman'
+ *
+ * const machines = await listMachines()
+ * console.log(machines.map((machine) => machine.Name))
+ * ```
+ */
+export declare function listMachines(): Promise<PodmanMachine[]>;
+/**
+ * Checks whether a Podman machine is currently running.
+ *
+ * @param machineName Name of the Podman machine to inspect.
+ * @returns Resolves to true when the machine is running.
+ *
+ * @example
+ * ```ts
+ * import {isMachineRunning} from 'podman'
+ *
+ * const running = await isMachineRunning()
+ * console.log('Machine running:', running)
+ * ```
+ */
+export declare function isMachineRunning(machineName?: string): Promise<boolean>;
+/**
+ * Starts a Podman machine.
  *
  * @param machineName Name of the Podman machine to start.
- * @returns Resolves to true when a machine start was triggered, or false if it is already running.
+ * @returns Resolves when the start command completes.
  *
  * @example
  * ```ts
  * import {startMachine} from 'podman'
  *
- * const started = await startMachine()
+ * await startMachine('podman-machine-default')
+ * ```
+ */
+export declare function startMachine(machineName?: string): Promise<void>;
+/**
+ * Starts a Podman machine, ignoring the "already running" error.
+ *
+ * @param machineName Name of the Podman machine to start.
+ * @returns Resolves to true when a start was triggered, or false when it was already running.
+ *
+ * @example
+ * ```ts
+ * import {forceStartMachine} from 'podman'
+ *
+ * const started = await forceStartMachine()
  * if (started) {
  *     console.log('Podman machine booted.')
  * }
  * ```
  */
-export declare function startMachine(machineName?: string): Promise<boolean>;
+export declare function forceStartMachine(machineName?: string): Promise<boolean>;
+export {};

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { run } from './commands/run';
 export { build } from './commands/build';
 export { push } from './commands/push';
 export { tag } from './commands/tag';
-export { startMachine } from './commands/start-machine.ts';
+export { forceStartMachine, isMachineRunning, listMachines, startMachine } from './commands/start-machine.ts';

package/dist/index.js

@@ -449,25 +449,50 @@ async function tag(image, targetNames) {
   return execPodmanStreaming(args.toArgs());
 }
 // src/commands/start-machine.ts
-async function startMachine(machineName = "podman-machine-default") {
+async function listMachines() {
   const out = await execPodman(["machine", "list", "--format", "json"]);
-  const machines = JSON.parse(out || "[]");
+  return JSON.parse(out || "[]");
+}
+async function isMachineRunning(machineName = "podman-machine-default") {
+  const machines = await listMachines();
   const m = machines.find((x) => x.Name === machineName);
   if (!m) {
     throw new Error(`Podman machine "${machineName}" not found in list:
 ${machines.map((x) => `- ${x.Name}`).join(`
 `)}`);
   }
-  if (m.Running) {
+  return m.Running;
+}
+async function startMachine(machineName = "podman-machine-default") {
+  await execPodman(["machine", "start", machineName]);
+}
+async function forceStartMachine(machineName = "podman-machine-default") {
+  try {
+    await startMachine(machineName);
+    return true;
+  } catch (err) {
+    if (isAlreadyRunningError(err)) {
+      return false;
+    }
+    throw err;
+  }
+}
+function isAlreadyRunningError(err) {
+  if (!err || typeof err !== "object") {
     return false;
   }
-  await execPodman(["machine", "start", machineName]);
-  return true;
+  const candidate = err;
+  const combined = [candidate.stderr, candidate.stdout, candidate.message].filter(Boolean).join(`
+`);
+  return combined.toLowerCase().includes("already running");
 }
 export {
   tag,
   startMachine,
   run,
   push,
+  listMachines,
+  isMachineRunning,
+  forceStartMachine,
   build
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "podman",
-    "version": "0.1.6",
+    "version": "0.2.0",
     "description": "Utilities for starting a Podman machine from Bun/Node.",
     "author": "Mark Penner <npm@mpen.ca>",
     "module": "index.ts",