opencode-sidebar 0.1.0

package/dist/lib/opencode.js

@@ -0,0 +1,366 @@
+import net from "node:net";
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { DEFAULT_PORT, PRIVATE_DIRECTORY_MODE, PRIVATE_FILE_MODE, SERVER_HOST, SERVER_LOG_FILE, SESSION_PAGE_LIMIT, SNAPSHOT_DEBOUNCE_MS, } from "./constants.js";
+import { buildSnapshot } from "./model.js";
+import { SoundNotifier } from "./notifications.js";
+import { loadState, saveState, updateState } from "./state.js";
+import { assertDirectoryExists, normalizeDirectory, sleep } from "./util.js";
+import { describeTerminalBackend, getPreviewSessionID, killSessionWindow, listActiveSessions, openSessionWithPreferredTerminal, retitleSessionWindow, } from "./terminal.js";
+const RECENT_COMPLETION_WINDOW_MS = 5 * 60_000;
+async function isHealthy(port) {
+    try {
+        const response = await fetch(`http://${SERVER_HOST}:${port}/global/health`);
+        if (!response.ok)
+            return false;
+        const json = (await response.json());
+        return json.healthy === true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once("error", () => resolve(false));
+        server.once("listening", () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, SERVER_HOST);
+    });
+}
+async function nextFreePort(start) {
+    for (let port = start; port < start + 50; port++) {
+        if (await isPortAvailable(port))
+            return port;
+    }
+    throw new Error("Could not find a free local port for opencode serve");
+}
+async function startDetachedServer(port) {
+    await fs.mkdir(path.dirname(SERVER_LOG_FILE), { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+    await fs.chmod(path.dirname(SERVER_LOG_FILE), PRIVATE_DIRECTORY_MODE).catch(() => { });
+    const handle = await fs.open(SERVER_LOG_FILE, "a", PRIVATE_FILE_MODE);
+    await fs.chmod(SERVER_LOG_FILE, PRIVATE_FILE_MODE).catch(() => { });
+    const child = spawn("opencode", ["serve", "--hostname", SERVER_HOST, "--port", String(port)], {
+        detached: true,
+        stdio: ["ignore", handle.fd, handle.fd],
+    });
+    child.unref();
+    await handle.close();
+}
+async function ensureServerPort() {
+    const state = await loadState();
+    let port = state.serverPort || DEFAULT_PORT;
+    if (await isHealthy(port))
+        return port;
+    if (!(await isPortAvailable(port))) {
+        port = await nextFreePort(Math.max(DEFAULT_PORT, port + 1));
+    }
+    if (port !== state.serverPort) {
+        await saveState({ ...state, serverPort: port });
+    }
+    await startDetachedServer(port);
+    const started = Date.now();
+    while (Date.now() - started < 20_000) {
+        if (await isHealthy(port))
+            return port;
+        await sleep(250);
+    }
+    throw new Error(`Timed out waiting for opencode serve on port ${port}`);
+}
+async function fetchAllSessions(client) {
+    const sessions = [];
+    let cursor;
+    while (sessions.length < 2000) {
+        const result = await client.experimental.session.list({
+            roots: true,
+            limit: SESSION_PAGE_LIMIT,
+            archived: false,
+            cursor,
+        });
+        const chunk = (result.data ?? []);
+        sessions.push(...chunk);
+        const next = result.response.headers.get("x-next-cursor");
+        if (!next)
+            break;
+        cursor = Number(next);
+        if (!Number.isFinite(cursor))
+            break;
+    }
+    return sessions;
+}
+async function fetchProjects(client) {
+    const result = await client.project.list();
+    return (result.data ?? []).map((project) => ({
+        id: project.id,
+        name: project.name,
+        worktree: project.worktree,
+        sandboxes: project.sandboxes ?? [],
+    }));
+}
+async function fetchSessionStatuses(client) {
+    const result = await client.session.status();
+    return (result.data ?? {});
+}
+async function fetchPendingQuestions(client) {
+    const result = await client.question.list();
+    return result.data ?? [];
+}
+async function fetchPendingPermissions(client) {
+    const result = await client.permission.list();
+    return result.data ?? [];
+}
+function mergeSessionStatuses(sessions, statuses) {
+    const now = Date.now();
+    return sessions.map((session) => {
+        const status = statuses[session.id];
+        if (status) {
+            return {
+                ...session,
+                status,
+            };
+        }
+        const justCompleted = now - session.time.updated <= RECENT_COMPLETION_WINDOW_MS;
+        return {
+            ...session,
+            status: {
+                type: "idle",
+                justCompleted,
+            },
+        };
+    });
+}
+export class LauncherService {
+    client;
+    baseUrl;
+    port;
+    readyPromise;
+    snapshotPromise;
+    launchedSessionIDs = new Set();
+    notifier = new SoundNotifier();
+    async ensureReady() {
+        if (this.client && this.baseUrl && this.port && (await isHealthy(this.port))) {
+            return {
+                client: this.client,
+                baseUrl: this.baseUrl,
+                port: this.port,
+            };
+        }
+        if (this.readyPromise) {
+            return this.readyPromise;
+        }
+        this.readyPromise = (async () => {
+            this.client = undefined;
+            this.baseUrl = undefined;
+            this.port = undefined;
+            const port = await ensureServerPort();
+            const baseUrl = `http://${SERVER_HOST}:${port}`;
+            const client = createOpencodeClient({ baseUrl });
+            this.client = client;
+            this.baseUrl = baseUrl;
+            this.port = port;
+            return {
+                client,
+                baseUrl,
+                port,
+            };
+        })();
+        try {
+            return await this.readyPromise;
+        }
+        finally {
+            this.readyPromise = undefined;
+        }
+    }
+    async getSnapshot() {
+        if (this.snapshotPromise) {
+            return this.snapshotPromise;
+        }
+        this.snapshotPromise = (async () => {
+            const [{ client, baseUrl, port }, state, activeSessions, previewSessionID] = await Promise.all([
+                this.ensureReady(),
+                loadState(),
+                listActiveSessions(),
+                getPreviewSessionID(),
+            ]);
+            const [projects, sessions, statuses, questions, permissions] = await Promise.all([
+                fetchProjects(client),
+                fetchAllSessions(client),
+                fetchSessionStatuses(client),
+                fetchPendingQuestions(client),
+                fetchPendingPermissions(client),
+            ]);
+            const snapshot = buildSnapshot({
+                baseUrl,
+                serverPort: port,
+                projects,
+                sessions: mergeSessionStatuses(sessions, statuses),
+                pinnedDirectories: state.pinnedDirectories,
+                panes: [],
+                activeSessions,
+                previewSessionID,
+            });
+            this.notifier.syncSnapshot(snapshot);
+            this.notifier.syncPendingRequests({
+                questions,
+                permissions,
+            });
+            return snapshot;
+        })();
+        try {
+            return await this.snapshotPromise;
+        }
+        finally {
+            this.snapshotPromise = undefined;
+        }
+    }
+    async addProjectDirectory(rawDirectory) {
+        const { client } = await this.ensureReady();
+        const directory = normalizeDirectory(rawDirectory);
+        await assertDirectoryExists(directory);
+        try {
+            await client.project.current({ directory });
+        }
+        catch {
+            // Some folders may not have been opened in OpenCode yet. Persisting the path
+            // still lets the sidebar surface it so a first session can be created there.
+        }
+        await updateState((state) => ({
+            ...state,
+            pinnedDirectories: state.pinnedDirectories.includes(directory)
+                ? state.pinnedDirectories
+                : [...state.pinnedDirectories, directory],
+        }));
+        return directory;
+    }
+    async pinDirectory(rawDirectory) {
+        return this.addProjectDirectory(rawDirectory);
+    }
+    async unpinDirectory(directory) {
+        await updateState((state) => ({
+            ...state,
+            pinnedDirectories: state.pinnedDirectories.filter((item) => item !== directory),
+        }));
+    }
+    async openSession(directory, session) {
+        const { baseUrl } = await this.ensureReady();
+        const result = await openSessionWithPreferredTerminal({
+            sessionID: session.id,
+            directory,
+            title: session.title,
+            baseUrl,
+        });
+        this.launchedSessionIDs.add(session.id);
+        return result;
+    }
+    async openNewSession(directory) {
+        const { client, baseUrl } = await this.ensureReady();
+        const result = await client.session.create({ directory });
+        if (!result.data) {
+            throw new Error("Failed to create a new session");
+        }
+        const session = result.data;
+        const openResult = await openSessionWithPreferredTerminal({
+            sessionID: session.id,
+            directory,
+            title: session.title,
+            baseUrl,
+        });
+        this.launchedSessionIDs.add(session.id);
+        return openResult;
+    }
+    async openDirectory(record) {
+        if (record.sessions.length > 0) {
+            return this.openSession(record.directory, record.sessions[0]);
+        }
+        return this.openNewSession(record.directory);
+    }
+    async deleteSession(directory, sessionID) {
+        const { client } = await this.ensureReady();
+        await client.session.delete({
+            sessionID,
+            directory,
+        });
+    }
+    async renameSession(directory, sessionID, title) {
+        const { client } = await this.ensureReady();
+        const nextTitle = title.trim();
+        if (!nextTitle) {
+            throw new Error("Session title is empty");
+        }
+        await client.session.update({
+            sessionID,
+            directory,
+            title: nextTitle,
+        });
+        await retitleSessionWindow(sessionID, directory, nextTitle).catch(() => false);
+        return nextTitle;
+    }
+    async killSession(sessionID) {
+        const killed = await killSessionWindow(sessionID);
+        if (killed) {
+            this.launchedSessionIDs.delete(sessionID);
+        }
+        return killed;
+    }
+    async shutdown() {
+        const launchedSessionIDs = [...this.launchedSessionIDs];
+        const results = [];
+        for (const sessionID of launchedSessionIDs) {
+            results.push(await killSessionWindow(sessionID).catch(() => false));
+        }
+        const deadline = Date.now() + 3_000;
+        while (Date.now() < deadline) {
+            const activeSessionIDs = new Set((await listActiveSessions().catch(() => [])).map((session) => session.sessionID));
+            if (launchedSessionIDs.every((sessionID) => !activeSessionIDs.has(sessionID))) {
+                break;
+            }
+            await sleep(100);
+        }
+        this.launchedSessionIDs.clear();
+        return results;
+    }
+    async subscribe(signal, onInvalidate) {
+        const { client } = await this.ensureReady();
+        let timer;
+        const invalidate = () => {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => {
+                if (!signal.aborted)
+                    onInvalidate();
+            }, SNAPSHOT_DEBOUNCE_MS);
+        };
+        signal.addEventListener("abort", () => {
+            if (timer)
+                clearTimeout(timer);
+        }, { once: true });
+        (async () => {
+            while (!signal.aborted) {
+                try {
+                    const events = await client.global.event({ signal });
+                    for await (const event of events.stream) {
+                        if (signal.aborted)
+                            break;
+                        this.notifier.handleEvent({
+                            directory: event.directory,
+                            event: event.payload,
+                        });
+                        invalidate();
+                    }
+                }
+                catch {
+                    if (signal.aborted)
+                        break;
+                    await sleep(1000);
+                }
+            }
+        })().catch(() => { });
+    }
+    describeBackend() {
+        return describeTerminalBackend();
+    }
+}

package/dist/lib/state.js

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+import { APP_DIR, DEFAULT_PORT, PRIVATE_DIRECTORY_MODE, PRIVATE_FILE_MODE, STATE_FILE } from "./constants.js";
+import { distinct } from "./util.js";
+const DEFAULT_STATE = {
+    serverPort: DEFAULT_PORT,
+    pinnedDirectories: [],
+};
+async function ensureAppDir() {
+    await fs.mkdir(APP_DIR, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+    await fs.chmod(APP_DIR, PRIVATE_DIRECTORY_MODE).catch(() => { });
+}
+export async function loadState() {
+    await ensureAppDir();
+    try {
+        const raw = await fs.readFile(STATE_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            serverPort: parsed.serverPort && Number.isInteger(parsed.serverPort) ? parsed.serverPort : DEFAULT_PORT,
+            pinnedDirectories: distinct((parsed.pinnedDirectories ?? []).filter((item) => typeof item === "string")),
+        };
+    }
+    catch {
+        return { ...DEFAULT_STATE };
+    }
+}
+export async function saveState(state) {
+    await ensureAppDir();
+    const normalized = {
+        serverPort: state.serverPort,
+        pinnedDirectories: distinct(state.pinnedDirectories),
+    };
+    await fs.writeFile(STATE_FILE, JSON.stringify(normalized, null, 2) + "\n", {
+        encoding: "utf8",
+        mode: PRIVATE_FILE_MODE,
+    });
+    await fs.chmod(STATE_FILE, PRIVATE_FILE_MODE).catch(() => { });
+}
+export async function updateState(updater) {
+    const current = await loadState();
+    const next = await updater(current);
+    await saveState(next);
+    return next;
+}
+export async function touchAppDir() {
+    await ensureAppDir();
+    return APP_DIR;
+}

package/dist/lib/terminal.js

@@ -0,0 +1,106 @@
+import { ensureTmuxLayout, findAnyWindowBySessionID, findBackgroundWindowBySessionID, getPreviewSessionMeta, isTmux, killSessionWindowBySessionID, listActiveSessionWindows, parkPreviewSession, pruneBackgroundSessions, renameSessionWindow, respawnPane, setPaneSession, setPreviewSession, setPaneTitle, swapPreviewWithSessionPane, } from "./tmux.js";
+import { sessionWindowTitle } from "./util.js";
+export function describeTerminalBackend() {
+    if (!isTmux()) {
+        throw new Error("This launcher now supports tmux mode only");
+    }
+    return "tmux";
+}
+export async function listActiveSessions() {
+    return listActiveSessionWindows();
+}
+export async function hasRunningSessionWindow(sessionID) {
+    return Boolean(await findAnyWindowBySessionID(sessionID));
+}
+export async function killSessionWindow(sessionID) {
+    return killSessionWindowBySessionID(sessionID);
+}
+export async function retitleSessionWindow(sessionID, directory, title) {
+    return renameSessionWindow(sessionID, directory, title);
+}
+export async function cleanupSidebarSessions(sessionIDs) {
+    const results = [];
+    for (const sessionID of sessionIDs) {
+        results.push(await killSessionWindowBySessionID(sessionID).catch(() => false));
+    }
+    return results;
+}
+export async function getPreviewSessionID() {
+    const preview = await getPreviewSessionMeta();
+    return preview?.sessionID;
+}
+export async function openSessionWithPreferredTerminal(input) {
+    let { rightPaneID } = await ensureTmuxLayout(input.directory);
+    const previewSession = await getPreviewSessionMeta();
+    if (previewSession?.paneID) {
+        rightPaneID = previewSession.paneID;
+    }
+    if (previewSession?.sessionID === input.sessionID) {
+        return {
+            action: "focused",
+            sessionID: input.sessionID,
+            backend: "tmux",
+        };
+    }
+    const parkedSession = await findBackgroundWindowBySessionID(input.sessionID);
+    if (parkedSession) {
+        await swapPreviewWithSessionPane({
+            previewPaneID: rightPaneID,
+            sessionPaneID: parkedSession.paneID,
+            hiddenWindowID: parkedSession.windowID,
+            previewSession,
+            nextSession: {
+                sessionID: input.sessionID,
+                directory: input.directory,
+                title: input.title,
+            },
+        });
+        await pruneBackgroundSessions({
+            keepSessionIDs: [input.sessionID],
+        });
+        return {
+            action: "focused",
+            sessionID: input.sessionID,
+            backend: "tmux",
+        };
+    }
+    if (previewSession && previewSession.sessionID !== input.sessionID) {
+        await parkPreviewSession({
+            previewPaneID: rightPaneID,
+            sessionID: previewSession.sessionID,
+            directory: previewSession.directory,
+            title: previewSession.title,
+        });
+        rightPaneID = (await ensureTmuxLayout(input.directory)).rightPaneID;
+    }
+    await respawnPane(rightPaneID, input.directory, [
+        "opencode",
+        "attach",
+        input.baseUrl,
+        "--dir",
+        input.directory,
+        "--session",
+        input.sessionID,
+    ]);
+    await setPaneSession({
+        paneID: rightPaneID,
+        sessionID: input.sessionID,
+        directory: input.directory,
+        title: input.title,
+    });
+    await setPaneTitle(rightPaneID, sessionWindowTitle(input.directory, input.title));
+    await setPreviewSession({
+        sessionID: input.sessionID,
+        directory: input.directory,
+        title: input.title,
+        paneID: rightPaneID,
+    });
+    await pruneBackgroundSessions({
+        keepSessionIDs: [input.sessionID],
+    });
+    return {
+        action: "focused",
+        sessionID: input.sessionID,
+        backend: "tmux",
+    };
+}