@archlast/cli 0.0.1

package/dist/commands/start.d.ts

@@ -0,0 +1,11 @@
+interface StartOptions {
+    port?: string;
+    path?: string;
+    image?: string;
+    tag?: string;
+    container?: string;
+    config?: string;
+}
+export declare function startCommand(options: StartOptions): Promise<void>;
+export {};
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/commands/start.ts"],"names":[],"mappings":"AASA,UAAU,YAAY;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAwBD,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA+DvE"}

package/dist/commands/start.js

@@ -0,0 +1,74 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { DockerManager } from "../docker/manager";
+import { generateComposeFile } from "../docker/compose";
+import { loadDockerConfig } from "../docker/config";
+const HEALTH_TIMEOUT_MS = 60000;
+const HEALTH_INTERVAL_MS = 2000;
+async function waitForHealth(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    const url = `http://localhost:${port}/health`;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+            if (response.ok) {
+                return true;
+            }
+        }
+        catch {
+            // retry
+        }
+        await new Promise((resolve) => setTimeout(resolve, HEALTH_INTERVAL_MS));
+    }
+    return false;
+}
+export async function startCommand(options) {
+    console.log(chalk.blue.bold("Archlast Docker Start\n"));
+    const config = loadDockerConfig({
+        path: options.path,
+        port: options.port,
+        image: options.image,
+        tag: options.tag,
+        containerName: options.container,
+        configFile: options.config,
+    });
+    const manager = new DockerManager();
+    const dockerAvailable = await manager.checkAvailable();
+    if (!dockerAvailable) {
+        console.error(chalk.red("Docker is not available."));
+        console.log(chalk.yellow("Install Docker Desktop or start Docker Engine before running this command."));
+        process.exit(1);
+    }
+    if (process.env.DOCKER_HOST?.includes("podman") || process.env.PODMAN_SOCKET) {
+        console.log(chalk.yellow("Warning: Podman support is experimental. If issues arise, try Docker Desktop."));
+    }
+    const composeDir = path.dirname(config.composePath);
+    fs.mkdirSync(composeDir, { recursive: true });
+    fs.writeFileSync(config.composePath, generateComposeFile(config), "utf-8");
+    const spinner = ora(`Starting ${config.image}:${config.tag}...`).start();
+    try {
+        await manager.start(config);
+        const healthy = await waitForHealth(config.port, HEALTH_TIMEOUT_MS);
+        if (!healthy) {
+            spinner.warn("Container started, but health check did not pass within 60 seconds.");
+        }
+        else {
+            spinner.succeed("Archlast server is running.");
+        }
+    }
+    catch (error) {
+        spinner.fail("Failed to start container.");
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        else {
+            console.error(chalk.red(String(error)));
+        }
+        process.exit(1);
+    }
+    console.log(chalk.green(`API:       http://localhost:${config.port}`));
+    console.log(chalk.green(`Dashboard: http://localhost:${config.port}/_admin`));
+    console.log(chalk.gray(`Compose:   ${config.composePath}`));
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,8 @@
+interface StatusOptions {
+    path?: string;
+    container?: string;
+    config?: string;
+}
+export declare function statusCommand(options: StatusOptions): Promise<void>;
+export {};
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAIA,UAAU,aAAa;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AA2BD,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CzE"}

package/dist/commands/status.js

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+import { DockerManager } from "../docker/manager";
+import { loadDockerConfig } from "../docker/config";
+function formatDuration(seconds) {
+    if (!seconds && seconds !== 0)
+        return "unknown";
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const parts = [];
+    if (days)
+        parts.push(`${days}d`);
+    if (hours)
+        parts.push(`${hours}h`);
+    if (minutes)
+        parts.push(`${minutes}m`);
+    if (!parts.length)
+        parts.push(`${seconds}s`);
+    return parts.join(" ");
+}
+function formatBytes(bytes) {
+    if (!bytes && bytes !== 0)
+        return "unknown";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${value.toFixed(1)} ${units[unitIndex]}`;
+}
+export async function statusCommand(options) {
+    console.log(chalk.blue.bold("Archlast Docker Status\n"));
+    const config = loadDockerConfig({
+        path: options.path,
+        containerName: options.container,
+        configFile: options.config,
+    });
+    const manager = new DockerManager();
+    const dockerAvailable = await manager.checkAvailable();
+    if (!dockerAvailable) {
+        console.error(chalk.red("Docker is not available."));
+        process.exit(1);
+    }
+    const status = await manager.status(config.containerName);
+    if (!status.exists) {
+        console.log(chalk.yellow("Archlast container not found."));
+        return;
+    }
+    console.log(chalk.green(`Container: ${config.containerName}`));
+    console.log(`State:     ${status.state ?? "unknown"}`);
+    console.log(`Health:    ${status.health ?? "unknown"}`);
+    console.log(`Uptime:    ${formatDuration(status.uptimeSeconds)}`);
+    if (status.ports && status.ports.length > 0) {
+        const ports = status.ports
+            .map((port) => port.hostPort ? `${port.hostIp ?? "0.0.0.0"}:${port.hostPort}->${port.containerPort}` : `${port.containerPort}`)
+            .join(", ");
+        console.log(`Ports:     ${ports}`);
+    }
+    if (status.cpuPercent !== undefined || status.memoryUsageBytes !== undefined) {
+        const cpuText = status.cpuPercent !== undefined ? `${status.cpuPercent.toFixed(1)}%` : "unknown";
+        const memoryText = status.memoryUsageBytes !== undefined
+            ? `${formatBytes(status.memoryUsageBytes)} / ${formatBytes(status.memoryLimitBytes)}`
+            : "unknown";
+        console.log(`CPU:       ${cpuText}`);
+        console.log(`Memory:    ${memoryText}`);
+    }
+}

package/dist/commands/stop.d.ts

@@ -0,0 +1,8 @@
+interface StopOptions {
+    path?: string;
+    container?: string;
+    config?: string;
+}
+export declare function stopCommand(options: StopOptions): Promise<void>;
+export {};
+//# sourceMappingURL=stop.d.ts.map

package/dist/commands/stop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../src/commands/stop.ts"],"names":[],"mappings":"AAIA,UAAU,WAAW;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBrE"}

package/dist/commands/stop.js

@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import { DockerManager } from "../docker/manager";
+import { loadDockerConfig } from "../docker/config";
+export async function stopCommand(options) {
+    console.log(chalk.blue.bold("Archlast Docker Stop\n"));
+    const config = loadDockerConfig({
+        path: options.path,
+        containerName: options.container,
+        configFile: options.config,
+    });
+    const manager = new DockerManager();
+    const dockerAvailable = await manager.checkAvailable();
+    if (!dockerAvailable) {
+        console.error(chalk.red("Docker is not available."));
+        process.exit(1);
+    }
+    const stopped = await manager.stop(config.containerName);
+    if (!stopped) {
+        console.log(chalk.yellow("No running Archlast container found."));
+        return;
+    }
+    console.log(chalk.green("Archlast container stopped."));
+}

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,12 @@
+interface UpgradeOptions {
+    path?: string;
+    image?: string;
+    tag?: string;
+    version?: string;
+    container?: string;
+    port?: string;
+    config?: string;
+}
+export declare function upgradeCommand(options: UpgradeOptions): Promise<void>;
+export {};
+//# sourceMappingURL=upgrade.d.ts.map

package/dist/commands/upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/commands/upgrade.ts"],"names":[],"mappings":"AASA,UAAU,cAAc;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAwBD,wBAAsB,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA4D3E"}

package/dist/commands/upgrade.js

@@ -0,0 +1,77 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { DockerManager } from "../docker/manager";
+import { loadDockerConfig } from "../docker/config";
+import { generateComposeFile } from "../docker/compose";
+const HEALTH_TIMEOUT_MS = 60000;
+const HEALTH_INTERVAL_MS = 2000;
+async function waitForHealth(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    const url = `http://localhost:${port}/health`;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+            if (response.ok) {
+                return true;
+            }
+        }
+        catch {
+            // retry
+        }
+        await new Promise((resolve) => setTimeout(resolve, HEALTH_INTERVAL_MS));
+    }
+    return false;
+}
+export async function upgradeCommand(options) {
+    console.log(chalk.blue.bold("Archlast Docker Upgrade\n"));
+    const config = loadDockerConfig({
+        path: options.path,
+        port: options.port,
+        image: options.image,
+        tag: options.tag ?? options.version,
+        containerName: options.container,
+        configFile: options.config,
+    });
+    const manager = new DockerManager();
+    const dockerAvailable = await manager.checkAvailable();
+    if (!dockerAvailable) {
+        console.error(chalk.red("Docker is not available."));
+        process.exit(1);
+    }
+    const imageTag = `${config.image}:${config.tag}`;
+    const spinner = ora(`Pulling ${imageTag}...`).start();
+    try {
+        await manager.pullImage(imageTag);
+        spinner.succeed(`Pulled ${imageTag}.`);
+    }
+    catch (error) {
+        spinner.fail("Failed to pull image.");
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        process.exit(1);
+    }
+    const restartSpinner = ora(`Upgrading ${config.containerName}...`).start();
+    try {
+        await manager.stop(config.containerName);
+        await manager.start(config);
+        fs.mkdirSync(path.dirname(config.composePath), { recursive: true });
+        fs.writeFileSync(config.composePath, generateComposeFile(config), "utf-8");
+        const healthy = await waitForHealth(config.port, HEALTH_TIMEOUT_MS);
+        if (!healthy) {
+            restartSpinner.warn("Container upgraded, but health check did not pass within 60 seconds.");
+        }
+        else {
+            restartSpinner.succeed(`Upgraded to ${config.tag}.`);
+        }
+    }
+    catch (error) {
+        restartSpinner.fail("Failed to upgrade container.");
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        process.exit(1);
+    }
+}

