@git.zone/cli 2.22.0 → 2.24.0

package/dist_ts/mod_services/classes.servicepruner.d.ts

@@ -0,0 +1,102 @@
+import { type TServiceName } from './classes.servicedatamarker.js';
+/** Default inactivity threshold before a project is even considered stale. */
+export declare const defaultStaleDays = 30;
+/**
+ * How a project was classified.
+ *
+ * - `live`     — recent activity; never a reclamation candidate.
+ * - `stale`    — project still on disk but inactive past the threshold.
+ * - `orphaned` — project directory no longer exists.
+ * - `unknown`  — insufficient evidence to classify; never reclaimed.
+ */
+export type TServiceProjectState = 'live' | 'stale' | 'orphaned' | 'unknown';
+/** Why a candidate was left alone. */
+export interface IServiceSkipReason {
+    target: string;
+    reason: string;
+}
+export interface IServiceDataDirReport {
+    service: TServiceName;
+    path: string;
+    exists: boolean;
+    sizeBytes: number;
+    reclaimable: boolean;
+    reason: string;
+}
+export interface IServiceContainerReport {
+    id: string;
+    name: string;
+    state: string;
+    running: boolean;
+    reclaimable: boolean;
+    reason: string;
+}
+export interface IServiceProjectReport {
+    projectPath: string;
+    projectName: string;
+    state: TServiceProjectState;
+    stateReason: string;
+    lastActive: number | null;
+    inactiveDays: number | null;
+    projectDirExists: boolean;
+    registered: boolean;
+    markerPresent: boolean;
+    containers: IServiceContainerReport[];
+    dataDirectories: IServiceDataDirReport[];
+    totalDataBytes: number;
+    reclaimableDataBytes: number;
+}
+export interface IServicePrunePlan {
+    staleDays: number;
+    dockerAvailable: boolean;
+    projects: IServiceProjectReport[];
+    registryEntriesToRemove: string[];
+    containersToRemove: Array<{
+        id: string;
+        name: string;
+        projectPath: string;
+    }>;
+    dataDirsToRemove: Array<{
+        projectPath: string;
+        service: TServiceName;
+        path: string;
+        sizeBytes: number;
+    }>;
+    skipped: IServiceSkipReason[];
+    totals: {
+        projects: number;
+        totalDataBytes: number;
+        reclaimableDataBytes: number;
+        /** Bytes that would be reclaimable if the holding containers were stopped first. */
+        blockedByRunningBytes: number;
+    };
+}
+export interface IServicePrunerOptions {
+    staleDays?: number;
+}
+/**
+ * Plans and applies reclamation of resources created by `gitzone services`.
+ *
+ * Design mirrors `@git.zone/tsdocker`'s `TsDockerPruner`: build an explicit
+ * plan, print it, and only mutate on an explicit apply that re-verifies every
+ * single item. Nothing is ever matched by image or by bare name pattern, and
+ * every ambiguity resolves to "skip".
+ */
+export declare class ServicePruner {
+    private docker;
+    private globalRegistry;
+    private staleDays;
+    constructor(optionsArg?: IServicePrunerOptions);
+    /**
+     * Build a reclamation plan. Read-only: touches nothing.
+     */
+    createPlan(): Promise<IServicePrunePlan>;
+    /**
+     * Apply a plan, re-verifying every item immediately before it is removed.
+     *
+     * Any drift between plan and current reality aborts with an error rather than
+     * removing something that may since have become live.
+     */
+    applyPlan(planArg: IServicePrunePlan): Promise<void>;
+    private isClaimedByExactlyOneProject;
+}

package/dist_ts/mod_services/classes.servicepruner.js

