@orkify/cli 1.0.0-beta.5

package/dist/deploy/CommandPoller.d.ts

@@ -0,0 +1,13 @@
+import type { Orchestrator } from '../daemon/Orchestrator.js';
+import type { TelemetryReporter } from '../telemetry/TelemetryReporter.js';
+import type { TelemetryConfig } from '../types/index.js';
+export declare class CommandPoller {
+    private config;
+    private orchestrator;
+    private telemetry;
+    private polling;
+    constructor(config: TelemetryConfig, orchestrator: Orchestrator, telemetry: TelemetryReporter);
+    start(): void;
+    fetchAndExecute(): Promise<void>;
+}
+//# sourceMappingURL=CommandPoller.d.ts.map

package/dist/deploy/CommandPoller.js

@@ -0,0 +1,53 @@
+import { hostname } from 'node:os';
+import { getAgentName } from '../agent-name.js';
+import { DeployExecutor } from './DeployExecutor.js';
+export class CommandPoller {
+    config;
+    orchestrator;
+    telemetry;
+    polling = false;
+    constructor(config, orchestrator, telemetry) {
+        this.config = config;
+        this.orchestrator = orchestrator;
+        this.telemetry = telemetry;
+    }
+    start() {
+        this.telemetry.on('commands:pending', () => {
+            void this.fetchAndExecute();
+        });
+    }
+    async fetchAndExecute() {
+        if (this.polling)
+            return;
+        this.polling = true;
+        try {
+            const hn = hostname();
+            const agentName = getAgentName();
+            const response = await fetch(`${this.config.apiHost}/api/v1/deploy/commands?hostname=${encodeURIComponent(hn)}&agentName=${encodeURIComponent(agentName)}`, {
+                headers: { Authorization: `Bearer ${this.config.apiKey}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!response.ok) {
+                console.error(`Command poll failed: ${response.status}`);
+                return;
+            }
+            const body = (await response.json());
+            for (const cmd of body.commands) {
+                if (cmd.type === 'deploy') {
+                    const executor = new DeployExecutor(this.config, this.orchestrator, this.telemetry, cmd);
+                    // Execute asynchronously — status reported via telemetry
+                    executor.execute().catch((err) => {
+                        console.error(`Deploy execution error: ${err.message}`);
+                    });
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Command poll error: ${err.message}`);
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+}
+//# sourceMappingURL=CommandPoller.js.map

package/dist/deploy/DeployExecutor.d.ts

@@ -0,0 +1,33 @@
+import type { Orchestrator } from '../daemon/Orchestrator.js';
+import type { TelemetryReporter } from '../telemetry/TelemetryReporter.js';
+import type { DeployCommand, DeployOptions, TelemetryConfig } from '../types/index.js';
+export declare class DeployExecutor {
+    private config;
+    private orchestrator;
+    private telemetry;
+    private cmd;
+    private options;
+    private buildLog;
+    private buildLogLines;
+    private nextDeploymentId;
+    private onProgress?;
+    private onOutput?;
+    constructor(config: TelemetryConfig, orchestrator: Orchestrator, telemetry: TelemetryReporter, cmd: DeployCommand, options?: DeployOptions);
+    setProgressCallback(cb: (phase: string, error?: string) => void): void;
+    setOutputCallback(cb: (line: string) => void): void;
+    execute(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    private reportPhase;
+    private download;
+    private verifySha256;
+    private extract;
+    private fetchSecrets;
+    private runCommand;
+    private swapSymlink;
+    private monitorCrashWindow;
+    private reconcileProcesses;
+    private cleanupOldReleases;
+}
+//# sourceMappingURL=DeployExecutor.d.ts.map

package/dist/deploy/DeployExecutor.js

@@ -0,0 +1,340 @@
+import { execSync, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { copyFileSync, createReadStream, createWriteStream, existsSync, mkdirSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { DEPLOY_CRASH_WINDOW_DEFAULT, DEPLOY_META_FILE, ORKIFY_DEPLOYS_DIR } from '../constants.js';
+import { detectFramework } from '../detect/framework.js';
+import { getOrkifyConfig } from './config.js';
+export class DeployExecutor {
+    config;
+    orchestrator;
+    telemetry;
+    cmd;
+    options;
+    buildLog = '';
+    buildLogLines = [];
+    nextDeploymentId;
+    onProgress;
+    onOutput;
+    constructor(config, orchestrator, telemetry, cmd, options) {
+        this.config = config;
+        this.orchestrator = orchestrator;
+        this.telemetry = telemetry;
+        this.cmd = cmd;
+        this.options = options ?? {};
+    }
+    setProgressCallback(cb) {
+        this.onProgress = cb;
+    }
+    setOutputCallback(cb) {
+        this.onOutput = cb;
+    }
+    async execute() {
+        const deployConfig = this.cmd.deployConfig;
+        const deploysDir = this.options.deploysDir ?? ORKIFY_DEPLOYS_DIR;
+        const releaseName = this.options.localTarball
+            ? `local-${this.cmd.version}`
+            : `${this.cmd.version}-${this.cmd.artifactId.slice(0, 8)}`;
+        const releasesDir = join(deploysDir, 'releases');
+        const releaseDir = join(releasesDir, releaseName);
+        const currentLink = join(deploysDir, 'current');
+        try {
+            mkdirSync(releasesDir, { recursive: true });
+            // 1. Download or copy local tarball
+            this.reportPhase('downloading');
+            const tarPath = join(releasesDir, `v${this.cmd.version}.tar.gz`);
+            if (this.options.localTarball) {
+                copyFileSync(this.options.localTarball, tarPath);
+            }
+            else {
+                await this.download(this.cmd.downloadUrl, tarPath);
+                await this.verifySha256(tarPath, this.cmd.sha256);
+            }
+            // 2. Extract
+            this.reportPhase('extracting');
+            mkdirSync(releaseDir, { recursive: true });
+            await this.extract(tarPath, releaseDir);
+            unlinkSync(tarPath);
+            // 2b. Write deploy metadata (used by restore to identify the current release)
+            writeFileSync(join(releaseDir, DEPLOY_META_FILE), JSON.stringify({
+                version: this.cmd.version,
+                artifactId: this.cmd.artifactId,
+            }), 'utf-8');
+            // 2c. Detect Next.js for version skew protection
+            if (detectFramework(releaseDir) === 'nextjs') {
+                this.nextDeploymentId = `v${this.cmd.version}-${this.cmd.artifactId.slice(0, 8)}`;
+            }
+            // 3. Fetch secrets
+            const secrets = this.options.secrets !== undefined
+                ? this.options.secrets
+                : await this.fetchSecrets(this.cmd.downloadToken);
+            // 4. Install + 5. Build
+            const buildEnv = { ...secrets, ...deployConfig.buildEnv };
+            // Pass NEXT_DEPLOYMENT_ID to build (unless user already set it)
+            if (this.nextDeploymentId && !buildEnv.NEXT_DEPLOYMENT_ID) {
+                buildEnv.NEXT_DEPLOYMENT_ID = this.nextDeploymentId;
+            }
+            if (!this.options.skipInstall) {
+                this.reportPhase('installing');
+                await this.runCommand(deployConfig.install, releaseDir, buildEnv);
+            }
+            if (!this.options.skipBuild && deployConfig.build) {
+                this.reportPhase('building');
+                await this.runCommand(deployConfig.build, releaseDir, buildEnv);
+            }
+            // 6. Swap symlink
+            let previousDir = null;
+            if (existsSync(currentLink)) {
+                try {
+                    previousDir = readlinkSync(currentLink);
+                }
+                catch {
+                    // Not a symlink
+                }
+            }
+            this.reportPhase('reloading');
+            this.swapSymlink(currentLink, releaseDir);
+            // 7. Reconcile processes
+            await this.reconcileProcesses(currentLink, secrets);
+            // 8. Monitor crash window
+            if (!this.options.skipMonitor) {
+                this.reportPhase('monitoring');
+                const crashWindow = deployConfig.crashWindow ?? DEPLOY_CRASH_WINDOW_DEFAULT;
+                const healthy = await this.monitorCrashWindow(crashWindow);
+                if (!healthy) {
+                    if (previousDir && existsSync(previousDir)) {
+                        this.swapSymlink(currentLink, previousDir);
+                        await this.reconcileProcesses(currentLink, secrets);
+                        this.reportPhase('rolled_back', 'Workers crashed within monitoring window');
+                        return {
+                            success: false,
+                            error: 'Workers crashed within monitoring window, rolled back',
+                        };
+                    }
+                    else {
+                        const msg = 'Workers crashed and no previous version to rollback to';
+                        this.reportPhase('failed', msg);
+                        return { success: false, error: msg };
+                    }
+                }
+            }
+            // 9. Success — health checks are now handled per-process during reconcile/reload
+            this.reportPhase('success');
+            // 10. Cleanup old releases (preserve the previous version for rollback)
+            this.cleanupOldReleases(releasesDir, 3, previousDir);
+            return { success: true };
+        }
+        catch (err) {
+            const message = err.message;
+            this.reportPhase('failed', message);
+            return { success: false, error: message };
+        }
+    }
+    reportPhase(phase, error) {
+        console.log(`[deploy] v${this.cmd.version}: ${phase}${error ? ` — ${error}` : ''}`);
+        this.onProgress?.(phase, error);
+        if (this.options.skipTelemetry)
+            return;
+        const status = {
+            deployId: this.cmd.deployId,
+            targetId: this.cmd.targetId,
+            phase,
+            buildLog: this.buildLog.slice(-5000),
+            error,
+        };
+        this.telemetry.setDeployStatus(status);
+        // Emit deploy lifecycle events for SSE streaming.
+        // Fields must be nested inside `details` so they survive Zod parsing
+        // on the ingest endpoint and end up in the ClickHouse details column.
+        if (phase === 'downloading') {
+            this.telemetry.emitEvent('process:deploy-started', 'deploy', {
+                details: { deployId: this.cmd.deployId, targetId: this.cmd.targetId },
+            });
+        }
+        else if (phase === 'success') {
+            this.telemetry.emitEvent('process:deploy-finished', 'deploy', {
+                details: { deployId: this.cmd.deployId, targetId: this.cmd.targetId },
+            });
+        }
+        else if (phase === 'failed' || phase === 'rolled_back') {
+            this.telemetry.emitEvent('process:deploy-failed', 'deploy', {
+                details: {
+                    deployId: this.cmd.deployId,
+                    targetId: this.cmd.targetId,
+                    error: error ?? phase,
+                },
+            });
+        }
+    }
+    async download(url, destPath) {
+        const response = await fetch(url);
+        if (!response.ok || !response.body) {
+            throw new Error(`Download failed: ${response.status}`);
+        }
+        const fileStream = createWriteStream(destPath);
+        const nodeStream = Readable.fromWeb(response.body);
+        await pipeline(nodeStream, fileStream);
+    }
+    async verifySha256(filePath, expected) {
+        const hash = createHash('sha256');
+        const stream = createReadStream(filePath);
+        for await (const chunk of stream) {
+            hash.update(chunk);
+        }
+        const actual = hash.digest('hex');
+        if (actual !== expected) {
+            throw new Error(`SHA-256 mismatch: expected ${expected.slice(0, 12)}..., got ${actual.slice(0, 12)}...`);
+        }
+    }
+    extract(tarPath, destDir) {
+        execSync(`tar xzf "${tarPath}" -C "${destDir}"`, { stdio: 'pipe' });
+    }
+    async fetchSecrets(token) {
+        try {
+            const response = await fetch(`${this.config.apiHost}/api/v1/deploy/secrets`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ token }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!response.ok) {
+                console.error(`Secrets fetch failed: ${response.status}`);
+                return {};
+            }
+            const body = (await response.json());
+            return body.secrets ?? {};
+        }
+        catch (err) {
+            console.error(`Secrets fetch error: ${err.message}`);
+            return {};
+        }
+    }
+    async runCommand(cmd, cwd, env) {
+        // Strip NODE_ENV during install/build so devDependencies (TypeScript,
+        // bundlers, etc.) are installed. Runtime processes get NODE_ENV from
+        // secrets/env as configured — this only affects the build phase.
+        const { NODE_ENV: _stripped, ...parentEnv } = process.env;
+        return new Promise((resolve, reject) => {
+            const isWin = process.platform === 'win32';
+            const child = spawn(isWin ? 'cmd.exe' : 'sh', isWin ? ['/c', cmd] : ['-c', cmd], {
+                cwd,
+                env: { ...parentEnv, ...env },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const capture = (data) => {
+                const text = data.toString();
+                this.buildLogLines.push(...text.split('\n'));
+                if (this.buildLogLines.length > 1000) {
+                    this.buildLogLines.splice(0, this.buildLogLines.length - 1000);
+                }
+                this.buildLog = this.buildLogLines.join('\n');
+                if (this.onOutput) {
+                    for (const line of text.split('\n')) {
+                        if (line.trim())
+                            this.onOutput(line);
+                    }
+                }
+            };
+            child.stdout?.on('data', capture);
+            child.stderr?.on('data', capture);
+            child.on('exit', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Command "${cmd}" exited with code ${code}\n${this.buildLog}`));
+            });
+            child.on('error', reject);
+        });
+    }
+    swapSymlink(linkPath, targetPath) {
+        if (process.platform === 'win32') {
+            if (existsSync(linkPath))
+                rmSync(linkPath, { recursive: true });
+            execSync(`mklink /J "${linkPath}" "${targetPath}"`, { shell: 'cmd.exe' });
+        }
+        else {
+            const tmpLink = linkPath + '.tmp';
+            if (existsSync(tmpLink))
+                unlinkSync(tmpLink);
+            symlinkSync(targetPath, tmpLink);
+            renameSync(tmpLink, linkPath);
+        }
+    }
+    async monitorCrashWindow(windowSeconds) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const onExit = (data) => {
+                if (!settled && data.code !== 0 && data.code !== null) {
+                    settled = true;
+                    clearTimeout(timer);
+                    this.orchestrator.removeListener('worker:exit', onExit);
+                    resolve(false);
+                }
+            };
+            this.orchestrator.on('worker:exit', onExit);
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    this.orchestrator.removeListener('worker:exit', onExit);
+                    resolve(true);
+                }
+            }, windowSeconds * 1000);
+            timer.unref();
+        });
+    }
+    async reconcileProcesses(currentLink, secrets) {
+        const fileConfig = getOrkifyConfig(currentLink);
+        if (!fileConfig?.processes?.length) {
+            throw new Error('No processes defined in orkify.yml');
+        }
+        const configs = fileConfig.processes;
+        // Resolve script paths relative to currentLink and set cwd
+        const resolvedConfigs = configs.map((config) => ({
+            ...config,
+            script: join(currentLink, config.script),
+            cwd: currentLink,
+        }));
+        // Default NODE_ENV=production for runtime processes during deploy.
+        // Users can override this via secrets/env vars on the dashboard.
+        const runtimeEnv = { NODE_ENV: 'production', ...secrets };
+        // Pass NEXT_DEPLOYMENT_ID to runtime for version skew protection
+        if (this.nextDeploymentId && !runtimeEnv.NEXT_DEPLOYMENT_ID) {
+            runtimeEnv.NEXT_DEPLOYMENT_ID = this.nextDeploymentId;
+        }
+        const result = await this.orchestrator.reconcile(resolvedConfigs, runtimeEnv);
+        if (result.started.length > 0) {
+            console.log(`[deploy] Started: ${result.started.join(', ')}`);
+        }
+        if (result.reloaded.length > 0) {
+            console.log(`[deploy] Reloaded: ${result.reloaded.join(', ')}`);
+        }
+        if (result.deleted.length > 0) {
+            console.log(`[deploy] Deleted: ${result.deleted.join(', ')}`);
+        }
+    }
+    cleanupOldReleases(releasesDir, keep, preserveDir) {
+        try {
+            const entries = readdirSync(releasesDir)
+                .filter((e) => statSync(join(releasesDir, e)).isDirectory())
+                .sort((a, b) => {
+                // Sort by directory mtime descending (newest first)
+                const mtimeA = statSync(join(releasesDir, a)).mtimeMs;
+                const mtimeB = statSync(join(releasesDir, b)).mtimeMs;
+                return mtimeB - mtimeA;
+            });
+            for (const entry of entries.slice(keep)) {
+                const dir = join(releasesDir, entry);
+                // Never delete the previous release — it's the rollback target
+                if (preserveDir && dir === preserveDir)
+                    continue;
+                rmSync(dir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+//# sourceMappingURL=DeployExecutor.js.map

package/dist/deploy/config.d.ts

@@ -0,0 +1,20 @@
+import type { SavedState } from '../types/index.js';
+interface PackageManager {
+    name: string;
+    install: string;
+}
+export declare function detectPackageManager(projectDir: string): PackageManager;
+export declare function detectBuildCommand(packageJson: Record<string, unknown>, pm: PackageManager): null | string;
+export declare function detectEntryPoint(packageJson: Record<string, unknown>, projectDir: string): string;
+export declare function readPackageJson(projectDir: string): Record<string, unknown>;
+export declare function getOrkifyConfig(projectDir: string): null | SavedState;
+export declare function saveOrkifyConfig(projectDir: string, config: SavedState): void;
+export declare function interactiveConfig(projectDir: string): Promise<SavedState>;
+export declare function collectGitMetadata(projectDir: string): {
+    gitSha?: string;
+    gitBranch?: string;
+    gitAuthor?: string;
+    gitMessage?: string;
+};
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/deploy/config.js

@@ -0,0 +1,161 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { parse, stringify } from 'yaml';
+import { DEFAULT_LOG_MAX_AGE, DEFAULT_LOG_MAX_FILES, DEFAULT_LOG_MAX_SIZE, ORKIFY_CONFIG_FILE, } from '../constants.js';
+export function detectPackageManager(projectDir) {
+    if (existsSync(join(projectDir, 'pnpm-lock.yaml')))
+        return { name: 'pnpm', install: 'pnpm install --frozen-lockfile' };
+    if (existsSync(join(projectDir, 'yarn.lock')))
+        return { name: 'yarn', install: 'yarn install --frozen-lockfile' };
+    if (existsSync(join(projectDir, 'bun.lock')))
+        return { name: 'bun', install: 'bun install --frozen-lockfile' };
+    return { name: 'npm', install: 'npm ci' };
+}
+export function detectBuildCommand(packageJson, pm) {
+    const scripts = packageJson.scripts;
+    if (scripts?.build)
+        return `${pm.name} run build`;
+    return null;
+}
+export function detectEntryPoint(packageJson, projectDir) {
+    if (packageJson.main && typeof packageJson.main === 'string')
+        return packageJson.main;
+    const candidates = [
+        'server.mjs',
+        'server.js',
+        'app.mjs',
+        'app.js',
+        'index.mjs',
+        'index.js',
+        'src/server.mjs',
+        'src/server.js',
+        'src/index.mjs',
+        'src/index.js',
+        'dist/server.js',
+        'dist/index.js',
+        'build/index.js',
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(join(projectDir, candidate)))
+            return candidate;
+    }
+    return 'server.js';
+}
+export function readPackageJson(projectDir) {
+    const pkgPath = join(projectDir, 'package.json');
+    if (!existsSync(pkgPath)) {
+        throw new Error(`No package.json found in ${projectDir}`);
+    }
+    return JSON.parse(readFileSync(pkgPath, 'utf-8'));
+}
+export function getOrkifyConfig(projectDir) {
+    const configPath = join(projectDir, ORKIFY_CONFIG_FILE);
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const raw = parse(content);
+        if (!raw)
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveOrkifyConfig(projectDir, config) {
+    const configPath = join(projectDir, ORKIFY_CONFIG_FILE);
+    writeFileSync(configPath, stringify(config, { defaultStringType: 'QUOTE_DOUBLE' }), 'utf-8');
+}
+async function prompt(question, prefill) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(`${question}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+        rl.write(prefill);
+    });
+}
+export async function interactiveConfig(projectDir) {
+    const hasPkg = existsSync(join(projectDir, 'package.json'));
+    const pkg = hasPkg ? readPackageJson(projectDir) : {};
+    const pm = detectPackageManager(projectDir);
+    const buildCmd = detectBuildCommand(pkg, pm);
+    const entry = detectEntryPoint(pkg, projectDir);
+    console.log('\nConfiguring deployment for this project:\n');
+    const install = await prompt('Install command (empty to skip)', hasPkg ? pm.install : '');
+    const build = await prompt('Build command (empty to skip)', hasPkg ? buildCmd || `${pm.name} run build` : '');
+    const entryPoint = await prompt('Entry point', entry);
+    const workersStr = await prompt('Workers (0 = max CPU cores, 1 = fork mode)', '0');
+    const parsed = parseInt(workersStr, 10);
+    const workers = Number.isNaN(parsed) ? 0 : parsed;
+    const deploy = { install };
+    if (build) {
+        deploy.build = build;
+    }
+    const process = {
+        name: 'app',
+        script: entryPoint,
+        cwd: projectDir,
+        workerCount: workers,
+        execMode: workers === 0 || workers > 1 ? 'cluster' : 'fork',
+        watch: false,
+        env: {},
+        nodeArgs: [],
+        args: [],
+        killTimeout: 5000,
+        maxRestarts: 10,
+        minUptime: 1000,
+        restartDelay: 100,
+        sticky: false,
+        logMaxSize: DEFAULT_LOG_MAX_SIZE,
+        logMaxFiles: DEFAULT_LOG_MAX_FILES,
+        logMaxAge: DEFAULT_LOG_MAX_AGE,
+    };
+    return {
+        version: 1,
+        deploy,
+        processes: [process],
+    };
+}
+export function collectGitMetadata(projectDir) {
+    const meta = {};
+    try {
+        meta.gitSha = execSync('git rev-parse HEAD', { cwd: projectDir, encoding: 'utf-8' }).trim();
+    }
+    catch {
+        // Not a git repo
+    }
+    try {
+        meta.gitBranch = execSync('git branch --show-current', {
+            cwd: projectDir,
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        // git not available
+    }
+    try {
+        meta.gitAuthor = execSync('git log -1 --format=%an', {
+            cwd: projectDir,
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        // git not available
+    }
+    try {
+        meta.gitMessage = execSync('git log -1 --format=%s', {
+            cwd: projectDir,
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        // git not available
+    }
+    return meta;
+}
+//# sourceMappingURL=config.js.map

package/dist/deploy/env.d.ts

@@ -0,0 +1,2 @@
+export declare function parseEnvFile(content: string): Record<string, string>;
+//# sourceMappingURL=env.d.ts.map

package/dist/deploy/env.js

@@ -0,0 +1,17 @@
+export function parseEnvFile(content) {
+    const env = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        const value = trimmed.slice(eqIndex + 1).trim();
+        if (key)
+            env[key] = value;
+    }
+    return env;
+}
+//# sourceMappingURL=env.js.map

package/dist/deploy/tarball.d.ts

@@ -0,0 +1,32 @@
+interface FileDep {
+    dir: string;
+    files: string[];
+}
+/**
+ * Scan package.json for `file:` dependencies. For each one, walk the
+ * referenced directory and collect its files. Returns a rewritten
+ * package.json string with paths pointing to `.file-deps/<name>/` and
+ * a map of the collected files — or null if there are no file deps.
+ */
+export declare function bundleFileDeps(projectDir: string): null | {
+    rewrittenPkg: string;
+    rewrittenLock: null | string;
+    fileDeps: Map<string, FileDep>;
+};
+/**
+ * Create a tar.gz archive of the project directory.
+ *
+ * Walks the directory tree, respecting .gitignore files from the git root
+ * all the way down into the project, plus a built-in exclude list
+ * (node_modules, .git, .env, etc.).
+ *
+ * Any `file:` dependencies in package.json are bundled into the tarball
+ * under `.file-deps/<name>/` and the paths are rewritten so `npm ci`
+ * can resolve them on the deploy target.
+ */
+export interface TarballOptions {
+    excludeSourceMaps?: boolean;
+}
+export declare function createTarball(projectDir: string, options?: TarballOptions): Promise<string>;
+export {};
+//# sourceMappingURL=tarball.d.ts.map