diff --git a/config/config.exs b/config/config.exs
index 0a12341..31313bb 100644
--- a/config/config.exs
+++ b/config/config.exs
@@ -9,7 +9,14 @@ config :bds, BDS.Repo,
stacktrace: true,
show_sensitive_data_on_connection_error: true
-config :bds, BDS.Application, desktop_adapter: :pending_selection
+config :bds, BDS.Application, desktop_adapter: :desktop
+
+config :bds, :desktop,
+ port: 4010,
+ window_size: {1440, 900},
+ window_min_size: {1100, 700},
+ title: "Blogging Desktop Server",
+ secret_key_base: "bds_desktop_shell_secret_key_base_64_chars_minimum_seed_value_001"
config :bds, :scripting,
runtime: BDS.Scripting.Lua,
diff --git a/config/runtime.exs b/config/runtime.exs
index 60260a8..4e61208 100644
--- a/config/runtime.exs
+++ b/config/runtime.exs
@@ -7,5 +7,5 @@ if config_env() == :prod do
config :bds, BDS.Repo,
database: database_path,
- pool_size: String.to_integer(System.get_env("POOL_SIZE") || "5")
+ pool_size: String.to_integer(System.get_env("POOL_SIZE") || "1")
end
diff --git a/lib/bds/application.ex b/lib/bds/application.ex
index afda2fb..34bf1d6 100644
--- a/lib/bds/application.ex
+++ b/lib/bds/application.ex
@@ -3,6 +3,31 @@ defmodule BDS.Application do
use Application
+ def desktop_children(env \\ nil)
+
+ def desktop_children(:test), do: []
+
+ def desktop_children(_env) do
+ if Application.get_env(:bds, BDS.Application)[:desktop_adapter] == :desktop do
+ [
+ {BDS.Desktop.Server, []},
+ {Desktop.Window,
+ [
+ app: :bds,
+ id: BDS.Desktop.MainWindow,
+ title: Application.get_env(:bds, :desktop)[:title] || "Blogging Desktop Server",
+ size: Application.get_env(:bds, :desktop)[:window_size] || {1440, 900},
+ min_size: Application.get_env(:bds, :desktop)[:window_min_size] || {1100, 700},
+ menubar: BDS.Desktop.MenuBar,
+ icon_menu: BDS.Desktop.Menu,
+ url: &BDS.Desktop.url/0
+ ]}
+ ]
+ else
+ []
+ end
+ end
+
@impl true
def start(_type, _args) do
children = [
@@ -14,9 +39,15 @@ defmodule BDS.Application do
BDS.Scripting.JobStore,
{Task.Supervisor, name: BDS.Scripting.TaskSupervisor},
BDS.Scripting.JobSupervisor
+ | desktop_children(current_env())
]
opts = [strategy: :one_for_one, name: BDS.Supervisor]
Supervisor.start_link(children, opts)
end
+
+ defp current_env do
+ Application.get_env(:bds, :current_env_override) ||
+ if(Code.ensure_loaded?(Mix), do: Mix.env(), else: :prod)
+ end
end
diff --git a/lib/bds/desktop.ex b/lib/bds/desktop.ex
new file mode 100644
index 0000000..1c141ba
--- /dev/null
+++ b/lib/bds/desktop.ex
@@ -0,0 +1,12 @@
+defmodule BDS.Desktop do
+ @moduledoc false
+
+ def url do
+ Application.get_env(:bds, :desktop)[:port]
+ |> url()
+ end
+
+ def url(port) when is_integer(port) do
+ "http://127.0.0.1:#{port}/"
+ end
+end
diff --git a/lib/bds/desktop/main_window.ex b/lib/bds/desktop/main_window.ex
new file mode 100644
index 0000000..25c6c9d
--- /dev/null
+++ b/lib/bds/desktop/main_window.ex
@@ -0,0 +1,3 @@
+defmodule BDS.Desktop.MainWindow do
+ @moduledoc false
+end
diff --git a/lib/bds/desktop/menu.ex b/lib/bds/desktop/menu.ex
new file mode 100644
index 0000000..c98635a
--- /dev/null
+++ b/lib/bds/desktop/menu.ex
@@ -0,0 +1,42 @@
+defmodule BDS.Desktop.Menu do
+ @moduledoc false
+
+ use Desktop.Menu
+ alias Desktop.Window
+
+ @impl true
+ def mount(menu) do
+ {:ok, menu}
+ end
+
+ @impl true
+ def render(assigns) do
+ ~H"""
+
+ - Open
+ - Quit
+
+ """
+ end
+
+ @impl true
+ def handle_event("open", menu) do
+ Window.show(BDS.Desktop.MainWindow)
+ {:noreply, menu}
+ end
+
+ def handle_event("quit", menu) do
+ Window.quit()
+ {:noreply, menu}
+ end
+
+ def handle_event(_, menu) do
+ {:noreply, menu}
+ end
+
+ @impl true
+ def handle_info(_, menu) do
+ {:noreply, menu}
+ end
+end
diff --git a/lib/bds/desktop/menu_bar.ex b/lib/bds/desktop/menu_bar.ex
new file mode 100644
index 0000000..73ce56a
--- /dev/null
+++ b/lib/bds/desktop/menu_bar.ex
@@ -0,0 +1,73 @@
+defmodule BDS.Desktop.MenuBar do
+ @moduledoc false
+
+ use Desktop.Menu
+ alias Desktop.Window
+
+ def groups(opts \\ []) do
+ dev_mode? = Keyword.get(opts, :dev_mode?, false)
+
+ [
+ %{id: :app, label: "App", items: [%{id: :about, label: "About"}]},
+ %{id: :file, label: "File", items: [%{id: :new_post, label: "New Post"}, %{id: :close_tab, label: "Close Tab"}]},
+ %{id: :edit, label: "Edit", items: [%{id: :undo, label: "Undo"}, %{id: :redo, label: "Redo"}]},
+ %{id: :view, label: "View", items: view_items(dev_mode?)},
+ %{id: :window, label: "Window", items: [%{id: :minimize, label: "Minimize"}]},
+ %{id: :help, label: "Help", items: [%{id: :documentation, label: "Documentation"}]}
+ ]
+ end
+
+ @impl true
+ def mount(menu) do
+ {:ok,
+ Desktop.Menu.assign(
+ menu,
+ :groups,
+ groups(dev_mode?: Application.get_env(:bds, :dev_routes, false))
+ )}
+ end
+
+ @impl true
+ def render(assigns) do
+ ~H"""
+
+ <%= for group <- @groups do %>
+
+ <%= for item <- group.items do %>
+ - {item.label}
+ <% end %>
+
+ <% end %>
+
+ """
+ end
+
+ @impl true
+ def handle_event("quit", menu) do
+ Window.quit()
+ {:noreply, menu}
+ end
+
+ def handle_event(_, menu) do
+ {:noreply, menu}
+ end
+
+ @impl true
+ def handle_info(_, menu) do
+ {:noreply, menu}
+ end
+
+ defp view_items(dev_mode?) do
+ items = [
+ %{id: :toggle_sidebar, label: "Toggle Sidebar"},
+ %{id: :toggle_panel, label: "Toggle Panel"},
+ %{id: :toggle_assistant_sidebar, label: "Toggle Assistant Sidebar"}
+ ]
+
+ if dev_mode? do
+ items ++ [%{id: :toggle_dev_tools, label: "Toggle Dev Tools"}]
+ else
+ items
+ end
+ end
+end
diff --git a/lib/bds/desktop/router.ex b/lib/bds/desktop/router.ex
new file mode 100644
index 0000000..1742d2d
--- /dev/null
+++ b/lib/bds/desktop/router.ex
@@ -0,0 +1,49 @@
+defmodule BDS.Desktop.Router do
+ @moduledoc false
+
+ use Plug.Router
+
+ plug :put_secret_key_base
+
+ plug Plug.Session,
+ store: :cookie,
+ key: "_bds_desktop_key",
+ signing_salt: "desktop-shell"
+
+ plug :match
+ plug Desktop.Auth
+
+ plug Plug.Static,
+ at: "/assets",
+ from: {:bds, "priv/ui"},
+ only: ["app.css", "app.js"]
+
+ plug :dispatch
+
+ get "/" do
+ conn
+ |> Plug.Conn.put_resp_content_type("text/html")
+ |> Plug.Conn.send_resp(200, BDS.Desktop.ShellController.index_html())
+ end
+
+ get "/health" do
+ Plug.Conn.send_resp(conn, 200, "ok")
+ end
+
+ match _ do
+ Plug.Conn.send_resp(conn, 404, "not found")
+ end
+
+ defp put_secret_key_base(conn, _opts) do
+ if conn.secret_key_base do
+ conn
+ else
+ %{conn | secret_key_base: desktop_secret_key_base()}
+ end
+ end
+
+ defp desktop_secret_key_base do
+ Application.get_env(:bds, :desktop)[:secret_key_base] ||
+ raise "missing :desktop secret_key_base configuration"
+ end
+end
diff --git a/lib/bds/desktop/server.ex b/lib/bds/desktop/server.ex
new file mode 100644
index 0000000..a92c081
--- /dev/null
+++ b/lib/bds/desktop/server.ex
@@ -0,0 +1,38 @@
+defmodule BDS.Desktop.Server do
+ @moduledoc false
+
+ use GenServer
+
+ def child_spec(opts) do
+ %{
+ id: __MODULE__,
+ start: {__MODULE__, :start_link, [opts]}
+ }
+ end
+
+ def start_link(opts) do
+ GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+ end
+
+ def url do
+ BDS.Desktop.url(port())
+ end
+
+ def port do
+ Application.get_env(:bds, :desktop)[:port] || 4010
+ end
+
+ @impl true
+ def init(_opts) do
+ {:ok, bandit_pid} =
+ Bandit.start_link(
+ plug: BDS.Desktop.Router,
+ scheme: :http,
+ ip: {127, 0, 0, 1},
+ port: port(),
+ startup_log: false
+ )
+
+ {:ok, %{bandit_pid: bandit_pid}}
+ end
+end
diff --git a/lib/bds/desktop/shell_controller.ex b/lib/bds/desktop/shell_controller.ex
new file mode 100644
index 0000000..3e16646
--- /dev/null
+++ b/lib/bds/desktop/shell_controller.ex
@@ -0,0 +1,7 @@
+defmodule BDS.Desktop.ShellController do
+ @moduledoc false
+
+ def index_html do
+ File.read!(Application.app_dir(:bds, ["priv", "ui", "index.html"]))
+ end
+end
diff --git a/lib/bds/ui/commands.ex b/lib/bds/ui/commands.ex
new file mode 100644
index 0000000..53f924c
--- /dev/null
+++ b/lib/bds/ui/commands.ex
@@ -0,0 +1,16 @@
+defmodule BDS.UI.Commands do
+ @moduledoc false
+
+ alias BDS.UI.MenuBar
+
+ def handle_shortcut(state, shortcut) when is_map(shortcut) do
+ key = shortcut |> Map.get(:key, Map.get(shortcut, "key", "")) |> String.downcase()
+ primary = Map.get(shortcut, :meta, false) or Map.get(shortcut, :ctrl, false)
+
+ cond do
+ primary and key == "b" -> MenuBar.execute(state, :toggle_sidebar)
+ primary and key == "w" -> MenuBar.execute(state, :close_tab)
+ true -> state
+ end
+ end
+end
\ No newline at end of file
diff --git a/lib/bds/ui/menu_bar.ex b/lib/bds/ui/menu_bar.ex
new file mode 100644
index 0000000..3d2f259
--- /dev/null
+++ b/lib/bds/ui/menu_bar.ex
@@ -0,0 +1,41 @@
+defmodule BDS.UI.MenuBar do
+ @moduledoc false
+
+ alias BDS.UI.Workbench
+
+ def default_groups(opts \\ []) do
+ dev_mode? = Keyword.get(opts, :dev_mode?, false)
+
+ [
+ %{id: :app, items: [%{id: :about}, %{id: :settings}]},
+ %{id: :file, items: [%{id: :new_post}, %{id: :new_page}, %{id: :close_tab}]},
+ %{id: :edit, items: [%{id: :undo}, %{id: :redo}]},
+ %{id: :view, items: view_items(dev_mode?)},
+ %{id: :window, items: [%{id: :minimize}, %{id: :zoom}]},
+ %{id: :help, items: [%{id: :documentation}, %{id: :api_documentation}]}
+ ]
+ end
+
+ def execute(state, :toggle_sidebar), do: Workbench.toggle_sidebar(state)
+ def execute(state, :toggle_panel), do: Workbench.toggle_panel(state)
+ def execute(state, :toggle_assistant_sidebar), do: Workbench.toggle_assistant_sidebar(state)
+
+ def execute(state, :close_tab) do
+ case state.active_tab do
+ {type, id} -> Workbench.close_tab(state, type, id)
+ nil -> state
+ end
+ end
+
+ def execute(state, _command_id), do: state
+
+ defp view_items(dev_mode?) do
+ base = [
+ %{id: :toggle_sidebar},
+ %{id: :toggle_panel},
+ %{id: :toggle_assistant_sidebar}
+ ]
+
+ if dev_mode?, do: base ++ [%{id: :toggle_dev_tools}], else: base
+ end
+end
\ No newline at end of file
diff --git a/lib/bds/ui/registry.ex b/lib/bds/ui/registry.ex
new file mode 100644
index 0000000..be63f11
--- /dev/null
+++ b/lib/bds/ui/registry.ex
@@ -0,0 +1,44 @@
+defmodule BDS.UI.Registry do
+ @moduledoc false
+
+ @sidebar_views [
+ %{id: :posts, label: "Posts", activity_group: :top, editor_route: :post, entity_tab: true, demo_kind: :entity},
+ %{id: :pages, label: "Pages", activity_group: :top, editor_route: :post, entity_tab: true, demo_kind: :entity},
+ %{id: :media, label: "Media", activity_group: :top, editor_route: :media, entity_tab: true, demo_kind: :entity},
+ %{id: :scripts, label: "Scripts", activity_group: :top, editor_route: :scripts, entity_tab: true, demo_kind: :entity},
+ %{id: :templates, label: "Templates", activity_group: :top, editor_route: :templates, entity_tab: true, demo_kind: :entity},
+ %{id: :tags, label: "Tags", activity_group: :top, editor_route: :tags, singleton: true, demo_kind: :singleton},
+ %{id: :chat, label: "AI Assistant", activity_group: :top, editor_route: :chat, entity_tab: true, demo_kind: :entity},
+ %{id: :import, label: "Import", activity_group: :top, editor_route: :import, entity_tab: true, demo_kind: :entity},
+ %{id: :git, label: "Source Control", activity_group: :bottom, editor_route: :git_diff, entity_tab: true, demo_kind: :entity},
+ %{id: :settings, label: "Settings", activity_group: :bottom, editor_route: :settings, singleton: true, demo_kind: :singleton}
+ ]
+
+ @editor_routes [
+ %{id: :dashboard, singleton: true, entity_tab: false, title: "Dashboard"},
+ %{id: :post, singleton: false, entity_tab: true, title: "Post"},
+ %{id: :media, singleton: false, entity_tab: true, title: "Media"},
+ %{id: :settings, singleton: true, entity_tab: false, title: "Settings"},
+ %{id: :style, singleton: true, entity_tab: false, title: "Style"},
+ %{id: :tags, singleton: true, entity_tab: false, title: "Tags"},
+ %{id: :chat, singleton: false, entity_tab: true, title: "Chat"},
+ %{id: :import, singleton: false, entity_tab: true, title: "Import"},
+ %{id: :menu_editor, singleton: true, entity_tab: false, title: "Menu"},
+ %{id: :metadata_diff, singleton: true, entity_tab: false, title: "Metadata Diff"},
+ %{id: :git_diff, singleton: false, entity_tab: true, title: "Git Diff"},
+ %{id: :documentation, singleton: true, entity_tab: false, title: "Documentation"},
+ %{id: :api_documentation, singleton: true, entity_tab: false, title: "API"},
+ %{id: :site_validation, singleton: true, entity_tab: false, title: "Site Validation"},
+ %{id: :translation_validation, singleton: true, entity_tab: false, title: "Translations"},
+ %{id: :scripts, singleton: false, entity_tab: true, title: "Script"},
+ %{id: :templates, singleton: false, entity_tab: true, title: "Template"},
+ %{id: :find_duplicates, singleton: true, entity_tab: false, title: "Find Duplicates"}
+ ]
+
+ def default_sidebar_view, do: :posts
+ def sidebar_views, do: @sidebar_views
+ def editor_routes, do: @editor_routes
+
+ def sidebar_view(id) when is_atom(id), do: Enum.find(@sidebar_views, &(&1.id == id))
+ def editor_route(id) when is_atom(id), do: Enum.find(@editor_routes, &(&1.id == id))
+end
\ No newline at end of file
diff --git a/lib/bds/ui/session.ex b/lib/bds/ui/session.ex
new file mode 100644
index 0000000..a6f2394
--- /dev/null
+++ b/lib/bds/ui/session.ex
@@ -0,0 +1,68 @@
+defmodule BDS.UI.Session do
+ @moduledoc false
+
+ alias BDS.UI.Workbench
+
+ def serialize(state) do
+ %{
+ "sidebar_visible" => state.sidebar_visible,
+ "sidebar_width" => state.sidebar_width,
+ "active_view" => Atom.to_string(state.active_view),
+ "assistant_sidebar_visible" => state.assistant_sidebar_visible,
+ "assistant_sidebar_width" => state.assistant_sidebar_width,
+ "panel" => %{
+ "visible" => state.panel.visible,
+ "active_tab" => Atom.to_string(state.panel.active_tab)
+ },
+ "tabs" =>
+ Enum.map(state.tabs, fn tab ->
+ %{
+ "type" => Atom.to_string(tab.type),
+ "id" => tab.id,
+ "is_transient" => tab.is_transient
+ }
+ end),
+ "active_tab" => encode_tab_ref(state.active_tab),
+ "dirty_tabs" => Enum.map(state.dirty_tabs, &encode_tab_ref/1)
+ }
+ end
+
+ def restore(payload) when is_map(payload) do
+ state =
+ Workbench.new(
+ sidebar_visible: Map.get(payload, "sidebar_visible", true),
+ sidebar_width: Map.get(payload, "sidebar_width", 280),
+ active_view: Map.get(payload, "active_view", "posts"),
+ assistant_sidebar_visible: Map.get(payload, "assistant_sidebar_visible", false),
+ assistant_sidebar_width: Map.get(payload, "assistant_sidebar_width", 360),
+ panel_visible: get_in(payload, ["panel", "visible"]) || false,
+ panel_tab: atomize(get_in(payload, ["panel", "active_tab"]) || "tasks"),
+ dirty_tabs: Enum.map(Map.get(payload, "dirty_tabs", []), &decode_tab_ref/1)
+ )
+
+ tabs =
+ Enum.map(Map.get(payload, "tabs", []), fn tab ->
+ %{
+ type: atomize(Map.get(tab, "type", "post")),
+ id: Map.get(tab, "id"),
+ is_transient: Map.get(tab, "is_transient", false)
+ }
+ end)
+
+ active_tab = decode_tab_ref(Map.get(payload, "active_tab"))
+
+ %{state | tabs: tabs, active_tab: active_tab, editor_route: active_route(active_tab)}
+ end
+
+ defp encode_tab_ref(nil), do: nil
+ defp encode_tab_ref({type, id}), do: %{"type" => Atom.to_string(type), "id" => id}
+
+ defp decode_tab_ref(nil), do: nil
+ defp decode_tab_ref(%{"type" => type, "id" => id}), do: {atomize(type), id}
+
+ defp atomize(value) when is_atom(value), do: value
+ defp atomize(value) when is_binary(value), do: String.to_atom(value)
+
+ defp active_route(nil), do: :dashboard
+ defp active_route({type, _id}), do: type
+end
\ No newline at end of file
diff --git a/lib/bds/ui/shell_page.ex b/lib/bds/ui/shell_page.ex
new file mode 100644
index 0000000..b5be7c8
--- /dev/null
+++ b/lib/bds/ui/shell_page.ex
@@ -0,0 +1,62 @@
+defmodule BDS.UI.ShellPage do
+ @moduledoc false
+
+ alias BDS.UI.MenuBar
+ alias BDS.UI.Registry
+ alias BDS.UI.Session
+ alias BDS.UI.Workbench
+
+ def render do
+ bootstrap =
+ %{
+ registry: %{
+ sidebar_views: Registry.sidebar_views(),
+ editor_routes: Registry.editor_routes(),
+ default_sidebar_view: Registry.default_sidebar_view()
+ },
+ menu_groups: MenuBar.default_groups(),
+ session: Session.serialize(Workbench.new(panel_visible: true)),
+ status: %{
+ post_count: 12,
+ media_count: 34,
+ theme_badge: "zinc",
+ ui_language: "en",
+ offline_mode: true,
+ running_task_message: "Building starter shell",
+ running_task_overflow: 1,
+ git_badge_count: 7
+ }
+ }
+
+ [
+ "",
+ "",
+ "",
+ " bDS Shell ",
+ " ",
+ "
",
+ "
",
+ "
",
+ "
",
+ "
",
+ "
",
+ " ",
+ " ",
+ " ",
+ "
",
+ "
",
+ "
",
+ "
${top.map(renderActivityButton).join('')}
+ ${bottom.map(renderActivityButton).join('')}
+ `;
+}
+
+function renderActivityButton(view) {
+ const active = state.sidebarVisible && state.activeView === view.id;
+ return `${view.label.slice(0, 1)} `;
+}
+
+function renderSidebar() {
+ const view = state.sidebarViews.find((entry) => entry.id === state.activeView) || state.sidebarViews[0];
+ const node = root.querySelector('.sidebar');
+
+ node.innerHTML = `
+
+
+ `;
+}
+
+function renderTabs() {
+ const node = root.querySelector('.tab-bar');
+ node.innerHTML = `${state.tabs.map(renderTab).join('')}
`;
+}
+
+function renderTab(tab) {
+ const active = tab.id === state.activeTabId;
+ const dirtyMarker = tab.dirty ? '● ' : '× ';
+ return `
+
+ ${tab.title}
+ ${dirtyMarker}
+
+ `;
+}
+
+function renderEditor() {
+ const node = root.querySelector('.editor-shell');
+ const activeTab = state.tabs.find((tab) => tab.id === state.activeTabId) || state.tabs[0];
+
+ node.innerHTML = `
+
+
+ ${activeTab.title}
+ ${activeTab.kind} editor surface routed through the desktop shell
+
+ Publish
+ Preview
+ Metadata
+
+ This desktop shell now runs inside an Elixir Desktop window instead of a standalone browser page. The frame, activity bar, tab strip, status bar and resizable side areas match the old application structure so the next slice can replace placeholders with the real editors and lists.
+ Preview tabs, dirty state and shell routing still come from the shared Elixir workbench modules. The runtime boundary is now a desktop window backed by a local shell server.
+
+
+
+
+ ${state.panelTab}
+ Shared bottom panel host for problems, search, tasks and later runtime details.
+
+
+
+ Next shell work
+ Swap sidebar placeholders with real project data views.
+
+
+ Offline gate
+ Automatic AI remains gated by airplane mode.
+
+
+ Desktop runtime
+ Window, menu bar and launch path now come from Elixir Desktop.
+
+
${state.statusBar.left.map(renderStatusItem).join('')}
+ ${state.statusBar.right.map(renderStatusItem).join('')}
+ `;
+}
+
+function renderStatusItem(item) {
+ return `${item.label}
`;
+}
+
+function applyVisibility() {
+ root.querySelector('.sidebar-shell').classList.toggle('is-hidden', !state.sidebarVisible);
+ root.querySelector('.assistant-sidebar-shell').classList.toggle('is-hidden', !state.assistantVisible);
+ root.querySelector('.panel-shell').classList.toggle('is-hidden', !state.panelVisible);
+}
+
+function bindEvents() {
+ root.querySelectorAll('[data-activity]').forEach((button) => {
+ button.onclick = () => {
+ const next = button.getAttribute('data-activity');
+ if (state.activeView === next && state.sidebarVisible) {
+ state.sidebarVisible = false;
+ } else {
+ state.activeView = next;
+ state.sidebarVisible = true;
+ }
+ render();
+ };
+ });
+
+ root.querySelectorAll('[data-open-tab]').forEach((button) => {
+ button.onclick = () => {
+ const tabId = button.getAttribute('data-open-tab');
+ let tab = state.tabs.find((entry) => entry.id === tabId);
+ if (!tab) {
+ tab = {
+ id: tabId,
+ title: tabId.split(':').pop(),
+ kind: state.activeView,
+ pinned: false,
+ dirty: false,
+ };
+ state.tabs.push(tab);
+ }
+ state.activeTabId = tab.id;
+ render();
+ };
+ });
+
+ root.querySelectorAll('[data-tab]').forEach((tab) => {
+ tab.onclick = () => {
+ state.activeTabId = tab.getAttribute('data-tab');
+ render();
+ };
+ });
+
+ root.querySelectorAll('[data-command]').forEach((button) => {
+ button.onclick = () => {
+ const command = button.getAttribute('data-command');
+ if (command === 'toggle-sidebar') {
+ state.sidebarVisible = !state.sidebarVisible;
+ }
+ if (command === 'toggle-panel') {
+ state.panelVisible = !state.panelVisible;
+ }
+ render();
+ };
+ });
+
+ root.querySelectorAll('[data-panel-tab]').forEach((button) => {
+ button.onclick = () => {
+ state.panelTab = button.getAttribute('data-panel-tab');
+ state.panelVisible = true;
+ render();
+ };
+ });
+
+ root.querySelectorAll('[data-resize]').forEach((handle) => {
+ handle.onpointerdown = (event) => {
+ const target = handle.getAttribute('data-resize');
+ const startX = event.clientX;
+ const startWidth = target === 'sidebar' ? state.sidebarWidth : state.assistantWidth;
+ handle.classList.add('is-dragging');
+
+ const onMove = (moveEvent) => {
+ const delta = moveEvent.clientX - startX;
+ if (target === 'sidebar') {
+ state.sidebarWidth = clamp(startWidth + delta, 220, 520);
+ } else {
+ state.assistantWidth = clamp(startWidth - delta, 280, 520);
+ }
+ render();
+ };
+
+ const onUp = () => {
+ handle.classList.remove('is-dragging');
+ window.removeEventListener('pointermove', onMove);
+ window.removeEventListener('pointerup', onUp);
+ };
+
+ window.addEventListener('pointermove', onMove);
+ window.addEventListener('pointerup', onUp);
+ };
+ });
+}
+
+function clamp(value, min, max) {
+ return Math.max(min, Math.min(max, value));
+}
+
+render();
+function renderStatusBar() {
+ const active = activeTab();
+ const dirty = active && rootState.dirty_tabs.some(entry => sameTab(entry, active));
+ const postStatus = active && active.type === "post" ? (dirty ? "draft" : "published") : null;
+ const tokenUsage = active && active.type === "chat" ? "I 120 · O 42 · C 8" : null;
+
+ statusBar.innerHTML = `
+
+
+ ${rootState.project}
+
+ ${rootState.running_task_message}${rootState.running_task_overflow ? ` +${rootState.running_task_overflow}` : ""}
+
+
+ ${postStatus ? `${postStatus} ` : ""}
+ ${rootState.post_count} posts
+ ${rootState.media_count} media
+ ${tokenUsage ? `${tokenUsage} ` : ""}
+
+ ${["zinc", "amber", "jade", "sand"].map(theme => `${theme} `).join("")}
+
+ ${rootState.offline_mode ? "Offline" : "Online"}
+
+ ${["en", "de", "fr", "it", "es"].map(language => `${language.toUpperCase()} `).join("")}
+
+ bDS
+
+ `;
+}
+
+function wireGlobalEvents() {
+ document.addEventListener("click", handleClick);
+ document.addEventListener("dblclick", handleDoubleClick);
+ document.addEventListener("keydown", handleKeyDown);
+ document.addEventListener("change", handleChange);
+ document.querySelectorAll('[data-role="resize-handle"]').forEach(handle => {
+ handle.addEventListener("pointerdown", startResize);
+ });
+}
+
+function handleClick(event) {
+ const commandButton = event.target.closest("[data-command]");
+ if (commandButton) {
+ event.preventDefault();
+ executeCommand(commandButton.dataset.command);
+ return;
+ }
+
+ const menuTrigger = event.target.closest("[data-menu-trigger]");
+ if (menuTrigger) {
+ const id = menuTrigger.dataset.menuTrigger;
+ openMenu = openMenu === id ? null : id;
+ render();
+ return;
+ }
+
+ if (!event.target.closest(".menu-group")) {
+ if (openMenu !== null) {
+ openMenu = null;
+ renderTitleBar();
+ }
+ }
+
+ const activity = event.target.closest("[data-activity]");
+ if (activity) {
+ clickActivity(activity.dataset.activity);
+ return;
+ }
+
+ const activate = event.target.closest("[data-tab-activate]");
+ if (activate) {
+ const [type, id] = activate.dataset.tabActivate.split(":");
+ rootState.active_tab = { type, id };
+ normalizePanel();
+ render();
+ return;
+ }
+
+ const closeButton = event.target.closest("[data-tab-close]");
+ if (closeButton) {
+ const [type, id] = closeButton.dataset.tabClose.split(":");
+ closeTab(type, id);
+ return;
+ }
+
+ const demoButton = event.target.closest("[data-open-demo]");
+ if (demoButton) {
+ openDemoFromView(demoButton.dataset.openDemo);
+ return;
+ }
+
+ const action = event.target.closest("[data-action]");
+ if (action) {
+ handleAction(action.dataset.action);
+ return;
+ }
+
+ const panelTab = event.target.closest("[data-panel-tab]");
+ if (panelTab && !panelTab.disabled) {
+ rootState.panel.active_tab = panelTab.dataset.panelTab;
+ render();
+ }
+}
+
+function handleDoubleClick(event) {
+ const tab = event.target.closest("[data-tab-type][data-tab-id]");
+ if (!tab) return;
+
+ const type = tab.dataset.tabType;
+ const id = tab.dataset.tabId;
+ const found = rootState.tabs.find(entry => entry.type === type && entry.id === id);
+
+ if (found && found.is_transient) {
+ found.is_transient = false;
+ render();
+ }
+}
+
+function handleKeyDown(event) {
+ const primary = event.metaKey || event.ctrlKey;
+ if (!primary) return;
+
+ const key = event.key.toLowerCase();
+
+ if (key === "b") {
+ event.preventDefault();
+ executeCommand("toggle_sidebar");
+ }
+
+ if (key === "w") {
+ event.preventDefault();
+ executeCommand("close_tab");
+ }
+}
+
+function handleChange(event) {
+ const action = event.target.dataset.action;
+ if (!action) return;
+
+ if (action === "theme-select") {
+ rootState.theme_badge = event.target.value;
+ render();
+ }
+
+ if (action === "language-select") {
+ rootState.ui_language = event.target.value;
+ render();
+ }
+}
+
+function startResize(event) {
+ const target = event.currentTarget.dataset.target;
+ const initialX = event.clientX;
+ const initialWidth = target === "sidebar" ? rootState.sidebar_width : rootState.assistant_sidebar_width;
+
+ const move = moveEvent => {
+ const delta = moveEvent.clientX - initialX;
+
+ if (target === "sidebar") {
+ rootState.sidebar_width = clamp(initialWidth + delta, 200, 500);
+ } else {
+ rootState.assistant_sidebar_width = clamp(initialWidth - delta, 280, 640);
+ }
+
+ render();
+ };
+
+ const stop = () => {
+ window.removeEventListener("pointermove", move);
+ window.removeEventListener("pointerup", stop);
+ };
+
+ window.addEventListener("pointermove", move);
+ window.addEventListener("pointerup", stop);
+}
+
+function executeCommand(command) {
+ if (command === "toggle_sidebar") {
+ rootState.sidebar_visible = !rootState.sidebar_visible;
+ }
+
+ if (command === "toggle_panel") {
+ rootState.panel.visible = !rootState.panel.visible;
+ }
+
+ if (command === "toggle_assistant_sidebar") {
+ rootState.assistant_sidebar_visible = !rootState.assistant_sidebar_visible;
+ }
+
+ if (command === "close_tab" && rootState.active_tab) {
+ closeTab(rootState.active_tab.type, rootState.active_tab.id);
+ return;
+ }
+
+ if (command === "settings") {
+ openTab("settings", "settings", "pin");
+ }
+
+ if (command === "documentation") {
+ openTab("documentation", "documentation", "pin");
+ }
+
+ if (command === "api_documentation") {
+ openTab("api_documentation", "api_documentation", "pin");
+ }
+
+ normalizePanel();
+ render();
+}
+
+function handleAction(action) {
+ if (action === "toggle-dirty") {
+ const active = activeTab();
+ if (!active || active.type !== "post") return;
+
+ const index = rootState.dirty_tabs.findIndex(entry => sameTab(entry, active));
+ if (index >= 0) {
+ rootState.dirty_tabs.splice(index, 1);
+ } else {
+ rootState.dirty_tabs.push({ type: active.type, id: active.id });
+ }
+ render();
+ return;
+ }
+
+ if (action === "pin-active") {
+ const active = activeTab();
+ if (!active) return;
+ const found = rootState.tabs.find(tab => sameTab(tab, active));
+ if (found) found.is_transient = false;
+ render();
+ return;
+ }
+
+ if (action === "toggle-offline") {
+ rootState.offline_mode = !rootState.offline_mode;
+ render();
+ return;
+ }
+
+ if (action === "reset-session") {
+ localStorage.removeItem(sessionKey);
+ location.reload();
+ return;
+ }
+
+ if (action === "open-chat") {
+ openTab("chat", "conversation-demo", "pin");
+ }
+}
+
+function clickActivity(id) {
+ if (rootState.active_view === id) {
+ rootState.sidebar_visible = !rootState.sidebar_visible;
+ } else {
+ rootState.active_view = id;
+ rootState.sidebar_visible = true;
+ }
+ render();
+}
+
+function openDemoFromView(mode) {
+ const view = registry.sidebar_views.find(entry => entry.id === rootState.active_view) || registry.sidebar_views[0];
+ const type = view.editor_route;
+ const isSingleton = !!view.singleton;
+ const id = isSingleton ? type : `${rootState.active_view}-demo-${view.activity_group === "bottom" ? "tool" : "item"}`;
+ const intent = mode === "pin" ? "pin" : "preview";
+
+ if (mode === "background") {
+ openTab(type, id, intent, true);
+ } else {
+ openTab(type, id, intent, false);
+ }
+}
+
+function openTab(type, id, intent, background) {
+ const existing = rootState.tabs.find(tab => tab.type === type && tab.id === id);
+ const singleton = !!routeMeta(type)?.singleton;
+ const sticky = type === "chat" || type === "import" || singleton;
+ const transient = !sticky && intent === "preview";
+
+ if (existing) {
+ if (intent === "pin") existing.is_transient = false;
+ if (!background) rootState.active_tab = { type, id };
+ normalizePanel();
+ render();
+ return;
+ }
+
+ if (transient) {
+ const replacementIndex = rootState.tabs.findIndex(tab => tab.type === type && tab.is_transient);
+ const newTab = { type, id, is_transient: true };
+ if (replacementIndex >= 0) {
+ rootState.tabs.splice(replacementIndex, 1, newTab);
+ } else {
+ rootState.tabs.push(newTab);
+ }
+ } else {
+ rootState.tabs.push({ type, id, is_transient: false });
+ }
+
+ if (!background) {
+ rootState.active_tab = { type, id };
+ }
+
+ normalizePanel();
+ render();
+}
+
+function closeTab(type, id) {
+ const index = rootState.tabs.findIndex(tab => tab.type === type && tab.id === id);
+ if (index < 0) return;
+
+ rootState.tabs.splice(index, 1);
+ rootState.dirty_tabs = rootState.dirty_tabs.filter(tab => !(tab.type === type && tab.id === id));
+
+ if (rootState.active_tab && rootState.active_tab.type === type && rootState.active_tab.id === id) {
+ if (rootState.tabs[index]) {
+ rootState.active_tab = { type: rootState.tabs[index].type, id: rootState.tabs[index].id };
+ } else if (rootState.tabs[index - 1]) {
+ rootState.active_tab = { type: rootState.tabs[index - 1].type, id: rootState.tabs[index - 1].id };
+ } else {
+ rootState.active_tab = null;
+ }
+ }
+
+ normalizePanel();
+ render();
+}
+
+function normalizePanel() {
+ const route = activeTab() ? activeTab().type : "dashboard";
+ if (!panelAvailable(route, rootState.panel.active_tab)) {
+ rootState.panel.active_tab = "tasks";
+ }
+}
+
+function panelAvailable(route, tab) {
+ if (tab === "tasks" || tab === "output") return true;
+ if (tab === "post_links") return route === "post";
+ if (tab === "git_log") return route === "post" || route === "media";
+ return false;
+}
+
+function activeTab() {
+ if (!rootState.active_tab) return null;
+ return rootState.tabs.find(tab => sameTab(tab, rootState.active_tab)) || null;
+}
+
+function routeMeta(id) {
+ return registry.editor_routes.find(route => route.id === id) || null;
+}
+
+function sameTab(left, right) {
+ return !!left && !!right && left.type === right.type && left.id === right.id;
+}
+
+function tabTitle(tab) {
+ const meta = routeMeta(tab.type);
+ const prefix = meta ? meta.title : titleCase(tab.type);
+ if (meta && meta.singleton) return prefix;
+ return `${prefix} ${tab.id}`;
+}
+
+function labelForPanel(tab) {
+ return {
+ tasks: "Tasks",
+ output: "Output",
+ post_links: "Post Links",
+ git_log: "Git Log"
+ }[tab] || titleCase(tab);
+}
+
+function labelForCommand(id) {
+ return id
+ .split("_")
+ .map(titleCase)
+ .join(" ");
+}
+
+function compactLabel(label) {
+ return label.split(" ").map(part => part[0]).join("").slice(0, 3).toUpperCase();
+}
+
+function titleCase(value) {
+ return String(value)
+ .split(/[_\s-]+/)
+ .filter(Boolean)
+ .map(part => part[0].toUpperCase() + part.slice(1))
+ .join(" ");
+}
+
+function clamp(value, min, max) {
+ return Math.min(max, Math.max(min, Number(value) || min));
+}
+
+function safeParse(value) {
+ try {
+ return value ? JSON.parse(value) : null;
+ } catch (_error) {
+ return null;
+ }
+}
diff --git a/priv/ui/index.html b/priv/ui/index.html
new file mode 100644
index 0000000..c3e0a1d
--- /dev/null
+++ b/priv/ui/index.html
@@ -0,0 +1,104 @@
+
+
+
+ bDS Shell
+ Blogging Desktop Server
+
+
+
+
Blogging Desktop Server
+
+
+
+
+
+
+
+
+
+
+
+
+
Workbench.open_tab(:post, "post-1", :preview)
+
+ assert state.active_tab == {:post, "post-1"}
+ assert state.editor_route == :post
+ assert [%{type: :post, id: "post-1", is_transient: true}] = state.tabs
+
+ state = Workbench.open_tab(state, :post, "post-2", :preview)
+
+ assert state.active_tab == {:post, "post-2"}
+ assert state.editor_route == :post
+ assert [%{type: :post, id: "post-2", is_transient: true}] = state.tabs
+ end
+
+ test "opening an existing preview tab as pinned upgrades it instead of duplicating it" do
+ state =
+ Workbench.new()
+ |> Workbench.open_tab(:post, "post-1", :preview)
+ |> Workbench.open_tab(:post, "post-1", :pin)
+
+ assert state.active_tab == {:post, "post-1"}
+ assert [%{type: :post, id: "post-1", is_transient: false}] = state.tabs
+ end
+
+ test "singleton tabs deduplicate and are never transient" do
+ state =
+ Workbench.new()
+ |> Workbench.open_tab(:settings, "settings", :preview)
+ |> Workbench.open_tab(:settings, "settings", :pin)
+
+ assert state.active_tab == {:settings, "settings"}
+ assert [%{type: :settings, id: "settings", is_transient: false}] = state.tabs
+ end
+
+ test "background opening keeps the active editor unchanged while still applying tab policy" do
+ state =
+ Workbench.new()
+ |> Workbench.open_tab(:post, "post-1", :pin)
+ |> Workbench.open_tab_in_background(:media, "media-1", :preview)
+
+ assert state.active_tab == {:post, "post-1"}
+ assert state.editor_route == :post
+
+ assert Enum.map(state.tabs, &{&1.type, &1.id, &1.is_transient}) == [
+ {:post, "post-1", false},
+ {:media, "media-1", true}
+ ]
+ end
+
+ test "closing the active tab activates the next tab at the same index and falls back to dashboard" do
+ state =
+ Workbench.new()
+ |> Workbench.open_tab(:post, "post-1", :pin)
+ |> Workbench.open_tab(:media, "media-1", :pin)
+ |> Workbench.open_tab(:chat, "conversation-1", :pin)
+
+ state = Workbench.close_tab(state, :media, "media-1")
+
+ assert state.active_tab == {:chat, "conversation-1"}
+ assert state.editor_route == :chat
+
+ state =
+ state
+ |> Workbench.close_tab(:chat, "conversation-1")
+ |> Workbench.close_tab(:post, "post-1")
+
+ assert state.tabs == []
+ assert state.active_tab == nil
+ assert state.editor_route == :dashboard
+ end
+
+ test "activity clicks switch sidebar views and toggle visibility when re-clicking the active view" do
+ state = Workbench.new()
+
+ assert state.active_view == :posts
+ assert state.sidebar_visible == true
+
+ state = Workbench.click_activity(state, :posts)
+ assert state.sidebar_visible == false
+ assert state.active_view == :posts
+
+ state = Workbench.click_activity(state, :media)
+ assert state.sidebar_visible == true
+ assert state.active_view == :media
+
+ buttons = Workbench.activity_buttons(state, 108)
+ media_button = Enum.find(buttons, &(&1.id == :media))
+ git_button = Enum.find(buttons, &(&1.id == :git))
+
+ assert media_button.active == true
+ assert git_button.badge.display == "99+"
+ end
+
+ test "panel tab availability falls back to tasks when the active editor no longer supports the panel" do
+ state =
+ Workbench.new()
+ |> Workbench.set_panel_visible(true)
+ |> Workbench.set_panel_tab(:post_links)
+ |> Workbench.open_tab(:post, "post-1", :pin)
+
+ assert state.panel.active_tab == :post_links
+
+ state = Workbench.open_tab(state, :settings, "settings", :pin)
+
+ assert state.editor_route == :settings
+ assert state.panel.active_tab == :tasks
+
+ state = Workbench.set_panel_tab(state, :git_log)
+ state = Workbench.open_tab(state, :media, "media-1", :pin)
+ assert state.panel.active_tab == :git_log
+ end
+
+ test "status bar data follows the active editor kind" do
+ state =
+ Workbench.new()
+ |> Workbench.open_tab(:post, "post-1", :pin)
+
+ status =
+ Workbench.status_bar(state,
+ post_count: 12,
+ media_count: 7,
+ theme_badge: "zinc",
+ ui_language: "de",
+ offline_mode: true,
+ running_task_message: "Generating site",
+ running_task_overflow: 2,
+ active_post_status: :draft,
+ token_usage: %{input_tokens: 10, output_tokens: 20, cache_read_tokens: 3}
+ )
+
+ assert status.left.running_task_message == "Generating site"
+ assert status.right.post_status == "draft"
+ assert status.right.post_count == "12 posts"
+ assert status.right.media_count == "7 media"
+ assert status.right.token_usage == nil
+
+ state = Workbench.open_tab(state, :chat, "conversation-1", :pin)
+
+ status =
+ Workbench.status_bar(state,
+ post_count: 12,
+ media_count: 7,
+ theme_badge: "zinc",
+ ui_language: "de",
+ offline_mode: true,
+ token_usage: %{input_tokens: 10, output_tokens: 20, cache_read_tokens: 3}
+ )
+
+ assert status.right.post_status == nil
+ assert status.right.token_usage == %{input_tokens: 10, output_tokens: 20, cache_read_tokens: 3}
+ end
+
+ test "menu commands expose generic shell controls through a shared command model" do
+ state = Workbench.new(sidebar_visible: false, panel_visible: false)
+ groups = MenuBar.default_groups(dev_mode?: false)
+
+ assert Enum.map(groups, & &1.id) == [:app, :file, :edit, :view, :window, :help]
+
+ view_group = Enum.find(groups, &(&1.id == :view))
+ command_ids = Enum.map(view_group.items, & &1.id)
+
+ assert :toggle_sidebar in command_ids
+ assert :toggle_panel in command_ids
+ refute :toggle_dev_tools in command_ids
+
+ state = MenuBar.execute(state, :toggle_sidebar)
+ state = MenuBar.execute(state, :toggle_panel)
+
+ assert state.sidebar_visible == true
+ assert state.panel.visible == true
+ end
+end
\ No newline at end of file