shortcutxl 0.3.76 → 0.3.78

package/dist/app/collab/collab-manager.js

@@ -1,218 +0,0 @@
-/**
- * CollabManager — orchestrates the full collaboration lifecycle.
- *
- * Pure app-layer class with no shell/TUI dependencies. Manages:
- * - CollabClient connection and room lifecycle
- * - CollabSync (CRDT workbook sync)
- * - CollabAwareness (peer sheet info broadcasting)
- * - Display name resolution
- *
- * Used by the interactive shell (/collab command), RPC mode, and tests.
- */
-import { CollabAwareness } from './awareness.js';
-import { CollabClient } from './collab-client.js';
-import { CollabSync } from './collab-sync.js';
-// ── File-based display name provider ───────────────────────────────────
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-const ADJECTIVES = [
-    'brave',
-    'calm',
-    'eager',
-    'fast',
-    'happy',
-    'keen',
-    'quick',
-    'sharp',
-    'bold',
-    'cool',
-    'fierce',
-    'witty',
-    'swift',
-    'wise',
-    'bright',
-    'chill'
-];
-const ANIMALS = [
-    'otter',
-    'fox',
-    'hawk',
-    'wolf',
-    'bear',
-    'lynx',
-    'crow',
-    'hare',
-    'puma',
-    'owl',
-    'stag',
-    'wren',
-    'seal',
-    'vole',
-    'dove',
-    'elk'
-];
-function randomName() {
-    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
-    const animal = ANIMALS[Math.floor(Math.random() * ANIMALS.length)];
-    const num = Math.floor(Math.random() * 100);
-    return `${adj}-${animal}-${num}`;
-}
-/** Persists display name to `<agentDir>/collab.json`. */
-export class FileDisplayNameProvider {
-    agentDir;
-    constructor(agentDir) {
-        this.agentDir = agentDir;
-    }
-    getOrCreate() {
-        const config = this.load();
-        if (config.displayName)
-            return { name: config.displayName, isNew: false };
-        const name = randomName();
-        this.save({ ...config, displayName: name });
-        return { name, isNew: true };
-    }
-    set(name) {
-        this.save({ ...this.load(), displayName: name });
-    }
-    get() {
-        return this.load().displayName;
-    }
-    configPath() {
-        return join(this.agentDir, 'collab.json');
-    }
-    load() {
-        const path = this.configPath();
-        if (!existsSync(path))
-            return {};
-        try {
-            return JSON.parse(readFileSync(path, 'utf-8'));
-        }
-        catch {
-            return {};
-        }
-    }
-    save(config) {
-        mkdirSync(this.agentDir, { recursive: true });
-        writeFileSync(this.configPath(), JSON.stringify(config, null, 2) + '\n');
-    }
-}
-/** Simple in-memory provider for tests. */
-export class StaticDisplayNameProvider {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-    getOrCreate() {
-        return { name: this.name, isNew: false };
-    }
-    set(name) {
-        this.name = name;
-    }
-    get() {
-        return this.name;
-    }
-}
-// ── CollabManager ──────────────────────────────────────────────────────
-export class CollabManager {
-    serverUrl;
-    pool;
-    displayNameProvider;
-    _client;
-    _sync = null;
-    _awareness = null;
-    constructor(serverUrl, pool, displayNameProvider) {
-        this.serverUrl = serverUrl;
-        this.pool = pool;
-        this.displayNameProvider = displayNameProvider;
-        this._client = new CollabClient(serverUrl);
-    }
-    /** The underlying CollabClient (for event wiring by modes). */
-    get client() {
-        return this._client;
-    }
-    get sync() {
-        return this._sync;
-    }
-    get awareness() {
-        return this._awareness;
-    }
-    // ── Room lifecycle ───────────────────────────────────────────────────
-    /** Create a new room and auto-join it. Returns the join result. */
-    async createRoom(displayName) {
-        const name = displayName ?? this.displayNameProvider.getOrCreate().name;
-        const roomId = await this._client.createRoom();
-        const result = await this._client.joinRoom(roomId, name);
-        this.attachSync();
-        this.attachAwareness();
-        return result;
-    }
-    /** Join an existing room by ID. Returns the join result. */
-    async joinRoom(roomId, displayName) {
-        const name = displayName ?? this.displayNameProvider.getOrCreate().name;
-        const result = await this._client.joinRoom(roomId, name);
-        this.attachSync();
-        this.attachAwareness();
-        return result;
-    }
-    /** Leave the current room and clean up sync/awareness. */
-    leave() {
-        this.detachSync();
-        this.detachAwareness();
-        this._client.leave();
-    }
-    /** Current collab status. */
-    getStatus() {
-        const { roomId, peerId, peers, connected } = this._client.state;
-        return {
-            connected,
-            roomId,
-            peerId,
-            peers: [...peers.values()]
-        };
-    }
-    /** Whether we're currently in a room. */
-    get inRoom() {
-        return this._client.state.roomId !== null;
-    }
-    // ── Display name ─────────────────────────────────────────────────────
-    getDisplayName() {
-        return this.displayNameProvider.getOrCreate();
-    }
-    setDisplayName(name) {
-        this.displayNameProvider.set(name);
-    }
-    currentDisplayName() {
-        return this.displayNameProvider.get();
-    }
-    // ── Cleanup ──────────────────────────────────────────────────────────
-    destroy() {
-        this.detachSync();
-        this.detachAwareness();
-        this._client.destroy();
-    }
-    // ── Private ──────────────────────────────────────────────────────────
-    attachSync() {
-        this._sync = new CollabSync(this._client, this.pool);
-        void this._sync.startSyncing();
-    }
-    detachSync() {
-        if (this._sync) {
-            this._sync.destroy();
-            this._sync = null;
-        }
-    }
-    attachAwareness() {
-        const activeWb = this.pool.activeWorkbookName;
-        if (!activeWb)
-            return;
-        const wb = this.pool.getWorkbook(activeWb);
-        this._awareness = new CollabAwareness(wb, this._client);
-    }
-    detachAwareness() {
-        if (this._awareness) {
-            this._awareness.destroy();
-            this._awareness = null;
-        }
-    }
-}
-//# sourceMappingURL=collab-manager.js.map

