@neuralnomads/codenomad 0.1.0

package/dist/server/http-server.js

@@ -0,0 +1,224 @@
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import replyFrom from "@fastify/reply-from";
+import fs from "fs";
+import path from "path";
+import { fetch } from "undici";
+import { registerWorkspaceRoutes } from "./routes/workspaces";
+import { registerConfigRoutes } from "./routes/config";
+import { registerFilesystemRoutes } from "./routes/filesystem";
+import { registerMetaRoutes } from "./routes/meta";
+import { registerEventRoutes } from "./routes/events";
+import { registerStorageRoutes } from "./routes/storage";
+export function createHttpServer(deps) {
+    const app = Fastify({ logger: false });
+    const proxyLogger = deps.logger.child({ component: "proxy" });
+    const sseClients = new Set();
+    const registerSseClient = (cleanup) => {
+        sseClients.add(cleanup);
+        return () => sseClients.delete(cleanup);
+    };
+    const closeSseClients = () => {
+        for (const cleanup of Array.from(sseClients)) {
+            cleanup();
+        }
+        sseClients.clear();
+    };
+    app.register(cors, {
+        origin: true,
+        credentials: true,
+    });
+    app.register(replyFrom, {
+        contentTypesToEncode: [],
+    });
+    registerWorkspaceRoutes(app, { workspaceManager: deps.workspaceManager });
+    registerConfigRoutes(app, { configStore: deps.configStore, binaryRegistry: deps.binaryRegistry });
+    registerFilesystemRoutes(app, { fileSystemBrowser: deps.fileSystemBrowser });
+    registerMetaRoutes(app, { serverMeta: deps.serverMeta });
+    registerEventRoutes(app, { eventBus: deps.eventBus, registerClient: registerSseClient });
+    registerStorageRoutes(app, {
+        instanceStore: deps.instanceStore,
+        eventBus: deps.eventBus,
+        workspaceManager: deps.workspaceManager,
+    });
+    registerInstanceProxyRoutes(app, { workspaceManager: deps.workspaceManager, logger: proxyLogger });
+    if (deps.uiDevServerUrl) {
+        setupDevProxy(app, deps.uiDevServerUrl);
+    }
+    else {
+        setupStaticUi(app, deps.uiStaticDir);
+    }
+    return {
+        instance: app,
+        start: async () => {
+            const addressInfo = await app.listen({ port: deps.port, host: deps.host });
+            let actualPort = deps.port;
+            if (typeof addressInfo === "string") {
+                try {
+                    const parsed = new URL(addressInfo);
+                    actualPort = Number(parsed.port) || deps.port;
+                }
+                catch {
+                    actualPort = deps.port;
+                }
+            }
+            else {
+                const address = app.server.address();
+                if (typeof address === "object" && address) {
+                    actualPort = address.port;
+                }
+            }
+            const displayHost = deps.host === "0.0.0.0" ? "127.0.0.1" : deps.host === "127.0.0.1" ? "localhost" : deps.host;
+            const serverUrl = `http://${displayHost}:${actualPort}`;
+            deps.serverMeta.httpBaseUrl = serverUrl;
+            deps.logger.info({ port: actualPort, host: deps.host }, "HTTP server listening");
+            console.log(`CodeNomad Server is ready at ${serverUrl}`);
+            return { port: actualPort, url: serverUrl, displayHost };
+        },
+        stop: () => {
+            closeSseClients();
+            return app.close();
+        },
+    };
+}
+function registerInstanceProxyRoutes(app, deps) {
+    app.register(async (instance) => {
+        instance.removeAllContentTypeParsers();
+        instance.addContentTypeParser("*", (req, body, done) => done(null, body));
+        const proxyBaseHandler = async (request, reply) => {
+            await proxyWorkspaceRequest({
+                request,
+                reply,
+                workspaceManager: deps.workspaceManager,
+                pathSuffix: "",
+                logger: deps.logger,
+            });
+        };
+        const proxyWildcardHandler = async (request, reply) => {
+            await proxyWorkspaceRequest({
+                request,
+                reply,
+                workspaceManager: deps.workspaceManager,
+                pathSuffix: request.params["*"] ?? "",
+                logger: deps.logger,
+            });
+        };
+        instance.all("/workspaces/:id/instance", proxyBaseHandler);
+        instance.all("/workspaces/:id/instance/*", proxyWildcardHandler);
+    });
+}
+const INSTANCE_PROXY_HOST = "127.0.0.1";
+async function proxyWorkspaceRequest(args) {
+    const { request, reply, workspaceManager, logger } = args;
+    const workspaceId = request.params.id;
+    const workspace = workspaceManager.get(workspaceId);
+    if (!workspace) {
+        reply.code(404).send({ error: "Workspace not found" });
+        return;
+    }
+    const port = workspaceManager.getInstancePort(workspaceId);
+    if (!port) {
+        reply.code(502).send({ error: "Workspace instance is not ready" });
+        return;
+    }
+    const normalizedSuffix = normalizeInstanceSuffix(args.pathSuffix);
+    const queryIndex = (request.raw.url ?? "").indexOf("?");
+    const search = queryIndex >= 0 ? (request.raw.url ?? "").slice(queryIndex) : "";
+    const targetUrl = `http://${INSTANCE_PROXY_HOST}:${port}${normalizedSuffix}${search}`;
+    return reply.from(targetUrl, {
+        onError: (proxyReply, { error }) => {
+            logger.error({ err: error, workspaceId, targetUrl }, "Failed to proxy workspace request");
+            if (!proxyReply.sent) {
+                proxyReply.code(502).send({ error: "Workspace instance proxy failed" });
+            }
+        },
+    });
+}
+function normalizeInstanceSuffix(pathSuffix) {
+    if (!pathSuffix || pathSuffix === "/") {
+        return "/";
+    }
+    const trimmed = pathSuffix.replace(/^\/+/, "");
+    return trimmed.length === 0 ? "/" : `/${trimmed}`;
+}
+function setupStaticUi(app, uiDir) {
+    if (!uiDir) {
+        app.log.warn("UI static directory not provided; API endpoints only");
+        return;
+    }
+    if (!fs.existsSync(uiDir)) {
+        app.log.warn({ uiDir }, "UI static directory missing; API endpoints only");
+        return;
+    }
+    app.register(fastifyStatic, {
+        root: uiDir,
+        prefix: "/",
+        decorateReply: false,
+    });
+    const indexPath = path.join(uiDir, "index.html");
+    app.setNotFoundHandler((request, reply) => {
+        const url = request.raw.url ?? "";
+        if (isApiRequest(url)) {
+            reply.code(404).send({ message: "Not Found" });
+            return;
+        }
+        if (fs.existsSync(indexPath)) {
+            reply.type("text/html").send(fs.readFileSync(indexPath, "utf-8"));
+        }
+        else {
+            reply.code(404).send({ message: "UI bundle missing" });
+        }
+    });
+}
+function setupDevProxy(app, upstreamBase) {
+    app.log.info({ upstreamBase }, "Proxying UI requests to development server");
+    app.setNotFoundHandler((request, reply) => {
+        const url = request.raw.url ?? "";
+        if (isApiRequest(url)) {
+            reply.code(404).send({ message: "Not Found" });
+            return;
+        }
+        void proxyToDevServer(request, reply, upstreamBase);
+    });
+}
+async function proxyToDevServer(request, reply, upstreamBase) {
+    try {
+        const targetUrl = new URL(request.raw.url ?? "/", upstreamBase);
+        const response = await fetch(targetUrl, {
+            method: request.method,
+            headers: buildProxyHeaders(request.headers),
+        });
+        response.headers.forEach((value, key) => {
+            reply.header(key, value);
+        });
+        reply.code(response.status);
+        if (!response.body || request.method === "HEAD") {
+            reply.send();
+            return;
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        reply.send(buffer);
+    }
+    catch (error) {
+        request.log.error({ err: error }, "Failed to proxy UI request to dev server");
+        if (!reply.sent) {
+            reply.code(502).send("UI dev server is unavailable");
+        }
+    }
+}
+function isApiRequest(rawUrl) {
+    if (!rawUrl)
+        return false;
+    const pathname = rawUrl.split("?")[0] ?? "";
+    return pathname === "/api" || pathname.startsWith("/api/");
+}
+function buildProxyHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        if (!value || key.toLowerCase() === "host")
+            continue;
+        result[key] = Array.isArray(value) ? value.join(",") : value;
+    }
+    return result;
+}

