@archlast/cli 0.0.1

package/dist/commands/generate.js

@@ -0,0 +1,100 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { Command } from "commander";
+import { TypeGenerator } from "../generator";
+/**
+ * Generate CRUD handlers for a collection
+ * Creates a re-export wrapper file in src/functions/
+ */
+async function generateCrudCommandAction(options) {
+    const archlastPath = options.path || ".";
+    const collection = options.collection;
+    const linked = options.linked !== false; // default to linked
+    console.log(chalk.blue.bold("🔧 Archlast Generate CRUD\n"));
+    const spinner = ora("Generating CRUD handler...").start();
+    try {
+        // Validate collection exists by checking schema
+        const schemaPath = path.join(archlastPath, "src", "schema.ts");
+        const schemaIndexPath = path.join(archlastPath, "src", "schema", "index.ts");
+        let schemaContent = "";
+        let schemaFilePath = "";
+        if (fs.existsSync(schemaPath)) {
+            schemaContent = fs.readFileSync(schemaPath, "utf-8");
+            schemaFilePath = schemaPath;
+        }
+        else if (fs.existsSync(schemaIndexPath)) {
+            schemaContent = fs.readFileSync(schemaIndexPath, "utf-8");
+            schemaFilePath = schemaIndexPath;
+        }
+        else {
+            spinner.fail(chalk.red("Schema file not found"));
+            console.error(chalk.red("Expected schema.ts at src/schema.ts or src/schema/index.ts"));
+            process.exit(1);
+        }
+        // Check if collection exists in schema
+        const collectionPattern = new RegExp(`(?:export\\s+(?:const|let)\\s+)?${collection}\\s*(?::\\s*\\w+)?\\s*[:=]\\s*defineTable`, "g");
+        if (!collectionPattern.test(schemaContent)) {
+            spinner.fail(chalk.red(`Collection "${collection}" not found in schema`));
+            console.error(chalk.red(`Please define the collection in ${schemaFilePath} first`));
+            process.exit(1);
+        }
+        const functionsDir = path.join(archlastPath, "src", "functions");
+        const targetFilePath = path.join(functionsDir, `${collection}.ts`);
+        // Ensure functions directory exists
+        if (!fs.existsSync(functionsDir)) {
+            fs.mkdirSync(functionsDir, { recursive: true });
+        }
+        // Check if file already exists
+        if (fs.existsSync(targetFilePath) && !options.force) {
+            spinner.fail(chalk.red(`File already exists: ${targetFilePath}`));
+            console.error(chalk.red("Use --force to overwrite"));
+            process.exit(1);
+        }
+        if (linked) {
+            // Generate linked (re-export) version
+            const pascalName = collection.charAt(0).toUpperCase() + collection.slice(1);
+            const content = `// Auto-generated CRUD re-export for "${collection}"
+// This file links to the auto-generated handlers in _generated/crud
+// Re-run "archlast generate crud ${collection}" to regenerate
+
+export * from "../_generated/crud/${collection}";
+
+// You can also import specific handlers:
+// import { list${pascalName}, get${pascalName}, create${pascalName}, update${pascalName}, delete${pascalName} } from "../_generated/crud/${collection}";
+`;
+            fs.writeFileSync(targetFilePath, content, "utf-8");
+            spinner.succeed(chalk.green(`✅ Created linked CRUD file: ${targetFilePath}`));
+            console.log(chalk.gray("\nLinked mode: This file re-exports auto-generated handlers."));
+            console.log(chalk.gray("When schema changes, run 'archlast dev' to regenerate _generated/crud.\n"));
+        }
+        else {
+            // Generate ejected (standalone) version
+            const generator = new TypeGenerator(archlastPath);
+            const handlerCode = generator.generateCrudHandlerForTable(collection);
+            fs.writeFileSync(targetFilePath, handlerCode, "utf-8");
+            spinner.succeed(chalk.green(`✅ Created ejected CRUD file: ${targetFilePath}`));
+            console.log(chalk.gray("\nEjected mode: This file contains standalone code."));
+            console.log(chalk.gray("You can modify it, but schema changes won't auto-update.\n"));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Generation failed"));
+        console.error(error);
+        process.exit(1);
+    }
+}
+/**
+ * Generate command with CRUD subcommand
+ */
+export const generateCommand = new Command("generate")
+    .description("Generate code from schema")
+    .command("crud")
+    .description("Generate CRUD handlers for a collection")
+    .argument("<collection>", "Name of the collection")
+    .option("--path <path>", "Path to archlast folder", ".")
+    .option("--force", "Overwrite existing file")
+    .option("--linked", "Generate linked (re-export) file (default)", true)
+    .option("--ejected", "Generate ejected (standalone) file")
+    .action(generateCrudCommandAction);

package/dist/commands/init.d.ts

@@ -0,0 +1,7 @@
+interface InitOptions {
+    path?: string;
+    name?: string;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAMA,UAAU,WAAW;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAqHD,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAoDrE"}

package/dist/commands/logs.d.ts

@@ -0,0 +1,10 @@
+interface LogsOptions {
+    path?: string;
+    container?: string;
+    tail?: string;
+    follow?: boolean;
+    config?: string;
+}
+export declare function logsCommand(options: LogsOptions): Promise<void>;
+export {};
+//# sourceMappingURL=logs.d.ts.map

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

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

package/dist/commands/logs.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import { DockerManager } from "../docker/manager";
+import { loadDockerConfig } from "../docker/config";
+export async function logsCommand(options) {
+    console.log(chalk.blue.bold("Archlast Docker Logs\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);
+    }
+    let stream;
+    try {
+        stream = await manager.logs(config.containerName, {
+            follow: options.follow ?? true,
+            tail: options.tail ?? "100",
+        });
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to read container logs."));
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        process.exit(1);
+        return;
+    }
+    manager.demuxStream(stream, process.stdout, process.stderr);
+    const shutdown = () => {
+        stream.destroy();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,16 @@
+interface PullOptions {
+    path?: string;
+    server?: string;
+    files?: string[];
+    force?: boolean;
+    diff?: boolean;
+    merge?: boolean;
+    smart?: boolean;
+    tag?: string;
+    image?: string;
+    docker?: boolean;
+    version?: string;
+}
+export declare function pullCommand(options: PullOptions): Promise<void>;
+export {};
+//# sourceMappingURL=pull.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../src/commands/pull.ts"],"names":[],"mappings":"AAcA,UAAU,WAAW;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AA6GD,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAoOrE"}

package/dist/commands/pull.js

@@ -0,0 +1,415 @@
+import * as fs from "fs";
+import * as path from "path";
+import { createRequire } from "module";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+import { diffLines } from "diff";
+import { glob } from "glob";
+import { getAuthHeaders, hashFile } from "../auth.js";
+import { DockerManager } from "../docker/manager";
+import { loadDockerConfig } from "../docker/config";
+const require = createRequire(import.meta.url);
+/**
+ * Compute local file hashes for smart diff
+ */
+function computeLocalHashes(archlastPath) {
+    const hashes = {};
+    // Common source files to check
+    const patterns = [
+        "src/**/*.ts",
+        "schema.ts",
+    ].map(p => path.join(archlastPath, p).replace(/\\/g, "/"));
+    for (const pattern of patterns) {
+        const files = glob.sync(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/*.d.ts"],
+            windowsPathsNoEscape: true,
+        });
+        for (const file of files) {
+            const relativePath = path.relative(archlastPath, file).replace(/\\/g, "/");
+            hashes[relativePath] = hashFile(file);
+        }
+    }
+    return hashes;
+}
+/**
+ * Display changes summary
+ */
+function displayChangesSummary(metadata) {
+    console.log(chalk.bold("\n📊 Changes Summary:\n"));
+    const fileChanges = metadata.files.filter(f => f.status !== "unchanged");
+    if (fileChanges.length === 0) {
+        console.log(chalk.gray("  No file changes detected"));
+    }
+    else {
+        const grouped = {
+            added: fileChanges.filter(f => f.status === "added"),
+            modified: fileChanges.filter(f => f.status === "modified"),
+            removed: fileChanges.filter(f => f.status === "removed"),
+        };
+        if (grouped.added.length > 0) {
+            console.log(chalk.green(`  + ${grouped.added.length} added:`));
+            for (const f of grouped.added.slice(0, 5)) {
+                console.log(chalk.green(`      ${f.filePath}`));
+            }
+            if (grouped.added.length > 5) {
+                console.log(chalk.green(`      ... and ${grouped.added.length - 5} more`));
+            }
+        }
+        if (grouped.modified.length > 0) {
+            console.log(chalk.yellow(`  ~ ${grouped.modified.length} modified:`));
+            for (const f of grouped.modified.slice(0, 5)) {
+                console.log(chalk.yellow(`      ${f.filePath}`));
+            }
+            if (grouped.modified.length > 5) {
+                console.log(chalk.yellow(`      ... and ${grouped.modified.length - 5} more`));
+            }
+        }
+        if (grouped.removed.length > 0) {
+            console.log(chalk.red(`  - ${grouped.removed.length} removed:`));
+            for (const f of grouped.removed.slice(0, 5)) {
+                console.log(chalk.red(`      ${f.filePath}`));
+            }
+            if (grouped.removed.length > 5) {
+                console.log(chalk.red(`      ... and ${grouped.removed.length - 5} more`));
+            }
+        }
+    }
+    console.log();
+}
+export async function pullCommand(options) {
+    if (options.docker || options.tag || options.image || options.version) {
+        await pullDockerImage(options);
+        return;
+    }
+    const archlastPath = path.resolve(options.path || ".");
+    const serverUrl = (options.server || "http://localhost:4000").replace(/\/$/, "");
+    const force = options.force || false;
+    const showDiff = options.diff || false;
+    const attemptMerge = options.merge || false;
+    const smartPull = options.smart !== false; // Smart pull is default
+    console.log(chalk.blue.bold("📥 Archlast Pull\n"));
+    try {
+        // Compute local hashes for smart diff detection
+        const localHashes = smartPull ? computeLocalHashes(archlastPath) : {};
+        // Build query parameters
+        const queryParams = new URLSearchParams();
+        if (options.files) {
+            queryParams.set("files", options.files.join(","));
+        }
+        if (smartPull && Object.keys(localHashes).length > 0) {
+            queryParams.set("hashes", JSON.stringify(localHashes));
+            queryParams.set("changes", "true"); // Only fetch changed files
+        }
+        const url = `${serverUrl}/_archlast/pull?${queryParams.toString()}`;
+        console.log(chalk.gray(`Fetching from: ${serverUrl}`));
+        if (smartPull) {
+            console.log(chalk.gray(`Smart pull enabled with ${Object.keys(localHashes).length} local files`));
+        }
+        const headers = {
+            "Content-Type": "application/json",
+            ...getAuthHeaders(archlastPath),
+        };
+        const response = await fetch(url, {
+            method: "GET",
+            signal: AbortSignal.timeout(30000),
+            headers,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(chalk.red(`Pull failed: ${response.status} ${response.statusText}`));
+            console.error(chalk.gray(errorText));
+            console.log(chalk.yellow("\nCurl example:"));
+            console.log(chalk.gray(`curl -X GET "${url}"`));
+            process.exit(1);
+        }
+        const result = (await response.json());
+        // Check if we have metadata (smart pull response)
+        if (result.metadata) {
+            displayChangesSummary(result.metadata);
+            if (!result.metadata.hasChanges) {
+                console.log(chalk.green("✅ Everything is up to date!\n"));
+                return;
+            }
+            // Confirm pull if not forced
+            if (!force) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "proceed",
+                        message: `Pull ${result.files.length} file(s)?`,
+                        default: true,
+                    },
+                ]);
+                if (!answer.proceed) {
+                    console.log(chalk.yellow("\nPull cancelled"));
+                    return;
+                }
+            }
+        }
+        if (!result.files || result.files.length === 0) {
+            console.log(chalk.green("✅ No files to pull"));
+            return;
+        }
+        console.log(chalk.gray(`\nReceived ${result.files.length} file(s)\n`));
+        let applyAll = force;
+        let quit = false;
+        for (const file of result.files) {
+            const localPath = path.join(archlastPath, file.filePath);
+            const localDir = path.dirname(localPath);
+            if (!fs.existsSync(localDir)) {
+                fs.mkdirSync(localDir, { recursive: true });
+            }
+            const localExists = fs.existsSync(localPath);
+            if (showDiff && localExists) {
+                const localCode = fs.readFileSync(localPath, "utf-8");
+                const diff = diffLines(localCode, file.code);
+                console.log(chalk.cyan(`\nDiff for ${file.filePath}:\n`));
+                diff.forEach((part) => {
+                    if (part.added) {
+                        process.stdout.write(chalk.green(part.value));
+                    }
+                    else if (part.removed) {
+                        process.stdout.write(chalk.red(part.value));
+                    }
+                    else {
+                        process.stdout.write(part.value);
+                    }
+                });
+                console.log();
+                continue;
+            }
+            if (attemptMerge && file.filePath.endsWith("schema.ts") && localExists) {
+                const mergedCode = await mergeSchema(localPath, file.code);
+                if (mergedCode !== null) {
+                    fs.writeFileSync(localPath, mergedCode, "utf-8");
+                    console.log(chalk.green(`✅ Merged ${file.filePath}`));
+                    continue;
+                }
+            }
+            if (localExists && !applyAll) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: "list",
+                        name: "action",
+                        message: `Overwrite ${chalk.yellow(file.filePath)}?`,
+                        choices: ["yes", "no", "yes to all", "quit", "diff"],
+                        default: "yes",
+                    },
+                ]);
+                if (answer.action === "quit") {
+                    console.log(chalk.yellow("\nPull cancelled"));
+                    quit = true;
+                    break;
+                }
+                if (answer.action === "no") {
+                    console.log(chalk.gray(`Skipped ${file.filePath}`));
+                    continue;
+                }
+                if (answer.action === "diff") {
+                    const localCode = fs.readFileSync(localPath, "utf-8");
+                    const diff = diffLines(localCode, file.code);
+                    console.log(chalk.cyan(`\nDiff for ${file.filePath}:\n`));
+                    diff.forEach((part) => {
+                        if (part.added) {
+                            process.stdout.write(chalk.green(part.value));
+                        }
+                        else if (part.removed) {
+                            process.stdout.write(chalk.red(part.value));
+                        }
+                        else {
+                            process.stdout.write(part.value);
+                        }
+                    });
+                    console.log();
+                    // Ask again after showing diff
+                    const diffAnswer = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "action",
+                            message: `Overwrite ${chalk.yellow(file.filePath)}?`,
+                            choices: ["yes", "no", "yes to all", "quit"],
+                            default: "yes",
+                        },
+                    ]);
+                    if (diffAnswer.action === "quit") {
+                        quit = true;
+                        break;
+                    }
+                    if (diffAnswer.action === "no") {
+                        console.log(chalk.gray(`Skipped ${file.filePath}`));
+                        continue;
+                    }
+                    if (diffAnswer.action === "yes to all") {
+                        applyAll = true;
+                    }
+                }
+                if (answer.action === "yes to all") {
+                    applyAll = true;
+                }
+                fs.writeFileSync(localPath, file.code, "utf-8");
+                console.log(chalk.green(`✅ Pulled ${file.filePath}`));
+            }
+            else {
+                fs.writeFileSync(localPath, file.code, "utf-8");
+                console.log(chalk.green(`✅ Pulled ${file.filePath}`));
+            }
+        }
+        if (quit) {
+            process.exit(0);
+        }
+        console.log(chalk.green("\n✨ Pull complete!\n"));
+        // Show summary of what was pulled
+        if (result.metadata) {
+            const added = result.metadata.files.filter(f => f.status === "added").length;
+            const modified = result.metadata.files.filter(f => f.status === "modified").length;
+            if (added > 0 || modified > 0) {
+                console.log(chalk.gray(`  Added: ${added} file(s)`));
+                console.log(chalk.gray(`  Modified: ${modified} file(s)`));
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.red("Pull failed"));
+        if (error instanceof Error) {
+            console.error(error.message);
+        }
+        else {
+            console.error(String(error));
+        }
+        process.exit(1);
+    }
+}
+async function pullDockerImage(options) {
+    console.log(chalk.blue.bold("Archlast Docker Pull\n"));
+    const config = loadDockerConfig({
+        path: options.path,
+        image: options.image,
+        tag: options.tag ?? options.version,
+    });
+    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, (event) => {
+            if (event?.status) {
+                const progress = event.progress ? ` ${event.progress}` : "";
+                spinner.text = `${event.status}${progress}`;
+            }
+        });
+        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);
+    }
+}
+async function mergeSchema(localPath, remoteCode) {
+    try {
+        const { Project } = await import("ts-morph");
+        const project = new Project();
+        const localSourceFile = project.addSourceFileAtPath(localPath);
+        const remoteSourceFile = project.createSourceFile("remote.ts", remoteCode);
+        const localTables = extractTableNames(localSourceFile);
+        const remoteTables = extractTableNames(remoteSourceFile);
+        const newTables = remoteTables.filter((t) => !localTables.includes(t));
+        if (newTables.length === 0) {
+            console.log(chalk.gray("No new tables to merge"));
+            return null;
+        }
+        console.log(chalk.gray(`Found ${newTables.length} new table(s): ${newTables.join(", ")}`));
+        const localLines = remoteCode.split("\n");
+        const mergedLines = [...localLines];
+        const schemaLineIndex = localLines.findIndex((line) => line.includes("defineSchema("));
+        if (schemaLineIndex === -1) {
+            console.log(chalk.yellow("Could not find defineSchema call"));
+            return null;
+        }
+        const closingBraceIndex = findClosingBraceIndex(localLines, schemaLineIndex);
+        for (const table of newTables) {
+            const tableDef = `  ${table}: defineTable({
+    id: v.id(),
+  }),`;
+            mergedLines.splice(closingBraceIndex, 0, tableDef);
+        }
+        return mergedLines.join("\n");
+    }
+    catch (error) {
+        console.error(chalk.red("Merge failed"));
+        if (error instanceof Error) {
+            console.error(error.message);
+        }
+        return null;
+    }
+}
+function extractTableNames(sourceFile) {
+    const tables = [];
+    try {
+        const { SyntaxKind } = require("ts-morph");
+        const variableStmts = sourceFile.getVariableStatements();
+        for (const stmt of variableStmts) {
+            const name = stmt.getName();
+            if (!name)
+                continue;
+            const initializer = stmt.getInitializer();
+            if (!initializer)
+                continue;
+            if (initializer.getKind() === SyntaxKind.CallExpression) {
+                const callExpr = initializer;
+                const expr = callExpr.getExpression();
+                if (expr && expr.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                    const objLit = expr;
+                    for (const prop of objLit.getProperties()) {
+                        if (prop.getKind() === SyntaxKind.PropertyAssignment) {
+                            const propAssign = prop;
+                            const propName = propAssign.getName();
+                            if (propName === "tables") {
+                                const propValue = propAssign.getInitializer();
+                                if (propValue &&
+                                    propValue.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                                    const tablesObj = propValue;
+                                    for (const tableProp of tablesObj.getProperties()) {
+                                        if (tableProp.getKind() === SyntaxKind.PropertyAssignment) {
+                                            const tablePropAssign = tableProp;
+                                            const tableName = tablePropAssign.getName();
+                                            if (tableName) {
+                                                tables.push(tableName);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.yellow(`Warning: Could not parse schema: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    return tables;
+}
+function findClosingBraceIndex(lines, startIndex) {
+    let braceCount = 0;
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+            if (char === "{")
+                braceCount++;
+            if (char === "}")
+                braceCount--;
+            if (braceCount === 0)
+                return i;
+        }
+    }
+    return lines.length - 1;
+}

package/dist/commands/restart.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"restart.d.ts","sourceRoot":"","sources":["../../src/commands/restart.ts"],"names":[],"mappings":"AAMA,UAAU,cAAc;IACpB,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,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAkD3E"}

package/dist/commands/restart.js

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import ora from "ora";
+import { DockerManager } from "../docker/manager";
+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 restartCommand(options) {
+    console.log(chalk.blue.bold("Archlast Docker Restart\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."));
+        process.exit(1);
+    }
+    const spinner = ora(`Restarting ${config.containerName}...`).start();
+    try {
+        await manager.restart(config);
+        const healthy = await waitForHealth(config.port, HEALTH_TIMEOUT_MS);
+        if (!healthy) {
+            spinner.warn("Container restarted, but health check did not pass within 60 seconds.");
+        }
+        else {
+            spinner.succeed("Archlast container restarted.");
+        }
+    }
+    catch (error) {
+        spinner.fail("Failed to restart 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`));
+}