package/dist/app/collab/collab-sync.d.ts

@@ -1,62 +0,0 @@
-/**
- * CollabSync — orchestrates multi-doc CRDT sync between local workbooks
- * and a remote collaboration server.
- *
- * Each workbook in the SheetEnginePool gets a SyncBridge. Local mutations
- * are debounced and pushed as Yrs diffs. Incoming binary frames from the
- * server are routed to the correct bridge by doc ID.
- *
- * Engine creation uses `createHeadlessEngine({ yrsState })` which calls
- * `compute_init_from_yrs_state` in Rust — this preserves exact Yrs item
- * identities so that subsequent `syncApply` diffs merge correctly.
- * (See mog/plans/active/colab/round-7/root-cause.md for why the JSON
- * snapshot path is broken.)
- */
-import { type SheetEnginePool } from '@shortcut/mog-sandbox-runtime';
-import type { CollabClient } from './collab-client.js';
-export declare class CollabSync {
-    private client;
-    private pool;
-    private bridges;
-    private debounceTimers;
-    private unsubscribers;
-    private workbookEventUnsubs;
-    private destroyed;
-    /** Frames that arrived while handleInitialState was in progress. */
-    private pendingUpdates;
-    /** Docs currently being initialized (guards against concurrent handleInitialState). */
-    private initializing;
-    constructor(client: CollabClient, pool: SheetEnginePool);
-    /**
-     * Start syncing all current workbooks in the pool.
-     * Called after creating/joining a room.
-     */
-    startSyncing(): Promise<void>;
-    /**
-     * Handle initial state for a doc received from server (late joiner).
-     * Creates a new engine from raw Yrs state bytes, registers it in the pool,
-     * and starts syncing.
-     */
-    handleInitialState(docId: string, state: Uint8Array): Promise<void>;
-    /**
-     * Handle incoming binary from server — apply remote update to the correct bridge.
-     */
-    handleRemoteUpdate(docId: string, data: Uint8Array): Promise<void>;
-    destroy(): void;
-    /**
-     * Share a local workbook with the room — create a bridge, send full state,
-     * subscribe to mutation events.
-     */
-    private shareWorkbook;
-    /**
-     * Subscribe to workbook mutation events for outbound sync.
-     * Synchronous — uses activeSheet property to avoid async gaps where
-     * cell changes could be missed.
-     */
-    private subscribeToWorkbookEvents;
-    /**
-     * Push local Yrs changes to the server for a specific doc.
-     */
-    private pushLocalChanges;
-}
-//# sourceMappingURL=collab-sync.d.ts.map

