portal-mojo 0.2.20 → 0.2.21

package/src/admin/fleet/operations.ts

@@ -0,0 +1,179 @@
+import { apiOrigin, getAuthSessionRevision, getAuthSnapshot, isReauthRequired, MojoError, requestFreshAuth } from '../../client/runtime';
+import { applyCapacityPlan, readCapacityBatch } from './api';
+import type { CapacityBatch, CapacityPlan } from './types';
+
+export interface FleetOperationState {
+    status: 'idle' | 'submitting' | 'running' | 'unknown' | 'done' | 'failed';
+    planId: string | null;
+    batchId: string | null;
+    batch: CapacityBatch | null;
+    message: string;
+    since: number;
+}
+interface OperationRecord {
+    value: FleetOperationState;
+    listeners: Set<() => void>;
+    busy: boolean;
+    reading: boolean;
+    deadline: number;
+    actor: number | null;
+    timerScope: string | null;
+    timer: ReturnType<typeof setTimeout> | null;
+}
+export function fleetSessionScope(): string | null {
+    const auth = getAuthSnapshot();
+    return auth.authenticated && auth.uid ? `${auth.uid}:${getAuthSessionRevision()}` : null;
+}
+export function batchOutcome(batch: CapacityBatch): 'running' | 'unknown' | 'done' | 'failed' {
+    const uncertain = (code: string | null) => code === 'mutation_state_unknown' || code === 'operation_failed';
+    if (uncertain(batch.error_code) || batch.steps.some(step => uncertain(step.error_code))) return 'unknown';
+    if (batch.state === 'done' && !batch.error_code && batch.steps.every(step => step.state === 'done' && !step.error_code)) return 'done';
+    if (batch.state === 'failed') return 'failed';
+    return batch.state === 'running' ? 'running' : 'unknown';
+}
+const errorMessage = (error: unknown) => error instanceof Error ? error.message : 'Capacity outcome could not be confirmed.';
+
+/** Safe unresolved IDs survive same-actor reauthentication; exact sessions fence every send/reply.
+ * Lives outside dialog/route components. Stores no credentials and never replays a mutation. */
+export function createFleetOperationCoordinator(deps: {
+    apply?: typeof applyCapacityPlan;
+    read?: typeof readCapacityBatch;
+    scope?: () => string | null;
+    now?: () => number;
+    interval?: number;
+} = {}) {
+    const apply = deps.apply ?? applyCapacityPlan;
+    const read = deps.read ?? readCapacityBatch;
+    const current = deps.scope ?? fleetSessionScope;
+    const now = deps.now ?? Date.now;
+    const records = new Map<string, OperationRecord>();
+    function record(scope: string): OperationRecord {
+        const actorKey = scope.slice(0, scope.lastIndexOf(':'));
+        const key = `${apiOrigin() || 'same-origin'}:${actorKey}`;
+        let entry = records.get(key);
+        if (!entry) {
+            entry = {
+                value: { status: 'idle', planId: null, batchId: null, batch: null, message: '', since: 0 },
+                listeners: new Set(), busy: false, reading: false, deadline: 0, actor: null, timerScope: null, timer: null,
+            };
+            records.set(key, entry);
+        }
+        return entry;
+    }
+    function update(scope: string, patch: Partial<FleetOperationState>): void {
+        const entry = record(scope);
+        entry.value = { ...entry.value, ...patch };
+        entry.listeners.forEach(listener => listener());
+    }
+    function active(scope: string): void {
+        if (current() !== scope) throw new Error('The signed-in session changed. Review again.');
+    }
+    function schedule(scope: string): void {
+        const entry = record(scope);
+        if (entry.timer) clearTimeout(entry.timer);
+        if (entry.value.status !== 'running') return;
+        entry.timerScope = scope;
+        entry.timer = setTimeout(() => {
+            entry.timer = null;
+            if (current() !== scope) return;
+            if (now() > entry.deadline) {
+                update(scope, { status: 'unknown', message: 'Automatic observation reached its budget. Progress is unknown; refresh this exact batch, never replay it.' });
+                return;
+            }
+            void observe(scope);
+        }, deps.interval ?? 10_000);
+    }
+    function accept(scope: string, batch: CapacityBatch): void {
+        const entry = record(scope);
+        if (batch.actor !== entry.actor || batch.plan_id !== entry.value.planId || entry.value.batchId && batch.id !== entry.value.batchId) {
+            throw new Error('Batch identity does not match the submitted plan.');
+        }
+        const status = batchOutcome(batch);
+        update(scope, { batchId: batch.id, batch, status, message: batch.stalled
+            ? 'Progress stalled. Check the jobs runner and cleanup channel, then refresh observation.' : batch.message ?? status });
+        schedule(scope);
+    }
+    async function observe(scope: string, batchId?: string): Promise<void> {
+        const entry = record(scope);
+        if (entry.reading || entry.busy) return;
+        const id = batchId?.trim() || entry.value.batchId;
+        if (!id || !entry.value.planId) return;
+        entry.reading = true;
+        try {
+            active(scope);
+            const batch = await read(id, { beforeSend: () => active(scope) });
+            active(scope);
+            accept(scope, batch);
+        } catch (error) {
+            if (current() === scope) update(scope, { status: 'unknown', message: `Observation unavailable: ${errorMessage(error)}. Keep the plan and batch IDs; no new change is safe yet.` });
+        } finally {
+            entry.reading = false;
+        }
+    }
+    return {
+        get: (scope: string) => record(scope).value,
+        subscribe(scope: string, listener: () => void) {
+            const entry = record(scope);
+            entry.listeners.add(listener);
+            // Resubscriptions on render must not keep postponing the next observation.
+            if (current() === scope && entry.value.status === 'running' && (!entry.timer || entry.timerScope !== scope)) schedule(scope);
+            return () => entry.listeners.delete(listener);
+        },
+        blocked: (scope: string) => ['submitting', 'running', 'unknown'].includes(record(scope).value.status),
+        observe,
+        async submit(scope: string, plan: CapacityPlan): Promise<void> {
+            const entry = record(scope);
+            if (entry.busy || ['submitting', 'running', 'unknown'].includes(entry.value.status)) return;
+            active(scope);
+            if (Date.parse(plan.expires_at) <= now()) throw new Error('This plan expired. Review a new plan.');
+            entry.busy = true;
+            entry.actor = plan.actor;
+            entry.deadline = now() + Math.max(1, plan.steps.length) * 90 * 60_000;
+            update(scope, { status: 'submitting', planId: plan.id, batchId: null, batch: null, message: 'Submitting the reviewed stored plan…', since: now() });
+            let beforeSendPassed = false, localRefusal = false;
+            try {
+                const batch = await apply(plan.id, { beforeSend: () => {
+                    try {
+                        active(scope);
+                        if (Date.parse(plan.expires_at) <= now()) throw new Error('Plan expired before submission.');
+                        beforeSendPassed = true;
+                    } catch (error) { localRefusal = true; throw error; }
+                } });
+                if (current() !== scope) {
+                    update(scope, { batchId: batch.id, status: 'unknown', message: 'The session changed during submission. Its batch ID is retained for reconciliation; observe it deliberately from your current session.' });
+                    return;
+                }
+                accept(scope, batch);
+            } catch (error) {
+                // The production transport always completes beforeSend before dispatch.
+                // An auth gate or our final fence can refuse without any request.
+                if (localRefusal || !deps.apply && !beforeSendPassed) {
+                    update(scope, { status: 'idle', planId: null, batchId: null, batch: null, message: `${errorMessage(error)} Refresh inventory and review a new plan.` });
+                    throw error;
+                }
+                const duplicate = error instanceof MojoError && error.errorCode === 'plan_already_applied';
+                const duplicateBatch = duplicate && error.data && typeof error.data === 'object'
+                    ? (error.data as { batch?: unknown }).batch : null;
+                if (typeof duplicateBatch === 'string' && duplicateBatch.trim()) {
+                    update(scope, { batchId: duplicateBatch, status: 'running', message: 'Already submitted. Observing the existing batch.' });
+                    schedule(scope);
+                } else if (isReauthRequired(error)) {
+                    update(scope, { status: 'idle', message: 'Authenticate again, refresh the fleet, and deliberately review a new plan.' });
+                    await requestFreshAuth();
+                    throw error;
+                } else if (!duplicate && error instanceof MojoError && [400, 401, 403, 404, 405, 409, 422].includes(error.status)) {
+                    update(scope, { status: 'idle', message: errorMessage(error) });
+                    throw error;
+                } else {
+                    update(scope, { status: 'unknown', message: `Apply outcome unknown: ${errorMessage(error)}. Inspect server capacity logs for plan ${plan.id}; enter its batch ID below. Inventory refresh or closing this dialog cannot resolve an unacknowledged submission. Do not replay it.` });
+                }
+            } finally {
+                entry.busy = false;
+            }
+        },
+        dispose() {
+            records.forEach(entry => { if (entry.timer) clearTimeout(entry.timer); });
+        },
+    };
+}
+export const fleetOperations = createFleetOperationCoordinator();

