@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/web-ui/local-runtime/model-setup-input.js

@@ -0,0 +1,107 @@
+import { parseRuntimeModelProfileId } from "../../../scripts/runtime-model-addition.js";
+import { parseBaseUrl, parseContextWindowTokens, } from "../../../scripts/runtime-setup-files.js";
+import { isRecord } from "../../runtime/config/utils.js";
+export class ModelSetupError extends Error {
+    code;
+    statusCode;
+    credentialSaved;
+    constructor(code, message, statusCode = 400, credentialSaved = false) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.credentialSaved = credentialSaved;
+    }
+}
+function requireAllowedFields(body, allowed) {
+    if (Object.keys(body).some((key) => !allowed.includes(key))) {
+        throw new ModelSetupError("invalid_model_input", "The model update contains unsupported fields.");
+    }
+}
+function inputString(body, field, optional = false) {
+    const value = body[field];
+    if (value === undefined && optional)
+        return undefined;
+    if (typeof value !== "string" || !value.trim())
+        throw new ModelSetupError("invalid_model_input", `The ${field} field must be a non-empty string.`);
+    return value.trim();
+}
+function isReservedIdentifier(value) {
+    return ["__proto__", "prototype", "constructor"].includes(value);
+}
+function requireIdentifier(value, kind) {
+    const pattern = kind === "provider"
+        ? /^[A-Za-z][A-Za-z0-9._-]*$/u
+        : /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+    if (value.length > 128 ||
+        !pattern.test(value) ||
+        isReservedIdentifier(value)) {
+        throw new ModelSetupError(`invalid_${kind}_id`, `Choose a ${kind} ID of up to 128 letters, numbers, dots, underscores, or dashes, starting with ${kind === "provider" ? "a letter" : "a letter or number"}.`);
+    }
+    return kind === "profile" ? parseRuntimeModelProfileId(value) : value;
+}
+function readNewProvider(value) {
+    if (!isRecord(value))
+        throw new ModelSetupError("invalid_model_provider", "Choose a configured provider or add a new provider.");
+    requireAllowedFields(value, ["id", "type", "baseUrl"]);
+    const id = requireIdentifier(inputString(value, "id"), "provider");
+    const type = inputString(value, "type");
+    if (type !== "openai" && type !== "ollama")
+        throw new ModelSetupError("invalid_model_provider", "A new provider must use OpenAI or Ollama.");
+    const address = inputString(value, "baseUrl", true);
+    if (address && type !== "ollama")
+        throw new ModelSetupError("invalid_model_address", "A custom address is available for a new Ollama provider.");
+    let baseUrl;
+    try {
+        baseUrl = address ? parseBaseUrl(address) : undefined;
+    }
+    catch {
+        throw new ModelSetupError("invalid_model_address", "Enter an HTTP or HTTPS origin without a path or credentials.");
+    }
+    return { id, type, ...(baseUrl ? { baseUrl } : {}) };
+}
+function requireModelIdentifier(model) {
+    if (model.length > 256 || /[\u0000-\u0020\u007f]/u.test(model))
+        throw new ModelSetupError("invalid_model_id", "Enter a model ID without spaces or control characters.");
+}
+function requireSafeCredential(apiKey) {
+    if (!apiKey)
+        return;
+    if (apiKey.length > 4096 || /[\u0000-\u0020\u007f'"`]/u.test(apiKey))
+        throw new ModelSetupError("invalid_model_credential", "The API key contains unsupported characters.");
+}
+export function parseModelSetupInput(body) {
+    requireAllowedFields(body, [
+        "profileId",
+        "model",
+        "contextWindowTokens",
+        "providerId",
+        "newProvider",
+        "apiKey",
+    ]);
+    const profileId = requireIdentifier(inputString(body, "profileId"), "profile");
+    let contextWindowTokens;
+    try {
+        contextWindowTokens = parseContextWindowTokens(body.contextWindowTokens);
+    }
+    catch {
+        throw new ModelSetupError("invalid_context_window", "Context window must be a positive whole number of tokens.");
+    }
+    const model = inputString(body, "model");
+    requireModelIdentifier(model);
+    const apiKey = inputString(body, "apiKey", true);
+    requireSafeCredential(apiKey);
+    const providerId = inputString(body, "providerId", true);
+    const hasOneProvider = (providerId !== undefined) !== (body.newProvider !== undefined);
+    if (!hasOneProvider)
+        throw new ModelSetupError("invalid_model_provider", "Choose exactly one configured provider or new provider.");
+    const selection = providerId
+        ? { providerId }
+        : { newProvider: readNewProvider(body.newProvider) };
+    return {
+        profileId,
+        model,
+        ...(contextWindowTokens !== undefined ? { contextWindowTokens } : {}),
+        ...(apiKey ? { apiKey } : {}),
+        ...selection,
+    };
+}

package/dist/src/web-ui/local-runtime/model-setup-provider.d.ts

@@ -0,0 +1,17 @@
+import { type ModelSetupInput, type NewModelProvider } from "./model-setup-input.js";
+import type { ModelSetupOptions } from "./model-setup-catalog.js";
+export declare function buildNewModelProvider(selection: NewModelProvider): {
+    id: string;
+    config: import("../../../scripts/runtime-setup-files.js").JsonObject;
+};
+export declare function planModelProvider(providers: Record<string, unknown>, input: ModelSetupInput): {
+    id: string;
+    config: import("../../../scripts/runtime-setup-files.js").JsonObject;
+};
+export declare function prepareModelCredential(options: ModelSetupOptions, provider: Record<string, unknown>, apiKey?: string): Promise<{
+    apiKey?: string | undefined;
+    apiKeyEnv: string;
+} | undefined>;
+export declare function saveModelCredential(options: ModelSetupOptions & {
+    configPath: string;
+}, credential: Awaited<ReturnType<typeof prepareModelCredential>>): Promise<boolean>;

package/dist/src/web-ui/local-runtime/model-setup-provider.js

@@ -0,0 +1,68 @@
+import { RuntimeSetupError } from "./runtime-setup-input.js";
+import { hasProviderCredentialBinding, isolatedProviderCredentialName, } from "./provider-credential-identity.js";
+import { buildProviderConfig } from "../../../scripts/runtime-setup-files.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { readRuntimeSetupCredential, assertRuntimeSetupCredentialFile, persistRuntimeSetupCredentials, } from "./runtime-setup-credentials.js";
+import { ModelSetupError, } from "./model-setup-input.js";
+export function buildNewModelProvider(selection) {
+    const config = buildProviderConfig(selection.type, selection.baseUrl);
+    const needsIsolatedCredentialBinding = selection.type === "openai";
+    if (needsIsolatedCredentialBinding)
+        config.apiKeyEnv = isolatedProviderCredentialName(selection.id);
+    return { id: selection.id, config };
+}
+export function planModelProvider(providers, input) {
+    if (input.providerId !== undefined) {
+        const provider = Object.hasOwn(providers, input.providerId)
+            ? providers[input.providerId]
+            : undefined;
+        if (!isRecord(provider))
+            throw new ModelSetupError("model_provider_not_found", "The selected provider no longer exists. Refresh and choose a provider.", 404);
+        return { id: input.providerId, config: provider };
+    }
+    const selection = input.newProvider;
+    if (Object.hasOwn(providers, selection.id))
+        throw new ModelSetupError("model_provider_exists", "That provider ID already exists. Choose its saved connection or use another ID.", 409);
+    const provider = buildNewModelProvider(selection);
+    const apiKeyEnv = provider.config.apiKeyEnv;
+    const hasNewProviderCredentialCollision = typeof apiKeyEnv === "string" &&
+        hasProviderCredentialBinding(providers, apiKeyEnv);
+    if (hasNewProviderCredentialCollision)
+        throw new ModelSetupError("model_credential_conflict", "The new provider's credential name is already in use. Choose another provider ID.", 409);
+    return provider;
+}
+export async function prepareModelCredential(options, provider, apiKey) {
+    const requiresApiKey = provider.type === "openai";
+    if (!requiresApiKey) {
+        if (apiKey)
+            throw new ModelSetupError("invalid_model_credential", "Only an OpenAI connection accepts an API key here.");
+        return undefined;
+    }
+    const apiKeyEnv = typeof provider.apiKeyEnv === "string"
+        ? provider.apiKeyEnv
+        : "OPENAI_API_KEY";
+    await assertRuntimeSetupCredentialFile(options.rootDir);
+    const savedKey = readRuntimeSetupCredential(options.rootDir, apiKeyEnv);
+    if (savedKey && apiKey && savedKey !== apiKey)
+        throw new ModelSetupError("credential_already_configured", "That provider already has a saved API key. Its credential was preserved.", 409);
+    if (!savedKey && !apiKey)
+        throw new ModelSetupError("model_credential_required", "Enter an API key for this OpenAI connection.");
+    return { apiKeyEnv, ...(savedKey ? {} : { apiKey }) };
+}
+export async function saveModelCredential(options, credential) {
+    if (!credential)
+        return false;
+    try {
+        await persistRuntimeSetupCredentials({
+            ...options,
+            ...credential,
+            preserveExistingCredential: true,
+        });
+    }
+    catch (error) {
+        if (error instanceof RuntimeSetupError)
+            throw new ModelSetupError(error.code, error.message, error.statusCode);
+        throw error;
+    }
+    return true;
+}

package/dist/src/web-ui/local-runtime/model-setup-retry.d.ts

@@ -0,0 +1,14 @@
+import { type ModelSetupOptions } from "./model-setup-catalog.js";
+import { type ModelSetupInput } from "./model-setup-input.js";
+/** A repeated POST may acknowledge only the exact inline addition already committed. */
+export declare function recoverCommittedModelAddition(options: ModelSetupOptions & {
+    configPath: string;
+}, models: Record<string, unknown>, input: ModelSetupInput, expectedRevision: string): Promise<{
+    model: {
+        profileId: string;
+        providerId: string;
+        provider: string;
+        model: string;
+    };
+    restartRequired: true;
+}>;

package/dist/src/web-ui/local-runtime/model-setup-retry.js

@@ -0,0 +1,47 @@
+import { isDeepStrictEqual } from "node:util";
+import { readConfigFileSnapshot } from "../../runtime/adapters/config-file-transaction.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { modelConfigMap, } from "./model-setup-catalog.js";
+import { buildModelSetupProfile, modelSetupResult, } from "./model-setup-identity.js";
+import { ModelSetupError } from "./model-setup-input.js";
+import { buildNewModelProvider, planModelProvider, prepareModelCredential, } from "./model-setup-provider.js";
+function rejectModelProfileCollision() {
+    throw new ModelSetupError("model_profile_exists", "That model profile ID already exists with different settings. Choose another ID.", 409);
+}
+function committedRetryProvider(providers, input) {
+    if (input.providerId !== undefined)
+        return planModelProvider(providers, input);
+    return buildNewModelProvider(input.newProvider);
+}
+async function requireUnchangedRetryConfiguration(options, expectedRevision) {
+    const current = await readConfigFileSnapshot(options.configPath);
+    if (current.revision === expectedRevision)
+        return;
+    throw new ModelSetupError("config_changed", "Configuration changed while the saved model was being checked. Refresh before retrying.", 409);
+}
+/** A repeated POST may acknowledge only the exact inline addition already committed. */
+export async function recoverCommittedModelAddition(options, models, input, expectedRevision) {
+    const profiles = modelConfigMap(models.profiles);
+    const profile = profiles[input.profileId];
+    const savedProfileIsInline = isRecord(profile);
+    if (!savedProfileIsInline)
+        rejectModelProfileCollision();
+    const providers = modelConfigMap(models.providers);
+    const providerId = input.providerId ?? input.newProvider.id;
+    const hasSavedProviderConnection = isRecord(providers[providerId]);
+    if (!hasSavedProviderConnection)
+        rejectModelProfileCollision();
+    const provider = committedRetryProvider(providers, input);
+    const savedProviderMatchesRequest = isDeepStrictEqual(providers[provider.id], provider.config);
+    if (!savedProviderMatchesRequest)
+        rejectModelProfileCollision();
+    const expectedProfile = await buildModelSetupProfile(provider, input);
+    const savedProfileMatchesRequest = isDeepStrictEqual(profile, expectedProfile);
+    if (!savedProfileMatchesRequest)
+        rejectModelProfileCollision();
+    const credential = await prepareModelCredential(options, provider.config, input.apiKey);
+    if (credential?.apiKey)
+        throw new ModelSetupError("model_credential_required", "The saved model's credential is missing. Restore its connection in Configuration before retrying.", 409);
+    await requireUnchangedRetryConfiguration(options, expectedRevision);
+    return modelSetupResult(provider, input);
+}

package/dist/src/web-ui/local-runtime/model-setup-routes.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { ModelSetupService } from "./model-setup-service.js";
+export declare class ModelSetupRoutes {
+    private readonly service;
+    constructor(service: ModelSetupService);
+    handle(params: {
+        method: string;
+        route: string;
+        request: IncomingMessage;
+        response: ServerResponse;
+    }): Promise<boolean>;
+}

package/dist/src/web-ui/local-runtime/model-setup-routes.js

@@ -0,0 +1,50 @@
+import { assertConfigMutationRequest, ConfigMutationRequestError, } from "./config-mutation-request.js";
+import { readBody, readJsonBody, sendJson } from "./http.js";
+import { ModelSetupError } from "./model-setup-input.js";
+export class ModelSetupRoutes {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    async handle(params) {
+        if (!["runtime/config/models", "runtime/config/models/setup"].includes(params.route))
+            return false;
+        params.response.setHeader("cache-control", "no-store");
+        try {
+            if (params.route === "runtime/config/models/setup" &&
+                params.method === "GET") {
+                sendJson(params.response, 200, {
+                    ok: true,
+                    ...(await this.service.catalog()),
+                });
+            }
+            else if (params.route === "runtime/config/models" &&
+                params.method === "POST") {
+                assertConfigMutationRequest(params.request);
+                const body = readJsonBody(await readBody(params.request, { maxBytes: 16_384 }));
+                sendJson(params.response, 200, {
+                    ok: true,
+                    ...(await this.service.add(body)),
+                });
+            }
+            else
+                sendJson(params.response, 405, {
+                    ok: false,
+                    error: "method_not_allowed",
+                });
+        }
+        catch (error) {
+            const known = error instanceof ModelSetupError ||
+                error instanceof ConfigMutationRequestError;
+            sendJson(params.response, known ? error.statusCode : 400, {
+                ok: false,
+                error: error instanceof ModelSetupError ? error.code : "model_setup_failed",
+                message: known
+                    ? error.message
+                    : "Model configuration could not be completed. Check the settings and try again.",
+                credentialSaved: error instanceof ModelSetupError && error.credentialSaved,
+            });
+        }
+        return true;
+    }
+}

package/dist/src/web-ui/local-runtime/model-setup-service.d.ts

@@ -0,0 +1,30 @@
+export declare class ModelSetupService {
+    private readonly options;
+    constructor(options: {
+        rootDir: string;
+        getConfigPath: () => string | undefined;
+    });
+    private sourceOptions;
+    catalog(): Promise<{
+        providers: {
+            id: string;
+            type: string;
+            label: string;
+            requiresApiKey: boolean;
+            credentialConfigured: boolean;
+        }[];
+        defaultContextWindowTokens: number;
+        profileIds: string[];
+    }>;
+    private canonicalOptions;
+    add(body: Record<string, unknown>): Promise<{
+        model: {
+            profileId: string;
+            providerId: string;
+            provider: string;
+            model: string;
+        };
+        restartRequired: true;
+    }>;
+    private save;
+}

package/dist/src/web-ui/local-runtime/model-setup-service.js

@@ -0,0 +1,93 @@
+import { isDeepStrictEqual } from "node:util";
+import { realpath } from "node:fs/promises";
+import { isAbsolute, relative } from "node:path";
+import { mergeRuntimeModelAddition } from "../../../scripts/runtime-model-addition.js";
+import { ConfigFileConflictError, withConfigFileTransaction, } from "../../runtime/adapters/config-file-transaction.js";
+import { getConfigDashboardSnapshot, saveConfigDashboardFile, } from "../config-dashboard-backend.js";
+import { getModelSetupCatalog, modelConfigMap, readModelSetupSource, } from "./model-setup-catalog.js";
+import { ModelSetupError, parseModelSetupInput, } from "./model-setup-input.js";
+import { planModelProvider, prepareModelCredential, saveModelCredential, } from "./model-setup-provider.js";
+import { validateModelAddition } from "./model-setup-validation.js";
+import { buildModelSetupProfile, modelSetupResult, } from "./model-setup-identity.js";
+import { recoverCommittedModelAddition } from "./model-setup-retry.js";
+function hasCommittedModelAddition(options, candidate) {
+    try {
+        return isDeepStrictEqual(readModelSetupSource(options).config, candidate);
+    }
+    catch {
+        return false;
+    }
+}
+export class ModelSetupService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    sourceOptions() {
+        return {
+            rootDir: this.options.rootDir,
+            configPath: this.options.getConfigPath(),
+        };
+    }
+    async catalog() {
+        return getModelSetupCatalog(await this.canonicalOptions());
+    }
+    async canonicalOptions() {
+        const source = readModelSetupSource(this.sourceOptions());
+        const options = {
+            rootDir: await realpath(this.options.rootDir),
+            configPath: await realpath(source.path),
+        };
+        const target = relative(options.rootDir, options.configPath);
+        if (target.startsWith("..") || isAbsolute(target))
+            throw new ModelSetupError("model_config_outside_workspace", "The selected configuration must be inside the workspace.", 409);
+        return options;
+    }
+    async add(body) {
+        const input = parseModelSetupInput(body);
+        const options = await this.canonicalOptions();
+        return withConfigFileTransaction(options.configPath, (transaction) => this.save(options, input, transaction));
+    }
+    async save(options, input, transaction) {
+        const source = readModelSetupSource(options);
+        const models = modelConfigMap(source.config.models);
+        const dashboard = await getConfigDashboardSnapshot(options);
+        const profileExists = dashboard.files.models.some((profile) => profile.id === input.profileId);
+        if (profileExists)
+            return recoverCommittedModelAddition(options, models, input, transaction.snapshot.revision);
+        const provider = planModelProvider(modelConfigMap(models.providers), input);
+        const profile = await buildModelSetupProfile(provider, input);
+        const candidate = mergeRuntimeModelAddition(source.config, {
+            profileId: input.profileId,
+            providerId: provider.id,
+            provider: provider.config,
+            profile,
+        }).config;
+        await validateModelAddition(candidate, options);
+        const credential = await prepareModelCredential(options, provider.config, input.apiKey);
+        let credentialSaved = false;
+        let configSaveAttempted = false;
+        try {
+            credentialSaved = await saveModelCredential(options, credential);
+            configSaveAttempted = true;
+            await saveConfigDashboardFile({
+                ...options,
+                kind: "runtime",
+                config: candidate,
+                transaction,
+            });
+        }
+        catch (error) {
+            if (error instanceof ModelSetupError)
+                throw error;
+            if (error instanceof ConfigFileConflictError)
+                throw new ModelSetupError("config_changed", error.message, 409, credentialSaved);
+            const modelCommitted = configSaveAttempted && hasCommittedModelAddition(options, candidate);
+            if (!modelCommitted)
+                throw new ModelSetupError("model_save_failed", credentialSaved
+                    ? "The credential is saved, but the model save could not be confirmed. Refresh Configuration, then retry without re-entering the key if the model is missing."
+                    : "The model save could not be confirmed. Refresh Configuration before trying again.", 500, credentialSaved);
+        }
+        return modelSetupResult(provider, input);
+    }
+}

package/dist/src/web-ui/local-runtime/model-setup-validation.d.ts

@@ -0,0 +1,5 @@
+/** Staging beside the selected source preserves every existing relative reference. */
+export declare function validateModelAddition(config: Record<string, unknown>, options: {
+    rootDir: string;
+    configPath: string;
+}): Promise<void>;

package/dist/src/web-ui/local-runtime/model-setup-validation.js

@@ -0,0 +1,33 @@
+import { randomUUID } from "node:crypto";
+import { rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { loadRuntimeConfig } from "../../runtime/config.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
+/** Staging beside the selected source preserves every existing relative reference. */
+export async function validateModelAddition(config, options) {
+    validateRuntimeConfigFile(config, options.configPath);
+    const temporary = join(dirname(options.configPath), `.model-addition-validation-${randomUUID()}.json`);
+    try {
+        await writeFile(temporary, JSON.stringify(config), {
+            encoding: "utf8",
+            mode: 0o600,
+            flag: "wx",
+        });
+        const environment = isRecord(config.environment) ? config.environment : {};
+        const profileIds = isRecord(environment.profiles)
+            ? Object.keys(environment.profiles)
+            : [];
+        const environments = profileIds.length ? profileIds : [undefined];
+        for (const profileId of environments)
+            loadRuntimeConfig({
+                rootDir: options.rootDir,
+                configPath: temporary,
+                profileId,
+                env: { ...process.env },
+            });
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/dist/src/web-ui/local-runtime/plugin-management-routes.d.ts

@@ -0,0 +1,14 @@
+import type { ServerResponse } from "node:http";
+export declare class PluginManagementRoutes {
+    private readonly options;
+    constructor(options: {
+        rootDir: string;
+        getConfigPath?: () => string | undefined;
+    });
+    handle(params: {
+        method: string;
+        route: string;
+        body: Record<string, unknown> | null;
+        response: ServerResponse;
+    }): Promise<boolean>;
+}

package/dist/src/web-ui/local-runtime/plugin-management-routes.js

@@ -0,0 +1,50 @@
+import { getRuntimePluginSnapshot, PluginManagementError, setRuntimePluginEnabled, } from "../plugin-management-service.js";
+import { sendJson } from "./http.js";
+export class PluginManagementRoutes {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async handle(params) {
+        if (params.route !== "runtime/plugins")
+            return false;
+        const options = {
+            rootDir: this.options.rootDir,
+            configPath: this.options.getConfigPath?.(),
+        };
+        try {
+            if (params.method === "GET") {
+                sendJson(params.response, 200, {
+                    ok: true,
+                    ...getRuntimePluginSnapshot(options),
+                });
+                return true;
+            }
+            if (params.method === "PUT") {
+                const result = await setRuntimePluginEnabled(options, params.body);
+                sendJson(params.response, 200, { ok: true, ...result });
+                return true;
+            }
+            sendJson(params.response, 405, {
+                ok: false,
+                error: "method_not_allowed",
+            });
+        }
+        catch (error) {
+            if (error instanceof PluginManagementError) {
+                sendJson(params.response, error.statusCode, {
+                    ok: false,
+                    error: error.code,
+                    message: error.message,
+                });
+                return true;
+            }
+            sendJson(params.response, 500, {
+                ok: false,
+                error: "plugin_management_failed",
+                message: "Plugin configuration could not be loaded or saved.",
+            });
+        }
+        return true;
+    }
+}

package/dist/src/web-ui/local-runtime/project-routes.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { JsonObject, RuntimeEnvironment } from "./contracts.js";
+type ProjectRouteRequest = {
+    method: string;
+    segments: readonly string[];
+    url: URL;
+    body: JsonObject | null;
+    environment: RuntimeEnvironment;
+    request: IncomingMessage;
+    response: ServerResponse;
+};
+/** Project management is an owner service; these routes only serialize it. */
+export declare class ProjectRoutes {
+    handle(request: ProjectRouteRequest): Promise<boolean>;
+    private dispatch;
+}
+export {};

package/dist/src/web-ui/local-runtime/project-routes.js

@@ -0,0 +1,93 @@
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { getString, sendJson } from "./http.js";
+function isProjectCollection(segments) {
+    return segments.length === 1;
+}
+function isProjectFolderListing(segments) {
+    if (segments.length !== 2)
+        return false;
+    return segments[1] === "folders";
+}
+function isProjectSessionCreation(segments) {
+    if (segments.length !== 3)
+        return false;
+    return segments[2] === "sessions";
+}
+function isProjectMutationRequest(method) {
+    return method === "POST";
+}
+function acceptProjectRequest(request) {
+    if (!isProjectMutationRequest(request.method))
+        return true;
+    return acceptConfigMutationRequest(request.request, request.response);
+}
+function projectErrorStatus(code) {
+    if (["project_not_found", "project_directory_unavailable"].includes(code))
+        return 404;
+    if (code === "project_directory_unreadable")
+        return 403;
+    if (code === "project_folder_cursor_stale")
+        return 409;
+    if (code === "projects_unavailable")
+        return 503;
+    return 400;
+}
+function sendProjectError(response, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof Error && "code" in error
+        ? String(error.code)
+        : "project_operation_failed";
+    sendJson(response, projectErrorStatus(code), {
+        ok: false,
+        error: code,
+        message,
+    });
+}
+/** Project management is an owner service; these routes only serialize it. */
+export class ProjectRoutes {
+    async handle(request) {
+        if (request.segments[0] !== "projects")
+            return false;
+        if (!acceptProjectRequest(request))
+            return true;
+        try {
+            const service = request.environment.services.projects;
+            if (!service)
+                throw Object.assign(new Error("Projects are unavailable on this backend."), { code: "projects_unavailable" });
+            await this.dispatch(request, service);
+        }
+        catch (error) {
+            sendProjectError(request.response, error);
+        }
+        return true;
+    }
+    async dispatch(request, service) {
+        const { method, segments, body, response } = request;
+        if (method === "GET" && isProjectCollection(segments)) {
+            sendJson(response, 200, { ok: true, projects: await service.list() });
+            return;
+        }
+        if (method === "POST" && isProjectCollection(segments)) {
+            const project = await service.create({
+                directory: getString(body?.directory),
+                name: getString(body?.name),
+            });
+            sendJson(response, 201, { ok: true, project });
+            return;
+        }
+        if (method === "GET" && isProjectFolderListing(segments)) {
+            const page = await service.browseFolders({
+                path: getString(request.url.searchParams.get("path")),
+                cursor: getString(request.url.searchParams.get("cursor")),
+            });
+            sendJson(response, 200, { ok: true, ...page });
+            return;
+        }
+        if (method === "POST" && isProjectSessionCreation(segments)) {
+            const session = await service.createSession(segments[1]);
+            sendJson(response, 201, { ok: true, ...session });
+            return;
+        }
+        sendJson(response, 404, { ok: false, error: "not_found" });
+    }
+}