package/dist/app/collab/collab-sync.js

@@ -1,215 +0,0 @@
-/**
- * CollabSync — orchestrates multi-doc CRDT sync between local workbooks
- * and a remote collaboration server.
- *
- * Each workbook in the SheetEnginePool gets a SyncBridge. Local mutations
- * are debounced and pushed as Yrs diffs. Incoming binary frames from the
- * server are routed to the correct bridge by doc ID.
- *
- * Engine creation uses `createHeadlessEngine({ yrsState })` which calls
- * `compute_init_from_yrs_state` in Rust — this preserves exact Yrs item
- * identities so that subsequent `syncApply` diffs merge correctly.
- * (See mog/plans/active/colab/round-7/root-cause.md for why the JSON
- * snapshot path is broken.)
- */
-import { createHeadlessEngine } from '@shortcut/mog-sandbox-runtime';
-import { SyncBridge } from './sync-bridge.js';
-// ── CollabSync ──────────────────────────────────────────────────────────
-export class CollabSync {
-    client;
-    pool;
-    bridges = new Map();
-    debounceTimers = new Map();
-    unsubscribers = [];
-    workbookEventUnsubs = new Map();
-    destroyed = false;
-    /** Frames that arrived while handleInitialState was in progress. */
-    pendingUpdates = new Map();
-    /** Docs currently being initialized (guards against concurrent handleInitialState). */
-    initializing = new Set();
-    constructor(client, pool) {
-        this.client = client;
-        this.pool = pool;
-        // Wire incoming binary frames from server
-        client.on('onSyncData', (docId, data) => {
-            this.handleRemoteUpdate(docId, data);
-        });
-        // React to new workbooks added to the pool while in a room
-        const unsub = pool.onWorkbookAdded((name, wb) => {
-            if (this.destroyed)
-                return;
-            // Only sync workbooks we don't already have a bridge for
-            if (!this.bridges.has(name)) {
-                void this.shareWorkbook(name, wb);
-            }
-        });
-        this.unsubscribers.push(unsub);
-    }
-    /**
-     * Start syncing all current workbooks in the pool.
-     * Called after creating/joining a room.
-     */
-    async startSyncing() {
-        const names = this.pool.listWorkbooks();
-        for (const name of names) {
-            const wb = this.pool.getWorkbook(name);
-            await this.shareWorkbook(name, wb);
-        }
-    }
-    /**
-     * Handle initial state for a doc received from server (late joiner).
-     * Creates a new engine from raw Yrs state bytes, registers it in the pool,
-     * and starts syncing.
-     */
-    async handleInitialState(docId, state) {
-        if (this.bridges.has(docId))
-            return;
-        if (this.initializing.has(docId))
-            return; // already creating — caller will buffer
-        this.initializing.add(docId);
-        try {
-            // Create engine from raw Yrs bytes — preserves exact Yrs item identities
-            // so that subsequent syncApply diffs merge correctly.
-            const addon = SyncBridge.getNativeAddon();
-            const engine = await createHeadlessEngine({
-                computeAddon: addon,
-                yrsState: state
-            });
-            const wb = engine.workbook;
-            const bridge = new SyncBridge(wb);
-            this.bridges.set(docId, bridge);
-            this.pool.registerWorkbook(docId, wb);
-            this.subscribeToWorkbookEvents(docId, wb);
-            // Drain any frames that arrived while we were creating the engine
-            const buffered = this.pendingUpdates.get(docId);
-            if (buffered) {
-                this.pendingUpdates.delete(docId);
-                for (const update of buffered) {
-                    try {
-                        await bridge.applyUpdate(update);
-                    }
-                    catch {
-                        /* best effort */
-                    }
-                }
-            }
-        }
-        catch (err) {
-            console.error(`[CollabSync] Failed to create workbook from Yrs state for "${docId}":`, err);
-        }
-        finally {
-            this.initializing.delete(docId);
-        }
-    }
-    /**
-     * Handle incoming binary from server — apply remote update to the correct bridge.
-     */
-    async handleRemoteUpdate(docId, data) {
-        if (this.initializing.has(docId)) {
-            // Engine is being created — buffer this frame for later
-            let buf = this.pendingUpdates.get(docId);
-            if (!buf) {
-                buf = [];
-                this.pendingUpdates.set(docId, buf);
-            }
-            buf.push(data);
-            return;
-        }
-        if (!this.bridges.has(docId)) {
-            await this.handleInitialState(docId, data);
-            return;
-        }
-        // Incremental update — syncApply merges the Yrs diff into the engine
-        try {
-            const bridge = this.bridges.get(docId);
-            if (!bridge)
-                return;
-            await bridge.applyUpdate(data);
-        }
-        catch (err) {
-            console.error(`[CollabSync] Failed to apply remote update for "${docId}":`, err);
-        }
-    }
-    destroy() {
-        this.destroyed = true;
-        for (const unsub of this.unsubscribers)
-            unsub();
-        this.unsubscribers = [];
-        for (const [, unsubs] of this.workbookEventUnsubs) {
-            for (const unsub of unsubs)
-                unsub();
-        }
-        this.workbookEventUnsubs.clear();
-        for (const [, timer] of this.debounceTimers)
-            clearTimeout(timer);
-        this.debounceTimers.clear();
-        this.bridges.clear();
-        this.pendingUpdates.clear();
-        this.initializing.clear();
-    }
-    // ── Private ────────────────────────────────────────────────────────────
-    /**
-     * Share a local workbook with the room — create a bridge, send full state,
-     * subscribe to mutation events.
-     */
-    async shareWorkbook(name, wb) {
-        try {
-            const bridge = new SyncBridge(wb);
-            this.bridges.set(name, bridge);
-            // Subscribe to events FIRST (synchronously) so no cell changes are
-            // missed between sending the initial state and subscribing.
-            this.subscribeToWorkbookEvents(name, wb);
-            // Then send full Yrs state to server
-            const fullState = await bridge.getFullState();
-            this.client.sendSyncData(name, fullState);
-        }
-        catch (err) {
-            console.error(`[CollabSync] Failed to share workbook "${name}":`, err);
-        }
-    }
-    /**
-     * Subscribe to workbook mutation events for outbound sync.
-     * Synchronous — uses activeSheet property to avoid async gaps where
-     * cell changes could be missed.
-     */
-    subscribeToWorkbookEvents(docId, wb) {
-        const unsubs = [];
-        const pushDebounced = () => {
-            if (this.destroyed)
-                return;
-            const existing = this.debounceTimers.get(docId);
-            if (existing)
-                clearTimeout(existing);
-            this.debounceTimers.set(docId, setTimeout(() => {
-                void this.pushLocalChanges(docId);
-            }, 50));
-        };
-        // Subscribe to active sheet events (synchronous — no missed events)
-        const activeSheet = wb.activeSheet;
-        if (activeSheet) {
-            unsubs.push(activeSheet.on('cellChanged', pushDebounced));
-            unsubs.push(activeSheet.on('structureChanged', pushDebounced));
-        }
-        // Workbook-level events (also synchronous)
-        unsubs.push(wb.on('sheetAdded', pushDebounced));
-        unsubs.push(wb.on('sheetRemoved', pushDebounced));
-        unsubs.push(wb.on('sheetRenamed', pushDebounced));
-        this.workbookEventUnsubs.set(docId, unsubs);
-    }
-    /**
-     * Push local Yrs changes to the server for a specific doc.
-     */
-    async pushLocalChanges(docId) {
-        const bridge = this.bridges.get(docId);
-        if (!bridge || this.destroyed)
-            return;
-        try {
-            const state = await bridge.getFullState();
-            this.client.sendSyncData(docId, state);
-        }
-        catch (err) {
-            console.error(`[CollabSync] Failed to push changes for "${docId}":`, err);
-        }
-    }
-}
-//# sourceMappingURL=collab-sync.js.map

