opencode-sidebar 0.1.0

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./app.js";
+import { LauncherService } from "./lib/opencode.js";
+const service = new LauncherService();
+let cleanedUp = false;
+function renderApp() {
+    return _jsx(App, { service: service, onCleanup: cleanup });
+}
+async function cleanup() {
+    if (cleanedUp)
+        return;
+    cleanedUp = true;
+    await service.shutdown().catch(() => { });
+}
+process.on("SIGINT", () => {
+    void cleanup().finally(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+    void cleanup().finally(() => process.exit(0));
+});
+process.on("exit", () => {
+    void cleanup();
+});
+const instance = render(renderApp(), { exitOnCtrlC: false });
+process.stdout.on("resize", () => {
+    instance.clear();
+    instance.rerender(renderApp());
+});

package/dist/lib/constants.js

@@ -0,0 +1,17 @@
+import os from "node:os";
+import path from "node:path";
+export const APP_NAME = "opencode-sidebar";
+export const APP_DIR = process.env.OPENCODE_SIDEBAR_DIR ?? path.join(os.homedir(), ".local", "share", APP_NAME);
+export const STATE_FILE = path.join(APP_DIR, "state.json");
+export const SERVER_LOG_FILE = path.join(APP_DIR, "opencode-server.log");
+export const PRIVATE_DIRECTORY_MODE = 0o700;
+export const PRIVATE_FILE_MODE = 0o600;
+export const DEFAULT_PORT = 42112;
+export const SESSION_WINDOW_PREFIX = "opencode-session-";
+export const LAUNCHER_WORKSPACE = "opencode-sidebar-launcher";
+export const SERVER_HOST = "127.0.0.1";
+export const SESSION_PAGE_LIMIT = 500;
+export const WINDOW_POLL_INTERVAL_MS = 2000;
+export const SNAPSHOT_DEBOUNCE_MS = 150;
+export const STATUS_MESSAGE_HOLD_MS = 2500;
+export const MAX_BACKGROUND_SESSIONS = 6;

package/dist/lib/model.js

@@ -0,0 +1,93 @@
+import { directoryLabel, directorySubtitle } from "./util.js";
+function openSessionSet(panes) {
+    const result = new Set();
+    for (const pane of panes) {
+        if (!pane.workspace.startsWith("opencode-session-"))
+            continue;
+        result.add(pane.workspace.slice("opencode-session-".length));
+    }
+    return result;
+}
+function buildProjectMaps(projects) {
+    const byDirectory = new Map();
+    for (const project of projects) {
+        byDirectory.set(project.worktree, {
+            label: project.name,
+            root: project.worktree,
+        });
+        for (const sandbox of project.sandboxes) {
+            byDirectory.set(sandbox, {
+                root: project.worktree,
+            });
+        }
+    }
+    return byDirectory;
+}
+export function buildSnapshot(input) {
+    const projectMap = buildProjectMaps(input.projects);
+    const openedSessions = openSessionSet(input.panes);
+    const directoryMap = new Map();
+    const ensureDirectory = (directory) => {
+        let current = directoryMap.get(directory);
+        if (current)
+            return current;
+        const projectInfo = projectMap.get(directory);
+        current = {
+            directory,
+            label: directoryLabel(directory, projectInfo?.label),
+            subtitle: directorySubtitle(directory, projectInfo?.root),
+            pinned: input.pinnedDirectories.includes(directory),
+            sessions: [],
+            openSessionIDs: new Set(),
+            activeSessionIDs: new Set(),
+        };
+        directoryMap.set(directory, current);
+        return current;
+    };
+    for (const project of input.projects) {
+        ensureDirectory(project.worktree);
+        for (const sandbox of project.sandboxes)
+            ensureDirectory(sandbox);
+    }
+    for (const directory of input.pinnedDirectories) {
+        ensureDirectory(directory).pinned = true;
+    }
+    for (const session of input.sessions) {
+        const record = ensureDirectory(session.directory);
+        record.sessions.push(session);
+        record.lastUpdated = Math.max(record.lastUpdated ?? 0, session.time.updated);
+        if (openedSessions.has(session.id)) {
+            record.openSessionIDs.add(session.id);
+        }
+    }
+    for (const activeSession of input.activeSessions ?? []) {
+        const record = ensureDirectory(activeSession.directory);
+        record.activeSessionIDs.add(activeSession.sessionID);
+        record.openSessionIDs.add(activeSession.sessionID);
+    }
+    const pinnedRank = new Map(input.pinnedDirectories.map((directory, index) => [directory, index]));
+    const directories = [...directoryMap.values()]
+        .map((record) => ({
+        ...record,
+        sessions: [...record.sessions].sort((a, b) => b.time.updated - a.time.updated),
+    }))
+        .sort((a, b) => {
+        if (a.pinned !== b.pinned)
+            return a.pinned ? -1 : 1;
+        if (a.pinned && b.pinned)
+            return (pinnedRank.get(a.directory) ?? 0) - (pinnedRank.get(b.directory) ?? 0);
+        const recentA = a.lastUpdated ?? 0;
+        const recentB = b.lastUpdated ?? 0;
+        if (recentA !== recentB)
+            return recentB - recentA;
+        return a.label.localeCompare(b.label);
+    });
+    return {
+        directories,
+        activeSessions: input.activeSessions ?? [],
+        previewSessionID: input.previewSessionID,
+        serverPort: input.serverPort,
+        baseUrl: input.baseUrl,
+        loadedAt: Date.now(),
+    };
+}

package/dist/lib/notifications.js

@@ -0,0 +1,250 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+const MACOS_SOUND_DIR = "/System/Library/Sounds";
+const DEFAULT_ATTENTION_SOUND = "Glass";
+const DEFAULT_COMPLETION_SOUND = "Ping";
+const COMPLETION_SUPPRESSION_WINDOW_MS = 4_000;
+function sessionIsWorking(status) {
+    return status?.type === "busy" || status?.type === "retry";
+}
+function resolveConfiguredSoundPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const expanded = trimmed.startsWith("~/") ? path.join(process.env.HOME ?? "", trimmed.slice(2)) : trimmed;
+    if (expanded.includes("/") || expanded.startsWith(".")) {
+        return path.resolve(expanded);
+    }
+    const fileName = /\.(aiff|wav|caf|mp3|m4a)$/i.test(expanded) ? expanded : `${expanded}.aiff`;
+    return path.join(MACOS_SOUND_DIR, fileName);
+}
+function playTerminalBell() {
+    try {
+        process.stdout.write("\u0007");
+    }
+    catch {
+        // Ignore notifier fallback errors.
+    }
+}
+export function notificationAudioMode() {
+    if (process.env.OPENCODE_SIDEBAR_NOTIFY === "0")
+        return "off";
+    if (process.platform === "darwin")
+        return "afplay";
+    return "bell";
+}
+export function playNotificationEffect(effect) {
+    const mode = notificationAudioMode();
+    if (mode === "off")
+        return;
+    if (mode === "bell") {
+        playTerminalBell();
+        return;
+    }
+    const configuredSound = effect.kind === "attention"
+        ? process.env.OPENCODE_SIDEBAR_NOTIFY_ATTENTION_SOUND ?? DEFAULT_ATTENTION_SOUND
+        : process.env.OPENCODE_SIDEBAR_NOTIFY_COMPLETE_SOUND ?? DEFAULT_COMPLETION_SOUND;
+    const soundPath = resolveConfiguredSoundPath(configuredSound);
+    if (!soundPath || !fs.existsSync(soundPath)) {
+        playTerminalBell();
+        return;
+    }
+    const child = spawn("/usr/bin/afplay", [soundPath], {
+        stdio: "ignore",
+    });
+    child.once("error", () => {
+        playTerminalBell();
+    });
+    child.unref();
+}
+export class NotificationTracker {
+    now;
+    initialized = false;
+    busySessionIDs = new Set();
+    sessionByID = new Map();
+    seenQuestionRequestIDs = new Set();
+    seenPermissionRequestIDs = new Set();
+    lastCompletionAt = new Map();
+    constructor(now = () => Date.now()) {
+        this.now = now;
+    }
+    syncSnapshot(snapshot) {
+        const nextBusySessionIDs = new Set();
+        const nextSessionByID = new Map();
+        const effects = [];
+        for (const record of snapshot.directories) {
+            for (const session of record.sessions) {
+                nextSessionByID.set(session.id, {
+                    sessionID: session.id,
+                    title: session.title || "New session",
+                    directory: record.directory,
+                    updated: session.time.updated,
+                });
+                if (sessionIsWorking(session.status)) {
+                    nextBusySessionIDs.add(session.id);
+                }
+            }
+        }
+        if (this.initialized) {
+            for (const sessionID of this.busySessionIDs) {
+                if (nextBusySessionIDs.has(sessionID))
+                    continue;
+                const session = nextSessionByID.get(sessionID);
+                if (!session)
+                    continue;
+                const effect = this.maybeEmitCompletion(session);
+                if (effect)
+                    effects.push(effect);
+            }
+        }
+        else {
+            this.initialized = true;
+        }
+        for (const sessionID of this.lastCompletionAt.keys()) {
+            if (!nextSessionByID.has(sessionID)) {
+                this.lastCompletionAt.delete(sessionID);
+            }
+        }
+        this.busySessionIDs = nextBusySessionIDs;
+        this.sessionByID = nextSessionByID;
+        return effects;
+    }
+    syncPendingRequests(input) {
+        const effects = [];
+        const nextQuestionRequestIDs = new Set();
+        const nextPermissionRequestIDs = new Set();
+        for (const request of input.questions) {
+            nextQuestionRequestIDs.add(request.id);
+            if (this.seenQuestionRequestIDs.has(request.id))
+                continue;
+            const session = this.sessionByID.get(request.sessionID);
+            effects.push(this.createAttentionEffect(`question:${request.id}`, session?.title || "OpenCode needs input", session?.directory || "Pending question"));
+        }
+        for (const request of input.permissions) {
+            nextPermissionRequestIDs.add(request.id);
+            if (this.seenPermissionRequestIDs.has(request.id))
+                continue;
+            const session = this.sessionByID.get(request.sessionID);
+            effects.push(this.createAttentionEffect(`permission:${request.id}`, session?.title || "OpenCode needs approval", session?.directory || "Pending permission"));
+        }
+        this.seenQuestionRequestIDs = nextQuestionRequestIDs;
+        this.seenPermissionRequestIDs = nextPermissionRequestIDs;
+        return effects;
+    }
+    handleEvent(input) {
+        const { directory, event } = input;
+        switch (event.type) {
+            case "session.created":
+            case "session.updated":
+                this.updateSessionMeta({
+                    sessionID: event.properties.sessionID,
+                    title: event.properties.info.title || "New session",
+                    directory: event.properties.info.directory || directory,
+                    updated: event.properties.info.time.updated,
+                });
+                return [];
+            case "session.deleted":
+                this.sessionByID.delete(event.properties.sessionID);
+                this.busySessionIDs.delete(event.properties.sessionID);
+                this.lastCompletionAt.delete(event.properties.sessionID);
+                return [];
+            case "question.asked": {
+                if (this.seenQuestionRequestIDs.has(event.properties.id))
+                    return [];
+                this.seenQuestionRequestIDs.add(event.properties.id);
+                const session = this.sessionByID.get(event.properties.sessionID);
+                return [
+                    this.createAttentionEffect(`question:${event.properties.id}`, session?.title || "OpenCode needs input", session?.directory || directory),
+                ];
+            }
+            case "question.replied":
+            case "question.rejected":
+                this.seenQuestionRequestIDs.delete(event.properties.requestID);
+                return [];
+            case "permission.asked": {
+                if (this.seenPermissionRequestIDs.has(event.properties.id))
+                    return [];
+                this.seenPermissionRequestIDs.add(event.properties.id);
+                const session = this.sessionByID.get(event.properties.sessionID);
+                return [
+                    this.createAttentionEffect(`permission:${event.properties.id}`, session?.title || "OpenCode needs approval", session?.directory || directory),
+                ];
+            }
+            case "permission.replied":
+                this.seenPermissionRequestIDs.delete(event.properties.requestID);
+                return [];
+            case "session.status":
+                if (event.properties.status.type === "busy" || event.properties.status.type === "retry") {
+                    this.busySessionIDs.add(event.properties.sessionID);
+                    return [];
+                }
+                return this.completeFromEvent(event.properties.sessionID, directory);
+            case "session.idle":
+                return this.completeFromEvent(event.properties.sessionID, directory);
+            default:
+                return [];
+        }
+    }
+    completeFromEvent(sessionID, directory) {
+        if (!this.busySessionIDs.has(sessionID))
+            return [];
+        this.busySessionIDs.delete(sessionID);
+        const session = this.sessionByID.get(sessionID);
+        const effect = this.maybeEmitCompletion(session ?? {
+            sessionID,
+            title: "OpenCode finished processing",
+            directory,
+            updated: this.now(),
+        });
+        return effect ? [effect] : [];
+    }
+    createAttentionEffect(id, title, detail) {
+        return {
+            id,
+            kind: "attention",
+            title,
+            detail,
+        };
+    }
+    updateSessionMeta(session) {
+        this.sessionByID.set(session.sessionID, session);
+    }
+    maybeEmitCompletion(session) {
+        const now = this.now();
+        const lastCompletion = this.lastCompletionAt.get(session.sessionID) ?? 0;
+        if (now - lastCompletion < COMPLETION_SUPPRESSION_WINDOW_MS) {
+            return undefined;
+        }
+        this.lastCompletionAt.set(session.sessionID, now);
+        return {
+            id: `completion:${session.sessionID}:${session.updated}`,
+            kind: "completion",
+            title: session.title || "OpenCode finished processing",
+            detail: session.directory,
+        };
+    }
+}
+export class SoundNotifier {
+    dispatch;
+    tracker;
+    constructor(dispatch = playNotificationEffect) {
+        this.dispatch = dispatch;
+        this.tracker = new NotificationTracker();
+    }
+    syncSnapshot(snapshot) {
+        for (const effect of this.tracker.syncSnapshot(snapshot)) {
+            this.dispatch(effect);
+        }
+    }
+    syncPendingRequests(input) {
+        for (const effect of this.tracker.syncPendingRequests(input)) {
+            this.dispatch(effect);
+        }
+    }
+    handleEvent(input) {
+        for (const effect of this.tracker.handleEvent(input)) {
+            this.dispatch(effect);
+        }
+    }
+}