bloby-bot 0.17.2

package/scripts/postinstall.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+// Copies source files to ~/.bloby/ so everything lives in one
+// predictable location. Backward compat for `npm install -g bloby`.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, '..');
+const BLOBY_HOME = path.join(os.homedir(), '.bloby');
+
+// Loop guard: if we're already running inside ~/.bloby/, exit
+// (prevents infinite loop when npm install triggers postinstall again)
+if (path.resolve(PKG_ROOT) === path.resolve(BLOBY_HOME)) {
+  process.exit(0);
+}
+
+// Dev guard: don't interfere with development
+if (fs.existsSync(path.join(PKG_ROOT, '.git'))) {
+  process.exit(0);
+}
+
+// ── Copy source files to ~/.bloby/ ──
+
+fs.mkdirSync(BLOBY_HOME, { recursive: true });
+
+// Code directories — always overwrite (these are application code)
+const CODE_DIRS = ['bin', 'supervisor', 'worker', 'shared', 'scripts'];
+
+// Code files — always overwrite
+const CODE_FILES = [
+  'package.json', 'vite.config.ts', 'vite.bloby.config.ts',
+  'tsconfig.json', 'postcss.config.js', 'components.json',
+];
+
+for (const dir of CODE_DIRS) {
+  const src = path.join(PKG_ROOT, dir);
+  if (!fs.existsSync(src)) continue;
+  const dst = path.join(BLOBY_HOME, dir);
+  fs.cpSync(src, dst, { recursive: true, force: true });
+}
+
+// Workspace template — only on first install (preserves user files, uploads, etc.)
+const wsSrc = path.join(PKG_ROOT, 'workspace');
+const wsDst = path.join(BLOBY_HOME, 'workspace');
+if (fs.existsSync(wsSrc) && !fs.existsSync(wsDst)) {
+  fs.cpSync(wsSrc, wsDst, { recursive: true });
+}
+
+// Ensure workspace has its own package.json and .npmrc (handles upgrades from older versions)
+for (const f of ['package.json', '.npmrc']) {
+  const src = path.join(PKG_ROOT, 'workspace', f);
+  const dst = path.join(BLOBY_HOME, 'workspace', f);
+  if (fs.existsSync(src) && !fs.existsSync(dst)) {
+    fs.copyFileSync(src, dst);
+  }
+}
+
+for (const file of CODE_FILES) {
+  const src = path.join(PKG_ROOT, file);
+  if (!fs.existsSync(src)) continue;
+  fs.copyFileSync(src, path.join(BLOBY_HOME, file));
+}
+
+// ── Install dependencies in ~/.bloby/ ──
+
+try {
+  execSync('npm install --omit=dev', {
+    cwd: BLOBY_HOME,
+    stdio: 'ignore',
+  });
+} catch {
+  // Non-fatal: deps may already exist from a previous install
+}
+
+// ── Install workspace dependencies (isolated from system deps) ──
+
+try {
+  execSync('npm install --omit=dev', {
+    cwd: path.join(BLOBY_HOME, 'workspace'),
+    stdio: 'ignore',
+  });
+} catch {
+  // Non-fatal: workspace deps may already exist
+}
+
+// ── Copy pre-built UI if available, otherwise build ──
+
+const distSrc = path.join(PKG_ROOT, 'dist-bloby');
+const distDst = path.join(BLOBY_HOME, 'dist-bloby');
+if (fs.existsSync(distSrc)) {
+  // Always use the pre-built UI from the package (handles updates)
+  if (fs.existsSync(distDst)) fs.rmSync(distDst, { recursive: true });
+  fs.cpSync(distSrc, distDst, { recursive: true });
+} else if (!fs.existsSync(path.join(distDst, 'onboard.html'))) {
+  try {
+    execSync('npm run build:bloby', {
+      cwd: BLOBY_HOME,
+      stdio: 'ignore',
+    });
+  } catch {
+    // Non-fatal: supervisor will build on first start
+  }
+}
+
+// ── Create bloby symlink ──
+
+const cliPath = path.join(BLOBY_HOME, 'bin', 'cli.js');
+fs.chmodSync(cliPath, 0o755);
+
+if (process.platform === 'win32') {
+  // On Windows, npm handles the bin linking via package.json "bin" field
+  // Just ensure the files are in place
+} else {
+  const targets = ['/usr/local/bin/bloby', path.join(os.homedir(), '.local', 'bin', 'bloby')];
+  let linked = false;
+
+  for (const target of targets) {
+    try {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      try { fs.unlinkSync(target); } catch {}
+      fs.symlinkSync(cliPath, target);
+      linked = true;
+      break;
+    } catch {
+      // No permission, try next
+    }
+  }
+
+  if (!linked) {
+    console.log(`Note: Could not create bloby symlink. You can run it directly: node ${cliPath}`);
+  }
+}

