@alisio/server 0.1.0-alpha.8 → 0.1.1

package/dist/host/workspace-host.js

@@ -1,5 +1,5 @@
 import { stat } from "node:fs/promises";
-import { createApplication, findWorkspace, resolveTrust, workspaceKey, } from "@alisio/core";
+import { createApplication, findWorkspace, ReloadFailedError, ReloadRefusedError, reloadApplication, resolveTrust, validateReloadConfig, workspaceKey, } from "@alisio/core";
 import { HttpError } from "../http/errors.js";
 const MISSING_ERRNO = new Set(["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"]);
 const missing = (path) => new HttpError("workspace_missing", `Workspace folder not found: ${path}`, { path });
@@ -76,22 +76,25 @@ export class WorkspaceHost {
         this.opening.set(id, promise);
         return promise;
     }
-    async create(id, path) {
+    /**
+     * Builds the `Application` of a workspace: launch flags are explicit, one-run trust like in the
+     * terminal; otherwise the trust store decides and a workspace that would need a prompt opens
+     * untrusted.
+     */
+    async build(id, path) {
         const base = this.options.base;
-        // Launch flags are explicit, one-run trust like in the terminal; otherwise the trust store
-        // decides and a workspace that would need a prompt opens untrusted.
         const explicit = !!base.trustProject || !!base.config;
         const trust = explicit ? undefined : await resolveTrust(path);
         const trusted = explicit || !!trust?.trusted;
-        let app;
         try {
-            app = await (this.options.create ?? createApplication)({
+            const app = await (this.options.create ?? createApplication)({
                 ...base,
                 trustProject: explicit ? base.trustProject : trusted,
                 cwd: path,
                 approvalSource: "web",
                 ...(this.options.wire?.(id, path) ?? {}),
             });
+            return { app, trusted, untrustedResources: !trusted && !!trust?.hasProjectResources };
         }
         catch (error) {
             // The folder vanished between the check and the open (the core canonicalizes it).
@@ -100,12 +103,15 @@ export class WorkspaceHost {
                 throw missing(path);
             throw error;
         }
+    }
+    async create(id, path) {
+        const { app, trusted, untrustedResources } = await this.build(id, path);
         const entry = {
             id,
             path,
             app,
             trusted,
-            untrustedResources: !trusted && !!trust?.hasProjectResources,
+            untrustedResources,
             lastUsed: this.now(),
         };
         if (this.closed) {
@@ -163,6 +169,56 @@ export class WorkspaceHost {
         await this.close(id);
         return this.openPath(entry.path);
     }
+    /**
+     * `/reload` for one open workspace: validate, build the new app NEXT TO the current one and
+     * only then swap, so a broken configuration leaves the workspace and its sessions untouched
+     * (unlike `recycle`, which closes first). The caller refuses while runs are active (`busy`).
+     * SSE subscribers are unaffected: they read the shared store.
+     */
+    async reload(id, guard = {}) {
+        const entry = this.open.get(id);
+        if (!entry)
+            throw new HttpError("not_found", "Workspace is not open");
+        const base = this.options.base;
+        let built;
+        try {
+            return await reloadApplication({
+                current: entry.app,
+                ...(guard.busy ? { busy: guard.busy } : {}),
+                validate: async () => {
+                    const explicit = !!base.trustProject || !!base.config;
+                    const trust = explicit ? undefined : await resolveTrust(entry.path);
+                    await validateReloadConfig({
+                        ...base,
+                        cwd: entry.path,
+                        trustProject: explicit ? base.trustProject : !!trust?.trusted,
+                    });
+                },
+                create: async () => {
+                    const next = await this.build(id, entry.path);
+                    built = next;
+                    return next.app;
+                },
+                swap: (next) => {
+                    if (this.closed || this.open.get(id) !== entry)
+                        throw new Error("The workspace was closed while reloading");
+                    this.options.onClose?.(entry);
+                    entry.app = next;
+                    entry.trusted = built?.trusted ?? entry.trusted;
+                    entry.untrustedResources = built?.untrustedResources ?? entry.untrustedResources;
+                    entry.lastUsed = this.now();
+                    this.options.onOpen?.(entry);
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof ReloadRefusedError)
+                throw new HttpError("runs_active", error.message);
+            if (error instanceof ReloadFailedError)
+                throw new HttpError("validation_failed", `Reload failed; the current session is unchanged: ${error.message}`, { stage: error.stage });
+            throw error;
+        }
+    }
     /** Closes every app in parallel (each close is capped by the core's teardown timeouts). */
     async closeAll() {
         this.closed = true;

package/dist/http/errors.js

@@ -34,6 +34,13 @@ export const STATUS = {
     dataset_unsupported: 415,
     query_rejected: 400,
     query_timeout: 408,
+    view_failed: 502,
+    view_timeout: 504,
+    view_too_large: 502,
+    task_not_found: 404,
+    goal_not_found: 404,
+    goal_conflict: 409,
+    goal_disabled: 409,
     internal: 500,
 };
 /** A typed API failure; routes throw it and the server renders it as an `ApiError` body. */

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { type ServerResponse } from "node:http";
+import { type AppOptions } from "@alisio/core";
 import { type FolderPicker } from "./host/folder-picker.ts";
 import { type ServerAppOptions } from "./host/workspace-host.ts";
 import { type Logger } from "./log.ts";
@@ -53,6 +54,13 @@ export interface ServerOptions {
      * tests. Always off when the server is bound for remote access.
      */
     folderPicker?: FolderPicker;
+    /** Limits of plugin data views (`GET /api/sessions/:sid/views/…`): 5 s and 1 MiB by default. */
+    views?: {
+        timeoutMs?: number;
+        maxBytes?: number;
+    };
+    /** Background-task runtime knobs (notification timing, kill grace, limits): tests tune them. */
+    tasks?: Pick<NonNullable<AppOptions["tasks"]>, "timing" | "sweepDelayMs" | "killGraceMs" | "maxPerProcess">;
 }
 export interface RunningServer {
     host: string;

package/dist/index.js

@@ -5,13 +5,15 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { dirname, join } from "node:path";
-import { AnalysisJobs, ArtifactStore, BlobStore, CapabilityGrants, SQLiteStore, stateHome, } from "@alisio/core";
+import { AnalysisJobs, ArtifactStore, BackgroundTaskStore, BlobStore, CapabilityGrants, GoalStore, SQLiteStore, stateHome, } from "@alisio/core";
 import { AuthGuard, isLoopbackHost } from "./auth/guard.js";
 import { newSecret } from "./auth/token.js";
 import { redactViewPath } from "./auth/view-token.js";
 import { ApprovalBridge } from "./bridges/approval-bridge.js";
 import { InteractionBridge } from "./bridges/interaction-bridge.js";
 import { createNativePicker } from "./host/folder-picker.js";
+import { GoalDriver } from "./host/goal.js";
+import { followUpPlanRun } from "./host/plan.js";
 import { RunScheduler } from "./host/run-scheduler.js";
 import { SessionService } from "./host/sessions.js";
 import { WorkspaceHost, workspaceId } from "./host/workspace-host.js";
@@ -25,18 +27,22 @@ import { registerArtifactViewRoutes, VIEW_PREFIX, viewerBaseHeaders, } from "./r
 import { registerArtifactRoutes } from "./routes/artifacts.js";
 import { registerBlobRoutes } from "./routes/blobs.js";
 import { registerCapabilityRoutes } from "./routes/capabilities.js";
+import { registerChangelogRoutes } from "./routes/changelog.js";
 import { registerCommandRoutes } from "./routes/commands.js";
 import { registerDatasetRoutes } from "./routes/datasets.js";
 import { registerEventRoutes } from "./routes/events.js";
 import { registerFileRoutes } from "./routes/files.js";
 import { registerFolderRoutes } from "./routes/folders.js";
+import { registerGoalRoutes } from "./routes/goal.js";
 import { registerHealthRoutes } from "./routes/health.js";
 import { registerManagementRoutes, WorkspaceRecycler } from "./routes/management.js";
+import { registerPluginViewRoutes } from "./routes/plugin-views.js";
 import { registerPromptRoutes } from "./routes/prompts.js";
 import { registerProviderRoutes } from "./routes/providers.js";
 import { registerSessionViewRoutes } from "./routes/session-views.js";
 import { registerSessionRoutes } from "./routes/sessions.js";
 import { registerSideQuestionRoutes } from "./routes/side-questions.js";
+import { registerTaskRoutes } from "./routes/tasks.js";
 import { registerWorkspaceRoutes } from "./routes/workspaces.js";
 import { SseHub } from "./sse/hub.js";
 import { InflightTracker } from "./sse/inflight.js";
@@ -93,21 +99,60 @@ export async function startServer(options = {}) {
     // process become interrupted before any client lists them.
     catalog.interruptRuns();
     catalog.interruptStale();
+    // Background tasks of a dead server or TUI process become `lost` (a live process's are kept).
+    new BackgroundTaskStore(catalog.db).markLost(Date.now());
+    // A goal left `active` by a process that is gone pauses (reason `restart`); it never resumes by
+    // itself, the user decides.
+    new GoalStore(catalog.db).pauseOrphans(Date.now());
     let shutdown;
     let sessions;
     const inflight = new InflightTracker();
     let recycler;
+    let goalDriver;
     const scheduler = new RunScheduler({
         ...(options.maxConcurrentRuns ? { maxConcurrent: options.maxConcurrentRuns } : {}),
-        onChange: (job, status) => {
+        onChange: (job, status, outcome) => {
             if (status === "finished") {
                 inflight.clear(job.sessionId, job.runId);
                 // A deferred plugin change applies once the workspace has no runs left.
                 setImmediate(() => recycler?.idle(job.workspaceId));
+                // A finished-task notification held back because this session was busy may go now.
+                setImmediate(() => job.app.tasks.sessionIdle(job.sessionId));
+                // An approved plan starts its implementation run once the plan run is over.
+                if (sessions && !job.tool)
+                    try {
+                        followUpPlanRun({
+                            job,
+                            cancelled: !!outcome?.cancelled,
+                            catalog,
+                            sessions,
+                            scheduler,
+                        });
+                    }
+                    catch (error) {
+                        logger.error("plan_follow_up_failed", {
+                            sessionId: job.sessionId,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                // The run is folded into the session's goal (tokens, turns, breakers), and the goal may
+                // continue: the pump runs after this tick so the plan follow-up above (if any) goes first.
+                if (outcome && !job.tool)
+                    try {
+                        goalDriver?.settle(job, outcome);
+                    }
+                    catch (error) {
+                        logger.error("goal_settle_failed", {
+                            sessionId: job.sessionId,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                setImmediate(() => goalDriver?.pump(job.sessionId));
             }
             else
                 inflight.mark(job.sessionId, job.runId, status);
             sessions?.notify(job.sessionId);
+            goalDriver?.refresh(job.sessionId);
         },
     });
     const workspaceOf = (sessionId) => {
@@ -140,6 +185,7 @@ export async function startServer(options = {}) {
                     approvals: approvals?.pending(sessionId) ?? [],
                     interactions: interactions?.pending(sessionId) ?? [],
                 },
+                ...(goalDriver?.info(sessionId) ? { goal: goalDriver.info(sessionId) } : {}),
             };
         },
         messagesAfter: (sessionId, after) => catalog.messagesPage(sessionId, { after, limit: 200 }),
@@ -148,10 +194,62 @@ export async function startServer(options = {}) {
         ...(options.heartbeatMs ? { heartbeatMs: options.heartbeatMs } : {}),
         ...(options.coalesceMs ? { coalesceMs: options.coalesceMs } : {}),
     });
+    /** Whether a workspace's application has live background tasks (it must not be closed). */
+    const tasksLive = (id) => (workspaces.get(id)?.app.tasks.liveCount() ?? 0) > 0;
+    /**
+     * The finished-task notification: a normal run of the owner session whose request id is the
+     * batch id (like the plan approval's `plan-<id>`), so the same batch can never start two runs.
+     * `runner.enqueue` would only park the text until the next run, so the wake-up goes through the
+     * scheduler. Busy sessions (a run, an approval or question, another process holding the
+     * session) answer `busy` and the core retries; archived or missing ones answer `skip`.
+     */
+    const wakeOwner = (workspaceKey, request) => {
+        if (closing || !sessions)
+            return "skip";
+        let session;
+        try {
+            session = catalog.get(request.sessionId);
+        }
+        catch {
+            return "skip";
+        }
+        const opened = workspaces.get(workspaceKey);
+        if (session.parentId || session.archivedAt || !opened)
+            return "skip";
+        if (catalog.lockedBy(session.id) ||
+            scheduler.busy(session.id) ||
+            opened.app.runner.isRunning(session.id) ||
+            approvals?.awaiting(session.id) ||
+            interactions?.awaiting(session.id))
+            return "busy";
+        const correlationId = randomUUID();
+        const { run, created } = sessions.beginRun({
+            id: randomUUID(),
+            session: session.id,
+            status: "queued",
+            requestId: request.requestId,
+            correlationId,
+            model: session.model,
+        });
+        if (!created)
+            return "started";
+        const service = sessions;
+        scheduler.submit({
+            runId: run.id,
+            sessionId: session.id,
+            workspaceId: opened.id,
+            app: opened.app,
+            text: request.text,
+            display: request.display,
+            correlationId,
+            options: () => service.runOptions(session.id),
+        });
+        return "started";
+    };
     const workspaces = new WorkspaceHost({
         base,
         catalog,
-        wire: () => ({
+        wire: (id) => ({
             onEvent: (event) => {
                 inflight.apply(event);
                 hub.publish(event);
@@ -165,12 +263,31 @@ export async function startServer(options = {}) {
             ...(approvals
                 ? { approve: approvals.handler, approveExternalDirectory: approvals.directoryHandler }
                 : {}),
+            tasks: {
+                ...(options.tasks ?? {}),
+                onChange: (task, root) => {
+                    hub.toSession(root, { t: "tasks_changed", sessionId: root, task });
+                    // A goal waiting for background tasks continues once the last one is over.
+                    if (task.status !== "running" && task.status !== "queued" && task.status !== "stopping")
+                        setImmediate(() => goalDriver?.pump(root));
+                    else
+                        goalDriver?.refresh(root);
+                    // A deferred recycle (a plugin change) goes ahead once the last task is over.
+                    if (task.status !== "running" && task.status !== "queued" && task.status !== "stopping") {
+                        const owner = workspaceOf(root);
+                        if (owner)
+                            setImmediate(() => recycler?.idle(owner));
+                    }
+                },
+                wake: (request) => wakeOwner(id, request),
+            },
+            goals: { onChange: (sessionId) => goalDriver?.refresh(sessionId) },
         }),
         onOpen: (entry) => {
             if (interactions)
                 entry.app.plugins.setInteractiveUI(interactions.uiFor(entry.id));
         },
-        busy: (id) => scheduler.busyWorkspace(id) || hub.watchesWorkspace(id),
+        busy: (id) => scheduler.busyWorkspace(id) || hub.watchesWorkspace(id) || tasksLive(id),
         ...(options.maxOpenWorkspaces ? { maxOpen: options.maxOpenWorkspaces } : {}),
         ...(options.idleEvictMs ? { idleEvictMs: options.idleEvictMs } : {}),
         ...(options.defaultWorkspace ? { defaultWorkspace: options.defaultWorkspace } : {}),
@@ -192,7 +309,10 @@ export async function startServer(options = {}) {
         runOf: (id) => scheduler.job(id)?.runId,
         ...(options.approvalGraceMs !== undefined ? { graceMs: options.approvalGraceMs } : {}),
         ...(options.approvalTimeoutMs !== undefined ? { timeoutMs: options.approvalTimeoutMs } : {}),
-        onChange: (root) => service.notify(root),
+        onChange: (root) => {
+            service.notify(root);
+            goalDriver?.refresh(root);
+        },
     });
     interactions = new InteractionBridge({
         hub,
@@ -200,8 +320,37 @@ export async function startServer(options = {}) {
         workspaceOf,
         ...(options.approvalGraceMs !== undefined ? { graceMs: options.approvalGraceMs } : {}),
         ...(options.approvalTimeoutMs !== undefined ? { timeoutMs: options.approvalTimeoutMs } : {}),
-        onOpen: (id) => service.notify(id),
-        onChange: (root) => root && service.notify(root),
+        onOpen: (id) => {
+            service.notify(id);
+            goalDriver?.refresh(id);
+        },
+        onChange: (root) => {
+            if (!root)
+                return;
+            service.notify(root);
+            goalDriver?.refresh(root);
+        },
+    });
+    goalDriver = new GoalDriver({
+        catalog,
+        sessions: () => service,
+        scheduler: () => scheduler,
+        workspaces: () => workspaces,
+        awaiting: (root) => approvals?.awaiting(root)
+            ? "approval"
+            : interactions?.awaiting(root)
+                ? "question"
+                : undefined,
+        toSession: (sessionId, frame) => hub.toSession(sessionId, frame),
+        closing: () => closing,
+        log: (event, data) => logger.error(event, data),
+    });
+    // A session option (the agent, say) changed: the plan-mode wait of a goal may be over.
+    service.bind({
+        onOptions: (sessionId) => {
+            goalDriver?.refresh(sessionId);
+            setImmediate(() => goalDriver?.pump(sessionId));
+        },
     });
     const stats = () => ({
         shuttingDown: closing,
@@ -228,6 +377,13 @@ export async function startServer(options = {}) {
     registerWorkspaceRoutes(router, { workspaces, catalog, scheduler });
     registerSessionRoutes(router, { catalog, workspaces, sessions, scheduler });
     registerSessionViewRoutes(router, { catalog, sessions });
+    registerPluginViewRoutes(router, {
+        sessions,
+        workspaces,
+        logger,
+        ...(options.views?.timeoutMs !== undefined ? { timeoutMs: options.views.timeoutMs } : {}),
+        ...(options.views?.maxBytes !== undefined ? { maxBytes: options.views.maxBytes } : {}),
+    });
     registerFileRoutes(router, { workspaces, catalog, sessions });
     registerBlobRoutes(router, { blobs });
     registerArtifactRoutes(router, {
@@ -251,16 +407,28 @@ export async function startServer(options = {}) {
         toSession: (sessionId, frame) => hub.toSession(sessionId, frame),
     });
     registerPromptRoutes(router, { sessions, scheduler });
-    registerCommandRoutes(router, { sessions, scheduler, workspaces });
-    registerSideQuestionRoutes(router, { sessions });
-    registerApprovalRoutes(router, { approvals, interactions });
+    registerGoalRoutes(router, { sessions, goals: goalDriver });
     const management = {
         workspaces,
         scheduler,
+        tasksLive,
         base,
         broadcast: (frame) => hub.broadcast(frame),
     };
     recycler = new WorkspaceRecycler(management);
+    const reloader = recycler;
+    registerChangelogRoutes(router, { version: options.version ?? "dev" });
+    registerCommandRoutes(router, {
+        sessions,
+        scheduler,
+        workspaces,
+        reload: (workspaceId) => reloader.reload(workspaceId),
+        ...(goalDriver ? { goals: goalDriver } : {}),
+        version: options.version ?? "dev",
+    });
+    registerSideQuestionRoutes(router, { sessions });
+    registerTaskRoutes(router, { sessions });
+    registerApprovalRoutes(router, { approvals, interactions });
     registerManagementRoutes(router, management, recycler);
     registerAgentDefinitionRoutes(router, management, recycler);
     registerProviderRoutes(router, management, recycler);

package/dist/routes/changelog.d.ts

@@ -0,0 +1,9 @@
+import type { Router } from "../http/router.ts";
+/**
+ * `GET /api/changelog?version=&lastSeen=`: the shipped `CHANGELOG.md` entries (offline, parsed at
+ * build time), the newest five or the one `version` names, plus `news` when `lastSeen` is older
+ * than the running version. Same auth, Host and Origin rules as every other `/api` route.
+ */
+export declare function registerChangelogRoutes(router: Router, options: {
+    version: string;
+}): void;

package/dist/routes/changelog.js

@@ -0,0 +1,32 @@
+import { changelogNews, loadChangelog, selectEntries } from "@alisio/core";
+import { HttpError } from "../http/errors.js";
+const MAX_QUERY = 100;
+/**
+ * `GET /api/changelog?version=&lastSeen=`: the shipped `CHANGELOG.md` entries (offline, parsed at
+ * build time), the newest five or the one `version` names, plus `news` when `lastSeen` is older
+ * than the running version. Same auth, Host and Origin rules as every other `/api` route.
+ */
+export function registerChangelogRoutes(router, options) {
+    router.get("/api/changelog", ({ url }) => {
+        const text = (name) => {
+            const value = url.searchParams.get(name)?.trim();
+            if (value && value.length > MAX_QUERY)
+                throw new HttpError("validation_failed", "Invalid query parameter", { fields: [name] });
+            return value || undefined;
+        };
+        const version = text("version");
+        const lastSeen = text("lastSeen");
+        const entries = loadChangelog();
+        const selected = selectEntries(entries, { ...(version ? { version } : {}), limit: 5 });
+        const news = changelogNews({ entries, current: options.version, lastSeen });
+        const body = {
+            current: options.version,
+            entries: selected.entries,
+            found: selected.found,
+            ...(news.show && news.latest
+                ? { news: { latest: news.latest, versions: news.versions } }
+                : {}),
+        };
+        return { body };
+    });
+}

package/dist/routes/commands.d.ts

@@ -1,3 +1,5 @@
+import type { ReloadReport } from "@alisio/sdk";
+import type { GoalDriver } from "../host/goal.ts";
 import type { RunScheduler } from "../host/run-scheduler.ts";
 import type { SessionService } from "../host/sessions.ts";
 import type { WorkspaceHost } from "../host/workspace-host.ts";
@@ -18,4 +20,10 @@ export declare function registerCommandRoutes(router: Router, ctx: {
     scheduler: RunScheduler;
     workspaces: WorkspaceHost;
     recent?: RecentRequests;
+    /** `/reload` of a workspace (validate, build next to the current app, swap, announce). */
+    reload?: (workspaceId: string) => Promise<ReloadReport>;
+    /** The running Alisio version (the CLI's), for `/changelog`. */
+    version?: string;
+    /** `/goal`: the driver that makes a goal continue and reports what it waits for. */
+    goals?: Pick<GoalDriver, "info" | "pump" | "refresh">;
 }): void;