arcane-agents 0.1.0

package/dist/server/server/orchestrator/spawn/command.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withClaudeSessionId = withClaudeSessionId;
+exports.looksLikeClaudeRuntime = looksLikeClaudeRuntime;
+exports.hasSessionIdArg = hasSessionIdArg;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+function withClaudeSessionId(runtimeId, command) {
+    if (!looksLikeClaudeRuntime(runtimeId, command) || hasSessionIdArg(command)) {
+        return [...command];
+    }
+    return [...command, "--session-id", (0, node_crypto_1.randomUUID)()];
+}
+function looksLikeClaudeRuntime(runtimeId, command) {
+    if (runtimeId.toLowerCase().includes("claude")) {
+        return true;
+    }
+    const binary = node_path_1.default.basename(command[0] ?? "").toLowerCase();
+    return binary.includes("claude");
+}
+function hasSessionIdArg(command) {
+    for (let index = 0; index < command.length; index += 1) {
+        const token = command[index] ?? "";
+        if (token === "--session-id") {
+            const nextValue = command[index + 1];
+            return typeof nextValue === "string" && nextValue.trim().length > 0;
+        }
+        if (token.startsWith("--session-id=")) {
+            const value = token.slice("--session-id=".length).trim();
+            return value.length > 0;
+        }
+    }
+    return false;
+}

