omp-mobile 0.1.1 → 0.2.0

package/README.md

@@ -14,6 +14,8 @@
 OMP Mobile is a native phone app for [oh-my-pi](https://github.com/can1357/oh-my-pi) (OMP), with a small daemon on each computer. Start, follow and steer OMP sessions from the phone: transcript, tool calls, approvals, and the sessions you started in a terminal.
 
 - **Native app:** The app draws the transcript, tool cards, thinking, Markdown and composer itself. No WebView, no web page.
+- **The whole transcript:** images the user sent and images tools produce (screenshots, opened files), edit diffs with their intent, tool results, Markdown tables, OMP's todo list, context usage and queued messages.
+- **Model switching:** tap the model in the composer to pick from OMP's catalog — grouped by provider and searchable — and set its thinking level. The model chip follows the session when it changes.
 - **Approvals on the phone:** OMP's own tool approvals and questions arrive as a sheet, and the turn waits for your answer.
 - **Terminal sessions:** Sessions you started in a terminal on the computer are listed too and continue on the phone. One still open in a terminal waits until that terminal exits.
 - **Notifications:** Android notifications for approvals, questions, and finished turns while the app is in the background.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-mobile",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "The computer side of OMP Mobile: runs oh-my-pi sessions and serves them to the phone app over Tailscale.",
   "keywords": [
     "mobile",

package/src/rpc-session.mjs

@@ -35,6 +35,36 @@ const IGNORED_UI = new Set(["setStatus", "setWidget", "setTitle", "set_editor_te
  * @property {boolean} [autoApprove]
  */
 
+/**
+ * One entry of OMP's model catalog, cut to what a phone lists: provider, name,
+ * context window and input kinds. The full object carries endpoints, cost and
+ * compatibility fields the app never shows.
+ * @param {Record<string, unknown>} model
+ */
+export function compactModel(model) {
+  const thinking = model.thinking;
+  const cost = model.cost;
+  return {
+    provider: typeof model.provider === "string" ? model.provider : "",
+    id: typeof model.id === "string" ? model.id : "",
+    name: typeof model.name === "string" ? model.name : typeof model.id === "string" ? model.id : "",
+    reasoning: model.reasoning === true,
+    input: Array.isArray(model.input) ? model.input.filter((kind) => typeof kind === "string") : [],
+    contextWindow: typeof model.contextWindow === "number" ? model.contextWindow : undefined,
+    cost:
+      cost !== null && typeof cost === "object"
+        ? {
+            input: typeof cost.input === "number" ? cost.input : undefined,
+            output: typeof cost.output === "number" ? cost.output : undefined,
+          }
+        : undefined,
+    efforts:
+      thinking !== null && typeof thinking === "object" && Array.isArray(thinking.efforts)
+        ? thinking.efforts.filter((level) => typeof level === "string")
+        : undefined,
+  };
+}
+
 export class RpcSession extends EventEmitter {
   /** @param {RpcSessionOptions} options */
   constructor(options) {
@@ -228,6 +258,41 @@ export class RpcSession extends EventEmitter {
     return response.data ?? { messages: [] };
   }
 
+  /**
+   * The models this session can switch to, compacted for a phone list.
+   * OMP waits out background discovery first, so this can take a few seconds.
+   * @returns {Promise<ReturnType<typeof compactModel>[]>}
+   */
+  async availableModels() {
+    const response = await this.request("get_available_models");
+    const models = response.data?.models;
+    return Array.isArray(models) ? models.map(compactModel) : [];
+  }
+
+  /**
+   * Switch this session to another model. Returns the state afterwards: the
+   * model's thinking efforts decide which levels the phone may offer.
+   * @param {string} provider
+   * @param {string} modelId
+   */
+  async setModel(provider, modelId) {
+    await this.request("set_model", { provider, modelId });
+    return this.getState();
+  }
+
+  /** @returns {Promise<{levels: string[]}>} */
+  async availableThinkingLevels() {
+    const response = await this.request("get_available_thinking_levels");
+    const levels = response.data?.levels;
+    return { levels: Array.isArray(levels) ? levels.filter((level) => typeof level === "string") : [] };
+  }
+
+  /** @param {string} level */
+  async setThinkingLevel(level) {
+    await this.request("set_thinking_level", { level });
+    return this.getState();
+  }
+
   /** @param {string} text */
   async prompt(text) {
     return this.request("prompt", { message: text });

package/src/server.mjs

@@ -30,6 +30,20 @@ const DEFAULT_OMP_HOME = join(homedir(), ".omp");
 const MAX_BODY = 256 * 1024;
 /** Terminal sessions listed next to the daemon's own, newest first. */
 const OMP_SESSION_LIMIT = 50;
+/**
+ * Session events after which `get_state` differs from what the phone holds:
+ * the model or thinking level changed, or the todo/queue/goal panels moved.
+ */
+const STATE_EVENTS = new Set([
+  "model_changed",
+  "thinking_level_changed",
+  "queue_update",
+  "todo_reminder",
+  "todo_auto_clear",
+  "goal_updated",
+]);
+/** OMP's content-addressed image store under `<omp home>/agent/blobs`. */
+const BLOB_NAME = /^[0-9a-f]{64}$/;
 
 /** @typedef {{id: string, title: string, cwd: string, status: string, model?: string, createdAt: number, updatedAt: number, sessionFile?: string, origin: "daemon" | "omp", openElsewhere?: boolean}} SessionSummary */
 
@@ -225,6 +239,39 @@ function sendJson(res, status, body) {
   res.end(data);
 }
 
+/** What a stored blob is, from its first bytes: OMP keeps the extension off the hash name. */
+export function blobType(bytes) {
+  if (bytes.length >= 4 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "image/jpeg";
+  if (bytes.length >= 4 && bytes.toString("ascii", 0, 4) === "GIF8") return "image/gif";
+  return "application/octet-stream";
+}
+
+/** A stored image: `GET /blobs/<sha256>[.ext]`, authenticated like every other route. */
+function sendBlob(res, ompHome, name) {
+  if (!BLOB_NAME.test(name)) {
+    sendJson(res, 400, { error: "bad blob name" });
+    return;
+  }
+  const path = join(ompHome, "agent", "blobs", name);
+  if (!existsSync(path) || !statSync(path).isFile()) {
+    sendJson(res, 404, { error: "no such blob" });
+    return;
+  }
+  const bytes = readFileSync(path);
+  res.writeHead(200, {
+    "content-type": blobType(bytes),
+    "content-length": bytes.length,
+    "cache-control": "private, max-age=31536000, immutable",
+  });
+  res.end(bytes);
+}
+
 function readBody(req) {
   return new Promise((resolveBody, reject) => {
     let size = 0;
@@ -359,6 +406,9 @@ class SessionEntry {
           this.onChange?.(this);
         }
       }
+      if (STATE_EVENTS.has(event.type)) void this.refreshState();
+      // A `todo` tool call rewrites the list before any reminder fires.
+      if (event.type === "tool_execution_end" && event.toolName === "todo") void this.refreshState();
       if (event.type === "turn_end" || event.type === "agent_end") void this.refreshState();
       this.broadcast({ type: "event", event });
     });
@@ -488,6 +538,11 @@ class Daemon {
       return;
     }
     this.noteClient(req);
+    const blob = /^\/blobs\/([0-9a-f]{64})(?:\.[a-z0-9]+)?$/.exec(url.pathname);
+    if (blob !== null && req.method === "GET") {
+      sendBlob(res, this.options.ompHome, blob[1]);
+      return;
+    }
     if (url.pathname === "/status" && req.method === "GET") {
       sendJson(res, 200, {
         pid: process.pid,
@@ -730,6 +785,39 @@ class Daemon {
         case "refresh":
           await entry.refreshState();
           return;
+        case "models": {
+          const models = await entry.rpc.availableModels();
+          ws.send(JSON.stringify({ type: "models", models }));
+          return;
+        }
+        case "set_model": {
+          if (typeof message.provider !== "string" || typeof message.modelId !== "string") {
+            throw new Error("set_model needs provider and modelId");
+          }
+          const state = await entry.rpc.setModel(message.provider, message.modelId);
+          entry.state = state;
+          entry.updatedAt = Date.now();
+          entry.onChange?.(entry);
+          entry.broadcast({ type: "state", state });
+          ws.send(JSON.stringify({ type: "accepted", command: "set_model" }));
+          return;
+        }
+        case "thinking_levels": {
+          const { levels } = await entry.rpc.availableThinkingLevels();
+          ws.send(
+            JSON.stringify({ type: "thinking_levels", levels, current: entry.state?.thinkingLevel ?? null }),
+          );
+          return;
+        }
+        case "set_thinking_level": {
+          if (typeof message.level !== "string" || message.level === "") throw new Error("set_thinking_level needs a level");
+          const state = await entry.rpc.setThinkingLevel(message.level);
+          entry.state = state;
+          entry.updatedAt = Date.now();
+          entry.broadcast({ type: "state", state });
+          ws.send(JSON.stringify({ type: "accepted", command: "set_thinking_level" }));
+          return;
+        }
         default:
           throw new Error(`unknown command ${String(message.type)}`);
       }