package/dist/docker/compose.d.ts

@@ -0,0 +1,3 @@
+import { DockerConfig } from "./types";
+export declare function generateComposeFile(config: DockerConfig): string;
+//# sourceMappingURL=compose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/docker/compose.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAUvC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAuChE"}

package/dist/docker/compose.js

@@ -0,0 +1,47 @@
+import * as path from "path";
+import { stringify } from "yaml";
+function normalizeDockerPath(input) {
+    const resolved = path.resolve(input);
+    if (process.platform === "win32") {
+        return resolved.replace(/\\/g, "/");
+    }
+    return resolved;
+}
+export function generateComposeFile(config) {
+    const environment = {};
+    for (const [key, value] of Object.entries(config.env)) {
+        if (value !== undefined && value !== "") {
+            environment[key] = value;
+        }
+    }
+    const compose = {
+        version: "3.8",
+        services: {
+            archlast: {
+                image: `${config.image}:${config.tag}`,
+                container_name: config.containerName,
+                restart: "unless-stopped",
+                ports: [`${config.port}:${config.port}`],
+                volumes: [
+                    `${config.dataVolumeName}:/data`,
+                    `${normalizeDockerPath(config.configDir)}:/config:ro`,
+                    `${normalizeDockerPath(config.deployDir)}:/app/server/.archlast-deploy:ro`,
+                ],
+                environment,
+                healthcheck: {
+                    test: ["CMD", "curl", "-f", `http://localhost:${config.port}/health`],
+                    interval: "30s",
+                    timeout: "10s",
+                    retries: 3,
+                    start_period: "60s",
+                },
+            },
+        },
+        volumes: {
+            [config.dataVolumeName]: {
+                name: config.dataVolumeName,
+            },
+        },
+    };
+    return stringify(compose);
+}

