teslacode.dev 1.0.0

package/dist/control.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOsControl = void 0;
+exports.execOsControl = execOsControl;
+const node_child_process_1 = require("node:child_process");
+function execOsControl(msg) {
+    if (!msg || typeof msg !== "object")
+        return;
+    const m = msg;
+    if (m.type === "key") {
+        if (m.key === "space") {
+            try {
+                (0, node_child_process_1.execSync)("osascript", { input: 'tell application "System Events" to keystroke " "' });
+            }
+            catch (err) {
+                console.log("[teslacode.dev] osascript failed:", "Accessibility permission required? Check System Settings → Privacy & Security → Accessibility. Error: " + String(err));
+            }
+        }
+        else if (m.key === "enter") {
+            try {
+                (0, node_child_process_1.execSync)("osascript", { input: 'tell application "System Events" to keystroke return' });
+            }
+            catch (err) {
+                console.log("[teslacode.dev] osascript failed:", "Accessibility permission required? Check System Settings → Privacy & Security → Accessibility. Error: " + String(err));
+            }
+        }
+    }
+}
+exports.defaultOsControl = {
+    execute: execOsControl,
+};

package/dist/control.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_child_process_1 = require("node:child_process");
+vitest_1.vi.mock("node:child_process", () => ({
+    execSync: vitest_1.vi.fn(),
+}));
+const control_js_1 = require("./control.js");
+(0, vitest_1.beforeEach)(() => {
+    vitest_1.vi.mocked(node_child_process_1.execSync).mockReset();
+});
+(0, vitest_1.describe)("execOsControl — key", () => {
+    (0, vitest_1.it)("dispatches osascript for space key", () => {
+        (0, control_js_1.execOsControl)({ type: "key", key: "space" });
+        (0, vitest_1.expect)(node_child_process_1.execSync).toHaveBeenCalledOnce();
+        const [cmd] = vitest_1.vi.mocked(node_child_process_1.execSync).mock.calls[0];
+        (0, vitest_1.expect)(cmd).toBe("osascript");
+        const opts = vitest_1.vi.mocked(node_child_process_1.execSync).mock.calls[0][1];
+        (0, vitest_1.expect)(opts.input).toContain('keystroke " "');
+    });
+    (0, vitest_1.it)("dispatches osascript for enter key", () => {
+        (0, control_js_1.execOsControl)({ type: "key", key: "enter" });
+        (0, vitest_1.expect)(node_child_process_1.execSync).toHaveBeenCalledOnce();
+        const [cmd] = vitest_1.vi.mocked(node_child_process_1.execSync).mock.calls[0];
+        (0, vitest_1.expect)(cmd).toBe("osascript");
+        const opts = vitest_1.vi.mocked(node_child_process_1.execSync).mock.calls[0][1];
+        (0, vitest_1.expect)(opts.input).toContain("keystroke return");
+    });
+});
+(0, vitest_1.describe)("execOsControl — no-ops", () => {
+    (0, vitest_1.it)("unknown key is a no-op", () => {
+        (0, control_js_1.execOsControl)({ type: "key", key: "tab" });
+        (0, vitest_1.expect)(node_child_process_1.execSync).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("non-object input is a no-op", () => {
+        (0, control_js_1.execOsControl)("space");
+        (0, vitest_1.expect)(node_child_process_1.execSync).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("null is a no-op", () => {
+        (0, control_js_1.execOsControl)(null);
+        (0, vitest_1.expect)(node_child_process_1.execSync).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("unknown type is a no-op", () => {
+        (0, control_js_1.execOsControl)({ type: "click", x: 100, y: 200 });
+        (0, vitest_1.expect)(node_child_process_1.execSync).not.toHaveBeenCalled();
+    });
+});
+(0, vitest_1.describe)("execOsControl — error handling", () => {
+    (0, vitest_1.it)("logs human-readable error when osascript exits non-zero", () => {
+        vitest_1.vi.mocked(node_child_process_1.execSync).mockImplementation(() => {
+            throw new Error("Command failed: osascript exit code 1");
+        });
+        const consoleSpy = vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+        (0, control_js_1.execOsControl)({ type: "key", key: "space" });
+        (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("[teslacode.dev]"), vitest_1.expect.stringContaining("Accessibility"));
+        consoleSpy.mockRestore();
+    });
+});

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_js_1 = require("./server.js");
+const control_js_1 = require("./control.js");
+const PORT = parseInt(process.env["TESLACODE_PORT"] ?? "27184", 10);
+const server = (0, server_js_1.createDaemonServer)(PORT, control_js_1.defaultOsControl);
+server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+        console.error(`[teslacode.dev] daemon already running on port ${PORT} — exiting`);
+    }
+    else {
+        console.error("[teslacode.dev] server error:", err.message);
+    }
+    process.exit(1);
+});
+server.listen(PORT, "127.0.0.1", () => {
+    console.log(`[teslacode.dev] running on http://localhost:${PORT}`);
+    console.log("[teslacode.dev] Reminder: grant Accessibility permission in System Settings → Privacy & Security → Accessibility");
+});

package/dist/server.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDaemonServer = createDaemonServer;
+const http = __importStar(require("node:http"));
+const VERSION = "1.0.0";
+function setCors(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+function json(res, status, body) {
+    setCors(res);
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+        req.on("error", reject);
+    });
+}
+function createDaemonServer(port, osControl) {
+    const server = http.createServer(async (req, res) => {
+        if (req.method === "OPTIONS") {
+            setCors(res);
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method === "GET" && req.url === "/health") {
+            json(res, 200, { ok: true, version: VERSION });
+            return;
+        }
+        if (req.method === "POST" && req.url === "/control") {
+            let body;
+            try {
+                body = await readBody(req);
+            }
+            catch {
+                json(res, 500, { ok: false, error: "failed to read body" });
+                return;
+            }
+            let msg;
+            try {
+                msg = JSON.parse(body);
+            }
+            catch {
+                json(res, 400, { ok: false, error: "invalid message" });
+                return;
+            }
+            if (msg && typeof msg === "object" && msg.type === "key") {
+                osControl.execute(msg);
+            }
+            json(res, 200, { ok: true });
+            return;
+        }
+        json(res, 404, { ok: false, error: "not found" });
+    });
+    return server;
+}

package/dist/server.test.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Import server after mocking (stubs replaced during T009)
+let createDaemonServer;
+async function loadServer() {
+    const mod = await Promise.resolve().then(() => __importStar(require("./server.js")));
+    createDaemonServer = mod.createDaemonServer;
+}
+function makeOsControl() {
+    return { execute: vitest_1.vi.fn() };
+}
+async function startServer(osControl) {
+    await loadServer();
+    const server = createDaemonServer(0, osControl);
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const addr = server.address();
+    return { server, port: addr.port };
+}
+async function stopServer(server) {
+    await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+}
+async function req(port, method, path, body) {
+    const bodyStr = body !== undefined ? JSON.stringify(body) : undefined;
+    const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+        method,
+        headers: body !== undefined ? { "Content-Type": "application/json" } : {},
+        body: bodyStr,
+    });
+    let json;
+    try {
+        json = await res.json();
+    }
+    catch {
+        json = null;
+    }
+    return {
+        status: res.status,
+        headers: Object.fromEntries(res.headers.entries()),
+        json,
+    };
+}
+(0, vitest_1.describe)("GET /health", () => {
+    let server;
+    let port;
+    (0, vitest_1.beforeEach)(async () => {
+        const result = await startServer(makeOsControl());
+        server = result.server;
+        port = result.port;
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await stopServer(server);
+    });
+    (0, vitest_1.it)("returns 200 with { ok: true, version }", async () => {
+        const r = await req(port, "GET", "/health");
+        (0, vitest_1.expect)(r.status).toBe(200);
+        (0, vitest_1.expect)(r.json.ok).toBe(true);
+        (0, vitest_1.expect)(typeof r.json.version).toBe("string");
+    });
+    (0, vitest_1.it)("includes Access-Control-Allow-Origin: * header", async () => {
+        const r = await req(port, "GET", "/health");
+        (0, vitest_1.expect)(r.headers["access-control-allow-origin"]).toBe("*");
+    });
+});
+(0, vitest_1.describe)("POST /control", () => {
+    let server;
+    let port;
+    let osControl;
+    (0, vitest_1.beforeEach)(async () => {
+        osControl = makeOsControl();
+        const result = await startServer(osControl);
+        server = result.server;
+        port = result.port;
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await stopServer(server);
+    });
+    (0, vitest_1.it)("calls OsControl.execute once for { type: 'key', key: 'space' }", async () => {
+        const r = await req(port, "POST", "/control", { type: "key", key: "space" });
+        (0, vitest_1.expect)(r.status).toBe(200);
+        (0, vitest_1.expect)(osControl.execute).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(osControl.execute).toHaveBeenCalledWith({ type: "key", key: "space" });
+    });
+    (0, vitest_1.it)("calls OsControl.execute once for { type: 'key', key: 'enter' }", async () => {
+        const r = await req(port, "POST", "/control", { type: "key", key: "enter" });
+        (0, vitest_1.expect)(r.status).toBe(200);
+        (0, vitest_1.expect)(osControl.execute).toHaveBeenCalledOnce();
+    });
+    (0, vitest_1.it)("returns 400 for malformed body", async () => {
+        const res = await fetch(`http://127.0.0.1:${port}/control`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: "not-json{",
+        });
+        (0, vitest_1.expect)(res.status).toBe(400);
+        const json = await res.json();
+        (0, vitest_1.expect)(json.ok).toBe(false);
+        (0, vitest_1.expect)(typeof json.error).toBe("string");
+    });
+    (0, vitest_1.it)("returns 200 and silently drops unknown type", async () => {
+        const r = await req(port, "POST", "/control", { type: "hover", x: 100, y: 200 });
+        (0, vitest_1.expect)(r.status).toBe(200);
+        (0, vitest_1.expect)(osControl.execute).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("includes Access-Control-Allow-Origin: * on all responses", async () => {
+        const r = await req(port, "POST", "/control", { type: "key", key: "space" });
+        (0, vitest_1.expect)(r.headers["access-control-allow-origin"]).toBe("*");
+    });
+});

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "teslacode.dev",
+  "version": "1.0.0",
+  "description": "Local control daemon for Tesla Screen Share",
+  "bin": {
+    "teslacode.dev": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  }
+}