package/dist/server/routes/config.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { ConfigFileSchema } from "../../config/schema";
+const BinaryCreateSchema = z.object({
+    path: z.string(),
+    label: z.string().optional(),
+    makeDefault: z.boolean().optional(),
+});
+const BinaryUpdateSchema = z.object({
+    label: z.string().optional(),
+    makeDefault: z.boolean().optional(),
+});
+const BinaryValidateSchema = z.object({
+    path: z.string(),
+});
+export function registerConfigRoutes(app, deps) {
+    app.get("/api/config/app", async () => deps.configStore.get());
+    app.put("/api/config/app", async (request) => {
+        const body = ConfigFileSchema.parse(request.body ?? {});
+        deps.configStore.replace(body);
+        return deps.configStore.get();
+    });
+    app.get("/api/config/binaries", async () => {
+        return { binaries: deps.binaryRegistry.list() };
+    });
+    app.post("/api/config/binaries", async (request, reply) => {
+        const body = BinaryCreateSchema.parse(request.body ?? {});
+        const binary = deps.binaryRegistry.create(body);
+        reply.code(201);
+        return { binary };
+    });
+    app.patch("/api/config/binaries/:id", async (request) => {
+        const body = BinaryUpdateSchema.parse(request.body ?? {});
+        const binary = deps.binaryRegistry.update(request.params.id, body);
+        return { binary };
+    });
+    app.delete("/api/config/binaries/:id", async (request, reply) => {
+        deps.binaryRegistry.remove(request.params.id);
+        reply.code(204);
+    });
+    app.post("/api/config/binaries/validate", async (request) => {
+        const body = BinaryValidateSchema.parse(request.body ?? {});
+        return deps.binaryRegistry.validatePath(body.path);
+    });
+}

