@jmfederico/pi-web 1.202606.0 → 1.202606.2

package/dist/pi-web-plugins/workspace-tasks/tasksPanelElement.js

@@ -0,0 +1,292 @@
+// Generated from pi-web-plugins/workspace-tasks/tasksPanelElement.ts. Do not edit directly.
+import { TASKS_CONFIG_PATH } from "./config.js";
+import { runWorkspaceTaskInTerminal } from "./taskRunner.js";
+import { loadWorkspaceTasksConfig, tasksConfigRefreshHint, tasksConfigUnavailableMessage } from "./workspaceTasksClient.js";
+export const tasksPanelTagName = "pi-web-workspace-tasks-panel";
+const configChangedEvent = "pi-web-workspace-tasks-config-changed";
+const configCache = new Map();
+export function defineTasksPanelElement() {
+    if (!customElements.get(tasksPanelTagName))
+        customElements.define(tasksPanelTagName, PiWebTasksPanel);
+}
+export function tasksPanelBadge(context) {
+    const state = getCachedWorkspaceConfig(context);
+    if (state?.kind === "unavailable")
+        return "!";
+    if (state?.kind === "loaded" && state.config.tasks.length > 0)
+        return state.config.tasks.length;
+    return undefined;
+}
+class PiWebTasksPanel extends HTMLElement {
+    contextValue;
+    runningTaskId;
+    status;
+    root;
+    onConfigChanged = () => {
+        this.render();
+    };
+    constructor() {
+        super();
+        this.root = this.attachShadow({ mode: "open" });
+    }
+    set context(value) {
+        const previousKey = this.contextValue === undefined ? undefined : cacheKeyForContext(this.contextValue);
+        const nextKey = value === undefined ? undefined : cacheKeyForContext(value);
+        this.contextValue = value;
+        // Parent app updates should not rebuild this shadow DOM for the same workspace:
+        // doing so resets the mobile scroll position and can replace buttons mid-click.
+        if (previousKey === nextKey)
+            return;
+        this.runningTaskId = undefined;
+        this.status = undefined;
+        this.render();
+    }
+    connectedCallback() {
+        window.addEventListener(configChangedEvent, this.onConfigChanged);
+        this.render();
+    }
+    disconnectedCallback() {
+        window.removeEventListener(configChangedEvent, this.onConfigChanged);
+    }
+    render() {
+        const context = this.contextValue;
+        if (context === undefined) {
+            this.root.innerHTML = `${taskStyles()}<section class="empty">Select a workspace.</section>`;
+            return;
+        }
+        const state = getOrLoadWorkspaceConfig(context);
+        this.root.innerHTML = `
+      ${taskStyles()}
+      <section class="toolbar">
+        <strong>Workspace Tasks</strong>
+        <span class="toolbar-tasks">
+          <button class="secondary" data-refresh-config ${state.kind === "loading" ? "disabled" : ""}>Refresh</button>
+          <button class="secondary" data-open-terminal>Open Terminal</button>
+        </span>
+      </section>
+      ${this.renderStatus()}
+      <section class="viewer tasks-viewer">
+        ${this.renderConfigState(state)}
+      </section>
+    `;
+        this.root.querySelector("button[data-refresh-config]")?.addEventListener("click", () => {
+            void this.refreshConfig(context);
+        });
+        for (const button of this.root.querySelectorAll("button[data-task-id]")) {
+            button.addEventListener("click", () => {
+                void this.dispatchTaskById(context, button.getAttribute("data-task-id"));
+            });
+        }
+        this.root.querySelector("button[data-open-terminal]")?.addEventListener("click", () => {
+            this.openWorkspaceTerminal();
+        });
+    }
+    dispatchTaskById(context, taskId) {
+        if (!this.isCurrentContext(context))
+            return Promise.resolve();
+        const task = taskFromConfigState(getCachedWorkspaceConfig(context), taskId);
+        if (task === undefined) {
+            this.status = { kind: "error", message: "That task is no longer available. Click Refresh, then try again." };
+            this.render();
+            return Promise.resolve();
+        }
+        return this.dispatchTask(context, task);
+    }
+    isCurrentContext(context) {
+        return this.contextValue !== undefined && cacheKeyForContext(this.contextValue) === cacheKeyForContext(context);
+    }
+    renderConfigState(state) {
+        if (state.kind === "loading")
+            return `<p class="muted">Loading ${escapeHtml(TASKS_CONFIG_PATH)}…</p>`;
+        if (state.kind === "missing")
+            return renderMissingState(state);
+        if (state.kind === "unavailable")
+            return renderUnavailableState(state);
+        if (state.config.tasks.length === 0)
+            return `<p class="muted">No tasks are defined in ${escapeHtml(state.path)}. Add tasks to the file, then click Refresh.</p>`;
+        return `
+      <p class="muted">Tasks run in a dedicated workspace terminal, then switch to that terminal. Edit ${escapeHtml(state.path)} and click Refresh to reload.</p>
+      ${renderTaskGroups(state.config.tasks, this.runningTaskId)}
+    `;
+    }
+    renderStatus() {
+        if (this.status === undefined)
+            return "";
+        const detail = this.status.detail === undefined ? "" : `<pre>${escapeHtml(this.status.detail)}</pre>`;
+        return `<div class="status panel-status ${escapeAttr(this.status.kind)}">${escapeHtml(this.status.message)}${detail}</div>`;
+    }
+    async refreshConfig(context) {
+        this.status = { kind: "info", message: `Refreshing ${TASKS_CONFIG_PATH}…` };
+        configCache.set(cacheKeyForContext(context), { kind: "loading" });
+        this.render();
+        const state = await refreshWorkspaceConfig(context);
+        if (!this.isCurrentContext(context))
+            return;
+        this.status = state.kind === "loaded"
+            ? { kind: "success", message: `Loaded ${String(state.config.tasks.length)} task${state.config.tasks.length === 1 ? "" : "s"}.` }
+            : undefined;
+        this.render();
+    }
+    async dispatchTask(context, task) {
+        if (this.runningTaskId !== undefined) {
+            this.status = { kind: "info", message: "Another task is already starting. Wait for it to finish dispatching, then try again." };
+            this.render();
+            return;
+        }
+        if (task.confirm && !window.confirm(`Run ${task.title}?\n\n${task.command}`)) {
+            this.status = { kind: "info", message: `Cancelled ${task.title}.` };
+            this.render();
+            return;
+        }
+        this.runningTaskId = task.id;
+        this.status = { kind: "info", message: `Starting ${task.title}…` };
+        this.render();
+        try {
+            const handle = await runWorkspaceTaskInTerminal(context.terminal, task);
+            if (!this.isCurrentContext(context))
+                return;
+            this.status = {
+                kind: "success",
+                message: `Started terminal command “${handle.run.title}”.`,
+                detail: task.command,
+            };
+            this.runningTaskId = undefined;
+            this.render();
+        }
+        catch (error) {
+            if (!this.isCurrentContext(context))
+                return;
+            this.runningTaskId = undefined;
+            this.status = { kind: "error", message: error instanceof Error ? error.message : String(error) };
+            this.render();
+        }
+    }
+    openWorkspaceTerminal(terminalId) {
+        const context = this.contextValue;
+        if (context === undefined) {
+            this.status = { kind: "error", message: "Select a workspace before opening a terminal." };
+            this.render();
+            return;
+        }
+        if (terminalId === undefined)
+            context.terminal.open();
+        else
+            context.terminal.open({ terminalId });
+    }
+}
+function getCachedWorkspaceConfig(context) {
+    return configCache.get(cacheKeyForContext(context));
+}
+function getOrLoadWorkspaceConfig(context) {
+    const cached = getCachedWorkspaceConfig(context);
+    if (cached !== undefined)
+        return cached;
+    const loading = { kind: "loading" };
+    configCache.set(cacheKeyForContext(context), loading);
+    void refreshWorkspaceConfig(context);
+    return loading;
+}
+async function refreshWorkspaceConfig(context) {
+    const key = cacheKeyForContext(context);
+    const state = await loadWorkspaceTasksConfig(context.files).catch((error) => ({
+        kind: "unavailable",
+        message: tasksConfigUnavailableMessage,
+        hint: tasksConfigRefreshHint,
+        detail: error instanceof Error ? error.message : String(error),
+    }));
+    configCache.set(key, state);
+    context.host.requestRender();
+    window.dispatchEvent(new Event(configChangedEvent));
+    return state;
+}
+function cacheKeyForContext(context) {
+    return `${context.machine.id}:${context.workspace.projectId}:${context.workspace.id}`;
+}
+function renderMissingState(state) {
+    return `<div class="empty-state"><strong>${escapeHtml(state.message)}</strong><p>${escapeHtml(state.hint)}</p></div>`;
+}
+function renderUnavailableState(state) {
+    const detail = state.detail === undefined ? "" : `<pre>${escapeHtml(state.detail)}</pre>`;
+    return `<div class="status error"><strong>${escapeHtml(state.message)}</strong><p>${escapeHtml(state.hint)}</p>${detail}</div>`;
+}
+function renderTaskGroups(tasks, runningTaskId) {
+    return `<div class="tasks">${groupTasks(tasks).map((group) => renderTaskGroup(group, runningTaskId)).join("")}</div>`;
+}
+function groupTasks(tasks) {
+    const groups = [];
+    for (const task of tasks) {
+        const title = task.group;
+        let group = groups.find((candidate) => candidate.title === title);
+        if (group === undefined) {
+            group = { title, tasks: [] };
+            groups.push(group);
+        }
+        group.tasks.push(task);
+    }
+    return groups;
+}
+function renderTaskGroup(group, runningTaskId) {
+    const title = group.title === undefined ? "" : `<h3>${escapeHtml(group.title)}</h3>`;
+    return `<section class="task-group">${title}${group.tasks.map((task) => renderTask(task, runningTaskId)).join("")}</section>`;
+}
+function renderTask(task, runningTaskId) {
+    const running = runningTaskId === task.id;
+    const disabled = runningTaskId !== undefined;
+    const description = task.description === undefined ? "" : `<span>${escapeHtml(task.description)}</span>`;
+    return `
+    <article class="task-card">
+      <div class="task-copy">
+        <strong>${escapeHtml(task.title)}</strong>
+        ${description}
+        <code>${escapeHtml(task.command)}</code>
+      </div>
+      <button data-task-id="${escapeAttr(task.id)}" ${disabled ? "disabled" : ""}>${running ? "Dispatching…" : "Run"}</button>
+    </article>
+  `;
+}
+function taskFromConfigState(state, taskId) {
+    if (state?.kind !== "loaded" || taskId === null)
+        return undefined;
+    return state.config.tasks.find((task) => task.id === taskId);
+}
+function taskStyles() {
+    return `
+    <style>
+      :host { display: contents; }
+      .toolbar { display: flex; align-items: center; justify-content: space-between; gap: 8px; padding: 10px 12px; border-bottom: 1px solid var(--pi-border-muted); }
+      .toolbar-tasks { display: inline-flex; flex-wrap: wrap; justify-content: flex-end; gap: 8px; }
+      .viewer { box-sizing: border-box; min-height: 0; overflow: auto; padding: 12px; }
+      .tasks-viewer { display: grid; align-content: start; gap: 12px; }
+      .tasks { display: grid; gap: 14px; }
+      .task-group { display: grid; gap: 10px; }
+      .task-group h3 { margin: 4px 0 0; color: var(--pi-text-secondary); font-size: 13px; text-transform: uppercase; letter-spacing: 0.04em; }
+      .task-card { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 12px; align-items: center; border: 1px solid var(--pi-border); border-radius: 10px; background: var(--pi-surface); padding: 12px; }
+      .task-copy { display: grid; min-width: 0; gap: 5px; }
+      .task-copy span, .muted { color: var(--pi-muted); }
+      code, pre { border: 1px solid var(--pi-border-muted); border-radius: 6px; background: var(--pi-bg); color: var(--pi-text-secondary); font: 12px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+      code { overflow: auto; padding: 5px 7px; white-space: nowrap; }
+      pre { margin: 8px 0 0; overflow: auto; padding: 8px; white-space: pre-wrap; }
+      button { border: 1px solid var(--pi-accent-border); border-radius: 7px; background: var(--pi-accent); color: var(--pi-bg); cursor: pointer; padding: 6px 10px; font: inherit; }
+      button.secondary { border-color: var(--pi-border); background: var(--pi-surface); color: var(--pi-text); }
+      button:disabled { cursor: wait; opacity: 0.65; }
+      .empty-state { border: 1px dashed var(--pi-border-muted); border-radius: 8px; color: var(--pi-muted); padding: 12px; }
+      .empty-state p { margin: 6px 0 0; }
+      .panel-status { margin: 12px 12px 0; }
+      .status { border: 1px solid var(--pi-border); border-radius: 8px; padding: 10px; }
+      .status.info { border-color: var(--pi-accent-border); background: var(--pi-bg-overlay-soft); }
+      .status.success { border-color: var(--pi-success-border); background: var(--pi-success-surface); color: var(--pi-success); }
+      .status.error { border-color: var(--pi-danger); color: var(--pi-danger); }
+      .empty { padding: 16px; color: var(--pi-muted); }
+      @media (max-width: 760px) {
+        .task-card { grid-template-columns: 1fr; }
+        .task-card button { justify-self: start; }
+      }
+    </style>
+  `;
+}
+function escapeHtml(value) {
+    return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttr(value) {
+    return escapeHtml(value).replaceAll('"', "&quot;");
+}

package/dist/pi-web-plugins/workspace-tasks/workspaceTasksClient.js

@@ -0,0 +1,47 @@
+// Generated from pi-web-plugins/workspace-tasks/workspaceTasksClient.ts. Do not edit directly.
+import { TASKS_CONFIG_PATH, parseTasksConfigText } from "./config.js";
+export const tasksConfigMissingMessage = "No workspace tasks configured here.";
+export const tasksConfigMissingHint = `${TASKS_CONFIG_PATH} is optional. Create it in this workspace if you want custom tasks.`;
+export const tasksConfigUnavailableMessage = "Could not load workspace tasks.";
+export const tasksConfigRefreshHint = `Fix ${TASKS_CONFIG_PATH}, then click Refresh.`;
+const missingWorkspaceFileError = "Path does not exist";
+export async function loadWorkspaceTasksConfig(files) {
+    let file;
+    try {
+        file = await files.readFile(TASKS_CONFIG_PATH);
+    }
+    catch (error) {
+        if (errorMessage(error) === missingWorkspaceFileError)
+            return missing();
+        return unavailable(`Unable to read ${TASKS_CONFIG_PATH}: ${formatUnknownError(error)}`);
+    }
+    if (file.binary)
+        return unavailable(`${TASKS_CONFIG_PATH} must be a text file`);
+    if (file.truncated)
+        return unavailable(`${TASKS_CONFIG_PATH} is too large and was truncated`);
+    const result = parseTasksConfigText(file.content);
+    if (!result.ok)
+        return unavailable(result.error);
+    return { kind: "loaded", config: result.config, path: TASKS_CONFIG_PATH };
+}
+function missing() {
+    return {
+        kind: "missing",
+        message: tasksConfigMissingMessage,
+        hint: tasksConfigMissingHint,
+    };
+}
+function unavailable(detail) {
+    return {
+        kind: "unavailable",
+        message: tasksConfigUnavailableMessage,
+        hint: tasksConfigRefreshHint,
+        detail,
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : undefined;
+}
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/plugin-api/unstable.d.ts

@@ -0,0 +1,22 @@
+import type { TerminalCommandRun, TerminalCommandRunFilter, TerminalCommandRunHandle, Workspace, WorkspaceTerminalCommandInput } from "../plugin-api.js";
+export interface UnstableRunTerminalCommandInput extends WorkspaceTerminalCommandInput {
+    workspace: Workspace;
+}
+export interface UnstableTerminalCommandRunsRuntime {
+    runCommand(input: UnstableRunTerminalCommandInput): Promise<TerminalCommandRunHandle>;
+    listCommandRuns(filter?: TerminalCommandRunFilter): Promise<TerminalCommandRun[]>;
+    getCommandRun(runId: string): Promise<TerminalCommandRun | undefined>;
+    open(options?: {
+        terminalId?: string | undefined;
+    }): void;
+}
+export interface UnstableRuntimeCapabilities {
+    terminalCommandRuns: UnstableTerminalCommandRunsRuntime;
+    openSettings?: (section?: string) => void;
+}
+export interface UnstablePluginRuntimeContext {
+    piWebUnstable?: UnstableRuntimeCapabilities;
+}
+export interface UnstableWorkspacePanelContext {
+    piWebUnstable?: Pick<UnstableRuntimeCapabilities, "terminalCommandRuns">;
+}

package/dist/plugin-api.d.ts

@@ -0,0 +1,169 @@
+import type { TemplateResult } from "lit";
+import type { FileContentResponse, MachineKind, PiWebStatusResponse, TerminalCommandRunHandle } from "./shared/apiTypes.js";
+export type { FileContentMediaType, FileContentResponse, FileTreeEntry, FileTreeResponse, MachineKind, PiWebComponentStatus, PiWebInstallationInfo, PiWebInstallationKind, PiWebReleaseStatus, PiWebServiceComponent, PiWebStatusMessage, PiWebStatusResponse, PiWebStatusSeverity, PiWebVersionResponse, TerminalCommandRun, TerminalCommandRunFilter, TerminalCommandRunHandle, TerminalCommandRunStatus, } from "./shared/apiTypes.js";
+export type PluginId = string;
+export type LocalContributionId = string;
+export type QualifiedContributionId = string;
+export type HtmlTemplateTag = (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
+export type SvgTemplateTag = (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
+export interface PiWebPlugin {
+    apiVersion: 1;
+    name: string;
+    activate: (context: PluginActivationContext) => PluginActivationResult;
+}
+export interface PluginActivationContext {
+    apiVersion: 1;
+    pluginId: PluginId;
+    html: HtmlTemplateTag;
+    svg: SvgTemplateTag;
+}
+export interface PluginActivationResult {
+    contributions: PluginContributions;
+}
+export interface PluginContributions {
+    actions?: PluginAction[];
+    workspacePanels?: WorkspacePanelContribution[];
+    workspaceLabels?: WorkspaceLabelContribution[];
+    themes?: ThemeContribution[];
+    themePairs?: ThemePairContribution[];
+}
+export interface PluginMachine {
+    id: string;
+    name: string;
+    kind: MachineKind;
+}
+export interface PluginRuntimeState {
+    selectedWorkspace?: Workspace;
+    selectedSession?: unknown;
+    workspaceTool?: string;
+    mainView?: string;
+    piWebStatus?: PiWebStatusResponse;
+}
+export interface PluginRuntimeContext {
+    state: PluginRuntimeState;
+    openActionPalette: () => void;
+    focusPrompt: () => void;
+    addProject: () => void | Promise<void>;
+    configureAuth: () => void | Promise<void>;
+    logoutAuth: () => void | Promise<void>;
+    openThemePicker: () => void;
+    selectMainView: (view: string) => void;
+    selectWorkspaceTool: (tool: QualifiedContributionId) => void;
+    openTerminal: (options?: {
+        terminalId?: string | undefined;
+    }) => void;
+    refreshFiles: () => void | Promise<void>;
+    refreshGit: () => void | Promise<void>;
+    refreshAppData: () => void | Promise<void>;
+    reloadPage: () => void;
+    startSession: () => void | Promise<void>;
+    archiveSession: () => void | Promise<void>;
+    stopActiveWork: () => void | Promise<void>;
+}
+export interface PluginAction {
+    id: LocalContributionId;
+    title: string;
+    description?: string;
+    shortcut?: string;
+    group?: string;
+    enabled?: (context: PluginRuntimeContext) => boolean;
+    run: (context: PluginRuntimeContext) => void | Promise<void>;
+}
+export interface Workspace {
+    id: string;
+    projectId: string;
+    path: string;
+    label: string;
+    branch?: string;
+    isMain: boolean;
+    isGitRepo: boolean;
+    isGitWorktree: boolean;
+}
+export interface WorkspaceFiles {
+    readFile(path: string): Promise<FileContentResponse>;
+}
+export type WorkspacePanelFiles = WorkspaceFiles;
+export interface WorkspaceHost {
+    requestRender(): void;
+}
+export type WorkspacePanelHost = WorkspaceHost;
+export interface WorkspaceContext {
+    machine: PluginMachine;
+    workspace: Workspace;
+    state?: PluginRuntimeState;
+    files: WorkspaceFiles;
+    host: WorkspaceHost;
+}
+export interface WorkspaceTerminalCommandInput {
+    title: string;
+    command: string;
+    metadata?: Record<string, string>;
+    open?: boolean;
+}
+export interface WorkspacePanelTerminal {
+    open(options?: {
+        terminalId?: string | undefined;
+    }): void;
+    runCommand(input: WorkspaceTerminalCommandInput): Promise<TerminalCommandRunHandle>;
+}
+export interface WorkspacePanelContext extends WorkspaceContext {
+    terminal: WorkspacePanelTerminal;
+}
+export type WorkspacePanelIcon = TemplateResult;
+export interface WorkspacePanelContribution {
+    id: LocalContributionId;
+    title: string;
+    icon?: WorkspacePanelIcon;
+    order?: number;
+    visible?: (context: WorkspacePanelContext) => boolean;
+    badge?: (context: WorkspacePanelContext) => string | number | TemplateResult | undefined;
+    render: (context: WorkspacePanelContext) => TemplateResult;
+}
+export interface WorkspaceLabelContext extends WorkspaceContext {
+    machine: PluginMachine;
+    workspace: Workspace;
+    state?: PluginRuntimeState;
+    files: WorkspaceFiles;
+    host: WorkspaceHost;
+}
+export type WorkspaceLabelItem = WorkspaceLabelTextItem | WorkspaceLabelLinkItem | WorkspaceLabelRenderItem;
+export interface WorkspaceLabelTextItem {
+    type: "text";
+    text: string;
+    title?: string;
+}
+export interface WorkspaceLabelLinkItem {
+    type: "link";
+    text: string;
+    href: string;
+    title?: string;
+    target?: "_blank" | "_self";
+}
+export interface WorkspaceLabelRenderItem {
+    type: "render";
+    render: () => TemplateResult;
+}
+export interface WorkspaceLabelContribution {
+    id: LocalContributionId;
+    order?: number;
+    visible?: (context: WorkspaceLabelContext) => boolean;
+    items: (context: WorkspaceLabelContext) => WorkspaceLabelItem[];
+}
+export type ThemeColorScheme = "dark" | "light";
+export type ThemeTokens = Record<string, string>;
+export interface ThemeContribution {
+    id: LocalContributionId;
+    name: string;
+    description?: string;
+    order?: number;
+    colorScheme: ThemeColorScheme;
+    tokens: ThemeTokens;
+}
+export interface ThemePairContribution {
+    id: LocalContributionId;
+    name: string;
+    description?: string;
+    order?: number;
+    light: LocalContributionId;
+    dark: LocalContributionId;
+}

package/dist/server/app.js

@@ -9,29 +9,23 @@ import { ProjectService } from "./projects/projectService.js";
 import { WorkspaceService } from "./workspaces/workspaceService.js";
 import { listFileSuggestions, listPathSuggestions } from "./workspaces/fileSuggestions.js";
 import { listDirectorySuggestions } from "./projects/directorySuggestions.js";
+import { SessionDaemonClient } from "../sessiond/sessionDaemonClient.js";
 import { registerSessionProxyRoutes } from "./sessiond/sessionProxyRoutes.js";
 import { registerWorkspaceExplorerRoutes } from "./workspaceExplorerRoutes.js";
 import { registerGitRoutes } from "./gitRoutes.js";
 import { registerTerminalProxyRoutes } from "./terminalProxyRoutes.js";
+import { registerWorkspaceDeletionRoutes } from "./workspaces/workspaceDeletionRoutes.js";
+import { registerConfigRoutes } from "./configRoutes.js";
 import { PiWebPluginService } from "./piWebPluginService.js";
-import { getPiWebStatus, getPiWebVersionStatus } from "./piWebStatus.js";
-export async function buildApp(deps = {}) {
-    const app = Fastify({ logger: deps.logger ?? true });
-    await app.register(fastifyWebsocket);
-    const projects = deps.projects ?? new ProjectService(new ProjectStore());
-    const workspaces = deps.workspaces ?? new WorkspaceService();
-    const piWebPlugins = deps.piWebPlugins ?? new PiWebPluginService();
-    app.get("/pi-web-plugins/manifest.json", async () => piWebPlugins.manifest());
-    app.get("/pi-web-plugins/:pluginId/*", async (request, reply) => {
-        const asset = await piWebPlugins.readAsset(request.params.pluginId, request.params["*"]);
-        if (asset === undefined)
-            return reply.code(404).send({ error: "Plugin asset not found" });
-        return reply.type(asset.contentType).send(asset.content);
-    });
-    app.get("/api/pi-web/status", async () => getPiWebStatus());
-    app.get("/api/pi-web/version", async () => getPiWebVersionStatus());
-    app.get("/api/projects", async () => projects.list());
-    app.post("/api/projects", async (request, reply) => {
+import { createPiWebStatusCache } from "./piWebStatusCache.js";
+import { getPiWebRuntime, getPiWebStatus, getPiWebVersionStatus } from "./piWebStatus.js";
+import { MachineService } from "./machines/machineService.js";
+import { registerMachineRoutes } from "./machines/machineRoutes.js";
+import { registerMachineProxyRoutes } from "./machines/machineProxyRoutes.js";
+import { proxyMachinePluginAsset, registerMachinePluginProxyRoutes } from "./machines/machinePluginProxyRoutes.js";
+function registerLocalProjectRoutes(app, projects, workspaces, prefix) {
+    app.get(`${prefix}/projects`, async () => projects.list());
+    app.post(`${prefix}/projects`, async (request, reply) => {
         try {
             return await projects.add(request.body);
         }
@@ -39,7 +33,7 @@ export async function buildApp(deps = {}) {
             return reply.code(400).send({ error: error instanceof Error ? error.message : String(error) });
         }
     });
-    app.delete("/api/projects/:projectId", async (request, reply) => {
+    app.delete(`${prefix}/projects/:projectId`, async (request, reply) => {
         try {
             await projects.close(request.params.projectId);
             return { closed: true };
@@ -48,7 +42,7 @@ export async function buildApp(deps = {}) {
             return reply.code(404).send({ error: error instanceof Error ? error.message : String(error) });
         }
     });
-    app.get("/api/project-directories", async (request, reply) => {
+    app.get(`${prefix}/project-directories`, async (request, reply) => {
         try {
             return await listDirectorySuggestions(request.query.q ?? "");
         }
@@ -56,7 +50,7 @@ export async function buildApp(deps = {}) {
             return reply.code(400).send({ error: error instanceof Error ? error.message : String(error) });
         }
     });
-    app.get("/api/projects/:projectId/workspaces", async (request, reply) => {
+    app.get(`${prefix}/projects/:projectId/workspaces`, async (request, reply) => {
         try {
             const project = await projects.requireProject(request.params.projectId);
             return await workspaces.list(project);
@@ -65,11 +59,9 @@ export async function buildApp(deps = {}) {
             return reply.code(404).send({ error: error instanceof Error ? error.message : String(error) });
         }
     });
-    registerSessionProxyRoutes(app);
-    registerWorkspaceExplorerRoutes(app, projects, workspaces);
-    registerGitRoutes(app, projects, workspaces);
-    registerTerminalProxyRoutes(app, projects, workspaces);
-    app.get("/api/files", async (request, reply) => {
+}
+function registerLocalFileSuggestionRoutes(app, prefix) {
+    app.get(`${prefix}/files`, async (request, reply) => {
         if (request.query.cwd === undefined || request.query.cwd === "")
             return reply.code(400).send({ error: "cwd query parameter is required" });
         try {
@@ -81,6 +73,51 @@ export async function buildApp(deps = {}) {
             return reply.code(400).send({ error: error instanceof Error ? error.message : String(error) });
         }
     });
+}
+export async function buildApp(deps = {}) {
+    const app = Fastify({ logger: deps.logger ?? true });
+    await app.register(fastifyWebsocket);
+    const projects = deps.projects ?? new ProjectService(new ProjectStore());
+    const workspaces = deps.workspaces ?? new WorkspaceService();
+    const piWebPlugins = deps.piWebPlugins ?? new PiWebPluginService();
+    const sessionDaemon = deps.sessionDaemon ?? new SessionDaemonClient();
+    const piWebStatusCache = createPiWebStatusCache(() => getPiWebStatus(sessionDaemon), {
+        onError: (error) => { app.log.warn({ err: error }, "failed to refresh PI WEB status cache"); },
+    });
+    const machines = deps.machines ?? new MachineService(undefined, {
+        localRuntime: () => getPiWebRuntime(sessionDaemon),
+    });
+    app.get("/pi-web-plugins/manifest.json", async () => piWebPlugins.manifest());
+    app.get("/pi-web-plugins/:pluginId/*", async (request, reply) => {
+        if (await proxyMachinePluginAsset(machines, request.params.pluginId, request.params["*"], request.url, reply))
+            return;
+        const asset = await piWebPlugins.readAsset(request.params.pluginId, request.params["*"]);
+        if (asset === undefined)
+            return reply.code(404).send({ error: "Plugin asset not found" });
+        return reply.type(asset.contentType).send(asset.content);
+    });
+    app.get("/api/pi-web/status", async () => piWebStatusCache.get());
+    app.get("/api/pi-web/version", async () => getPiWebVersionStatus(sessionDaemon));
+    app.get("/api/pi-web/runtime", async () => getPiWebRuntime(sessionDaemon));
+    app.get("/api/plugins", async () => piWebPlugins.plugins());
+    registerConfigRoutes(app, deps.config);
+    registerMachineRoutes(app, machines);
+    registerMachinePluginProxyRoutes(app, machines);
+    registerLocalProjectRoutes(app, projects, workspaces, "/api");
+    registerLocalProjectRoutes(app, projects, workspaces, "/api/machines/local");
+    registerSessionProxyRoutes(app, sessionDaemon);
+    registerSessionProxyRoutes(app, sessionDaemon, "/api/machines/local");
+    registerWorkspaceExplorerRoutes(app, projects, workspaces);
+    registerWorkspaceExplorerRoutes(app, projects, workspaces, "/api/machines/local");
+    registerGitRoutes(app, projects, workspaces);
+    registerGitRoutes(app, projects, workspaces, "/api/machines/local");
+    registerTerminalProxyRoutes(app, projects, workspaces, sessionDaemon);
+    registerTerminalProxyRoutes(app, projects, workspaces, sessionDaemon, "/api/machines/local");
+    registerWorkspaceDeletionRoutes(app, projects, workspaces, sessionDaemon);
+    registerWorkspaceDeletionRoutes(app, projects, workspaces, sessionDaemon, "/api/machines/local");
+    registerLocalFileSuggestionRoutes(app, "/api");
+    registerLocalFileSuggestionRoutes(app, "/api/machines/local");
+    registerMachineProxyRoutes(app, machines);
     const packagedClientDist = join(dirname(fileURLToPath(import.meta.url)), "..", "client");
     const clientDist = deps.clientDist ?? (existsSync(packagedClientDist) ? packagedClientDist : join(process.cwd(), "dist", "client"));
     if (clientDist !== false && existsSync(clientDist)) {