package/dist/server/server/orchestrator/spawn/command.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const command_1 = require("./command");
+(0, vitest_1.describe)("looksLikeClaudeRuntime", () => {
+    (0, vitest_1.it)("matches runtime IDs or command binaries that look like claude", () => {
+        (0, vitest_1.expect)((0, command_1.looksLikeClaudeRuntime)("claude", ["bash"])).toBe(true);
+        (0, vitest_1.expect)((0, command_1.looksLikeClaudeRuntime)("assistant", ["/usr/local/bin/claude-code"])).toBe(true);
+        (0, vitest_1.expect)((0, command_1.looksLikeClaudeRuntime)("shell", ["bash"])).toBe(false);
+    });
+});
+(0, vitest_1.describe)("hasSessionIdArg", () => {
+    (0, vitest_1.it)("detects --session-id passed as separate or inline argument", () => {
+        (0, vitest_1.expect)((0, command_1.hasSessionIdArg)(["claude", "--session-id", "abc"])).toBe(true);
+        (0, vitest_1.expect)((0, command_1.hasSessionIdArg)(["claude", "--session-id=abc"])).toBe(true);
+        (0, vitest_1.expect)((0, command_1.hasSessionIdArg)(["claude", "--session-id"])).toBe(false);
+        (0, vitest_1.expect)((0, command_1.hasSessionIdArg)(["claude", "--session-id="])).toBe(false);
+    });
+});
+(0, vitest_1.describe)("withClaudeSessionId", () => {
+    (0, vitest_1.it)("returns an unchanged copy for non-claude commands", () => {
+        const command = ["bash", "-lc", "ls"];
+        const result = (0, command_1.withClaudeSessionId)("shell", command);
+        (0, vitest_1.expect)(result).toEqual(command);
+        (0, vitest_1.expect)(result).not.toBe(command);
+    });
+    (0, vitest_1.it)("does not append a second session id when one already exists", () => {
+        const command = ["claude", "--session-id", "existing"];
+        const result = (0, command_1.withClaudeSessionId)("claude", command);
+        (0, vitest_1.expect)(result).toEqual(command);
+    });
+    (0, vitest_1.it)("appends a generated session id for claude commands missing one", () => {
+        const result = (0, command_1.withClaudeSessionId)("claude", ["claude"]);
+        const sessionId = result[2];
+        (0, vitest_1.expect)(result[0]).toBe("claude");
+        (0, vitest_1.expect)(result[1]).toBe("--session-id");
+        (0, vitest_1.expect)(sessionId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+    });
+});

package/dist/server/server/orchestrator/spawn/resolveSpawnPlan.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSpawnPlan = resolveSpawnPlan;
+const appError_1 = require("../../http/appError");
+function resolveSpawnPlan(config, input) {
+    if ("shortcutIndex" in input) {
+        const shortcut = config.shortcuts[input.shortcutIndex];
+        if (!shortcut) {
+            throw (0, appError_1.notFoundError)(`Shortcut index '${input.shortcutIndex}' is out of range.`, "shortcut_not_found");
+        }
+        const project = config.projects[shortcut.project];
+        const runtime = config.runtimes[shortcut.runtime];
+        if (!project) {
+            throw (0, appError_1.notFoundError)(`Shortcut '${shortcut.label}' references unknown project '${shortcut.project}'.`, "project_not_found");
+        }
+        if (!runtime) {
+            throw (0, appError_1.notFoundError)(`Shortcut '${shortcut.label}' references unknown runtime '${shortcut.runtime}'.`, "runtime_not_found");
+        }
+        return {
+            projectId: shortcut.project,
+            project,
+            runtimeId: shortcut.runtime,
+            runtime,
+            command: shortcut.command ?? runtime.command,
+            displayName: shortcut.label,
+            avatar: shortcut.avatar
+        };
+    }
+    const project = config.projects[input.projectId];
+    const runtime = config.runtimes[input.runtimeId];
+    if (!project) {
+        throw (0, appError_1.notFoundError)(`Unknown project '${input.projectId}'.`, "project_not_found");
+    }
+    if (!runtime) {
+        throw (0, appError_1.notFoundError)(`Unknown runtime '${input.runtimeId}'.`, "runtime_not_found");
+    }
+    return {
+        projectId: input.projectId,
+        project,
+        runtimeId: input.runtimeId,
+        runtime,
+        command: input.command && input.command.length > 0 ? input.command : runtime.command
+    };
+}

package/dist/server/server/orchestrator/spawn/resolveSpawnPlan.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const resolveSpawnPlan_1 = require("./resolveSpawnPlan");
+function createConfig() {
+    return {
+        projects: {
+            pa: { path: "/tmp/pa", shortName: "pa" },
+            lab: { path: "/tmp/lab", shortName: "lab" }
+        },
+        runtimes: {
+            claude: { label: "Claude", command: ["claude"] },
+            shell: { label: "Shell", command: ["bash"] }
+        },
+        shortcuts: [
+            {
+                label: "PA",
+                project: "pa",
+                runtime: "claude",
+                command: ["claude", "--dangerously-skip-permissions"],
+                avatar: "wizard"
+            }
+        ],
+        discovery: [],
+        avatars: {
+            disabled: []
+        },
+        audio: {
+            enableSound: true
+        },
+        backend: {
+            tmux: {
+                sessionName: "arcane-agents",
+                pollIntervalMs: 2500
+            }
+        },
+        server: {
+            host: "127.0.0.1",
+            port: 7600
+        }
+    };
+}
+(0, vitest_1.describe)("resolveSpawnPlan", () => {
+    (0, vitest_1.it)("resolves shortcut spawn with override command and avatar", () => {
+        const config = createConfig();
+        const plan = (0, resolveSpawnPlan_1.resolveSpawnPlan)(config, { shortcutIndex: 0 });
+        (0, vitest_1.expect)(plan).toMatchObject({
+            projectId: "pa",
+            runtimeId: "claude",
+            command: ["claude", "--dangerously-skip-permissions"],
+            displayName: "PA",
+            avatar: "wizard"
+        });
+    });
+    (0, vitest_1.it)("uses runtime command for direct spawn when command is empty", () => {
+        const config = createConfig();
+        const plan = (0, resolveSpawnPlan_1.resolveSpawnPlan)(config, {
+            projectId: "lab",
+            runtimeId: "shell",
+            command: []
+        });
+        (0, vitest_1.expect)(plan.command).toEqual(["bash"]);
+    });
+    (0, vitest_1.it)("uses provided command for direct spawn when non-empty", () => {
+        const config = createConfig();
+        const plan = (0, resolveSpawnPlan_1.resolveSpawnPlan)(config, {
+            projectId: "lab",
+            runtimeId: "shell",
+            command: ["npm", "test"]
+        });
+        (0, vitest_1.expect)(plan.command).toEqual(["npm", "test"]);
+    });
+    (0, vitest_1.it)("throws helpful errors for unknown shortcut/project/runtime references", () => {
+        const config = createConfig();
+        (0, vitest_1.expect)(() => (0, resolveSpawnPlan_1.resolveSpawnPlan)(config, { shortcutIndex: 99 })).toThrow("Shortcut index '99' is out of range.");
+        (0, vitest_1.expect)(() => (0, resolveSpawnPlan_1.resolveSpawnPlan)(config, { projectId: "missing", runtimeId: "shell" })).toThrow("Unknown project 'missing'.");
+        (0, vitest_1.expect)(() => (0, resolveSpawnPlan_1.resolveSpawnPlan)(config, { projectId: "pa", runtimeId: "missing" })).toThrow("Unknown runtime 'missing'.");
+    });
+});

package/dist/server/server/orchestrator/spawn/spawnPosition.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOutpostSpawnSpec = loadOutpostSpawnSpec;
+exports.nextSpawnPosition = nextSpawnPosition;
+exports.isSpawnPositionFree = isSpawnPositionFree;
+const node_fs_1 = __importDefault(require("node:fs"));
+const appRoot_1 = require("../../utils/appRoot");
+const defaultSpawnSeparationDistancePx = 52;
+function loadOutpostSpawnSpec(mapPath = (0, appRoot_1.resolveAppPath)("assets", "maps", "outpost.json")) {
+    if (!node_fs_1.default.existsSync(mapPath)) {
+        return undefined;
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(mapPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.tileSize !== "number") {
+            return undefined;
+        }
+        return {
+            width: typeof parsed.width === "number" ? parsed.width : undefined,
+            height: typeof parsed.height === "number" ? parsed.height : undefined,
+            tileSize: parsed.tileSize,
+            spawnArea: parsed.spawnArea
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function nextSpawnPosition({ activeWorkers, spec, spawnSeparationDistancePx, anchorPositions }) {
+    const separation = spawnSeparationDistancePx ?? defaultSpawnSeparationDistancePx;
+    const anchoredCandidate = nextSpawnPositionNearAnchors(anchorPositions, activeWorkers, spec, separation);
+    if (anchoredCandidate) {
+        return anchoredCandidate;
+    }
+    const index = activeWorkers.length;
+    if (spec?.spawnArea) {
+        const { tileSize, spawnArea } = spec;
+        const areaWidth = Math.max(1, spawnArea.x2 - spawnArea.x1 + 1);
+        const areaHeight = Math.max(1, spawnArea.y2 - spawnArea.y1 + 1);
+        const totalTiles = areaWidth * areaHeight;
+        const startTileIndex = index % totalTiles;
+        for (let step = 0; step < totalTiles; step += 1) {
+            const tileIndex = (startTileIndex + step) % totalTiles;
+            const tileOffsetX = tileIndex % areaWidth;
+            const tileOffsetY = Math.floor(tileIndex / areaWidth);
+            const tileX = spawnArea.x1 + tileOffsetX;
+            const tileY = spawnArea.y1 + tileOffsetY;
+            const candidate = {
+                x: (tileX + 0.5) * tileSize,
+                y: (tileY + 0.5) * tileSize
+            };
+            if (isSpawnPositionFree(candidate, activeWorkers, separation)) {
+                return candidate;
+            }
+        }
+        const fallbackOffsetX = startTileIndex % areaWidth;
+        const fallbackOffsetY = Math.floor(startTileIndex / areaWidth);
+        return {
+            x: (spawnArea.x1 + fallbackOffsetX + 0.5) * tileSize,
+            y: (spawnArea.y1 + fallbackOffsetY + 0.5) * tileSize
+        };
+    }
+    const ringSize = 6;
+    const ring = Math.floor(index / ringSize);
+    const angle = (index % ringSize) * ((Math.PI * 2) / ringSize);
+    const radius = 110 + ring * 85;
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        const adjustedRadius = radius + attempt * 36;
+        const adjustedAngle = angle + attempt * 0.32;
+        const candidate = {
+            x: 520 + Math.cos(adjustedAngle) * adjustedRadius,
+            y: 310 + Math.sin(adjustedAngle) * adjustedRadius
+        };
+        if (isSpawnPositionFree(candidate, activeWorkers, separation)) {
+            return candidate;
+        }
+    }
+    return {
+        x: 520 + Math.cos(angle) * radius,
+        y: 310 + Math.sin(angle) * radius
+    };
+}
+function nextSpawnPositionNearAnchors(anchorPositions, activeWorkers, spec, separation) {
+    if (!anchorPositions || anchorPositions.length === 0) {
+        return undefined;
+    }
+    const center = averagePosition(anchorPositions);
+    const phaseSeed = activeWorkers.length * 0.37;
+    const radialDistances = [
+        Math.max(24, separation * 0.8),
+        Math.max(36, separation * 1.15),
+        Math.max(48, separation * 1.5)
+    ];
+    const candidates = [center];
+    for (const distance of radialDistances) {
+        for (let index = 0; index < 12; index += 1) {
+            const angle = phaseSeed + (index / 12) * Math.PI * 2;
+            candidates.push({
+                x: center.x + Math.cos(angle) * distance,
+                y: center.y + Math.sin(angle) * distance
+            });
+        }
+    }
+    for (const candidate of candidates) {
+        const normalized = clampToMapBounds(candidate, spec);
+        if (isSpawnPositionFree(normalized, activeWorkers, separation)) {
+            return normalized;
+        }
+    }
+    return clampToMapBounds(center, spec);
+}
+function averagePosition(positions) {
+    if (positions.length === 0) {
+        return { x: 520, y: 310 };
+    }
+    let xSum = 0;
+    let ySum = 0;
+    for (const position of positions) {
+        xSum += position.x;
+        ySum += position.y;
+    }
+    return {
+        x: xSum / positions.length,
+        y: ySum / positions.length
+    };
+}
+function clampToMapBounds(candidate, spec) {
+    if (!spec || typeof spec.width !== "number" || typeof spec.height !== "number") {
+        return candidate;
+    }
+    const mapWidth = spec.width * spec.tileSize;
+    const mapHeight = spec.height * spec.tileSize;
+    const margin = Math.max(14, spec.tileSize * 0.45);
+    return {
+        x: Math.min(Math.max(candidate.x, margin), mapWidth - margin),
+        y: Math.min(Math.max(candidate.y, margin), mapHeight - margin)
+    };
+}
+function isSpawnPositionFree(candidate, workers, minDistance) {
+    return workers.every((worker) => {
+        return Math.hypot(candidate.x - worker.position.x, candidate.y - worker.position.y) >= minDistance;
+    });
+}

package/dist/server/server/orchestrator/spawn/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/server/orchestrator/spawn/windowName.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeWindowName = makeWindowName;
+exports.slugify = slugify;
+function makeWindowName(projectShortName, runtimeId, shortId) {
+    const sanitize = (value) => value.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    return `${sanitize(projectShortName)}-${sanitize(runtimeId)}-${sanitize(shortId)}`;
+}
+function slugify(value) {
+    const slug = value.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/(^-|-$)/g, "");
+    return slug || "project";
+}

package/dist/server/server/persistence/workerRepository.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerRepository = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class WorkerRepository {
+    db;
+    constructor(dbPath) {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(dbPath), { recursive: true });
+        this.db = new better_sqlite3_1.default(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.init();
+    }
+    listWorkers() {
+        const rows = this.db
+            .prepare("SELECT * FROM workers ORDER BY datetime(created_at) ASC")
+            .all();
+        return rows.map((row) => this.fromRow(row));
+    }
+    getWorker(workerId) {
+        const row = this.db.prepare("SELECT * FROM workers WHERE id = ?").get(workerId);
+        return row ? this.fromRow(row) : undefined;
+    }
+    saveWorker(worker) {
+        this.db
+            .prepare(`
+        INSERT INTO workers (
+          id, name, display_name, project_id, project_path, runtime_id, runtime_label,
+          command_json, status, activity_text, activity_tool, activity_path, avatar_type, movement_mode,
+          position_x, position_y, tmux_session, tmux_window, tmux_pane,
+          created_at, updated_at
+        ) VALUES (
+          @id, @name, @display_name, @project_id, @project_path, @runtime_id, @runtime_label,
+          @command_json, @status, @activity_text, @activity_tool, @activity_path, @avatar_type, @movement_mode,
+          @position_x, @position_y, @tmux_session, @tmux_window, @tmux_pane,
+          @created_at, @updated_at
+        )
+        ON CONFLICT(id) DO UPDATE SET
+          name = excluded.name,
+          display_name = excluded.display_name,
+          project_id = excluded.project_id,
+          project_path = excluded.project_path,
+          runtime_id = excluded.runtime_id,
+          runtime_label = excluded.runtime_label,
+          command_json = excluded.command_json,
+          status = excluded.status,
+          activity_text = excluded.activity_text,
+          activity_tool = excluded.activity_tool,
+          activity_path = excluded.activity_path,
+          avatar_type = excluded.avatar_type,
+          movement_mode = excluded.movement_mode,
+          position_x = excluded.position_x,
+          position_y = excluded.position_y,
+          tmux_session = excluded.tmux_session,
+          tmux_window = excluded.tmux_window,
+          tmux_pane = excluded.tmux_pane,
+          updated_at = excluded.updated_at
+      `)
+            .run(this.toRow(worker));
+    }
+    updateStatus(workerId, update) {
+        const worker = this.getWorker(workerId);
+        if (!worker) {
+            return undefined;
+        }
+        const updated = {
+            ...worker,
+            status: update.status,
+            activityText: update.activityText,
+            activityTool: update.activityTool,
+            activityPath: update.activityPath,
+            updatedAt: new Date().toISOString()
+        };
+        this.saveWorker(updated);
+        return updated;
+    }
+    updatePosition(workerId, position) {
+        const worker = this.getWorker(workerId);
+        if (!worker) {
+            return undefined;
+        }
+        const updated = {
+            ...worker,
+            position,
+            updatedAt: new Date().toISOString()
+        };
+        this.saveWorker(updated);
+        return updated;
+    }
+    updateMovementMode(workerId, movementMode) {
+        const worker = this.getWorker(workerId);
+        if (!worker) {
+            return undefined;
+        }
+        const updated = {
+            ...worker,
+            movementMode,
+            updatedAt: new Date().toISOString()
+        };
+        this.saveWorker(updated);
+        return updated;
+    }
+    deleteWorker(workerId) {
+        const result = this.db.prepare("DELETE FROM workers WHERE id = ?").run(workerId);
+        return result.changes > 0;
+    }
+    close() {
+        this.db.close();
+    }
+    init() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS workers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        display_name TEXT,
+        project_id TEXT NOT NULL,
+        project_path TEXT NOT NULL,
+        runtime_id TEXT NOT NULL,
+        runtime_label TEXT NOT NULL,
+        command_json TEXT NOT NULL,
+        status TEXT NOT NULL,
+        activity_text TEXT,
+        activity_tool TEXT,
+        activity_path TEXT,
+        avatar_type TEXT NOT NULL,
+        movement_mode TEXT,
+        position_x REAL NOT NULL,
+        position_y REAL NOT NULL,
+        tmux_session TEXT NOT NULL,
+        tmux_window TEXT NOT NULL,
+        tmux_pane TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_workers_status ON workers(status);
+      CREATE INDEX IF NOT EXISTS idx_workers_tmux ON workers(tmux_session, tmux_window);
+    `);
+        this.ensureColumn("workers", "activity_tool", "TEXT");
+        this.ensureColumn("workers", "activity_path", "TEXT");
+        this.ensureColumn("workers", "display_name", "TEXT");
+        this.ensureColumn("workers", "movement_mode", "TEXT");
+    }
+    fromRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            displayName: row.display_name ?? undefined,
+            projectId: row.project_id,
+            projectPath: row.project_path,
+            runtimeId: row.runtime_id,
+            runtimeLabel: row.runtime_label,
+            command: JSON.parse(row.command_json),
+            status: row.status,
+            activityText: row.activity_text ?? undefined,
+            activityTool: row.activity_tool ?? undefined,
+            activityPath: row.activity_path ?? undefined,
+            avatarType: row.avatar_type,
+            movementMode: row.movement_mode === "wander" ? "wander" : "hold",
+            position: {
+                x: row.position_x,
+                y: row.position_y
+            },
+            tmuxRef: {
+                session: row.tmux_session,
+                window: row.tmux_window,
+                pane: row.tmux_pane
+            },
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+    toRow(worker) {
+        return {
+            id: worker.id,
+            name: worker.name,
+            display_name: worker.displayName ?? null,
+            project_id: worker.projectId,
+            project_path: worker.projectPath,
+            runtime_id: worker.runtimeId,
+            runtime_label: worker.runtimeLabel,
+            command_json: JSON.stringify(worker.command),
+            status: worker.status,
+            activity_text: worker.activityText ?? null,
+            activity_tool: worker.activityTool ?? null,
+            activity_path: worker.activityPath ?? null,
+            avatar_type: worker.avatarType,
+            movement_mode: worker.movementMode,
+            position_x: worker.position.x,
+            position_y: worker.position.y,
+            tmux_session: worker.tmuxRef.session,
+            tmux_window: worker.tmuxRef.window,
+            tmux_pane: worker.tmuxRef.pane,
+            created_at: worker.createdAt,
+            updated_at: worker.updatedAt
+        };
+    }
+    ensureColumn(tableName, columnName, type) {
+        try {
+            this.db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${type}`);
+        }
+        catch {
+            // column already exists
+        }
+    }
+}
+exports.WorkerRepository = WorkerRepository;