package/dist/app/collab/index.d.ts

@@ -1,9 +0,0 @@
-export { CollabAwareness } from './awareness.js';
-export { CollabClient } from './collab-client.js';
-export type { JoinResult } from './collab-client.js';
-export { CollabManager, FileDisplayNameProvider, StaticDisplayNameProvider } from './collab-manager.js';
-export type { CollabStatus, DisplayNameProvider } from './collab-manager.js';
-export { CollabSync } from './collab-sync.js';
-export { SyncBridge } from './sync-bridge.js';
-export type { CollabCallbacks, CollabState, PeerInfo, ServerMessage, SheetInfo } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/app/collab/index.js

@@ -1,6 +0,0 @@
-export { CollabAwareness } from './awareness.js';
-export { CollabClient } from './collab-client.js';
-export { CollabManager, FileDisplayNameProvider, StaticDisplayNameProvider } from './collab-manager.js';
-export { CollabSync } from './collab-sync.js';
-export { SyncBridge } from './sync-bridge.js';
-//# sourceMappingURL=index.js.map

package/dist/app/collab/super-fight.d.ts

@@ -1,90 +0,0 @@
-/**
- * Super Fight — Multiplayer ASCII fighting game engine.
- *
- * Headless game logic: state, physics, hit detection, sprite rendering,
- * frame composition, and network message encoding. Zero TUI dependencies.
- */
-export declare const VIEWPORT_W = 80;
-export declare const VIEWPORT_H = 40;
-export declare const GROUND_Y = 34;
-export declare const GRAVITY = 0.8;
-export declare const JUMP_VY = -8;
-export declare const MOVE_SPEED = 2;
-export declare const PUNCH_RANGE = 2;
-export declare const KICK_RANGE = 3;
-export declare const DAMAGE = 10;
-export declare const MAX_HEALTH = 100;
-export declare const RESPAWN_TIME = 3000;
-export declare const TICK_MS = 66;
-export declare const SPRITE_W = 5;
-export declare const SPRITE_H = 5;
-export declare const GAME_MSG_PREFIX = "\u0001GAME:";
-/** 8 bright ANSI colors for up to 8 players (wraps if more) */
-export declare const PLAYER_COLORS: readonly ["\u001B[91m", "\u001B[92m", "\u001B[93m", "\u001B[94m", "\u001B[95m", "\u001B[96m", "\u001B[97m", "\u001B[33m"];
-export declare const RESET = "\u001B[0m";
-export type GameAction = 'idle' | 'walk-left' | 'walk-right' | 'jump' | 'crouch' | 'punch' | 'kick' | 'hit' | 'dead';
-export type Facing = 'left' | 'right';
-export interface PlayerState {
-    x: number;
-    y: number;
-    vy: number;
-    action: GameAction;
-    facing: Facing;
-    health: number;
-    kills: number;
-    respawnTimer: number;
-    color: string;
-    displayName: string;
-    /** Tick counter for action animation (punch/kick last a few ticks) */
-    actionTimer: number;
-}
-export type GameState = Map<string, PlayerState>;
-export type GameMessage = {
-    type: 'start';
-} | {
-    type: 'state';
-    peerId: string;
-    x: number;
-    y: number;
-    vy: number;
-    action: GameAction;
-    facing: Facing;
-    health: number;
-    kills: number;
-} | {
-    type: 'hit';
-    targetId: string;
-    damage: number;
-} | {
-    type: 'quit';
-};
-export declare function encodeGameMsg(msg: GameMessage): string;
-export declare function decodeGameMsg(text: string): GameMessage | null;
-export declare function createPlayer(displayName: string, colorIndex: number, x?: number): PlayerState;
-/**
- * Returns a 5-line array of the ASCII fighter sprite for the given pose.
- * All sprites are exactly SPRITE_W (5) chars wide.
- * `facing` flips the sprite horizontally.
- */
-export declare function renderSprite(action: GameAction, facing: Facing): string[];
-/**
- * Renders a complete game frame as an array of VIEWPORT_H strings,
- * each exactly VIEWPORT_W chars. No ANSI colors — caller wraps with color.
- * Returns { lines, colors } where colors[row][col] is the ANSI color code.
- */
-export declare function renderFrame(state: GameState, viewportW?: number, viewportH?: number): string[];
-/**
- * Update a single player's physics for one tick.
- * `dt` is the number of ticks elapsed (usually 1).
- */
-export declare function tickPlayer(player: PlayerState, dt?: number): void;
-/**
- * Check whether `attacker` is currently hitting `target`.
- * Returns true if the attacker is punching/kicking and the target is in range.
- */
-export declare function checkHit(attacker: PlayerState, target: PlayerState): boolean;
-/**
- * Apply damage to a target. Returns true if the hit killed them.
- */
-export declare function applyDamage(target: PlayerState, amount: number): boolean;
-//# sourceMappingURL=super-fight.d.ts.map