@orkify/cli 1.0.0-beta.5

package/dist/deploy/tarball.js

@@ -0,0 +1,243 @@
+import ig from 'ignore';
+import { createWriteStream, existsSync, mkdirSync, readdirSync, readFileSync, statSync, } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { createGzip } from 'node:zlib';
+import { pack } from 'tar-stream';
+import { ORKIFY_HOME } from '../constants.js';
+// Always exclude these patterns
+const ALWAYS_EXCLUDE = [
+    'node_modules',
+    '.git',
+    '.gitignore',
+    '.env',
+    '.env.local',
+    '.env.production',
+    '.env.staging',
+    '.orkify',
+];
+/** Walk up from startDir looking for a .git directory. */
+function findGitRoot(startDir) {
+    let dir = startDir;
+    for (;;) {
+        if (existsSync(join(dir, '.git')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/** Parse a .gitignore file into an array of patterns. */
+function readGitignorePatterns(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    return readFileSync(filePath, 'utf-8')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l && !l.startsWith('#'));
+}
+/**
+ * Collect .gitignore filters from ancestor directories (gitRoot up to,
+ * but not including, projectDir). The projectDir's own .gitignore is
+ * handled during the walk so it isn't double-loaded.
+ */
+function collectAncestorFilters(projectDir) {
+    const filters = [];
+    const gitRoot = findGitRoot(projectDir);
+    if (!gitRoot)
+        return filters;
+    const relPath = relative(gitRoot, projectDir);
+    if (!relPath)
+        return filters; // projectDir IS the git root
+    const parts = relPath.split(sep);
+    let current = gitRoot;
+    // Git root .gitignore
+    const rootPatterns = readGitignorePatterns(join(current, '.gitignore'));
+    if (rootPatterns.length > 0) {
+        filters.push({ dir: current, ig: ig().add(rootPatterns) });
+    }
+    // Intermediate directories (not including projectDir itself)
+    for (let i = 0; i < parts.length - 1; i++) {
+        current = join(current, parts[i]);
+        const patterns = readGitignorePatterns(join(current, '.gitignore'));
+        if (patterns.length > 0) {
+            filters.push({ dir: current, ig: ig().add(patterns) });
+        }
+    }
+    return filters;
+}
+/** Check whether absPath is ignored by any of the gitignore filters. */
+function isIgnoredByFilters(absPath, isDir, filters) {
+    for (const filter of filters) {
+        const rel = relative(filter.dir, absPath);
+        if (rel.startsWith('..') || rel === '')
+            continue;
+        const normalized = rel.split(sep).join('/') + (isDir ? '/' : '');
+        if (filter.ig.ignores(normalized))
+            return true;
+    }
+    return false;
+}
+/**
+ * Recursively walk a directory, collecting file paths while respecting
+ * .gitignore files found along the way and the built-in exclude list.
+ */
+function walkDirectory(dir, projectDir, parentFilters, builtinIgnore) {
+    const files = [];
+    // Load .gitignore from this directory (if any)
+    const patterns = readGitignorePatterns(join(dir, '.gitignore'));
+    const filters = patterns.length > 0 ? [...parentFilters, { dir, ig: ig().add(patterns) }] : parentFilters;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const absPath = join(dir, entry.name);
+        const relToProject = relative(projectDir, absPath).split(sep).join('/');
+        const isDir = entry.isDirectory();
+        // Check built-in excludes
+        if (builtinIgnore.ignores(relToProject + (isDir ? '/' : '')))
+            continue;
+        // Check gitignore filters
+        if (isIgnoredByFilters(absPath, isDir, filters))
+            continue;
+        if (isDir) {
+            files.push(...walkDirectory(absPath, projectDir, filters, builtinIgnore));
+        }
+        else if (entry.isFile()) {
+            files.push(absPath);
+        }
+    }
+    return files;
+}
+/**
+ * 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 function bundleFileDeps(projectDir) {
+    const pkgPath = join(projectDir, 'package.json');
+    if (!existsSync(pkgPath))
+        return null;
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    const fileDeps = new Map();
+    // Track original relative path → new .file-deps path for lock file rewriting
+    const pathRewrites = new Map();
+    for (const section of ['dependencies', 'devDependencies']) {
+        const deps = pkg[section];
+        if (!deps)
+            continue;
+        for (const [name, spec] of Object.entries(deps)) {
+            if (!spec.startsWith('file:'))
+                continue;
+            const rawRelPath = spec.slice(5);
+            const depDir = resolve(projectDir, rawRelPath);
+            if (!existsSync(depDir)) {
+                throw new Error(`file: dependency "${name}" points to "${depDir}" which does not exist`);
+            }
+            const ancestorFilters = collectAncestorFilters(depDir);
+            const builtinIgnore = ig().add(ALWAYS_EXCLUDE);
+            const files = walkDirectory(depDir, depDir, ancestorFilters, builtinIgnore);
+            // Normalize the relative path (strip leading ./) to match lock file keys
+            const normalizedRel = relative(projectDir, depDir).split(sep).join('/');
+            const newPath = `.file-deps/${name}`;
+            deps[name] = `file:${newPath}`;
+            pathRewrites.set(normalizedRel, newPath);
+            fileDeps.set(name, { dir: depDir, files });
+        }
+    }
+    if (fileDeps.size === 0)
+        return null;
+    // Rewrite package-lock.json to match the new file: paths
+    let rewrittenLock = null;
+    const lockPath = join(projectDir, 'package-lock.json');
+    if (existsSync(lockPath)) {
+        const lock = JSON.parse(readFileSync(lockPath, 'utf-8'));
+        const packages = lock.packages;
+        if (packages) {
+            const renames = [];
+            for (const [oldRel, newRel] of pathRewrites) {
+                // Rewrite the package entry key (e.g. "packages/cache" → ".file-deps/@orkify/cache")
+                if (packages[oldRel]) {
+                    renames.push([oldRel, newRel]);
+                }
+                // Rewrite node_modules link entries that resolve to the old path
+                for (const [key, val] of Object.entries(packages)) {
+                    if (key.startsWith('node_modules/') && val.resolved === oldRel) {
+                        val.resolved = newRel;
+                    }
+                }
+            }
+            for (const [oldKey, newKey] of renames) {
+                packages[newKey] = packages[oldKey];
+                delete packages[oldKey];
+            }
+            // Also rewrite any file: specifiers in nested dependencies
+            for (const val of Object.values(packages)) {
+                const deps = val.dependencies;
+                if (!deps)
+                    continue;
+                for (const [depName, depSpec] of Object.entries(deps)) {
+                    if (typeof depSpec === 'string' && depSpec.startsWith('file:')) {
+                        const rel = depSpec.slice(5);
+                        if (pathRewrites.has(rel)) {
+                            deps[depName] = `file:${pathRewrites.get(rel)}`;
+                        }
+                    }
+                }
+            }
+        }
+        rewrittenLock = JSON.stringify(lock, null, 2) + '\n';
+    }
+    return { rewrittenPkg: JSON.stringify(pkg, null, 2) + '\n', rewrittenLock, fileDeps };
+}
+export async function createTarball(projectDir, options) {
+    const artifactsDir = join(ORKIFY_HOME, 'tmp');
+    if (!existsSync(artifactsDir)) {
+        mkdirSync(artifactsDir, { recursive: true });
+    }
+    const tarPath = join(artifactsDir, `deploy-${Date.now()}.tar.gz`);
+    const ancestorFilters = collectAncestorFilters(projectDir);
+    const excludes = options?.excludeSourceMaps ? [...ALWAYS_EXCLUDE, '*.map'] : ALWAYS_EXCLUDE;
+    const builtinIgnore = ig().add(excludes);
+    const files = walkDirectory(projectDir, projectDir, ancestorFilters, builtinIgnore);
+    // Check for file: deps to bundle
+    const bundle = bundleFileDeps(projectDir);
+    const p = pack();
+    const gzip = createGzip();
+    const output = createWriteStream(tarPath);
+    const done = pipeline(p, gzip, output);
+    for (const file of files) {
+        const rel = relative(projectDir, file).split(sep).join('/');
+        // Skip package.json and package-lock.json if we need to rewrite them
+        if (bundle && (rel === 'package.json' || (rel === 'package-lock.json' && bundle.rewrittenLock)))
+            continue;
+        const stat = statSync(file);
+        p.entry({ name: rel, size: stat.size, mode: stat.mode, mtime: stat.mtime }, readFileSync(file));
+    }
+    if (bundle) {
+        // Add rewritten package.json
+        const content = Buffer.from(bundle.rewrittenPkg);
+        p.entry({ name: 'package.json', size: content.length }, content);
+        // Add rewritten package-lock.json
+        if (bundle.rewrittenLock) {
+            const lockContent = Buffer.from(bundle.rewrittenLock);
+            p.entry({ name: 'package-lock.json', size: lockContent.length }, lockContent);
+        }
+        // Add bundled file: dep contents
+        for (const [name, dep] of bundle.fileDeps) {
+            for (const file of dep.files) {
+                const rel = relative(dep.dir, file).split(sep).join('/');
+                const stat = statSync(file);
+                p.entry({
+                    name: `.file-deps/${name}/${rel}`,
+                    size: stat.size,
+                    mode: stat.mode,
+                    mtime: stat.mtime,
+                }, readFileSync(file));
+            }
+        }
+    }
+    p.finalize();
+    await done;
+    return tarPath;
+}
+//# sourceMappingURL=tarball.js.map

package/dist/detect/framework.d.ts

@@ -0,0 +1,2 @@
+export declare function detectFramework(cwd: string): string | undefined;
+//# sourceMappingURL=framework.d.ts.map

package/dist/detect/framework.js

@@ -0,0 +1,24 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const NEXT_CONFIG_FILES = ['next.config.ts', 'next.config.js', 'next.config.mjs'];
+export function detectFramework(cwd) {
+    // Primary: check package.json for `next` dependency
+    try {
+        const raw = readFileSync(join(cwd, 'package.json'), 'utf-8');
+        const pkg = JSON.parse(raw);
+        if (pkg.dependencies?.next || pkg.devDependencies?.next) {
+            return 'nextjs';
+        }
+    }
+    catch {
+        // Missing or malformed package.json — fall through to config file check
+    }
+    // Fallback: check for next.config.{ts,js,mjs}
+    for (const file of NEXT_CONFIG_FILES) {
+        if (existsSync(join(cwd, file))) {
+            return 'nextjs';
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=framework.js.map

package/dist/ipc/DaemonClient.d.ts

@@ -0,0 +1,31 @@
+import type { IPCRequest, IPCResponse } from '../types/index.js';
+import { IPCMessageType } from '../constants.js';
+export declare class DaemonClient {
+    private socket;
+    private messageParser;
+    private pendingRequests;
+    private streamHandlers;
+    private progressHandlers;
+    private spawnEnv;
+    connect(): Promise<void>;
+    private configureTelemetry;
+    private isDaemonRunning;
+    /**
+     * Attempt to acquire an exclusive lock for daemon startup.
+     * Uses O_EXCL for atomic create-if-not-exists.
+     * Returns true if lock acquired, false if another process holds it.
+     */
+    private acquireLock;
+    private releaseLock;
+    private startDaemon;
+    private handleMessage;
+    send(request: IPCRequest, timeoutMs?: number): Promise<IPCResponse>;
+    request(type: (typeof IPCMessageType)[keyof typeof IPCMessageType], payload?: IPCRequest['payload'], timeoutMs?: number): Promise<IPCResponse>;
+    requestWithProgress(type: (typeof IPCMessageType)[keyof typeof IPCMessageType], payload: IPCRequest['payload'], onProgress: (data: unknown) => void, timeoutMs?: number): Promise<IPCResponse>;
+    streamLogs(target: number | string | undefined, onData: (data: unknown) => void): Promise<() => void>;
+    private cleanup;
+    setSpawnEnv(env: Record<string, string>): void;
+    disconnect(): void;
+}
+export declare const daemonClient: DaemonClient;
+//# sourceMappingURL=DaemonClient.d.ts.map

package/dist/ipc/DaemonClient.js

@@ -0,0 +1,248 @@
+import { spawn } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { connect } from 'node:net';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DAEMON_LOCK_FILE, DAEMON_LOG_FILE, DAEMON_PID_FILE, DAEMON_STARTUP_TIMEOUT, IPC_CONNECT_TIMEOUT, IPC_RESPONSE_TIMEOUT, IPCMessageType, ORKIFY_HOME, SOCKET_PATH, TELEMETRY_DEFAULT_API_HOST, } from '../constants.js';
+import { createMessageParser, createRequest, serialize } from './protocol.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export class DaemonClient {
+    socket = null;
+    messageParser = createMessageParser();
+    pendingRequests = new Map();
+    streamHandlers = new Map();
+    progressHandlers = new Map();
+    spawnEnv = {};
+    async connect() {
+        if (this.socket) {
+            return;
+        }
+        // Check if daemon is running
+        const daemonAlreadyRunning = this.isDaemonRunning();
+        if (!daemonAlreadyRunning) {
+            await this.startDaemon();
+        }
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.socket?.destroy();
+                this.cleanup();
+                reject(new Error('Connection timeout'));
+            }, IPC_CONNECT_TIMEOUT);
+            this.socket = connect(SOCKET_PATH);
+            this.socket.on('connect', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.socket.on('data', (chunk) => {
+                const messages = this.messageParser(chunk);
+                for (const message of messages) {
+                    this.handleMessage(message);
+                }
+            });
+            this.socket.on('error', (err) => {
+                clearTimeout(timeout);
+                this.cleanup();
+                reject(err);
+            });
+            this.socket.on('close', () => {
+                this.cleanup();
+            });
+        });
+        // If we connected to an already-running daemon and the CLI has
+        // ORKIFY_API_KEY, push the telemetry config so the daemon can
+        // enable telemetry even if it started without it.
+        if (daemonAlreadyRunning && process.env.ORKIFY_API_KEY) {
+            this.configureTelemetry();
+        }
+    }
+    configureTelemetry() {
+        if (!this.socket)
+            return;
+        const req = createRequest(IPCMessageType.CONFIGURE_TELEMETRY, {
+            apiKey: process.env.ORKIFY_API_KEY,
+            apiHost: process.env.ORKIFY_API_HOST || TELEMETRY_DEFAULT_API_HOST,
+        });
+        // Fire-and-forget — don't block the caller waiting for a response
+        this.socket.write(serialize(req));
+    }
+    isDaemonRunning() {
+        if (!existsSync(SOCKET_PATH)) {
+            return false;
+        }
+        if (existsSync(DAEMON_PID_FILE)) {
+            try {
+                const pid = parseInt(readFileSync(DAEMON_PID_FILE, 'utf-8').trim(), 10);
+                process.kill(pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Attempt to acquire an exclusive lock for daemon startup.
+     * Uses O_EXCL for atomic create-if-not-exists.
+     * Returns true if lock acquired, false if another process holds it.
+     */
+    acquireLock() {
+        try {
+            const fd = openSync(DAEMON_LOCK_FILE, 'wx');
+            writeFileSync(fd, String(process.pid));
+            closeSync(fd);
+            return true;
+        }
+        catch {
+            // Lock file exists — check if holder is still alive
+            try {
+                const holderPid = parseInt(readFileSync(DAEMON_LOCK_FILE, 'utf-8').trim(), 10);
+                process.kill(holderPid, 0); // throws if dead
+                return false; // holder is alive
+            }
+            catch {
+                // Holder is dead — take over stale lock
+                try {
+                    unlinkSync(DAEMON_LOCK_FILE);
+                    const fd = openSync(DAEMON_LOCK_FILE, 'wx');
+                    writeFileSync(fd, String(process.pid));
+                    closeSync(fd);
+                    return true;
+                }
+                catch {
+                    return false; // race with another takeover
+                }
+            }
+        }
+    }
+    releaseLock() {
+        try {
+            unlinkSync(DAEMON_LOCK_FILE);
+        }
+        catch {
+            // Ignore — may already be cleaned up
+        }
+    }
+    async startDaemon() {
+        if (!existsSync(ORKIFY_HOME)) {
+            mkdirSync(ORKIFY_HOME, { recursive: true });
+        }
+        if (!this.acquireLock()) {
+            // Another process is spawning the daemon — wait for socket instead
+            const startTime = Date.now();
+            while (Date.now() - startTime < DAEMON_STARTUP_TIMEOUT) {
+                if (existsSync(SOCKET_PATH)) {
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    return;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+            throw new Error('Daemon failed to start (waited for lock holder)');
+        }
+        try {
+            const daemonScript = join(__dirname, '..', 'daemon', 'index.js');
+            const logFd = openSync(DAEMON_LOG_FILE, 'a');
+            const child = spawn(process.execPath, [daemonScript], {
+                detached: true,
+                stdio: ['ignore', logFd, logFd],
+                env: { ...process.env, ...this.spawnEnv },
+            });
+            this.spawnEnv = {};
+            child.unref();
+            // Wait for socket to be available
+            const startTime = Date.now();
+            while (Date.now() - startTime < DAEMON_STARTUP_TIMEOUT) {
+                if (existsSync(SOCKET_PATH)) {
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    return;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+            throw new Error('Daemon failed to start');
+        }
+        finally {
+            this.releaseLock();
+        }
+    }
+    handleMessage(message) {
+        const response = message;
+        // Deploy progress — emit to handler without resolving the pending request
+        if (message.type === IPCMessageType.DEPLOY_PROGRESS) {
+            const handler = this.progressHandlers.get(response.id);
+            handler?.(response.data);
+            return;
+        }
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(response.id);
+            this.progressHandlers.delete(response.id);
+            pending.resolve(response);
+            return;
+        }
+        // Check for stream handlers (for logs)
+        const streamHandler = this.streamHandlers.get(response.id);
+        if (streamHandler && message.type === IPCMessageType.LOG_DATA) {
+            streamHandler(response.data);
+        }
+    }
+    async send(request, timeoutMs) {
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error('Not connected to daemon');
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(request.id);
+                reject(new Error('Request timeout'));
+            }, timeoutMs ?? IPC_RESPONSE_TIMEOUT);
+            this.pendingRequests.set(request.id, { resolve, reject, timeout });
+            socket.write(serialize(request));
+        });
+    }
+    async request(type, payload, timeoutMs) {
+        await this.connect();
+        const request = createRequest(type, payload);
+        return this.send(request, timeoutMs);
+    }
+    async requestWithProgress(type, payload, onProgress, timeoutMs) {
+        await this.connect();
+        const request = createRequest(type, payload);
+        this.progressHandlers.set(request.id, onProgress);
+        return this.send(request, timeoutMs);
+    }
+    async streamLogs(target, onData) {
+        await this.connect();
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error('Not connected to daemon');
+        }
+        const request = createRequest(IPCMessageType.LOGS, { target, follow: true });
+        this.streamHandlers.set(request.id, onData);
+        socket.write(serialize(request));
+        return () => {
+            this.streamHandlers.delete(request.id);
+        };
+    }
+    cleanup() {
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Connection closed'));
+        }
+        this.pendingRequests.clear();
+        this.streamHandlers.clear();
+        this.socket = null;
+    }
+    setSpawnEnv(env) {
+        this.spawnEnv = env;
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.end();
+            this.cleanup();
+        }
+    }
+}
+export const daemonClient = new DaemonClient();
+//# sourceMappingURL=DaemonClient.js.map

package/dist/ipc/DaemonServer.d.ts

@@ -0,0 +1,28 @@
+import { type Socket } from 'node:net';
+import type { IPCRequest, IPCResponse } from '../types/index.js';
+export type RequestHandler = (request: IPCRequest, client: ClientConnection) => IPCResponse | Promise<IPCResponse>;
+export declare class ClientConnection {
+    private socket;
+    private messageParser;
+    constructor(socket: Socket);
+    send(message: IPCResponse): void;
+    onData(handler: (messages: IPCRequest[]) => void): void;
+    onClose(handler: () => void): void;
+    onError(handler: (err: Error) => void): void;
+    close(): void;
+}
+export declare class DaemonServer {
+    private server;
+    private clients;
+    private handlers;
+    private logSubscribers;
+    registerHandler(type: string, handler: RequestHandler): void;
+    subscribeToLogs(processName: string, client: ClientConnection, requestId: string): void;
+    unsubscribeFromLogs(processName: string, client: ClientConnection): void;
+    broadcastLog(processName: string, data: unknown): void;
+    start(): Promise<void>;
+    private handleRequest;
+    broadcast(message: IPCResponse): void;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=DaemonServer.d.ts.map