@archlast/cli 0.0.1

package/dist/docker/manager.js

@@ -0,0 +1,239 @@
+import * as fs from "fs";
+import { Readable } from "stream";
+import Docker from "dockerode";
+export class DockerManager {
+    docker;
+    constructor(docker) {
+        this.docker = docker ?? new Docker();
+    }
+    async checkAvailable() {
+        try {
+            await this.docker.ping();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async pullImage(imageTag, onProgress) {
+        const stream = await this.docker.pull(imageTag);
+        await new Promise((resolve, reject) => {
+            this.docker.modem.followProgress(stream, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            }, onProgress);
+        });
+    }
+    async ensureImage(imageTag) {
+        try {
+            await this.docker.getImage(imageTag).inspect();
+        }
+        catch (error) {
+            await this.pullImage(imageTag);
+        }
+    }
+    async ensureVolume(volumeName) {
+        try {
+            await this.docker.getVolume(volumeName).inspect();
+        }
+        catch (error) {
+            await this.docker.createVolume({ Name: volumeName });
+        }
+    }
+    async start(config) {
+        const imageTag = `${config.image}:${config.tag}`;
+        await this.ensureImage(imageTag);
+        await this.ensureVolume(config.dataVolumeName);
+        fs.mkdirSync(config.configDir, { recursive: true });
+        fs.mkdirSync(config.deployDir, { recursive: true });
+        const container = this.docker.getContainer(config.containerName);
+        try {
+            const info = await container.inspect();
+            const imageMatches = info.Config?.Image === imageTag;
+            const envMatches = (info.Config?.Env || []).includes(`ARCHLAST_PORT=${config.port}`);
+            const portKey = `${config.port}/tcp`;
+            const portBindings = info.HostConfig?.PortBindings || {};
+            const portMatches = Array.isArray(portBindings[portKey]) &&
+                portBindings[portKey]?.some((binding) => binding.HostPort === String(config.port));
+            const bindSources = info.HostConfig?.Binds || [];
+            const expectedBinds = [
+                `${config.dataVolumeName}:/data`,
+                `${formatBindPath(config.configDir)}:/config:ro`,
+                `${formatBindPath(config.deployDir)}:/app/server/.archlast-deploy:ro`,
+            ];
+            const bindsMatch = expectedBinds.every((bind) => bindSources.includes(bind));
+            if (!imageMatches || !envMatches || !portMatches || !bindsMatch) {
+                await container.remove({ force: true });
+            }
+            else if (info.State?.Running) {
+                return;
+            }
+            else {
+                await container.start();
+                return;
+            }
+        }
+        catch (error) {
+            if (error?.statusCode !== 404) {
+                throw error;
+            }
+        }
+        const env = Object.entries(config.env).map(([key, value]) => `${key}=${value}`);
+        await this.docker.createContainer({
+            name: config.containerName,
+            Image: imageTag,
+            Env: env,
+            ExposedPorts: {
+                [`${config.port}/tcp`]: {},
+            },
+            HostConfig: {
+                Binds: [
+                    `${config.dataVolumeName}:/data`,
+                    `${formatBindPath(config.configDir)}:/config:ro`,
+                    `${formatBindPath(config.deployDir)}:/app/server/.archlast-deploy:ro`,
+                ],
+                PortBindings: {
+                    [`${config.port}/tcp`]: [{ HostPort: String(config.port) }],
+                },
+                RestartPolicy: {
+                    Name: "unless-stopped",
+                },
+            },
+        }).then((created) => created.start());
+    }
+    async stop(containerName) {
+        const container = this.docker.getContainer(containerName);
+        try {
+            const info = await container.inspect();
+            if (info.State?.Running) {
+                await container.stop({ t: 10 });
+            }
+            await container.remove({ force: true });
+            return true;
+        }
+        catch (error) {
+            if (error?.statusCode === 404) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async restart(config) {
+        await this.stop(config.containerName);
+        await this.start(config);
+    }
+    async status(containerName) {
+        const container = this.docker.getContainer(containerName);
+        try {
+            const info = await container.inspect();
+            const ports = parsePorts(info.NetworkSettings?.Ports || {});
+            const stats = await this.fetchStats(container);
+            const startedAt = info.State?.StartedAt || undefined;
+            const uptimeSeconds = startedAt
+                ? Math.max(0, Math.floor((Date.now() - new Date(startedAt).getTime()) / 1000))
+                : undefined;
+            return {
+                exists: true,
+                state: info.State?.Status,
+                status: info.State?.Status,
+                health: info.State?.Health?.Status,
+                startedAt,
+                uptimeSeconds,
+                ports,
+                cpuPercent: stats?.cpuPercent,
+                memoryUsageBytes: stats?.memoryUsageBytes,
+                memoryLimitBytes: stats?.memoryLimitBytes,
+            };
+        }
+        catch (error) {
+            if (error?.statusCode === 404) {
+                return { exists: false };
+            }
+            throw error;
+        }
+    }
+    async logs(containerName, options = {}) {
+        const container = this.docker.getContainer(containerName);
+        const tail = normalizeTail(options.tail);
+        const baseOptions = {
+            stdout: true,
+            stderr: true,
+            timestamps: true,
+            ...(tail !== undefined ? { tail } : {}),
+        };
+        if (options.follow === false) {
+            const buffer = await container.logs({
+                ...baseOptions,
+                follow: false,
+            });
+            return Readable.from(buffer);
+        }
+        return container.logs({
+            ...baseOptions,
+            follow: true,
+        });
+    }
+    demuxStream(stream, stdout, stderr) {
+        this.docker.modem.demuxStream(stream, stdout, stderr);
+    }
+    async fetchStats(container) {
+        try {
+            const stats = await container.stats({ stream: false });
+            const cpuDelta = stats.cpu_stats.cpu_usage.total_usage -
+                stats.precpu_stats.cpu_usage.total_usage;
+            const systemDelta = stats.cpu_stats.system_cpu_usage - stats.precpu_stats.system_cpu_usage;
+            const cpuCount = stats.cpu_stats.online_cpus ||
+                stats.cpu_stats.cpu_usage.percpu_usage?.length ||
+                1;
+            let cpuPercent;
+            if (systemDelta > 0 && cpuDelta > 0) {
+                cpuPercent = (cpuDelta / systemDelta) * cpuCount * 100;
+            }
+            return {
+                cpuPercent,
+                memoryUsageBytes: stats.memory_stats.usage,
+                memoryLimitBytes: stats.memory_stats.limit,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function formatBindPath(input) {
+    if (process.platform === "win32") {
+        return input.replace(/\\/g, "/");
+    }
+    return input;
+}
+function parsePorts(ports) {
+    const results = [];
+    for (const [containerPort, bindings] of Object.entries(ports)) {
+        const portNumber = parseInt(containerPort.split("/")[0], 10);
+        if (!bindings || bindings.length === 0) {
+            results.push({ containerPort: portNumber });
+            continue;
+        }
+        for (const binding of bindings) {
+            results.push({
+                containerPort: portNumber,
+                hostPort: parseInt(binding.HostPort, 10),
+                hostIp: binding.HostIp,
+            });
+        }
+    }
+    return results;
+}
+function normalizeTail(value) {
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    return undefined;
+}

package/dist/docker/ports.d.ts

@@ -0,0 +1,6 @@
+import { DockerConfig } from "./types";
+export declare function ensureAvailablePort(config: DockerConfig): Promise<{
+    port: number;
+    changed: boolean;
+}>;
+//# sourceMappingURL=ports.d.ts.map

package/dist/docker/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/docker/ports.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAKvC,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CACpB,CAAC,CAmBD"}

package/dist/docker/restart-on-deploy.d.ts

@@ -0,0 +1,6 @@
+import { DockerConfig } from "./types";
+export declare function restartDockerIfNeeded(config: DockerConfig, serverUrl: string, isDevelopment?: boolean): Promise<{
+    restarted: boolean;
+    reason?: string;
+}>;
+//# sourceMappingURL=restart-on-deploy.d.ts.map

package/dist/docker/restart-on-deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restart-on-deploy.d.ts","sourceRoot":"","sources":["../../src/docker/restart-on-deploy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGvC,wBAAsB,qBAAqB,CACvC,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,aAAa,GAAE,OAAc,GAC9B,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA8BlD"}

package/dist/docker/types.d.ts

@@ -0,0 +1,36 @@
+export interface DockerConfig {
+    projectPath: string;
+    image: string;
+    tag: string;
+    containerName: string;
+    port: number;
+    dataVolumeName: string;
+    configDir: string;
+    deployDir: string;
+    composePath: string;
+    env: Record<string, string>;
+    restartOnDeploy: boolean;
+    configFilePath?: string;
+    envFilePath?: string;
+}
+export interface DockerContainerStatus {
+    exists: boolean;
+    state?: string;
+    status?: string;
+    health?: string;
+    startedAt?: string;
+    uptimeSeconds?: number;
+    ports?: Array<{
+        containerPort: number;
+        hostPort?: number;
+        hostIp?: string;
+    }>;
+    cpuPercent?: number;
+    memoryUsageBytes?: number;
+    memoryLimitBytes?: number;
+}
+export interface DockerLogsOptions {
+    follow?: boolean;
+    tail?: number | string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/docker/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/docker/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B"}

package/dist/docker/types.js

@@ -0,0 +1 @@
+export {};

package/dist/events-listener.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Server Events Listener
+ * Listens to Server-Sent Events (SSE) from the Archlast server
+ * Enables reactive deployments - when server changes happen, CLI responds
+ */
+export interface EventListenerOptions {
+    serverUrl: string;
+    adminToken?: string;
+    onSchemaUpdated?: () => Promise<void> | void;
+    onDeploymentComplete?: (type: "full" | "delta") => Promise<void> | void;
+    onDeploymentFailed?: () => Promise<void> | void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Listen to server deployment events via SSE
+ * Returns a cleanup function to stop listening
+ */
+export declare function listenToServerEvents(options: EventListenerOptions): () => void;
+//# sourceMappingURL=events-listener.d.ts.map

package/dist/events-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-listener.d.ts","sourceRoot":"","sources":["../src/events-listener.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC7C,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACxE,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAChD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,IAAI,CA8G9E"}

package/dist/events-listener.js

@@ -0,0 +1,105 @@
+/**
+ * Server Events Listener
+ * Listens to Server-Sent Events (SSE) from the Archlast server
+ * Enables reactive deployments - when server changes happen, CLI responds
+ */
+import chalk from "chalk";
+/**
+ * Listen to server deployment events via SSE
+ * Returns a cleanup function to stop listening
+ */
+export function listenToServerEvents(options) {
+    const { serverUrl, adminToken, onSchemaUpdated, onDeploymentComplete, onDeploymentFailed, onError } = options;
+    const eventsUrl = new URL("/_archlast/admin/deployments/events", serverUrl);
+    // Build request headers
+    const headers = {
+        "Accept": "text/event-stream",
+    };
+    if (adminToken) {
+        headers["X-Admin-Token"] = adminToken;
+    }
+    // Use EventSource for SSE (native browser API, need polyfill for Node)
+    // Since Node doesn't have native EventSource, we'll use fetch with streaming
+    let aborted = false;
+    let abortController = null;
+    async function connect() {
+        if (aborted)
+            return;
+        abortController = new AbortController();
+        try {
+            const response = await fetch(eventsUrl.toString(), {
+                headers,
+                signal: abortController.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error("Response body is null");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (!aborted) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    // Connection closed, try to reconnect
+                    if (!aborted) {
+                        setTimeout(connect, 3000);
+                    }
+                    break;
+                }
+                // Decode and process SSE data
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || ""; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    if (line.startsWith("data: ")) {
+                        const data = line.slice(6);
+                        if (data.trim() === "" || data === ": heartbeat")
+                            continue;
+                        try {
+                            const event = JSON.parse(data);
+                            handleEvent(event);
+                        }
+                        catch (e) {
+                            // Ignore invalid JSON
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (!aborted && error.name !== "AbortError") {
+                onError?.(error);
+                // Reconnect after delay
+                setTimeout(connect, 5000);
+            }
+        }
+    }
+    async function handleEvent(event) {
+        switch (event.type) {
+            case "schema_updated":
+                console.log(chalk.magenta("\n📊 Schema updated on server - regenerating types..."));
+                await onSchemaUpdated?.();
+                break;
+            case "deployment_complete":
+                const deploymentType = event.data?.deploymentType || "delta";
+                await onDeploymentComplete?.(deploymentType);
+                break;
+            case "deployment_failed":
+                console.log(chalk.red("\n❌ Deployment failed on server"));
+                await onDeploymentFailed?.();
+                break;
+        }
+    }
+    // Start connection
+    connect().catch((err) => {
+        onError?.(err);
+    });
+    // Return cleanup function
+    return () => {
+        aborted = true;
+        abortController?.abort();
+    };
+}

package/dist/generator.d.ts

@@ -0,0 +1,44 @@
+import { AnalysisResult } from "./analyzer";
+export declare class TypeGenerator {
+    private archlastPath;
+    constructor(archlastPath: string);
+    generate(analysis: AnalysisResult): Promise<void>;
+    private analyzeTypesWithTsMorph;
+    private analyzeRpcTypesWithTsMorph;
+    private extractRpcTypeInfo;
+    private extractTypeInfo;
+    private parseZodSchema;
+    private inferReturnType;
+    private generateDataModelFromSchema;
+    /**
+     * Scan schema folder for all .ts files
+     */
+    private scanSchemaFolder;
+    private generateApiTypes;
+    private generateRpcTypes;
+    /**
+     * Generate runtime tRPC router definition file
+     * This creates a real t.router() that imports and wraps the actual RPC procedures
+     */
+    private generateTrpcRouter;
+    private generateServerTypes;
+    private generateIndexExport;
+    /**
+     * Generate CRUD handlers for all collections in the schema
+     * Creates _generated/crud/ directory with individual collection files
+     */
+    generateCrudHandlers(generatedDir: string): Promise<void>;
+    /**
+     * Extract table names from the DataModel type string
+     */
+    private extractTableNames;
+    /**
+     * Generate CRUD handler code for a single table (public for CLI command)
+     */
+    generateCrudHandlerForTable(tableName: string): string;
+    /**
+     * Generate the index.ts file for CRUD handlers
+     */
+    private generateCrudIndex;
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAqD5C,qBAAa,aAAa;IACtB,OAAO,CAAC,YAAY,CAAS;gBAEjB,YAAY,EAAE,MAAM;IAK1B,QAAQ,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;YAiDzC,uBAAuB;YAgDvB,0BAA0B;IA6CxC,OAAO,CAAC,kBAAkB;IA6H1B,OAAO,CAAC,eAAe;IA+GvB,OAAO,CAAC,cAAc;IAiDtB,OAAO,CAAC,eAAe;YA6RT,2BAA2B;IA4PzC;;OAEG;YACW,gBAAgB;YAyBhB,gBAAgB;YAuDhB,gBAAgB;IAgF9B;;;OAGG;YACW,kBAAkB;YA2GlB,mBAAmB;IA0iBjC,OAAO,CAAC,mBAAmB;IAS3B;;;OAGG;IACG,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoC/D;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuBzB;;OAEG;IACH,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IA2HtD;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAkB5B"}