copilot-hub 0.1.0

package/apps/control-plane/dist/index.js

@@ -0,0 +1,349 @@
+// @ts-nocheck
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import express from "express";
+import { BotManager } from "@copilot-hub/core/bot-manager";
+import { loadBotRegistry } from "@copilot-hub/core/bot-registry";
+import { config } from "./config.js";
+import { InstanceLock } from "@copilot-hub/core/instance-lock";
+import { KernelControlPlane } from "@copilot-hub/core/kernel-control-plane";
+import { CONTROL_ACTIONS } from "@copilot-hub/core/control-plane-actions";
+import { KernelSecretStore } from "@copilot-hub/core/secret-store";
+let activeWebPort = config.webPort;
+let runtimeWebPublicBaseUrl = config.webPublicBaseUrl;
+let shuttingDown = false;
+let server = null;
+let botManager = null;
+let instanceLock = null;
+let controlPlane = null;
+let secretStore = null;
+const workerScriptPath = fileURLToPath(new URL("./agent-worker.js", import.meta.url));
+await bootstrap();
+async function bootstrap() {
+    try {
+        if (config.instanceLockEnabled) {
+            instanceLock = new InstanceLock(config.instanceLockFilePath);
+            await instanceLock.acquire();
+        }
+        secretStore = new KernelSecretStore(config.secretStoreFilePath);
+        await secretStore.init();
+        const registry = await loadBotRegistry({
+            filePath: config.botRegistryFilePath,
+            dataDir: config.dataDir,
+            defaultWorkspaceRoot: config.defaultWorkspaceRoot,
+            defaultThreadMode: config.defaultThreadMode,
+            defaultSharedThreadId: config.defaultSharedThreadId,
+            defaultAllowedChatIds: config.defaultAllowedChatIds,
+            bootstrapTelegramToken: config.bootstrapTelegramToken,
+            defaultProviderKind: config.defaultProviderKind,
+            workspacePolicy: config.workspacePolicy,
+            resolveSecret: (name) => secretStore.getSecret(name),
+        });
+        const runtimeBots = registry.bots.filter((bot) => bot.enabled !== false && bot.id !== config.adminBotId);
+        if (runtimeBots.length !== registry.bots.filter((bot) => bot.enabled !== false).length) {
+            console.warn(`Runtime registry contains reserved id '${config.adminBotId}'. It is ignored because admin is managed by control-plane hub.`);
+        }
+        botManager = new BotManager({
+            botDefinitions: runtimeBots,
+            providerDefaults: config.providerDefaults,
+            turnActivityTimeoutMs: config.turnActivityTimeoutMs,
+            maxMessages: config.maxMessages,
+            webPublicBaseUrl: runtimeWebPublicBaseUrl,
+            projectsBaseDir: config.projectsBaseDir,
+            workerScriptPath,
+            botDataRootDir: path.join(config.dataDir, "bots"),
+            heartbeatEnabled: config.agentHeartbeatEnabled,
+            heartbeatIntervalMs: config.agentHeartbeatIntervalMs,
+            heartbeatTimeoutMs: config.agentHeartbeatTimeoutMs,
+        });
+        controlPlane = new KernelControlPlane({
+            botManager,
+            registryFilePath: registry.filePath,
+            secretStore,
+            registryLoadOptions: {
+                dataDir: config.dataDir,
+                defaultWorkspaceRoot: config.defaultWorkspaceRoot,
+                defaultThreadMode: config.defaultThreadMode,
+                defaultSharedThreadId: config.defaultSharedThreadId,
+                defaultAllowedChatIds: config.defaultAllowedChatIds,
+                bootstrapTelegramToken: config.bootstrapTelegramToken,
+                defaultProviderKind: config.defaultProviderKind,
+                workspacePolicy: config.workspacePolicy,
+                resolveSecret: (name) => secretStore.getSecret(name),
+            },
+        });
+        botManager.setKernelActionHandler((request) => controlPlane.handleAgentAction(request));
+        const app = buildApiApp({
+            botManager,
+            controlPlane,
+            registryFilePath: registry.filePath,
+        });
+        const started = await startWebServer({
+            app,
+            host: config.webHost,
+            basePort: config.webPort,
+            autoIncrement: config.webPortAutoIncrement,
+            maxAttempts: config.webPortSearchMax,
+        });
+        server = started.server;
+        activeWebPort = started.port;
+        runtimeWebPublicBaseUrl = resolveRuntimeWebPublicBaseUrl({
+            explicit: config.webPublicBaseUrlExplicit,
+            configuredBaseUrl: config.webPublicBaseUrl,
+            host: config.webHost,
+            port: activeWebPort,
+        });
+        botManager.setWebPublicBaseUrl(runtimeWebPublicBaseUrl);
+        await botManager.startAutoBots();
+        registerSignals();
+        console.log(`HTTP API listening on http://${config.webHost}:${activeWebPort}`);
+        console.log(`Bot registry loaded: ${registry.filePath}`);
+        if (instanceLock) {
+            console.log(`Instance lock acquired: ${config.instanceLockFilePath}`);
+        }
+    }
+    catch (error) {
+        const message = sanitizeError(error);
+        console.error(message);
+        await cleanupBeforeExit();
+        process.exit(1);
+    }
+}
+function buildApiApp({ botManager, controlPlane, registryFilePath }) {
+    const app = express();
+    app.use(express.json({ limit: "1mb" }));
+    app.use((req, res, next) => {
+        res.setHeader("Cache-Control", "no-store");
+        next();
+    });
+    app.get("/api/health", (req, res) => {
+        res.json({
+            ok: true,
+            service: "runtime_kernel",
+            providerDefault: config.defaultProviderKind,
+            webPort: activeWebPort,
+            webPublicBaseUrl: runtimeWebPublicBaseUrl,
+            botCount: botManager.getBotCount(),
+            turnActivityTimeoutMs: config.turnActivityTimeoutMs,
+            heartbeatEnabled: config.agentHeartbeatEnabled,
+            heartbeatIntervalMs: config.agentHeartbeatIntervalMs,
+            heartbeatTimeoutMs: config.agentHeartbeatTimeoutMs,
+            registryFile: registryFilePath,
+            projectsBaseDir: config.projectsBaseDir,
+            secretStoreFile: config.secretStoreFilePath,
+        });
+    });
+    app.get("/api/extensions/contract", wrapAsync(async (req, res) => {
+        const contract = await controlPlane.runSystemAction(CONTROL_ACTIONS.EXTENSIONS_CONTRACT_GET, {});
+        res.json(contract);
+    }));
+    app.get("/api/bots", wrapAsync(async (req, res) => {
+        const bots = await botManager.listBotsLive();
+        res.json({ bots });
+    }));
+    app.post("/api/bots/:botId/delete", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const deleteMode = parseDeleteModeFromRequest(req.body);
+        const deleted = await controlPlane.runSystemAction(CONTROL_ACTIONS.BOTS_DELETE, {
+            botId,
+            deleteMode,
+        });
+        res.json(deleted);
+    }));
+    app.post("/api/bots/:botId/project", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const projectName = String(req.body?.projectName ?? "").trim();
+        if (!projectName) {
+            res.status(400).json({ error: "Field 'projectName' is required." });
+            return;
+        }
+        const result = await controlPlane.runSystemAction(CONTROL_ACTIONS.BOTS_SET_PROJECT, {
+            botId,
+            projectName,
+        });
+        res.json(result);
+    }));
+    app.post("/api/bots/:botId/policy", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const sandboxMode = String(req.body?.sandboxMode ?? "")
+            .trim()
+            .toLowerCase();
+        const approvalPolicy = String(req.body?.approvalPolicy ?? "")
+            .trim()
+            .toLowerCase();
+        if (!sandboxMode) {
+            res.status(400).json({ error: "Field 'sandboxMode' is required." });
+            return;
+        }
+        if (!approvalPolicy) {
+            res.status(400).json({ error: "Field 'approvalPolicy' is required." });
+            return;
+        }
+        const result = await controlPlane.runSystemAction(CONTROL_ACTIONS.BOTS_SET_POLICY, {
+            botId,
+            sandboxMode,
+            approvalPolicy,
+        });
+        res.json(result);
+    }));
+    app.post("/api/bots/:botId/reset", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        await botManager.resetWebThread(botId);
+        const bot = await botManager.getBotStatus(botId);
+        res.json({
+            bot,
+            reset: true,
+        });
+    }));
+    app.get("/api/bots/:botId/approvals", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const threadId = String(req.query.threadId ?? "").trim() || undefined;
+        const approvals = await botManager.listBotApprovals(botId, threadId);
+        res.json({ approvals });
+    }));
+    app.post("/api/bots/:botId/approvals/:approvalId", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const approvalId = String(req.params.approvalId ?? "").trim();
+        const threadId = String(req.body?.threadId ?? "").trim();
+        const decision = String(req.body?.decision ?? "").trim();
+        if (!threadId) {
+            res.status(400).json({ error: "Field 'threadId' is required." });
+            return;
+        }
+        if (!decision) {
+            res.status(400).json({ error: "Field 'decision' is required." });
+            return;
+        }
+        const resolved = await botManager.resolveBotApproval(botId, {
+            threadId,
+            approvalId,
+            decision,
+        });
+        res.json({ approval: resolved });
+    }));
+    app.get("/api/bots/:botId/capabilities", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const result = await controlPlane.runSystemAction(CONTROL_ACTIONS.BOTS_CAPABILITIES_LIST, {
+            botId,
+        });
+        res.json(result);
+    }));
+    app.post("/api/bots/:botId/capabilities/reload", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const result = await controlPlane.runSystemAction(CONTROL_ACTIONS.BOTS_CAPABILITIES_RELOAD, {
+            botId,
+        });
+        res.json(result);
+    }));
+    app.post("/api/bots/:botId/capabilities/scaffold", wrapAsync(async (req, res) => {
+        const botId = String(req.params.botId ?? "").trim();
+        const capabilityId = String(req.body?.capabilityId ?? "").trim();
+        const capabilityName = String(req.body?.capabilityName ?? "").trim();
+        if (!capabilityId) {
+            res.status(400).json({ error: "Field 'capabilityId' is required." });
+            return;
+        }
+        const result = await controlPlane.runSystemAction(CONTROL_ACTIONS.BOTS_CAPABILITIES_SCAFFOLD, {
+            botId,
+            capabilityId,
+            capabilityName: capabilityName || undefined,
+        });
+        res.json(result);
+    }));
+    app.get("/api/projects", wrapAsync(async (req, res) => {
+        const projects = await controlPlane.runSystemAction(CONTROL_ACTIONS.PROJECTS_LIST, {});
+        res.json(projects);
+    }));
+    app.post("/api/projects/create", wrapAsync(async (req, res) => {
+        const name = String(req.body?.name ?? "").trim();
+        if (!name) {
+            res.status(400).json({ error: "Field 'name' is required." });
+            return;
+        }
+        const created = await controlPlane.runSystemAction(CONTROL_ACTIONS.PROJECTS_CREATE, { name });
+        res.json(created);
+    }));
+    app.use((error, req, res, _next) => {
+        const message = sanitizeError(error);
+        res.status(400).json({ error: message });
+    });
+    return app;
+}
+function registerSignals() {
+    process.on("SIGINT", () => {
+        void shutdown(0);
+    });
+    process.on("SIGTERM", () => {
+        void shutdown(0);
+    });
+}
+function wrapAsync(handler) {
+    return (req, res, next) => {
+        Promise.resolve(handler(req, res, next)).catch(next);
+    };
+}
+function resolveRuntimeWebPublicBaseUrl({ explicit, configuredBaseUrl, host, port }) {
+    if (explicit) {
+        return configuredBaseUrl;
+    }
+    const exposedHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    return `http://${exposedHost}:${port}`;
+}
+async function startWebServer({ app, host, basePort, autoIncrement, maxAttempts }) {
+    let port = basePort;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        try {
+            const startedServer = await listenOnce({ app, host, port });
+            return { server: startedServer, port };
+        }
+        catch (error) {
+            const occupied = error && typeof error === "object" && error.code === "EADDRINUSE";
+            if (!occupied || !autoIncrement || port >= 65535) {
+                throw error;
+            }
+            port += 1;
+        }
+    }
+    throw new Error(`Could not find a free web port after ${maxAttempts} attempts starting from ${basePort}.`);
+}
+function listenOnce({ app, host, port }) {
+    return new Promise((resolve, reject) => {
+        const candidate = app.listen(port, host);
+        candidate.once("listening", () => resolve(candidate));
+        candidate.once("error", (error) => reject(error));
+    });
+}
+async function shutdown(exitCode) {
+    if (shuttingDown) {
+        return;
+    }
+    shuttingDown = true;
+    await cleanupBeforeExit();
+    process.exit(exitCode);
+}
+async function cleanupBeforeExit() {
+    if (botManager) {
+        await botManager.shutdownAll();
+    }
+    if (server) {
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+    }
+    if (instanceLock) {
+        await instanceLock.release();
+    }
+}
+function sanitizeError(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    return raw.split(/\r?\n/).slice(0, 12).join("\n");
+}
+function parseDeleteModeFromRequest(body) {
+    const value = String(body?.deleteMode ?? "")
+        .trim()
+        .toLowerCase();
+    if (value === "soft" || value === "purge_data" || value === "purge_all") {
+        return value;
+    }
+    return "soft";
+}

