otherwise-cli 0.1.0

package/src/models.js

@@ -0,0 +1,146 @@
+/**
+ * Centralized model definitions - shared between CLI and frontend
+ * This mirrors the ModelID.json structure
+ */
+
+export const MODEL_DATA = {
+  localModels: [
+    { id: "Qwen3.5-4B", name: "Qwen 3.5 4B", type: ["reasoning", "image-input"], provider: "Local", parameters: "4B", maxTokens: 8192 },
+    { id: "Llama-3.2", name: "Llama-3.2", type: [""], provider: "Local", parameters: "1B", maxTokens: 8192 },
+    { id: "Janus-Pro", name: "Janus-Pro", type: ["image-input", "image-output"], provider: "Local", parameters: "1B", maxTokens: 4096 },
+    { id: "Phi-3.5", name: "Phi-3.5", type: [""], provider: "Local", parameters: "3.8B", maxTokens: 8192 },
+    { id: "SmoLlm", name: "SmoLlm", type: [""], provider: "Local", parameters: "1.7B", maxTokens: 4096 },
+    { id: "Deepseek-R1", name: "Deepseek-R1", type: ["reasoning"], provider: "Local", parameters: "1.5B", maxTokens: 8192 },
+    { id: "Zyphra-ZR1", name: "Zyphra-ZR1", type: ["reasoning"], provider: "Local", parameters: "1.5B", maxTokens: 8192 },
+  ],
+  apiModels: {
+    anthropic: [
+      { id: "claude-sonnet-4-20250514", name: "Claude 4 Sonnet", type: [""], provider: "Anthropic", maxTokens: 64000 },
+      { id: "claude-4-opus", name: "Claude 4 Opus", type: [""], provider: "Anthropic", maxTokens: 32000 },
+      { id: "claude-sonnet-4-5-20250929", name: "Claude 4.5 Sonnet", type: [""], provider: "Anthropic", maxTokens: 64000 },
+      { id: "claude-opus-4-5-20251101", name: "Claude 4.5 Opus", type: [""], provider: "Anthropic", maxTokens: 32000 },
+    ],
+    openai: [
+      { id: "gpt-4.1-2025-04-14", name: "GPT-4.1", type: [""], provider: "OpenAI", maxTokens: 16384 },
+      { id: "gpt-4o-2024-08-06", name: "GPT-4o", type: [""], provider: "OpenAI", maxTokens: 16384 },
+      { id: "gpt-5-2025-08-07", name: "GPT-5", type: ["reasoning", "web-search"], provider: "OpenAI", maxTokens: 32768 },
+      { id: "gpt-5-mini-2025-08-07", name: "GPT-5 Mini", type: ["web-search"], provider: "OpenAI", maxTokens: 16384 },
+    ],
+    google: [
+      { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro", type: ["reasoning", "web-search"], provider: "Google", maxTokens: 65536 },
+      { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash", type: ["reasoning", "web-search"], provider: "Google", maxTokens: 65536 },
+      { id: "gemini-2.5-flash-lite", name: "Gemini 2.5 Flash-Lite", type: ["web-search"], provider: "Google", maxTokens: 65536 },
+      { id: "gemini-3-pro-preview", name: "Gemini 3 Pro", type: ["reasoning", "web-search", "image-input"], provider: "Google", maxTokens: 65536 },
+      { id: "gemini-3-flash-preview", name: "Gemini 3 Flash", type: ["reasoning", "web-search"], provider: "Google", maxTokens: 65536 },
+    ],
+    xai: [
+      { id: "grok-3-mini", name: "Grok 3 Mini", type: ["reasoning"], provider: "xAI", maxTokens: 131072 },
+      { id: "grok-code-fast-1", name: "Grok Code Fast 1", type: ["reasoning"], provider: "xAI", maxTokens: 131072 },
+      { id: "grok-4-fast-reasoning", name: "Grok 4 Fast Reasoning", type: ["reasoning"], provider: "xAI", maxTokens: 131072 },
+      { id: "grok-4-fast-non-reasoning", name: "Grok 4 Fast", type: [], provider: "xAI", maxTokens: 131072 },
+      { id: "grok-4-1-fast", name: "Grok 4.1 Fast", type: [], provider: "xAI", maxTokens: 131072 },
+      { id: "grok-4-1-fast-reasoning", name: "Grok 4.1 Fast Reasoning", type: ["reasoning"], provider: "xAI", maxTokens: 131072 },
+    ],
+    // OpenRouter models are fetched dynamically from their API
+    // This placeholder array will be populated at runtime
+    openrouter: [],
+  },
+};
+
+// Cache for OpenRouter models (shared with inference module)
+let openRouterModelsCache = [];
+
+/**
+ * Set OpenRouter models (called when models are fetched from API)
+ * @param {Array} models - Array of OpenRouter model objects
+ */
+export function setOpenRouterModels(models) {
+  openRouterModelsCache = models;
+  MODEL_DATA.apiModels.openrouter = models;
+}
+
+/**
+ * Get cached OpenRouter models
+ * @returns {Array} Cached OpenRouter models
+ */
+export function getOpenRouterModels() {
+  return openRouterModelsCache;
+}
+
+/**
+ * Find a model by ID
+ * @param {string} modelId - Model ID to find
+ * @returns {Object|null} Model object or null
+ */
+export function findModelById(modelId) {
+  // Check local models
+  const localModel = MODEL_DATA.localModels.find(m => m.id === modelId);
+  if (localModel) return localModel;
+  
+  // Check API models
+  for (const models of Object.values(MODEL_DATA.apiModels)) {
+    const model = models.find(m => m.id === modelId);
+    if (model) return model;
+  }
+  
+  return null;
+}
+
+/**
+ * Get provider for a model ID
+ * @param {string} modelId - Model ID
+ * @returns {string} Provider name
+ */
+export function getProviderForModel(modelId) {
+  if (modelId.startsWith('openrouter:')) return 'openrouter';
+  if (modelId.startsWith('claude')) return 'anthropic';
+  if (modelId.startsWith('gpt') || modelId.startsWith('o1') || modelId.startsWith('o3')) return 'openai';
+  if (modelId.startsWith('gemini')) return 'google';
+  if (modelId.startsWith('grok')) return 'xai';
+  
+  // Check local models
+  const localModel = MODEL_DATA.localModels.find(m => m.id === modelId);
+  if (localModel) return 'local';
+  
+  // Check OpenRouter models
+  const orModel = MODEL_DATA.apiModels.openrouter.find(m => m.id === modelId);
+  if (orModel) return 'openrouter';
+  
+  return 'unknown';
+}
+
+/**
+ * Get display name for a model
+ * @param {string} modelId - Model ID
+ * @returns {string} Display name
+ */
+export function getModelDisplayName(modelId) {
+  const model = findModelById(modelId);
+  if (model) return model.name;
+  
+  // Fallback: format the ID nicely
+  return modelId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+}
+
+/**
+ * Get max tokens for a model
+ * @param {string} modelId - Model ID
+ * @returns {number} Max tokens
+ */
+export function getModelMaxTokens(modelId) {
+  const model = findModelById(modelId);
+  return model?.maxTokens || 8192;
+}
+
+/**
+ * Check if a model supports a feature
+ * @param {string} modelId - Model ID
+ * @param {string} feature - Feature to check (e.g., 'reasoning', 'web-search', 'image-input')
+ * @returns {boolean}
+ */
+export function modelSupports(modelId, feature) {
+  const model = findModelById(modelId);
+  return model?.type?.includes(feature) || false;
+}
+
+export default MODEL_DATA;

package/src/remote/client.js

@@ -0,0 +1,225 @@
+/**
+ * Outbound WebSocket client to connect the CLI to the backend (otherwise.ai router).
+ * Used for "remote" mode: user on otherwise.ai talks to this CLI via the backend.
+ * Connect with pairing token from device-code flow (otherwise connect → enter code at otherwise.ai/connect).
+ *
+ * Reconnection uses exponential backoff with jitter (2s → 60s cap). The pairing token
+ * is a long-lived JWT so it survives backend restarts — no need to re-enter a code.
+ *
+ * Ping/pong keep-alive prevents Azure ARR and other reverse proxies from closing
+ * idle WebSocket connections (sends ping every 25s, expects pong within 10s).
+ */
+
+import WebSocket from "ws";
+
+let remoteWs = null;
+let reconnectTimeout = null;
+let reconnectAttempt = 0;
+const RECONNECT_BASE_MS = 2000;
+const RECONNECT_MAX_MS = 60000;
+const RECONNECT_JITTER = 0.3;
+const STABLE_CONNECTION_MS = 15000;
+const PING_INTERVAL_MS = 25000;
+const PONG_TIMEOUT_MS = 10000;
+
+const DEFAULT_BACKEND =
+  "https://gptez-acb8f4ggfrbkhtep.canadacentral-01.azurewebsites.net";
+
+/**
+ * Get backend HTTP(S) base URL (no trailing slash). Used for REST API (device-code, pairing-token) and to derive WS URL.
+ * Env: OTHERWISE_BACKEND_URL (e.g. https://your-app.azurewebsites.net) overrides default.
+ * @returns {string} e.g. https://api.otherwise.ai or https://gptez-....azurewebsites.net
+ */
+export function getBackendBaseUrl() {
+  if (typeof process !== "undefined" && process.env?.OTHERWISE_BACKEND_URL) {
+    return process.env.OTHERWISE_BACKEND_URL.replace(/\/$/, "");
+  }
+  return DEFAULT_BACKEND;
+}
+
+/**
+ * Get backend WebSocket URL from config or env.
+ * Uses OTHERWISE_BACKEND_URL if set (derives wss from https), else OTHERWISE_BACKEND_WS_URL, else default.
+ * @returns {string} e.g. wss://api.otherwise.ai/ws
+ */
+export function getBackendWsUrl() {
+  if (typeof process !== "undefined" && process.env?.OTHERWISE_BACKEND_WS_URL) {
+    return process.env.OTHERWISE_BACKEND_WS_URL;
+  }
+  const base = getBackendBaseUrl();
+  const wsBase = base
+    .replace(/^http:\/\//, "ws://")
+    .replace(/^https:\/\//, "wss://");
+  return wsBase + (wsBase.endsWith("/ws") ? "" : "/ws");
+}
+
+function getReconnectDelay() {
+  const base = Math.min(
+    RECONNECT_BASE_MS * Math.pow(1.5, reconnectAttempt),
+    RECONNECT_MAX_MS,
+  );
+  const jitter = base * RECONNECT_JITTER * (Math.random() - 0.5) * 2;
+  return Math.round(base + jitter);
+}
+
+/**
+ * Connect to the backend as a CLI client using a pairing token (JWT, survives restarts).
+ * Messages from the backend are passed to onMessage(rawMessage, sendReply).
+ * sendReply(msg) sends a message back through the WebSocket (same JSON protocol as local /ws).
+ *
+ * @param {string} pairingToken - JWT from POST /api/pairing-token (user gets it from otherwise.ai/connect)
+ * @param {function} onMessage - (rawMessage: Buffer|string, sendReply: (msg: object) => void) => Promise<void>
+ * @param {object} options - { backendUrl?, onConnect?, onDisconnect?, onInvalidToken?, reconnect? }
+ * @returns {{ stop: function }} - call stop() to close the connection and stop reconnecting
+ */
+export function connectToBackend(pairingToken, onMessage, options = {}) {
+  const backendUrl = options.backendUrl || getBackendWsUrl();
+  const baseUrl = backendUrl.replace(/^http/, "ws").replace(/\/$/, "");
+  const path = baseUrl.endsWith("/ws") ? baseUrl : `${baseUrl}/ws`;
+  const wsUrl = `${path}?role=cli&token=${encodeURIComponent(pairingToken)}`;
+  let stopped = false;
+  let pingInterval = null;
+  let pongTimeout = null;
+  let stableTimer = null;
+  let connectedAt = 0;
+
+  function clearTimers() {
+    if (pingInterval) {
+      clearInterval(pingInterval);
+      pingInterval = null;
+    }
+    if (pongTimeout) {
+      clearTimeout(pongTimeout);
+      pongTimeout = null;
+    }
+    if (stableTimer) {
+      clearTimeout(stableTimer);
+      stableTimer = null;
+    }
+  }
+
+  function startPingLoop(ws) {
+    clearTimers();
+    pingInterval = setInterval(() => {
+      if (!ws || ws.readyState !== WebSocket.OPEN) {
+        clearTimers();
+        return;
+      }
+      try {
+        ws.ping();
+        pongTimeout = setTimeout(() => {
+          console.log("[Remote] Pong timeout — closing stale connection");
+          try {
+            ws.terminate();
+          } catch (_) {}
+        }, PONG_TIMEOUT_MS);
+      } catch (_) {}
+    }, PING_INTERVAL_MS);
+  }
+
+  function stop() {
+    stopped = true;
+    clearTimers();
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+    if (remoteWs) {
+      try {
+        remoteWs.close();
+      } catch (e) {}
+      remoteWs = null;
+    }
+    options.onDisconnect?.();
+  }
+
+  function sendReply(msg) {
+    if (remoteWs && remoteWs.readyState === WebSocket.OPEN) {
+      remoteWs.send(JSON.stringify(msg));
+    }
+  }
+
+  function scheduleReconnect() {
+    if (stopped || options.reconnect === false || !pairingToken) return;
+    const delay = getReconnectDelay();
+    reconnectAttempt++;
+    console.log(
+      `[Remote] Reconnecting in ${delay}ms (attempt ${reconnectAttempt})...`,
+    );
+    reconnectTimeout = setTimeout(connect, delay);
+  }
+
+  function connect() {
+    if (stopped) return;
+    if (remoteWs && remoteWs.readyState === WebSocket.OPEN) return;
+    console.log("[Remote] Connecting to backend...");
+    remoteWs = new WebSocket(wsUrl);
+
+    remoteWs.on("open", () => {
+      console.log("[Remote] Connected to backend");
+      connectedAt = Date.now();
+
+      stableTimer = setTimeout(() => {
+        reconnectAttempt = 0;
+      }, STABLE_CONNECTION_MS);
+
+      startPingLoop(remoteWs);
+      options.onConnect?.(sendReply);
+    });
+
+    remoteWs.on("pong", () => {
+      if (pongTimeout) {
+        clearTimeout(pongTimeout);
+        pongTimeout = null;
+      }
+    });
+
+    remoteWs.on("close", (code, reason) => {
+      const elapsed = connectedAt ? Date.now() - connectedAt : 0;
+      clearTimers();
+      remoteWs = null;
+      console.log(
+        `[Remote] Disconnected from backend code=${code} reason=${reason?.toString() || ""} after=${elapsed}ms`,
+      );
+      options.onDisconnect?.();
+      if (code === 4001) {
+        options.onInvalidToken?.();
+        return;
+      }
+      scheduleReconnect();
+    });
+
+    remoteWs.on("error", (err) => {
+      console.error("[Remote] WebSocket error:", err?.message || err);
+    });
+
+    remoteWs.on("message", (data) => {
+      try {
+        const raw =
+          typeof data === "string" ? data : data?.toString?.() || data;
+        const msg = typeof raw === "string" ? JSON.parse(raw) : raw;
+        if (msg && msg.type === "cli_connected") {
+          return;
+        }
+        Promise.resolve(onMessage(raw, sendReply)).catch((e) => {
+          console.error("[Remote] Message handler error:", e);
+        });
+      } catch (e) {
+        console.error("[Remote] Failed to parse message:", e);
+      }
+    });
+  }
+
+  connect();
+
+  return { stop };
+}
+
+/**
+ * Check if the CLI is currently connected to the backend (remote mode).
+ */
+export function isConnectedToBackend() {
+  return remoteWs != null && remoteWs.readyState === WebSocket.OPEN;
+}
+
+export default { getBackendWsUrl, connectToBackend, isConnectedToBackend };

package/src/scheduler/cron.js

@@ -0,0 +1,243 @@
+import cron from "node-cron";
+import {
+  getScheduledTasks,
+  markScheduledTaskRun,
+  updateScheduledTaskNextRun,
+  getScheduledTask,
+} from "../storage/db.js";
+import { runScheduledTask } from "../agent/index.js";
+
+// Store active cron jobs
+const activeJobs = new Map();
+
+// One-time tasks: id -> { timeoutId } (run once after N minutes)
+let oneTimeId = 0;
+const oneTimeTimeouts = new Map();
+
+// Import silentMode check - we'll check process.env for a flag
+const isSilent = () => process.env.SILENT_MODE === "true";
+const schedulerLog = (...args) => {
+  if (!isSilent()) console.log(...args);
+};
+
+/**
+ * Calculate next run time for a cron expression
+ */
+function getNextRunTime(cronExpression) {
+  try {
+    const interval = cron.getTasks().get(cronExpression);
+    // Use the cron-parser to calculate next run
+    // For simplicity, we'll just return the current time + 1 minute as placeholder
+    // In production, use a proper cron parser
+    return new Date(Date.now() + 60000).toISOString();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Initialize scheduler and load all enabled tasks
+ * @param {object} config - Configuration
+ */
+export function initScheduler(config) {
+  schedulerLog("[Scheduler] Initializing...");
+
+  try {
+    const tasks = getScheduledTasks(true); // Only enabled tasks
+
+    for (const task of tasks) {
+      scheduleTask(task, config);
+    }
+
+    console.log(`[Scheduler] Loaded ${tasks.length} scheduled tasks`);
+  } catch (err) {
+    console.error("[Scheduler] Error loading tasks:", err);
+  }
+}
+
+/**
+ * Schedule a task for execution
+ * @param {object} task - Task from database
+ * @param {object} config - Configuration
+ */
+export function scheduleTask(task, config) {
+  // Validate cron expression
+  if (!cron.validate(task.cron_expression)) {
+    console.error(
+      `[Scheduler] Invalid cron expression for task ${task.id}: ${task.cron_expression}`,
+    );
+    return false;
+  }
+
+  // Cancel existing job if any
+  if (activeJobs.has(task.id)) {
+    activeJobs.get(task.id).stop();
+    activeJobs.delete(task.id);
+  }
+
+  // Create new cron job
+  const job = cron.schedule(
+    task.cron_expression,
+    async () => {
+      console.log(`[Scheduler] Executing task ${task.id}: ${task.description}`);
+
+      try {
+        // Mark task as running
+        markScheduledTaskRun(task.id);
+
+        // Run the agent with the task description
+        const result = await runScheduledTask(task.description, config);
+
+        console.log(`[Scheduler] Task ${task.id} completed`);
+
+        // Update next run time
+        updateScheduledTaskNextRun(
+          task.id,
+          getNextRunTime(task.cron_expression),
+        );
+      } catch (err) {
+        console.error(`[Scheduler] Task ${task.id} failed:`, err);
+      }
+    },
+    {
+      scheduled: true,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    },
+  );
+
+  activeJobs.set(task.id, job);
+
+  // Update next run time in database
+  updateScheduledTaskNextRun(task.id, getNextRunTime(task.cron_expression));
+
+  console.log(`[Scheduler] Task ${task.id} scheduled: ${task.cron_expression}`);
+  return true;
+}
+
+/**
+ * Cancel a scheduled task
+ * @param {number} taskId - Task ID
+ */
+export function cancelTask(taskId) {
+  if (activeJobs.has(taskId)) {
+    activeJobs.get(taskId).stop();
+    activeJobs.delete(taskId);
+    console.log(`[Scheduler] Task ${taskId} cancelled`);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Get status of all active jobs
+ */
+export function getSchedulerStatus() {
+  return {
+    activeJobs: activeJobs.size,
+    jobs: Array.from(activeJobs.keys()),
+  };
+}
+
+/**
+ * Reload a task from database (call after creating/updating)
+ * @param {number} taskId - Task ID
+ * @param {object} config - Configuration
+ * @returns {boolean} - true if task was scheduled, false if invalid or disabled
+ */
+export function reloadTask(taskId, config) {
+  const task = getScheduledTask(taskId);
+  if (!task || !task.enabled) {
+    schedulerLog(
+      "[Scheduler] reloadTask: task",
+      taskId,
+      "not found or disabled",
+    );
+    return false;
+  }
+  const ok = scheduleTask(task, config);
+  if (!ok) {
+    console.error(
+      "[Scheduler] reloadTask: failed to schedule task",
+      taskId,
+      "(invalid cron?)",
+    );
+  }
+  return ok;
+}
+
+/**
+ * Schedule a one-time task to run once after N minutes (for "in 5 minutes" style requests).
+ * Does not persist across CLI restarts.
+ * @param {string} description - What the task should do
+ * @param {number} runInMinutes - Minutes from now to run
+ * @param {object} config - Agent config
+ * @returns {number} - One-time task id (can be used to cancel via cancelOneTimeTask)
+ */
+export function scheduleOneTimeTask(description, runInMinutes, config) {
+  const id = ++oneTimeId;
+  const ms = Math.max(1, runInMinutes) * 60 * 1000;
+  schedulerLog(
+    "[Scheduler] One-time task",
+    id,
+    "scheduled in",
+    runInMinutes,
+    "minute(s)",
+  );
+  const timeoutId = setTimeout(async () => {
+    oneTimeTimeouts.delete(id);
+    try {
+      console.log(
+        "[Scheduler] Executing one-time task",
+        id,
+        ":",
+        description.slice(0, 60) + (description.length > 60 ? "..." : ""),
+      );
+      await runScheduledTask(description, config);
+      console.log("[Scheduler] One-time task", id, "completed");
+    } catch (err) {
+      console.error("[Scheduler] One-time task", id, "failed:", err);
+    }
+  }, ms);
+  oneTimeTimeouts.set(id, { timeoutId });
+  return id;
+}
+
+/**
+ * Cancel a one-time scheduled task
+ */
+export function cancelOneTimeTask(id) {
+  const entry = oneTimeTimeouts.get(id);
+  if (entry) {
+    clearTimeout(entry.timeoutId);
+    oneTimeTimeouts.delete(id);
+    schedulerLog("[Scheduler] One-time task", id, "cancelled");
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Stop all scheduled tasks and one-time timeouts
+ */
+export function stopScheduler() {
+  for (const [id, job] of activeJobs) {
+    job.stop();
+  }
+  activeJobs.clear();
+  for (const [id, entry] of oneTimeTimeouts) {
+    clearTimeout(entry.timeoutId);
+  }
+  oneTimeTimeouts.clear();
+  schedulerLog("[Scheduler] All tasks stopped");
+}
+
+export default {
+  initScheduler,
+  scheduleTask,
+  cancelTask,
+  getSchedulerStatus,
+  reloadTask,
+  stopScheduler,
+  scheduleOneTimeTask,
+  cancelOneTimeTask,
+};