walkietalkiebot 0.3.0

package/server/index.js

@@ -0,0 +1,137 @@
+import { Hono } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { createServer as createHttpsServer } from "https";
+import { readFileSync, existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { getSSLCerts } from "./ssl.js";
+import { api } from "./api.js";
+import { initDb, closeDb } from "./db/index.js";
+import { startTelegramBot, stopTelegramBot } from "./telegram/index.js";
+import { getNotificationDispatcher } from "./notifications/dispatcher.js";
+import { MacOSNotificationChannel } from "./notifications/macos.js";
+import { getJobManager } from "./jobs/manager.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const distPath = join(__dirname, "..", "dist");
+let server = null;
+function startServer(port = 5173) {
+  return new Promise((resolve, reject) => {
+    if (!existsSync(distPath)) {
+      reject(new Error(`dist/ not found at ${distPath}. Run 'npm run build' first.`));
+      return;
+    }
+    try {
+      initDb();
+    } catch (err) {
+      console.error("Failed to initialize database:", err);
+      reject(err);
+      return;
+    }
+    const dispatcher = getNotificationDispatcher();
+    dispatcher.register(new MacOSNotificationChannel());
+    const jobManager = getJobManager();
+    jobManager.init();
+    startTelegramBot().catch((err) => {
+      console.log("Telegram bot not started:", err.message);
+    });
+    const app = new Hono();
+    app.route("/api", api);
+    app.use("/*", serveStatic({ root: distPath.replace(process.cwd(), ".") }));
+    app.get("*", (c) => {
+      const indexPath = join(distPath, "index.html");
+      if (existsSync(indexPath)) {
+        const html = readFileSync(indexPath, "utf-8");
+        return c.html(html);
+      }
+      return c.text("Not found", 404);
+    });
+    const certs = getSSLCerts();
+    const serverOptions = {
+      key: certs.key,
+      cert: certs.cert
+    };
+    server = createHttpsServer(serverOptions, async (req, res) => {
+      const url = new URL(req.url || "/", `https://localhost:${port}`);
+      const headers = new Headers();
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value) {
+          if (Array.isArray(value)) {
+            value.forEach((v) => headers.append(key, v));
+          } else {
+            headers.set(key, value);
+          }
+        }
+      }
+      let body = null;
+      if (req.method && ["POST", "PUT", "PATCH"].includes(req.method)) {
+        const chunks = [];
+        for await (const chunk of req) {
+          chunks.push(chunk);
+        }
+        body = Buffer.concat(chunks);
+      }
+      const request = new Request(url.toString(), {
+        method: req.method || "GET",
+        headers,
+        body,
+        // @ts-expect-error - Node.js specific
+        duplex: "half"
+      });
+      const response = await app.fetch(request);
+      res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+      if (response.body) {
+        const reader = response.body.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            res.write(value);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      res.end();
+    });
+    server.listen(port, () => {
+      console.log(`Talkie server running at https://localhost:${port}`);
+      resolve();
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use`));
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+async function stopServer() {
+  stopTelegramBot();
+  closeDb();
+  if (server) {
+    await new Promise((resolve) => {
+      server.close(() => resolve());
+    });
+    server = null;
+  }
+}
+function setupShutdownHandlers() {
+  const shutdown = async (signal) => {
+    console.log(`
+Received ${signal}, shutting down gracefully...`);
+    await stopServer();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  setupShutdownHandlers();
+  const port = parseInt(process.env.PORT || "5173", 10);
+  startServer(port).catch(console.error);
+}
+export {
+  startServer,
+  stopServer
+};

package/server/jobs/api.js

@@ -0,0 +1,108 @@
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { getJobManager } from "./manager.js";
+const jobRoutes = new Hono();
+jobRoutes.post("/", async (c) => {
+  const { conversationId, prompt, source, history } = await c.req.json();
+  if (!conversationId || !prompt) {
+    return c.json({ error: "conversationId and prompt are required" }, 400);
+  }
+  const manager = getJobManager();
+  const job = manager.createJob({ conversationId, prompt, source, history });
+  return c.json({ id: job.id, status: job.status });
+});
+jobRoutes.get("/", (c) => {
+  const status = c.req.query("status");
+  const conversationId = c.req.query("conversationId");
+  const manager = getJobManager();
+  const filters = {};
+  if (status) filters.status = status;
+  if (conversationId) filters.conversationId = conversationId;
+  const jobs = manager.listJobs(filters);
+  return c.json({ jobs });
+});
+jobRoutes.get("/:id", (c) => {
+  const id = c.req.param("id");
+  const manager = getJobManager();
+  const job = manager.getJob(id);
+  if (!job) {
+    return c.json({ error: "Job not found" }, 404);
+  }
+  return c.json(job);
+});
+jobRoutes.get("/:id/events", async (c) => {
+  const id = c.req.param("id");
+  const manager = getJobManager();
+  const job = manager.getJob(id);
+  if (!job) {
+    return c.json({ error: "Job not found" }, 404);
+  }
+  return streamSSE(c, async (stream) => {
+    const existingEvents = manager.getJobEvents(id);
+    for (const event of existingEvents) {
+      await stream.writeSSE({
+        data: JSON.stringify({
+          type: event.event_type,
+          data: event.data,
+          timestamp: event.timestamp
+        })
+      });
+    }
+    if (["completed", "failed", "cancelled"].includes(job.status)) {
+      await stream.writeSSE({ data: JSON.stringify({ done: true, status: job.status }) });
+      return;
+    }
+    let closed = false;
+    const unsubscribe = manager.subscribe(id, (event) => {
+      if (closed) return;
+      stream.writeSSE({
+        data: JSON.stringify(event)
+      }).catch(() => {
+        closed = true;
+        unsubscribe();
+      });
+      if (event.type === "status_change") {
+        try {
+          const data = JSON.parse(event.data);
+          if (["completed", "failed", "cancelled"].includes(data.status)) {
+            stream.writeSSE({ data: JSON.stringify({ done: true, status: data.status }) }).catch(() => {
+            });
+            closed = true;
+            unsubscribe();
+          }
+        } catch {
+        }
+      }
+    });
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (closed) {
+          clearInterval(check);
+          resolve();
+        }
+      }, 500);
+      setTimeout(() => {
+        clearInterval(check);
+        closed = true;
+        unsubscribe();
+        resolve();
+      }, 6e5);
+    });
+  });
+});
+jobRoutes.delete("/:id", (c) => {
+  const id = c.req.param("id");
+  const manager = getJobManager();
+  const cancelled = manager.cancelJob(id);
+  if (!cancelled) {
+    const job = manager.getJob(id);
+    if (!job) {
+      return c.json({ error: "Job not found" }, 404);
+    }
+    return c.json({ error: `Cannot cancel job with status: ${job.status}` }, 400);
+  }
+  return c.json({ success: true });
+});
+export {
+  jobRoutes
+};

package/server/jobs/manager.js

@@ -0,0 +1,231 @@
+import { spawnClaude } from "./runner.js";
+import { getNotificationDispatcher } from "../notifications/dispatcher.js";
+import * as jobsRepo from "../db/repositories/jobs.js";
+import * as messagesRepo from "../db/repositories/messages.js";
+import * as conversationsRepo from "../db/repositories/conversations.js";
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+class JobManager {
+  currentHandle = null;
+  currentJobId = null;
+  subscribers = /* @__PURE__ */ new Map();
+  init() {
+    const cleaned = jobsRepo.cleanupStaleJobs();
+    if (cleaned > 0) {
+      console.log(`Cleaned up ${cleaned} stale jobs from previous run`);
+    }
+  }
+  createJob(params) {
+    const id = generateId();
+    const job = jobsRepo.createJob({
+      id,
+      conversationId: params.conversationId,
+      prompt: params.prompt,
+      source: params.source || "web"
+    });
+    if (params.history && params.history.length > 0) {
+      jobsRepo.createJobEvent({
+        jobId: id,
+        eventType: "context",
+        data: JSON.stringify(params.history)
+      });
+    }
+    this.emitEvent(id, {
+      type: "status_change",
+      data: JSON.stringify({ status: "queued", jobId: id })
+    });
+    this.processNext();
+    return job;
+  }
+  getJob(id) {
+    return jobsRepo.getJob(id);
+  }
+  listJobs(filters) {
+    return jobsRepo.listJobs(filters);
+  }
+  getJobEvents(jobId, since) {
+    return jobsRepo.getJobEvents(jobId, since);
+  }
+  cancelJob(id) {
+    const job = jobsRepo.getJob(id);
+    if (!job) return false;
+    if (job.status === "queued") {
+      jobsRepo.updateJob(id, { status: "cancelled", completed_at: Date.now() });
+      this.emitEvent(id, {
+        type: "status_change",
+        data: JSON.stringify({ status: "cancelled" })
+      });
+      return true;
+    }
+    if (job.status === "running" && this.currentJobId === id && this.currentHandle) {
+      this.currentHandle.kill();
+      jobsRepo.updateJob(id, { status: "cancelled", completed_at: Date.now() });
+      this.emitEvent(id, {
+        type: "status_change",
+        data: JSON.stringify({ status: "cancelled" })
+      });
+      this.currentHandle = null;
+      this.currentJobId = null;
+      this.processNext();
+      return true;
+    }
+    return false;
+  }
+  subscribe(jobId, callback) {
+    if (!this.subscribers.has(jobId)) {
+      this.subscribers.set(jobId, /* @__PURE__ */ new Set());
+    }
+    this.subscribers.get(jobId).add(callback);
+    return () => {
+      const subs = this.subscribers.get(jobId);
+      if (subs) {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          this.subscribers.delete(jobId);
+        }
+      }
+    };
+  }
+  emitEvent(jobId, event) {
+    const subs = this.subscribers.get(jobId);
+    if (subs) {
+      for (const callback of subs) {
+        try {
+          callback(event);
+        } catch (e) {
+          console.error("Job event subscriber error:", e);
+        }
+      }
+    }
+  }
+  processNext() {
+    if (this.currentHandle) return;
+    const queued = jobsRepo.listJobs({ status: "queued" });
+    if (queued.length === 0) return;
+    queued.sort((a, b) => a.created_at - b.created_at);
+    const job = queued[0];
+    this.runJob(job);
+  }
+  async runJob(job) {
+    const jobId = job.id;
+    this.currentJobId = jobId;
+    jobsRepo.updateJob(jobId, { status: "running", started_at: Date.now() });
+    this.emitEvent(jobId, {
+      type: "status_change",
+      data: JSON.stringify({ status: "running" })
+    });
+    let history = [];
+    const events = jobsRepo.getJobEvents(jobId);
+    const contextEvent = events.find((e) => e.event_type === "context");
+    if (contextEvent?.data) {
+      try {
+        history = JSON.parse(contextEvent.data);
+      } catch {
+      }
+    }
+    let fullResponse = "";
+    const handle = spawnClaude({
+      prompt: job.prompt,
+      history,
+      callbacks: {
+        onText: (text) => {
+          fullResponse += text;
+          jobsRepo.createJobEvent({
+            jobId,
+            eventType: "text",
+            data: text
+          });
+          this.emitEvent(jobId, {
+            type: "text",
+            data: JSON.stringify({ text })
+          });
+        },
+        onActivity: (event) => {
+          jobsRepo.createJobEvent({
+            jobId,
+            eventType: event.type,
+            data: JSON.stringify(event)
+          });
+          this.emitEvent(jobId, {
+            type: "activity",
+            data: JSON.stringify(event)
+          });
+        },
+        onError: (error) => {
+          jobsRepo.createJobEvent({
+            jobId,
+            eventType: "error",
+            data: error
+          });
+          this.emitEvent(jobId, {
+            type: "error",
+            data: JSON.stringify({ error })
+          });
+        },
+        onComplete: (code) => {
+          const currentJob = jobsRepo.getJob(jobId);
+          if (currentJob?.status === "cancelled") return;
+          const now = Date.now();
+          const status = code === 0 ? "completed" : "failed";
+          const error = code !== 0 ? `Process exited with code ${code}` : void 0;
+          jobsRepo.updateJob(jobId, {
+            status,
+            result: fullResponse || null,
+            error: error || void 0,
+            completed_at: now
+          });
+          if (fullResponse.trim()) {
+            try {
+              const msgId = generateId();
+              messagesRepo.createMessage({
+                id: msgId,
+                conversationId: job.conversation_id,
+                role: "assistant",
+                content: fullResponse,
+                source: "job"
+              });
+              conversationsRepo.touchConversation(job.conversation_id);
+            } catch (e) {
+              console.error("Failed to save job response as message:", e);
+            }
+          }
+          this.emitEvent(jobId, {
+            type: "status_change",
+            data: JSON.stringify({ status, result: fullResponse, error })
+          });
+          const dispatcher = getNotificationDispatcher();
+          const notification = status === "completed" ? {
+            type: "job_completed",
+            jobId,
+            title: "Talkie: Task complete",
+            body: fullResponse.slice(0, 80) || "Done."
+          } : {
+            type: "job_failed",
+            jobId,
+            title: "Talkie: Task failed",
+            body: error || "Unknown error"
+          };
+          dispatcher.dispatch(notification).catch((e) => {
+            console.error("Notification dispatch failed:", e);
+          });
+          this.currentHandle = null;
+          this.currentJobId = null;
+          this.processNext();
+        }
+      }
+    });
+    this.currentHandle = handle;
+    jobsRepo.updateJob(jobId, { pid: handle.pid });
+  }
+}
+let manager = null;
+function getJobManager() {
+  if (!manager) {
+    manager = new JobManager();
+  }
+  return manager;
+}
+export {
+  getJobManager
+};