package/src/admin/fleet/standalone-data.ts

@@ -0,0 +1,87 @@
+import { actionReason, drainedNodeReason, nodeRemovalReason, offered } from './data';
+import type { CapacityReport, CapacityStep } from './types';
+
+/** Standalone intent identifies every existing member explicitly; the Dashboard compiler is unchanged. */
+export interface CapacityDraft {
+    addNodes: number; source: string; subnet: string; removeNodes: string[]; terminateNodes: string[];
+    databases: Record<string, { addReaders: number; sizes: Record<string, string>; removeReaders: string[] }>;
+    caches: Record<string, { replicas: number; size: string }>;
+}
+export function newCapacityDraft(report: CapacityReport): CapacityDraft {
+    return { addNodes: 0, source: '', subnet: '', removeNodes: [], terminateNodes: [], databases: Object.fromEntries(report.databases.map(row => [row.identifier, { addReaders: 0, sizes: {}, removeReaders: [] }])), caches: Object.fromEntries(report.caches.map(row => [row.identifier, { replicas: row.replica_count, size: '' }])) };
+}
+export function compileCapacityDraft(report: CapacityReport, draft: CapacityDraft): CapacityStep[] {
+    if (report.mode !== 'managed') throw new Error('External infrastructure is read-only.');
+    const steps: CapacityStep[] = [];
+    const add = (step: CapacityStep) => { if (!offered(report, step.action)) throw new Error(`${step.action}: ${actionReason(report, step.action)}`); steps.push(step); };
+    const count = (value: number, label: string, min = 0, max = 20) => { if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error(`${label} must be a whole number from ${min} to ${max}.`); };
+    const unique = (ids: string[], label: string) => { if (new Set(ids).size !== ids.length) throw new Error(`${label} contains a duplicate target.`); };
+    count(draft.addNodes, 'App additions');
+    unique(draft.removeNodes, 'Node removals'); unique(draft.terminateNodes, 'Node terminations');
+    if (draft.addNodes) {
+        if (!report.nodes.inventory_available || !report.nodes.serving_available) throw new Error('Fresh node inventory and serving evidence are required.');
+        const source = report.nodes.instances.find(n => n.id === draft.source && n.healthy && n.registered && n.instance_state === 'running' && n.lifecycle_state === 'available');
+        if (!source) throw new Error('Choose an explicit healthy source node.');
+        if (draft.removeNodes.includes(source.id) || draft.terminateNodes.includes(source.id)) throw new Error('Keep the selected source node while adding nodes.');
+        if (draft.subnet && !/^subnet-[A-Za-z0-9]+$/.test(draft.subnet)) throw new Error('Subnet must be a subnet-… identifier.');
+        for (let i = 0; i < draft.addNodes; i++) add({ action: 'add_node', source_instance: source.id, ...(draft.subnet ? { subnet_id: draft.subnet } : {}) });
+    }
+    for (const id of draft.removeNodes) {
+        if (draft.terminateNodes.includes(id)) throw new Error('Choose one removal task per node.');
+        const node = report.nodes.instances.find(n => n.id === id);
+        if (!node) throw new Error('Selected node is absent from the fresh inventory.');
+        const reason = nodeRemovalReason(report, node, draft.removeNodes.filter(other => other !== id));
+        if (reason) throw new Error(reason);
+        add({ action: 'drain_node', resource: id }); add({ action: 'terminate_node', resource: id });
+    }
+    for (const id of draft.terminateNodes) {
+        const node = report.nodes.instances.find(n => n.id === id);
+        if (!node) throw new Error('Selected drained node is absent from the fresh inventory.');
+        const reason = drainedNodeReason(report, node); if (reason) throw new Error(reason);
+        add({ action: 'terminate_node', resource: id });
+    }
+    for (const [id, d] of Object.entries(draft.databases)) {
+        if (!d.addReaders && !d.removeReaders.length && !Object.values(d.sizes).some(Boolean)) continue;
+        const row = report.databases.find(r => r.identifier === id);
+        if (!row || !report.databases_available || row.blocked_reason) throw new Error(`${id}: ${row?.blocked_reason ?? 'Database inventory unavailable.'}`);
+        count(d.addReaders, 'Reader additions'); unique(d.removeReaders, 'Reader removals');
+        for (const target of d.removeReaders) {
+            const member = row.members.find(m => m.id === target);
+            if (!row.readers.includes(target) || !member?.can_remove) throw new Error(`${target}: reader removal is unavailable.`);
+            if (d.sizes[target]) throw new Error(`${target}: choose resize or removal.`);
+            add({ action: 'remove_reader', resource: target });
+        }
+        for (let i = 0; i < d.addReaders; i++) add({ action: 'add_reader', resource: id });
+        for (const [target, size] of Object.entries(d.sizes)) {
+            if (!size) continue;
+            const member = row.members.find(m => m.id === target), choice = report.sizes.database.find(s => s.size === size);
+            if (!member?.can_resize || !choice) throw new Error(`${target}: choose an available member and curated database size.`);
+            if (choice.type !== member.instance_class) add({ action: 'resize_database', resource: target, size, apply_immediately: true });
+        }
+    }
+    for (const [id, d] of Object.entries(draft.caches)) {
+        const row = report.caches.find(r => r.identifier === id);
+        if (!row) throw new Error(`${id}: Redis group is absent from the fresh inventory.`);
+        const choice = d.size ? report.sizes.cache.find(s => s.size === d.size) : null;
+        const resizing = !!choice && choice.type !== row.node_type;
+        if (d.size && !choice) throw new Error(`${id}: choose a curated Redis size.`);
+        count(d.replicas, 'Redis replicas', row.min_replicas, 100);
+        if (d.replicas === row.replica_count && !resizing) continue;
+        if (!report.caches_available || row.blocked_reason) throw new Error(`${id}: ${row.blocked_reason ?? 'Redis inventory unavailable.'}`);
+        if (d.replicas !== row.replica_count && resizing) throw new Error(`${id}: change size or replica count in one plan. Apply, refresh, then review the other change separately.`);
+        if (resizing) add({ action: 'resize_cache', resource: id, size: d.size, apply_immediately: true });
+        if (d.replicas !== row.replica_count) add({ action: 'set_cache_replicas', resource: id, count: d.replicas, apply_immediately: true });
+    }
+    if (steps.length > 20) throw new Error(`A plan supports 20 steps; this draft has ${steps.length}. Reduce the changes.`);
+    return steps;
+}
+export function observationAge(value: string | null, now = Date.now()): string {
+    const time = value ? Date.parse(value) : NaN;
+    if (!Number.isFinite(time)) return 'Observation time unavailable';
+    const seconds = Math.max(0, Math.floor((now - time) / 1000));
+    return seconds < 60 ? `Observed ${seconds}s ago` : seconds < 3600 ? `Observed ${Math.floor(seconds / 60)}m ago` : `Observed ${Math.floor(seconds / 3600)}h ago`;
+}
+export function completeAllowlist(report: CapacityReport): boolean {
+    const e = report.egress;
+    return e.available && e.fleet_available && e.addresses_available && e.policy_available && e.enabled && !e.pending_nodes.length;
+}

