arcane-agents 0.1.0

package/dist/server/server/config/loadConfig.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArcaneAgentsPaths = getArcaneAgentsPaths;
+exports.loadResolvedConfig = loadResolvedConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+const schema_1 = require("./schema");
+const path_1 = require("../utils/path");
+function getArcaneAgentsPaths() {
+    const configDir = (0, path_1.resolveUserPath)("~/.config/arcane-agents");
+    const stateDir = (0, path_1.resolveUserPath)("~/.local/state/arcane-agents");
+    return {
+        configDir,
+        configPath: node_path_1.default.join(configDir, "config.yaml"),
+        localOverridePath: node_path_1.default.join(configDir, "config.local.yaml"),
+        stateDir,
+        dbPath: node_path_1.default.join(stateDir, "arcane-agents.db"),
+        cacheDir: (0, path_1.resolveUserPath)("~/.cache/arcane-agents")
+    };
+}
+function loadResolvedConfig(paths = getArcaneAgentsPaths()) {
+    const defaults = (0, schema_1.createDefaultConfig)();
+    const userConfig = readConfigFile(paths.configPath);
+    const localOverride = readConfigFile(paths.localOverridePath);
+    const merged = deepMerge(deepMerge(defaults, userConfig), localOverride);
+    const parsed = schema_1.resolvedConfigSchema.parse(merged);
+    const normalizedProjects = Object.fromEntries(Object.entries(parsed.projects).map(([projectId, project]) => [
+        projectId,
+        {
+            ...project,
+            path: (0, path_1.resolveUserPath)(project.path),
+            source: project.source ?? "config"
+        }
+    ]));
+    const normalizedDiscovery = parsed.discovery.map((rule) => ({
+        ...rule,
+        path: (0, path_1.resolveUserPath)(rule.path)
+    }));
+    const finalConfig = {
+        ...parsed,
+        projects: normalizedProjects,
+        discovery: normalizedDiscovery
+    };
+    const normalizedShortcutConfig = normalizeShortcutProjectReferences(finalConfig);
+    validateReferences(normalizedShortcutConfig);
+    return normalizedShortcutConfig;
+}
+function readConfigFile(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return {};
+    }
+    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+    if (!raw.trim()) {
+        return {};
+    }
+    const parsedYaml = yaml_1.default.parse(raw);
+    const validated = schema_1.partialConfigSchema.parse(parsedYaml);
+    return validated;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(baseValue, overrideValue) {
+    if (Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+        return [...overrideValue];
+    }
+    if (isRecord(baseValue) && isRecord(overrideValue)) {
+        const result = { ...baseValue };
+        for (const [key, value] of Object.entries(overrideValue)) {
+            result[key] = key in result ? deepMerge(result[key], value) : value;
+        }
+        return result;
+    }
+    return overrideValue === undefined ? baseValue : overrideValue;
+}
+function validateReferences(config) {
+    for (const shortcut of config.shortcuts) {
+        if (!config.projects[shortcut.project]) {
+            throw new Error(`Shortcut '${shortcut.label}' references unknown project '${shortcut.project}'.`);
+        }
+        if (!config.runtimes[shortcut.runtime]) {
+            throw new Error(`Shortcut '${shortcut.label}' references unknown runtime '${shortcut.runtime}'.`);
+        }
+    }
+}
+function normalizeShortcutProjectReferences(config) {
+    const projectIdsByShortName = new Map();
+    for (const [projectId, project] of Object.entries(config.projects)) {
+        const existing = projectIdsByShortName.get(project.shortName);
+        if (existing) {
+            existing.push(projectId);
+        }
+        else {
+            projectIdsByShortName.set(project.shortName, [projectId]);
+        }
+    }
+    const normalizedShortcuts = config.shortcuts.map((shortcut) => {
+        if (config.projects[shortcut.project]) {
+            return shortcut;
+        }
+        const projectIdMatches = projectIdsByShortName.get(shortcut.project);
+        if (!projectIdMatches || projectIdMatches.length === 0) {
+            return shortcut;
+        }
+        if (projectIdMatches.length > 1) {
+            throw new Error(`Shortcut '${shortcut.label}' references project '${shortcut.project}', but that shortName is ambiguous (${projectIdMatches.join(", ")}). Use an explicit project id.`);
+        }
+        return {
+            ...shortcut,
+            project: projectIdMatches[0]
+        };
+    });
+    return {
+        ...config,
+        shortcuts: normalizedShortcuts
+    };
+}

