opencode-subagent-magazine 1.5.2 → 1.6.0-beta.1

package/dist/v2/commands.d.ts

@@ -0,0 +1,7 @@
+import type { Context, KeymapCommand } from "./types";
+import type { PanelApi } from "../panel/panel-api";
+import type { SharedSignals } from "../core/types";
+import { KV_PREFIX } from "../core/kv";
+/** V2 命令（对齐 V1 的 9 个斜杠命令——promise 式对话框）。 */
+export declare function makeCommands(context: Context, api: PanelApi, signals: SharedSignals): KeymapCommand[];
+export { KV_PREFIX };

package/dist/v2/commands.js

@@ -0,0 +1,263 @@
+import { KV_PREFIX, SETTING_KEYS, loadSessionData, saveSessionData, readTTLDays } from "../core/kv";
+import { PLUGIN_VERSION } from "../_version";
+import { LANG_META, createT } from "../i18n";
+import { globalEntryCache, setClearTick } from "../panel/store";
+/** V2 命令（对齐 V1 的 9 个斜杠命令——promise 式对话框）。 */
+export function makeCommands(context, api, signals) {
+    const t = createT(() => signals.lang());
+    const kv = api.kv;
+    const clampMax = (n) => Math.max(1, Math.min(50, n));
+    const resolveParent = (sid) => {
+        try {
+            const session = api.session.get(sid);
+            const parentID = session?.parentID;
+            if (parentID)
+                return { parentSid: parentID, isChild: true };
+        }
+        catch { }
+        return { parentSid: sid, isChild: false };
+    };
+    return [
+        {
+            id: "opencode-subagent-magazine.subagent.lang",
+            title: "SubAgent Magazine: Language",
+            description: "Switch display language (中文 / English / 日本語 / 한국어)",
+            slash: { name: "subagent-lang" },
+            palette: true,
+            run: async () => {
+                const lang = await context.ui.dialog.select({
+                    title: "Language / 语言",
+                    options: LANG_META.map((m) => ({ title: m.label, value: m.code })),
+                });
+                if (!lang)
+                    return;
+                signals.setLang(lang);
+                kv.set(SETTING_KEYS.lang, lang);
+                api.ui.toast("Language: " + (LANG_META.find((m) => m.code === lang)?.label ?? lang));
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.order",
+            title: "SubAgent Magazine: Sort Order",
+            description: "Set sub-agent entry sort order (desc / asc)",
+            slash: { name: "subagent-order" },
+            palette: true,
+            run: async () => {
+                const order = await context.ui.dialog.select({
+                    title: "Sort Order / 排序方式",
+                    options: [
+                        { title: t("order.desc"), value: "desc" },
+                        { title: t("order.asc"), value: "asc" },
+                    ],
+                });
+                if (!order)
+                    return;
+                signals.setSortOrder(order);
+                kv.set(SETTING_KEYS.order, order);
+                api.ui.toast(order === "desc" ? t("order.desc") : t("order.asc"));
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.scroll",
+            title: "SubAgent Magazine: Scroll Mode",
+            description: "Set scroll mode (wheel / click)",
+            slash: { name: "subagent-scroll" },
+            palette: true,
+            run: async () => {
+                const mode = await context.ui.dialog.select({
+                    title: "Scroll Mode / 滚动模式",
+                    options: [
+                        { title: t("scroll.wheel"), value: "wheel" },
+                        { title: t("scroll.click"), value: "click" },
+                    ],
+                });
+                if (!mode)
+                    return;
+                signals.setScrollMode(mode);
+                kv.set(SETTING_KEYS.scrollMode, mode);
+                api.ui.toast(mode === "wheel" ? t("scroll.wheel") : t("scroll.click"));
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.max",
+            title: "SubAgent Magazine: Max Entries",
+            description: "Set max visible sub-agent entries in sidebar",
+            slash: { name: "subagent-max" },
+            palette: true,
+            run: async () => {
+                const val = await context.ui.dialog.prompt({
+                    title: "Max Visible Entries",
+                    message: "Number of entries to show in the sidebar (1–50)",
+                    placeholder: String(signals.maxEntries()),
+                });
+                if (val === undefined)
+                    return;
+                const n = clampMax(parseInt(val, 10) || 10);
+                signals.setMaxEntries(n);
+                kv.set(SETTING_KEYS.maxEntries, n);
+                api.ui.toast(`Max entries: ${n}`);
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.version",
+            title: "SubAgent Magazine: Version",
+            description: "Show plugin version",
+            slash: { name: "subagent-version" },
+            palette: true,
+            run: () => {
+                api.ui.toast(`opencode-subagent-magazine v${PLUGIN_VERSION}`);
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.session",
+            title: "SubAgent Magazine: Session",
+            description: "Show current session ID",
+            slash: { name: "subagent-session" },
+            palette: true,
+            run: () => {
+                api.ui.toast(`Session: ${signals.sessionId}`);
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.clear-running",
+            title: "SubAgent Magazine: Clear Running",
+            description: "Mark all running sub-agent entries as done (for stuck/zombie entries)",
+            slash: { name: "subagent-clear-running" },
+            palette: true,
+            run: () => {
+                const sid = signals.sessionId;
+                const entries = globalEntryCache.get(sid);
+                if (!entries || entries.size === 0) {
+                    api.ui.toast(signals.lang() === "zh" ? "暂无子代理条目" : "No sub-agent entries found");
+                    return;
+                }
+                let count = 0;
+                for (const [, entry] of entries) {
+                    if (entry.status === "running" || entry.status === "cancel_requested") {
+                        entry.status = "done";
+                        entry.endedAt = Date.now();
+                        count++;
+                    }
+                }
+                if (count > 0) {
+                    try {
+                        const data = loadSessionData(kv);
+                        const { parentSid, isChild } = resolveParent(sid);
+                        if (isChild) {
+                            if (!data[parentSid])
+                                data[parentSid] = { ts: Date.now(), entries: [], scroll: 0, expanded: "", children: {} };
+                            if (!data[parentSid].children)
+                                data[parentSid].children = {};
+                            if (!data[parentSid].children[sid])
+                                data[parentSid].children[sid] = { scroll: 0, expanded: "", entries: [] };
+                            data[parentSid].children[sid] = { ...data[parentSid].children[sid], entries: [...entries.values()] };
+                        }
+                        else {
+                            data[sid] = {
+                                ts: Date.now(),
+                                entries: [...entries.values()],
+                                scroll: data[sid]?.scroll ?? 0,
+                                expanded: data[sid]?.expanded ?? "",
+                                children: data[sid]?.children ?? {},
+                            };
+                        }
+                        saveSessionData(kv, data);
+                    }
+                    catch { }
+                    api.ui.toast(signals.lang() === "zh"
+                        ? `已标记 ${count} 个运行中的条目为完成`
+                        : `Marked ${count} running entries as done`);
+                }
+                else {
+                    api.ui.toast(signals.lang() === "zh" ? "没有需要清理的运行中条目" : "No running entries to clear");
+                }
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.ttl",
+            title: "SubAgent Magazine: TTL",
+            description: "Set session data retention period (days before auto-cleanup)",
+            slash: { name: "subagent-ttl" },
+            palette: true,
+            run: async () => {
+                const curDays = readTTLDays(kv);
+                const curLabel = curDays === 0 ? t("ttl.unlimited") : `${curDays}d`;
+                const days = await context.ui.dialog.select({
+                    title: `${t("ttl.label")}  (${curLabel})`,
+                    options: [
+                        { title: t("ttl.3d"), value: 3 },
+                        { title: t("ttl.7d"), value: 7 },
+                        { title: t("ttl.14d"), value: 14 },
+                        { title: t("ttl.30d"), value: 30 },
+                        { title: t("ttl.unlimited"), value: 0 },
+                    ],
+                });
+                if (days === undefined)
+                    return;
+                kv.set(SETTING_KEYS.ttlDays, String(days));
+                api.ui.toast(days === 0 ? t("ttl.toast_unlimited") : t("ttl.toast", { n: days }));
+            },
+        },
+        {
+            id: "opencode-subagent-magazine.subagent.clear-entries",
+            title: "SubAgent Magazine: Clear Entries",
+            description: "Delete all sub-agent records for the current session (cannot be undone)",
+            slash: { name: "subagent-clear-entries" },
+            palette: true,
+            run: async () => {
+                const sid = signals.sessionId;
+                const sessionObj = api.session.get(sid);
+                const parentID = sessionObj?.parentID;
+                const cached = globalEntryCache.get(sid);
+                let runningCount = 0;
+                if (cached) {
+                    for (const [, e] of cached) {
+                        if (e.status === "running")
+                            runningCount++;
+                    }
+                }
+                const msg = runningCount > 0 ? t("clear.prompt_running", { n: runningCount }) : t("clear.prompt");
+                const choice = await context.ui.dialog.select({
+                    title: t("clear.title"),
+                    options: [
+                        { title: t("clear.title"), value: "yes" },
+                        { title: t("cancel.label"), value: "no" },
+                    ],
+                });
+                if (choice !== "yes")
+                    return;
+                try {
+                    const data = loadSessionData(kv);
+                    let count = 0;
+                    if (parentID) {
+                        if (data[parentID]?.children?.[sid]) {
+                            const child = data[parentID].children[sid];
+                            const ids = child.entries?.map((e) => e.id) ?? [];
+                            count = ids.length;
+                            child.entries = [];
+                            child.scroll = 0;
+                            child.expanded = "";
+                            child.clearedIds = [...new Set([...(child.clearedIds ?? []), ...ids])];
+                        }
+                    }
+                    else {
+                        count = data[sid]?.entries?.length ?? 0;
+                        if (data[sid]) {
+                            const ids = data[sid].entries?.map((e) => e.id) ?? [];
+                            data[sid].entries = [];
+                            data[sid].scroll = 0;
+                            data[sid].expanded = "";
+                            data[sid].clearedIds = [...new Set([...(data[sid].clearedIds ?? []), ...ids])];
+                        }
+                    }
+                    saveSessionData(kv, data);
+                    globalEntryCache.delete(sid);
+                    setClearTick((v) => v + 1);
+                    api.ui.toast(t("clear.done", { n: count }));
+                }
+                catch { }
+            },
+        },
+    ];
+}
+export { KV_PREFIX };

package/dist/v2/index.d.ts

@@ -0,0 +1,8 @@
+/** @jsxImportSource @opentui/solid */
+import type { PluginModule } from "./types";
+/** V2 入口：setup 创建共享信号 + PanelApi + 命令 layer + 侧边栏槽位。
+ *  行为对齐 V1 tui()（信号初始值从 KV 恢复；侧边栏渲染共享 SubAgentPanel）。 */
+declare const mod: PluginModule & {
+    server: () => Promise<Record<string, never>>;
+};
+export default mod;

package/dist/v2/index.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "@opentui/solid/jsx-runtime";
+/** @jsxImportSource @opentui/solid */
+import { createSignal } from "solid-js";
+import { createPanelApi } from "./v2-panel-api";
+import { makeCommands } from "./commands";
+import { mapTheme } from "./theme";
+import { SubAgentPanel } from "../panel/SubAgentPanel";
+import { SETTING_KEYS } from "../core/kv";
+import { LANG_META, detectLang } from "../i18n";
+/** 面板根组件：keymap.layer 必须在组件渲染上下文注册（setup 内调用报
+ *  Keymap.Provider missing），再渲染共享 SubAgentPanel。 */
+function PluginRoot(props) {
+    props.context.keymap.layer(() => ({
+        mode: "global",
+        commands: makeCommands(props.context, props.api, props.signals),
+    }));
+    return (_jsx(SubAgentPanel, { api: props.api, theme: mapTheme(props.context.theme), lang: props.signals.lang, maxEntries: props.signals.maxEntries, sortOrder: props.signals.sortOrder, scrollMode: props.signals.scrollMode, sessionId: props.sessionID }));
+}
+/** V2 入口：setup 创建共享信号 + PanelApi + 命令 layer + 侧边栏槽位。
+ *  行为对齐 V1 tui()（信号初始值从 KV 恢复；侧边栏渲染共享 SubAgentPanel）。 */
+const mod = {
+    id: "opencode-subagent-magazine",
+    setup(context) {
+        // settings 惰性 getter（闭包引用信号变量——运行时已赋值）
+        let lang;
+        let maxEntries;
+        let sortOrder;
+        let scrollMode;
+        const api = createPanelApi(context, {
+            lang: () => lang(),
+            maxEntries: () => maxEntries(),
+            sortOrder: () => sortOrder(),
+            scrollMode: () => scrollMode(),
+        });
+        // 信号初始值从 KV 恢复（对齐 V1 tui()）
+        const storedLang = String(api.kv.get(SETTING_KEYS.lang, ""));
+        const initialLang = LANG_META.some((m) => m.code === storedLang) ? storedLang : detectLang();
+        const [langSignal, setLang] = createSignal(initialLang);
+        const [maxSignal, setMaxEntries] = createSignal(Number(api.kv.get(SETTING_KEYS.maxEntries, "10")) || 10);
+        const [orderSignal, setSortOrder] = createSignal(String(api.kv.get(SETTING_KEYS.order, "desc")) === "asc" ? "asc" : "desc");
+        const [scrollSignal, setScrollMode] = createSignal(String(api.kv.get(SETTING_KEYS.scrollMode, "wheel")) === "click" ? "click" : "wheel");
+        lang = langSignal;
+        maxEntries = maxSignal;
+        sortOrder = orderSignal;
+        scrollMode = scrollSignal;
+        const signals = {
+            lang, setLang, maxEntries, setMaxEntries, sortOrder, setSortOrder, scrollMode, setScrollMode, sessionId: "",
+        };
+        // 命令 layer（组件内注册——见 PluginRoot）
+        // 侧边栏面板（共享 SubAgentPanel——V1/V2 同一组件）
+        context.ui.slot({
+            prepend: "sidebar.content",
+            render: (props) => {
+                signals.sessionId = String(props.sessionID ?? "");
+                return (_jsx(PluginRoot, { context: context, api: api, signals: signals, sessionID: String(props.sessionID ?? "") }));
+            },
+        });
+    },
+    // V1 server 空实现（兼容标记）：v2 加载 setup，V1 检测需要 server 字段识别为插件
+    server: async () => ({}),
+};
+export default mod;

package/dist/v2/theme.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "./types";
+/** V2 theme → V1 形状映射（组件按 primary/text/textMuted/… 字段消费）。 */
+export declare function mapTheme(theme: Context["theme"]): Record<string, unknown>;

package/dist/v2/theme.js

@@ -0,0 +1,12 @@
+/** V2 theme → V1 形状映射（组件按 primary/text/textMuted/… 字段消费）。 */
+export function mapTheme(theme) {
+    return {
+        primary: theme.hue.interactive[300],
+        text: theme.text.default,
+        textMuted: theme.text.subdued,
+        success: theme.text.feedback.success.default,
+        warning: theme.text.feedback.warning.default,
+        error: theme.text.feedback.error.default,
+        border: theme.text.subdued,
+    };
+}

package/dist/v2/types.d.ts

@@ -0,0 +1,231 @@
+/**
+ * V2 (opencode2) TUI plugin API — 最小本地类型（实验版）。
+ * 运行时由 opencode2 提供，此处仅用于本地类型检查；
+ * 结构对应 v2 分支 packages/plugin/src/tui/context.ts。
+ */
+export interface App {
+    readonly version: string;
+    readonly channel: string;
+}
+export interface Theme {
+    readonly hue: {
+        readonly interactive: {
+            readonly 300: string;
+        };
+        readonly accent: {
+            readonly 500: string;
+        };
+    };
+    readonly text: {
+        readonly default: string;
+        readonly subdued: string;
+        readonly feedback: {
+            readonly success: {
+                readonly default: string;
+            };
+            readonly error: {
+                readonly default: string;
+            };
+            readonly warning: {
+                readonly default: string;
+            };
+        };
+    };
+}
+export interface TokenUsage {
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: {
+        read?: number;
+        write?: number;
+    };
+}
+export interface MessageInfo {
+    readonly id: string;
+    readonly type: string;
+    readonly agent?: string;
+    readonly model?: string;
+    readonly time: {
+        readonly created: number;
+        readonly completed?: number;
+    };
+    readonly cost?: unknown;
+    readonly tokens?: TokenUsage;
+    readonly content?: unknown[];
+}
+export interface SessionInfo {
+    readonly id: string;
+    readonly title?: string;
+    readonly time?: {
+        readonly created: number;
+        readonly updated: number;
+    };
+    readonly model?: string;
+    readonly agent?: string;
+    readonly parentID?: string;
+    readonly cost?: number;
+    readonly tokens?: TokenUsage;
+}
+export interface Data {
+    readonly session: {
+        get(sessionID: string): SessionInfo | undefined;
+        list(): SessionInfo[];
+        cost(sessionID: string): number;
+        status(sessionID: string): string;
+        interrupt(sessionID: string): Promise<void>;
+        readonly message: {
+            list(sessionID: string): MessageInfo[];
+            sync(sessionID: string): Promise<void>;
+        };
+    };
+    readonly location: {
+        readonly provider: {
+            list(location?: unknown): unknown[];
+        };
+        readonly model: {
+            list(location?: unknown): unknown[];
+        };
+        readonly mcp: {
+            readonly server: {
+                list(location?: unknown): unknown[];
+            };
+        };
+    };
+    readonly on: (type: string, handler: (event: unknown) => void) => () => void;
+    readonly listen: (handler: (event: unknown) => void) => () => void;
+}
+export interface Storage {
+    store<Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }): readonly [Value, (mutation: (draft: Value) => void) => Promise<void>];
+    memory<Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }): readonly [Value, (mutation: (draft: Value) => void) => void];
+}
+export type SlotClaim = {
+    readonly render: (input: Record<string, any>) => unknown;
+} & ({
+    readonly append: string;
+    readonly prepend?: never;
+    readonly before?: never;
+    readonly after?: never;
+    readonly replace?: never;
+} | {
+    readonly prepend: string;
+    readonly append?: never;
+    readonly before?: never;
+    readonly after?: never;
+    readonly replace?: never;
+} | {
+    readonly before: string;
+    readonly append?: never;
+    readonly prepend?: never;
+    readonly after?: never;
+    readonly replace?: never;
+} | {
+    readonly after: string;
+    readonly append?: never;
+    readonly prepend?: never;
+    readonly before?: never;
+    readonly replace?: never;
+} | {
+    readonly replace: string;
+    readonly append?: never;
+    readonly prepend?: never;
+    readonly before?: never;
+    readonly after?: never;
+});
+export interface KeymapCommand {
+    readonly id?: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly group?: string;
+    readonly palette?: true;
+    readonly slash?: {
+        readonly name: string;
+        readonly aliases?: string[];
+        readonly arguments?: true;
+    };
+    readonly namespace?: string;
+    readonly name?: string;
+    readonly desc?: string;
+    readonly category?: string;
+    readonly slashName?: string;
+    readonly slashAliases?: string[];
+    readonly run: (input?: string) => void | false | Promise<void>;
+}
+/** 最小 client 面（运行时由 V2 提供——取消走 session.interrupt）。 */
+export interface ClientLike {
+    readonly session: {
+        interrupt(input: {
+            sessionID: string;
+            continue?: boolean;
+        }): Promise<unknown>;
+    };
+}
+export interface Context {
+    readonly app: App;
+    readonly options: Record<string, any>;
+    readonly location: {
+        readonly directory?: string;
+    } | undefined;
+    readonly renderer: {
+        readonly terminalWidth: number;
+    };
+    readonly theme: Theme;
+    readonly data: Data;
+    readonly client: ClientLike;
+    readonly storage: Storage;
+    readonly ui: {
+        slot(claim: SlotClaim): () => void;
+        readonly toast: {
+            show(options: {
+                readonly message: string;
+                readonly title?: string;
+                readonly variant?: string;
+            }): void;
+        };
+        readonly dialog: {
+            prompt(options: {
+                readonly title: string;
+                readonly message?: string;
+                readonly placeholder?: string;
+            }): Promise<string | undefined>;
+            select<Value>(options: {
+                readonly title: string;
+                readonly placeholder?: string;
+                readonly options: readonly {
+                    readonly title: string;
+                    readonly value: Value;
+                    readonly description?: string;
+                    readonly category?: string;
+                    readonly disabled?: boolean;
+                }[];
+                readonly current?: Value;
+            }): Promise<Value | undefined>;
+        };
+        readonly router: {
+            current(): {
+                readonly type?: string;
+                readonly sessionID?: string;
+                readonly params?: Record<string, unknown>;
+            };
+            navigate(route: {
+                type: string;
+                sessionID?: string;
+                params?: Record<string, unknown>;
+            }): void;
+        };
+    };
+    readonly keymap: {
+        layer(input: () => {
+            readonly commands?: readonly KeymapCommand[];
+        }): void;
+        shortcuts(id: string): readonly string[];
+    };
+}
+export type PluginModule = {
+    readonly id: string;
+    readonly setup: (context: Context) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>;
+};

package/dist/v2/types.js

@@ -0,0 +1,6 @@
+/**
+ * V2 (opencode2) TUI plugin API — 最小本地类型（实验版）。
+ * 运行时由 opencode2 提供，此处仅用于本地类型检查；
+ * 结构对应 v2 分支 packages/plugin/src/tui/context.ts。
+ */
+export {};

package/dist/v2/v2-panel-api.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from "./types";
+import type { PanelApi } from "../panel/panel-api";
+/**
+ * V2 (opencode2) context → PanelApi 适配实现。
+ * 数据流（功能对齐 V1）：
+ * - usage：messages 反向遍历（同 V1 readSessionTokens/Cost/Model 逻辑）；todo 无 V2 对应 → undefined
+ * - 事件：tool 事件 → V1 ToolPart（subagent 工具名归一化 + metadata 双写 session_id/sessionId）；
+ *        execution.succeeded/failed → session.idle/error
+ * - 取消：session.interrupt（V1 abort 的 V2 对应）
+ * - 路由：router.navigate({type:"session"})（V1 route.navigate 的 V2 对应）
+ */
+export declare function createPanelApi(context: Context, settings: PanelApi["settings"]): PanelApi;