@creativeintelligence/abbie 0.1.6 → 0.1.8

package/dist/lib/preview/sprite.js

@@ -1,321 +0,0 @@
-import { spawn } from "node:child_process";
-import { createWriteStream, existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
-import { createGzip } from "node:zlib";
-import { pack } from "tar-fs";
-/**
- * Run a sprite CLI command and return the result
- */
-export function runSprite(args) {
-    return new Promise((resolve) => {
-        const child = spawn("sprite", args, {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (data) => {
-            stdout += data.toString();
-        });
-        child.stderr.on("data", (data) => {
-            stderr += data.toString();
-        });
-        child.on("close", (code) => {
-            if (code === 0) {
-                resolve({ success: true, stdout, stderr });
-            }
-            else {
-                resolve({ success: false, stdout, stderr, error: stderr || `Exit code ${code}` });
-            }
-        });
-        child.on("error", (err) => {
-            resolve({ success: false, stdout: "", stderr: "", error: err.message });
-        });
-    });
-}
-/**
- * Create a new sprite
- */
-export async function createSprite(name) {
-    return runSprite(["create", name, "-skip-console"]);
-}
-/**
- * Destroy a sprite
- */
-export async function destroySprite(name) {
-    return runSprite(["destroy", "-s", name]);
-}
-/**
- * Set sprite URL to public access
- */
-export async function makeUrlPublic(spriteName) {
-    return runSprite(["url", "update", "-s", spriteName, "--auth", "public"]);
-}
-/**
- * Get sprite URL
- */
-export async function getSpriteUrl(spriteName) {
-    const result = await runSprite(["url", "-s", spriteName]);
-    if (!result.success)
-        return null;
-    // Parse URL from output (format: "URL: https://...")
-    const lines = result.stdout.split("\n");
-    for (const line of lines) {
-        if (line.includes("http")) {
-            // Extract URL from line
-            const match = line.match(/https?:\/\/[^\s]+/);
-            if (match)
-                return match[0];
-        }
-    }
-    return null;
-}
-/**
- * Check if a sprite exists by listing all sprites
- */
-export async function spriteExists(name) {
-    const result = await runSprite(["list"]);
-    if (!result.success)
-        return false;
-    // Check if sprite name appears in the output
-    return result.stdout.includes(name);
-}
-/**
- * Execute a command on a sprite
- */
-export async function execOnSprite(spriteName, command, options) {
-    const args = ["exec", "-s", spriteName];
-    if (options?.dir) {
-        args.push("-dir", options.dir);
-    }
-    if (options?.env && Object.keys(options.env).length > 0) {
-        const envStr = Object.entries(options.env)
-            .map(([k, v]) => `${k}=${v}`)
-            .join(",");
-        args.push("-env", envStr);
-    }
-    if (options?.files) {
-        for (const file of options.files) {
-            args.push("-file", `${file.local}:${file.remote}`);
-        }
-    }
-    args.push("bash", "-c", command);
-    return runSprite(args);
-}
-/**
- * Create a tarball of a project excluding common build artifacts
- */
-/** Directories/files to exclude from tarball and watch (checked against full path and basename) */
-export const EXCLUDE_PATTERNS = [
-    "node_modules",
-    ".git",
-    ".next",
-    ".turbo",
-    "dist",
-    ".cache",
-    ".vercel",
-    ".convex",
-    ".pnpm",
-    "coverage",
-    ".DS_Store",
-    "playwright-report",
-    "test-results",
-    ".playwright-mcp", // Large playwright screenshots
-];
-/** File extensions to exclude from tarball and watch (reduce size for large assets) */
-export const EXCLUDE_EXTENSIONS = [
-    ".png",
-    ".svg",
-    ".jpg",
-    ".jpeg",
-    ".gif",
-    ".webp",
-    ".mp4",
-    ".mov",
-];
-export async function createProjectTarball(projectPath) {
-    const tarPath = join(tmpdir(), `sprite-sync-${Date.now()}.tar.gz`);
-    const ignore = (fullPath) => {
-        // Get the basename of the path
-        const name = basename(fullPath);
-        // Check file extension
-        const ext = name.toLowerCase().slice(name.lastIndexOf("."));
-        if (EXCLUDE_EXTENSIONS.includes(ext)) {
-            return true;
-        }
-        // Check if basename matches any exclude pattern
-        if (EXCLUDE_PATTERNS.includes(name)) {
-            return true;
-        }
-        // Check if any segment of the path matches
-        const segments = fullPath.split("/");
-        return segments.some((seg) => EXCLUDE_PATTERNS.includes(seg));
-    };
-    return new Promise((resolve, reject) => {
-        const writeStream = createWriteStream(tarPath);
-        const gzip = createGzip();
-        pack(projectPath, { ignore })
-            .pipe(gzip)
-            .pipe(writeStream)
-            .on("finish", () => resolve(tarPath))
-            .on("error", reject);
-    });
-}
-/**
- * Sync project files to sprite:
- * 1. Create tarball locally
- * 2. Upload via sprite exec -file
- * 3. Extract on remote
- */
-export async function syncToSprite(spriteName, projectPath, remotePath = "/app") {
-    const startTime = Date.now();
-    // Create tarball
-    let tarPath;
-    try {
-        tarPath = await createProjectTarball(projectPath);
-    }
-    catch (err) {
-        return {
-            success: false,
-            error: `Failed to create tarball: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    const tarName = basename(tarPath);
-    const remoteTar = `/tmp/${tarName}`;
-    // Upload and extract
-    const result = await execOnSprite(spriteName, `mkdir -p ${remotePath} && tar --overwrite -xzf ${remoteTar} -C ${remotePath} && rm ${remoteTar}`, {
-        files: [{ local: tarPath, remote: remoteTar }],
-    });
-    // Clean up local tarball
-    try {
-        unlinkSync(tarPath);
-    }
-    catch {
-        // Ignore cleanup errors
-    }
-    const syncDurationMs = Date.now() - startTime;
-    if (!result.success) {
-        return {
-            success: false,
-            tarPath,
-            error: result.error || result.stderr,
-            syncDurationMs,
-        };
-    }
-    return {
-        success: true,
-        tarPath,
-        syncDurationMs,
-    };
-}
-/**
- * Check if a process is running on the sprite
- */
-export async function isProcessRunning(spriteName, processPattern) {
-    const result = await execOnSprite(spriteName, `pgrep -f "${processPattern}" || true`);
-    return result.success && result.stdout.trim().length > 0;
-}
-/**
- * Kill processes matching a pattern on the sprite
- * Note: Uses lsof to find PIDs since pkill is not allowed
- */
-export async function killProcess(spriteName, processPattern) {
-    // Find PIDs matching the pattern, then kill them individually
-    // Using lsof and grep instead of pkill
-    const findAndKill = `
-    pids=$(ps aux | grep -E "${processPattern}" | grep -v grep | awk '{print $2}')
-    if [ -n "$pids" ]; then
-      for pid in $pids; do
-        kill -9 $pid 2>/dev/null || true
-      done
-      echo "Killed PIDs: $pids"
-    else
-      echo "No matching processes found"
-    fi
-  `;
-    return execOnSprite(spriteName, findAndKill);
-}
-/**
- * Start a dev server on the sprite with health checking.
- *
- * Uses TTY session for proper PATH/environment on the sprite.
- * Pipes output to a local log file so the detached process persists
- * after the CLI exits. Polls the sprite URL until healthy (up to 90s).
- */
-export async function startDevServer(spriteName, devCommand, options) {
-    const dir = options?.dir || "/app";
-    const port = options?.port || 8080;
-    // Ensure the command binds to 0.0.0.0 and uses the correct port
-    let cmd = devCommand;
-    if (!cmd.includes("-H") && !cmd.includes("--hostname")) {
-        if (cmd.includes("next dev") || cmd.includes("bun run dev")) {
-            cmd = cmd.replace(/-p\s*\d+/g, ""); // Remove existing port
-            cmd = `${cmd} -p ${port} -H 0.0.0.0`;
-        }
-    }
-    // Build environment string for -env flag
-    const envStr = options?.env && Object.keys(options.env).length > 0
-        ? Object.entries(options.env)
-            .map(([k, v]) => `${k}=${v}`)
-            .join(",")
-        : "";
-    // Kill any existing dev server first
-    await killProcess(spriteName, "next dev|bun run dev|node.*dev");
-    const fullCmd = `cd ${dir} && ${cmd}`;
-    // Use TTY session for proper PATH/environment on the sprite
-    const args = ["exec", "-s", spriteName, "-tty"];
-    if (envStr) {
-        args.push("-env", envStr);
-    }
-    args.push("bash", "-c", fullCmd);
-    // Pipe output to a local log file so the detached process persists
-    const logDir = join(tmpdir(), "agents-preview");
-    if (!existsSync(logDir))
-        mkdirSync(logDir, { recursive: true });
-    const logPath = join(logDir, `${spriteName}.log`);
-    const logStream = createWriteStream(logPath, { flags: "a" });
-    const child = spawn("sprite", args, {
-        detached: true,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    // Pipe stdout/stderr to log file to keep the process alive
-    if (child.stdout)
-        child.stdout.pipe(logStream);
-    if (child.stderr)
-        child.stderr.pipe(logStream);
-    child.unref();
-    // Write PID for later cleanup
-    const pidPath = join(logDir, `${spriteName}.pid`);
-    writeFileSync(pidPath, String(child.pid));
-    // Health check: poll until server responds or timeout
-    const healthUrl = options?.healthCheckUrl || (await getSpriteUrl(spriteName));
-    if (healthUrl) {
-        const timeoutMs = options?.healthCheckTimeoutMs ?? 90_000;
-        const pollIntervalMs = 3000;
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            try {
-                const resp = await fetch(healthUrl, {
-                    method: "HEAD",
-                    signal: AbortSignal.timeout(5000),
-                });
-                if (resp.ok || resp.status === 308 || resp.status === 307 || resp.status === 302) {
-                    return { success: true, stdout: `Server healthy (${resp.status})`, stderr: "" };
-                }
-            }
-            catch {
-                // Server not ready yet
-            }
-            await new Promise((r) => setTimeout(r, pollIntervalMs));
-        }
-        return {
-            success: false,
-            stdout: "",
-            stderr: "",
-            error: `Server did not become healthy within ${timeoutMs / 1000}s`,
-        };
-    }
-    // No URL to check — fall back to a brief wait
-    await new Promise((r) => setTimeout(r, 3000));
-    return { success: true, stdout: "Server starting...", stderr: "" };
-}

package/dist/lib/preview/watcher.d.ts

@@ -1,63 +0,0 @@
-/**
- * File watcher for continuous sprite sync.
- *
- * Uses node:fs watch() with recursive mode (macOS FSEvents).
- * Debounces changes and serializes syncs to prevent overlap.
- */
-export interface WatcherConfig {
-    /** Absolute path to the project directory */
-    projectPath: string;
-    /** Sprite name for sync target */
-    spriteName: string;
-    /** Remote path on the sprite (default: "/app") */
-    remotePath?: string;
-    /** Debounce delay in ms (default: 1500) */
-    debounceMs?: number;
-    /** Whether to run install when lockfiles change (default: true) */
-    autoInstall?: boolean;
-    /** Package manager for install command */
-    packageManager?: "pnpm" | "bun" | "npm";
-    /** Doppler project for secrets */
-    dopplerProject?: string;
-    /** NPM token for private packages */
-    npmToken?: string;
-    /** AbortSignal for clean shutdown */
-    signal: AbortSignal;
-}
-export type WatcherEvent = {
-    type: "started";
-    projectPath: string;
-} | {
-    type: "sync_start";
-    fileCount: number;
-    needsInstall: boolean;
-} | {
-    type: "sync_complete";
-    syncMs: number;
-    installMs: number;
-    totalMs: number;
-} | {
-    type: "sync_error";
-    error: string;
-    retryable: boolean;
-} | {
-    type: "stopped";
-};
-export interface WatcherStats {
-    totalSyncs: number;
-    totalErrors: number;
-    lastSyncMs: number | null;
-    lastSyncAt: Date | null;
-    queuedFiles: number;
-    syncing: boolean;
-}
-export type WatcherEventHandler = (event: WatcherEvent) => void;
-export interface WatcherHandle {
-    /** Resolves when the watcher has fully stopped */
-    done: Promise<void>;
-    /** Get current stats */
-    stats: () => WatcherStats;
-}
-export declare function shouldIgnoreFile(filename: string): boolean;
-export declare function startWatcher(config: WatcherConfig, onEvent: WatcherEventHandler): WatcherHandle;
-//# sourceMappingURL=watcher.d.ts.map

package/dist/lib/preview/watcher.js

@@ -1,185 +0,0 @@
-/**
- * File watcher for continuous sprite sync.
- *
- * Uses node:fs watch() with recursive mode (macOS FSEvents).
- * Debounces changes and serializes syncs to prevent overlap.
- */
-import { watch } from "node:fs";
-import { basename } from "node:path";
-import { getInstallCommand } from "./detect.js";
-import { EXCLUDE_EXTENSIONS, EXCLUDE_PATTERNS, execOnSprite, syncToSprite } from "./sprite.js";
-// ── Lockfile detection ─────────────────────────────────────────────────────
-const LOCKFILE_NAMES = new Set([
-    "package.json",
-    "pnpm-lock.yaml",
-    "bun.lock",
-    "bun.lockb",
-    "package-lock.json",
-    "yarn.lock",
-]);
-function isLockfileChange(filename) {
-    return LOCKFILE_NAMES.has(basename(filename));
-}
-// ── File filter ────────────────────────────────────────────────────────────
-const excludeSet = new Set(EXCLUDE_PATTERNS);
-const extSet = new Set(EXCLUDE_EXTENSIONS);
-export function shouldIgnoreFile(filename) {
-    const name = basename(filename);
-    // Check extension
-    const dotIdx = name.lastIndexOf(".");
-    if (dotIdx !== -1) {
-        const ext = name.slice(dotIdx).toLowerCase();
-        if (extSet.has(ext))
-            return true;
-    }
-    // Check basename
-    if (excludeSet.has(name))
-        return true;
-    // Check path segments
-    const segments = filename.split("/");
-    return segments.some((seg) => excludeSet.has(seg));
-}
-// ── Watch engine ───────────────────────────────────────────────────────────
-export function startWatcher(config, onEvent) {
-    const { projectPath, spriteName, remotePath = "/app", debounceMs = 1500, autoInstall = true, packageManager = "npm", dopplerProject, npmToken, signal, } = config;
-    // State
-    let fsWatcher = null;
-    let debounceTimer = null;
-    let syncInFlight = false;
-    let pendingSyncQueued = false;
-    let needsInstall = false;
-    const pendingChanges = new Set();
-    const stats = {
-        totalSyncs: 0,
-        totalErrors: 0,
-        lastSyncMs: null,
-        lastSyncAt: null,
-        queuedFiles: 0,
-        syncing: false,
-    };
-    // Sync cycle
-    async function runSync() {
-        if (signal.aborted)
-            return;
-        syncInFlight = true;
-        stats.syncing = true;
-        const fileCount = pendingChanges.size;
-        const shouldInstall = needsInstall && autoInstall;
-        // Snapshot and clear
-        pendingChanges.clear();
-        needsInstall = false;
-        stats.queuedFiles = 0;
-        onEvent({ type: "sync_start", fileCount, needsInstall: shouldInstall });
-        const totalStart = Date.now();
-        let syncMs = 0;
-        let installMs = 0;
-        try {
-            const syncResult = await syncToSprite(spriteName, projectPath, remotePath);
-            syncMs = syncResult.syncDurationMs ?? 0;
-            if (!syncResult.success) {
-                throw new Error(syncResult.error ?? "Sync failed");
-            }
-            // Install if lockfiles changed
-            if (shouldInstall) {
-                const installStart = Date.now();
-                let installCmd = getInstallCommand(packageManager);
-                const env = {};
-                if (npmToken)
-                    env.NPM_TOKEN = npmToken;
-                if (dopplerProject) {
-                    installCmd = `doppler run -p ${dopplerProject} -c dev -- ${installCmd}`;
-                }
-                const installResult = await execOnSprite(spriteName, installCmd, {
-                    dir: remotePath,
-                    env,
-                });
-                installMs = Date.now() - installStart;
-                if (!installResult.success) {
-                    throw new Error(`Install failed: ${installResult.error}`);
-                }
-            }
-            const totalMs = Date.now() - totalStart;
-            stats.totalSyncs++;
-            stats.lastSyncMs = totalMs;
-            stats.lastSyncAt = new Date();
-            onEvent({ type: "sync_complete", syncMs, installMs, totalMs });
-        }
-        catch (err) {
-            stats.totalErrors++;
-            const message = err instanceof Error ? err.message : String(err);
-            onEvent({ type: "sync_error", error: message, retryable: true });
-        }
-        finally {
-            syncInFlight = false;
-            stats.syncing = false;
-            stats.queuedFiles = pendingChanges.size;
-            // If changes accumulated during sync, trigger another cycle
-            if (pendingSyncQueued && pendingChanges.size > 0 && !signal.aborted) {
-                pendingSyncQueued = false;
-                runSync();
-            }
-            else {
-                pendingSyncQueued = false;
-            }
-        }
-    }
-    // Debounced trigger
-    function scheduleSync() {
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        stats.queuedFiles = pendingChanges.size;
-        debounceTimer = setTimeout(() => {
-            debounceTimer = null;
-            if (syncInFlight) {
-                pendingSyncQueued = true;
-                return;
-            }
-            runSync();
-        }, debounceMs);
-    }
-    // Done promise — resolves when watcher fully stops
-    const done = new Promise((resolve) => {
-        const shutdown = async () => {
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            fsWatcher?.close();
-            fsWatcher = null;
-            // Wait for in-flight sync (max 30s)
-            if (syncInFlight) {
-                const deadline = Date.now() + 30_000;
-                while (syncInFlight && Date.now() < deadline) {
-                    await new Promise((r) => setTimeout(r, 200));
-                }
-            }
-            onEvent({ type: "stopped" });
-            resolve();
-        };
-        signal.addEventListener("abort", () => shutdown(), { once: true });
-        // If already aborted, shut down immediately
-        if (signal.aborted) {
-            shutdown();
-        }
-    });
-    // Start watching
-    fsWatcher = watch(projectPath, { recursive: true }, (_eventType, filename) => {
-        if (!filename)
-            return;
-        if (signal.aborted)
-            return;
-        if (shouldIgnoreFile(filename))
-            return;
-        pendingChanges.add(filename);
-        if (isLockfileChange(filename)) {
-            needsInstall = true;
-        }
-        scheduleSync();
-    });
-    fsWatcher.on("error", (err) => {
-        onEvent({ type: "sync_error", error: `Watcher error: ${err.message}`, retryable: false });
-    });
-    onEvent({ type: "started", projectPath });
-    return {
-        done,
-        stats: () => ({ ...stats, queuedFiles: pendingChanges.size }),
-    };
-}

package/dist/lib/project-identity.d.ts

@@ -1,16 +0,0 @@
-export declare const PROJECT_IDENTITY_FALLBACK_EMOJIS: readonly string[];
-export declare const PROJECT_IDENTITY_COLOR_HEXES: readonly string[];
-export declare function normalizeProjectName(name: string): string;
-export declare function projectIdentityHash(name: string): number;
-export declare function normalizeProjectEmoji(emoji?: string | null): string | undefined;
-export declare function normalizeProjectColorHex(color?: string | null): string | undefined;
-export declare function resolveProjectIdentity(name: string, identity?: {
-    emoji?: string | null;
-    color?: string | null;
-}): {
-    emoji: string;
-    color: string;
-};
-export declare function resolveProjectEmoji(name: string, emoji?: string | null): string;
-export declare function resolveProjectColor(name: string, color?: string | null): string;
-//# sourceMappingURL=project-identity.d.ts.map

package/dist/lib/project-identity.js

@@ -1,75 +0,0 @@
-// Generated by @lnittman/icons (scripts/sync-clients.mjs).
-export const PROJECT_IDENTITY_FALLBACK_EMOJIS = [
-    "🌑",
-    "🌙",
-    "🔮",
-    "🎱",
-    "👻",
-    "🦇",
-    "🕳️",
-    "🪨",
-    "🌿",
-    "🌊",
-    "☁️",
-    "⚡",
-];
-export const PROJECT_IDENTITY_COLOR_HEXES = [
-    "#bec2c8",
-    "#d67600",
-    "#c74440",
-    "#9f3f4f",
-    "#c4a000",
-    "#5f8c50",
-    "#2aa889",
-    "#00857c",
-    "#1b8dbf",
-    "#3067c6",
-    "#5b3fc5",
-    "#8338ec",
-    "#a4457a",
-    "#506480",
-    "#8b6f47",
-    "#2d3748",
-];
-const DEFAULT_PROJECT_EMOJI = "📁";
-const DEFAULT_PROJECT_COLOR = PROJECT_IDENTITY_COLOR_HEXES[0] ?? "#bec2c8";
-export function normalizeProjectName(name) {
-    return name.trim().toLowerCase();
-}
-export function projectIdentityHash(name) {
-    const normalized = normalizeProjectName(name);
-    if (!normalized)
-        return 0;
-    let hash = 0;
-    for (let i = 0; i < normalized.length; i++) {
-        hash = (Math.imul(hash, 31) + normalized.charCodeAt(i)) | 0;
-    }
-    return Math.abs(hash);
-}
-export function normalizeProjectEmoji(emoji) {
-    const trimmed = emoji?.trim();
-    return trimmed ? trimmed : undefined;
-}
-export function normalizeProjectColorHex(color) {
-    const trimmed = color?.trim();
-    if (!trimmed)
-        return undefined;
-    return /^#[0-9a-fA-F]{6}$/.test(trimmed) ? trimmed.toLowerCase() : undefined;
-}
-export function resolveProjectIdentity(name, identity) {
-    const hash = projectIdentityHash(name);
-    return {
-        emoji: normalizeProjectEmoji(identity?.emoji) ??
-            PROJECT_IDENTITY_FALLBACK_EMOJIS[hash % PROJECT_IDENTITY_FALLBACK_EMOJIS.length] ??
-            DEFAULT_PROJECT_EMOJI,
-        color: normalizeProjectColorHex(identity?.color) ??
-            PROJECT_IDENTITY_COLOR_HEXES[hash % PROJECT_IDENTITY_COLOR_HEXES.length] ??
-            DEFAULT_PROJECT_COLOR,
-    };
-}
-export function resolveProjectEmoji(name, emoji) {
-    return resolveProjectIdentity(name, { emoji }).emoji;
-}
-export function resolveProjectColor(name, color) {
-    return resolveProjectIdentity(name, { color }).color;
-}