@bytespell/shella 0.1.5 → 0.1.7

package/dist/bin/cli.js

@@ -0,0 +1,921 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// bin/cli.ts
+import { program } from "commander";
+import { networkInterfaces } from "os";
+import { spawn } from "child_process";
+import * as p from "@clack/prompts";
+
+// src/index.ts
+import express from "express";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { createExpressMiddleware } from "@trpc/server/adapters/express";
+import { applyWSSHandler } from "@trpc/server/adapters/ws";
+import { agentManager as agentManager2 } from "@bytespell/amux/agents/manager";
+import "@bytespell/amux/db";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+// src/lib/paths.ts
+import path from "path";
+import os from "os";
+import fs from "fs";
+function getDataDir() {
+  const home = os.homedir();
+  let dataDir;
+  switch (process.platform) {
+    case "darwin":
+      dataDir = path.join(home, "Library", "Application Support", "shella");
+      break;
+    case "win32":
+      dataDir = path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "shella");
+      break;
+    default:
+      dataDir = path.join(process.env.XDG_DATA_HOME || path.join(home, ".local", "share"), "shella");
+  }
+  return dataDir;
+}
+function isMockMode() {
+  return process.env.SHELLA_MOCK_MODE === "true";
+}
+function getShellaDbPath() {
+  const filename = isMockMode() ? "shella-ui.mock.db" : "shella-ui.db";
+  return path.join(getDataDir(), filename);
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  panes: () => panes,
+  uiState: () => uiState,
+  windows: () => windows
+});
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+var windows = sqliteTable("windows", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  hasCustomTitle: integer("has_custom_title", { mode: "boolean" }).notNull().default(false),
+  /** JSON-serialized LayoutNode tree */
+  layout: text("layout", { mode: "json" }).$type().notNull(),
+  activePaneId: text("active_pane_id").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`),
+  lastAccessedAt: integer("last_accessed_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+var panes = sqliteTable("panes", {
+  id: text("id").primaryKey(),
+  windowId: text("window_id").notNull().references(() => windows.id, { onDelete: "cascade" }),
+  /** References amux session ID (cross-database) */
+  sessionId: text("session_id").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+var uiState = sqliteTable("ui_state", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull()
+});
+
+// src/db/index.ts
+ensureDir(getDataDir());
+var sqlite = new Database(getShellaDbPath());
+sqlite.pragma("journal_mode = WAL");
+sqlite.pragma("foreign_keys = ON");
+var db = drizzle(sqlite, { schema: schema_exports });
+sqlite.exec(`
+  CREATE TABLE IF NOT EXISTS windows (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    has_custom_title INTEGER NOT NULL DEFAULT 0,
+    layout TEXT NOT NULL,
+    active_pane_id TEXT NOT NULL,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+    last_accessed_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+  );
+
+  CREATE TABLE IF NOT EXISTS panes (
+    id TEXT PRIMARY KEY,
+    window_id TEXT NOT NULL REFERENCES windows(id) ON DELETE CASCADE,
+    session_id TEXT NOT NULL,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+  );
+
+  CREATE TABLE IF NOT EXISTS ui_state (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`);
+
+// src/amuxBridge.ts
+import { randomUUID } from "crypto";
+import { eq, inArray } from "drizzle-orm";
+import { db as db2, schema } from "@bytespell/amux/db";
+import { agentManager } from "@bytespell/amux/agents/manager";
+import { clearEventsForSession } from "@bytespell/amux/agents/eventStore";
+import { listFilesForAutocomplete } from "@bytespell/amux/trpc/files";
+var { sessions, agentConfigs, appState } = schema;
+function createAmuxBridge() {
+  return {
+    async getSessions(ids) {
+      if (ids.length === 0) return [];
+      return db2.select().from(sessions).where(inArray(sessions.id, ids)).all();
+    },
+    async getSession(id) {
+      return db2.select().from(sessions).where(eq(sessions.id, id)).get() ?? null;
+    },
+    async createSession(params) {
+      let configId = params.agentConfigId;
+      if (!configId) {
+        const lastUsedRow = db2.select().from(appState).where(eq(appState.key, "last_used_agent_config_id")).get();
+        if (lastUsedRow?.value) {
+          const config = db2.select().from(agentConfigs).where(eq(agentConfigs.id, lastUsedRow.value)).get();
+          if (config) configId = config.id;
+        }
+        if (!configId) {
+          const firstConfig = db2.select().from(agentConfigs).get();
+          if (!firstConfig) {
+            throw new Error("No agent configs available");
+          }
+          configId = firstConfig.id;
+        }
+      } else {
+        db2.insert(appState).values({ key: "last_used_agent_config_id", value: configId }).onConflictDoUpdate({ target: appState.key, set: { value: configId } }).run();
+      }
+      const id = params.id ?? randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      db2.insert(sessions).values({
+        id,
+        directory: params.directory,
+        agentConfigId: configId,
+        acpSessionId: null,
+        model: null,
+        mode: null,
+        createdAt: now
+      }).run();
+      return db2.select().from(sessions).where(eq(sessions.id, id)).get();
+    },
+    async deleteSession(id) {
+      await agentManager.stopForSession(id);
+      clearEventsForSession(id);
+      db2.delete(sessions).where(eq(sessions.id, id)).run();
+    },
+    async getAgentConfigs() {
+      return db2.select().from(agentConfigs).all();
+    },
+    async startAgent(sessionId) {
+      return agentManager.startForSession(sessionId);
+    },
+    async stopAgent(sessionId) {
+      await agentManager.stopForSession(sessionId);
+    },
+    async prompt(sessionId, message) {
+      await agentManager.prompt(sessionId, message);
+    },
+    async cancel(sessionId) {
+      await agentManager.cancel(sessionId);
+    },
+    async setMode(sessionId, modeId) {
+      await agentManager.setMode(sessionId, modeId);
+    },
+    async setModel(sessionId, modelId) {
+      await agentManager.setModel(sessionId, modelId);
+    },
+    respondPermission(sessionId, requestId, optionId) {
+      agentManager.respondPermission(sessionId, requestId, optionId);
+    },
+    async switchAgent(sessionId, agentConfigId) {
+      await agentManager.stopForSession(sessionId);
+      clearEventsForSession(sessionId);
+      db2.update(sessions).set({
+        agentConfigId,
+        acpSessionId: null,
+        model: null,
+        mode: null
+      }).where(eq(sessions.id, sessionId)).run();
+      db2.insert(appState).values({ key: "last_used_agent_config_id", value: agentConfigId }).onConflictDoUpdate({ target: appState.key, set: { value: agentConfigId } }).run();
+    },
+    subscribeToSession(sessionId, callback) {
+      const handler = (event) => {
+        if (event.sessionId === sessionId) {
+          callback(event.update);
+        }
+      };
+      agentManager.on("update", handler);
+      return () => agentManager.off("update", handler);
+    },
+    async listFilesForAutocomplete(sessionId, partialPath, limit) {
+      const session = db2.select().from(sessions).where(eq(sessions.id, sessionId)).get();
+      if (!session) throw new Error(`Session ${sessionId} not found`);
+      return listFilesForAutocomplete(session.directory, partialPath, limit);
+    }
+  };
+}
+
+// src/trpc/trpc.ts
+import { initTRPC } from "@trpc/server";
+var t = initTRPC.create();
+var router = t.router;
+var publicProcedure = t.procedure;
+
+// src/trpc/windows.ts
+import { z } from "zod";
+import { randomUUID as randomUUID2 } from "crypto";
+import { eq as eq2 } from "drizzle-orm";
+
+// client/lib/layout.ts
+function createLeaf(paneId) {
+  return { type: "leaf", paneId };
+}
+function createBranch(direction, first, second, ratio = 50) {
+  return { type: "branch", direction, ratio, first, second };
+}
+function getAllPaneIds(node) {
+  if (node.type === "leaf") {
+    return [node.paneId];
+  }
+  return [...getAllPaneIds(node.first), ...getAllPaneIds(node.second)];
+}
+function findPanePath(node, paneId, path3 = []) {
+  if (node.type === "leaf") {
+    return node.paneId === paneId ? path3 : null;
+  }
+  const firstPath = findPanePath(node.first, paneId, [...path3, "first"]);
+  if (firstPath) return firstPath;
+  return findPanePath(node.second, paneId, [...path3, "second"]);
+}
+function replacePaneWithNode(root, paneId, newNode) {
+  if (root.type === "leaf") {
+    return root.paneId === paneId ? newNode : root;
+  }
+  return {
+    ...root,
+    first: replacePaneWithNode(root.first, paneId, newNode),
+    second: replacePaneWithNode(root.second, paneId, newNode)
+  };
+}
+function splitPane(root, paneId, newPaneId, direction) {
+  const originalLeaf = createLeaf(paneId);
+  const newLeaf = createLeaf(newPaneId);
+  const branch = createBranch(direction, originalLeaf, newLeaf);
+  return replacePaneWithNode(root, paneId, branch);
+}
+function removePane(root, paneId) {
+  if (root.type === "leaf") {
+    return root.paneId === paneId ? null : root;
+  }
+  if (root.first.type === "leaf" && root.first.paneId === paneId) {
+    return root.second;
+  }
+  if (root.second.type === "leaf" && root.second.paneId === paneId) {
+    return root.first;
+  }
+  const newFirst = removePane(root.first, paneId);
+  const newSecond = removePane(root.second, paneId);
+  if (newFirst === null) return newSecond;
+  if (newSecond === null) return newFirst;
+  if (newFirst !== root.first || newSecond !== root.second) {
+    return { ...root, first: newFirst, second: newSecond };
+  }
+  return root;
+}
+function updateRatio(root, path3, newRatio) {
+  if (path3.length === 0) {
+    if (root.type === "branch") {
+      return { ...root, ratio: Math.max(10, Math.min(90, newRatio)) };
+    }
+    return root;
+  }
+  if (root.type === "leaf") return root;
+  const [next, ...rest] = path3;
+  if (next === "first") {
+    return { ...root, first: updateRatio(root.first, rest, newRatio) };
+  } else {
+    return { ...root, second: updateRatio(root.second, rest, newRatio) };
+  }
+}
+function getAdjacentPane(root, currentPaneId, direction) {
+  const path3 = findPanePath(root, currentPaneId);
+  if (!path3) return null;
+  let node = root;
+  const pathNodes = [];
+  for (const step of path3) {
+    if (node.type === "branch") {
+      pathNodes.push({ node, childSide: step });
+      node = step === "first" ? node.first : node.second;
+    }
+  }
+  for (let i = pathNodes.length - 1; i >= 0; i--) {
+    const { node: branch, childSide } = pathNodes[i];
+    const isHorizontal = branch.direction === "horizontal";
+    const isVertical = branch.direction === "vertical";
+    const canMove = direction === "left" && isHorizontal && childSide === "second" || direction === "right" && isHorizontal && childSide === "first" || direction === "up" && isVertical && childSide === "second" || direction === "down" && isVertical && childSide === "first";
+    if (canMove) {
+      const otherChild = childSide === "first" ? branch.second : branch.first;
+      return getFirstPaneInDirection(otherChild, direction);
+    }
+  }
+  return null;
+}
+function getFirstPaneInDirection(node, fromDirection) {
+  if (node.type === "leaf") {
+    return node.paneId;
+  }
+  const isHorizontal = node.direction === "horizontal";
+  if (fromDirection === "left" || fromDirection === "up") {
+    const targetChild = isHorizontal ? fromDirection === "left" ? node.first : node.first : fromDirection === "up" ? node.first : node.first;
+    return getFirstPaneInDirection(targetChild, fromDirection);
+  } else {
+    const targetChild = isHorizontal ? fromDirection === "right" ? node.second : node.second : fromDirection === "down" ? node.second : node.second;
+    return getFirstPaneInDirection(targetChild, fromDirection);
+  }
+}
+
+// src/trpc/windows.ts
+var amux;
+function setAmuxBridge(bridge) {
+  amux = bridge;
+}
+function generateTitle(existingCount, directory) {
+  const dirName = directory.split("/").pop();
+  if (dirName && dirName !== "~" && dirName !== "") {
+    return dirName;
+  }
+  return `Window ${existingCount + 1}`;
+}
+var windowsRouter = router({
+  /**
+   * List all windows with their panes and sessions.
+   */
+  list: publicProcedure.query(async () => {
+    const allWindows = db.select().from(windows).orderBy(windows.createdAt).all();
+    const allPanes = db.select().from(panes).all();
+    const activeRow = db.select().from(uiState).where(eq2(uiState.key, "active_window_id")).get();
+    const sessionIds = [...new Set(allPanes.map((p2) => p2.sessionId))];
+    const sessionsData = await amux.getSessions(sessionIds);
+    const sessionMap = new Map(sessionsData.map((s) => [s.id, s]));
+    const agentConfigs2 = await amux.getAgentConfigs();
+    return {
+      windows: allWindows.map((w) => ({
+        ...w,
+        panes: allPanes.filter((p2) => p2.windowId === w.id).map((p2) => ({
+          ...p2,
+          session: sessionMap.get(p2.sessionId) ?? null
+        }))
+      })),
+      activeWindowId: activeRow?.value ?? allWindows[allWindows.length - 1]?.id ?? null,
+      agentConfigs: agentConfigs2
+    };
+  }),
+  /**
+   * Get a single window by ID.
+   */
+  get: publicProcedure.input(z.object({ id: z.string() })).query(async ({ input }) => {
+    const window = db.select().from(windows).where(eq2(windows.id, input.id)).get();
+    if (!window) {
+      throw new Error(`Window ${input.id} not found`);
+    }
+    const windowPanes = db.select().from(panes).where(eq2(panes.windowId, input.id)).all();
+    const sessionIds = windowPanes.map((p2) => p2.sessionId);
+    const sessionsData = await amux.getSessions(sessionIds);
+    const sessionMap = new Map(sessionsData.map((s) => [s.id, s]));
+    return {
+      ...window,
+      panes: windowPanes.map((p2) => ({
+        ...p2,
+        session: sessionMap.get(p2.sessionId) ?? null
+      }))
+    };
+  }),
+  /**
+   * Create a new window with a single pane.
+   */
+  create: publicProcedure.input(z.object({
+    id: z.string().optional(),
+    title: z.string().optional(),
+    directory: z.string().optional(),
+    agentConfigId: z.string().optional()
+  })).mutation(async ({ input }) => {
+    const directory = input.directory ?? process.cwd();
+    const session = await amux.createSession({
+      directory,
+      agentConfigId: input.agentConfigId
+    });
+    const windowId = input.id ?? randomUUID2();
+    const paneId = randomUUID2();
+    const existingCount = db.select().from(windows).all().length;
+    const layout = createLeaf(paneId);
+    db.insert(windows).values({
+      id: windowId,
+      title: input.title || generateTitle(existingCount, directory),
+      hasCustomTitle: !!input.title,
+      // Only true if title is non-empty string
+      layout,
+      activePaneId: paneId
+    }).run();
+    db.insert(panes).values({
+      id: paneId,
+      windowId,
+      sessionId: session.id
+    }).run();
+    db.insert(uiState).values({ key: "active_window_id", value: windowId }).onConflictDoUpdate({ target: uiState.key, set: { value: windowId } }).run();
+    const newWindow = db.select().from(windows).where(eq2(windows.id, windowId)).get();
+    const newPanes = db.select().from(panes).where(eq2(panes.windowId, windowId)).all();
+    return {
+      ...newWindow,
+      panes: newPanes.map((p2) => ({
+        ...p2,
+        session: p2.sessionId === session.id ? session : null
+      }))
+    };
+  }),
+  /**
+   * Update a window (title, etc).
+   */
+  update: publicProcedure.input(z.object({
+    id: z.string(),
+    title: z.string().optional()
+  })).mutation(async ({ input }) => {
+    const updates = {};
+    if (input.title !== void 0) {
+      updates.title = input.title;
+      updates.hasCustomTitle = true;
+    }
+    updates.lastAccessedAt = /* @__PURE__ */ new Date();
+    db.update(windows).set(updates).where(eq2(windows.id, input.id)).run();
+    return db.select().from(windows).where(eq2(windows.id, input.id)).get();
+  }),
+  /**
+   * Delete a window and all its panes/sessions.
+   */
+  delete: publicProcedure.input(z.object({ id: z.string() })).mutation(async ({ input }) => {
+    const windowPanes = db.select().from(panes).where(eq2(panes.windowId, input.id)).all();
+    for (const pane of windowPanes) {
+      await amux.deleteSession(pane.sessionId);
+    }
+    db.delete(windows).where(eq2(windows.id, input.id)).run();
+    const activeRow = db.select().from(uiState).where(eq2(uiState.key, "active_window_id")).get();
+    if (activeRow?.value === input.id) {
+      const remaining = db.select().from(windows).orderBy(windows.createdAt).all();
+      const newActiveId = remaining[remaining.length - 1]?.id ?? null;
+      if (newActiveId) {
+        db.update(uiState).set({ value: newActiveId }).where(eq2(uiState.key, "active_window_id")).run();
+      } else {
+        db.delete(uiState).where(eq2(uiState.key, "active_window_id")).run();
+      }
+    }
+    return { ok: true };
+  }),
+  /**
+   * Set the active window.
+   */
+  setActive: publicProcedure.input(z.object({ id: z.string() })).mutation(async ({ input }) => {
+    db.insert(uiState).values({ key: "active_window_id", value: input.id }).onConflictDoUpdate({ target: uiState.key, set: { value: input.id } }).run();
+    db.update(windows).set({ lastAccessedAt: /* @__PURE__ */ new Date() }).where(eq2(windows.id, input.id)).run();
+    return { ok: true };
+  })
+});
+
+// src/trpc/layout.ts
+import { z as z2 } from "zod";
+import { randomUUID as randomUUID3 } from "crypto";
+import { eq as eq3 } from "drizzle-orm";
+var amux2;
+function setAmuxBridge2(bridge) {
+  amux2 = bridge;
+}
+var layoutRouter = router({
+  /**
+   * Split a pane horizontally or vertically.
+   * Creates a new session in amux and a new pane in shella.
+   */
+  split: publicProcedure.input(z2.object({
+    windowId: z2.string(),
+    paneId: z2.string(),
+    direction: z2.enum(["horizontal", "vertical"]),
+    // Client can provide IDs for optimistic updates
+    newPaneId: z2.string().optional(),
+    newSessionId: z2.string().optional()
+  })).mutation(async ({ input }) => {
+    const sourcePane = db.select().from(panes).where(eq3(panes.id, input.paneId)).get();
+    if (!sourcePane) {
+      throw new Error(`Pane ${input.paneId} not found`);
+    }
+    const sourceSession = await amux2.getSession(sourcePane.sessionId);
+    if (!sourceSession) {
+      throw new Error(`Session ${sourcePane.sessionId} not found`);
+    }
+    const newSession = await amux2.createSession({
+      id: input.newSessionId,
+      directory: sourceSession.directory,
+      agentConfigId: sourceSession.agentConfigId
+    });
+    const newPaneId = input.newPaneId ?? randomUUID3();
+    db.insert(panes).values({
+      id: newPaneId,
+      windowId: input.windowId,
+      sessionId: newSession.id
+    }).run();
+    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    if (!window) {
+      throw new Error(`Window ${input.windowId} not found`);
+    }
+    const currentLayout = window.layout;
+    const newLayout = splitPane(currentLayout, input.paneId, newPaneId, input.direction);
+    db.update(windows).set({
+      layout: newLayout,
+      activePaneId: newPaneId,
+      lastAccessedAt: /* @__PURE__ */ new Date()
+    }).where(eq3(windows.id, input.windowId)).run();
+    await amux2.startAgent(newSession.id);
+    const now = /* @__PURE__ */ new Date();
+    return {
+      newPaneId,
+      newSessionId: newSession.id,
+      layout: newLayout,
+      // Match exact shape from windows.list: { ...pane, session }
+      newPane: {
+        id: newPaneId,
+        windowId: input.windowId,
+        sessionId: newSession.id,
+        createdAt: now.toISOString(),
+        session: {
+          id: newSession.id,
+          directory: newSession.directory,
+          agentConfigId: newSession.agentConfigId,
+          model: newSession.model,
+          mode: newSession.mode,
+          createdAt: newSession.createdAt.toISOString(),
+          acpSessionId: newSession.acpSessionId
+        }
+      }
+    };
+  }),
+  /**
+   * Close a pane. If it's the last pane, close the window.
+   */
+  closePane: publicProcedure.input(z2.object({
+    windowId: z2.string(),
+    paneId: z2.string()
+  })).mutation(async ({ input }) => {
+    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    if (!window) {
+      throw new Error(`Window ${input.windowId} not found`);
+    }
+    const pane = db.select().from(panes).where(eq3(panes.id, input.paneId)).get();
+    if (!pane) {
+      throw new Error(`Pane ${input.paneId} not found`);
+    }
+    const currentLayout = window.layout;
+    const allPaneIds = getAllPaneIds(currentLayout);
+    if (allPaneIds.length === 1) {
+      await amux2.deleteSession(pane.sessionId);
+      db.delete(windows).where(eq3(windows.id, input.windowId)).run();
+      return { windowClosed: true, layout: null, activePaneId: null };
+    }
+    await amux2.deleteSession(pane.sessionId);
+    db.delete(panes).where(eq3(panes.id, input.paneId)).run();
+    const newLayout = removePane(currentLayout, input.paneId);
+    if (!newLayout) {
+      throw new Error("Failed to remove pane from layout");
+    }
+    const newActivePaneId = window.activePaneId === input.paneId ? getAllPaneIds(newLayout)[0] : window.activePaneId;
+    db.update(windows).set({
+      layout: newLayout,
+      activePaneId: newActivePaneId,
+      lastAccessedAt: /* @__PURE__ */ new Date()
+    }).where(eq3(windows.id, input.windowId)).run();
+    return {
+      windowClosed: false,
+      layout: newLayout,
+      activePaneId: newActivePaneId
+    };
+  }),
+  /**
+   * Set the active pane within a window.
+   */
+  setActivePane: publicProcedure.input(z2.object({
+    windowId: z2.string(),
+    paneId: z2.string()
+  })).mutation(async ({ input }) => {
+    db.update(windows).set({
+      activePaneId: input.paneId,
+      lastAccessedAt: /* @__PURE__ */ new Date()
+    }).where(eq3(windows.id, input.windowId)).run();
+    return { ok: true };
+  }),
+  /**
+   * Navigate to an adjacent pane.
+   */
+  navigate: publicProcedure.input(z2.object({
+    windowId: z2.string(),
+    currentPaneId: z2.string(),
+    direction: z2.enum(["left", "right", "up", "down"])
+  })).mutation(async ({ input }) => {
+    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    if (!window) {
+      throw new Error(`Window ${input.windowId} not found`);
+    }
+    const currentLayout = window.layout;
+    const adjacentPaneId = getAdjacentPane(currentLayout, input.currentPaneId, input.direction);
+    if (adjacentPaneId) {
+      db.update(windows).set({
+        activePaneId: adjacentPaneId,
+        lastAccessedAt: /* @__PURE__ */ new Date()
+      }).where(eq3(windows.id, input.windowId)).run();
+      return { newActivePaneId: adjacentPaneId };
+    }
+    return { newActivePaneId: null };
+  }),
+  /**
+   * Update the split ratio at a specific position.
+   */
+  setRatio: publicProcedure.input(z2.object({
+    windowId: z2.string(),
+    path: z2.array(z2.enum(["first", "second"])),
+    ratio: z2.number().min(10).max(90)
+  })).mutation(async ({ input }) => {
+    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    if (!window) {
+      throw new Error(`Window ${input.windowId} not found`);
+    }
+    const currentLayout = window.layout;
+    const newLayout = updateRatio(currentLayout, input.path, input.ratio);
+    db.update(windows).set({ layout: newLayout }).where(eq3(windows.id, input.windowId)).run();
+    return { layout: newLayout };
+  })
+});
+
+// src/trpc/agents.ts
+import { z as z3 } from "zod";
+import { eq as eq4 } from "drizzle-orm";
+import { observable } from "@trpc/server/observable";
+var amux3;
+function setAmuxBridge3(bridge) {
+  amux3 = bridge;
+}
+var paneInput = z3.object({
+  paneId: z3.string()
+});
+function getSessionIdForPane(paneId) {
+  const pane = db.select().from(panes).where(eq4(panes.id, paneId)).get();
+  if (!pane) {
+    throw new Error(`Pane ${paneId} not found`);
+  }
+  return pane.sessionId;
+}
+var agentsRouter = router({
+  /**
+   * Start agent for a pane.
+   */
+  start: publicProcedure.input(paneInput).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    return amux3.startAgent(sessionId);
+  }),
+  /**
+   * Stop agent for a pane.
+   */
+  stop: publicProcedure.input(paneInput).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    await amux3.stopAgent(sessionId);
+    return { ok: true };
+  }),
+  /**
+   * Send a prompt to a pane's agent.
+   */
+  prompt: publicProcedure.input(z3.object({
+    paneId: z3.string(),
+    message: z3.string()
+  })).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    await amux3.prompt(sessionId, input.message);
+    return { ok: true };
+  }),
+  /**
+   * Cancel the current prompt.
+   */
+  cancel: publicProcedure.input(paneInput).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    await amux3.cancel(sessionId);
+    return { ok: true };
+  }),
+  /**
+   * Set agent mode.
+   */
+  setMode: publicProcedure.input(z3.object({
+    paneId: z3.string(),
+    modeId: z3.string()
+  })).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    await amux3.setMode(sessionId, input.modeId);
+    return { ok: true };
+  }),
+  /**
+   * Set agent model.
+   */
+  setModel: publicProcedure.input(z3.object({
+    paneId: z3.string(),
+    modelId: z3.string()
+  })).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    await amux3.setModel(sessionId, input.modelId);
+    return { ok: true };
+  }),
+  /**
+   * Respond to a permission request.
+   */
+  respondPermission: publicProcedure.input(z3.object({
+    paneId: z3.string(),
+    requestId: z3.string(),
+    optionId: z3.string()
+  })).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    amux3.respondPermission(sessionId, input.requestId, input.optionId);
+    return { ok: true };
+  }),
+  /**
+   * Switch to a different agent.
+   */
+  switchAgent: publicProcedure.input(z3.object({
+    paneId: z3.string(),
+    agentConfigId: z3.string()
+  })).mutation(async ({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    await amux3.switchAgent(sessionId, input.agentConfigId);
+    return { ok: true };
+  }),
+  /**
+   * Subscribe to updates for a pane's agent session.
+   */
+  subscribe: publicProcedure.input(paneInput).subscription(({ input }) => {
+    const sessionId = getSessionIdForPane(input.paneId);
+    return observable((emit) => {
+      return amux3.subscribeToSession(sessionId, (update) => {
+        emit.next(update);
+      });
+    });
+  })
+});
+
+// src/trpc/files.ts
+import { z as z4 } from "zod";
+import { eq as eq5 } from "drizzle-orm";
+var amux4;
+function setAmuxBridge4(bridge) {
+  amux4 = bridge;
+}
+function getSessionIdForPane2(paneId) {
+  const pane = db.select().from(panes).where(eq5(panes.id, paneId)).get();
+  if (!pane) {
+    throw new Error(`Pane ${paneId} not found`);
+  }
+  return pane.sessionId;
+}
+var filesRouter = router({
+  /**
+   * List files/directories matching a partial path for autocomplete.
+   * Returns files in the session's working directory.
+   */
+  listForAutocomplete: publicProcedure.input(z4.object({
+    paneId: z4.string(),
+    partialPath: z4.string(),
+    limit: z4.number().default(20)
+  })).query(async ({ input }) => {
+    const sessionId = getSessionIdForPane2(input.paneId);
+    return amux4.listFilesForAutocomplete(sessionId, input.partialPath, input.limit);
+  })
+});
+
+// src/trpc/router.ts
+function initializeRouters(amux5) {
+  setAmuxBridge(amux5);
+  setAmuxBridge2(amux5);
+  setAmuxBridge3(amux5);
+  setAmuxBridge4(amux5);
+}
+var shellaRouter = router({
+  windows: windowsRouter,
+  layout: layoutRouter,
+  agents: agentsRouter,
+  files: filesRouter
+});
+
+// src/index.ts
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+function createShellaServer(options = {}) {
+  const port = options.port ?? 3067;
+  const amuxBridge = createAmuxBridge();
+  initializeRouters(amuxBridge);
+  const app = express();
+  app.use(express.json());
+  const publicPath = path2.join(__dirname, "..", "public");
+  app.use(express.static(publicPath));
+  app.use("/trpc", createExpressMiddleware({ router: shellaRouter }));
+  app.get("/health", (_req, res) => res.json({ status: "ok" }));
+  app.get("/{*splat}", (_req, res) => {
+    res.sendFile(path2.join(publicPath, "index.html"));
+  });
+  const server = createServer(app);
+  const wss = new WebSocketServer({ server, path: "/trpc" });
+  applyWSSHandler({ wss, router: shellaRouter });
+  return {
+    start: () => {
+      return new Promise((resolve) => {
+        server.listen(port, () => {
+          const url = `http://localhost:${port}`;
+          console.log(`[shella] Running on ${url}`);
+          options.onReady?.(url);
+          resolve();
+        });
+      });
+    },
+    stop: async () => {
+      console.log("[shella] Shutting down...");
+      wss.close();
+      await agentManager2.stopAll();
+      server.close();
+    }
+  };
+}
+
+// bin/cli.ts
+var VERSION = "0.1.0";
+var BRAND = "\x1B[38;2;99;102;241m";
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var brand = (text2) => `${BRAND}${text2}${RESET}`;
+var dim = (text2) => `${DIM}${text2}${RESET}`;
+function getLanIp() {
+  const interfaces = networkInterfaces();
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    if (/^(lo|docker|veth|br-|virbr)/.test(name)) continue;
+    for (const addr of addrs || []) {
+      if (addr.family === "IPv4" && !addr.internal) {
+        return addr.address;
+      }
+    }
+  }
+  return "localhost";
+}
+async function startCommand(options) {
+  const port = parseInt(options.port, 10);
+  const verbose = options.verbose;
+  const s = verbose ? null : p.spinner();
+  const log2 = (msg) => verbose && console.log(msg);
+  if (!verbose) {
+    p.intro(`${brand("shella")} ${dim(`v${VERSION}`)}`);
+  } else {
+    log2(`${brand("shella")} ${dim(`v${VERSION}`)}`);
+  }
+  if (s) s.start("Starting server...");
+  else log2("Starting server...");
+  const shella = createShellaServer({
+    port,
+    onReady: (url) => {
+      if (s) s.stop("Ready");
+      const lanIp = getLanIp();
+      const lanUrl = `http://${lanIp}:${port}`;
+      if (verbose) {
+        log2(`
+${brand(lanUrl)}`);
+        log2(dim("access from any device"));
+        log2(`
+${dim("press ctrl+c to stop")}
+`);
+      } else {
+        p.log.success(`${brand(lanUrl)}`);
+        p.log.message(dim("access from any device"));
+        p.outro(dim("press ctrl+c to stop"));
+      }
+      if (options.open) {
+        const openCommand = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        spawn(openCommand, [url], { stdio: "ignore", detached: true }).unref();
+      }
+    }
+  });
+  await shella.start();
+  const shutdown = async () => {
+    console.log("");
+    console.log(dim("stopping..."));
+    await shella.stop();
+    console.log(`${brand("shella")} ${dim("stopped")}`);
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+program.name("shella").description(`${brand("shella")} - Self-hosted AI coding agents. Access from your phone.`).version(VERSION).option("-p, --port <port>", "Server port", "3067").option("--no-open", "Don't open browser automatically").option("-v, --verbose", "Show detailed logs", false).action(startCommand);
+program.parse();
+//# sourceMappingURL=cli.js.map