Migrate a project onto a new base image without losing its volumes

Projects were pinned to the image they were first created from. Both
create paths preferred triple-c-snapshot-<id>:latest whenever it
existed, and container_needs_recreation compared the container's live
image against the triple-c.image label — which create_container wrote
from the same image it created from. A tautology that could never fire.
The only escape was Reset, which calls remove_project_volumes and
destroys the login, skills and transcripts.

Measured consequences on this host: real projects are missing socat (so
the auth bridge cannot tunnel) and bubblewrap (so sandbox mode does not
work), plus Mission Control and triple-c-sso-refresh, and sit 61
packages behind the base including ca-certificates, openssl and curl.

Detection. create_container now writes triple-c.base-image-id (the image
ID, not RepoDigests, which local-built and custom images do not have)
and triple-c.create-image. container_needs_recreation takes the expected
create-image and compares against the latter, so the check means
something. base-image-id is deliberately NOT compared: a base bump would
otherwise silently recreate from the snapshot, consuming the "you should
migrate" signal without migrating. Staleness is surfaced, never acted on
automatically.

Migration keeps the volumes. /home/claude and ~/.claude are volumes and
the image's copy is seed-only — permanently masked after first mount —
so the login, ~/.claude.json, skills, transcripts, scheduler tasks, SSH
keys, cargo, uv, ruff and Claude Code itself re-attach untouched. Only
root-level state is rebuilt: apt packages are replayed against the new
base rather than copied, so no stale libc is dragged forward, and
/usr/local, /opt and the non-bind-mounted parts of /workspace are copied
verbatim with tar --skip-old-files so they can never clobber a newer
base binary.

docker diff is not used: on a snapshot-derived container it reports only
changes since the last commit. Raw image-vs-image diffing is filtered
through dpkg ownership because it otherwise lies — 8,677 raw path
differences on a real project reduced to 2 genuinely user-authored
files, both loose /workspace-root files.

Crash safety. snapshot:latest keeps pointing at the old image until the
final commit, so any crash before it self-heals on next start. Later
crashes are caught by reconcile_project_statuses. The rollback pin is a
docker tag: 0.057s and 0 bytes. Rollback restores the system layer only
— volumes are never touched — and the UI says so rather than implying a
time machine.

Fixes an infinite recreation loop shipped with the MCP removal. docker
commit propagates labels to the image, so a container created from a
snapshot inherited its non-empty triple-c.mcp-fingerprint and the
one-shot shim recreated it again on every start, forever. Lineage labels
are now always written explicitly.

Documents the second, separate bug this uncovered: Dockerfile changes
under /home/claude never reach an existing project, migration or not,
because the volume masks them. Anything that must stay upgradable
belongs in /usr/local/bin or /opt, or must be seeded by entrypoint.sh.