@@ -0,0 +1,410 @@
+import * as plugins from './mod.plugins.js';
+import * as helpers from './helpers.js';
+import { DockerContainer } from './classes.dockercontainer.js';
+import { GlobalRegistry } from './classes.globalregistry.js';
+import { getServiceDataDirectory, isSafeServiceDataPath, isServiceOwnedByLabels, readServiceDataMarker, serviceImages, serviceNames, serviceToolLabel, } from './classes.servicedatamarker.js';
+import { logger } from '../gitzone.logging.js';
+/** Default inactivity threshold before a project is even considered stale. */
+export const defaultStaleDays = 30;
+const dayInMs = 24 * 60 * 60 * 1000;
+/**
+ * Plans and applies reclamation of resources created by `gitzone services`.
+ *
+ * Design mirrors `@git.zone/tsdocker`'s `TsDockerPruner`: build an explicit
+ * plan, print it, and only mutate on an explicit apply that re-verifies every
+ * single item. Nothing is ever matched by image or by bare name pattern, and
+ * every ambiguity resolves to "skip".
+ */
+export class ServicePruner {
+    docker;
+    globalRegistry;
+    staleDays;
+    constructor(optionsArg = {}) {
+        this.docker = new DockerContainer();
+        this.globalRegistry = GlobalRegistry.getInstance();
+        this.staleDays = optionsArg.staleDays ?? defaultStaleDays;
+    }
+    /**
+     * Build a reclamation plan. Read-only: touches nothing.
+     */
+    async createPlan() {
+        const skipped = [];
+        const registryProjects = await this.globalRegistry.getAllProjects();
+        // Collect tool-owned containers. A Docker failure must not be mistaken for
+        // "no containers exist", so we record availability and fail closed below.
+        let dockerAvailable = true;
+        let labeledContainers = [];
+        let runningMountSources = [];
+        try {
+            const ids = await this.docker.listIds([`label=git.zone.tool=${serviceToolLabel}`]);
+            labeledContainers = await this.docker.inspectMany(ids);
+            runningMountSources = await this.docker.listRunningMountSources();
+        }
+        catch (error) {
+            dockerAvailable = false;
+            const message = error instanceof Error ? error.message : String(error);
+            skipped.push({
+                target: 'docker',
+                reason: `docker unavailable (${message}); container and data reclamation disabled`,
+            });
+        }
+        // Containers recorded in the registry but not labeled (created by older
+        // versions). Their names are only trusted when exactly one registry entry
+        // claims them.
+        const nameClaims = new Map();
+        for (const [projectPath, project] of Object.entries(registryProjects)) {
+            for (const containerName of Object.values(project.containers)) {
+                if (!containerName) {
+                    continue;
+                }
+                const claims = nameClaims.get(containerName) || [];
+                claims.push(projectPath);
+                nameClaims.set(containerName, claims);
+            }
+        }
+        let legacyContainers = [];
+        if (dockerAvailable && nameClaims.size > 0) {
+            try {
+                // One `docker ps -a` for all claimed names rather than one per name:
+                // each shell-out is a spawned child process, and this runs on every
+                // prune. Identity is established by the exact-name match below, so the
+                // listing only needs to be a superset.
+                const labeledIds = new Set(labeledContainers.map((container) => container.id));
+                const allIds = await this.docker.listIds([]);
+                const candidateIds = allIds.filter((id) => !labeledIds.has(id));
+                const inspected = await this.docker.inspectMany(candidateIds);
+                legacyContainers = inspected.filter((container) => nameClaims.has(container.name));
+            }
+            catch (error) {
+                dockerAvailable = false;
+                const message = error instanceof Error ? error.message : String(error);
+                skipped.push({
+                    target: 'docker',
+                    reason: `docker unavailable (${message}); container and data reclamation disabled`,
+                });
+            }
+        }
+        // Group every known container and registry entry under a project path.
+        const candidates = new Map();
+        const ensureCandidate = (projectPathArg, projectNameArg) => {
+            const projectPath = plugins.path.resolve(projectPathArg);
+            const existing = candidates.get(projectPath);
+            if (existing) {
+                return existing;
+            }
+            const candidate = {
+                projectPath,
+                projectName: projectNameArg,
+                containers: [],
+            };
+            candidates.set(projectPath, candidate);
+            return candidate;
+        };
+        for (const [projectPath, project] of Object.entries(registryProjects)) {
+            const candidate = ensureCandidate(projectPath, project.projectName);
+            candidate.registryEntry = project;
+        }
+        for (const container of labeledContainers) {
+            const projectPath = container.labels['git.zone.project-path'];
+            if (!projectPath) {
+                skipped.push({
+                    target: container.name,
+                    reason: 'labeled as tool-owned but carries no git.zone.project-path',
+                });
+                continue;
+            }
+            const candidate = ensureCandidate(projectPath, plugins.path.basename(projectPath));
+            candidate.containers.push(container);
+        }
+        // Projects whose container ownership cannot be resolved. Ambiguity must
+        // *tighten* the decision, never loosen it: if we cannot attribute a
+        // container, we also cannot claim that a project has no container running,
+        // so such projects are forced to `unknown` and nothing is reclaimed.
+        const ambiguousProjectPaths = new Set();
+        for (const container of legacyContainers) {
+            const claims = nameClaims.get(container.name) || [];
+            if (claims.length !== 1) {
+                skipped.push({
+                    target: container.name,
+                    reason: `unlabeled container claimed by ${claims.length} registered projects; ownership ambiguous`,
+                });
+                for (const claim of claims) {
+                    ambiguousProjectPaths.add(plugins.path.resolve(claim));
+                    ensureCandidate(claim, plugins.path.basename(claim));
+                }
+                continue;
+            }
+            const projectPath = claims[0];
+            const candidate = ensureCandidate(projectPath, plugins.path.basename(projectPath));
+            candidate.containers.push(container);
+        }
+        // Classify and decide.
+        const projects = [];
+        const registryEntriesToRemove = [];
+        const containersToRemove = [];
+        const dataDirsToRemove = [];
+        let blockedByRunningBytes = 0;
+        for (const candidate of [...candidates.values()].sort((first, second) => first.projectPath.localeCompare(second.projectPath))) {
+            const projectDirExists = await plugins.smartfs.directory(candidate.projectPath).exists();
+            const marker = await readServiceDataMarker(candidate.projectPath);
+            const lastActive = candidate.registryEntry?.lastActive ?? null;
+            const inactiveDays = lastActive === null ? null : Math.floor((Date.now() - lastActive) / dayInMs);
+            let state;
+            let stateReason;
+            if (ambiguousProjectPaths.has(candidate.projectPath)) {
+                state = 'unknown';
+                stateReason =
+                    'a container name for this project is claimed by more than one project; ownership ambiguous';
+            }
+            else if (!projectDirExists) {
+                state = 'orphaned';
+                stateReason = 'project directory no longer exists';
+            }
+            else if (lastActive === null) {
+                state = 'unknown';
+                stateReason = 'no lastActive timestamp recorded; cannot prove inactivity';
+            }
+            else if (inactiveDays > this.staleDays) {
+                state = 'stale';
+                stateReason = `inactive for ${inactiveDays} days (threshold ${this.staleDays})`;
+            }
+            else {
+                state = 'live';
+                stateReason = `active ${inactiveDays} day(s) ago`;
+            }
+            const anyContainerRunning = candidate.containers.some((container) => container.running);
+            // Containers
+            const containerReports = [];
+            for (const container of candidate.containers) {
+                let reclaimable = false;
+                let reason;
+                if (!dockerAvailable) {
+                    reason = 'docker unavailable';
+                }
+                else if (state === 'live') {
+                    reason = 'project is live';
+                }
+                else if (state === 'unknown') {
+                    reason = 'project state unknown';
+                }
+                else if (container.running) {
+                    reason = 'container is running; stop it first';
+                }
+                else {
+                    reclaimable = true;
+                    reason = `project ${state}, container stopped`;
+                }
+                containerReports.push({
+                    id: container.id,
+                    name: container.name,
+                    state: container.state,
+                    running: container.running,
+                    reclaimable,
+                    reason,
+                });
+                if (reclaimable) {
+                    containersToRemove.push({
+                        id: container.id,
+                        name: container.name,
+                        projectPath: candidate.projectPath,
+                    });
+                }
+            }
+            // Data directories
+            const ownershipProven = !!marker || !!candidate.registryEntry;
+            const dataReports = [];
+            let totalDataBytes = 0;
+            let reclaimableDataBytes = 0;
+            for (const service of serviceNames) {
+                const dataPath = getServiceDataDirectory(candidate.projectPath, service);
+                const exists = await plugins.smartfs.directory(dataPath).exists();
+                const sizeBytes = exists ? await helpers.getDirectorySize(dataPath) : 0;
+                totalDataBytes += sizeBytes;
+                let reclaimable = false;
+                let reason;
+                const mountConflict = runningMountSources.find((source) => helpers.pathsOverlap(dataPath, source));
+                if (!exists) {
+                    reason = 'no data directory';
+                }
+                else if (!dockerAvailable) {
+                    reason = 'docker unavailable; cannot prove no container uses this data';
+                }
+                else if (!isSafeServiceDataPath(candidate.projectPath, dataPath)) {
+                    reason = 'path outside the allowed service data shape';
+                }
+                else if (!ownershipProven) {
+                    reason = 'no marker and no registry entry; ownership unproven';
+                }
+                else if (state === 'live') {
+                    reason = 'project is live';
+                }
+                else if (state === 'unknown') {
+                    reason = 'project state unknown';
+                }
+                else if (state === 'orphaned') {
+                    // Data lives inside the project directory, which is gone.
+                    reason = 'project directory absent';
+                }
+                else if (mountConflict) {
+                    reason = `mounted by a running container (${mountConflict})`;
+                    blockedByRunningBytes += sizeBytes;
+                }
+                else if (anyContainerRunning) {
+                    reason = 'a container for this project is still running';
+                    blockedByRunningBytes += sizeBytes;
+                }
+                else {
+                    reclaimable = true;
+                    reason = `project stale, no container running, ownership proven by ${marker ? 'marker' : 'registry'}`;
+                }
+                dataReports.push({ service, path: dataPath, exists, sizeBytes, reclaimable, reason });
+                if (reclaimable) {
+                    reclaimableDataBytes += sizeBytes;
+                    dataDirsToRemove.push({
+                        projectPath: candidate.projectPath,
+                        service,
+                        path: dataPath,
+                        sizeBytes,
+                    });
+                }
+            }
+            // Registry entry: safe to drop only once no container remains. For
+            // containers created before labels existed, the registry claim is the only
+            // thing that can ever identify them again — dropping it while one still
+            // exists would make it invisible to prune, `stop -g` and `cleanup -g`,
+            // leaving it running forever under `restart: unless-stopped`.
+            if (state === 'orphaned' && candidate.registryEntry) {
+                if (candidate.containers.length === 0) {
+                    registryEntriesToRemove.push(candidate.projectPath);
+                }
+                else {
+                    skipped.push({
+                        target: candidate.projectPath,
+                        reason: `project directory is gone but ${candidate.containers.length} container(s) remain; keeping the registry entry so they stay identifiable`,
+                    });
+                }
+            }
+            projects.push({
+                projectPath: candidate.projectPath,
+                projectName: candidate.registryEntry?.projectName || candidate.projectName,
+                state,
+                stateReason,
+                lastActive,
+                inactiveDays,
+                projectDirExists,
+                registered: !!candidate.registryEntry,
+                markerPresent: !!marker,
+                containers: containerReports,
+                dataDirectories: dataReports,
+                totalDataBytes,
+                reclaimableDataBytes,
+            });
+        }
+        return {
+            staleDays: this.staleDays,
+            dockerAvailable,
+            projects,
+            registryEntriesToRemove,
+            containersToRemove,
+            dataDirsToRemove,
+            skipped,
+            totals: {
+                projects: projects.length,
+                totalDataBytes: projects.reduce((sum, project) => sum + project.totalDataBytes, 0),
+                reclaimableDataBytes: projects.reduce((sum, project) => sum + project.reclaimableDataBytes, 0),
+                blockedByRunningBytes,
+            },
+        };
+    }
+    /**
+     * Apply a plan, re-verifying every item immediately before it is removed.
+     *
+     * Any drift between plan and current reality aborts with an error rather than
+     * removing something that may since have become live.
+     */
+    async applyPlan(planArg) {
+        if (!planArg.dockerAvailable && (planArg.containersToRemove.length > 0 || planArg.dataDirsToRemove.length > 0)) {
+            throw new Error('Refusing to apply container or data removal without a reachable Docker daemon');
+        }
+        // Containers first, so their mounts stop protecting the data we then remove.
+        if (planArg.containersToRemove.length > 0) {
+            const current = await this.docker.inspectMany(planArg.containersToRemove.map((container) => container.id));
+            for (const planned of planArg.containersToRemove) {
+                const container = current.find((candidate) => candidate.id === planned.id);
+                if (!container) {
+                    throw new Error(`Refusing to remove vanished container: ${planned.name}`);
+                }
+                if (container.running) {
+                    throw new Error(`Refusing to remove running container: ${container.name}`);
+                }
+                const labelOwned = isServiceOwnedByLabels(container.labels);
+                const registryOwned = await this.isClaimedByExactlyOneProject(container.name, planned.projectPath);
+                if (!labelOwned && !registryOwned) {
+                    throw new Error(`Refusing to remove container with unproven ownership: ${container.name}`);
+                }
+                if (!(await this.docker.remove(container.name, false))) {
+                    throw new Error(`Failed to remove container: ${container.name}`);
+                }
+                logger.log('ok', `Removed container ${container.name}`);
+            }
+        }
+        // Data directories. Cheap, local invariants are re-checked first so an
+        // invalid plan is rejected before any Docker call and before anything is
+        // deleted; only then is the live mount table consulted.
+        if (planArg.dataDirsToRemove.length > 0) {
+            const currentProjects = await this.globalRegistry.getAllProjects();
+            for (const planned of planArg.dataDirsToRemove) {
+                if (!isSafeServiceDataPath(planned.projectPath, planned.path)) {
+                    throw new Error(`Refusing unsafe service data path: ${planned.path}`);
+                }
+                const marker = await readServiceDataMarker(planned.projectPath);
+                const registered = await this.globalRegistry.isRegistered(planned.projectPath);
+                if (!marker && !registered) {
+                    throw new Error(`Refusing data path with unproven ownership: ${planned.path}`);
+                }
+                // Re-verify staleness: the project may have been started between
+                // planning and applying, which would make this live data.
+                const currentEntry = Object.entries(currentProjects).find(([projectPath]) => plugins.path.resolve(projectPath) === planned.projectPath)?.[1];
+                if (currentEntry) {
+                    const inactiveDays = Math.floor((Date.now() - currentEntry.lastActive) / dayInMs);
+                    if (inactiveDays <= this.staleDays) {
+                        throw new Error(`Refusing data path for a project that became active: ${planned.path} (${inactiveDays}d)`);
+                    }
+                }
+            }
+            const runningMountSources = await this.docker.listRunningMountSources();
+            for (const planned of planArg.dataDirsToRemove) {
+                const conflict = runningMountSources.find((source) => helpers.pathsOverlap(planned.path, source));
+                if (conflict) {
+                    throw new Error(`Refusing mounted data path: ${planned.path} is used by ${conflict}`);
+                }
+                if (!(await plugins.smartfs.directory(planned.path).exists())) {
+                    continue;
+                }
+                // Escalates to a privileged one-off container when the contents belong to
+                // the container user; throws rather than deleting only part of the tree.
+                await this.docker.removeDataDirectory(planned.path, serviceImages[planned.service]);
+                logger.log('ok', `Removed data directory ${planned.path}`);
+            }
+        }
+        // Registry metadata last, so a failure above leaves the claim intact.
+        for (const projectPath of planArg.registryEntriesToRemove) {
+            if (await plugins.smartfs.directory(projectPath).exists()) {
+                throw new Error(`Refusing to unregister an existing project: ${projectPath}`);
+            }
+            await this.globalRegistry.unregisterProject(projectPath);
+            logger.log('ok', `Unregistered ${projectPath}`);
+        }
+    }
+    async isClaimedByExactlyOneProject(containerNameArg, projectPathArg) {
+        const projects = await this.globalRegistry.getAllProjects();
+        const claims = [];
+        for (const [projectPath, project] of Object.entries(projects)) {
+            if (Object.values(project.containers).includes(containerNameArg)) {
+                claims.push(plugins.path.resolve(projectPath));
+            }
+        }
+        return claims.length === 1 && claims[0] === plugins.path.resolve(projectPathArg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.servicepruner.js","sourceRoot":"","sources":["../../ts/mod_services/classes.servicepruner.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_services/helpers.d.ts

@@ -18,6 +18,21 @@ export declare const printHeader: (title: string) => void;
  * Format bytes to human readable string
  */
 export declare const formatBytes: (bytes: number) => string;
+/**
+ * True when either path contains the other, or they are the same path.
+ *
+ * Used to decide whether a deletion candidate collides with a directory a
+ * running container has mounted. Containment in *either* direction counts: a
+ * parent mount protects its children, and a child mount protects its parent.
+ */
+export declare const pathsOverlap: (firstPathArg: string, secondPathArg: string) => boolean;
+/**
+ * Total size in bytes of a directory tree.
+ *
+ * Symlinks are counted by their own size and never followed, so a symlink
+ * inside a data directory can neither inflate the report nor walk out of it.
+ */
+export declare const getDirectorySize: (directoryPathArg: string, maxDepthArg?: number) => Promise<number>;
 /**
  * Get the local network IP address
  */

package/dist_ts/mod_services/helpers.js

@@ -77,6 +77,62 @@ export const formatBytes = (bytes) => {
     }
     return `${size.toFixed(2)} ${units[unitIndex]}`;
 };
+/**
+ * True when either path contains the other, or they are the same path.
+ *
+ * Used to decide whether a deletion candidate collides with a directory a
+ * running container has mounted. Containment in *either* direction counts: a
+ * parent mount protects its children, and a child mount protects its parent.
+ */
+export const pathsOverlap = (firstPathArg, secondPathArg) => {
+    const firstPath = plugins.path.resolve(firstPathArg);
+    const secondPath = plugins.path.resolve(secondPathArg);
+    const contains = (containerPath, candidatePath) => {
+        const relative = plugins.path.relative(containerPath, candidatePath);
+        if (relative === '') {
+            return true;
+        }
+        return !!relative && !relative.startsWith('..') && !plugins.path.isAbsolute(relative);
+    };
+    return contains(firstPath, secondPath) || contains(secondPath, firstPath);
+};
+/**
+ * Total size in bytes of a directory tree.
+ *
+ * Symlinks are counted by their own size and never followed, so a symlink
+ * inside a data directory can neither inflate the report nor walk out of it.
+ */
+export const getDirectorySize = async (directoryPathArg, maxDepthArg = 64) => {
+    let total = 0;
+    const walk = async (currentPath, depth) => {
+        // Bind mounts inside a data directory are user-controlled and can form a
+        // cycle; a depth cap keeps this from recursing until it exhausts memory.
+        if (depth > maxDepthArg) {
+            return;
+        }
+        const entries = await plugins.fs
+            .readdir(currentPath, { withFileTypes: true })
+            .catch(() => []);
+        for (const entry of entries) {
+            const entryPath = plugins.path.join(currentPath, entry.name);
+            // isDirectory() here is lstat-based, so symlinks are counted by their own
+            // size and never followed.
+            if (entry.isDirectory()) {
+                await walk(entryPath, depth + 1);
+                continue;
+            }
+            try {
+                const stats = await plugins.fs.lstat(entryPath);
+                total += stats.size;
+            }
+            catch {
+                // entry disappeared between readdir and lstat; ignore
+            }
+        }
+    };
+    await walk(plugins.path.resolve(directoryPathArg), 0);
+    return total;
+};
 /**
  * Get the local network IP address
  */
@@ -109,4 +165,4 @@ export const getLocalNetworkIp = async () => {
     // Last resort: localhost
     return 'localhost';
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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