package/src/control.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { execSync } from "node:child_process";
+
+vi.mock("node:child_process", () => ({
+  execSync: vi.fn(),
+}));
+
+import { execOsControl } from "./control.js";
+
+beforeEach(() => {
+  vi.mocked(execSync).mockReset();
+});
+
+describe("execOsControl — key", () => {
+  it("dispatches osascript for space key", () => {
+    execOsControl({ type: "key", key: "space" });
+    expect(execSync).toHaveBeenCalledOnce();
+    const [cmd] = vi.mocked(execSync).mock.calls[0];
+    expect(cmd).toBe("osascript");
+    const opts = vi.mocked(execSync).mock.calls[0][1] as { input: string };
+    expect(opts.input).toContain('keystroke " "');
+  });
+
+  it("dispatches osascript for enter key", () => {
+    execOsControl({ type: "key", key: "enter" });
+    expect(execSync).toHaveBeenCalledOnce();
+    const [cmd] = vi.mocked(execSync).mock.calls[0];
+    expect(cmd).toBe("osascript");
+    const opts = vi.mocked(execSync).mock.calls[0][1] as { input: string };
+    expect(opts.input).toContain("keystroke return");
+  });
+});
+
+describe("execOsControl — no-ops", () => {
+  it("unknown key is a no-op", () => {
+    execOsControl({ type: "key", key: "tab" });
+    expect(execSync).not.toHaveBeenCalled();
+  });
+
+  it("non-object input is a no-op", () => {
+    execOsControl("space");
+    expect(execSync).not.toHaveBeenCalled();
+  });
+
+  it("null is a no-op", () => {
+    execOsControl(null);
+    expect(execSync).not.toHaveBeenCalled();
+  });
+
+  it("unknown type is a no-op", () => {
+    execOsControl({ type: "click", x: 100, y: 200 });
+    expect(execSync).not.toHaveBeenCalled();
+  });
+});
+
+describe("execOsControl — error handling", () => {
+  it("logs human-readable error when osascript exits non-zero", () => {
+    vi.mocked(execSync).mockImplementation(() => {
+      throw new Error("Command failed: osascript exit code 1");
+    });
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    execOsControl({ type: "key", key: "space" });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[teslacode.dev]"),
+      expect.stringContaining("Accessibility"),
+    );
+    consoleSpy.mockRestore();
+  });
+});

