@shmulikdav/solix 1.1.1 → 1.2.0

package/dist/index.js

@@ -671,11 +671,231 @@ function install(opts = {}) {
   console.log(`[solix] merged hooks into ${CLAUDE_SETTINGS}`);
 }
 
-// src/skills.ts
+// src/install-shim.ts
+import {
+  appendFileSync,
+  existsSync as existsSync4,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { basename, join as join5 } from "path";
+var BLOCK_START = "# >>> solix shim >>>";
+var BLOCK_END = "# <<< solix shim <<<";
+function detectShellRcPath() {
+  const shell = process.env.SHELL ?? "";
+  const home = homedir3();
+  if (shell.endsWith("zsh") || existsSync4(join5(home, ".zshrc"))) {
+    return join5(home, ".zshrc");
+  }
+  if (shell.endsWith("bash") || existsSync4(join5(home, ".bashrc"))) {
+    return join5(home, ".bashrc");
+  }
+  if (existsSync4(join5(home, ".bash_profile"))) {
+    return join5(home, ".bash_profile");
+  }
+  return null;
+}
+function readRc(rcPath) {
+  return existsSync4(rcPath) ? readFileSync3(rcPath, "utf8") : "";
+}
+function blockText() {
+  return [
+    BLOCK_START,
+    "# Aliases `claude` to `solix run` so every claude session is wrapped",
+    "# by Solix. The Solix UI composer becomes write-enabled for these.",
+    "# Remove with `solix uninstall` (or delete this block manually).",
+    "alias claude='solix run'",
+    BLOCK_END,
+    ""
+  ].join("\n");
+}
+function installShim() {
+  const rcPath = detectShellRcPath();
+  if (!rcPath) {
+    console.error(
+      "[solix] couldn't find a shell rc file (.zshrc / .bashrc). Add `alias claude='solix run'` manually to your shell config."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const current = readRc(rcPath);
+  if (current.includes(BLOCK_START)) {
+    console.log(`[solix] shim already installed in ${rcPath}`);
+    return;
+  }
+  const prefix = current.endsWith("\n") || current.length === 0 ? "" : "\n";
+  appendFileSync(rcPath, prefix + "\n" + blockText());
+  console.log(`[solix] shim added to ${basename(rcPath)}.`);
+  console.log(
+    `[solix] run \`exec $SHELL\` (or open a new terminal) to activate, then \`claude\` will route through \`solix run\`.`
+  );
+}
+function uninstallShim() {
+  const rcPath = detectShellRcPath();
+  if (!rcPath) return false;
+  const current = readRc(rcPath);
+  if (!current.includes(BLOCK_START)) return false;
+  const startIdx = current.indexOf(BLOCK_START);
+  const endIdx = current.indexOf(BLOCK_END);
+  if (endIdx < 0) return false;
+  const before = current.slice(0, startIdx).replace(/\n+$/, "\n");
+  const after = current.slice(endIdx + BLOCK_END.length).replace(/^\n+/, "");
+  writeFileSync3(rcPath, before + after);
+  console.log(`[solix] shim removed from ${basename(rcPath)}.`);
+  return true;
+}
+
+// src/run.ts
+import { createServer as createUnixServer } from "net";
+import { mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+import { nanoid } from "nanoid";
 var PORT4 = process.env.SOLIX_PORT ?? "4242";
 var BASE4 = `http://127.0.0.1:${PORT4}`;
+async function registerWithServer(payload) {
+  try {
+    const res = await fetch(`${BASE4}/api/wrappers/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(800)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function unregisterFromServer(wrapperId) {
+  try {
+    await fetch(
+      `${BASE4}/api/wrappers/${encodeURIComponent(wrapperId)}/unregister`,
+      { method: "POST", signal: AbortSignal.timeout(800) }
+    );
+  } catch {
+  }
+}
+async function runWrapped(args) {
+  let pty;
+  try {
+    pty = await import("node-pty");
+  } catch (err) {
+    console.error(
+      "[solix run] node-pty failed to load. Bidirectional chat needs a working PTY; on most platforms a clean `pnpm install` (or `npm rebuild`) fixes it."
+    );
+    console.error(`[solix run] underlying error: ${err.message}`);
+    process.exit(1);
+  }
+  const wrapperId = nanoid(10);
+  const sockDir = join6(homedir4(), ".solix", "wrappers");
+  mkdirSync2(sockDir, { recursive: true });
+  const socketPath = join6(sockDir, `${wrapperId}.sock`);
+  const cwd = process.cwd();
+  const registered = await registerWithServer({ wrapperId, socketPath, cwd });
+  const cols = process.stdout.columns ?? 80;
+  const rows = process.stdout.rows ?? 24;
+  const term = pty.spawn("claude", args, {
+    name: process.env.TERM ?? "xterm-256color",
+    cols,
+    rows,
+    cwd,
+    env: { ...process.env, SOLIX_WRAPPER_ID: wrapperId }
+  });
+  const wasRaw = Boolean(process.stdin.isTTY);
+  if (wasRaw) process.stdin.setRawMode?.(true);
+  process.stdin.resume();
+  const onStdin = (chunk) => {
+    term.write(chunk.toString("utf8"));
+  };
+  process.stdin.on("data", onStdin);
+  term.onData((d) => {
+    process.stdout.write(d);
+  });
+  const onResize = () => {
+    term.resize(process.stdout.columns ?? 80, process.stdout.rows ?? 24);
+  };
+  process.stdout.on("resize", onResize);
+  const sockServer = createUnixServer((conn) => {
+    let buf = "";
+    conn.setEncoding("utf8");
+    conn.on("data", (chunk) => {
+      buf += chunk;
+      let i = buf.indexOf("\n");
+      while (i >= 0) {
+        const line = buf.slice(0, i).trim();
+        buf = buf.slice(i + 1);
+        if (line) {
+          try {
+            const msg = JSON.parse(line);
+            if (msg.type === "send_prompt" && typeof msg.text === "string") {
+              term.write(msg.text + "\r");
+            }
+          } catch {
+          }
+        }
+        i = buf.indexOf("\n");
+      }
+    });
+    conn.on("error", () => {
+    });
+  });
+  sockServer.on("error", (err) => {
+    console.error(`[solix run] socket error: ${err.message}`);
+  });
+  sockServer.listen(socketPath);
+  if (registered) {
+    process.stderr.write(
+      `[solix run] wrapped \u2014 UI prompts to this session will land here. Don't type a prompt while the UI is sending one.
+`
+    );
+  } else {
+    process.stderr.write(
+      `[solix run] note: Solix server not reachable at ${BASE4}; claude will run normally, but the UI composer won't be active.
+`
+    );
+  }
+  let cleaned = false;
+  const cleanup = async (exitCode = 0) => {
+    if (cleaned) return;
+    cleaned = true;
+    try {
+      sockServer.close();
+    } catch {
+    }
+    try {
+      unlinkSync(socketPath);
+    } catch {
+    }
+    if (registered) await unregisterFromServer(wrapperId);
+    process.stdin.removeListener("data", onStdin);
+    process.stdout.removeListener("resize", onResize);
+    if (wasRaw) {
+      try {
+        process.stdin.setRawMode?.(false);
+      } catch {
+      }
+    }
+    process.exit(exitCode);
+  };
+  term.onExit(({ exitCode }) => {
+    void cleanup(exitCode ?? 0);
+  });
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(sig, () => {
+      try {
+        term.kill();
+      } catch {
+      }
+    });
+  }
+}
+
+// src/skills.ts
+var PORT5 = process.env.SOLIX_PORT ?? "4242";
+var BASE5 = `http://127.0.0.1:${PORT5}`;
 async function api3(path, init) {
-  const res = await fetch(`${BASE4}${path}`, init);
+  const res = await fetch(`${BASE5}${path}`, init);
   if (!res.ok) {
     const text = await res.text().catch(() => "");
     throw new Error(`HTTP ${res.status} on ${path}: ${text}`);
@@ -699,7 +919,7 @@ async function listSkillsCmd() {
       );
     }
   } catch (err) {
-    console.error(`[solix] could not reach server at ${BASE4}: ${String(err)}`);
+    console.error(`[solix] could not reach server at ${BASE5}: ${String(err)}`);
     process.exitCode = 1;
   }
 }
@@ -765,16 +985,16 @@ var Broadcaster = class {
 import Database from "better-sqlite3";
 
 // ../server/src/paths.ts
-import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
-import { mkdirSync as mkdirSync2 } from "fs";
-var SOLIX_HOME2 = process.env.SOLIX_HOME ?? join5(homedir3(), ".solix");
-var DB_PATH = join5(SOLIX_HOME2, "solix.db");
-var HOOKS_DIR2 = join5(SOLIX_HOME2, "hooks");
-var LOG_PATH = join5(SOLIX_HOME2, "solix.log");
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+var SOLIX_HOME2 = process.env.SOLIX_HOME ?? join7(homedir5(), ".solix");
+var DB_PATH = join7(SOLIX_HOME2, "solix.db");
+var HOOKS_DIR2 = join7(SOLIX_HOME2, "hooks");
+var LOG_PATH = join7(SOLIX_HOME2, "solix.log");
 function ensureSolixHome() {
-  mkdirSync2(SOLIX_HOME2, { recursive: true });
-  mkdirSync2(HOOKS_DIR2, { recursive: true });
+  mkdirSync3(SOLIX_HOME2, { recursive: true });
+  mkdirSync3(HOOKS_DIR2, { recursive: true });
 }
 
 // ../server/src/db.ts
@@ -927,6 +1147,7 @@ function getDb() {
   ensureColumn(db, "sessions", "kind", "kind TEXT NOT NULL DEFAULT 'user'");
   ensureColumn(db, "sessions", "advisor_role", "advisor_role TEXT");
   ensureColumn(db, "sessions", "worktree_path", "worktree_path TEXT");
+  ensureColumn(db, "sessions", "wrapper_socket_path", "wrapper_socket_path TEXT");
   ensureColumn(db, "advisors", "texture_pack", "texture_pack TEXT");
   ensureColumn(db, "missions", "error_summary", "error_summary TEXT");
   _db = db;
@@ -934,8 +1155,8 @@ function getDb() {
 }
 
 // ../server/src/http.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
-import { dirname as dirname4, extname, join as join8, resolve as resolve3 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
+import { dirname as dirname4, extname, join as join10, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { spawnSync } from "child_process";
 import { Hono } from "hono";
@@ -943,12 +1164,12 @@ import { cors } from "hono/cors";
 
 // ../server/src/util.ts
 import { createHash } from "crypto";
-import { basename } from "path";
+import { basename as basename2 } from "path";
 function hashCwd(cwd) {
   return createHash("sha1").update(cwd).digest("hex").slice(0, 12);
 }
 function projectNameFromCwd(cwd) {
-  return basename(cwd) || cwd;
+  return basename2(cwd) || cwd;
 }
 function now() {
   return Date.now();
@@ -1013,7 +1234,8 @@ function rowToSession(row) {
     lastCompletedMissionId: row.last_completed_mission_id ?? void 0,
     orbitSlot: row.orbit_slot,
     name: row.name ?? void 0,
-    worktreePath: row.worktree_path ?? void 0
+    worktreePath: row.worktree_path ?? void 0,
+    wrapperSocketPath: row.wrapper_socket_path ?? void 0
   };
 }
 function nextOrbitSlot(db, projectId) {
@@ -1048,9 +1270,9 @@ function upsertSession(db, input) {
     `INSERT INTO sessions (
        id, pid, project_id, parent_session_id, origin, model, status,
        context_usage_pct, orbit_slot, cwd, name, kind, advisor_role,
-       worktree_path, created_at, updated_at
+       worktree_path, wrapper_socket_path, created_at, updated_at
      )
-     VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, NULL, ?, ?, ?, ?, ?)`
+     VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`
   ).run(
     input.id,
     input.pid,
@@ -1064,6 +1286,7 @@ function upsertSession(db, input) {
     kind,
     input.advisorRole ?? null,
     input.worktreePath ?? null,
+    input.wrapperSocketPath ?? null,
     ts2,
     ts2
   );
@@ -1082,7 +1305,8 @@ function upsertSession(db, input) {
     parentSessionId: input.parentSessionId,
     contextUsagePct: 0,
     orbitSlot,
-    worktreePath: input.worktreePath
+    worktreePath: input.worktreePath,
+    wrapperSocketPath: input.wrapperSocketPath
   };
 }
 function setSessionStatus(db, sessionId, status) {
@@ -1135,7 +1359,7 @@ function listSessionsForProject(db, projectId) {
 }
 
 // ../server/src/state/missions.ts
-import { nanoid } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 function rowToMission(row) {
   let filesTouched = [];
   try {
@@ -1178,7 +1402,7 @@ function shortNameFromPrompt(prompt) {
   ).filter(Boolean).join(" ") || "New Mission";
 }
 function startMission(db, sessionId, prompt) {
-  const id = nanoid();
+  const id = nanoid2();
   const ts2 = now();
   const shortName = shortNameFromPrompt(prompt);
   db.prepare(
@@ -1357,7 +1581,7 @@ function loadTimeline(db, opts = {}) {
 }
 
 // ../server/src/state/audit.ts
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid as nanoid3 } from "nanoid";
 function rowToAuditEvent(row) {
   let payload;
   if (row.payload_json) {
@@ -1380,7 +1604,7 @@ function rowToAuditEvent(row) {
 }
 function recordAudit(db, input) {
   const event = {
-    id: nanoid2(),
+    id: nanoid3(),
     ts: Date.now(),
     kind: input.kind,
     sessionId: input.sessionId,
@@ -1435,11 +1659,11 @@ function listAudit(db, opts = {}) {
 }
 
 // ../server/src/state/advisors.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join6, resolve } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join8, resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findAgentsDir() {
-  if (process.env.SOLIX_AGENTS_DIR && existsSync4(process.env.SOLIX_AGENTS_DIR)) {
+  if (process.env.SOLIX_AGENTS_DIR && existsSync5(process.env.SOLIX_AGENTS_DIR)) {
     return process.env.SOLIX_AGENTS_DIR;
   }
   const here = dirname2(fileURLToPath2(import.meta.url));
@@ -1452,17 +1676,17 @@ function findAgentsDir() {
     resolve(process.cwd(), "packages", "agents")
   ];
   for (const c of candidates) {
-    if (existsSync4(join6(c, "manifest.json"))) return c;
+    if (existsSync5(join8(c, "manifest.json"))) return c;
   }
   return candidates[0];
 }
 var AGENTS_DIR = findAgentsDir();
 function readManifest() {
-  const path = join6(AGENTS_DIR, "manifest.json");
-  if (!existsSync4(path)) {
+  const path = join8(AGENTS_DIR, "manifest.json");
+  if (!existsSync5(path)) {
     return { version: 1, advisors: [] };
   }
-  return JSON.parse(readFileSync3(path, "utf8"));
+  return JSON.parse(readFileSync4(path, "utf8"));
 }
 function rowToAdvisor(row) {
   let requiredSkills = [];
@@ -1505,7 +1729,7 @@ function seedAdvisors(db) {
      WHERE id = ?`
   );
   for (const a of manifest.advisors) {
-    const md = join6(AGENTS_DIR, a.agentMd);
+    const md = join8(AGENTS_DIR, a.agentMd);
     insert.run(
       a.id,
       a.role,
@@ -1563,10 +1787,55 @@ function setAdvisorPinned(db, id, pinned, sessionId) {
   return getAdvisor(db, id);
 }
 function readAdvisorAgentMd(advisor) {
-  if (!existsSync4(advisor.agentMdPath)) {
+  if (!existsSync5(advisor.agentMdPath)) {
     return "";
   }
-  return readFileSync3(advisor.agentMdPath, "utf8");
+  return readFileSync4(advisor.agentMdPath, "utf8");
+}
+
+// ../server/src/state/wrappers.ts
+import { connect } from "net";
+var wrappers = /* @__PURE__ */ new Map();
+var FRESHNESS_WINDOW_MS = 6e4;
+function registerWrapper(rec) {
+  wrappers.set(rec.wrapperId, rec);
+}
+function unregisterWrapper(wrapperId) {
+  wrappers.delete(wrapperId);
+}
+function claimWrapperForCwd(cwd) {
+  const now2 = Date.now();
+  let best;
+  for (const rec of wrappers.values()) {
+    if (rec.cwd !== cwd) continue;
+    if (now2 - rec.registeredAt > FRESHNESS_WINDOW_MS) continue;
+    if (!best || rec.registeredAt > best.registeredAt) best = rec;
+  }
+  if (best) {
+    wrappers.delete(best.wrapperId);
+  }
+  return best;
+}
+function writeToWrapperSocket(socketPath, text) {
+  try {
+    const client = connect(socketPath);
+    let settled = false;
+    client.on("error", () => {
+      if (!settled) {
+        settled = true;
+        try {
+          client.destroy();
+        } catch {
+        }
+      }
+    });
+    client.write(JSON.stringify({ type: "send_prompt", text }) + "\n");
+    client.end();
+    settled = true;
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 // ../server/src/state/context.ts
@@ -1656,10 +1925,10 @@ function buildContextEnvelope(db, args) {
 }
 
 // ../server/src/state/skills.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import { dirname as dirname3, join as join7, resolve as resolve2 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { dirname as dirname3, join as join9, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir6 } from "os";
 function findSolixSkillsDir() {
   const here = dirname3(fileURLToPath3(import.meta.url));
   const candidates = [
@@ -1668,15 +1937,15 @@ function findSolixSkillsDir() {
     resolve2(process.cwd(), "packages", "skills")
   ];
   for (const c of candidates) {
-    if (existsSync5(c)) return c;
+    if (existsSync6(c)) return c;
   }
   return candidates[0];
 }
 var SOLIX_SKILLS_DIR2 = findSolixSkillsDir();
-var ANTHROPIC_SKILLS_DIR = join7(homedir4(), ".claude", "skills");
+var ANTHROPIC_SKILLS_DIR = join9(homedir6(), ".claude", "skills");
 function parseSkillManifest(manifestPath, fallbackId) {
   try {
-    const txt = readFileSync4(manifestPath, "utf8");
+    const txt = readFileSync5(manifestPath, "utf8");
     const match = txt.match(/^---\n([\s\S]*?)\n---/);
     let name = fallbackId;
     let description = "";
@@ -1725,9 +1994,9 @@ function discoverSkills(db) {
     { dir: SOLIX_SKILLS_DIR2, source: "solix" }
   ];
   for (const { dir, source } of sources) {
-    if (!existsSync5(dir)) continue;
+    if (!existsSync6(dir)) continue;
     for (const entry of readdirSync3(dir)) {
-      const full = join7(dir, entry);
+      const full = join9(dir, entry);
       let isDir = false;
       try {
         isDir = statSync3(full).isDirectory();
@@ -1735,8 +2004,8 @@ function discoverSkills(db) {
         continue;
       }
       if (!isDir) continue;
-      const manifestPath = join7(full, "SKILL.md");
-      if (!existsSync5(manifestPath)) continue;
+      const manifestPath = join9(full, "SKILL.md");
+      if (!existsSync6(manifestPath)) continue;
       const parsed = parseSkillManifest(manifestPath, entry);
       if (!parsed) continue;
       const id = `${source}:${parsed.id}`;
@@ -1761,8 +2030,8 @@ function getSkill(db, id) {
   return row ? rowToSkill(row) : null;
 }
 function readSkillManifest(skill) {
-  if (!existsSync5(skill.manifestPath)) return "";
-  return readFileSync4(skill.manifestPath, "utf8");
+  if (!existsSync6(skill.manifestPath)) return "";
+  return readFileSync5(skill.manifestPath, "utf8");
 }
 function recordSkillInstall(db, skillId, projectId) {
   const skill = getSkill(db, skillId);
@@ -1775,7 +2044,7 @@ function recordSkillInstall(db, skillId, projectId) {
 }
 
 // ../server/src/state/galaxy.ts
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid4 } from "nanoid";
 function exportManifest(db, opts = {}) {
   const advisors2 = listAdvisors(db);
   const skills2 = listSkills(db);
@@ -1823,7 +2092,7 @@ function importManifest(db, manifest, sourceUrl) {
   db.prepare(
     `INSERT INTO galaxy_imports (id, source_url, manifest_json, imported_at)
      VALUES (?, ?, ?, ?)`
-  ).run(nanoid3(), sourceUrl ?? null, JSON.stringify(manifest), now());
+  ).run(nanoid4(), sourceUrl ?? null, JSON.stringify(manifest), now());
   return {
     advisorsEnabled: enabled,
     advisorsDisabled: disabled,
@@ -1884,7 +2153,7 @@ function snapshotExport(db, manifest) {
       return rowToVersion(existing);
     }
   }
-  const id = nanoid3();
+  const id = nanoid4();
   const ts2 = now();
   const ordinal = (last?.ordinal ?? 0) + 1;
   db.prepare(
@@ -2278,6 +2547,23 @@ function createHttpApp(opts) {
     }
   });
   app.get("/api/galaxy/imports", (c) => c.json(listImportHistory(opts.db)));
+  app.post("/api/wrappers/register", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body?.wrapperId || !body.socketPath || !body.cwd) {
+      return c.json({ error: "wrapperId, socketPath, cwd required" }, 400);
+    }
+    registerWrapper({
+      wrapperId: body.wrapperId,
+      socketPath: body.socketPath,
+      cwd: body.cwd,
+      registeredAt: Date.now()
+    });
+    return c.json({ ok: true });
+  });
+  app.post("/api/wrappers/:id/unregister", (c) => {
+    unregisterWrapper(c.req.param("id"));
+    return c.json({ ok: true });
+  });
   let preflightCache = null;
   app.get("/api/system/preflight", (c) => {
     if (preflightCache) return c.json(preflightCache);
@@ -2307,17 +2593,17 @@ function createHttpApp(opts) {
         return c.notFound();
       }
       const safe = url.pathname.replace(/\.\.+/g, ".");
-      const candidate = join8(webDist, safe === "/" ? "index.html" : safe);
+      const candidate = join10(webDist, safe === "/" ? "index.html" : safe);
       let filePath = candidate;
       try {
-        if (!existsSync6(filePath) || statSync4(filePath).isDirectory()) {
-          filePath = join8(webDist, "index.html");
+        if (!existsSync7(filePath) || statSync4(filePath).isDirectory()) {
+          filePath = join10(webDist, "index.html");
         }
       } catch {
-        filePath = join8(webDist, "index.html");
+        filePath = join10(webDist, "index.html");
       }
-      if (!existsSync6(filePath)) return c.notFound();
-      const data = readFileSync5(filePath);
+      if (!existsSync7(filePath)) return c.notFound();
+      const data = readFileSync6(filePath);
       return new Response(data, {
         headers: { "Content-Type": mimeFor(filePath) }
       });
@@ -2375,7 +2661,7 @@ function createHttpApp(opts) {
 }
 function findWebDist() {
   if (process.env.SOLIX_WEB_DIST) {
-    return existsSync6(process.env.SOLIX_WEB_DIST) ? process.env.SOLIX_WEB_DIST : null;
+    return existsSync7(process.env.SOLIX_WEB_DIST) ? process.env.SOLIX_WEB_DIST : null;
   }
   const here = dirname4(fileURLToPath4(import.meta.url));
   const candidates = [
@@ -2388,7 +2674,7 @@ function findWebDist() {
     resolve3(process.cwd(), "packages", "web", "dist")
   ];
   for (const c of candidates) {
-    if (existsSync6(join8(c, "index.html"))) return c;
+    if (existsSync7(join10(c, "index.html"))) return c;
   }
   return null;
 }
@@ -2414,10 +2700,10 @@ function mimeFor(filePath) {
 
 // ../server/src/launcher.ts
 import { spawn, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { basename as basename2, join as join9 } from "path";
-import { nanoid as nanoid4 } from "nanoid";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import { basename as basename3, join as join11 } from "path";
+import { nanoid as nanoid5 } from "nanoid";
 function ensureWorktree(opts) {
   const repoRoot = (() => {
     const r = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
@@ -2429,10 +2715,10 @@ function ensureWorktree(opts) {
     }
     return (r.stdout ?? "").trim();
   })();
-  const repoName = basename2(repoRoot);
+  const repoName = basename3(repoRoot);
   const safeBranch = opts.branch.replace(/[^a-zA-Z0-9._-]+/g, "-");
-  const worktreesDir = join9(homedir5(), ".solix", "worktrees");
-  const path = join9(worktreesDir, `${repoName}-${safeBranch}`);
+  const worktreesDir = join11(homedir7(), ".solix", "worktrees");
+  const path = join11(worktreesDir, `${repoName}-${safeBranch}`);
   const list = spawnSync2("git", ["worktree", "list", "--porcelain"], {
     cwd: repoRoot,
     encoding: "utf8"
@@ -2440,7 +2726,7 @@ function ensureWorktree(opts) {
   if (list.status === 0 && (list.stdout ?? "").includes(`worktree ${path}`)) {
     return { path, created: false };
   }
-  mkdirSync3(worktreesDir, { recursive: true });
+  mkdirSync4(worktreesDir, { recursive: true });
   const branchProbe = spawnSync2(
     "git",
     ["rev-parse", "--verify", "--quiet", `refs/heads/${opts.branch}`],
@@ -2535,7 +2821,7 @@ var Launcher = class {
   }
   pinSynthetic(advisorId, codename, cwd) {
     const project = ensureProject(this.db, cwd);
-    const sessionId = `advisor-${advisorId}-${nanoid4(6)}`;
+    const sessionId = `advisor-${advisorId}-${nanoid5(6)}`;
     const fakePid = 1e5 + Math.floor(Math.random() * 1e5);
     const session = upsertSession(this.db, {
       id: sessionId,
@@ -2644,7 +2930,7 @@ var Launcher = class {
         worktreePath
       });
     }
-    if (!existsSync7(spawnCwd)) {
+    if (!existsSync8(spawnCwd)) {
       this.broadcaster.broadcast({
         type: "toast",
         level: "error",
@@ -2655,7 +2941,7 @@ var Launcher = class {
     const args = ["--print"];
     if (opts.model) args.push("--model", String(opts.model));
     args.push(opts.initialPrompt);
-    const sessionId = `task-${nanoid4(8)}`;
+    const sessionId = `task-${nanoid5(8)}`;
     return this.spawnPrint({
       sessionId,
       cwd: spawnCwd,
@@ -2783,7 +3069,7 @@ var Launcher = class {
   }
   launchSynthetic(opts) {
     const project = ensureProject(this.db, opts.cwd);
-    const sessionId = `task-${nanoid4(8)}`;
+    const sessionId = `task-${nanoid5(8)}`;
     const fakePid = 2e5 + Math.floor(Math.random() * 1e5);
     upsertSession(this.db, {
       id: sessionId,
@@ -2829,12 +3115,12 @@ var Launcher = class {
 };
 
 // ../server/src/router.ts
-import { nanoid as nanoid6 } from "nanoid";
+import { nanoid as nanoid7 } from "nanoid";
 
 // ../server/src/state/toolcalls.ts
-import { nanoid as nanoid5 } from "nanoid";
+import { nanoid as nanoid6 } from "nanoid";
 function recordToolCall(db, input) {
-  const id = nanoid5();
+  const id = nanoid6();
   const ts2 = now();
   const status = input.status ?? "running";
   db.prepare(
@@ -2936,6 +3222,7 @@ var EventRouter = class {
     const sessionId = this.extractSessionId(event);
     const advisorRole = this.launcher?.advisorRoleForPid(event.pid);
     const worktreePath = this.launcher?.worktreePathForInternalCwd(event.cwd);
+    const wrapper = claimWrapperForCwd(event.cwd);
     const session = upsertSession(this.db, {
       id: sessionId,
       pid: event.pid,
@@ -2946,7 +3233,8 @@ var EventRouter = class {
       parentSessionId: this.extractParentSessionId(event),
       kind: advisorRole ? "advisor" : "user",
       advisorRole,
-      worktreePath
+      worktreePath,
+      wrapperSocketPath: wrapper?.socketPath
     });
     this.broadcaster.broadcast({ type: "session_upsert", session });
     if (!session.parentSessionId) {
@@ -3013,7 +3301,7 @@ var EventRouter = class {
     const parentSessionId = this.extractSessionId(event);
     const parent = getSession(this.db, parentSessionId);
     if (!parent) return;
-    const subId = nanoid6();
+    const subId = nanoid7();
     const sub = upsertSession(this.db, {
       id: subId,
       pid: event.pid,
@@ -3090,7 +3378,7 @@ var EventRouter = class {
     const p = event.payload;
     const message = typeof p.message === "string" ? p.message : "Permission requested";
     const tool = typeof p.tool_name === "string" ? p.tool_name : "unknown";
-    const requestId = nanoid6();
+    const requestId = nanoid7();
     this.permissions.set(requestId, {
       requestId,
       sessionId,
@@ -3230,6 +3518,31 @@ var EventRouter = class {
     });
   }
   sendPromptToSession(sessionId, text) {
+    const session = getSession(this.db, sessionId);
+    if (!session) return false;
+    if (session.wrapperSocketPath) {
+      const ok = writeToWrapperSocket(session.wrapperSocketPath, text);
+      if (ok) {
+        this.broadcaster.broadcast({
+          type: "chat_delta",
+          sessionId,
+          delta: {
+            messageId: `u-${Date.now()}`,
+            role: "user",
+            content: text,
+            ts: Date.now(),
+            done: true
+          }
+        });
+      } else {
+        this.broadcaster.broadcast({
+          type: "toast",
+          level: "warn",
+          message: "Wrapper socket unreachable \u2014 the `solix run` process may have exited."
+        });
+      }
+      return ok;
+    }
     if (!this.launcher) return false;
     return this.launcher.sendPromptToInternal(sessionId, text);
   }
@@ -3364,15 +3677,15 @@ function handleClientMessage(ctx, _ws, msg) {
 // ../server/src/state/transcript.ts
 import {
   closeSync,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   openSync,
   readSync,
   statSync as statSync5,
   watch
 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join10 } from "path";
-var TRANSCRIPT_BASE = join10(homedir6(), ".claude", "projects");
+import { homedir as homedir8 } from "os";
+import { join as join12 } from "path";
+var TRANSCRIPT_BASE = join12(homedir8(), ".claude", "projects");
 var CONTEXT_BUDGETS_BY_MODEL = {
   "claude-opus-4-7": 2e5,
   "claude-opus-4-6": 2e5,
@@ -3385,7 +3698,7 @@ function encodeProjectPath(cwd) {
   return cwd.replace(/[/\\]/g, "-");
 }
 function transcriptPathFor(cwd, sessionId) {
-  return join10(TRANSCRIPT_BASE, encodeProjectPath(cwd), `${sessionId}.jsonl`);
+  return join12(TRANSCRIPT_BASE, encodeProjectPath(cwd), `${sessionId}.jsonl`);
 }
 var TranscriptWatcherManager = class {
   constructor(db, broadcaster) {
@@ -3405,7 +3718,7 @@ var TranscriptWatcherManager = class {
   startWatching(sessionId, cwd) {
     if (this.records.has(sessionId)) return;
     const filePath = transcriptPathFor(cwd, sessionId);
-    if (!existsSync8(filePath)) {
+    if (!existsSync9(filePath)) {
       this.scheduleRetry(sessionId, cwd, 0);
       return;
     }
@@ -3416,7 +3729,7 @@ var TranscriptWatcherManager = class {
     const t = setTimeout(() => {
       this.deferredRetry.delete(sessionId);
       const filePath = transcriptPathFor(cwd, sessionId);
-      if (existsSync8(filePath)) {
+      if (existsSync9(filePath)) {
         this.attach(sessionId, filePath);
       } else {
         this.scheduleRetry(sessionId, cwd, attempt + 1);
@@ -3678,19 +3991,20 @@ async function start(opts = {}) {
 }
 
 // src/uninstall.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 function uninstall() {
-  if (existsSync9(CLAUDE_BACKUP)) {
+  uninstallShim();
+  if (existsSync10(CLAUDE_BACKUP)) {
     copyFileSync2(CLAUDE_BACKUP, CLAUDE_SETTINGS);
     console.log(`[solix] restored settings.json from backup`);
     return;
   }
-  if (!existsSync9(CLAUDE_SETTINGS)) {
+  if (!existsSync10(CLAUDE_SETTINGS)) {
     console.log("[solix] nothing to uninstall (no settings.json found)");
     return;
   }
   const cur = JSON.parse(
-    readFileSync6(CLAUDE_SETTINGS, "utf8")
+    readFileSync7(CLAUDE_SETTINGS, "utf8")
   );
   if (cur.hooks) {
     for (const [evt, entries] of Object.entries(cur.hooks)) {
@@ -3700,7 +4014,7 @@ function uninstall() {
       if (cur.hooks[evt].length === 0) delete cur.hooks[evt];
     }
   }
-  writeFileSync3(CLAUDE_SETTINGS, JSON.stringify(cur, null, 2) + "\n");
+  writeFileSync4(CLAUDE_SETTINGS, JSON.stringify(cur, null, 2) + "\n");
   console.log(`[solix] removed Solix hooks from ${CLAUDE_SETTINGS}`);
 }
 
@@ -3717,6 +4031,16 @@ program.command("install").description("Install Solix hooks into ~/.claude/setti
 program.command("uninstall").description("Restore ~/.claude/settings.json from backup").action(() => {
   uninstall();
 });
+program.command("run").description(
+  "Wrap a claude session under a PTY so the Solix UI can send prompts to it. Pass any args you would normally pass to claude."
+).allowUnknownOption(true).helpOption(false).action(async (_opts, cmd) => {
+  await runWrapped(cmd.args ?? []);
+});
+program.command("install-shim").description(
+  "Add `alias claude='solix run'` to your shell rc so every claude session is wrapped automatically."
+).action(() => {
+  installShim();
+});
 program.command("doctor").description("Run diagnostics").action(async () => {
   await doctor();
 });