package/apps/control-plane/dist/kernel/admin-contract.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+const BOT_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+export const DEFAULT_ADMIN_BOT_ID = "admin_agent";
+export const DEFAULT_ADMIN_TOKEN_ENV = "TELEGRAM_TOKEN_ADMIN";
+export const DEFAULT_ADMIN_CHANNEL_ID = "telegram_admin";
+export function normalizeAdminBotId(value) {
+    const id = String(value ?? DEFAULT_ADMIN_BOT_ID).trim();
+    if (!BOT_ID_PATTERN.test(id)) {
+        throw new Error("ADMIN_BOT_ID has invalid format.");
+    }
+    return id;
+}
+export function normalizeAdminTokenEnv(value) {
+    const name = String(value ?? DEFAULT_ADMIN_TOKEN_ENV).trim();
+    if (!name) {
+        throw new Error("ADMIN_TELEGRAM_TOKEN_ENV cannot be empty.");
+    }
+    return name;
+}
+export function buildAdminAgentDefinition({ botId, tokenEnvName }) {
+    const normalizedBotId = normalizeAdminBotId(botId);
+    const normalizedTokenEnv = normalizeAdminTokenEnv(tokenEnvName);
+    return {
+        id: normalizedBotId,
+        name: "Admin Agent",
+        enabled: true,
+        autoStart: true,
+        dataDir: `./data/bots/${normalizedBotId}`,
+        threadMode: "single",
+        sharedThreadId: normalizedBotId === DEFAULT_ADMIN_BOT_ID
+            ? "shared-admin"
+            : `shared-${normalizedBotId.replace(/_/g, "-")}`,
+        provider: {
+            kind: "codex",
+            options: {},
+        },
+        kernelAccess: {
+            enabled: true,
+            allowedActions: ["*"],
+            allowedChatIds: [],
+        },
+        channels: [
+            {
+                kind: "telegram",
+                id: DEFAULT_ADMIN_CHANNEL_ID,
+                tokenEnv: normalizedTokenEnv,
+            },
+        ],
+        capabilities: [],
+    };
+}