package/dist/server/server/config/schema.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvedConfigSchema = exports.partialConfigSchema = void 0;
+exports.createDefaultConfig = createDefaultConfig;
+const zod_1 = require("zod");
+const avatarSchema = zod_1.z.string().trim().min(1);
+const projectSchema = zod_1.z.object({
+    path: zod_1.z.string().min(1),
+    shortName: zod_1.z.string().min(1),
+    label: zod_1.z.string().min(1).optional(),
+    source: zod_1.z.enum(["config", "discovered"]).optional()
+});
+const runtimeSchema = zod_1.z.object({
+    command: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    label: zod_1.z.string().min(1)
+});
+const shortcutSchema = zod_1.z.object({
+    label: zod_1.z.string().min(1),
+    project: zod_1.z.string().min(1),
+    runtime: zod_1.z.string().min(1),
+    command: zod_1.z.array(zod_1.z.string().min(1)).min(1).optional(),
+    avatar: avatarSchema.optional(),
+    hotkeys: zod_1.z.array(zod_1.z.string().min(1)).optional()
+});
+const discoveryRuleSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    type: zod_1.z.enum(["worktrees", "directories", "glob"]),
+    path: zod_1.z.string().min(1),
+    match: zod_1.z.string().optional(),
+    exclude: zod_1.z.array(zod_1.z.string()).optional(),
+    maxDepth: zod_1.z.number().int().min(0).optional()
+});
+const backendSchema = zod_1.z.object({
+    tmux: zod_1.z.object({
+        sessionName: zod_1.z.string().min(1),
+        pollIntervalMs: zod_1.z.number().int().min(250)
+    })
+});
+const serverSchema = zod_1.z.object({
+    host: zod_1.z.string().min(1),
+    port: zod_1.z.number().int().min(1).max(65535)
+});
+const audioSchema = zod_1.z.object({
+    enableSound: zod_1.z.boolean()
+});
+const avatarsSchema = zod_1.z.object({
+    disabled: zod_1.z.array(avatarSchema)
+});
+exports.partialConfigSchema = zod_1.z
+    .object({
+    projects: zod_1.z.record(projectSchema).optional(),
+    runtimes: zod_1.z.record(runtimeSchema).optional(),
+    shortcuts: zod_1.z.array(shortcutSchema).optional(),
+    discovery: zod_1.z.array(discoveryRuleSchema).optional(),
+    avatars: avatarsSchema.partial().optional(),
+    audio: audioSchema.partial().optional(),
+    backend: zod_1.z
+        .object({
+        tmux: zod_1.z
+            .object({
+            sessionName: zod_1.z.string().min(1).optional(),
+            pollIntervalMs: zod_1.z.number().int().min(250).optional()
+        })
+            .optional()
+    })
+        .optional(),
+    server: serverSchema.partial().optional()
+})
+    .passthrough();
+exports.resolvedConfigSchema = zod_1.z.object({
+    projects: zod_1.z.record(projectSchema),
+    runtimes: zod_1.z.record(runtimeSchema),
+    shortcuts: zod_1.z.array(shortcutSchema),
+    discovery: zod_1.z.array(discoveryRuleSchema),
+    avatars: avatarsSchema,
+    audio: audioSchema,
+    backend: backendSchema,
+    server: serverSchema
+});
+function createDefaultConfig() {
+    return {
+        projects: {
+            "arcane-agents": {
+                path: process.cwd(),
+                shortName: "aa",
+                label: "Arcane Agents",
+                source: "config"
+            }
+        },
+        runtimes: {
+            shell: {
+                command: ["bash"],
+                label: "Shell"
+            }
+        },
+        shortcuts: [
+            {
+                label: "AA",
+                project: "arcane-agents",
+                runtime: "shell"
+            }
+        ],
+        discovery: [],
+        avatars: {
+            disabled: []
+        },
+        audio: {
+            enableSound: true
+        },
+        backend: {
+            tmux: {
+                sessionName: "arcane-agents",
+                pollIntervalMs: 2500
+            }
+        },
+        server: {
+            host: "127.0.0.1",
+            port: 7600
+        }
+    };
+}