package/dist/server/routes/events.js

@@ -0,0 +1,35 @@
+export function registerEventRoutes(app, deps) {
+    app.get("/api/events", (request, reply) => {
+        const origin = request.headers.origin ?? "*";
+        reply.raw.setHeader("Access-Control-Allow-Origin", origin);
+        reply.raw.setHeader("Access-Control-Allow-Credentials", "true");
+        reply.raw.setHeader("Content-Type", "text/event-stream");
+        reply.raw.setHeader("Cache-Control", "no-cache");
+        reply.raw.setHeader("Connection", "keep-alive");
+        reply.raw.flushHeaders?.();
+        reply.hijack();
+        const send = (event) => {
+            reply.raw.write(`data: ${JSON.stringify(event)}\n\n`);
+        };
+        const unsubscribe = deps.eventBus.onEvent(send);
+        const heartbeat = setInterval(() => {
+            reply.raw.write(`:hb ${Date.now()}\n\n`);
+        }, 15000);
+        let closed = false;
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            clearInterval(heartbeat);
+            unsubscribe();
+            reply.raw.end?.();
+        };
+        const unregister = deps.registerClient(close);
+        const handleClose = () => {
+            close();
+            unregister();
+        };
+        request.raw.on("close", handleClose);
+        request.raw.on("error", handleClose);
+    });
+}