package/shared/ai.ts

@@ -0,0 +1,141 @@
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+export interface AiProvider {
+  name: string;
+  chat(
+    messages: ChatMessage[],
+    model: string,
+    onToken: (token: string) => void,
+    onDone: (full: string, usage?: { tokensIn: number; tokensOut: number }) => void,
+    onError: (err: Error) => void,
+    signal?: AbortSignal,
+  ): void;
+}
+
+export function createProvider(provider: string, apiKey: string, baseUrl?: string): AiProvider | null {
+  switch (provider) {
+    case 'openai': return openai(apiKey, baseUrl);
+    case 'anthropic': return anthropic(apiKey);
+    case 'ollama': return ollama(baseUrl);
+    default: return null;
+  }
+}
+
+// ── SSE line parser ──
+
+async function readSSE(res: Response, onLine: (line: string) => void, signal?: AbortSignal) {
+  const reader = res.body!.getReader();
+  const dec = new TextDecoder();
+  let buf = '';
+  while (true) {
+    if (signal?.aborted) break;
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    const lines = buf.split('\n');
+    buf = lines.pop()!;
+    for (const line of lines) {
+      if (line.startsWith('data: ') && line !== 'data: [DONE]') onLine(line.slice(6));
+    }
+  }
+}
+
+// ── Providers (raw fetch, zero deps) ──
+
+function openai(apiKey: string, baseUrl = 'https://api.openai.com/v1'): AiProvider {
+  return {
+    name: 'openai',
+    async chat(messages, model, onToken, onDone, onError, signal) {
+      try {
+        const res = await fetch(`${baseUrl}/chat/completions`, {
+          method: 'POST',
+          headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ model, messages, stream: true, stream_options: { include_usage: true } }),
+          signal,
+        });
+        if (!res.ok) throw new Error(`OpenAI ${res.status}: ${await res.text()}`);
+        let full = '';
+        let usage: { tokensIn: number; tokensOut: number } | undefined;
+        await readSSE(res, (line) => {
+          const j = JSON.parse(line);
+          const t = j.choices?.[0]?.delta?.content;
+          if (t) { full += t; onToken(t); }
+          if (j.usage) usage = { tokensIn: j.usage.prompt_tokens, tokensOut: j.usage.completion_tokens };
+        }, signal);
+        onDone(full, usage);
+      } catch (e) { if (!signal?.aborted) onError(e instanceof Error ? e : new Error(String(e))); }
+    },
+  };
+}
+
+function anthropic(apiKey: string): AiProvider {
+  return {
+    name: 'anthropic',
+    async chat(messages, model, onToken, onDone, onError, signal) {
+      try {
+        const sys = messages.find((m) => m.role === 'system');
+        const msgs = messages.filter((m) => m.role !== 'system');
+        const res = await fetch('https://api.anthropic.com/v1/messages', {
+          method: 'POST',
+          headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ model, max_tokens: 4096, system: sys?.content, messages: msgs, stream: true }),
+          signal,
+        });
+        if (!res.ok) throw new Error(`Anthropic ${res.status}: ${await res.text()}`);
+        let full = '';
+        let usage: { tokensIn: number; tokensOut: number } | undefined;
+        await readSSE(res, (line) => {
+          const j = JSON.parse(line);
+          if (j.type === 'content_block_delta' && j.delta?.text) {
+            full += j.delta.text;
+            onToken(j.delta.text);
+          }
+          if (j.type === 'message_delta' && j.usage) {
+            usage = { tokensIn: j.usage?.input_tokens ?? 0, tokensOut: j.usage.output_tokens };
+          }
+          if (j.type === 'message_start' && j.message?.usage) {
+            usage = { tokensIn: j.message.usage.input_tokens, tokensOut: 0 };
+          }
+        }, signal);
+        onDone(full, usage);
+      } catch (e) { if (!signal?.aborted) onError(e instanceof Error ? e : new Error(String(e))); }
+    },
+  };
+}
+
+function ollama(baseUrl = 'http://localhost:11434'): AiProvider {
+  return {
+    name: 'ollama',
+    async chat(messages, model, onToken, onDone, onError, signal) {
+      try {
+        const res = await fetch(`${baseUrl}/api/chat`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ model, messages, stream: true }),
+          signal,
+        });
+        if (!res.ok) throw new Error(`Ollama ${res.status}`);
+        const reader = res.body!.getReader();
+        const dec = new TextDecoder();
+        let full = '';
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          for (const line of dec.decode(value, { stream: true }).split('\n').filter(Boolean)) {
+            const j = JSON.parse(line);
+            if (j.message?.content) { full += j.message.content; onToken(j.message.content); }
+            if (j.done) { onDone(full, { tokensIn: j.prompt_eval_count ?? 0, tokensOut: j.eval_count ?? 0 }); return; }
+          }
+        }
+        onDone(full);
+      } catch (e) { if (!signal?.aborted) onError(e instanceof Error ? e : new Error(String(e))); }
+    },
+  };
+}

