host daemon (#2)

* feat: host daemon api scaffold

* fix: use sparse writes

* fix: unix socket length (<108 bytes)

internal/store/file_store_test.go

@@ -0,0 +1,130 @@
+package store
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/getcompanion-ai/computer-host/internal/model"
+	contracthost "github.com/getcompanion-ai/computer-host/contract"
+)
+
+func TestFileStorePersistsStateAndOperations(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	statePath := filepath.Join(root, "state", "state.json")
+	opsPath := filepath.Join(root, "state", "ops.json")
+
+	ctx := context.Background()
+	first, err := NewFileStore(statePath, opsPath)
+	if err != nil {
+		t.Fatalf("create file store: %v", err)
+	}
+
+	artifact := model.ArtifactRecord{
+		Ref: contracthost.ArtifactRef{
+			KernelImageURL: "https://example.com/kernel",
+			RootFSURL:      "https://example.com/rootfs",
+		},
+		LocalKey:        "artifact-key",
+		LocalDir:        filepath.Join(root, "artifacts", "artifact-key"),
+		KernelImagePath: filepath.Join(root, "artifacts", "artifact-key", "kernel"),
+		RootFSPath:      filepath.Join(root, "artifacts", "artifact-key", "rootfs"),
+		CreatedAt:       time.Unix(1700000000, 0).UTC(),
+	}
+	if err := first.PutArtifact(ctx, artifact); err != nil {
+		t.Fatalf("put artifact: %v", err)
+	}
+
+	machine := model.MachineRecord{
+		ID:             "vm-1",
+		Artifact:       artifact.Ref,
+		SystemVolumeID: "vm-1-system",
+		RuntimeHost:    "172.16.0.2",
+		TapDevice:      "fctap0",
+		Ports: []contracthost.MachinePort{
+			{Name: contracthost.MachinePortNameSSH, Port: 22, Protocol: contracthost.PortProtocolTCP},
+		},
+		Phase:      contracthost.MachinePhaseRunning,
+		PID:        1234,
+		SocketPath: filepath.Join(root, "runtime", "machine.sock"),
+		CreatedAt:  time.Unix(1700000001, 0).UTC(),
+		StartedAt:  timePtr(time.Unix(1700000002, 0).UTC()),
+	}
+	if err := first.CreateMachine(ctx, machine); err != nil {
+		t.Fatalf("create machine: %v", err)
+	}
+
+	volume := model.VolumeRecord{
+		ID:                "vm-1-system",
+		Kind:              contracthost.VolumeKindSystem,
+		AttachedMachineID: machineIDPtr("vm-1"),
+		Path:              filepath.Join(root, "machine-disks", "vm-1", "system.img"),
+		CreatedAt:         time.Unix(1700000003, 0).UTC(),
+	}
+	if err := first.CreateVolume(ctx, volume); err != nil {
+		t.Fatalf("create volume: %v", err)
+	}
+
+	operation := model.OperationRecord{
+		MachineID: "vm-1",
+		Type:      model.MachineOperationCreate,
+		StartedAt: time.Unix(1700000004, 0).UTC(),
+	}
+	if err := first.UpsertOperation(ctx, operation); err != nil {
+		t.Fatalf("upsert operation: %v", err)
+	}
+
+	second, err := NewFileStore(statePath, opsPath)
+	if err != nil {
+		t.Fatalf("reopen file store: %v", err)
+	}
+
+	gotArtifact, err := second.GetArtifact(ctx, artifact.Ref)
+	if err != nil {
+		t.Fatalf("get artifact after reopen: %v", err)
+	}
+	if gotArtifact.LocalKey != artifact.LocalKey {
+		t.Fatalf("artifact local key mismatch: got %q want %q", gotArtifact.LocalKey, artifact.LocalKey)
+	}
+
+	gotMachine, err := second.GetMachine(ctx, machine.ID)
+	if err != nil {
+		t.Fatalf("get machine after reopen: %v", err)
+	}
+	if gotMachine.Phase != contracthost.MachinePhaseRunning {
+		t.Fatalf("machine phase mismatch: got %q", gotMachine.Phase)
+	}
+	if gotMachine.RuntimeHost != machine.RuntimeHost {
+		t.Fatalf("runtime host mismatch: got %q want %q", gotMachine.RuntimeHost, machine.RuntimeHost)
+	}
+
+	gotVolume, err := second.GetVolume(ctx, volume.ID)
+	if err != nil {
+		t.Fatalf("get volume after reopen: %v", err)
+	}
+	if gotVolume.AttachedMachineID == nil || *gotVolume.AttachedMachineID != "vm-1" {
+		t.Fatalf("attached machine mismatch: got %#v", gotVolume.AttachedMachineID)
+	}
+
+	operations, err := second.ListOperations(ctx)
+	if err != nil {
+		t.Fatalf("list operations after reopen: %v", err)
+	}
+	if len(operations) != 1 {
+		t.Fatalf("operation count mismatch: got %d want 1", len(operations))
+	}
+	if operations[0].Type != model.MachineOperationCreate {
+		t.Fatalf("operation type mismatch: got %q", operations[0].Type)
+	}
+}
+
+func timePtr(value time.Time) *time.Time {
+	return &value
+}
+
+func machineIDPtr(value contracthost.MachineID) *contracthost.MachineID {
+	return &value
+}