@hasna/loops 0.3.3 → 0.3.5

package/dist/sdk/index.js

@@ -345,6 +345,7 @@ function rowToLoop(row) {
     status: row.status,
     schedule: JSON.parse(row.schedule_json),
     target: JSON.parse(row.target_json),
+    machine: row.machine_json ? JSON.parse(row.machine_json) : undefined,
     nextRunAt: row.next_run_at ?? undefined,
     retryScheduledFor: row.retry_scheduled_for ?? undefined,
     catchUp: row.catch_up,
@@ -487,6 +488,7 @@ class Store {
         status TEXT NOT NULL,
         schedule_json TEXT NOT NULL,
         target_json TEXT NOT NULL,
+        machine_json TEXT,
         next_run_at TEXT,
         retry_scheduled_for TEXT,
         catch_up TEXT NOT NULL,
@@ -608,10 +610,14 @@ class Store {
       );
       CREATE INDEX IF NOT EXISTS idx_workflow_events_run_sequence ON workflow_events(workflow_run_id, sequence);
     `);
+    try {
+      this.db.query("ALTER TABLE loops ADD COLUMN machine_json TEXT").run();
+    } catch {}
     try {
       this.db.query("ALTER TABLE workflow_step_runs ADD COLUMN pid INTEGER").run();
     } catch {}
     this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0001_initial_and_workflows", nowIso());
+    this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0002_loop_machines", nowIso());
   }
   assertDaemonLeaseFence(opts = {}, now = nowIso()) {
     if (!opts.daemonLeaseId)
@@ -629,6 +635,7 @@ class Store {
       status: "active",
       schedule: input.schedule,
       target: input.target,
+      machine: input.machine,
       nextRunAt: initialNextRun(input.schedule, from),
       catchUp: input.catchUp ?? "latest",
       catchUpLimit: input.catchUpLimit ?? 50,
@@ -640,9 +647,9 @@ class Store {
       createdAt: now,
       updatedAt: now
     };
-    this.db.query(`INSERT INTO loops (id, name, description, status, schedule_json, target_json, next_run_at, retry_scheduled_for,
+    this.db.query(`INSERT INTO loops (id, name, description, status, schedule_json, target_json, machine_json, next_run_at, retry_scheduled_for,
           catch_up, catch_up_limit, overlap, max_attempts, retry_delay_ms, lease_ms, expires_at, created_at, updated_at)
-         VALUES ($id, $name, $description, $status, $schedule, $target, $nextRun, NULL, $catchUp, $catchUpLimit,
+         VALUES ($id, $name, $description, $status, $schedule, $target, $machine, $nextRun, NULL, $catchUp, $catchUpLimit,
           $overlap, $maxAttempts, $retryDelay, $leaseMs, $expiresAt, $created, $updated)`).run({
       $id: loop.id,
       $name: loop.name,
@@ -650,6 +657,7 @@ class Store {
       $status: loop.status,
       $schedule: JSON.stringify(loop.schedule),
       $target: JSON.stringify(loop.target),
+      $machine: loop.machine ? JSON.stringify(loop.machine) : null,
       $nextRun: loop.nextRunAt ?? null,
       $catchUp: loop.catchUp,
       $catchUpLimit: loop.catchUpLimit,
@@ -1500,8 +1508,9 @@ class Store {
 }
 
 // src/lib/executor.ts
-import { spawn } from "child_process";
+import { spawn, spawnSync as spawnSync2 } from "child_process";
 import { once } from "events";
+import { resolveMachineCommand } from "@hasna/machines/consumer";
 
 // src/lib/accounts.ts
 import { spawnSync } from "child_process";
@@ -1658,6 +1667,59 @@ function commandNotFoundMessage(command, env = process.env) {
   return `Executable not found in PATH: ${command}. Effective PATH=${env.PATH || "(empty)"}`;
 }
 
+// src/lib/machines.ts
+import {
+  discoverMachineTopology,
+  resolveMachineRoute
+} from "@hasna/machines/consumer";
+function compact(value) {
+  const text = value?.trim();
+  return text ? text : undefined;
+}
+function entryToSummary(entry, topology) {
+  return {
+    id: entry.machine_id,
+    hostname: compact(entry.hostname),
+    platform: compact(entry.platform),
+    user: compact(entry.user),
+    workspacePath: compact(entry.workspace_path),
+    route: entry.ssh.route,
+    local: entry.machine_id === topology.local_machine_id || entry.ssh.route === "local",
+    heartbeatStatus: entry.heartbeat_status,
+    tailscaleOnline: entry.tailscale.online,
+    tags: entry.tags
+  };
+}
+function machineFromRoute(route, topology) {
+  if (!route.ok || !route.machine_id) {
+    throw new Error(`OpenMachines route not found for machine: ${route.requested_machine_id}`);
+  }
+  const entry = topology.machines.find((machine) => machine.machine_id === route.machine_id);
+  return {
+    id: route.machine_id,
+    requestedId: route.requested_machine_id !== route.machine_id ? route.requested_machine_id : undefined,
+    route: route.route,
+    local: route.local,
+    confidence: route.confidence,
+    workspacePath: compact(entry?.workspace_path),
+    resolvedAt: route.generated_at,
+    packageVersion: route.package.version,
+    warnings: route.warnings.length ? route.warnings : undefined
+  };
+}
+function listOpenMachines() {
+  const topology = discoverMachineTopology();
+  return topology.machines.map((entry) => entryToSummary(entry, topology));
+}
+function resolveLoopMachine(machineId) {
+  const topology = discoverMachineTopology();
+  const route = resolveMachineRoute(machineId, { topology });
+  return machineFromRoute(route, topology);
+}
+function refreshLoopMachine(machine) {
+  return resolveLoopMachine(machine.id);
+}
+
 // src/lib/executor.ts
 var DEFAULT_TIMEOUT_MS = 30 * 60000;
 var DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
@@ -1678,6 +1740,23 @@ var AUTH_ENV_KEYS = [
   "XDG_STATE_HOME",
   "XDG_CACHE_HOME"
 ];
+var TRANSPORT_ENV_KEYS = new Set([
+  "BUN_INSTALL",
+  "HOME",
+  "LANG",
+  "LANGUAGE",
+  "LOGNAME",
+  "PATH",
+  "SHELL",
+  "SSH_AGENT_PID",
+  "SSH_AUTH_SOCK",
+  "TERM",
+  "TMP",
+  "TMPDIR",
+  "TEMP",
+  "USER",
+  "XDG_RUNTIME_DIR"
+]);
 function appendBounded(current, chunk, maxBytes) {
   const next = current + chunk.toString("utf8");
   if (Buffer.byteLength(next, "utf8") <= maxBytes)
@@ -1704,6 +1783,29 @@ function killProcessGroup(pid) {
     }
   }, 2000).unref();
 }
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function metadataEnv(metadata) {
+  const env = {};
+  if (metadata.loopId)
+    env.LOOPS_LOOP_ID = metadata.loopId;
+  if (metadata.loopName)
+    env.LOOPS_LOOP_NAME = metadata.loopName;
+  if (metadata.runId)
+    env.LOOPS_RUN_ID = metadata.runId;
+  if (metadata.scheduledFor)
+    env.LOOPS_SCHEDULED_FOR = metadata.scheduledFor;
+  if (metadata.workflowId)
+    env.LOOPS_WORKFLOW_ID = metadata.workflowId;
+  if (metadata.workflowName)
+    env.LOOPS_WORKFLOW_NAME = metadata.workflowName;
+  if (metadata.workflowRunId)
+    env.LOOPS_WORKFLOW_RUN_ID = metadata.workflowRunId;
+  if (metadata.workflowStepId)
+    env.LOOPS_WORKFLOW_STEP_ID = metadata.workflowStepId;
+  return env;
+}
 function providerCommand(provider) {
   switch (provider) {
     case "claude":
@@ -1825,26 +1927,213 @@ function executionEnv(spec, metadata, opts) {
   }
   Object.assign(env, spec.env ?? {});
   env.PATH = normalizeExecutionPath(env);
-  if (metadata.loopId)
-    env.LOOPS_LOOP_ID = metadata.loopId;
-  if (metadata.loopName)
-    env.LOOPS_LOOP_NAME = metadata.loopName;
-  if (metadata.runId)
-    env.LOOPS_RUN_ID = metadata.runId;
-  if (metadata.scheduledFor)
-    env.LOOPS_SCHEDULED_FOR = metadata.scheduledFor;
-  if (metadata.workflowId)
-    env.LOOPS_WORKFLOW_ID = metadata.workflowId;
-  if (metadata.workflowName)
-    env.LOOPS_WORKFLOW_NAME = metadata.workflowName;
-  if (metadata.workflowRunId)
-    env.LOOPS_WORKFLOW_RUN_ID = metadata.workflowRunId;
-  if (metadata.workflowStepId)
-    env.LOOPS_WORKFLOW_STEP_ID = metadata.workflowStepId;
+  Object.assign(env, metadataEnv(metadata));
+  return env;
+}
+function resolvedMachine(opts) {
+  if (!opts.machine)
+    return;
+  return (opts.machineResolver ?? refreshLoopMachine)(opts.machine);
+}
+function commandForShell(spec) {
+  if (!spec.args.length)
+    return spec.command;
+  return [spec.command, ...spec.args.map(shellQuote)].join(" ");
+}
+function hereDoc(value) {
+  let delimiter2 = `__OPENLOOPS_STDIN_${Math.random().toString(36).slice(2).toUpperCase()}__`;
+  while (value.split(/\r?\n/).includes(delimiter2)) {
+    delimiter2 = `__OPENLOOPS_STDIN_${Math.random().toString(36).slice(2).toUpperCase()}__`;
+  }
+  return [`cat > "$__OPENLOOPS_STDIN" <<'${delimiter2}'`, value, delimiter2];
+}
+function remoteBootstrapLines(spec, metadata) {
+  const lines = [
+    "set -e",
+    'export PATH="$HOME/.local/bin:$HOME/.bun/bin:$HOME/.cargo/bin:$HOME/.npm-global/bin:$HOME/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin${PATH:+:$PATH}"'
+  ];
+  if (spec.cwd)
+    lines.push(`cd ${shellQuote(spec.cwd)}`);
+  if (spec.account) {
+    if (!spec.accountTool)
+      throw new Error("account.tool is required when no provider tool can be inferred");
+    lines.push("if ! command -v accounts >/dev/null 2>&1; then echo 'accounts CLI is not available on remote machine' >&2; exit 127; fi", `unset ${AUTH_ENV_KEYS.join(" ")}`, `eval "$(accounts env ${shellQuote(spec.account.profile)} --tool ${shellQuote(spec.accountTool)})"`, `export LOOPS_ACCOUNT_PROFILE=${shellQuote(spec.account.profile)}`, `export LOOPS_ACCOUNT_TOOL=${shellQuote(spec.accountTool)}`);
+  }
+  for (const [key, value] of Object.entries({ ...metadataEnv(metadata), ...spec.env ?? {} })) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+      continue;
+    lines.push(`export ${key}=${shellQuote(value)}`);
+  }
+  return lines;
+}
+function remoteScript(spec, metadata) {
+  const lines = remoteBootstrapLines(spec, metadata);
+  let stdinRedirect = "";
+  if (spec.stdin !== undefined) {
+    lines.push('__OPENLOOPS_STDIN="$(mktemp -t openloops-stdin.XXXXXX)"', `trap 'rm -f "$__OPENLOOPS_STDIN"' EXIT`);
+    lines.push(...hereDoc(spec.stdin));
+    stdinRedirect = ' < "$__OPENLOOPS_STDIN"';
+  }
+  const invocation = spec.shell ? `sh -c ${shellQuote(commandForShell(spec))}${stdinRedirect}` : `${[spec.command, ...spec.args].map(shellQuote).join(" ")}${stdinRedirect}`;
+  lines.push(invocation);
+  return `${lines.join(`
+`)}
+`;
+}
+function remotePreflightScript(spec, metadata) {
+  return [
+    ...remoteBootstrapLines(spec, metadata),
+    "command -v bash >/dev/null 2>&1",
+    `command -v ${shellQuote(spec.shell ? "sh" : spec.command)} >/dev/null 2>&1`
+  ].join(`
+`);
+}
+function transportEnv(opts) {
+  const source = opts.env ?? process.env;
+  const env = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === undefined)
+      continue;
+    if (TRANSPORT_ENV_KEYS.has(key) || key.startsWith("LC_"))
+      env[key] = value;
+  }
+  env.PATH = normalizeExecutionPath(env);
   return env;
 }
+function preflightRemoteSpec(spec, machine, metadata, opts) {
+  const plan = (opts.machineCommandResolver ?? resolveMachineCommand)(machine.id, "bash -s");
+  const result = spawnSync2(plan.command, plan.args, {
+    encoding: "utf8",
+    env: transportEnv(opts),
+    input: remotePreflightScript(spec, metadata),
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 15000
+  });
+  if (result.error)
+    throw new Error(`remote preflight failed on ${machine.id}: ${result.error.message}`);
+  if ((result.status ?? 1) !== 0) {
+    const detail = (result.stderr || result.stdout || `exit ${result.status ?? "unknown"}`).trim();
+    throw new Error(`remote preflight failed on ${machine.id}${detail ? `: ${detail}` : ""}`);
+  }
+}
+async function executeRemoteSpec(spec, machine, metadata, opts) {
+  const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  const startedAt = nowIso();
+  let stdout = "";
+  let stderr = "";
+  let timedOut = false;
+  let exitCode;
+  let error;
+  let plan;
+  let script;
+  try {
+    plan = (opts.machineCommandResolver ?? resolveMachineCommand)(machine.id, "bash -s");
+    script = remoteScript(spec, metadata);
+  } catch (err) {
+    return {
+      status: "failed",
+      stdout: "",
+      stderr: "",
+      error: err instanceof Error ? err.message : String(err),
+      startedAt,
+      finishedAt: nowIso(),
+      durationMs: 0
+    };
+  }
+  const child = spawn(plan.command, plan.args, {
+    env: transportEnv(opts),
+    detached: true,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (child.pid)
+    opts.onSpawn?.(child.pid);
+  child.stdin?.on("error", (err) => {
+    if (err.code !== "EPIPE")
+      error = err.message;
+  });
+  child.stdin?.end(script);
+  const abortHandler = () => {
+    error = "cancelled";
+    if (child.pid)
+      killProcessGroup(child.pid);
+  };
+  if (opts.signal?.aborted)
+    abortHandler();
+  opts.signal?.addEventListener("abort", abortHandler, { once: true });
+  child.stdout?.on("data", (chunk) => {
+    stdout = appendBounded(stdout, chunk, maxOutputBytes);
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderr = appendBounded(stderr, chunk, maxOutputBytes);
+  });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    if (child.pid)
+      killProcessGroup(child.pid);
+  }, spec.timeoutMs);
+  timer.unref();
+  try {
+    const [code, signal] = await once(child, "exit");
+    if (typeof code === "number")
+      exitCode = code;
+    if (signal)
+      error = `terminated by ${signal}`;
+  } catch (err) {
+    error = err instanceof Error ? err.message : String(err);
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", abortHandler);
+  }
+  const finishedAt = nowIso();
+  const durationMs = new Date(finishedAt).getTime() - new Date(startedAt).getTime();
+  if (timedOut) {
+    return {
+      status: "timed_out",
+      exitCode,
+      stdout,
+      stderr,
+      error: `timed out after ${spec.timeoutMs}ms`,
+      pid: child.pid,
+      startedAt,
+      finishedAt,
+      durationMs
+    };
+  }
+  if (error || exitCode !== 0) {
+    return {
+      status: "failed",
+      exitCode,
+      stdout,
+      stderr,
+      error: error ?? `remote process on ${machine.id} exited with code ${exitCode ?? "unknown"}`,
+      pid: child.pid,
+      startedAt,
+      finishedAt,
+      durationMs
+    };
+  }
+  return {
+    status: "succeeded",
+    exitCode,
+    stdout,
+    stderr,
+    pid: child.pid,
+    startedAt,
+    finishedAt,
+    durationMs
+  };
+}
 function preflightTarget(target, metadata = {}, opts = {}) {
   const spec = commandSpec(target);
+  const machine = resolvedMachine(opts);
+  if (machine && !machine.local) {
+    preflightRemoteSpec(spec, machine, metadata, opts);
+    return {
+      command: spec.command,
+      accountProfile: spec.account?.profile,
+      accountTool: spec.accountTool
+    };
+  }
   const env = executionEnv(spec, metadata, opts);
   if (!spec.shell && !executableExists(spec.command, env)) {
     throw new Error(commandNotFoundMessage(spec.command, env));
@@ -1857,6 +2146,9 @@ function preflightTarget(target, metadata = {}, opts = {}) {
 }
 async function executeTarget(target, metadata = {}, opts = {}) {
   const spec = commandSpec(target);
+  const machine = resolvedMachine(opts);
+  if (machine && !machine.local)
+    return executeRemoteSpec(spec, machine, metadata, opts);
   const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   const startedAt = nowIso();
   let stdout = "";
@@ -1972,7 +2264,7 @@ async function executeLoop(loop, run, opts = {}) {
     loopName: loop.name,
     runId: run.id,
     scheduledFor: run.scheduledFor
-  }, opts);
+  }, { ...opts, machine: opts.machine ?? loop.machine });
 }
 
 // src/lib/workflow-runner.ts
@@ -2074,6 +2366,7 @@ async function executeWorkflow(store, workflow, opts = {}) {
     try {
       result = await executeTarget(targetWithStepAccount(step), metadata, {
         ...opts,
+        machine: opts.machine ?? opts.loop?.machine,
         signal: controller.signal,
         onSpawn: (pid) => {
           opts.beforePersist?.();

package/dist/types.d.ts

@@ -7,6 +7,19 @@ export interface AccountRef {
     profile: string;
     tool?: string;
 }
+export type LoopMachineRoute = "local" | "lan" | "tailscale" | "ssh" | "unknown";
+export type LoopMachineConfidence = "exact" | "high" | "medium" | "low" | "none";
+export interface LoopMachineRef {
+    id: string;
+    requestedId?: string;
+    route?: LoopMachineRoute;
+    local?: boolean;
+    confidence?: LoopMachineConfidence;
+    workspacePath?: string;
+    resolvedAt?: string;
+    packageVersion?: string;
+    warnings?: string[];
+}
 export interface OnceSchedule {
     type: "once";
     at: string;
@@ -138,6 +151,7 @@ export interface Loop {
     status: LoopStatus;
     schedule: ScheduleSpec;
     target: LoopTarget;
+    machine?: LoopMachineRef;
     nextRunAt?: string;
     retryScheduledFor?: string;
     catchUp: CatchUpPolicy;
@@ -175,6 +189,7 @@ export interface CreateLoopInput {
     description?: string;
     schedule: ScheduleSpec;
     target: LoopTarget;
+    machine?: LoopMachineRef;
     catchUp?: CatchUpPolicy;
     catchUpLimit?: number;
     overlap?: OverlapPolicy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/loops",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   "type": "module",
   "main": "dist/index.js",
@@ -64,6 +64,7 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
+    "@hasna/machines": "0.0.49",
     "commander": "^13.1.0"
   },
   "devDependencies": {