package/shared/config.ts

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import { paths, DATA_DIR } from './paths.js';
+
+export interface ChannelConfig {
+  enabled: boolean;
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
+  mode: 'channel' | 'business';
+  /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
+  admins?: string[];
+  /** Active skill for customer-facing mode (folder name in workspace/skills/) */
+  skill?: string;
+}
+
+export interface BotConfig {
+  port: number;
+  username: string;
+  ai: {
+    provider: 'openai' | 'anthropic' | 'ollama' | '';
+    model: string;
+    apiKey: string;
+    baseUrl?: string;
+  };
+  tunnel: {
+    mode: 'off' | 'quick' | 'named';
+    name?: string;
+    domain?: string;
+    configPath?: string;
+  };
+  relay: {
+    token: string;
+    tier: string;
+    url: string;
+  };
+  wallet?: {
+    privateKey: string;
+    address: string;
+  };
+  channels?: {
+    whatsapp?: ChannelConfig;
+  };
+  tunnelUrl?: string;
+}
+
+const DEFAULTS: BotConfig = {
+  port: 3000,
+  username: '',
+  ai: { provider: '', model: '', apiKey: '' },
+  tunnel: { mode: 'quick' },
+  relay: { token: '', tier: '', url: '' },
+};
+
+export function loadConfig(): BotConfig {
+  if (!fs.existsSync(paths.config)) throw new Error('No config. Run `bloby init`.');
+  const config = JSON.parse(fs.readFileSync(paths.config, 'utf-8'));
+
+  // Backward compat: migrate old { enabled: boolean } → { mode }
+  if ('enabled' in config.tunnel && !('mode' in config.tunnel)) {
+    config.tunnel = { mode: config.tunnel.enabled ? 'quick' : 'off' };
+    saveConfig(config);
+  }
+
+  return config;
+}
+
+export function saveConfig(config: BotConfig): void {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  fs.writeFileSync(paths.config, JSON.stringify(config, null, 2));
+}

package/shared/logger.ts

@@ -0,0 +1,13 @@
+const c = {
+  r: '\x1b[0m', d: '\x1b[2m',
+  g: '\x1b[32m', y: '\x1b[33m', red: '\x1b[31m', cy: '\x1b[36m',
+};
+
+const ts = () => new Date().toLocaleTimeString('en-GB', { hour12: false });
+
+export const log = {
+  info: (msg: string, ...a: unknown[]) => console.log(`${c.d}${ts()}${c.r} ${c.cy}INFO${c.r}  ${msg}`, ...a),
+  warn: (msg: string, ...a: unknown[]) => console.warn(`${c.d}${ts()}${c.r} ${c.y}WARN${c.r}  ${msg}`, ...a),
+  error: (msg: string, ...a: unknown[]) => console.error(`${c.d}${ts()}${c.r} ${c.red}ERR${c.r}   ${msg}`, ...a),
+  ok: (msg: string, ...a: unknown[]) => console.log(`${c.d}${ts()}${c.r} ${c.g}OK${c.r}    ${msg}`, ...a),
+};

package/shared/paths.ts