package/apps/control-plane/dist/test/project-fingerprint.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createProjectFingerprint } from "@copilot-hub/core/project-fingerprint";
+test("createProjectFingerprint is stable and order-independent for channels", () => {
+    const a = createProjectFingerprint({
+        runtimeId: "control-plane",
+        workspaceRoot: "./workspace-admin",
+        providerKind: "CODEX",
+        channels: [
+            { kind: "telegram", id: "123" },
+            { kind: "whatsapp", id: "admin" },
+        ],
+    });
+    const b = createProjectFingerprint({
+        runtimeId: "control-plane",
+        workspaceRoot: "./workspace-admin",
+        providerKind: "codex",
+        channels: [
+            { kind: "whatsapp", id: "admin" },
+            { kind: "telegram", id: "123" },
+        ],
+    });
+    assert.equal(a, b);
+    assert.match(a, /^[a-f0-9]{24}$/);
+});
+test("createProjectFingerprint changes when stable inputs differ", () => {
+    const base = createProjectFingerprint({
+        runtimeId: "control-plane",
+        workspaceRoot: "./workspace-admin",
+        providerKind: "codex",
+        channels: [{ kind: "telegram", id: "123" }],
+    });
+    const changedWorkspace = createProjectFingerprint({
+        runtimeId: "control-plane",
+        workspaceRoot: "./workspace-other",
+        providerKind: "codex",
+        channels: [{ kind: "telegram", id: "123" }],
+    });
+    assert.notEqual(base, changedWorkspace);
+});