package/dist/server/server/http/appError.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+exports.validationError = validationError;
+exports.notFoundError = notFoundError;
+exports.conflictError = conflictError;
+exports.isAppError = isAppError;
+class AppError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.name = "AppError";
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.AppError = AppError;
+function validationError(message, code = "validation_error") {
+    return new AppError(400, code, message);
+}
+function notFoundError(message, code = "not_found") {
+    return new AppError(404, code, message);
+}
+function conflictError(message, code = "conflict") {
+    return new AppError(409, code, message);
+}
+function isAppError(error) {
+    return error instanceof AppError;
+}

package/dist/server/server/http/errorResponse.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequestError = handleRequestError;
+const appError_1 = require("./appError");
+function handleRequestError(res, error) {
+    if ((0, appError_1.isAppError)(error)) {
+        res.status(error.status).json({
+            error: error.message,
+            code: error.code
+        });
+        return;
+    }
+    if (isBodyParseError(error)) {
+        res.status(400).json({
+            error: "Request body must be valid JSON.",
+            code: "validation_error"
+        });
+        return;
+    }
+    res.status(500).json({
+        error: "Internal server error.",
+        code: "internal_error"
+    });
+}
+function isBodyParseError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const record = error;
+    return record.type === "entity.parse.failed";
+}

package/dist/server/server/http/errorResponse.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const appError_1 = require("./appError");
+const errorResponse_1 = require("./errorResponse");
+function createResponseMock() {
+    const response = {
+        status: vitest_1.vi.fn(),
+        json: vitest_1.vi.fn()
+    };
+    response.status.mockReturnValue(response);
+    return response;
+}
+(0, vitest_1.describe)("handleRequestError", () => {
+    (0, vitest_1.it)("maps typed app errors to explicit status and code", () => {
+        const response = createResponseMock();
+        (0, errorResponse_1.handleRequestError)(response, (0, appError_1.validationError)("Invalid payload", "invalid_payload"));
+        (0, vitest_1.expect)(response.status).toHaveBeenCalledWith(400);
+        (0, vitest_1.expect)(response.json).toHaveBeenCalledWith({
+            error: "Invalid payload",
+            code: "invalid_payload"
+        });
+        (0, errorResponse_1.handleRequestError)(response, (0, appError_1.notFoundError)("Missing worker", "worker_not_found"));
+        (0, vitest_1.expect)(response.status).toHaveBeenCalledWith(404);
+        (0, errorResponse_1.handleRequestError)(response, (0, appError_1.conflictError)("Worker already stopping", "worker_conflict"));
+        (0, vitest_1.expect)(response.status).toHaveBeenCalledWith(409);
+    });
+    (0, vitest_1.it)("maps malformed JSON body parse errors to validation response", () => {
+        const response = createResponseMock();
+        (0, errorResponse_1.handleRequestError)(response, { type: "entity.parse.failed" });
+        (0, vitest_1.expect)(response.status).toHaveBeenCalledWith(400);
+        (0, vitest_1.expect)(response.json).toHaveBeenCalledWith({
+            error: "Request body must be valid JSON.",
+            code: "validation_error"
+        });
+    });
+    (0, vitest_1.it)("maps unknown errors to internal server responses", () => {
+        const response = createResponseMock();
+        (0, errorResponse_1.handleRequestError)(response, new Error("boom"));
+        (0, vitest_1.expect)(response.status).toHaveBeenCalledWith(500);
+        (0, vitest_1.expect)(response.json).toHaveBeenCalledWith({
+            error: "Internal server error.",
+            code: "internal_error"
+        });
+    });
+});

