@vibedeckx/linux-x64 0.1.10

package/dist/command.d.ts

@@ -0,0 +1 @@
+export declare const program: import("@stricli/core").Application<import("@stricli/core").CommandContext>;

package/dist/command.js

@@ -0,0 +1,163 @@
+import path from "node:path";
+import { buildApplication, buildCommand, buildRouteMap } from "@stricli/core";
+import { createSqliteStorage } from "./storage/sqlite.js";
+import { createServer } from "./server.js";
+import { ReverseConnectClient } from "./reverse-connect-client.js";
+import { DB_PATH, DEFAULT_PORT } from "./constants.js";
+import open from "open";
+const startCommand = buildCommand({
+    parameters: {
+        flags: {
+            port: {
+                kind: "parsed",
+                parse: parseInt,
+                brief: "Port to run the server on",
+                optional: true,
+            },
+            auth: {
+                kind: "boolean",
+                brief: "Enable Clerk authentication (requires CLERK_SECRET_KEY and CLERK_PUBLISHABLE_KEY env vars)",
+                optional: true,
+            },
+            "data-dir": {
+                kind: "parsed",
+                parse: String,
+                brief: "Directory for storing database file (default: ~/.vibedeckx)",
+                optional: true,
+            },
+        },
+    },
+    func: async (flags) => {
+        const port = flags.port ?? DEFAULT_PORT;
+        const authEnabled = flags.auth ?? false;
+        console.log("Starting vibedeckx...");
+        const dbPath = flags["data-dir"]
+            ? path.join(flags["data-dir"], "data.sqlite")
+            : DB_PATH;
+        const storage = await createSqliteStorage(dbPath);
+        const server = await createServer({ storage, authEnabled });
+        const url = await server.start(port);
+        console.log(`Server running at ${url}`);
+        // 打开浏览器
+        await open(url);
+        // Graceful shutdown with re-entrancy guard and force-exit timeout
+        let shuttingDown = false;
+        const cleanup = async () => {
+            if (shuttingDown) {
+                console.log("\nForce exiting...");
+                process.exit(1);
+            }
+            shuttingDown = true;
+            console.log("\nShutting down...");
+            // Force exit after 5 seconds if cleanup hangs
+            const forceExit = setTimeout(() => {
+                console.log("Shutdown timed out, force exiting...");
+                process.exit(1);
+            }, 5000);
+            forceExit.unref();
+            try {
+                await server.close(); // triggers onClose hooks that kill child processes
+                storage.close();
+            }
+            catch (err) {
+                console.error("Error during shutdown:", err);
+            }
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    },
+    docs: {
+        brief: "Start the vibedeckx server",
+    },
+});
+const connectCommand = buildCommand({
+    parameters: {
+        flags: {
+            "connect-to": {
+                kind: "parsed",
+                parse: String,
+                brief: "URL of the Vibedeckx server to connect to",
+            },
+            token: {
+                kind: "parsed",
+                parse: String,
+                brief: "Authentication token for the reverse connection",
+            },
+            port: {
+                kind: "parsed",
+                parse: parseInt,
+                brief: "Local port for the server (default: 5173)",
+                optional: true,
+            },
+            "data-dir": {
+                kind: "parsed",
+                parse: String,
+                brief: "Directory for storing database file (default: ~/.vibedeckx)",
+                optional: true,
+            },
+        },
+    },
+    func: async (flags) => {
+        const requestedPort = flags.port ?? 0;
+        console.log("Starting vibedeckx in reverse-connect mode...");
+        const dbPath = flags["data-dir"]
+            ? path.join(flags["data-dir"], "data.sqlite")
+            : DB_PATH;
+        const storage = await createSqliteStorage(dbPath);
+        const server = await createServer({ storage });
+        // Start local server on localhost only (not publicly exposed)
+        // Port 0 lets the OS pick a random available port
+        const { instance, port: localPort } = await server.startLocal(requestedPort);
+        console.log(`Local server running on 127.0.0.1:${localPort}`);
+        // Create and start the reverse-connect client
+        const client = new ReverseConnectClient(instance, flags["connect-to"], flags.token, localPort);
+        client.connect();
+        console.log(`Connecting to ${flags["connect-to"]}...`);
+        // Graceful shutdown
+        let shuttingDown = false;
+        const cleanup = async () => {
+            if (shuttingDown) {
+                console.log("\nForce exiting...");
+                process.exit(1);
+            }
+            shuttingDown = true;
+            console.log("\nShutting down...");
+            const forceExit = setTimeout(() => {
+                console.log("Shutdown timed out, force exiting...");
+                process.exit(1);
+            }, 5000);
+            forceExit.unref();
+            try {
+                client.shutdown();
+                await server.close();
+                storage.close();
+            }
+            catch (err) {
+                console.error("Error during shutdown:", err);
+            }
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    },
+    docs: {
+        brief: "Connect to a remote Vibedeckx server as an inbound node",
+    },
+});
+const routes = buildRouteMap({
+    routes: {
+        start: startCommand,
+        connect: connectCommand,
+    },
+    defaultCommand: "start",
+    docs: {
+        brief: "Vibedeckx - AI-powered app generator",
+    },
+});
+export const program = buildApplication(routes, {
+    name: "vibedeckx",
+    versionInfo: {
+        currentVersion: "0.1.0",
+    },
+});

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const VIBEDECKX_HOME: string;
+export declare const DB_PATH: string;
+export declare const DEFAULT_PORT = 5173;

package/dist/constants.js

@@ -0,0 +1,5 @@
+import { homedir } from "os";
+import path from "path";
+export const VIBEDECKX_HOME = path.join(homedir(), ".vibedeckx");
+export const DB_PATH = path.join(VIBEDECKX_HOME, "data.sqlite");
+export const DEFAULT_PORT = 5173;

package/dist/conversation-patch.d.ts

@@ -0,0 +1,103 @@
+/**
+ * RFC 6902 JSON Patch utilities for conversation updates
+ */
+import type { AgentMessage } from "./agent-types.js";
+export type PatchOperation = "add" | "replace" | "remove";
+export interface PatchEntry {
+    op: PatchOperation;
+    path: string;
+    value?: PatchValue;
+}
+export type Patch = PatchEntry[];
+/**
+ * PatchType discriminated union
+ */
+export type PatchValue = {
+    type: "ENTRY";
+    content: AgentMessage;
+} | {
+    type: "STATUS";
+    content: AgentSessionStatus;
+} | {
+    type: "READY";
+    content: true;
+} | {
+    type: "FINISHED";
+    content: true;
+};
+export type AgentSessionStatus = "running" | "stopped" | "error";
+/**
+ * Messages sent over WebSocket to frontend
+ */
+export type AgentWsMessage = {
+    JsonPatch: Patch;
+} | {
+    Ready: true;
+} | {
+    finished: true;
+} | {
+    error: string;
+} | {
+    taskCompleted: {
+        duration_ms?: number;
+        cost_usd?: number;
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+} | {
+    browserCommand: BrowserCommand;
+} | {
+    openPreviewFrame: {
+        projectId: string;
+        url: string;
+    };
+};
+/**
+ * Browser command sent from backend to frontend via WebSocket.
+ * Frontend forwards to iframe's injected script via postMessage.
+ */
+export interface BrowserCommand {
+    id: string;
+    action: "click" | "fill" | "select" | "pressKey" | "getText" | "getHTML" | "querySelector";
+    selector?: string;
+    value?: string;
+    key?: string;
+}
+/**
+ * Browser command result sent from frontend back to backend via WebSocket.
+ */
+export interface BrowserCommandResult {
+    id: string;
+    success: boolean;
+    error?: string;
+    content?: string;
+    found?: boolean;
+    tag?: string;
+    text?: string;
+}
+/**
+ * ConversationPatch - Static utility for creating RFC 6902 patches
+ */
+export declare const ConversationPatch: {
+    /**
+     * Create an ADD patch for a new entry at the given index
+     */
+    addEntry(entryIndex: number, entry: AgentMessage): Patch;
+    /**
+     * Create a REPLACE patch for updating an existing entry
+     */
+    replaceEntry(entryIndex: number, entry: AgentMessage): Patch;
+    /**
+     * Create a REMOVE patch for deleting an entry
+     */
+    removeEntry(entryIndex: number): Patch;
+    /**
+     * Create a status update patch
+     */
+    updateStatus(status: AgentSessionStatus): Patch;
+    /**
+     * Create a patch to clear all entries (for session restart)
+     * Uses a special path "/entries" with "replace" to signal full clear
+     */
+    clearAll(): Patch;
+};

package/dist/conversation-patch.js

@@ -0,0 +1,69 @@
+/**
+ * RFC 6902 JSON Patch utilities for conversation updates
+ */
+// ============ Conversation Patch Builder ============
+/**
+ * ConversationPatch - Static utility for creating RFC 6902 patches
+ */
+export const ConversationPatch = {
+    /**
+     * Create an ADD patch for a new entry at the given index
+     */
+    addEntry(entryIndex, entry) {
+        return [
+            {
+                op: "add",
+                path: `/entries/${entryIndex}`,
+                value: { type: "ENTRY", content: entry },
+            },
+        ];
+    },
+    /**
+     * Create a REPLACE patch for updating an existing entry
+     */
+    replaceEntry(entryIndex, entry) {
+        return [
+            {
+                op: "replace",
+                path: `/entries/${entryIndex}`,
+                value: { type: "ENTRY", content: entry },
+            },
+        ];
+    },
+    /**
+     * Create a REMOVE patch for deleting an entry
+     */
+    removeEntry(entryIndex) {
+        return [
+            {
+                op: "remove",
+                path: `/entries/${entryIndex}`,
+            },
+        ];
+    },
+    /**
+     * Create a status update patch
+     */
+    updateStatus(status) {
+        return [
+            {
+                op: "replace",
+                path: "/status",
+                value: { type: "STATUS", content: status },
+            },
+        ];
+    },
+    /**
+     * Create a patch to clear all entries (for session restart)
+     * Uses a special path "/entries" with "replace" to signal full clear
+     */
+    clearAll() {
+        return [
+            {
+                op: "replace",
+                path: "/entries",
+                value: { type: "ENTRY", content: { type: "system", content: "__CLEAR_ALL__", timestamp: Date.now() } },
+            },
+        ];
+    },
+};

package/dist/dialog.d.ts

@@ -0,0 +1 @@
+export declare const selectFolder: () => Promise<string | null>;

package/dist/dialog.js

@@ -0,0 +1,41 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+const execAsync = promisify(exec);
+export const selectFolder = async () => {
+    const os = platform();
+    try {
+        if (os === "darwin") {
+            // macOS: 使用 osascript
+            const { stdout } = await execAsync(`osascript -e 'set folderPath to POSIX path of (choose folder with prompt "Select a project folder")' -e 'return folderPath'`);
+            const path = stdout.trim();
+            return path || null;
+        }
+        else if (os === "win32") {
+            // Windows: 使用 PowerShell
+            const { stdout } = await execAsync(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $f = New-Object System.Windows.Forms.FolderBrowserDialog; $f.ShowDialog() | Out-Null; $f.SelectedPath"`);
+            const path = stdout.trim();
+            return path || null;
+        }
+        else {
+            // Linux: 尝试 zenity，然后 kdialog
+            try {
+                const { stdout } = await execAsync(`zenity --file-selection --directory --title="Select a project folder"`);
+                return stdout.trim() || null;
+            }
+            catch {
+                try {
+                    const { stdout } = await execAsync(`kdialog --getexistingdirectory ~`);
+                    return stdout.trim() || null;
+                }
+                catch {
+                    throw new Error("No file dialog available. Please install zenity or kdialog.");
+                }
+            }
+        }
+    }
+    catch (error) {
+        // 用户取消选择
+        return null;
+    }
+};

package/dist/entry-index-provider.d.ts

@@ -0,0 +1,74 @@
+/**
+ * EntryIndexProvider - Provides monotonically increasing indices for entries
+ * Matches vibe-kanban's pattern for thread-safe index management
+ */
+/**
+ * Provides unique, monotonically increasing indices for conversation entries.
+ * Can be cloned to share the same counter across multiple processors.
+ */
+export declare class EntryIndexProvider {
+    private currentIndex;
+    constructor(startAt?: number);
+    /**
+     * Get the next available index (increments the counter)
+     */
+    next(): number;
+    /**
+     * Get the current index without incrementing
+     */
+    current(): number;
+    /**
+     * Reset the counter to 0
+     */
+    reset(): void;
+    /**
+     * Set the counter to a specific value
+     */
+    setIndex(index: number): void;
+    /**
+     * Clone the provider (shares nothing - creates independent copy)
+     * For shared state, use the same instance directly
+     */
+    clone(): EntryIndexProvider;
+}
+/**
+ * Tracks which message index corresponds to which entry index.
+ * Useful for tracking the last assistant message for streaming updates.
+ */
+export declare class EntryTracker {
+    private entryIndices;
+    private indexProvider;
+    constructor(indexProvider: EntryIndexProvider);
+    /**
+     * Get or create an entry index for a given key.
+     * Returns { index, isNew } to indicate if this is a new entry.
+     */
+    getOrCreate(key: string): {
+        index: number;
+        isNew: boolean;
+    };
+    /**
+     * Get the entry index for a key, or undefined if not tracked
+     */
+    get(key: string): number | undefined;
+    /**
+     * Check if a key is being tracked
+     */
+    has(key: string): boolean;
+    /**
+     * Directly set an entry index for a key (used during session restoration)
+     */
+    set(key: string, index: number): void;
+    /**
+     * Remove tracking for a key
+     */
+    remove(key: string): boolean;
+    /**
+     * Clear all tracked entries
+     */
+    clear(): void;
+    /**
+     * Get the underlying index provider
+     */
+    getProvider(): EntryIndexProvider;
+}

package/dist/entry-index-provider.js

@@ -0,0 +1,105 @@
+/**
+ * EntryIndexProvider - Provides monotonically increasing indices for entries
+ * Matches vibe-kanban's pattern for thread-safe index management
+ */
+/**
+ * Provides unique, monotonically increasing indices for conversation entries.
+ * Can be cloned to share the same counter across multiple processors.
+ */
+export class EntryIndexProvider {
+    currentIndex;
+    constructor(startAt = 0) {
+        this.currentIndex = startAt;
+    }
+    /**
+     * Get the next available index (increments the counter)
+     */
+    next() {
+        return this.currentIndex++;
+    }
+    /**
+     * Get the current index without incrementing
+     */
+    current() {
+        return this.currentIndex;
+    }
+    /**
+     * Reset the counter to 0
+     */
+    reset() {
+        this.currentIndex = 0;
+    }
+    /**
+     * Set the counter to a specific value
+     */
+    setIndex(index) {
+        this.currentIndex = index;
+    }
+    /**
+     * Clone the provider (shares nothing - creates independent copy)
+     * For shared state, use the same instance directly
+     */
+    clone() {
+        return new EntryIndexProvider(this.currentIndex);
+    }
+}
+/**
+ * Tracks which message index corresponds to which entry index.
+ * Useful for tracking the last assistant message for streaming updates.
+ */
+export class EntryTracker {
+    entryIndices = new Map();
+    indexProvider;
+    constructor(indexProvider) {
+        this.indexProvider = indexProvider;
+    }
+    /**
+     * Get or create an entry index for a given key.
+     * Returns { index, isNew } to indicate if this is a new entry.
+     */
+    getOrCreate(key) {
+        const existing = this.entryIndices.get(key);
+        if (existing !== undefined) {
+            return { index: existing, isNew: false };
+        }
+        const newIndex = this.indexProvider.next();
+        this.entryIndices.set(key, newIndex);
+        return { index: newIndex, isNew: true };
+    }
+    /**
+     * Get the entry index for a key, or undefined if not tracked
+     */
+    get(key) {
+        return this.entryIndices.get(key);
+    }
+    /**
+     * Check if a key is being tracked
+     */
+    has(key) {
+        return this.entryIndices.has(key);
+    }
+    /**
+     * Directly set an entry index for a key (used during session restoration)
+     */
+    set(key, index) {
+        this.entryIndices.set(key, index);
+    }
+    /**
+     * Remove tracking for a key
+     */
+    remove(key) {
+        return this.entryIndices.delete(key);
+    }
+    /**
+     * Clear all tracked entries
+     */
+    clear() {
+        this.entryIndices.clear();
+    }
+    /**
+     * Get the underlying index provider
+     */
+    getProvider() {
+        return this.indexProvider;
+    }
+}

package/dist/event-bus.d.ts

@@ -0,0 +1,47 @@
+export type GlobalEvent = {
+    type: "session:status";
+    projectId: string;
+    branch: string | null;
+    sessionId: string;
+    status: "running" | "stopped" | "error";
+    agentType?: string;
+} | {
+    type: "session:finished";
+    projectId: string;
+    branch: string | null;
+    sessionId: string;
+    duration_ms?: number;
+    cost_usd?: number;
+    agentType?: string;
+} | {
+    type: "task:created";
+    projectId: string;
+    task: Record<string, unknown>;
+} | {
+    type: "task:updated";
+    projectId: string;
+    task: Record<string, unknown>;
+} | {
+    type: "task:deleted";
+    projectId: string;
+    taskId: string;
+} | {
+    type: "executor:started";
+    projectId: string;
+    executorId: string;
+    processId: string;
+    target?: string;
+} | {
+    type: "executor:stopped";
+    projectId: string;
+    executorId: string;
+    processId: string;
+    exitCode: number;
+    target?: string;
+};
+export declare class EventBus {
+    private emitter;
+    constructor();
+    emit(event: GlobalEvent): void;
+    subscribe(listener: (event: GlobalEvent) => void): () => void;
+}

package/dist/event-bus.js

@@ -0,0 +1,16 @@
+import { EventEmitter } from "events";
+export class EventBus {
+    emitter = new EventEmitter();
+    constructor() {
+        this.emitter.setMaxListeners(100);
+    }
+    emit(event) {
+        this.emitter.emit("event", event);
+    }
+    subscribe(listener) {
+        this.emitter.on("event", listener);
+        return () => {
+            this.emitter.off("event", listener);
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createServer } from "./server.js";
+export { createSqliteStorage } from "./storage/sqlite.js";
+export type { Storage, Project } from "./storage/types.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createServer } from "./server.js";
+export { createSqliteStorage } from "./storage/sqlite.js";

package/dist/plugins/shared-services.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyPluginAsync } from "fastify";
+import type { Storage } from "../storage/types.js";
+import "../server-types.js";
+interface SharedServicesOptions {
+    storage: Storage;
+}
+declare const _default: FastifyPluginAsync<SharedServicesOptions>;
+export default _default;