@love-moon/conductor-cli 0.11.2 → 0.13.0

package/src/fire-session-registry.js

@@ -134,3 +134,22 @@ export function pruneFireSessionRecords(dir, liveSessionNames, { fsImpl = fs } =
   }
   return pruned;
 }
+
+// Task ids a previous daemon left a tmux Fire running for. This is the only
+// evidence available to a successor that has no `tmux` binary to enumerate
+// sessions with, so it is what scopes that daemon's refusal to kill.
+export function listFireSessionTaskIds(dir, { fsImpl = fs } = {}) {
+  let entries;
+  try {
+    entries = fsImpl.readdirSync(dir);
+  } catch {
+    return new Set();
+  }
+  const taskIds = new Set();
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const record = readFireSessionRecord(dir, entry.slice(0, -".json".length), { fsImpl });
+    if (record?.taskId) taskIds.add(record.taskId);
+  }
+  return taskIds;
+}

package/src/remote/archive.js

@@ -0,0 +1,129 @@
+/**
+ * Directory transfer, built on the single-file path plus `tar`.
+ *
+ * `remote cp -r` packs a directory locally (or remotely), moves the one
+ * resulting tarball through the ordinary transfer, then unpacks it on the other
+ * side. No new protocol: the wire still only ever carries one file.
+ *
+ * The remote halves run through `sh -c` with the paths passed as **positional
+ * arguments**, never interpolated into the script text. A directory literally
+ * named `; rm -rf /` is therefore just an awkward directory name.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+
+/** Where the target stages its tarball. Overridable for hosts without /tmp. */
+export function remoteTempPath(env = process.env) {
+  const root = (env.CONDUCTOR_REMOTE_TMP || "/tmp").replace(/\/+$/, "") || "/tmp";
+  return `${root}/.conductor-rcp-${randomUUID()}.tgz`;
+}
+
+export function localTempPath() {
+  return path.join(os.tmpdir(), `.conductor-rcp-${randomUUID()}.tgz`);
+}
+
+/**
+ * Unpack `$1` into `$2`, following scp: an existing destination directory
+ * receives the source *inside* it; a missing one becomes the copy itself.
+ * `$3` is the source's basename, which is the top-level entry in the tarball.
+ */
+export const EXTRACT_SCRIPT = `
+set -e
+tmp=$1; dest=$2; base=$3
+if [ -d "$dest" ]; then
+  tar xzf "$tmp" -C "$dest"
+else
+  parent=$(dirname "$dest")
+  mkdir -p "$parent"
+  # Unpack into a private staging dir, never straight into the parent: the
+  # tarball's top entry is the SOURCE's name, and an unrelated neighbour of
+  # the destination could already have it. Extracting in place would clobber
+  # that neighbour, and the rename below would then carry it off.
+  # Staging inside the parent keeps the final mv on one filesystem.
+  stage=$(mktemp -d "$parent/.conductor-rcp-XXXXXX")
+  tar xzf "$tmp" -C "$stage"
+  rm -rf "$dest"
+  mv "$stage/$base" "$dest"
+  rmdir "$stage"
+fi
+`.trim();
+
+/** Pack directory `$1` into tarball `$2`, keeping `$1`'s own name inside. */
+export const PACK_SCRIPT = `
+set -e
+src=$1; tmp=$2
+if [ ! -d "$src" ]; then
+  echo "not a directory: $src" >&2
+  exit 1
+fi
+tar czf "$tmp" -C "$(dirname "$src")" "$(basename "$src")"
+`.trim();
+
+/** Remove the staged tarball. Never fails the transfer. */
+export const CLEANUP_SCRIPT = 'rm -f "$1"';
+
+/** `sh -c <script> sh <args...>` — the `sh` placeholder becomes $0. */
+export function shellArgs(script, ...args) {
+  return ["-c", script, "sh", ...args];
+}
+
+function runLocal(command, args, { spawnFn = spawn } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      // Bounded: a pathological tar could otherwise stream forever.
+      if (stderr.length < 8192) stderr += String(chunk);
+    });
+    child.on("error", (error) =>
+      reject(new Error(`failed to run ${command}: ${error.message}`)));
+    child.on("close", (code) => {
+      if (code === 0) return resolve();
+      reject(new Error(`${command} exited ${code}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+    });
+  });
+}
+
+/** Pack a local directory, preserving its own name as the top-level entry. */
+export async function packLocalDirectory(sourceDir, tarball, deps = {}) {
+  await runLocal(
+    "tar",
+    ["czf", tarball, "-C", path.dirname(sourceDir), path.basename(sourceDir)],
+    deps,
+  );
+  return tarball;
+}
+
+/** Unpack locally with the same scp semantics as `EXTRACT_SCRIPT`. */
+export async function unpackLocalDirectory(tarball, destination, baseName, deps = {}) {
+  const fsp = deps.fsp || fs.promises;
+  let destStat = null;
+  try {
+    destStat = await fsp.stat(destination);
+  } catch {
+    destStat = null;
+  }
+
+  if (destStat?.isDirectory()) {
+    await runLocal("tar", ["xzf", tarball, "-C", destination], deps);
+    return path.join(destination, baseName);
+  }
+
+  const parent = path.dirname(destination);
+  await fsp.mkdir(parent, { recursive: true });
+  // Same reasoning as EXTRACT_SCRIPT: stage in a private directory so an
+  // existing neighbour that happens to share the source's name survives.
+  const stage = await fsp.mkdtemp(path.join(parent, ".conductor-rcp-"));
+  try {
+    await runLocal("tar", ["xzf", tarball, "-C", stage], deps);
+    await fsp.rm(destination, { recursive: true, force: true });
+    await fsp.rename(path.join(stage, baseName), destination);
+  } finally {
+    await fsp.rm(stage, { recursive: true, force: true }).catch(() => {});
+  }
+  return destination;
+}

package/src/remote/client.js

@@ -0,0 +1,204 @@
+/**
+ * Shared plumbing for the `conductor remote` subcommands.
+ *
+ * `exec` and `cp` talk to the same backend, authenticate with the same token,
+ * resolve the same config file and report failures the same way, so all of that
+ * lives here rather than being copied per verb.
+ */
+
+import fs from "node:fs";
+import process from "node:process";
+
+import { ConductorConfig, loadConfig } from "@love-moon/conductor-sdk";
+import { envForExplicitConfigFile } from "../config-env.js";
+import { resolveConductorConfigPath } from "../conductor-paths.js";
+
+/**
+ * Following ssh: the remote command's exit code is passed through verbatim
+ * (0-254) and 255 is reserved for this CLI's own failures. Reusing 1/2/4 for
+ * local errors would make `grep` finding nothing (1) or `ls` on a missing path
+ * (2) indistinguishable from a network error or a usage mistake.
+ */
+export const EXIT = { OK: 0, CLI_ERROR: 255 };
+
+export class UsageError extends Error {}
+
+export const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** Accepts `500ms`, `30s`, `2m`, or a bare number of seconds. */
+export function parseTimeoutMs(value, defaultMs) {
+  if (value === undefined || value === null || value === "") {
+    return defaultMs;
+  }
+  const raw = String(value).trim().toLowerCase();
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m)?$/);
+  if (!match) {
+    throw new UsageError(`invalid --timeout value: ${value}`);
+  }
+  const amount = Number.parseFloat(match[1]);
+  const unit = match[2] || "s";
+  const multiplier = unit === "ms" ? 1 : unit === "m" ? 60_000 : 1_000;
+  const ms = Math.round(amount * multiplier);
+  if (!Number.isFinite(ms) || ms <= 0) {
+    throw new UsageError(`invalid --timeout value: ${value}`);
+  }
+  return ms;
+}
+
+export function loadCliConfig(configFile, env = process.env) {
+  const configPath = resolveConductorConfigPath(configFile, env);
+  const configEnv = envForExplicitConfigFile(configFile, env);
+  if (fs.existsSync(configPath)) {
+    return loadConfig(configPath, { env: configEnv });
+  }
+
+  const agentToken = typeof env.CONDUCTOR_AGENT_TOKEN === "string" ? env.CONDUCTOR_AGENT_TOKEN.trim() : "";
+  const backendUrl = typeof env.CONDUCTOR_BACKEND_URL === "string" ? env.CONDUCTOR_BACKEND_URL.trim() : "";
+  if (agentToken && backendUrl) {
+    return new ConductorConfig({ agentToken, backendUrl });
+  }
+
+  return loadConfig(configPath, { env: configEnv });
+}
+
+function authHeaders(config) {
+  return { Authorization: `Bearer ${config.agentToken}` };
+}
+
+async function toApiError(response) {
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = null;
+  }
+  const message = payload?.error || text.trim() || `HTTP ${response.status}`;
+  const error = new Error(message);
+  error.status = response.status;
+  // A 409 on a chunked upload means "wrong offset, here is the real one".
+  // Carrying it on the error is what lets the caller resync instead of failing.
+  if (typeof payload?.receivedBytes === "number") {
+    error.receivedBytes = payload.receivedBytes;
+  }
+  return error;
+}
+
+/**
+ * Whether a failed request is worth retrying.
+ *
+ * Network-level failures have no `status` at all; those are the blips resume
+ * exists for. Among HTTP statuses only 5xx and 429 can plausibly succeed on a
+ * second try — retrying a 403 or a 413 just wastes the user's time.
+ */
+export function isRetryable(error) {
+  const status = error?.status;
+  if (status === undefined || status === null) return true;
+  return status >= 500 || status === 429;
+}
+
+/**
+ * Retry `fn` on transient failures, handing it the attempt number. `retryable`
+ * narrows what counts as transient: a caller whose request is not idempotent
+ * (starting a command) must not retry a 5xx that may already have taken effect.
+ */
+export async function withRetry(fn, {
+  attempts = 4, baseDelayMs = 500, sleep = delay, retryable = isRetryable,
+} = {}) {
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      lastError = error;
+      // An aborted transfer is the caller's own deadline firing, not a blip.
+      if (error?.name === "AbortError" || !retryable(error)) throw error;
+      if (attempt === attempts - 1) break;
+      await sleep(baseDelayMs * 2 ** attempt);
+    }
+  }
+  throw lastError;
+}
+
+export async function callApi(config, method, pathname, body, fetchImpl) {
+  const url = new URL(pathname, config.backendUrl);
+  const response = await fetchImpl(url.toString(), {
+    method,
+    headers: {
+      ...authHeaders(config),
+      Accept: "application/json",
+      ...(body ? { "Content-Type": "application/json" } : {}),
+    },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  });
+
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = null;
+  }
+
+  if (!response.ok) {
+    const message = payload?.error || text.trim() || `HTTP ${response.status}`;
+    const error = new Error(message);
+    error.status = response.status;
+    throw error;
+  }
+  return payload;
+}
+
+/**
+ * Stream a body up to the backend. Kept separate from `callApi` because the
+ * body is a stream, not JSON: buffering a multi-hundred-MB file just to reuse
+ * one helper would defeat the point of the whole transfer design.
+ */
+export async function putStream(config, pathname, stream, {
+  sizeBytes, fetchImpl, signal, contentRange,
+}) {
+  const url = new URL(pathname, config.backendUrl);
+  const response = await fetchImpl(url.toString(), {
+    method: "PUT",
+    headers: {
+      ...authHeaders(config),
+      Accept: "application/json",
+      "Content-Type": "application/octet-stream",
+      ...(Number.isFinite(sizeBytes) ? { "Content-Length": String(sizeBytes) } : {}),
+      ...(contentRange ? { "Content-Range": contentRange } : {}),
+    },
+    body: stream,
+    // Node's fetch requires this for a streaming request body.
+    duplex: "half",
+    ...(signal ? { signal } : {}),
+  });
+  if (!response.ok) {
+    throw await toApiError(response);
+  }
+  const text = await response.text();
+  try {
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Open a streaming download. The caller owns consuming `response.body`. */
+export async function getStream(config, pathname, { fetchImpl, signal, rangeFrom }) {
+  const url = new URL(pathname, config.backendUrl);
+  const response = await fetchImpl(url.toString(), {
+    method: "GET",
+    headers: {
+      ...authHeaders(config),
+      Accept: "application/octet-stream",
+      ...(rangeFrom > 0 ? { Range: `bytes=${rangeFrom}-` } : {}),
+    },
+    ...(signal ? { signal } : {}),
+  });
+  // 416 is not a failure here: it means the local `.part` is already at or past
+  // the full size, so there is nothing left to fetch.
+  if (!response.ok && response.status !== 416) {
+    throw await toApiError(response);
+  }
+  return response;
+}