package/apps/control-plane/dist/test/thread-id.test.js

@@ -0,0 +1,12 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeThreadId } from "@copilot-hub/core/thread-id";
+test("normalizeThreadId trims and accepts valid thread ids", () => {
+    assert.equal(normalizeThreadId("  shared-copilot-hub  "), "shared-copilot-hub");
+    assert.equal(normalizeThreadId("chat:123_ABC-1"), "chat:123_ABC-1");
+});
+test("normalizeThreadId rejects empty and invalid values", () => {
+    assert.throws(() => normalizeThreadId(""), /threadId is required/);
+    assert.throws(() => normalizeThreadId("thread id with spaces"), /Invalid threadId/);
+    assert.throws(() => normalizeThreadId("chat/123"), /Invalid threadId/);
+});

package/apps/control-plane/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@copilot-hub/control-plane",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Copilot Hub control plane",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:test": "tsc -p tsconfig.test.json",
+    "prestart": "node ../../scripts/ensure-shared-build.mjs && npm run build",
+    "start": "node dist/copilot-hub.js",
+    "predev": "node ../../scripts/ensure-shared-build.mjs && npm run build",
+    "dev": "node --watch dist/copilot-hub.js",
+    "pretest": "node ../../scripts/ensure-shared-build.mjs && npm run build && npm run build:test",
+    "test": "node ../../scripts/run-node-tests.mjs dist/test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@copilot-hub/contracts": "0.1.0",
+    "@copilot-hub/core": "0.1.0",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "grammy": "^1.38.3"
+  }
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "copilot-hub",
+  "version": "0.1.0",
+  "description": "Copilot Hub CLI and runtime bundle",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openminedev/copilot-hub.git"
+  },
+  "homepage": "https://github.com/openminedev/copilot-hub#readme",
+  "bugs": {
+    "url": "https://github.com/openminedev/copilot-hub/issues"
+  },
+  "keywords": [
+    "copilot",
+    "telegram",
+    "agents",
+    "automation",
+    "cli"
+  ],
+  "bin": {
+    "copilot-hub": "scripts/cli.mjs"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "scripts/",
+    "apps/agent-engine/.env.example",
+    "apps/agent-engine/bot-registry.example.json",
+    "apps/agent-engine/capabilities/",
+    "apps/agent-engine/dist/",
+    "apps/agent-engine/package.json",
+    "apps/control-plane/.env.example",
+    "apps/control-plane/bot-registry.example.json",
+    "apps/control-plane/capabilities/",
+    "apps/control-plane/dist/",
+    "apps/control-plane/package.json",
+    "packages/contracts/dist/",
+    "packages/contracts/package.json",
+    "packages/core/dist/",
+    "packages/core/package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "workspaces": [
+    "apps/*",
+    "packages/*"
+  ],
+  "scripts": {
+    "build": "npm run build --workspaces --if-present",
+    "prepare:shared": "node scripts/ensure-shared-build.mjs",
+    "start": "node scripts/cli.mjs start",
+    "stop": "node scripts/cli.mjs stop",
+    "restart": "node scripts/cli.mjs restart",
+    "status": "node scripts/cli.mjs status",
+    "logs": "node scripts/cli.mjs logs",
+    "configure": "node scripts/cli.mjs configure",
+    "test": "npm run test --workspaces --if-present",
+    "lint": "eslint .",
+    "format": "prettier --write \"{scripts,packages}/**/*.{js,mjs,ts,json}\" \"apps/*/src/**/*.{js,ts}\" \"apps/*/package.json\" \"apps/*/test/**/*.{js,ts}\" \"apps/*/tsconfig*.json\" \"{README.md,CONTRIBUTING.md,ARCHITECTURE.md}\" \"eslint.config.mjs\" \"package.json\" \"tsconfig.base.json\"",
+    "format:check": "prettier --check \"{scripts,packages}/**/*.{js,mjs,ts,json}\" \"apps/*/src/**/*.{js,ts}\" \"apps/*/package.json\" \"apps/*/test/**/*.{js,ts}\" \"apps/*/tsconfig*.json\" \"{README.md,CONTRIBUTING.md,ARCHITECTURE.md}\" \"eslint.config.mjs\" \"package.json\" \"tsconfig.base.json\"",
+    "start:control-plane": "npm --prefix apps/control-plane run start",
+    "start:agent-engine": "npm --prefix apps/agent-engine run start",
+    "setup:agent-engine": "npm --prefix apps/agent-engine run setup",
+    "check:agent-engine": "npm --prefix apps/agent-engine run build && node --check apps/agent-engine/dist/index.js",
+    "check:control-plane": "npm --prefix apps/control-plane run build && node --check apps/control-plane/dist/copilot-hub.js",
+    "check:apps": "npm run check:agent-engine && npm run check:control-plane",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@copilot-hub/contracts": "file:packages/contracts",
+    "@copilot-hub/core": "file:packages/core",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "grammy": "^1.38.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.22.0",
+    "@types/node": "^22.13.10",
+    "eslint": "^9.22.0",
+    "globals": "^16.0.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/packages/contracts/README.md

@@ -0,0 +1,10 @@
+# Contracts
+
+Shared versioned contracts for control-plane actions across:
+- `apps/agent-engine`
+- `apps/control-plane`
+
+Current contract:
+- `control-plane.v1.json` (version `1.1.0`)
+
+This package exports action constants and validators used by both planes.

package/packages/contracts/dist/control-plane.d.ts

@@ -0,0 +1,24 @@
+export declare const CONTROL_ACTIONS: Readonly<{
+    readonly BOTS_LIST: "bots:list";
+    readonly BOTS_STATUS: "bots:status";
+    readonly BOTS_START: "bots:start";
+    readonly BOTS_STOP: "bots:stop";
+    readonly BOTS_CREATE: "bots:create";
+    readonly BOTS_DELETE: "bots:delete";
+    readonly BOTS_SET_POLICY: "bots:set_policy";
+    readonly BOTS_SET_PROJECT: "bots:set_project";
+    readonly BOTS_CAPABILITIES_LIST: "bots:capabilities:list";
+    readonly BOTS_CAPABILITIES_RELOAD: "bots:capabilities:reload";
+    readonly BOTS_CAPABILITIES_SCAFFOLD: "bots:capabilities:scaffold";
+    readonly PROJECTS_LIST: "projects:list";
+    readonly PROJECTS_CREATE: "projects:create";
+    readonly SECRETS_LIST: "secrets:list";
+    readonly SECRETS_SET: "secrets:set";
+    readonly SECRETS_DELETE: "secrets:delete";
+    readonly EXTENSIONS_CONTRACT_GET: "extensions:contract:get";
+}>;
+export type ControlAction = (typeof CONTROL_ACTIONS)[keyof typeof CONTROL_ACTIONS];
+export declare function normalizeControlAction(value: unknown): string;
+export declare function isControlAction(value: unknown): value is ControlAction;
+export declare function requireControlAction(value: unknown): ControlAction;
+export declare const CONTROL_ACTION_LIST: readonly ControlAction[];

package/packages/contracts/dist/control-plane.js

@@ -0,0 +1,37 @@
+export const CONTROL_ACTIONS = Object.freeze({
+    BOTS_LIST: "bots:list",
+    BOTS_STATUS: "bots:status",
+    BOTS_START: "bots:start",
+    BOTS_STOP: "bots:stop",
+    BOTS_CREATE: "bots:create",
+    BOTS_DELETE: "bots:delete",
+    BOTS_SET_POLICY: "bots:set_policy",
+    BOTS_SET_PROJECT: "bots:set_project",
+    BOTS_CAPABILITIES_LIST: "bots:capabilities:list",
+    BOTS_CAPABILITIES_RELOAD: "bots:capabilities:reload",
+    BOTS_CAPABILITIES_SCAFFOLD: "bots:capabilities:scaffold",
+    PROJECTS_LIST: "projects:list",
+    PROJECTS_CREATE: "projects:create",
+    SECRETS_LIST: "secrets:list",
+    SECRETS_SET: "secrets:set",
+    SECRETS_DELETE: "secrets:delete",
+    EXTENSIONS_CONTRACT_GET: "extensions:contract:get",
+});
+const CONTROL_ACTION_SET = new Set(Object.values(CONTROL_ACTIONS));
+export function normalizeControlAction(value) {
+    return String(value ?? "")
+        .trim()
+        .toLowerCase();
+}
+export function isControlAction(value) {
+    return CONTROL_ACTION_SET.has(normalizeControlAction(value));
+}
+export function requireControlAction(value) {
+    const action = normalizeControlAction(value);
+    if (!CONTROL_ACTION_SET.has(action)) {
+        throw new Error(`Unsupported control action '${action || "<empty>"}'.`);
+    }
+    return action;
+}
+export const CONTROL_ACTION_LIST = Object.freeze([...CONTROL_ACTION_SET]);
+//# sourceMappingURL=control-plane.js.map

package/packages/contracts/dist/control-plane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-plane.js","sourceRoot":"","sources":["../src/control-plane.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3C,SAAS,EAAE,WAAW;IACtB,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,SAAS,EAAE,WAAW;IACtB,WAAW,EAAE,aAAa;IAC1B,WAAW,EAAE,aAAa;IAC1B,eAAe,EAAE,iBAAiB;IAClC,gBAAgB,EAAE,kBAAkB;IACpC,sBAAsB,EAAE,wBAAwB;IAChD,wBAAwB,EAAE,0BAA0B;IACpD,0BAA0B,EAAE,4BAA4B;IACxD,aAAa,EAAE,eAAe;IAC9B,eAAe,EAAE,iBAAiB;IAClC,YAAY,EAAE,cAAc;IAC5B,WAAW,EAAE,aAAa;IAC1B,cAAc,EAAE,gBAAgB;IAChC,uBAAuB,EAAE,yBAAyB;CAC1C,CAAC,CAAC;AAIZ,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAgB,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC;AAElF,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,OAAO,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC;SACvB,IAAI,EAAE;SACN,WAAW,EAAE,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,OAAO,kBAAkB,CAAC,GAAG,CAAC,sBAAsB,CAAC,KAAK,CAAkB,CAAC,CAAC;AAChF,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,MAAM,MAAM,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;IAC7C,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAuB,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,+BAA+B,MAAM,IAAI,SAAS,IAAI,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,MAAuB,CAAC;AACjC,CAAC;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,kBAAkB,CAAoB,CAAC,CAAC"}

package/packages/contracts/dist/index.d.ts

@@ -0,0 +1 @@
+export { CONTROL_ACTIONS, CONTROL_ACTION_LIST, normalizeControlAction, isControlAction, requireControlAction, } from "./control-plane.js";

package/packages/contracts/dist/index.js

@@ -0,0 +1,2 @@
+export { CONTROL_ACTIONS, CONTROL_ACTION_LIST, normalizeControlAction, isControlAction, requireControlAction, } from "./control-plane.js";
+//# sourceMappingURL=index.js.map

package/packages/contracts/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}