145 Rust tests, 227 frontend tests, both builds clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
2026-08-09 18:19:12 -07:00
co-authored by Claude Opus 5
parent cc5f691677
commit d42b741337
26 changed files with 5704 additions and 58 deletions
@@ -0,0 +1,241 @@
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { render, screen, fireEvent, act } from "@testing-library/react";
import MigrateContainerModal from "./MigrateContainerModal";
import type { ContainerMigration } from "../../hooks/useContainerMigration";
import type { ContainerStaleness } from "../../lib/types";
/** Modal focuses via rAF so the panel is laid out first; jsdom needs a flush. */
async function flushFocus() {
await act(async () => {
vi.advanceTimersByTime(20);
});
}
const STALE: ContainerStaleness = {
stale: true,
known: true,
base_image_id: "sha256:aaa",
current_base_image_id: "sha256:bbb",
snapshot_created_at: "2026-03-01T09:00:00Z",
missing_paths: ["/usr/bin/socat"],
missing_features: ["Auth bridge tunnel (socat)", "Mission Control"],
apt_delta: ["socat", "bubblewrap"],
npm_global_delta: [],
verbatim_paths: [],
outdated_package_count: 61,
probe_error: null,
};
function migration(overrides: Partial<ContainerMigration> = {}): ContainerMigration {
return {
staleness: STALE,
probing: false,
running: false,
recovered: false,
interrupted: null,
report: null,
log: [],
phaseMessage: null,
busy: false,
start: vi.fn(async () => {}),
resume: vi.fn(async () => {}),
keep: vi.fn(async () => {}),
rollback: vi.fn(async () => {}),
dismiss: vi.fn(),
refresh: vi.fn(async () => {}),
...overrides,
};
}
async function renderModal(
staleness: ContainerStaleness | null = STALE,
overrides: Partial<ContainerMigration> = {},
) {
const m = migration({ staleness, ...overrides });
const onClose = vi.fn();
render(
<MigrateContainerModal
projectName="api-server"
staleness={staleness}
migration={m}
onClose={onClose}
/>,
);
await flushFocus();
return { m, onClose };
}
describe("MigrateContainerModal", () => {
beforeEach(() => {
vi.useFakeTimers({ toFake: ["requestAnimationFrame", "setTimeout"] });
});
afterEach(() => {
vi.useRealTimers();
});
describe("pre-flight", () => {
it("leads with what is kept, as a statement rather than a choice", async () => {
await renderModal();
const kept = screen.getByText("Kept automatically");
expect(kept).toBeInTheDocument();
expect(screen.getByText(/no signing in again/i)).toBeInTheDocument();
expect(screen.getByText(/every saved session transcript/i)).toBeInTheDocument();
expect(screen.getByText(/are Docker volumes/i)).toBeInTheDocument();
// Reassurance comes first: it is above the replay section in the DOM.
const replay = screen.getByText(/Reinstalled from the new base's repos/);
expect(kept.compareDocumentPosition(replay)).toBe(
Node.DOCUMENT_POSITION_FOLLOWING,
);
// And it is a statement — there is no switch attached to it.
const keptSection = kept.closest("section");
expect(keptSection?.querySelector('[role="switch"]')).toBeNull();
});
it("hides the verbatim-copy section when nothing user-authored was found", async () => {
await renderModal({ ...STALE, verbatim_paths: [] });
expect(screen.queryByText(/Copied across as-is/i)).not.toBeInTheDocument();
});
it("shows the verbatim-copy section with its paths when there are some", async () => {
await renderModal({
...STALE,
verbatim_paths: ["/usr/local/bin/deploy.sh", "/etc/pki/corp.crt"],
});
expect(screen.getByText("Copied across as-is (2)")).toBeInTheDocument();
expect(screen.getByText("/usr/local/bin/deploy.sh")).toBeInTheDocument();
expect(screen.getByText("/etc/pki/corp.crt")).toBeInTheDocument();
});
it("counts the apt packages and states the rollback's disk cost", async () => {
await renderModal();
expect(
screen.getByText("Reinstalled from the new base's repos (2)"),
).toBeInTheDocument();
expect(screen.getByText("socat")).toBeInTheDocument();
expect(screen.getByText("bubblewrap")).toBeInTheDocument();
expect(screen.getByText(/3.812.3 GB/)).toBeInTheDocument();
expect(
screen.getByText(/Rollback restores the system layer only/i),
).toBeInTheDocument();
});
it("lists the gains as the inverse of the missing features", async () => {
await renderModal();
expect(screen.getByText("You will gain")).toBeInTheDocument();
expect(screen.getByText(/Auth bridge tunnel \(socat\)/)).toBeInTheDocument();
expect(screen.getByText(/Mission Control/)).toBeInTheDocument();
expect(
screen.getByText(
/61 packages the current base carries at a different version/i,
),
).toBeInTheDocument();
});
it("passes the three options through when the run is started", async () => {
const { m } = await renderModal({
...STALE,
verbatim_paths: ["/usr/local/bin/deploy.sh"],
});
fireEvent.click(
screen.getByRole("switch", {
name: /Keep a rollback image until I confirm/i,
}),
);
fireEvent.click(
screen.getByRole("button", { name: "Update container base" }),
);
expect(m.start).toHaveBeenCalledWith({
replay_packages: true,
copy_paths: true,
keep_rollback: false,
});
});
it("does not ask to copy paths when there are none to copy", async () => {
const { m } = await renderModal({ ...STALE, verbatim_paths: [] });
fireEvent.click(
screen.getByRole("button", { name: "Update container base" }),
);
expect(m.start).toHaveBeenCalledWith({
replay_packages: true,
copy_paths: false,
keep_rollback: true,
});
});
it("does not start anything on cancel", async () => {
const { m, onClose } = await renderModal();
fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
expect(onClose).toHaveBeenCalledTimes(1);
expect(m.start).not.toHaveBeenCalled();
});
});
describe("mid-run", () => {
const RUNNING: Partial<ContainerMigration> = {
running: true,
log: ["Snapshotting container…", "Creating container on the new base…"],
phaseMessage: "Creating container on the new base…",
};
it("streams the phase message and the output", async () => {
await renderModal(STALE, RUNNING);
expect(screen.getByRole("status").textContent).toBe(
"Creating container on the new base…",
);
const log = screen.getByTestId("migration-log");
expect(log.textContent).toContain("Snapshotting container…");
expect(log.textContent).toContain("Creating container on the new base…");
});
it("can be dismissed without cancelling the run", async () => {
const { m, onClose } = await renderModal(STALE, RUNNING);
// A run takes minutes; blocking the app for it would be wrong, so the
// dialog closes and the work carries on.
expect(
screen.getByText(/keeps running if you close it/i),
).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Hide" }));
expect(onClose).toHaveBeenCalledTimes(1);
// Nothing on the migration was touched — closing is not cancelling.
expect(m.start).not.toHaveBeenCalled();
expect(m.rollback).not.toHaveBeenCalled();
expect(m.dismiss).not.toHaveBeenCalled();
});
it("still closes on Escape and on the header ✕ while running", async () => {
const { m, onClose } = await renderModal(STALE, RUNNING);
fireEvent.click(screen.getByRole("button", { name: "Close dialog" }));
expect(onClose).toHaveBeenCalledTimes(1);
fireEvent.keyDown(document, { key: "Escape" });
expect(onClose).toHaveBeenCalledTimes(2);
expect(m.dismiss).not.toHaveBeenCalled();
});
});
describe("outcome", () => {
it("shows the report in place of the pre-flight once it lands", async () => {
await renderModal(STALE, {
report: {
phase: "partial",
packages_requested: ["socat", "bubblewrap"],
packages_installed: ["socat"],
packages_failed: [
{ name: "bubblewrap", reason: "held back by apt-mark" },
],
paths_copied: [],
features_restored: ["Auth bridge tunnel (socat)"],
rollback_available: true,
message: "",
},
});
expect(screen.getByText(/Updated, but not completely/i)).toBeInTheDocument();
expect(screen.queryByText("Kept automatically")).not.toBeInTheDocument();
expect(screen.getByText(/held back by apt-mark/)).toBeInTheDocument();
});
});
});