package/src/control.ts

@@ -0,0 +1,32 @@
+import { execSync } from "node:child_process";
+
+export type ControlMessage = { type: "key"; key: "space" | "enter" };
+
+export interface OsControl {
+  execute(msg: unknown): void;
+}
+
+export function execOsControl(msg: unknown): void {
+  if (!msg || typeof msg !== "object") return;
+  const m = msg as Record<string, unknown>;
+
+  if (m.type === "key") {
+    if (m.key === "space") {
+      try {
+        execSync("osascript", { input: 'tell application "System Events" to keystroke " "' });
+      } catch (err) {
+        console.log("[teslacode.dev] osascript failed:", "Accessibility permission required? Check System Settings → Privacy & Security → Accessibility. Error: " + String(err));
+      }
+    } else if (m.key === "enter") {
+      try {
+        execSync("osascript", { input: 'tell application "System Events" to keystroke return' });
+      } catch (err) {
+        console.log("[teslacode.dev] osascript failed:", "Accessibility permission required? Check System Settings → Privacy & Security → Accessibility. Error: " + String(err));
+      }
+    }
+  }
+}
+
+export const defaultOsControl: OsControl = {
+  execute: execOsControl,
+};

package/src/index.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { createDaemonServer } from "./server.js";
+import { defaultOsControl } from "./control.js";
+
+const PORT = parseInt(process.env["TESLACODE_PORT"] ?? "27184", 10);
+
+const server = createDaemonServer(PORT, defaultOsControl);
+
+server.on("error", (err: NodeJS.ErrnoException) => {
+  if (err.code === "EADDRINUSE") {
+    console.error(`[teslacode.dev] daemon already running on port ${PORT} — exiting`);
+  } else {
+    console.error("[teslacode.dev] server error:", err.message);
+  }
+  process.exit(1);
+});
+
+server.listen(PORT, "127.0.0.1", () => {
+  console.log(`[teslacode.dev] running on http://localhost:${PORT}`);
+  console.log("[teslacode.dev] Reminder: grant Accessibility permission in System Settings → Privacy & Security → Accessibility");
+});

