agent-office 0.0.0

package/dist/manage/components/CreateSession.d.ts

@@ -0,0 +1,7 @@
+interface CreateSessionProps {
+    serverUrl: string;
+    password: string;
+    onBack: () => void;
+}
+export declare function CreateSession({ serverUrl, password, onBack }: CreateSessionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/components/CreateSession.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+import { TextInput, Spinner } from "@inkjs/ui";
+import { useApi, useAsyncState } from "../hooks/useApi.js";
+export function CreateSession({ serverUrl, password, onBack }) {
+    const { createSession } = useApi(serverUrl, password);
+    const { loading, error, run } = useAsyncState();
+    const [created, setCreated] = useState(null);
+    const [submitted, setSubmitted] = useState(false);
+    // Auto-return to menu 1.5s after success or error
+    useEffect(() => {
+        if (created || error) {
+            const timer = setTimeout(onBack, 1500);
+            return () => clearTimeout(timer);
+        }
+    }, [created, error, onBack]);
+    const handleSubmit = async (name) => {
+        const trimmed = name.trim();
+        if (!trimmed)
+            return;
+        setSubmitted(true);
+        const result = await run(() => createSession(trimmed));
+        if (result)
+            setCreated(result);
+    };
+    if (loading) {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Create Session" }), _jsx(Spinner, { label: "Creating session on OpenCode..." })] }));
+    }
+    if (created) {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Create Session" }), _jsx(Text, { color: "green", children: "Session created!" }), _jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Name:" }), _jsx(Text, { color: "cyan", children: created.name })] }), _jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "OpenCode ID:" }), _jsx(Text, { dimColor: true, children: created.session_id })] }), _jsx(Text, { dimColor: true, children: "Returning to menu..." })] }));
+    }
+    if (error) {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Create Session" }), _jsxs(Text, { color: "red", children: ["Error: ", error] }), _jsx(Text, { dimColor: true, children: "Returning to menu..." })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Create Session" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "Name: " }), !submitted && (_jsx(TextInput, { placeholder: "e.g. john", onSubmit: handleSubmit }))] })] }));
+}

package/dist/manage/components/DeleteSession.d.ts

@@ -0,0 +1,7 @@
+interface DeleteSessionProps {
+    serverUrl: string;
+    password: string;
+    onBack: () => void;
+}
+export declare function DeleteSession({ serverUrl, password, onBack }: DeleteSessionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/components/DeleteSession.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { Select, Spinner, ConfirmInput } from "@inkjs/ui";
+import { useApi, useAsyncState } from "../hooks/useApi.js";
+export function DeleteSession({ serverUrl, password, onBack }) {
+    const { listSessions, deleteSession } = useApi(serverUrl, password);
+    const { run } = useAsyncState();
+    const [sessions, setSessions] = useState([]);
+    const [stage, setStage] = useState("loading");
+    const [selected, setSelected] = useState(null);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        void run(listSessions).then((rows) => {
+            if (rows && rows.length > 0) {
+                setSessions(rows);
+                setStage("select");
+            }
+            else if (rows) {
+                setError("No sessions to delete.");
+                setStage("error");
+            }
+        });
+    }, []);
+    // Auto-return to menu 1.5s after done or error
+    useEffect(() => {
+        if (stage === "done" || stage === "error") {
+            const timer = setTimeout(onBack, 1500);
+            return () => clearTimeout(timer);
+        }
+    }, [stage, onBack]);
+    const handleSelect = (name) => {
+        setSelected(name);
+        setStage("confirm");
+    };
+    const handleConfirm = async (confirmed) => {
+        if (!confirmed || !selected) {
+            onBack();
+            return;
+        }
+        setStage("deleting");
+        try {
+            await deleteSession(selected);
+            setStage("done");
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setStage("error");
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Delete Session" }), stage === "loading" && (_jsx(Spinner, { label: "Loading sessions..." })), stage === "select" && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "Select a session to delete:" }), _jsx(Select, { options: sessions.map((s) => ({
+                            label: `${s.name}  ${s.session_id.slice(0, 8)}...`,
+                            value: s.name,
+                        })), onChange: handleSelect })] })), stage === "confirm" && selected && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["Delete ", _jsx(Text, { color: "yellow", bold: true, children: selected }), "?", " ", _jsx(Text, { dimColor: true, children: "This also deletes the OpenCode session." })] }), _jsx(ConfirmInput, { defaultChoice: "cancel", onConfirm: () => void handleConfirm(true), onCancel: () => void handleConfirm(false) })] })), stage === "deleting" && (_jsx(Spinner, { label: `Deleting "${selected}"...` })), stage === "done" && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "green", children: ["Session \"", selected, "\" deleted."] }), _jsx(Text, { dimColor: true, children: "Returning to menu..." })] })), stage === "error" && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "red", children: ["Error: ", error] }), _jsx(Text, { dimColor: true, children: "Returning to menu..." })] }))] }));
+}

