tower-studio 0.1.9 → 0.1.11

package/bin/tower.mjs

@@ -16,15 +16,17 @@
 
 import { existsSync, readFileSync, mkdirSync } from "fs";
 import { join, dirname, resolve } from "path";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { createServer } from "http";
 import { fileURLToPath } from "url";
 import { parseArgs } from "node:util";
 import { homedir } from "os";
+import { createRequire } from "module";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PROJECT_ROOT = resolve(__dirname, "..");
+const require = createRequire(import.meta.url);
 
 // ─── Data directory: ~/.tower ───
 const TOWER_DIR = join(homedir(), ".tower");
@@ -85,15 +87,27 @@ function logError(msg) {
   console.error(`\x1b[31m[tower]\x1b[0m ${msg}`);
 }
 
-function run(cmd) {
+function resolveBin(pkgName, binName) {
+  const pkgJsonPath = require.resolve(`${pkgName}/package.json`, { paths: [PROJECT_ROOT] });
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+  const binField = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.[binName];
+
+  if (!binField) {
+    throw new Error(`No bin entry found for ${pkgName}`);
+  }
+
+  return resolve(dirname(pkgJsonPath), binField);
+}
+
+function run(binPath, args) {
   try {
-    execSync(cmd, {
+    execFileSync(process.execPath, [binPath, ...args], {
       cwd: PROJECT_ROOT,
       stdio: "inherit",
       env: { ...process.env, DATABASE_URL: DB_URL },
     });
   } catch {
-    logError(`Command failed: ${cmd}`);
+    logError(`Command failed: ${binPath} ${args.join(" ")}`);
     process.exit(1);
   }
 }
@@ -111,26 +125,30 @@ function ensureDirs() {
 }
 
 async function initDatabase() {
+  const prismaBin = resolveBin("prisma", "prisma");
+  const tsxBin = resolveBin("tsx", "tsx");
+
   log("Initializing Tower...");
   ensureDirs();
   log(`Data directory: ${TOWER_DIR}`);
 
   log("Syncing database schema...");
-  run("npx prisma db push --skip-generate");
+  run(prismaBin, ["db", "push", "--skip-generate"]);
 
   log("Seeding initial data...");
-  run("npx tsx scripts/init-db.ts");
+  run(tsxBin, ["scripts/init-db.ts"]);
 
   log("Initializing full-text search...");
-  run("npx tsx prisma/init-fts.ts");
+  run(tsxBin, ["prisma/init-fts.ts"]);
 
   log("Initialization complete!");
 }
 
 // ─── Commands ───
 async function cmdMigrate() {
+  const tsxBin = resolveBin("tsx", "tsx");
   log("Running data migration...");
-  run("npx tsx scripts/migrate-data.ts --run");
+  run(tsxBin, ["scripts/migrate-data.ts", "--run"]);
 }
 
 async function cmdStart() {
@@ -150,6 +168,26 @@ async function cmdStart() {
   await app.prepare();
 
   const server = createServer(handle);
+  let shuttingDown = false;
+
+  const shutdown = (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log(`Received ${signal}, shutting down...`);
+
+    const forceExitTimer = setTimeout(() => {
+      process.exit(0);
+    }, 2000);
+    forceExitTimer.unref();
+
+    server.close(() => {
+      process.exit(0);
+    });
+  };
+
+  process.once("SIGINT", () => shutdown("SIGINT"));
+  process.once("SIGTERM", () => shutdown("SIGTERM"));
+
   server.listen(PORT, HOST, () => {
     log(`Tower running on http://${HOST === "0.0.0.0" ? "localhost" : HOST}:${PORT}`);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tower-studio",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "AI Task Orchestration Platform — Kanban + Terminal + Code Editor + MCP",
   "bin": {
     "tower": "bin/tower.mjs"
@@ -12,8 +12,13 @@
     "prisma/schema.prisma",
     "prisma/init-fts.ts",
     "scripts/init-db.ts",
+    "scripts/generate-prisma-client.js",
+    "scripts/link-prisma.js",
     "scripts/migrate-data.ts",
     "scripts/copy-monaco.js",
+    "scripts/post-tool-hook.js",
+    "scripts/session-start-hook.js",
+    "scripts/stop-hook.js",
     "src/mcp/",
     "next.config.ts",
     "tsconfig.json"
@@ -26,6 +31,7 @@
     "build": "next build",
     "build:clean": "rm -rf .next && next build && find .next -name '*.map' -delete",
     "release": "pnpm build:clean && npm pack",
+    "release:smoke": "node scripts/release-smoke.js",
     "release:publish": "pnpm build:clean && npm publish",
     "start": "next start",
     "lint": "eslint",
@@ -40,7 +46,7 @@
     "test:e2e": "NO_PROXY=localhost,127.0.0.1 no_proxy=localhost,127.0.0.1 playwright test",
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
     "mcp": "tsx src/mcp/index.ts",
-    "postinstall": "node scripts/copy-monaco.js && node scripts/link-prisma.js"
+    "postinstall": "node scripts/copy-monaco.js && node scripts/generate-prisma-client.js && node scripts/link-prisma.js"
   },
   "pnpm": {
     "onlyBuiltDependencies": [
@@ -83,11 +89,13 @@
     "react-resizable-panels": "^2.1.9",
     "react-reverse-portal": "^2.3.0",
     "remark-gfm": "^4.0.1",
+    "prisma": "^6.19.2",
     "shadcn": "^4.1.0",
     "simple-git": "^3.36.0",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",
     "tw-animate-css": "^1.4.0",
+    "tsx": "^4.21.0",
     "ws": "^8.20.0",
     "zod": "^4.3.6",
     "zustand": "^5.0.12"
@@ -110,9 +118,7 @@
     "eslint": "^9",
     "eslint-config-next": "16.2.1",
     "jsdom": "^29.0.1",
-    "prisma": "^6.19.2",
     "tailwindcss": "^4",
-    "tsx": "^4.21.0",
     "typescript": "^5",
     "vitest": "^4.1.1"
   }

package/scripts/generate-prisma-client.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+const { execFileSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const packageRoot = path.join(__dirname, "..");
+
+function resolvePrismaBin() {
+  const pkgJsonPath = require.resolve("prisma/package.json", { paths: [packageRoot] });
+  const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+  const binField = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.prisma;
+
+  if (!binField) {
+    throw new Error("No prisma bin entry found");
+  }
+
+  return path.resolve(path.dirname(pkgJsonPath), binField);
+}
+
+function hasGeneratedClient() {
+  try {
+    require.resolve(".prisma/client/default", { paths: [packageRoot] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (hasGeneratedClient()) {
+  console.log("[generate-prisma] Prisma client already generated");
+  process.exit(0);
+}
+
+try {
+  execFileSync(process.execPath, [resolvePrismaBin(), "generate", "--schema", "prisma/schema.prisma"], {
+    cwd: packageRoot,
+    stdio: "inherit",
+    env: process.env,
+  });
+} catch (error) {
+  console.warn(`[generate-prisma] Failed to generate Prisma client: ${error.message}`);
+  process.exit(0);
+}

package/scripts/link-prisma.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * Turbopack may rewrite external package names with content hashes
+ * (for example `@prisma/client-<hash>` or `node-pty-<hash>`).
+ * This script scans the build output and creates symlinks so Node.js
+ * can resolve those hashed names at runtime after global install.
+ */
+const fs = require("fs");
+const path = require("path");
+
+const packageRoot = path.join(__dirname, "..");
+const serverDir = path.join(packageRoot, ".next", "server");
+const supportedPackages = [
+  "@prisma/client",
+  "node-pty",
+  "@vscode/ripgrep",
+  "ws",
+];
+
+if (!fs.existsSync(serverDir)) {
+  process.exit(0);
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function collectJsFiles(dir, result = []) {
+  if (!fs.existsSync(dir)) return result;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectJsFiles(full, result);
+    } else if (entry.name.endsWith(".js")) {
+      result.push(full);
+    }
+  }
+  return result;
+}
+
+function detectHashedReferences(files) {
+  const matches = new Map();
+
+  for (const pkg of supportedPackages) {
+    matches.set(pkg, new Set());
+  }
+
+  for (const file of files) {
+    const content = fs.readFileSync(file, "utf-8");
+    for (const pkg of supportedPackages) {
+      const pattern = new RegExp(`${escapeRegExp(pkg)}-([0-9a-f]+)`, "g");
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        matches.get(pkg).add(match[1]);
+      }
+    }
+  }
+
+  return matches;
+}
+
+function getPackageParts(pkg) {
+  if (pkg.startsWith("@")) {
+    const [scope, name] = pkg.split("/");
+    return { scope, name };
+  }
+
+  return { scope: null, name: pkg };
+}
+
+function getVisiblePackageDir(pkg) {
+  const { scope, name } = getPackageParts(pkg);
+  return scope
+    ? path.join(packageRoot, "node_modules", scope, name)
+    : path.join(packageRoot, "node_modules", name);
+}
+
+function collectAliasTargets(pkg) {
+  const pkgJsonPath = require.resolve(`${pkg}/package.json`, { paths: [packageRoot] });
+  const realPackageDir = path.dirname(pkgJsonPath);
+  const visiblePackageDir = getVisiblePackageDir(pkg);
+  const candidates = new Map();
+
+  if (fs.existsSync(visiblePackageDir)) {
+    candidates.set(visiblePackageDir, path.dirname(visiblePackageDir));
+  }
+
+  candidates.set(realPackageDir, path.dirname(realPackageDir));
+
+  return {
+    targetDir: visiblePackageDir,
+    aliasBaseDirs: [...candidates.values()],
+    packageName: getPackageParts(pkg).name,
+  };
+}
+
+function linkHashedPackage(pkg, hash) {
+  let paths;
+  try {
+    paths = collectAliasTargets(pkg);
+  } catch (error) {
+    console.warn(`[link-prisma] Cannot resolve ${pkg}: ${error.message}`);
+    return;
+  }
+
+  if (!fs.existsSync(paths.targetDir)) {
+    console.warn(`[link-prisma] Target package directory missing for ${pkg}, skipping`);
+    return;
+  }
+
+  const linkName = `${paths.packageName}-${hash}`;
+
+  for (const aliasBaseDir of paths.aliasBaseDirs) {
+    const linkPath = path.join(aliasBaseDir, linkName);
+    if (fs.existsSync(linkPath)) {
+      console.log(`[link-prisma] ${pkg}-${hash} already exists in ${aliasBaseDir}`);
+      continue;
+    }
+
+    try {
+      fs.symlinkSync(paths.targetDir, linkPath, "junction");
+      console.log(`[link-prisma] Linked ${pkg}-${hash} -> ${pkg} in ${aliasBaseDir}`);
+    } catch (error) {
+      console.warn(
+        `[link-prisma] Failed to create symlink for ${pkg}-${hash} in ${aliasBaseDir}: ${error.message}`
+      );
+    }
+  }
+}
+
+const jsFiles = collectJsFiles(serverDir);
+const references = detectHashedReferences(jsFiles);
+let createdAny = false;
+
+for (const [pkg, hashes] of references.entries()) {
+  for (const hash of hashes) {
+    createdAny = true;
+    linkHashedPackage(pkg, hash);
+  }
+}
+
+if (!createdAny) {
+  console.log("[link-prisma] No hashed external package references found, skipping");
+}

package/scripts/post-tool-hook.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * Tower PostToolUse Hook
+ *
+ * Claude Code PostToolUse hook that auto-captures file outputs as task assets.
+ * When Claude writes/edits a file matching the configured extension whitelist,
+ * this hook uploads it to Tower's internal API for asset tracking.
+ *
+ * Environment:
+ *   TOWER_TASK_ID  - Required. The task ID to associate the asset with.
+ *   TOWER_API_URL  - Required. Base URL of the Tower server (e.g. http://localhost:3000).
+ *
+ * Stdin: JSON object from Claude Code with { tool_name, tool_input, session_id, cwd, ... }
+ * Exit: Always 0 (hook must never block Claude Code).
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const http = require("http");
+const https = require("https");
+
+const DEFAULT_TYPES = ["png", "jpg", "jpeg", "gif", "webp", "svg", "pdf", "md", "txt", "json"];
+const FILE_WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit"]);
+
+function main() {
+  const taskId = process.env.TOWER_TASK_ID;
+  if (!taskId) {
+    process.exit(0);
+  }
+
+  const apiUrl = process.env.TOWER_API_URL;
+  if (!apiUrl) {
+    process.exit(0);
+  }
+
+  // SECURITY: Only talk to localhost — refuse remote servers
+  try {
+    const parsed = new URL(apiUrl);
+    if (!["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname)) {
+      process.exit(0);
+    }
+  } catch {
+    process.exit(0);
+  }
+
+  // Read stdin with timeout
+  let input = "";
+  const timeout = setTimeout(() => {
+    // Stdin timeout — exit silently
+    process.exit(0);
+  }, 10000);
+
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    input += chunk;
+  });
+
+  process.stdin.on("end", () => {
+    clearTimeout(timeout);
+    processInput(input, taskId, apiUrl);
+  });
+
+  process.stdin.on("error", () => {
+    clearTimeout(timeout);
+    process.exit(0);
+  });
+
+  // If stdin is not a pipe (e.g., running interactively), exit
+  if (process.stdin.isTTY) {
+    clearTimeout(timeout);
+    process.exit(0);
+  }
+}
+
+function processInput(input, taskId, apiUrl) {
+  let data;
+  try {
+    data = JSON.parse(input);
+  } catch {
+    process.exit(0);
+  }
+
+  const toolName = data.tool_name;
+  if (!toolName || !FILE_WRITE_TOOLS.has(toolName)) {
+    process.exit(0);
+  }
+
+  const filePath = data.tool_input && data.tool_input.file_path;
+  if (!filePath) {
+    process.exit(0);
+  }
+
+  // Resolve to absolute path
+  const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(data.cwd || process.cwd(), filePath);
+
+  // Check extension against whitelist
+  const ext = path.extname(absolutePath).slice(1).toLowerCase();
+  if (!ext) {
+    process.exit(0);
+  }
+
+  // Try to fetch config from Tower, fall back to defaults
+  fetchAllowedTypes(apiUrl, (types) => {
+    if (!types.includes(ext)) {
+      process.exit(0);
+    }
+
+    // Check file exists
+    try {
+      fs.statSync(absolutePath);
+    } catch {
+      process.exit(0);
+    }
+
+    // Upload to Tower
+    uploadFile(apiUrl, taskId, absolutePath);
+  });
+}
+
+function fetchAllowedTypes(apiUrl, callback) {
+  const url = apiUrl + "/api/internal/hooks/upload";
+  const mod = url.startsWith("https") ? https : http;
+
+  const req = mod.get(url, (res) => {
+    let body = "";
+    res.on("data", (chunk) => { body += chunk; });
+    res.on("end", () => {
+      try {
+        const json = JSON.parse(body);
+        if (Array.isArray(json.types)) {
+          callback(json.types);
+          return;
+        }
+      } catch {
+        // Fall through to defaults
+      }
+      callback(DEFAULT_TYPES);
+    });
+  });
+
+  req.on("error", () => {
+    callback(DEFAULT_TYPES);
+  });
+
+  req.setTimeout(3000, () => {
+    req.destroy();
+    callback(DEFAULT_TYPES);
+  });
+}
+
+function uploadFile(apiUrl, taskId, filePath) {
+  const url = new URL("/api/internal/hooks/upload", apiUrl);
+  const payload = JSON.stringify({ taskId, filePath });
+  const mod = url.protocol === "https:" ? https : http;
+
+  const options = {
+    hostname: url.hostname,
+    port: url.port,
+    path: url.pathname,
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(payload),
+    },
+    timeout: 5000,
+  };
+
+  const req = mod.request(options, () => {
+    // Response doesn't matter — fire and forget
+    process.exit(0);
+  });
+
+  req.on("error", () => {
+    process.exit(0);
+  });
+
+  req.on("timeout", () => {
+    req.destroy();
+    process.exit(0);
+  });
+
+  req.write(payload);
+  req.end();
+}
+
+main();

package/scripts/session-start-hook.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Tower SessionStart Hook
+ *
+ * Reports the Claude CLI session_id to Tower's API so resume/continue works.
+ * Runs once when a Claude Code session starts.
+ *
+ * Environment:
+ *   TOWER_TASK_ID  - Required. Skip if absent (not a Tower session).
+ *   TOWER_API_URL  - Required. Base URL of the Tower server.
+ *
+ * Stdin: JSON object from Claude Code with { session_id, cwd, ... }
+ */
+
+"use strict";
+
+const http = require("http");
+const https = require("https");
+
+function main() {
+  const taskId = process.env.TOWER_TASK_ID;
+  if (!taskId) process.exit(0);
+
+  const apiUrl = process.env.TOWER_API_URL;
+  if (!apiUrl) process.exit(0);
+
+  // Validate localhost
+  try {
+    const parsed = new URL(apiUrl);
+    if (!["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname)) {
+      process.exit(0);
+    }
+  } catch {
+    process.exit(0);
+  }
+
+  let input = "";
+  const timeout = setTimeout(() => process.exit(0), 5000);
+
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => { input += chunk; });
+
+  process.stdin.on("end", () => {
+    clearTimeout(timeout);
+
+    let data;
+    try { data = JSON.parse(input); } catch { process.exit(0); }
+
+    const sessionId = data.session_id;
+    if (!sessionId) process.exit(0);
+
+    // POST sessionId to Tower
+    const url = new URL("/api/internal/hooks/session", apiUrl);
+    const payload = JSON.stringify({ taskId, sessionId });
+    const mod = url.protocol === "https:" ? https : http;
+
+    const req = mod.request({
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+      },
+      timeout: 3000,
+    }, () => process.exit(0));
+
+    req.on("error", () => process.exit(0));
+    req.on("timeout", () => { req.destroy(); process.exit(0); });
+    req.write(payload);
+    req.end();
+  });
+
+  process.stdin.on("error", () => { clearTimeout(timeout); process.exit(0); });
+  if (process.stdin.isTTY) { clearTimeout(timeout); process.exit(0); }
+}
+
+main();

package/scripts/stop-hook.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Tower Stop Hook
+ *
+ * Claude Code Stop hook that fires when Claude finishes responding.
+ * Notifies Tower so the UI can show a "response complete" indicator.
+ *
+ * Environment:
+ *   TOWER_TASK_ID  - Required. Skip if absent (not a Tower session).
+ *   TOWER_API_URL  - Required. Base URL of the Tower server.
+ *
+ * Stdin: JSON object from Claude Code with { session_id, cwd, ... }
+ */
+
+"use strict";
+
+const http = require("http");
+const https = require("https");
+
+function main() {
+  const taskId = process.env.TOWER_TASK_ID;
+  if (!taskId) process.exit(0);
+
+  const apiUrl = process.env.TOWER_API_URL;
+  if (!apiUrl) process.exit(0);
+
+  // SECURITY: Only talk to localhost
+  try {
+    const parsed = new URL(apiUrl);
+    if (!["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname)) {
+      process.exit(0);
+    }
+  } catch {
+    process.exit(0);
+  }
+
+  let input = "";
+  const timeout = setTimeout(() => process.exit(0), 5000);
+
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => { input += chunk; });
+
+  process.stdin.on("end", () => {
+    clearTimeout(timeout);
+
+    let data;
+    try { data = JSON.parse(input); } catch { process.exit(0); }
+
+    const sessionId = data.session_id || "";
+
+    // POST to Tower
+    const url = new URL("/api/internal/hooks/stop", apiUrl);
+    const payload = JSON.stringify({ taskId, sessionId });
+    const mod = url.protocol === "https:" ? https : http;
+
+    const req = mod.request({
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+      },
+      timeout: 3000,
+    }, () => process.exit(0));
+
+    req.on("error", () => process.exit(0));
+    req.on("timeout", () => { req.destroy(); process.exit(0); });
+    req.write(payload);
+    req.end();
+  });
+
+  process.stdin.on("error", () => { clearTimeout(timeout); process.exit(0); });
+  if (process.stdin.isTTY) { clearTimeout(timeout); process.exit(0); }
+}
+
+main();