package/src/server.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as http from "node:http";
+import type { OsControl } from "./control.js";
+
+// Import server after mocking (stubs replaced during T009)
+let createDaemonServer: (port: number, osControl: OsControl) => http.Server;
+
+async function loadServer() {
+  const mod = await import("./server.js");
+  createDaemonServer = mod.createDaemonServer;
+}
+
+function makeOsControl(): OsControl & { execute: ReturnType<typeof vi.fn> } {
+  return { execute: vi.fn() };
+}
+
+async function startServer(osControl: OsControl): Promise<{ server: http.Server; port: number }> {
+  await loadServer();
+  const server = createDaemonServer(0, osControl);
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const addr = server.address() as { port: number };
+  return { server, port: addr.port };
+}
+
+async function stopServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+}
+
+async function req(port: number, method: string, path: string, body?: unknown): Promise<{ status: number; headers: Record<string, string | string[] | undefined>; json: unknown }> {
+  const bodyStr = body !== undefined ? JSON.stringify(body) : undefined;
+  const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+    method,
+    headers: body !== undefined ? { "Content-Type": "application/json" } : {},
+    body: bodyStr,
+  });
+  let json: unknown;
+  try { json = await res.json(); } catch { json = null; }
+  return {
+    status: res.status,
+    headers: Object.fromEntries(res.headers.entries()),
+    json,
+  };
+}
+
+describe("GET /health", () => {
+  let server: http.Server;
+  let port: number;
+
+  beforeEach(async () => {
+    const result = await startServer(makeOsControl());
+    server = result.server;
+    port = result.port;
+  });
+
+  afterEach(async () => {
+    await stopServer(server);
+  });
+
+  it("returns 200 with { ok: true, version }", async () => {
+    const r = await req(port, "GET", "/health");
+    expect(r.status).toBe(200);
+    expect((r.json as Record<string, unknown>).ok).toBe(true);
+    expect(typeof (r.json as Record<string, unknown>).version).toBe("string");
+  });
+
+  it("includes Access-Control-Allow-Origin: * header", async () => {
+    const r = await req(port, "GET", "/health");
+    expect(r.headers["access-control-allow-origin"]).toBe("*");
+  });
+});
+
+describe("POST /control", () => {
+  let server: http.Server;
+  let port: number;
+  let osControl: OsControl & { execute: ReturnType<typeof vi.fn> };
+
+  beforeEach(async () => {
+    osControl = makeOsControl();
+    const result = await startServer(osControl);
+    server = result.server;
+    port = result.port;
+  });
+
+  afterEach(async () => {
+    await stopServer(server);
+  });
+
+  it("calls OsControl.execute once for { type: 'key', key: 'space' }", async () => {
+    const r = await req(port, "POST", "/control", { type: "key", key: "space" });
+    expect(r.status).toBe(200);
+    expect(osControl.execute).toHaveBeenCalledOnce();
+    expect(osControl.execute).toHaveBeenCalledWith({ type: "key", key: "space" });
+  });
+
+  it("calls OsControl.execute once for { type: 'key', key: 'enter' }", async () => {
+    const r = await req(port, "POST", "/control", { type: "key", key: "enter" });
+    expect(r.status).toBe(200);
+    expect(osControl.execute).toHaveBeenCalledOnce();
+  });
+
+  it("returns 400 for malformed body", async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/control`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "not-json{",
+    });
+    expect(res.status).toBe(400);
+    const json = await res.json() as Record<string, unknown>;
+    expect(json.ok).toBe(false);
+    expect(typeof json.error).toBe("string");
+  });
+
+  it("returns 200 and silently drops unknown type", async () => {
+    const r = await req(port, "POST", "/control", { type: "hover", x: 100, y: 200 });
+    expect(r.status).toBe(200);
+    expect(osControl.execute).not.toHaveBeenCalled();
+  });
+
+  it("includes Access-Control-Allow-Origin: * on all responses", async () => {
+    const r = await req(port, "POST", "/control", { type: "key", key: "space" });
+    expect(r.headers["access-control-allow-origin"]).toBe("*");
+  });
+});

package/src/server.ts

@@ -0,0 +1,70 @@
+import * as http from "node:http";
+import type { OsControl } from "./control.js";
+
+const VERSION = "1.0.0";
+
+function setCors(res: http.ServerResponse): void {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+
+function json(res: http.ServerResponse, status: number, body: unknown): void {
+  setCors(res);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+function readBody(req: http.IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk: Buffer) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+
+export function createDaemonServer(port: number, osControl: OsControl): http.Server {
+  const server = http.createServer(async (req, res) => {
+    if (req.method === "OPTIONS") {
+      setCors(res);
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (req.method === "GET" && req.url === "/health") {
+      json(res, 200, { ok: true, version: VERSION });
+      return;
+    }
+
+    if (req.method === "POST" && req.url === "/control") {
+      let body: string;
+      try {
+        body = await readBody(req);
+      } catch {
+        json(res, 500, { ok: false, error: "failed to read body" });
+        return;
+      }
+
+      let msg: unknown;
+      try {
+        msg = JSON.parse(body);
+      } catch {
+        json(res, 400, { ok: false, error: "invalid message" });
+        return;
+      }
+
+      if (msg && typeof msg === "object" && (msg as Record<string, unknown>).type === "key") {
+        osControl.execute(msg);
+      }
+
+      json(res, 200, { ok: true });
+      return;
+    }
+
+    json(res, 404, { ok: false, error: "not found" });
+  });
+
+  return server;
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+  },
+});