Executions

dedalus machines executions create \
  --machine-id "$MACHINE_ID" \
  --command '["echo 'hello world'"]'

import time
from dedalus_sdk import Dedalus

TERMINAL = {"succeeded", "failed", "cancelled", "expired"}

def run(client: Dedalus, machine_id: str, command: list[str], **kwargs) -> str:
    """Block until the execution finishes; return stdout. Raises on failure."""
    exc = client.machines.executions.create(machine_id=machine_id, command=command, **kwargs)
    delay = 0.1
    while exc.status not in TERMINAL:
        wait = (exc.retry_after_ms or 0) / 1000 if exc.status == "wake_in_progress" else delay
        time.sleep(wait)
        delay = min(delay * 2, 2.0)
        exc = client.machines.executions.retrieve(machine_id=machine_id, execution_id=exc.execution_id)
    if exc.status != "succeeded":
        raise RuntimeError(f"{exc.status}: {exc.error_code}: {exc.error_message}")
    out = client.machines.executions.output(machine_id=machine_id, execution_id=exc.execution_id)
    return out.stdout or ""

print(run(client, machine_id, ["/bin/bash", "-c", "uname -a"]))

import Dedalus from "dedalus";

const TERMINAL = new Set(["succeeded", "failed", "cancelled", "expired"]);
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

async function run(
  client: Dedalus, machineId: string, command: string[],
  opts: { stdin?: string; env?: Record<string, string>; cwd?: string; timeout_ms?: number } = {},
): Promise<string> {
  let exc = await client.machines.executions.create({
    machine_id: machineId,
    command,
    ...opts,
  });
  let delay = 100;
  while (!TERMINAL.has(exc.status)) {
    const wait = exc.status === "wake_in_progress" ? (exc.retry_after_ms ?? 0) : delay;
    await sleep(wait);
    delay = Math.min(delay * 2, 2000);
    exc = await client.machines.executions.retrieve({
      machine_id: machineId,
      execution_id: exc.execution_id,
    });
  }
  if (exc.status !== "succeeded") {
    throw new Error(`${exc.status}: ${exc.error_code}: ${exc.error_message}`);
  }
  const out = await client.machines.executions.output({
    machine_id: machineId,
    execution_id: exc.execution_id,
  });
  return out.stdout ?? "";
}

console.log(await run(client, machineId, ["/bin/bash", "-c", "uname -a"]));

func run(ctx context.Context, client dedalus.Client, machineID string, command []string) (string, error) {
    done := map[dedalus.ExecutionStatus]bool{
        dedalus.ExecutionStatusSucceeded: true,
        dedalus.ExecutionStatusFailed: true,
        dedalus.ExecutionStatusCancelled: true,
        dedalus.ExecutionStatusExpired: true,
    }

    exc, err := client.Machines.Executions.New(ctx, dedalus.MachineExecutionNewParams{
        MachineID: machineID,
        ExecutionCreateParams: dedalus.ExecutionCreateParams{
            Command: command,
        },
    })
    if err != nil {
        return "", err
    }

    for !done[exc.Status] {
        time.Sleep(500 * time.Millisecond)
        exc, err = client.Machines.Executions.Get(ctx, dedalus.MachineExecutionGetParams{
            MachineID: machineID, ExecutionID: exc.ExecutionID,
        })
        if err != nil {
            return "", err
        }
    }
    if exc.Status != dedalus.ExecutionStatusSucceeded {
        return "", fmt.Errorf("%s: %s", exc.ErrorCode, exc.ErrorMessage)
    }

    out, err := client.Machines.Executions.Output(ctx, dedalus.MachineExecutionOutputParams{
        MachineID: machineID, ExecutionID: exc.ExecutionID,
    })
    if err != nil {
        return "", err
    }
    return out.Stdout, nil
}

stdout, _ := run(ctx, client, machineID, []string{"/bin/bash", "-c", "uname -a"})
fmt.Println(stdout)

dedalus machines executions create --machine-id "$MACHINE_ID" --command '["whoami"]'

exc = client.machines.executions.create(
    machine_id=machine_id,
    command=["/bin/bash", "-c", "whoami"],
)

const exc = await client.machines.executions.create({
  machine_id: machineId,
  command: ["/bin/bash", "-c", "whoami"],
});

exc, _ := client.Machines.Executions.New(ctx, dedalus.MachineExecutionNewParams{
    MachineID: machineID,
    ExecutionCreateParams: dedalus.ExecutionCreateParams{
        Command: []string{"/bin/bash", "-c", "whoami"},
    },
})
fmt.Println(exc.ExecutionID)

dedalus machines executions retrieve --machine-id "$MACHINE_ID" --execution-id "$EXEC_ID"

exc = client.machines.executions.retrieve(machine_id=machine_id, execution_id="<execution_id>")

const exc = await client.machines.executions.retrieve({
  machine_id: machineId,
  execution_id: "<execution_id>",
});

exc, _ := client.Machines.Executions.Get(ctx, dedalus.MachineExecutionGetParams{
    MachineID:    machineID,
    ExecutionID: "<execution_id>",
})
fmt.Println(exc.Status)

dedalus machines executions list --machine-id "$MACHINE_ID"

page = client.machines.executions.list(machine_id=machine_id)
for exc in page.items or []:
    print(exc.execution_id, exc.status)

const page = await client.machines.executions.list({ machine_id: machineId });
for (const exc of page.items ?? []) console.log(exc.execution_id, exc.status);

page, _ := client.Machines.Executions.List(ctx, dedalus.MachineExecutionListParams{
    MachineID: machineID,
})
for _, exc := range page.Items {
    fmt.Println(exc.ExecutionID, exc.Status)
}

dedalus machines executions delete --machine-id "$MACHINE_ID" --execution-id "$EXEC_ID"

client.machines.executions.delete(machine_id=machine_id, execution_id="<execution_id>")

await client.machines.executions.delete({
  machine_id: machineId,
  execution_id: "<execution_id>",
});

client.Machines.Executions.Delete(ctx, dedalus.MachineExecutionDeleteParams{
    MachineID:    machineID,
    ExecutionID: "<execution_id>",
})

dedalus machines executions events --machine-id "$MACHINE_ID" --execution-id "$EXEC_ID"

page = client.machines.executions.events(machine_id=machine_id, execution_id="<execution_id>")
for e in page.items or []:
    print(e.sequence, e.type, e.chunk)

const events = client.machines.executions.events({
  machine_id: machineId,
  execution_id: "<execution_id>",
});
for await (const e of events) console.log(e.sequence, e.type, e.chunk);

page, _ := client.Machines.Executions.Events(ctx, dedalus.MachineExecutionEventsParams{
    MachineID:   machineID,
    ExecutionID: "<execution_id>",
})
for _, e := range page.Items {
    fmt.Println(e.Sequence, e.Type, e.Chunk)
}

dedalus machines executions output --machine-id "$MACHINE_ID" --execution-id "$EXEC_ID"

out = client.machines.executions.output(machine_id=machine_id, execution_id="<execution_id>")
print(out.stdout)

const out = await client.machines.executions.output({
  machine_id: machineId,
  execution_id: "<execution_id>",
});
console.log(out.stdout);

out, _ := client.Machines.Executions.Output(ctx, dedalus.MachineExecutionOutputParams{
    MachineID:    machineID,
    ExecutionID: "<execution_id>",
})
fmt.Println(out.Stdout)