package/dist/manage/components/InjectText.d.ts

@@ -0,0 +1,8 @@
+interface InjectTextProps {
+    serverUrl: string;
+    password: string;
+    onBack: () => void;
+    contentHeight: number;
+}
+export declare function InjectText({ serverUrl, password, onBack, contentHeight }: InjectTextProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/components/InjectText.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { Select, Spinner, TextInput } from "@inkjs/ui";
+import { useApi, useAsyncState } from "../hooks/useApi.js";
+export function InjectText({ serverUrl, password, onBack, contentHeight }) {
+    const { listSessions, injectText } = useApi(serverUrl, password);
+    const { run: runList } = useAsyncState();
+    const [sessions, setSessions] = useState([]);
+    const [sessionsLoading, setSessionsLoading] = useState(true);
+    const [stage, setStage] = useState("select");
+    const [selectedName, setSelectedName] = useState(null);
+    const [error, setError] = useState(null);
+    const [submitted, setSubmitted] = useState(false);
+    useEffect(() => {
+        runList(listSessions).then((rows) => {
+            setSessions(rows ?? []);
+            setSessionsLoading(false);
+        });
+    }, []);
+    // Auto-return after done or error
+    useEffect(() => {
+        if (stage === "done" || stage === "error") {
+            const timer = setTimeout(onBack, 2000);
+            return () => clearTimeout(timer);
+        }
+    }, [stage, onBack]);
+    const handleSessionSelect = (name) => {
+        setSelectedName(name);
+        setStage("input");
+    };
+    const handleTextSubmit = async (text) => {
+        const trimmed = text.trim();
+        if (!trimmed || !selectedName)
+            return;
+        setSubmitted(true);
+        setStage("submitting");
+        try {
+            await injectText(selectedName, trimmed);
+            setStage("done");
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setStage("error");
+        }
+    };
+    if (sessionsLoading) {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading sessions..." }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Inject Text" }), stage === "select" && sessions.length === 0 && (_jsx(Box, { height: contentHeight - 2, alignItems: "center", justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "No sessions yet. Create one first." }) })), stage === "select" && sessions.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "Select a session to inject into:" }), _jsx(Select, { options: sessions.map((s) => ({ label: s.name, value: s.name })), onChange: handleSessionSelect })] })), stage === "input" && (_jsxs(_Fragment, { children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "Session: " }), _jsx(Text, { color: "cyan", children: selectedName })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "Text: " }), !submitted && (_jsx(TextInput, { placeholder: "Type your message...", onSubmit: handleTextSubmit }))] })] })), stage === "submitting" && (_jsx(Spinner, { label: `Injecting into "${selectedName}"...` })), stage === "done" && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "green", children: ["Message injected into \"", selectedName, "\"."] }), _jsx(Text, { dimColor: true, children: "Returning to menu..." })] })), stage === "error" && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "red", children: ["Error: ", error] }), _jsx(Text, { dimColor: true, children: "Returning to menu..." })] }))] }));
+}

package/dist/manage/components/SessionList.d.ts