package/dist/server/server/http/requestParsers.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpawnInput = parseSpawnInput;
+exports.parseBroadcastInput = parseBroadcastInput;
+const appError_1 = require("./appError");
+function parseSpawnInput(body) {
+    if (!isRecordObject(body)) {
+        throw (0, appError_1.validationError)("Spawn body must be an object.", "spawn_invalid_body");
+    }
+    const record = body;
+    const spawnNearWorkerIds = parseSpawnNearWorkerIds(record);
+    if (typeof record.shortcutIndex !== "undefined") {
+        if (typeof record.shortcutIndex !== "number" || !Number.isInteger(record.shortcutIndex) || record.shortcutIndex < 0) {
+            throw (0, appError_1.validationError)("shortcutIndex must be a non-negative integer.", "spawn_invalid_shortcut_index");
+        }
+        return {
+            shortcutIndex: record.shortcutIndex,
+            spawnNearWorkerIds
+        };
+    }
+    if (typeof record.projectId === "string" && typeof record.runtimeId === "string") {
+        const command = parseSpawnCommand(record);
+        return {
+            projectId: record.projectId,
+            runtimeId: record.runtimeId,
+            command,
+            spawnNearWorkerIds
+        };
+    }
+    throw (0, appError_1.validationError)("Invalid spawn request: expected shortcutIndex or projectId+runtimeId.", "spawn_invalid_payload");
+}
+function parseSpawnNearWorkerIds(record) {
+    if (typeof record.spawnNearWorkerIds === "undefined") {
+        return undefined;
+    }
+    if (!Array.isArray(record.spawnNearWorkerIds)) {
+        throw (0, appError_1.validationError)("spawnNearWorkerIds must be an array when provided.", "spawn_invalid_nearby_worker_ids");
+    }
+    const ids = [];
+    const seenIds = new Set();
+    for (const value of record.spawnNearWorkerIds) {
+        if (typeof value !== "string") {
+            throw (0, appError_1.validationError)("spawnNearWorkerIds must only contain strings.", "spawn_invalid_nearby_worker_ids");
+        }
+        const workerId = value.trim();
+        if (!workerId) {
+            throw (0, appError_1.validationError)("spawnNearWorkerIds must not contain empty IDs.", "spawn_invalid_nearby_worker_ids");
+        }
+        if (seenIds.has(workerId)) {
+            continue;
+        }
+        seenIds.add(workerId);
+        ids.push(workerId);
+        if (ids.length >= 32) {
+            break;
+        }
+    }
+    return ids.length > 0 ? ids : undefined;
+}
+function parseSpawnCommand(record) {
+    if (typeof record.command === "undefined") {
+        return undefined;
+    }
+    if (!Array.isArray(record.command)) {
+        throw (0, appError_1.validationError)("command must be an array of command tokens when provided.", "spawn_invalid_command");
+    }
+    if (record.command.length === 0) {
+        throw (0, appError_1.validationError)("command must include at least one token when provided.", "spawn_invalid_command");
+    }
+    const command = [];
+    for (let index = 0; index < record.command.length; index += 1) {
+        const token = record.command[index];
+        if (typeof token !== "string") {
+            throw (0, appError_1.validationError)("command must only contain strings.", "spawn_invalid_command");
+        }
+        const normalized = token.trim();
+        if (!normalized) {
+            throw (0, appError_1.validationError)("command must not include empty tokens.", "spawn_invalid_command");
+        }
+        command.push(normalized);
+    }
+    return command;
+}
+function parseBroadcastInput(body) {
+    if (!isRecordObject(body)) {
+        throw (0, appError_1.validationError)("Broadcast input body must be an object.", "broadcast_invalid_body");
+    }
+    const record = body;
+    if (!Array.isArray(record.workerIds)) {
+        throw (0, appError_1.validationError)("Broadcast input requires workerIds array.", "broadcast_invalid_worker_ids");
+    }
+    const workerIds = [];
+    const seenWorkerIds = new Set();
+    for (const value of record.workerIds) {
+        if (typeof value !== "string") {
+            throw (0, appError_1.validationError)("Broadcast workerIds must only contain strings.", "broadcast_invalid_worker_ids");
+        }
+        const workerId = value.trim();
+        if (!workerId) {
+            throw (0, appError_1.validationError)("Broadcast workerIds must not contain empty IDs.", "broadcast_invalid_worker_ids");
+        }
+        if (seenWorkerIds.has(workerId)) {
+            continue;
+        }
+        seenWorkerIds.add(workerId);
+        workerIds.push(workerId);
+    }
+    if (workerIds.length === 0) {
+        throw (0, appError_1.validationError)("Broadcast input requires at least one worker ID.", "broadcast_invalid_worker_ids");
+    }
+    if (typeof record.text !== "string") {
+        throw (0, appError_1.validationError)("Broadcast input requires text.", "broadcast_invalid_text");
+    }
+    const text = record.text;
+    if (text.length > 4096) {
+        throw (0, appError_1.validationError)("Broadcast input text is too long.", "broadcast_invalid_text");
+    }
+    if (typeof record.submit !== "undefined" && typeof record.submit !== "boolean") {
+        throw (0, appError_1.validationError)("Broadcast input submit must be boolean when provided.", "broadcast_invalid_submit");
+    }
+    const submit = record.submit ?? true;
+    if (!text.length && !submit) {
+        throw (0, appError_1.validationError)("Broadcast input requires text or submit=true.", "broadcast_invalid_payload");
+    }
+    return {
+        workerIds,
+        text,
+        submit
+    };
+}
+function isRecordObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/server/server/http/requestParsers.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const requestParsers_1 = require("./requestParsers");
+(0, vitest_1.describe)("parseSpawnInput", () => {
+    (0, vitest_1.it)("parses shortcut spawn input and sanitizes nearby worker IDs", () => {
+        const nearby = Array.from({ length: 40 }, (_, index) => `worker-${index}`);
+        const parsed = (0, requestParsers_1.parseSpawnInput)({
+            shortcutIndex: 2,
+            spawnNearWorkerIds: [...nearby, " worker-1 "]
+        });
+        (0, vitest_1.expect)(parsed).toEqual({
+            shortcutIndex: 2,
+            spawnNearWorkerIds: nearby.slice(0, 32)
+        });
+    });
+    (0, vitest_1.it)("parses project/runtime spawn input with normalized command tokens", () => {
+        const parsed = (0, requestParsers_1.parseSpawnInput)({
+            projectId: "project-a",
+            runtimeId: "shell",
+            command: [" npm ", "run", "test"]
+        });
+        (0, vitest_1.expect)(parsed).toMatchObject({
+            projectId: "project-a",
+            runtimeId: "shell",
+            command: ["npm", "run", "test"]
+        });
+        (0, vitest_1.expect)(parsed.spawnNearWorkerIds).toBeUndefined();
+    });
+    (0, vitest_1.it)("rejects malformed spawn payloads", () => {
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseSpawnInput)(null)).toThrow("Spawn body must be an object.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseSpawnInput)({ projectId: "project-a" })).toThrow("Invalid spawn request: expected shortcutIndex or projectId+runtimeId.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseSpawnInput)({ shortcutIndex: 0, spawnNearWorkerIds: "worker-1" })).toThrow("spawnNearWorkerIds must be an array when provided.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseSpawnInput)({ projectId: "project-a", runtimeId: "shell", command: ["", "test"] })).toThrow("command must not include empty tokens.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseSpawnInput)({ projectId: "project-a", runtimeId: "shell", command: ["npm", 7] })).toThrow("command must only contain strings.");
+    });
+});
+(0, vitest_1.describe)("parseBroadcastInput", () => {
+    (0, vitest_1.it)("parses and sanitizes broadcast payload", () => {
+        const parsed = (0, requestParsers_1.parseBroadcastInput)({
+            workerIds: [" w1 ", "w1", "w2"],
+            text: "hello"
+        });
+        (0, vitest_1.expect)(parsed).toEqual({
+            workerIds: ["w1", "w2"],
+            text: "hello",
+            submit: true
+        });
+    });
+    (0, vitest_1.it)("rejects invalid broadcast payloads", () => {
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseBroadcastInput)({ workerIds: "w1", text: "hello" })).toThrow("Broadcast input requires workerIds array.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseBroadcastInput)({ workerIds: ["   "], text: "hello" })).toThrow("Broadcast workerIds must not contain empty IDs.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseBroadcastInput)({ workerIds: ["w1", 9], text: "hello" })).toThrow("Broadcast workerIds must only contain strings.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseBroadcastInput)({ workerIds: ["w1"], text: "", submit: false })).toThrow("Broadcast input requires text or submit=true.");
+        (0, vitest_1.expect)(() => (0, requestParsers_1.parseBroadcastInput)({ workerIds: ["w1"], text: "x".repeat(4097) })).toThrow("Broadcast input text is too long.");
+    });
+});