package/dist/docker/config.d.ts

@@ -0,0 +1,12 @@
+import { DockerConfig } from "./types";
+export interface DockerConfigOptions {
+    path?: string;
+    port?: string | number;
+    image?: string;
+    tag?: string;
+    containerName?: string;
+    configFile?: string;
+    restartOnDeploy?: boolean;
+}
+export declare function loadDockerConfig(options: DockerConfigOptions): DockerConfig;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/docker/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGvC,MAAM,WAAW,mBAAmB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B;AAwLD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAyH3E"}

package/dist/docker/config.js

@@ -0,0 +1,183 @@
+import * as fs from "fs";
+import * as path from "path";
+import { createRequire } from "module";
+const DEFAULTS = {
+    docker: {
+        image: "archlast/server",
+        tag: "latest",
+        containerName: "archlast-server",
+        volumeName: "archlast-data",
+    },
+    server: {
+        port: 4000,
+    },
+    paths: {
+        config: ".archlast/config",
+        deploy: ".archlast-deploy",
+    },
+    cors: {
+        origins: ["http://localhost:3000"],
+    },
+    env: {
+        NODE_ENV: "development",
+        ARCHLAST_LOG_LEVEL: "info",
+        ARCHLAST_DB_ROOT: "/data",
+        STORAGE_ROOT: "/data/storage",
+        ARCHLAST_DASHBOARD_PORT: "4001",
+        ARCHLAST_STORE_PORT: "7001",
+        ARCHLAST_STORE_NO_TLS: "false",
+    },
+};
+const ENV_PREFIXES = ["ARCHLAST_", "S3_", "AWS_", "STORAGE_"];
+const ENV_KEYS = ["NODE_ENV", "BETTER_AUTH_SECRET"];
+function pickEnv(source) {
+    const result = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (!value)
+            continue;
+        if (ENV_KEYS.includes(key)) {
+            result[key] = value;
+            continue;
+        }
+        if (ENV_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function parseEnvFile(filePath) {
+    const env = {};
+    const contents = fs.readFileSync(filePath, "utf-8");
+    const lines = contents.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const index = trimmed.indexOf("=");
+        if (index === -1)
+            continue;
+        const key = trimmed.slice(0, index).trim();
+        let value = trimmed.slice(index + 1).trim();
+        if ((value.startsWith("\"") && value.endsWith("\"")) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        env[key] = value;
+    }
+    return env;
+}
+function findEnvFile(projectPath) {
+    const localEnv = path.join(projectPath, ".env.local");
+    if (fs.existsSync(localEnv)) {
+        return localEnv;
+    }
+    const envPath = path.join(projectPath, ".env");
+    if (fs.existsSync(envPath)) {
+        return envPath;
+    }
+    return undefined;
+}
+function loadConfigFile(configPath) {
+    const require = createRequire(import.meta.url);
+    try {
+        const loaded = require(configPath);
+        return (loaded && loaded.default) || loaded || {};
+    }
+    catch (error) {
+        return {};
+    }
+}
+function resolvePath(projectPath, value) {
+    if (path.isAbsolute(value)) {
+        return value;
+    }
+    return path.resolve(projectPath, value);
+}
+function resolveNumber(value, fallback) {
+    if (value === undefined || value === null) {
+        return fallback;
+    }
+    const parsed = typeof value === "number" ? value : parseInt(String(value), 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+export function loadDockerConfig(options) {
+    const projectPath = path.resolve(options.path || ".");
+    const configFilePath = options.configFile
+        ? resolvePath(projectPath, options.configFile)
+        : path.join(projectPath, "archlast.config.js");
+    const hasConfigFile = fs.existsSync(configFilePath);
+    const configFile = hasConfigFile ? loadConfigFile(configFilePath) : {};
+    const envFilePath = findEnvFile(projectPath);
+    const envFileVars = envFilePath ? parseEnvFile(envFilePath) : {};
+    const configDocker = configFile.docker || {};
+    const configServer = configFile.server || {};
+    const configPaths = configFile.paths || {};
+    const configCors = configFile.cors || {};
+    const configEnv = configFile.env || {};
+    const port = resolveNumber(options.port ??
+        process.env.ARCHLAST_PORT ??
+        configServer.port ??
+        envFileVars.ARCHLAST_PORT, DEFAULTS.server.port);
+    const image = options.image ??
+        process.env.ARCHLAST_DOCKER_IMAGE ??
+        process.env.ARCHLAST_IMAGE ??
+        configDocker.image ??
+        envFileVars.ARCHLAST_DOCKER_IMAGE ??
+        envFileVars.ARCHLAST_IMAGE ??
+        DEFAULTS.docker.image;
+    const tag = options.tag ??
+        process.env.ARCHLAST_VERSION ??
+        configDocker.tag ??
+        envFileVars.ARCHLAST_VERSION ??
+        DEFAULTS.docker.tag;
+    const containerName = options.containerName ??
+        process.env.ARCHLAST_CONTAINER_NAME ??
+        configDocker.containerName ??
+        envFileVars.ARCHLAST_CONTAINER_NAME ??
+        DEFAULTS.docker.containerName;
+    const dataVolumeName = process.env.ARCHLAST_DATA_VOLUME ??
+        configDocker.volumeName ??
+        envFileVars.ARCHLAST_DATA_VOLUME ??
+        DEFAULTS.docker.volumeName;
+    const configDir = resolvePath(projectPath, process.env.ARCHLAST_CONFIG_DIR ??
+        configPaths.config ??
+        envFileVars.ARCHLAST_CONFIG_DIR ??
+        DEFAULTS.paths.config);
+    const deployDir = resolvePath(projectPath, process.env.ARCHLAST_DEPLOY_DIR ??
+        configPaths.deploy ??
+        envFileVars.ARCHLAST_DEPLOY_DIR ??
+        DEFAULTS.paths.deploy);
+    const envFromDefaults = { ...DEFAULTS.env };
+    const envFromFile = pickEnv(envFileVars);
+    const envFromConfig = pickEnv(configEnv);
+    const envFromProcess = pickEnv(process.env);
+    const env = {
+        ...envFromDefaults,
+        ...envFromFile,
+        ...envFromConfig,
+        ...envFromProcess,
+    };
+    env.PORT = String(port);
+    env.ARCHLAST_PORT = env.ARCHLAST_PORT ?? String(port);
+    if (!env.ARCHLAST_ALLOWED_ORIGINS) {
+        const origins = configCors.origins?.length ? configCors.origins : DEFAULTS.cors.origins;
+        env.ARCHLAST_ALLOWED_ORIGINS = origins.join(",");
+    }
+    if (!env.NODE_ENV) {
+        env.NODE_ENV = DEFAULTS.env.NODE_ENV;
+    }
+    return {
+        projectPath,
+        image,
+        tag,
+        containerName,
+        port,
+        dataVolumeName,
+        configDir,
+        deployDir,
+        composePath: path.join(projectPath, ".archlast", "docker-compose.yml"),
+        env,
+        configFilePath: hasConfigFile ? configFilePath : undefined,
+        envFilePath,
+    };
+}

package/dist/docker/manager.d.ts

@@ -0,0 +1,19 @@
+import Docker from "dockerode";
+import { DockerConfig, DockerContainerStatus, DockerLogsOptions } from "./types";
+export declare class DockerManager {
+    private docker;
+    constructor(docker?: Docker);
+    checkAvailable(): Promise<boolean>;
+    pullImage(imageTag: string, onProgress?: (event: Record<string, unknown>) => void): Promise<void>;
+    ensureImage(imageTag: string): Promise<void>;
+    ensureVolume(volumeName: string): Promise<void>;
+    start(config: DockerConfig): Promise<void>;
+    stop(containerName: string): Promise<boolean>;
+    restart(config: DockerConfig): Promise<void>;
+    restartContainer(containerName: string): Promise<boolean>;
+    status(containerName: string): Promise<DockerContainerStatus>;
+    logs(containerName: string, options?: DockerLogsOptions): Promise<NodeJS.ReadableStream>;
+    demuxStream(stream: NodeJS.ReadableStream, stdout: NodeJS.WritableStream, stderr: NodeJS.WritableStream): void;
+    private fetchStats;
+}
+//# sourceMappingURL=manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/docker/manager.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjF,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,CAAC,EAAE,MAAM;IAIrB,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IASlC,SAAS,CACX,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACtD,OAAO,CAAC,IAAI,CAAC;IAkBV,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5C,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/C,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAiE1C,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB7C,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5C,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAazD,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA+B7D,IAAI,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,iBAAsB,GAChC,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC;IAwBjC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI;YAIhG,UAAU;CAmC3B"}