@@ -0,0 +1,8 @@
+interface SessionListProps {
+    serverUrl: string;
+    password: string;
+    onBack: () => void;
+    contentHeight: number;
+}
+export declare function SessionList({ serverUrl, password, contentHeight }: SessionListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/components/SessionList.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { Spinner } from "@inkjs/ui";
+import { useApi, useAsyncState } from "../hooks/useApi.js";
+const MASKED_CODE = "••••••••-••••-••••-••••-••••••••••••";
+export function SessionList({ serverUrl, password, contentHeight }) {
+    const { listSessions } = useApi(serverUrl, password);
+    const { data: sessions, loading, error, run } = useAsyncState();
+    const [cursor, setCursor] = useState(0);
+    const [revealedRows, setRevealedRows] = useState(new Set());
+    useEffect(() => {
+        void run(listSessions);
+    }, []);
+    const rows = sessions ?? [];
+    useInput((input, key) => {
+        if (loading || rows.length === 0)
+            return;
+        if (key.upArrow) {
+            setCursor((c) => Math.max(0, c - 1));
+        }
+        if (key.downArrow) {
+            setCursor((c) => Math.min(rows.length - 1, c + 1));
+        }
+        if (input === "r") {
+            const id = rows[cursor]?.id;
+            if (id == null)
+                return;
+            setRevealedRows((prev) => {
+                const next = new Set(prev);
+                if (next.has(id)) {
+                    next.delete(id);
+                }
+                else {
+                    next.add(id);
+                }
+                return next;
+            });
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading sessions..." }) }));
+    }
+    if (error) {
+        return (_jsxs(Box, { height: contentHeight, flexDirection: "column", gap: 1, children: [_jsx(Text, { color: "red", bold: true, children: "Error" }), _jsx(Text, { children: error })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { bold: true, children: ["Sessions ", _jsxs(Text, { dimColor: true, children: ["(", rows.length, ")"] })] }), rows.length === 0 ? (_jsx(Box, { height: contentHeight - 2, alignItems: "center", justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "No sessions yet. Create one first." }) })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "  NAME".padEnd(18) }), _jsx(Text, { bold: true, color: "cyan", children: "OPENCODE SESSION ID".padEnd(36) }), _jsx(Text, { bold: true, color: "cyan", children: "AGENT CODE" })] }), rows.map((s, i) => {
+                        const selected = i === cursor;
+                        const revealed = revealedRows.has(s.id);
+                        return (_jsxs(Box, { gap: 2, children: [_jsxs(Box, { width: 18, children: [_jsx(Text, { color: selected ? "cyan" : undefined, children: selected ? "▶ " : "  " }), _jsx(Text, { color: selected ? "cyan" : "green", bold: selected, children: s.name })] }), _jsx(Text, { dimColor: !selected, children: s.session_id.padEnd(36) }), revealed ? (_jsx(Text, { color: "yellow", children: s.agent_code })) : (_jsx(Text, { dimColor: true, children: MASKED_CODE }))] }, s.id));
+                    })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u00B7 r reveal/hide code \u00B7 Esc back" }) })] }));
+}

package/dist/manage/components/TailMessages.d.ts

@@ -0,0 +1,8 @@
+interface TailMessagesProps {
+    serverUrl: string;
+    password: string;
+    onBack: () => void;
+    contentHeight: number;
+}
+export declare function TailMessages({ serverUrl, password, onBack, contentHeight }: TailMessagesProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/manage/components/TailMessages.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { Select, Spinner } from "@inkjs/ui";
+import { useApi, useAsyncState } from "../hooks/useApi.js";
+export function TailMessages({ serverUrl, password, onBack, contentHeight }) {
+    const { listSessions, getMessages } = useApi(serverUrl, password);
+    const { run: runList } = useAsyncState();
+    const [sessions, setSessions] = useState([]);
+    const [sessionsLoading, setSessionsLoading] = useState(true);
+    const [stage, setStage] = useState("select");
+    const [selectedName, setSelectedName] = useState(null);
+    const [messages, setMessages] = useState([]);
+    const [error, setError] = useState(null);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    useEffect(() => {
+        runList(listSessions).then((rows) => {
+            setSessions(rows ?? []);
+            setSessionsLoading(false);
+        });
+    }, []);
+    // Scroll through messages with arrow keys when viewing
+    useInput((input, key) => {
+        if (stage !== "viewing")
+            return;
+        if (key.upArrow)
+            setScrollOffset((o) => Math.max(0, o - 1));
+        if (key.downArrow)
+            setScrollOffset((o) => o + 1);
+    });
+    const handleSelect = async (name) => {
+        setSelectedName(name);
+        setStage("loading");
+        try {
+            const msgs = await getMessages(name, 50);
+            setMessages(msgs);
+            setScrollOffset(0);
+            setStage("viewing");
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setStage("error");
+        }
+    };
+    if (sessionsLoading) {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Loading sessions..." }) }));
+    }
+    if (stage === "select") {
+        if (sessions.length === 0) {
+            return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "No sessions yet. Create one first." }) }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Tail Messages" }), _jsx(Text, { dimColor: true, children: "Select a session:" }), _jsx(Select, { options: sessions.map((s) => ({ label: s.name, value: s.name })), onChange: handleSelect })] }));
+    }
+    if (stage === "loading") {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: `Fetching messages for "${selectedName}"...` }) }));
+    }
+    if (stage === "error") {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: "Tail Messages" }), _jsxs(Text, { color: "red", children: ["Error: ", error] })] }));
+    }
+    // viewing — render messages with scroll
+    const messageLines = [];
+    for (const msg of messages) {
+        for (const part of msg.parts) {
+            // Split multiline text into individual lines for rendering
+            const lines = part.text.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                messageLines.push({ role: msg.role, text: i === 0 ? lines[i] : `  ${lines[i]}` });
+            }
+            messageLines.push({ role: msg.role, text: "" }); // blank line between parts
+        }
+    }
+    const viewHeight = contentHeight - 3; // header + separator
+    const maxOffset = Math.max(0, messageLines.length - viewHeight);
+    const clampedOffset = Math.min(scrollOffset, maxOffset);
+    const visible = messageLines.slice(clampedOffset, clampedOffset + viewHeight);
+    return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Messages" }), _jsx(Text, { color: "cyan", children: selectedName }), _jsxs(Text, { dimColor: true, children: ["(", messages.length, " messages)"] })] }), _jsx(Box, { flexDirection: "column", height: viewHeight, overflow: "hidden", children: visible.length === 0 ? (_jsx(Text, { dimColor: true, children: "No messages in this session yet." })) : (visible.map((line, i) => (_jsx(Box, { children: line.role === "user" ? (_jsx(Text, { color: "green", children: line.text })) : (_jsx(Text, { children: line.text })) }, i)))) }), messageLines.length > viewHeight && (_jsxs(Text, { dimColor: true, children: ["[", clampedOffset + 1, "-", Math.min(clampedOffset + viewHeight, messageLines.length), "/", messageLines.length, " lines] \u2191\u2193 scroll"] }))] }));
+}