@@ -0,0 +1,20 @@
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+export const PKG_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+export const DATA_DIR = path.join(os.homedir(), '.bloby');
+export const WORKSPACE_DIR = process.env.BLOBY_WORKSPACE || path.join(PKG_DIR, 'workspace');
+
+const cfName = process.platform === 'win32' ? 'cloudflared.exe' : 'cloudflared';
+
+export const paths = {
+  config: path.join(DATA_DIR, 'config.json'),
+  db: path.join(DATA_DIR, 'memory.db'),
+  widgetJs: path.join(PKG_DIR, 'supervisor', 'widget.js'),
+  cloudflared: path.join(DATA_DIR, 'bin', cfName),
+  files: path.join(WORKSPACE_DIR, 'files'),
+  filesAudio: path.join(WORKSPACE_DIR, 'files', 'audio'),
+  filesImages: path.join(WORKSPACE_DIR, 'files', 'images'),
+  filesDocuments: path.join(WORKSPACE_DIR, 'files', 'documents'),
+};

package/shared/relay.ts

@@ -0,0 +1,148 @@
+import { log } from './logger.js';
+
+const RELAY_API = 'https://api.bloby.bot/api';
+
+// ─── Register a new handle ──────────────────────────────────────────────────
+
+export async function registerHandle(
+  username: string,
+  tier: string,
+  walletAddress?: string,
+): Promise<{ token: string; relayUrl: string }> {
+  const payload: Record<string, string> = { username, tier };
+  if (walletAddress) payload.walletAddress = walletAddress;
+
+  const res = await fetch(`${RELAY_API}/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  const data = await res.json();
+
+  if (!res.ok) {
+    throw new Error(data.error || `Registration failed (${res.status})`);
+  }
+
+  return { token: data.token, relayUrl: data.relayUrl };
+}
+
+// ─── Check username availability ─────────────────────────────────────────────
+
+export async function checkAvailability(
+  username: string,
+): Promise<{
+  valid: boolean;
+  error?: string;
+  handles: { tier: string; url: string; paid: boolean; price: number; available: boolean }[];
+}> {
+  const res = await fetch(`${RELAY_API}/availability/${encodeURIComponent(username)}`);
+  return res.json();
+}
+
+// ─── Claim a reserved (purchased) handle ────────────────────────────────────
+
+export async function claimReservedHandle(
+  handle: string,
+  hash: string,
+  walletAddress?: string,
+): Promise<{ token: string; relayUrl: string }> {
+  const payload: Record<string, string> = { handle, hash };
+  if (walletAddress) payload.walletAddress = walletAddress;
+
+  const res = await fetch(`${RELAY_API}/handle/claim-reserved`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  const data = await res.json();
+
+  if (!res.ok) {
+    throw new Error(data.error || `Claim failed (${res.status})`);
+  }
+
+  return { token: data.token, relayUrl: data.relayUrl };
+}
+
+// ─── Release handle ─────────────────────────────────────────────────────────
+
+export async function releaseHandle(token: string): Promise<void> {
+  const res = await fetch(`${RELAY_API}/handle`, {
+    method: 'DELETE',
+    headers: { Authorization: `Bearer ${token}` },
+  });
+
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error || `Release failed (${res.status})`);
+  }
+}
+
+// ─── Update tunnel URL ──────────────────────────────────────────────────────
+
+export async function updateTunnelUrl(token: string, tunnelUrl: string): Promise<void> {
+  const res = await fetch(`${RELAY_API}/tunnel`, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ tunnelUrl }),
+  });
+
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error || `Tunnel update failed (${res.status})`);
+  }
+
+  log.ok('Relay updated with tunnel URL');
+}
+
+// ─── Heartbeat ───────────────────────────────────────────────────────────────
+
+let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+
+export function startHeartbeat(token: string, tunnelUrl?: string): void {
+  stopHeartbeat();
+
+  const beat = async () => {
+    try {
+      await fetch(`${RELAY_API}/heartbeat`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(tunnelUrl ? { tunnelUrl } : {}),
+      });
+    } catch {
+      // Silent — next heartbeat will retry
+    }
+  };
+
+  beat(); // immediate first beat
+  heartbeatTimer = setInterval(beat, 30_000); // every 30s
+}
+
+export function stopHeartbeat(): void {
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+}
+
+// ─── Disconnect (graceful shutdown) ──────────────────────────────────────────
+
+export async function disconnect(token: string): Promise<void> {
+  stopHeartbeat();
+
+  try {
+    await fetch(`${RELAY_API}/disconnect`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}` },
+    });
+  } catch {
+    // Best-effort — if it fails, heartbeat timeout will mark offline
+  }
+}