package/dist/server/routes/filesystem.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+const FilesystemQuerySchema = z.object({
+    path: z.string().optional(),
+    includeFiles: z.coerce.boolean().optional(),
+});
+export function registerFilesystemRoutes(app, deps) {
+    app.get("/api/filesystem", async (request, reply) => {
+        const query = FilesystemQuerySchema.parse(request.query ?? {});
+        try {
+            return deps.fileSystemBrowser.browse(query.path, {
+                includeFiles: query.includeFiles,
+            });
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error.message };
+        }
+    });
+}

package/dist/server/routes/meta.js

@@ -0,0 +1,3 @@
+export function registerMetaRoutes(app, deps) {
+    app.get("/api/meta", async () => deps.serverMeta);
+}

package/dist/server/routes/storage.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { ModelPreferenceSchema } from "../../config/schema";
+const InstanceDataSchema = z.object({
+    messageHistory: z.array(z.string()).default([]),
+    agentModelSelections: z.record(z.string(), ModelPreferenceSchema).default({}),
+});
+const EMPTY_INSTANCE_DATA = {
+    messageHistory: [],
+    agentModelSelections: {},
+};
+export function registerStorageRoutes(app, deps) {
+    const resolveStorageKey = (instanceId) => {
+        const workspace = deps.workspaceManager.get(instanceId);
+        return workspace?.path ?? instanceId;
+    };
+    app.get("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const storageId = resolveStorageKey(request.params.id);
+            const data = await deps.instanceStore.read(storageId);
+            return data;
+        }
+        catch (error) {
+            reply.code(500);
+            return { error: error instanceof Error ? error.message : "Failed to read instance data" };
+        }
+    });
+    app.put("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const body = InstanceDataSchema.parse(request.body ?? {});
+            const storageId = resolveStorageKey(request.params.id);
+            await deps.instanceStore.write(storageId, body);
+            deps.eventBus.publish({ type: "instance.dataChanged", instanceId: request.params.id, data: body });
+            reply.code(204);
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to save instance data" };
+        }
+    });
+    app.delete("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const storageId = resolveStorageKey(request.params.id);
+            await deps.instanceStore.delete(storageId);
+            deps.eventBus.publish({ type: "instance.dataChanged", instanceId: request.params.id, data: EMPTY_INSTANCE_DATA });
+            reply.code(204);
+        }
+        catch (error) {
+            reply.code(500);
+            return { error: error instanceof Error ? error.message : "Failed to delete instance data" };
+        }
+    });
+}

