openpalm 0.3.2 → 0.3.4

package/dist/openpalm.js

@@ -7232,46 +7232,106 @@ function generateToken(length = 64) {
   return urlSafeBase64.slice(0, length);
 }
 
-// packages/lib/src/compose.ts
-function buildComposeArgs(config) {
-  return [
-    config.subcommand,
-    "--env-file",
-    config.envFile,
-    "-f",
-    config.composeFile
-  ];
+// packages/lib/src/compose-runner.ts
+var transientErrorMatchers = [
+  { pattern: /Cannot connect to the Docker daemon|error during connect|dial unix/i, code: "daemon_unreachable", retryable: true },
+  { pattern: /pull access denied|manifest unknown|failed to fetch/i, code: "image_pull_failed", retryable: true },
+  { pattern: /permission denied|access denied/i, code: "permission_denied", retryable: false },
+  { pattern: /yaml:|invalid compose|unsupported config/i, code: "invalid_compose", retryable: false }
+];
+function classifyError(stderr) {
+  for (const matcher of transientErrorMatchers) {
+    if (matcher.pattern.test(stderr))
+      return { code: matcher.code, retryable: matcher.retryable };
+  }
+  return { code: "unknown", retryable: false };
 }
-async function composeExec(config, args, options) {
-  const fullArgs = [...buildComposeArgs(config), ...args];
-  const proc = Bun.spawn([config.bin, ...fullArgs], {
-    stdout: options?.stream ? "inherit" : "pipe",
-    stderr: options?.stream ? "inherit" : "pipe",
-    stdin: "inherit"
-  });
-  const timeoutMs = options?.timeout ?? (options?.stream ? 0 : 30000);
-  if (timeoutMs > 0) {
-    const result = await Promise.race([
-      proc.exited.then(() => "done"),
-      new Promise((r) => setTimeout(() => r("timeout"), timeoutMs))
-    ]);
-    if (result === "timeout") {
-      proc.kill();
-      return { exitCode: 1, stdout: "", stderr: `compose command timed out after ${timeoutMs}ms` };
-    }
-  } else {
-    await proc.exited;
+function buildComposeArgs(options, args) {
+  const base = [];
+  if (options.subcommand)
+    base.push(options.subcommand);
+  if (options.envFile)
+    base.push("--env-file", options.envFile);
+  base.push("-f", options.composeFile);
+  return [...base, ...args];
+}
+async function runComposeOnce(args, options) {
+  const composeArgs = buildComposeArgs(options, args);
+  const stream = options.stream ?? false;
+  const timeoutMs = options.timeoutMs ?? (stream ? 0 : 30000);
+  const controller = timeoutMs > 0 ? new AbortController : undefined;
+  const spawnOptions = {
+    stdout: stream ? "inherit" : "pipe",
+    stderr: stream ? "inherit" : "pipe",
+    stdin: "inherit",
+    cwd: options.cwd,
+    env: options.env ? { ...process.env, ...options.env } : process.env,
+    signal: controller?.signal
+  };
+  let timeoutId;
+  if (controller && timeoutMs > 0) {
+    timeoutId = setTimeout(() => controller.abort("timeout"), timeoutMs);
   }
+  let proc;
+  try {
+    proc = Bun.spawn([options.bin, ...composeArgs], spawnOptions);
+    await proc.exited;
+  } catch (error) {
+    if (timeoutId)
+      clearTimeout(timeoutId);
+    const message = error instanceof Error ? error.message : String(error);
+    const isTimeout = controller?.signal.aborted === true || message.includes("timeout");
+    const classified2 = classifyError(message);
+    const code = isTimeout ? "timeout" : classified2.code;
+    return { ok: false, exitCode: 1, stdout: "", stderr: message, code };
+  }
+  if (timeoutId)
+    clearTimeout(timeoutId);
   const exitCode = proc.exitCode ?? 1;
-  const stdout = options?.stream ? "" : await new Response(proc.stdout).text();
-  const stderr = options?.stream ? "" : await new Response(proc.stderr).text();
-  return { exitCode, stdout, stderr };
+  const stdoutStream = proc.stdout;
+  const stderrStream = proc.stderr;
+  const stdout = stream || typeof stdoutStream === "number" || !stdoutStream ? "" : await new Response(stdoutStream).text();
+  const stderr = stream || typeof stderrStream === "number" || !stderrStream ? "" : await new Response(stderrStream).text();
+  if (exitCode === 0)
+    return { ok: true, exitCode, stdout, stderr, code: "unknown" };
+  const classified = classifyError(stderr);
+  return { ok: false, exitCode, stdout, stderr, code: classified.code };
+}
+async function runCompose(args, options) {
+  const retries = options.retries ?? 2;
+  let attempt = 0;
+  while (true) {
+    const result = await runComposeOnce(args, options);
+    if (result.ok)
+      return result;
+    if (result.code === "timeout")
+      return result;
+    const classified = classifyError(result.stderr);
+    if (classified.code !== "unknown")
+      result.code = classified.code;
+    if (!classified.retryable || attempt >= retries)
+      return result;
+    attempt += 1;
+  }
+}
+
+// packages/lib/src/compose.ts
+async function composeExec(config, args, options) {
+  const result = await runCompose(args, {
+    bin: config.bin,
+    subcommand: config.subcommand,
+    envFile: config.envFile,
+    composeFile: config.composeFile,
+    stream: options?.stream,
+    timeoutMs: options?.timeout
+  });
+  return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr, code: result.code };
 }
 async function composePull(config, services) {
   const args = ["pull", ...services ?? []];
   const result = await composeExec(config, args, { stream: true });
   if (result.exitCode !== 0) {
-    throw new Error(`compose pull failed with exit code ${result.exitCode}`);
+    throw new Error(`compose pull failed:${result.code}`);
   }
 }
 async function composeUp(config, services, options) {
@@ -7294,7 +7354,7 @@ async function composeUp(config, services, options) {
   }
   const result = await composeExec(config, args, { stream: true });
   if (result.exitCode !== 0) {
-    throw new Error(`compose up failed with exit code ${result.exitCode}`);
+    throw new Error(`compose up failed:${result.code}`);
   }
 }
 async function composeDown(config, options) {
@@ -7308,21 +7368,21 @@ async function composeDown(config, options) {
   }
   const result = await composeExec(config, args, { stream: true });
   if (result.exitCode !== 0) {
-    throw new Error(`compose down failed with exit code ${result.exitCode}`);
+    throw new Error(`compose down failed:${result.code}`);
   }
 }
 async function composeRestart(config, services) {
   const args = ["restart", ...services ?? []];
   const result = await composeExec(config, args, { stream: true });
   if (result.exitCode !== 0) {
-    throw new Error(`compose restart failed with exit code ${result.exitCode}`);
+    throw new Error(`compose restart failed:${result.code}`);
   }
 }
 async function composeStop(config, services) {
   const args = ["stop", ...services ?? []];
   const result = await composeExec(config, args, { stream: true });
   if (result.exitCode !== 0) {
-    throw new Error(`compose stop failed with exit code ${result.exitCode}`);
+    throw new Error(`compose stop failed:${result.code}`);
   }
 }
 async function composeLogs(config, services, options) {
@@ -7338,13 +7398,13 @@ async function composeLogs(config, services, options) {
   }
   const result = await composeExec(config, args, { stream: true });
   if (result.exitCode !== 0) {
-    throw new Error(`compose logs failed with exit code ${result.exitCode}`);
+    throw new Error(`compose logs failed:${result.code}`);
   }
 }
 async function composePs(config) {
   const result = await composeExec(config, ["ps", "-a"]);
   if (result.exitCode !== 0) {
-    throw new Error(`compose ps failed with exit code ${result.exitCode}`);
+    throw new Error(`compose ps failed:${result.code}`);
   }
   return result.stdout;
 }
@@ -9071,7 +9131,7 @@ async function automation(subcommand, args) {
 // packages/cli/package.json
 var package_default = {
   name: "openpalm",
-  version: "0.3.2",
+  version: "0.3.4",
   description: "CLI tool for installing and managing an OpenPalm stack",
   type: "module",
   license: "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openpalm",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "CLI tool for installing and managing an OpenPalm stack",
   "type": "module",
   "license": "MIT",