@codori/server 0.0.2 → 0.0.4

package/dist/attachment-store.js

@@ -0,0 +1,84 @@
+import { createHash } from 'node:crypto';
+import { open, readFile, writeFile, mkdir } from 'node:fs/promises';
+import os from 'node:os';
+import { pipeline } from 'node:stream/promises';
+import { basename, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { resolveCodoriHome } from './config.js';
+const hashSegment = (value) => createHash('sha256').update(value).digest('hex').slice(0, 16);
+const sanitizeFilename = (value) => {
+    const normalized = basename(value).trim();
+    return normalized || 'attachment';
+};
+const createFileNameCandidate = (directory, filename, index) => {
+    const extension = extname(filename);
+    const base = extension ? filename.slice(0, -extension.length) : filename;
+    return join(directory, index === 0 ? filename : `${base}-${index}${extension}`);
+};
+const attachmentMetadataPath = (filePath) => `${filePath}.metadata.json`;
+export const resolveAttachmentsRootDir = (rootDir) => resolve(rootDir ?? join(resolveCodoriHome(os.homedir()), 'attachments'));
+export const resolveProjectAttachmentsDir = (projectPath, rootDir) => join(resolveAttachmentsRootDir(rootDir), hashSegment(projectPath));
+export const resolveThreadAttachmentsDir = (projectPath, threadId, rootDir) => join(resolveProjectAttachmentsDir(projectPath, rootDir), hashSegment(threadId));
+export const isPathInsideDirectory = (targetPath, directory) => {
+    const relativePath = relative(directory, targetPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
+};
+export const writeAttachmentMetadata = async (filePath, metadata) => {
+    await writeFile(attachmentMetadataPath(filePath), `${JSON.stringify(metadata, null, 2)}\n`, 'utf8');
+};
+export const readAttachmentMetadata = async (filePath) => {
+    try {
+        const source = await readFile(attachmentMetadataPath(filePath), 'utf8');
+        const parsed = JSON.parse(source);
+        if (typeof parsed === 'object'
+            && parsed !== null
+            && 'mediaType' in parsed
+            && (typeof parsed.mediaType === 'string' || parsed.mediaType === null)) {
+            return {
+                mediaType: parsed.mediaType
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+export const createThreadAttachmentTarget = async (input) => {
+    const directory = resolveThreadAttachmentsDir(input.projectPath, input.threadId, input.rootDir);
+    await mkdir(directory, { recursive: true });
+    const filename = sanitizeFilename(input.filename);
+    for (let index = 0; index < 10_000; index += 1) {
+        const candidate = createFileNameCandidate(directory, filename, index);
+        try {
+            const handle = await open(candidate, 'wx');
+            return {
+                filePath: candidate,
+                handle
+            };
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`Failed to allocate a unique attachment path for ${filename}.`);
+};
+export const persistThreadAttachmentStream = async (input) => {
+    const target = await createThreadAttachmentTarget(input);
+    try {
+        await pipeline(input.stream, target.handle.createWriteStream());
+        await writeAttachmentMetadata(target.filePath, {
+            mediaType: input.mediaType
+        });
+        return {
+            filename: basename(target.filePath),
+            mediaType: input.mediaType,
+            path: target.filePath
+        };
+    }
+    finally {
+        await target.handle.close().catch(() => { });
+    }
+};

package/dist/cli.d.ts

@@ -1,2 +1,6 @@
 #!/usr/bin/env node
-export {};
+import { type ServiceCommandDependencies } from './service.js';
+export declare const CLI_USAGE: string;
+export declare const resolveCliEntrypointPath: (value: string | undefined) => string | null;
+export declare const isCliEntrypointPath: (argvPath: string | undefined, moduleUrl: string) => boolean;
+export declare const runCli: (argv?: string[], dependencies?: ServiceCommandDependencies) => Promise<void>;

package/dist/cli.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { parseArgs } from 'node:util';
 import { asErrorMessage, CodoriError } from './errors.js';
 import { startHttpServer } from './http-server.js';
 import { createRuntimeManager } from './process-manager.js';
+import { installService, restartService, uninstallService } from './service.js';
 const printJson = (value) => {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 };
@@ -35,6 +39,16 @@ const optionConfig = {
     },
     json: {
         type: 'boolean'
+    },
+    scope: {
+        type: 'string'
+    },
+    yes: {
+        type: 'boolean'
+    },
+    help: {
+        type: 'boolean',
+        short: 'h'
     }
 };
 const coercePort = (value) => {
@@ -45,22 +59,125 @@ const coercePort = (value) => {
     return Number.isFinite(parsed) ? parsed : undefined;
 };
 const resolveCliRoot = (value) => value ?? process.cwd();
-const main = async () => {
+export const CLI_USAGE = [
+    'Usage:',
+    '  npx @codori/server <command> [projectId] [options]',
+    '  codori <command> [projectId] [options]',
+    '',
+    'Runtime commands:',
+    '  serve',
+    '  list',
+    '  status [projectId]',
+    '  start <projectId>',
+    '  stop <projectId>',
+    '',
+    'Service commands:',
+    '  install-service',
+    '  setup-service',
+    '  restart-service',
+    '  uninstall-service',
+    '',
+    'Options:',
+    '  --root <path>',
+    '  --host <host>',
+    '  --port <port>',
+    '  --scope <user|system>',
+    '  --yes',
+    '  --json',
+    '  --help',
+    '',
+    'Canonical service examples:',
+    '  npx @codori/server install-service',
+    '  npx @codori/server restart-service --root ~/Project/codori',
+    '  npx @codori/server uninstall-service --root ~/Project/codori',
+    '',
+    'Installed binary examples:',
+    '  codori install-service',
+    '  codori restart-service --root ~/Project/codori'
+].join('\n');
+const printUsage = (stdout = process.stdout) => {
+    stdout.write(`${CLI_USAGE}\n`);
+};
+export const resolveCliEntrypointPath = (value) => {
+    if (!value) {
+        return null;
+    }
+    const resolved = resolvePath(value);
+    try {
+        return realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+};
+export const isCliEntrypointPath = (argvPath, moduleUrl) => {
+    const entryPath = resolveCliEntrypointPath(argvPath);
+    const modulePath = resolveCliEntrypointPath(fileURLToPath(moduleUrl));
+    return entryPath !== null && entryPath === modulePath;
+};
+const executeServiceCommand = async (command, values, dependencies = {}) => {
+    const stdout = dependencies.stdout ?? process.stdout;
+    const options = {
+        root: values.root,
+        host: values.host,
+        port: values.port,
+        scope: values.scope,
+        yes: values.yes ?? false
+    };
+    switch (command) {
+        case 'install-service':
+        case 'setup-service': {
+            const result = await installService(options, dependencies);
+            stdout.write(`Installed service ${result.metadata.serviceName}\n`);
+            return;
+        }
+        case 'restart-service': {
+            const result = await restartService({
+                root: values.root,
+                scope: values.scope,
+                yes: values.yes ?? false
+            }, dependencies);
+            stdout.write(`Restarted service ${result.metadata.serviceName}\n`);
+            return;
+        }
+        case 'uninstall-service': {
+            const result = await uninstallService({
+                root: values.root,
+                yes: values.yes ?? false
+            }, dependencies);
+            stdout.write(`Removed service ${result.metadata.serviceName}\n`);
+        }
+    }
+};
+export const runCli = async (argv = process.argv.slice(2), dependencies = {}) => {
     const parsed = parseArgs({
+        args: argv,
         allowPositionals: true,
         options: optionConfig
     });
+    const values = parsed.values;
     const [command = 'serve', maybeProjectId] = parsed.positionals;
-    const manager = createRuntimeManager({
-        configOverrides: {
-            root: resolveCliRoot(parsed.values.root),
-            host: parsed.values.host,
-            port: coercePort(parsed.values.port)
-        }
-    });
-    const json = parsed.values.json ?? false;
+    if (values.help) {
+        printUsage(dependencies.stdout ?? process.stdout);
+        return;
+    }
+    if (command === 'install-service'
+        || command === 'setup-service'
+        || command === 'restart-service'
+        || command === 'uninstall-service') {
+        await executeServiceCommand(command, values, dependencies);
+        return;
+    }
     switch (command) {
         case 'list': {
+            const manager = createRuntimeManager({
+                configOverrides: {
+                    root: resolveCliRoot(values.root),
+                    host: values.host,
+                    port: coercePort(values.port)
+                }
+            });
+            const json = values.json ?? false;
             const statuses = manager.listProjectStatuses();
             if (json) {
                 printJson(statuses);
@@ -71,6 +188,14 @@ const main = async () => {
             return;
         }
         case 'status': {
+            const manager = createRuntimeManager({
+                configOverrides: {
+                    root: resolveCliRoot(values.root),
+                    host: values.host,
+                    port: coercePort(values.port)
+                }
+            });
+            const json = values.json ?? false;
             if (maybeProjectId) {
                 const status = manager.getProjectStatus(maybeProjectId);
                 if (json) {
@@ -91,6 +216,14 @@ const main = async () => {
             return;
         }
         case 'start': {
+            const manager = createRuntimeManager({
+                configOverrides: {
+                    root: resolveCliRoot(values.root),
+                    host: values.host,
+                    port: coercePort(values.port)
+                }
+            });
+            const json = values.json ?? false;
             if (!maybeProjectId) {
                 throw new CodoriError('MISSING_PROJECT_ID', 'The start command requires a project id.');
             }
@@ -104,6 +237,14 @@ const main = async () => {
             return;
         }
         case 'stop': {
+            const manager = createRuntimeManager({
+                configOverrides: {
+                    root: resolveCliRoot(values.root),
+                    host: values.host,
+                    port: coercePort(values.port)
+                }
+            });
+            const json = values.json ?? false;
             if (!maybeProjectId) {
                 throw new CodoriError('MISSING_PROJECT_ID', 'The stop command requires a project id.');
             }
@@ -117,22 +258,33 @@ const main = async () => {
             return;
         }
         case 'serve': {
+            const manager = createRuntimeManager({
+                configOverrides: {
+                    root: resolveCliRoot(values.root),
+                    host: values.host,
+                    port: coercePort(values.port)
+                }
+            });
             const app = await startHttpServer(manager);
             process.stdout.write(`Running codori server with project root directory: ${manager.config.root}\n`);
             process.stdout.write(`Codori listening on http://${manager.config.server.host}:${manager.config.server.port}\n`);
+            process.stdout.write('Private tunnel is not included. Expose Codori through your own network layer such as Tailscale or Cloudflare Tunnel when you need remote access.\n');
             await app.ready();
             return;
         }
         default:
-            process.stdout.write('Usage: npx @codori/server [serve|list|status|start|stop] [projectId] --root <path> [--host <host>] [--port <port>] [--json]\n');
+            printUsage(dependencies.stdout ?? process.stdout);
     }
 };
-void main().catch((error) => {
-    if (error instanceof CodoriError) {
-        process.stderr.write(`${error.code}: ${error.message}\n`);
-    }
-    else {
-        process.stderr.write(`${asErrorMessage(error)}\n`);
-    }
-    process.exitCode = 1;
-});
+const isEntrypoint = isCliEntrypointPath(process.argv[1], import.meta.url);
+if (isEntrypoint) {
+    void runCli().catch((error) => {
+        if (error instanceof CodoriError) {
+            process.stderr.write(`${error.code}: ${error.message}\n`);
+        }
+        else {
+            process.stderr.write(`${asErrorMessage(error)}\n`);
+        }
+        process.exitCode = 1;
+    });
+}

package/dist/config.d.ts

@@ -1,4 +1,6 @@
 import type { CodoriConfig, ConfigOverrides } from './types.js';
+export declare const DEFAULT_SERVER_HOST = "127.0.0.1";
+export declare const DEFAULT_SERVER_PORT = 4310;
 export declare const resolveCodoriHome: (homeDir?: string) => string;
 export declare const resolveCodoriConfigPath: (homeDir?: string) => string;
 export declare const ensureCodoriDirectories: (homeDir?: string) => {

package/dist/config.js

@@ -2,8 +2,8 @@ import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import os from 'node:os';
 import { join, resolve } from 'node:path';
 import { CodoriError } from './errors.js';
-const DEFAULT_SERVER_HOST = '127.0.0.1';
-const DEFAULT_SERVER_PORT = 4310;
+export const DEFAULT_SERVER_HOST = '127.0.0.1';
+export const DEFAULT_SERVER_PORT = 4310;
 const DEFAULT_PORT_START = 46000;
 const DEFAULT_PORT_END = 46999;
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);

package/dist/http-server.d.ts

@@ -1,4 +1,5 @@
 import Fastify, { type FastifyInstance } from 'fastify';
+import { type ServiceUpdateController } from './service-update.js';
 import type { ProjectStatusRecord, StartProjectResult } from './types.js';
 type MaybePromise<T> = T | Promise<T>;
 export type RuntimeManagerLike = {
@@ -15,6 +16,8 @@ export type RuntimeManagerLike = {
 };
 export type HttpServerOptions = {
     clientBundleDir?: string | null;
+    attachmentsRootDir?: string | null;
+    serviceUpdateController?: ServiceUpdateController | null;
 };
 export declare const createHttpServer: (manager: RuntimeManagerLike, options?: HttpServerOptions) => Promise<FastifyInstance>;
 export declare const startHttpServer: (manager?: import("./process-manager.js").RuntimeManager) => Promise<Fastify.FastifyInstance<Fastify.RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, Fastify.FastifyBaseLogger, Fastify.FastifyTypeProviderDefault>>;

package/dist/http-server.js

@@ -1,13 +1,18 @@
+import { readFile, stat } from 'node:fs/promises';
 import net from 'node:net';
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import multipart from '@fastify/multipart';
 import fastifyStatic from '@fastify/static';
 import websocket from '@fastify/websocket';
 import Fastify, {} from 'fastify';
+import { lookup as lookupMimeType } from 'mime-types';
 import WebSocket from 'ws';
+import { isPathInsideDirectory, persistThreadAttachmentStream, readAttachmentMetadata, resolveProjectAttachmentsDir } from './attachment-store.js';
 import { CodoriError } from './errors.js';
 import { createRuntimeManager } from './process-manager.js';
+import { createServiceUpdateController } from './service-update.js';
 const isCodoriError = (error) => error instanceof CodoriError;
 const resolveBundledClientDir = () => {
     const candidates = [
@@ -23,14 +28,21 @@ const resolveBundledClientDir = () => {
 };
 const toRequestPath = (url) => url.split('?')[0]?.split('#')[0] ?? url;
 const isAssetRequest = (pathname) => /\.[a-z0-9]+$/i.test(pathname);
+const MAX_ATTACHMENTS_PER_MESSAGE = 8;
+const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 const toStatusCode = (error) => {
     switch (error.code) {
         case 'PROJECT_NOT_FOUND':
             return 404;
         case 'INVALID_CONFIG':
         case 'MISSING_PROJECT_ID':
+        case 'MISSING_THREAD_ID':
+        case 'INVALID_ATTACHMENT':
         case 'MISSING_ROOT':
             return 400;
+        case 'SERVICE_UPDATE_UNAVAILABLE':
+        case 'SERVICE_UPDATE_IN_PROGRESS':
+            return 409;
         default:
             return 500;
     }
@@ -42,6 +54,24 @@ const getProjectIdFromRequest = (value) => {
     return value;
 };
 const resolveValue = async (value) => value;
+const isStatusCodeCarrier = (error) => typeof error === 'object'
+    && error !== null
+    && 'statusCode' in error
+    && typeof error.statusCode === 'number';
+const normalizeImageMediaType = (input) => {
+    const declared = input.declaredMediaType?.trim().toLowerCase() ?? null;
+    if (declared?.startsWith('image/')) {
+        return declared;
+    }
+    if (declared) {
+        return null;
+    }
+    const inferred = lookupMimeType(input.filename);
+    if (typeof inferred === 'string' && inferred.toLowerCase().startsWith('image/')) {
+        return inferred.toLowerCase();
+    }
+    return null;
+};
 const wait = async (ms) => new Promise((resolvePromise) => {
     setTimeout(resolvePromise, ms);
 });
@@ -78,6 +108,14 @@ export const createHttpServer = async (manager, options = {}) => {
     const clientBundleDir = options.clientBundleDir === undefined
         ? resolveBundledClientDir()
         : options.clientBundleDir;
+    const serviceUpdateController = options.serviceUpdateController ?? null;
+    await app.register(multipart, {
+        limits: {
+            files: MAX_ATTACHMENTS_PER_MESSAGE,
+            fields: 4,
+            fileSize: MAX_ATTACHMENT_BYTES
+        }
+    });
     await app.register(websocket);
     if (clientBundleDir) {
         await app.register(fastifyStatic, {
@@ -95,6 +133,15 @@ export const createHttpServer = async (manager, options = {}) => {
             });
             return;
         }
+        if (isStatusCodeCarrier(error)) {
+            reply.status(error.statusCode).send({
+                error: {
+                    code: error.code ?? 'REQUEST_ERROR',
+                    message: error.message ?? 'Request failed.'
+                }
+            });
+            return;
+        }
         reply.status(500).send({
             error: {
                 code: 'INTERNAL_ERROR',
@@ -105,6 +152,26 @@ export const createHttpServer = async (manager, options = {}) => {
     app.get('/api/projects', async () => ({
         projects: await resolveValue(manager.listProjectStatuses())
     }));
+    app.get('/api/service/update', async () => ({
+        serviceUpdate: serviceUpdateController
+            ? await serviceUpdateController.getStatus()
+            : {
+                enabled: false,
+                updateAvailable: false,
+                updating: false,
+                installedVersion: null,
+                latestVersion: null
+            }
+    }));
+    app.post('/api/service/update', async (_request, reply) => {
+        if (!serviceUpdateController) {
+            throw new CodoriError('SERVICE_UPDATE_UNAVAILABLE', 'Self-update is only available while Codori is running as a registered service.');
+        }
+        reply.status(202);
+        return {
+            serviceUpdate: await serviceUpdateController.requestUpdate()
+        };
+    });
     app.get('/api/projects/:projectId', async (request) => ({
         project: await resolveValue(manager.getProjectStatus(getProjectIdFromRequest(request.params.projectId)))
     }));
@@ -117,6 +184,114 @@ export const createHttpServer = async (manager, options = {}) => {
     app.post('/api/projects/:projectId/stop', async (request) => ({
         project: await resolveValue(manager.stopProject(getProjectIdFromRequest(request.params.projectId)))
     }));
+    app.post('/api/projects/:projectId/attachments', async (request, reply) => {
+        const projectId = getProjectIdFromRequest(request.params.projectId);
+        const project = await resolveValue(manager.getProjectStatus(projectId));
+        const files = [];
+        let threadId = null;
+        for await (const part of request.parts()) {
+            if (part.type === 'file') {
+                if (!threadId) {
+                    throw new CodoriError('MISSING_THREAD_ID', 'Thread id must be provided before file parts.');
+                }
+                const mediaType = normalizeImageMediaType({
+                    filename: part.filename ?? 'attachment',
+                    declaredMediaType: part.mimetype || null
+                });
+                if (!mediaType) {
+                    throw new CodoriError('INVALID_ATTACHMENT', 'Only image attachments are supported.');
+                }
+                const attachment = await persistThreadAttachmentStream({
+                    projectPath: project.projectPath,
+                    threadId,
+                    filename: part.filename ?? 'attachment',
+                    mediaType,
+                    stream: part.file,
+                    rootDir: options.attachmentsRootDir
+                });
+                files.push(attachment);
+                continue;
+            }
+            if (part.fieldname === 'threadId' && typeof part.value === 'string') {
+                threadId = part.value.trim() || null;
+            }
+        }
+        if (!threadId) {
+            throw new CodoriError('MISSING_THREAD_ID', 'Missing thread id.');
+        }
+        if (!files.length) {
+            throw new CodoriError('INVALID_ATTACHMENT', 'No files provided.');
+        }
+        reply.header('cache-control', 'no-store');
+        return {
+            threadId,
+            files
+        };
+    });
+    app.get('/api/projects/:projectId/attachments/file', async (request, reply) => {
+        const projectId = getProjectIdFromRequest(request.params.projectId);
+        const requestedPath = typeof request.query.path === 'string'
+            ? request.query.path.trim()
+            : '';
+        if (!requestedPath) {
+            throw new CodoriError('INVALID_ATTACHMENT', 'Missing attachment path.');
+        }
+        const project = await resolveValue(manager.getProjectStatus(projectId));
+        const allowedRoot = resolveProjectAttachmentsDir(project.projectPath, options.attachmentsRootDir);
+        const resolvedPath = resolve(requestedPath);
+        if (!isPathInsideDirectory(resolvedPath, allowedRoot)) {
+            reply.status(403);
+            return {
+                error: {
+                    code: 'FORBIDDEN',
+                    message: 'Invalid attachment path.'
+                }
+            };
+        }
+        let fileStat;
+        try {
+            fileStat = await stat(resolvedPath);
+        }
+        catch {
+            reply.status(404);
+            return {
+                error: {
+                    code: 'NOT_FOUND',
+                    message: 'Attachment not found.'
+                }
+            };
+        }
+        if (!fileStat.isFile()) {
+            reply.status(404);
+            return {
+                error: {
+                    code: 'NOT_FOUND',
+                    message: 'Attachment not found.'
+                }
+            };
+        }
+        const attachmentMetadata = await readAttachmentMetadata(resolvedPath);
+        const inferredMediaType = typeof lookupMimeType(resolvedPath) === 'string'
+            ? String(lookupMimeType(resolvedPath)).toLowerCase()
+            : null;
+        const mediaType = attachmentMetadata?.mediaType?.toLowerCase()
+            ?? inferredMediaType
+            ?? null;
+        if (!mediaType?.startsWith('image/')) {
+            reply.status(415);
+            return {
+                error: {
+                    code: 'UNSUPPORTED_MEDIA_TYPE',
+                    message: 'Attachment preview is only available for image files.'
+                }
+            };
+        }
+        reply.header('cache-control', 'private, max-age=3600');
+        reply.header('cross-origin-resource-policy', 'cross-origin');
+        reply.header('content-type', mediaType);
+        reply.header('content-disposition', `inline; filename="${basename(resolvedPath).replace(/"/g, '')}"`);
+        return await readFile(resolvedPath);
+    });
     app.get('/api/projects/:projectId/rpc', { websocket: true }, async (clientSocket, request) => {
         const projectId = getProjectIdFromRequest(request.params.projectId);
         const pendingClientMessages = [];
@@ -210,10 +385,14 @@ export const createHttpServer = async (manager, options = {}) => {
     return app;
 };
 export const startHttpServer = async (manager = createRuntimeManager()) => {
-    const app = await createHttpServer(manager);
     if (!manager.config) {
         throw new CodoriError('INVALID_CONFIG', 'Manager config is required to start the HTTP server.');
     }
+    const app = await createHttpServer(manager, {
+        serviceUpdateController: createServiceUpdateController({
+            root: manager.config.root
+        })
+    });
     await app.listen({
         host: manager.config.server.host,
         port: manager.config.server.port

package/dist/index.d.ts

@@ -4,5 +4,8 @@ export { createHttpServer, startHttpServer } from './http-server.js';
 export { findAvailablePort } from './ports.js';
 export { createRuntimeManager, RuntimeManager } from './process-manager.js';
 export { scanProjects } from './project-scanner.js';
+export * from './service-adapters.js';
+export * from './service-update.js';
 export { RuntimeStore } from './runtime-store.js';
+export * from './service.js';
 export type * from './types.js';

package/dist/index.js

@@ -4,4 +4,7 @@ export { createHttpServer, startHttpServer } from './http-server.js';
 export { findAvailablePort } from './ports.js';
 export { createRuntimeManager, RuntimeManager } from './process-manager.js';
 export { scanProjects } from './project-scanner.js';
+export * from './service-adapters.js';
+export * from './service-update.js';
 export { RuntimeStore } from './runtime-store.js';
+export * from './service.js';