package/dist/server/routes/workspaces.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+const WorkspaceCreateSchema = z.object({
+    path: z.string(),
+    name: z.string().optional(),
+});
+const WorkspaceFilesQuerySchema = z.object({
+    path: z.string().optional(),
+});
+const WorkspaceFileContentQuerySchema = z.object({
+    path: z.string(),
+});
+const WorkspaceFileSearchQuerySchema = z.object({
+    q: z.string().trim().min(1, "Query is required"),
+    limit: z.coerce.number().int().positive().max(200).optional(),
+    type: z.enum(["all", "file", "directory"]).optional(),
+    refresh: z
+        .string()
+        .optional()
+        .transform((value) => (value === undefined ? undefined : value === "true")),
+});
+export function registerWorkspaceRoutes(app, deps) {
+    app.get("/api/workspaces", async () => {
+        return deps.workspaceManager.list();
+    });
+    app.post("/api/workspaces", async (request, reply) => {
+        const body = WorkspaceCreateSchema.parse(request.body ?? {});
+        const workspace = await deps.workspaceManager.create(body.path, body.name);
+        reply.code(201);
+        return workspace;
+    });
+    app.get("/api/workspaces/:id", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        return workspace;
+    });
+    app.delete("/api/workspaces/:id", async (request, reply) => {
+        await deps.workspaceManager.delete(request.params.id);
+        reply.code(204);
+    });
+    app.get("/api/workspaces/:id/files", async (request, reply) => {
+        try {
+            const query = WorkspaceFilesQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.listFiles(request.params.id, query.path ?? ".");
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/files/search", async (request, reply) => {
+        try {
+            const query = WorkspaceFileSearchQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.searchFiles(request.params.id, query.q, {
+                limit: query.limit,
+                type: query.type,
+                refresh: query.refresh,
+            });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/files/content", async (request, reply) => {
+        try {
+            const query = WorkspaceFileContentQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.readFile(request.params.id, query.path);
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+}
+function handleWorkspaceError(error, reply) {
+    if (error instanceof Error && error.message === "Workspace not found") {
+        reply.code(404);
+        return { error: "Workspace not found" };
+    }
+    reply.code(400);
+    return { error: error instanceof Error ? error.message : "Unable to fulfill request" };
+}

package/dist/storage/instance-store.js

@@ -0,0 +1,56 @@
+import fs from "fs";
+import { promises as fsp } from "fs";
+import os from "os";
+import path from "path";
+const DEFAULT_INSTANCE_DATA = {
+    messageHistory: [],
+    agentModelSelections: {},
+};
+export class InstanceStore {
+    constructor(baseDir = path.join(os.homedir(), ".config", "codenomad", "instances")) {
+        this.instancesDir = baseDir;
+        fs.mkdirSync(this.instancesDir, { recursive: true });
+    }
+    async read(id) {
+        try {
+            const filePath = this.resolvePath(id);
+            const content = await fsp.readFile(filePath, "utf-8");
+            const parsed = JSON.parse(content);
+            return { ...DEFAULT_INSTANCE_DATA, ...parsed };
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return DEFAULT_INSTANCE_DATA;
+            }
+            throw error;
+        }
+    }
+    async write(id, data) {
+        const filePath = this.resolvePath(id);
+        await fsp.mkdir(path.dirname(filePath), { recursive: true });
+        await fsp.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    async delete(id) {
+        try {
+            const filePath = this.resolvePath(id);
+            await fsp.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    resolvePath(id) {
+        const filename = this.sanitizeId(id);
+        return path.join(this.instancesDir, `${filename}.json`);
+    }
+    sanitizeId(id) {
+        return id
+            .replace(/[\\/]/g, "_")
+            .replace(/[^a-zA-Z0-9_.-]/g, "_")
+            .replace(/_{2,}/g, "_")
+            .replace(/^_|_$/g, "")
+            .toLowerCase();
+    }
+}

package/dist/workspaces/manager.js

@@ -0,0 +1,147 @@
+import path from "path";
+import { FileSystemBrowser } from "../filesystem/browser";
+import { searchWorkspaceFiles } from "../filesystem/search";
+import { clearWorkspaceSearchCache } from "../filesystem/search-cache";
+import { WorkspaceRuntime } from "./runtime";
+export class WorkspaceManager {
+    constructor(options) {
+        this.options = options;
+        this.workspaces = new Map();
+        this.runtime = new WorkspaceRuntime(this.options.eventBus, this.options.logger);
+    }
+    list() {
+        return Array.from(this.workspaces.values());
+    }
+    get(id) {
+        return this.workspaces.get(id);
+    }
+    getInstancePort(id) {
+        return this.workspaces.get(id)?.port;
+    }
+    listFiles(workspaceId, relativePath = ".") {
+        const workspace = this.requireWorkspace(workspaceId);
+        const browser = new FileSystemBrowser({ rootDir: workspace.path });
+        return browser.list(relativePath);
+    }
+    searchFiles(workspaceId, query, options) {
+        const workspace = this.requireWorkspace(workspaceId);
+        return searchWorkspaceFiles(workspace.path, query, options);
+    }
+    readFile(workspaceId, relativePath) {
+        const workspace = this.requireWorkspace(workspaceId);
+        const browser = new FileSystemBrowser({ rootDir: workspace.path });
+        const contents = browser.readFile(relativePath);
+        return {
+            workspaceId,
+            relativePath,
+            contents,
+        };
+    }
+    async create(folder, name) {
+        const id = `${Date.now().toString(36)}`;
+        const binary = this.options.binaryRegistry.resolveDefault();
+        const workspacePath = path.isAbsolute(folder) ? folder : path.resolve(this.options.rootDir, folder);
+        clearWorkspaceSearchCache(workspacePath);
+        this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: binary.path }, "Creating workspace");
+        const proxyPath = `/workspaces/${id}/instance`;
+        const descriptor = {
+            id,
+            path: workspacePath,
+            name,
+            status: "starting",
+            proxyPath,
+            binaryId: binary.id,
+            binaryLabel: binary.label,
+            binaryVersion: binary.version,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        this.workspaces.set(id, descriptor);
+        this.options.eventBus.publish({ type: "workspace.created", workspace: descriptor });
+        const environment = this.options.configStore.get().preferences.environmentVariables ?? {};
+        try {
+            const { pid, port } = await this.runtime.launch({
+                workspaceId: id,
+                folder: workspacePath,
+                binaryPath: binary.path,
+                environment,
+                onExit: (info) => this.handleProcessExit(info.workspaceId, info),
+            });
+            descriptor.pid = pid;
+            descriptor.port = port;
+            descriptor.status = "ready";
+            descriptor.updatedAt = new Date().toISOString();
+            this.options.eventBus.publish({ type: "workspace.started", workspace: descriptor });
+            this.options.logger.info({ workspaceId: id, port }, "Workspace ready");
+            return descriptor;
+        }
+        catch (error) {
+            descriptor.status = "error";
+            descriptor.error = error instanceof Error ? error.message : String(error);
+            descriptor.updatedAt = new Date().toISOString();
+            this.options.eventBus.publish({ type: "workspace.error", workspace: descriptor });
+            this.options.logger.error({ workspaceId: id, err: error }, "Workspace failed to start");
+            throw error;
+        }
+    }
+    async delete(id) {
+        const workspace = this.workspaces.get(id);
+        if (!workspace)
+            return undefined;
+        this.options.logger.info({ workspaceId: id }, "Stopping workspace");
+        const wasRunning = Boolean(workspace.pid);
+        if (wasRunning) {
+            await this.runtime.stop(id).catch((error) => {
+                this.options.logger.warn({ workspaceId: id, err: error }, "Failed to stop workspace process cleanly");
+            });
+        }
+        this.workspaces.delete(id);
+        clearWorkspaceSearchCache(workspace.path);
+        if (!wasRunning) {
+            this.options.eventBus.publish({ type: "workspace.stopped", workspaceId: id });
+        }
+        return workspace;
+    }
+    async shutdown() {
+        this.options.logger.info("Shutting down all workspaces");
+        for (const [id, workspace] of this.workspaces) {
+            if (workspace.pid) {
+                this.options.logger.info({ workspaceId: id }, "Stopping workspace during shutdown");
+                await this.runtime.stop(id).catch((error) => {
+                    this.options.logger.error({ workspaceId: id, err: error }, "Failed to stop workspace during shutdown");
+                });
+            }
+            else {
+                this.options.logger.debug({ workspaceId: id }, "Workspace already stopped");
+            }
+        }
+        this.workspaces.clear();
+        this.options.logger.info("All workspaces cleared");
+    }
+    requireWorkspace(id) {
+        const workspace = this.workspaces.get(id);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        return workspace;
+    }
+    handleProcessExit(workspaceId, info) {
+        const workspace = this.workspaces.get(workspaceId);
+        if (!workspace)
+            return;
+        this.options.logger.info({ workspaceId, ...info }, "Workspace process exited");
+        workspace.pid = undefined;
+        workspace.port = undefined;
+        workspace.updatedAt = new Date().toISOString();
+        if (info.requested || info.code === 0) {
+            workspace.status = "stopped";
+            workspace.error = undefined;
+            this.options.eventBus.publish({ type: "workspace.stopped", workspaceId });
+        }
+        else {
+            workspace.status = "error";
+            workspace.error = `Process exited with code ${info.code}`;
+            this.options.eventBus.publish({ type: "workspace.error", workspace });
+        }
+    }
+}