package/src/admin/fleet/types.ts

@@ -0,0 +1,208 @@
+export type FleetFacts = Record<string, unknown>;
+export interface FleetSource {
+    status: string;
+    observed_at: string | null;
+    stale_after: string | null;
+    reason: string | null;
+    data: FleetFacts;
+}
+export interface FleetDashboard {
+    schema_version: 2;
+    observed_at: string;
+    availability: {
+        state: 'ok' | 'down' | 'unknown';
+        message: string;
+        down: string[];
+    };
+    attention: {
+        message: string | null;
+    };
+    sources: Record<string, FleetSource>;
+}
+export type CapacityAction = 'add_node' | 'drain_node' | 'terminate_node' | 'add_reader' | 'remove_reader' | 'set_cache_replicas' | 'resize_cache' | 'resize_database';
+export interface CapacityStep {
+    action: CapacityAction;
+    resource?: string;
+    size?: string;
+    count?: number;
+    apply_immediately?: true;
+    source_instance?: string;
+    subnet_id?: string;
+}
+export interface CapacityNode {
+    id: string;
+    name: string;
+    state: string;
+    instance_state: string | null;
+    lifecycle_state: string;
+    instance_type: string | null;
+    zone: string | null;
+    subnet_id: string | null;
+    public_ip: string | null;
+    healthy: boolean;
+    registered: boolean;
+    can_drain: boolean;
+    self: boolean;
+    primary: boolean;
+    added_by_capacity: boolean;
+    stable_ip: boolean;
+    groups: string[];
+}
+export interface DatabaseMember {
+    id: string;
+    role: string;
+    status: string | null;
+    lifecycle_state: string;
+    instance_class: string | null;
+    can_resize: boolean;
+    can_remove: boolean;
+}
+export interface CapacityDatabase {
+    identifier: string;
+    kind: 'aurora' | 'standalone';
+    engine: string;
+    status: string;
+    writer: string | null;
+    readers: string[];
+    instance_class: string | null;
+    writer_instance_class: string | null;
+    reader_instance_classes: Record<string, string | null>;
+    members: DatabaseMember[];
+    blocked_reason: string | null;
+}
+export interface CapacityCache {
+    identifier: string;
+    status: string;
+    node_type: string;
+    replica_count: number;
+    min_replicas: number;
+    resize_impact: 'rolling' | 'downtime';
+    blocked_reason: string | null;
+    members: {
+        id: string;
+        role: string;
+        status: string;
+        lifecycle_state: string;
+    }[];
+}
+export interface CapacitySize {
+    size: string;
+    label: string;
+    type: string;
+    monthly_usd: number | null;
+}
+export interface CapacityReport {
+    schema_version: 2;
+    mode: string;
+    region: string;
+    generated_at: string;
+    identity_available: boolean;
+    identity: {
+        project: string;
+        environment: string;
+    } | null;
+    node_id_pinned: boolean;
+    nodes: {
+        self: string | null;
+        self_check: string;
+        serving_available: boolean;
+        inventory_available: boolean;
+        instances: CapacityNode[];
+    };
+    databases_available: boolean;
+    caches_available: boolean;
+    databases: CapacityDatabase[];
+    caches: CapacityCache[];
+    sizes: {
+        database: CapacitySize[];
+        cache: CapacitySize[];
+    };
+    actions: Record<string, {
+        offered: boolean;
+        blocked_reason: string | null;
+    }>;
+    warnings: {
+        code: string;
+        message: string;
+        iam_action: string | null;
+    }[];
+    reader_routing: {
+        database: {
+            active: boolean;
+            host: string | null;
+            skip_reason: string | null;
+            matches_reader_endpoint: boolean | null;
+        };
+        redis: {
+            active: boolean;
+        };
+    };
+    egress: {
+        available: boolean;
+        fleet_available: boolean;
+        addresses_available: boolean;
+        policy_available: boolean;
+        enabled: boolean;
+        addresses: string[];
+        attached: {
+            instance: string;
+            public_ip: string;
+            managed: boolean;
+        }[];
+        fallback_attached: {
+            instance: string;
+            public_ip: string;
+            managed: boolean;
+        }[];
+        reserved: {
+            public_ip: string;
+        }[];
+        pending_nodes: string[];
+    };
+}
+export interface CapacityPlanStep {
+    index: number;
+    action: CapacityAction;
+    resource: string;
+    description: string;
+    kind: string;
+    params: FleetFacts;
+    warnings: string[];
+    monthly_delta_usd: number | null;
+}
+export interface CapacityPlan {
+    schema_version: 2;
+    id: string;
+    actor: number;
+    created: number | string;
+    expires_at: string;
+    expires_in: number;
+    steps: CapacityPlanStep[];
+    total_monthly_delta_usd: number | null;
+    estimate_complete: boolean;
+    order_note: string;
+}
+export interface CapacityBatchStep {
+    index: number;
+    action: CapacityAction;
+    resource: string;
+    description: string;
+    state: string;
+    operation: string | null;
+    phase: string | null;
+    message: string | null;
+    error_code: string | null;
+}
+export interface CapacityBatch {
+    schema_version: 2;
+    id: string;
+    plan_id: string;
+    actor: number;
+    state: string;
+    started: number | string;
+    current_index: number;
+    message: string | null;
+    error_code: string | null;
+    stalled: boolean;
+    steps: CapacityBatchStep[];
+}