package/dist/manage/hooks/useApi.d.ts

@@ -0,0 +1,33 @@
+export interface Session {
+    id: number;
+    name: string;
+    session_id: string;
+    agent_code: string;
+    created_at: string;
+}
+export interface MessagePart {
+    type: "text";
+    text: string;
+}
+export interface SessionMessage {
+    role: "user" | "assistant";
+    parts: MessagePart[];
+}
+export declare function useApi(serverUrl: string, password: string): {
+    listSessions: () => Promise<Session[]>;
+    createSession: (name: string) => Promise<Session>;
+    deleteSession: (name: string) => Promise<void>;
+    checkHealth: () => Promise<boolean>;
+    getMessages: (name: string, limit?: number) => Promise<SessionMessage[]>;
+    injectText: (name: string, text: string) => Promise<{
+        ok: boolean;
+        messageID: string;
+    }>;
+    regenerateCode: (name: string) => Promise<Session>;
+};
+export declare function useAsyncState<T>(): {
+    run: (fn: () => Promise<T>) => Promise<T | null>;
+    data: T | null;
+    loading: boolean;
+    error: string | null;
+};

package/dist/manage/hooks/useApi.js

@@ -0,0 +1,82 @@
+import { useState, useCallback } from "react";
+function makeHeaders(password) {
+    return {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${password}`,
+    };
+}
+async function apiFetch(url, password, init) {
+    const res = await fetch(url, {
+        ...init,
+        headers: {
+            ...makeHeaders(password),
+            ...init?.headers,
+        },
+    });
+    if (res.status === 401) {
+        throw new Error("Unauthorized: check your --password");
+    }
+    const body = await res.json();
+    if (!res.ok) {
+        const msg = body.error ?? `HTTP ${res.status}`;
+        throw new Error(msg);
+    }
+    return body;
+}
+export function useApi(serverUrl, password) {
+    const base = serverUrl.replace(/\/$/, "");
+    const listSessions = useCallback(async () => {
+        return apiFetch(`${base}/sessions`, password);
+    }, [base, password]);
+    const createSession = useCallback(async (name) => {
+        return apiFetch(`${base}/sessions`, password, {
+            method: "POST",
+            body: JSON.stringify({ name }),
+        });
+    }, [base, password]);
+    const deleteSession = useCallback(async (name) => {
+        await apiFetch(`${base}/sessions/${encodeURIComponent(name)}`, password, {
+            method: "DELETE",
+        });
+    }, [base, password]);
+    const checkHealth = useCallback(async () => {
+        try {
+            await apiFetch(`${base}/health`, password);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, [base, password]);
+    const getMessages = useCallback(async (name, limit = 20) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/messages?limit=${limit}`, password);
+    }, [base, password]);
+    const injectText = useCallback(async (name, text) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/inject`, password, { method: "POST", body: JSON.stringify({ text }) });
+    }, [base, password]);
+    const regenerateCode = useCallback(async (name) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(name)}/regenerate-code`, password, { method: "POST" });
+    }, [base, password]);
+    return { listSessions, createSession, deleteSession, checkHealth, getMessages, injectText, regenerateCode };
+}
+export function useAsyncState() {
+    const [state, setState] = useState({
+        data: null,
+        loading: false,
+        error: null,
+    });
+    const run = useCallback(async (fn) => {
+        setState({ data: null, loading: true, error: null });
+        try {
+            const data = await fn();
+            setState({ data, loading: false, error: null });
+            return data;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            setState({ data: null, loading: false, error });
+            return null;
+        }
+    }, []);
+    return { ...state, run };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+import type { Sql } from "../db/index.js";
+import type { OpencodeClient } from "../lib/opencode.js";
+export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string): import("express-serve-static-core").Express;

package/dist/server/index.js

@@ -0,0 +1,22 @@
+import express from "express";
+import { createRouter, createWorkerRouter } from "./routes.js";
+function authMiddleware(password) {
+    return (req, res, next) => {
+        const header = req.headers.authorization;
+        if (!header || header !== `Bearer ${password}`) {
+            res.status(401).json({ error: "Unauthorized" });
+            return;
+        }
+        next();
+    };
+}
+export function createApp(sql, opencode, password) {
+    const app = express();
+    app.use(express.json());
+    // Worker routes are unauthenticated — mounted before auth middleware
+    app.use("/", createWorkerRouter(sql));
+    // Everything else requires Bearer auth
+    app.use(authMiddleware(password));
+    app.use("/", createRouter(sql, opencode));
+    return app;
+}

package/dist/server/routes.d.ts

@@ -0,0 +1,5 @@
+import { Router } from "express";
+import type { Sql } from "../db/index.js";
+import type { OpencodeClient } from "../lib/opencode.js";
+export declare function createRouter(sql: Sql, opencode: OpencodeClient): Router;
+export declare function createWorkerRouter(sql: Sql): Router;