@git.zone/cli 3.2.1 → 5.0.0

package/dist_ts/mod_services/classes.globalregistrystore.js

@@ -0,0 +1,156 @@
+import * as plugins from '../plugins.js';
+import { InterProcessLock } from './classes.interprocesslock.js';
+const isPlainObject = (valueArg) => {
+    return typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+};
+const assertAllowedKeys = (valueArg, allowedKeysArg, contextArg) => {
+    if (Object.keys(valueArg).some((keyArg) => !allowedKeysArg.includes(keyArg))) {
+        throw new Error(`Global services registry ${contextArg} contains unsupported fields.`);
+    }
+};
+const assertOptionalStrings = (valueArg, keysArg, contextArg) => {
+    for (const key of keysArg) {
+        if (valueArg[key] !== undefined && (typeof valueArg[key] !== 'string' || !valueArg[key])) {
+            throw new Error(`Global services registry ${contextArg}.${key} must be a non-empty string.`);
+        }
+    }
+};
+const assertOptionalNumbers = (valueArg, keysArg, contextArg) => {
+    for (const key of keysArg) {
+        const value = valueArg[key];
+        if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value))) {
+            throw new Error(`Global services registry ${contextArg}.${key} must be a finite number.`);
+        }
+    }
+};
+/** Validate the canonical runtime schema after startup migrations have completed. */
+export const assertCanonicalGlobalRegistryData = (dataArg) => {
+    if (!isPlainObject(dataArg)) {
+        throw new Error('Global services registry root must be a JSON object.');
+    }
+    assertAllowedKeys(dataArg, ['schemaVersion', 'projects'], 'root');
+    if (dataArg.schemaVersion !== 2 || !isPlainObject(dataArg.projects)) {
+        throw new Error('Global services registry requires canonical schema version 2.');
+    }
+    for (const [projectPath, rawProject] of Object.entries(dataArg.projects)) {
+        if (!isPlainObject(rawProject)) {
+            throw new Error(`Global services registry project ${projectPath} must be a JSON object.`);
+        }
+        assertAllowedKeys(rawProject, [
+            'projectPath',
+            'projectName',
+            'containers',
+            'ports',
+            'legacy',
+            'enabledServices',
+            'lastActive',
+        ], `project ${projectPath}`);
+        if (typeof rawProject.projectPath !== 'string' ||
+            !rawProject.projectPath ||
+            plugins.path.resolve(rawProject.projectPath) !== plugins.path.resolve(projectPath)) {
+            throw new Error(`Global services registry project ${projectPath} has an invalid or inconsistent path.`);
+        }
+        if (typeof rawProject.projectName !== 'string' || !rawProject.projectName) {
+            throw new Error(`Global services registry project ${projectPath} has an invalid name.`);
+        }
+        if (!isPlainObject(rawProject.containers) || !isPlainObject(rawProject.ports)) {
+            throw new Error(`Global services registry project ${projectPath} requires container and port objects.`);
+        }
+        if (!Array.isArray(rawProject.enabledServices)) {
+            throw new Error(`Global services registry project ${projectPath} has invalid enabled services.`);
+        }
+        const canonicalServices = ['mongodb', 'objectstorage', 'elasticsearch'];
+        if (!rawProject.enabledServices.every((serviceArg) => typeof serviceArg === 'string' && canonicalServices.includes(serviceArg)) ||
+            new Set(rawProject.enabledServices).size !== rawProject.enabledServices.length) {
+            throw new Error(`Global services registry project ${projectPath} has noncanonical enabled services.`);
+        }
+        if (typeof rawProject.lastActive !== 'number' || !Number.isFinite(rawProject.lastActive)) {
+            throw new Error(`Global services registry project ${projectPath} has an invalid lastActive value.`);
+        }
+        const rawContainers = rawProject.containers;
+        const rawPorts = rawProject.ports;
+        assertAllowedKeys(rawContainers, ['mongo', 'objectstorage', 'elasticsearch'], `project ${projectPath} containers`);
+        assertOptionalStrings(rawContainers, ['mongo', 'objectstorage', 'elasticsearch'], `project ${projectPath}.containers`);
+        assertAllowedKeys(rawPorts, ['mongo', 's3', 's3Ui', 'elasticsearch'], `project ${projectPath} ports`);
+        assertOptionalNumbers(rawPorts, ['mongo', 's3', 's3Ui', 'elasticsearch'], `project ${projectPath}.ports`);
+        if (rawProject.legacy !== undefined) {
+            if (!isPlainObject(rawProject.legacy)) {
+                throw new Error(`Global services registry project ${projectPath} has invalid legacy evidence.`);
+            }
+            assertAllowedKeys(rawProject.legacy, ['minioContainer'], `project ${projectPath} legacy`);
+            assertOptionalStrings(rawProject.legacy, ['minioContainer'], `project ${projectPath}.legacy`);
+            if (!rawProject.legacy.minioContainer) {
+                throw new Error(`Global services registry project ${projectPath} has empty legacy evidence.`);
+            }
+        }
+    }
+    return dataArg;
+};
+/** Raw, atomically replaced registry storage shared by runtime and migrations. */
+export class GlobalRegistryStore {
+    filePath;
+    lock;
+    constructor(optionsArg = {}) {
+        this.filePath = plugins.path.resolve(optionsArg.filePath ||
+            plugins.path.join(plugins.smartpath.get.home(), '.smartconfig', 'kv', 'gitzone-services.json'));
+        this.lock = new InterProcessLock({
+            lockPath: `${this.filePath}.lock`,
+            description: 'Global services registry',
+            timeoutMs: optionsArg.lockTimeoutMs,
+            pollMs: optionsArg.lockPollMs,
+        });
+    }
+    async readRaw() {
+        let content;
+        try {
+            content = await plugins.fs.readFile(this.filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return {};
+            }
+            throw new Error('Global services registry could not be read.', { cause: error });
+        }
+        try {
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error('Global services registry contains invalid JSON.', { cause: error });
+        }
+    }
+    async readCanonical() {
+        return assertCanonicalGlobalRegistryData(await this.readRaw());
+    }
+    async transact(operationArg) {
+        return this.lock.runExclusive(async () => {
+            const transaction = await operationArg(await this.readRaw());
+            if (transaction.writeData) {
+                await this.writeAtomic(assertCanonicalGlobalRegistryData(transaction.writeData));
+            }
+            return transaction.result;
+        });
+    }
+    async writeAtomic(dataArg) {
+        await plugins.fs.mkdir(plugins.path.dirname(this.filePath), { recursive: true });
+        const tempPath = `${this.filePath}.tmp-${process.pid}-${plugins.crypto
+            .randomBytes(12)
+            .toString('hex')}`;
+        let handle;
+        try {
+            handle = await plugins.fs.open(tempPath, 'wx', 0o600);
+            await handle.writeFile(`${JSON.stringify(dataArg, null, 2)}\n`, 'utf8');
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await plugins.fs.rename(tempPath, this.filePath);
+        }
+        catch (error) {
+            await handle?.close().catch(() => { });
+            await plugins.fs.rm(tempPath, { force: true }).catch(() => { });
+            throw new Error('Global services registry could not be written atomically.', {
+                cause: error,
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.globalregistrystore.js","sourceRoot":"","sources":["../../../ts/mod_services/classes.globalregistrystore.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,21 @@
+import type { TServiceName } from './classes.servicedatamarker.js';
+export interface IInterProcessLockOptions {
+    lockPath: string;
+    description: string;
+    timeoutMs?: number;
+    pollMs?: number;
+}
+/** Atomic-mkdir lock with bounded waiting and manual-only stale-lock recovery. */
+export declare class InterProcessLock {
+    readonly lockPath: string;
+    private readonly description;
+    private readonly timeoutMs;
+    private readonly pollMs;
+    constructor(optionsArg: IInterProcessLockOptions);
+    runExclusive<T>(operationArg: () => Promise<T>): Promise<T>;
+    private acquire;
+    private release;
+}
+export declare const withInterProcessLock: <T>(optionsArg: IInterProcessLockOptions, operationArg: () => Promise<T>) => Promise<T>;
+export declare const getServiceDataOperationLockPath: (projectPathArg: string, serviceArg: TServiceName) => string;
+export declare const withServiceDataOperationLock: <T>(projectPathArg: string, serviceArg: TServiceName, operationArg: () => Promise<T>) => Promise<T>;

package/dist_ts/mod_services/classes.interprocesslock.js

@@ -0,0 +1,141 @@
+import * as plugins from '../plugins.js';
+const isPlainObject = (valueArg) => {
+    return typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+};
+/** Atomic-mkdir lock with bounded waiting and manual-only stale-lock recovery. */
+export class InterProcessLock {
+    lockPath;
+    description;
+    timeoutMs;
+    pollMs;
+    constructor(optionsArg) {
+        this.lockPath = plugins.path.resolve(optionsArg.lockPath);
+        this.description = optionsArg.description;
+        this.timeoutMs = optionsArg.timeoutMs ?? 5_000;
+        this.pollMs = optionsArg.pollMs ?? 25;
+        if (!this.description) {
+            throw new Error('Interprocess lock description must not be empty.');
+        }
+        if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0) {
+            throw new Error('Interprocess lock timeout must be a positive safe integer.');
+        }
+        if (!Number.isSafeInteger(this.pollMs) || this.pollMs <= 0) {
+            throw new Error('Interprocess lock poll interval must be a positive safe integer.');
+        }
+    }
+    async runExclusive(operationArg) {
+        const release = await this.acquire();
+        let result;
+        let primaryError;
+        try {
+            result = await operationArg();
+        }
+        catch (error) {
+            primaryError = error;
+        }
+        let releaseError;
+        try {
+            await release();
+        }
+        catch (error) {
+            releaseError = error;
+        }
+        if (primaryError && releaseError) {
+            throw new AggregateError([primaryError, releaseError], `${this.description} failed and its lock could not be released.`);
+        }
+        if (primaryError) {
+            throw primaryError;
+        }
+        if (releaseError) {
+            throw releaseError;
+        }
+        return result;
+    }
+    async acquire() {
+        await plugins.fs.mkdir(plugins.path.dirname(this.lockPath), { recursive: true });
+        const owner = {
+            token: plugins.crypto.randomBytes(16).toString('hex'),
+            pid: process.pid,
+            createdAt: new Date().toISOString(),
+        };
+        const ownerPath = plugins.path.join(this.lockPath, 'owner.json');
+        const deadlineAt = Date.now() + this.timeoutMs;
+        while (true) {
+            try {
+                await plugins.fs.mkdir(this.lockPath);
+                try {
+                    await plugins.fs.writeFile(ownerPath, `${JSON.stringify(owner)}\n`, {
+                        encoding: 'utf8',
+                        flag: 'wx',
+                        mode: 0o600,
+                    });
+                }
+                catch (error) {
+                    await this.release(owner.token, false).catch(() => { });
+                    throw error;
+                }
+                return async () => this.release(owner.token, true);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST') {
+                    throw new Error(`${this.description} lock could not be acquired.`, { cause: error });
+                }
+                const remaining = deadlineAt - Date.now();
+                if (remaining <= 0) {
+                    let ownerDescription = 'owner metadata unavailable';
+                    try {
+                        const existingOwner = JSON.parse(await plugins.fs.readFile(ownerPath, 'utf8'));
+                        if (typeof existingOwner.pid === 'number' &&
+                            typeof existingOwner.createdAt === 'string') {
+                            ownerDescription = `pid ${existingOwner.pid}, created ${existingOwner.createdAt}`;
+                        }
+                    }
+                    catch {
+                        // Incomplete stale locks remain fail-closed and require operator review.
+                    }
+                    throw new Error(`${this.description} is locked (${ownerDescription}). ` +
+                        `If that process no longer exists, inspect and remove ${this.lockPath}.`);
+                }
+                await plugins.smartdelay.delayFor(Math.min(this.pollMs, remaining));
+            }
+        }
+    }
+    async release(tokenArg, requireOwnerArg) {
+        const ownerPath = plugins.path.join(this.lockPath, 'owner.json');
+        if (requireOwnerArg) {
+            let owner;
+            try {
+                owner = JSON.parse(await plugins.fs.readFile(ownerPath, 'utf8'));
+            }
+            catch (error) {
+                throw new Error(`${this.description} lock ownership could not be verified.`, {
+                    cause: error,
+                });
+            }
+            if (!isPlainObject(owner) || owner.token !== tokenArg) {
+                throw new Error(`${this.description} lock ownership changed before release.`);
+            }
+        }
+        const tombstonePath = `${this.lockPath}.release-${tokenArg}`;
+        await plugins.fs.rename(this.lockPath, tombstonePath);
+        await plugins.fs.rm(tombstonePath, { recursive: true, force: false });
+    }
+}
+export const withInterProcessLock = async (optionsArg, operationArg) => {
+    return new InterProcessLock(optionsArg).runExclusive(operationArg);
+};
+export const getServiceDataOperationLockPath = (projectPathArg, serviceArg) => {
+    const projectHash = plugins.crypto
+        .createHash('sha256')
+        .update(plugins.path.resolve(projectPathArg))
+        .digest('hex')
+        .slice(0, 32);
+    return plugins.path.join(plugins.smartpath.get.home(), '.smartconfig', 'kv', 'gitzone-services-locks', `${projectHash}-${serviceArg}.lock`);
+};
+export const withServiceDataOperationLock = async (projectPathArg, serviceArg, operationArg) => {
+    return withInterProcessLock({
+        lockPath: getServiceDataOperationLockPath(projectPathArg, serviceArg),
+        description: `${serviceArg} service data operation`,
+    }, operationArg);
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -8,15 +8,6 @@ export declare const isValidS3BucketName: (bucketArg: unknown) => bucketArg is s
  * alphabet than custom S3 names. Long names retain a stable hash suffix.
  */
 export declare const deriveS3BucketName: (projectNameArg: string) => string;
-export type TLegacyS3BucketRepair = {
-    bucket: unknown;
-    repaired: false;
-} | {
-    bucket: string;
-    repaired: true;
-};
-/** Repair only the exact invalid value emitted by older GitZone releases. */
-export declare const repairLegacyGeneratedS3Bucket: (projectNameArg: string, bucketArg: unknown) => TLegacyS3BucketRepair;
 export interface IServiceConfig {
     PROJECT_NAME: string;
     MONGODB_HOST: string;
@@ -33,9 +24,11 @@ export interface IServiceConfig {
     MONGODB_AUTH_ENABLED: boolean;
     S3_HOST: string;
     S3_PORT: string;
-    S3_CONSOLE_PORT: string;
+    S3_UI_PORT: string;
     S3_ACCESSKEY: string;
     S3_SECRETKEY: string;
+    S3_ADMIN_PASSWORD: string;
+    S3_REGION: string;
     S3_BUCKET: string;
     S3_ENDPOINT: string;
     S3_USESSL: boolean;
@@ -45,9 +38,12 @@ export interface IServiceConfig {
     ELASTICSEARCH_PASS: string;
     ELASTICSEARCH_URL: string;
 }
+/** Validate the complete canonical env.json shape before runtime use or persistence. */
+export declare const assertCanonicalServiceRuntimeConfig: (configArg: unknown) => asserts configArg is IServiceConfig;
 export declare class ServiceConfiguration {
     private configPath;
     private config;
+    private persistedConfigSnapshot?;
     private docker;
     /** Where the effective MongoDB auth mode came from. */
     private mongoAuthSource;
@@ -56,6 +52,8 @@ export declare class ServiceConfiguration {
      * Load or create the configuration
      */
     loadOrCreate(): Promise<IServiceConfig>;
+    /** Reload and validate persisted runtime state without deriving or writing fields. */
+    reloadFromDisk(): Promise<IServiceConfig>;
     /**
      * Fold `@git.zone/cli.serviceOptions` into the runtime configuration.
      */
@@ -90,6 +88,8 @@ export declare class ServiceConfiguration {
      * closed on the combination.
      */
     assertMongoExposureIsSafe(): void;
+    /** Reject ObjectStorage's prohibited defaults and credential reuse before Docker mutation. */
+    assertObjectStorageCredentialsAreSafe(): void;
     /**
      * Persist the MongoDB auth mode.
      *
@@ -131,7 +131,8 @@ export declare class ServiceConfiguration {
      */
     getContainerNames(): {
         mongo: string;
-        minio: string;
+        objectstorage: string;
+        legacyMinio: string;
         elasticsearch: string;
     };
     /**
@@ -142,7 +143,7 @@ export declare class ServiceConfiguration {
      */
     getDataDirectories(): {
         mongo: string;
-        minio: string;
+        objectstorage: string;
         elasticsearch: string;
     };
     /**
@@ -153,6 +154,8 @@ export declare class ServiceConfiguration {
      * Validate and update ports if they're not available
      */
     validateAndUpdatePorts(): Promise<boolean>;
+    /** Validate ObjectStorage host ports only after legacy/conflict checks pass. */
+    validateObjectStoragePorts(): Promise<boolean>;
     /**
      * Force reconfigure all ports with new available ones
      */