ztile-cli 0.0.1 → 0.2.2

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+var args = process.argv.slice(2);
+if (args[0] === "hook") {
+  const { handleHook } = await import("./hook-SN73JWB3.js");
+  await handleHook();
+  process.exit(0);
+}
+if (args[0] === "setup") {
+  const { setupClaudeCode } = await import("./setup-6PUWCUFR.js");
+  const apiKey = process.env["ZTILE_API_KEY"] ?? findArg(args, "--api-key");
+  if (!apiKey) {
+    console.error("Error: API key is required.");
+    console.error("  Set ZTILE_API_KEY env var, or pass --api-key <key>");
+    process.exit(1);
+  }
+  await setupClaudeCode({
+    apiKey,
+    serverUrl: process.env["ZTILE_SERVER_URL"] ?? findArg(args, "--server-url"),
+    machineId: process.env["ZTILE_MACHINE_ID"] ?? findArg(args, "--machine-id"),
+    project: process.env["ZTILE_PROJECT"] ?? findArg(args, "--project")
+  });
+  process.exit(0);
+}
+if (args[0] === "daemon") {
+  const { runDaemon } = await import("./daemon-KSDSRNAZ.js");
+  const projectDir = findArg(args, "--project") ?? process.env["ZTILE_PROJECT"] ?? process.cwd();
+  await runDaemon(projectDir);
+}
+if (args.length === 0 || !["hook", "setup", "daemon"].includes(args[0])) {
+  if (args.length > 0) console.error(`Unknown command: ${args[0]}`);
+  console.log("Usage:");
+  console.log("  ztile hook     Handle Claude Code hook (stdin \u2192 transcript diff \u2192 server)");
+  console.log("  ztile setup    Configure Claude Code hooks");
+  console.log("  ztile daemon   Start daemon for remote control (poll server for commands)");
+  process.exit(args.length > 0 ? 1 : 0);
+}
+function findArg(args2, name) {
+  const idx = args2.indexOf(name);
+  if (idx === -1 || idx + 1 >= args2.length) return void 0;
+  return args2[idx + 1];
+}

package/dist/daemon-KSDSRNAZ.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+
+// src/commands/daemon.ts
+import { hostname } from "os";
+
+// src/lib/workspace.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+import { webcrypto as crypto } from "crypto";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// src/lib/workspace.ts
+function getWorkspaceId(projectDir) {
+  const dir = join(projectDir, ".ztile");
+  const path = join(dir, "workspace-id");
+  if (existsSync(path)) return readFileSync(path, "utf-8").trim();
+  mkdirSync(dir, { recursive: true });
+  const id = nanoid(12);
+  writeFileSync(path, id);
+  return id;
+}
+
+// src/lib/server-client.ts
+var DEFAULT_SERVER_URL = "https://ztile.dev";
+function getConfig() {
+  return {
+    serverUrl: process.env["ZTILE_SERVER_URL"] ?? DEFAULT_SERVER_URL,
+    apiKey: process.env["ZTILE_API_KEY"] ?? ""
+  };
+}
+async function request(method, path, body) {
+  const { serverUrl, apiKey } = getConfig();
+  const response = await fetch(`${serverUrl}${path}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await response.json();
+  return { ok: response.ok, status: response.status, data };
+}
+async function sendHeartbeat(workspaceId, hostname2, sessions2) {
+  const result = await request("POST", "/api/workspaces/heartbeat", {
+    workspaceId,
+    hostname: hostname2,
+    sessions: sessions2
+  });
+  return result.ok;
+}
+async function pollCommands(workspaceId) {
+  const result = await request("GET", `/api/commands?workspaceId=${workspaceId}`);
+  if (!result.ok) return [];
+  return result.data?.commands ?? [];
+}
+async function updateCommand(commandId, status, result) {
+  const res = await request("PATCH", `/api/commands/${commandId}`, {
+    status,
+    result
+  });
+  return res.ok;
+}
+async function sendStreamData(sessionId, workspaceId, data) {
+  const res = await request("POST", `/api/sessions/${sessionId}/stream`, {
+    workspaceId,
+    data
+  });
+  return res.ok;
+}
+
+// src/lib/session-manager.ts
+import { spawn as ptySpawn } from "node-pty";
+var sessions = /* @__PURE__ */ new Map();
+function log(msg) {
+  console.log(`[session] ${msg}`);
+}
+function attachStreamParser(pty, info, commandId) {
+  let buffer = "";
+  pty.onData((data) => {
+    buffer += data;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg.type === "system" && msg.subtype === "init") {
+          info.sessionId = msg.session_id;
+          info.status = "running";
+          log(`session started: ${info.sessionId}`);
+        }
+        if (msg.type === "result") {
+          info.status = "idle";
+          log(`session completed: ${info.sessionId} (${msg.duration_ms}ms, $${msg.total_cost_usd})`);
+        }
+        if (info.sessionId) {
+          sendStreamData(info.sessionId, info.workspaceId, msg).catch((err) => {
+            log(`stream send error: ${err instanceof Error ? err.message : err}`);
+          });
+        }
+      } catch {
+      }
+    }
+  });
+  pty.onExit(({ exitCode }) => {
+    log(`process exited: code=${exitCode}, session=${info.sessionId}`);
+    info.status = "idle";
+    info.pty = null;
+    updateCommand(commandId, exitCode === 0 ? "completed" : "failed", {
+      sessionId: info.sessionId || void 0,
+      error: exitCode !== 0 ? `exit code ${exitCode}` : void 0
+    }).catch(() => {
+    });
+  });
+}
+function spawnSession(commandId, workspaceId, prompt, workdir, allowedTools) {
+  const args = ["-p", prompt, "--output-format", "stream-json", "--verbose"];
+  if (allowedTools?.length) {
+    args.push("--allowedTools", ...allowedTools);
+  }
+  const info = {
+    sessionId: "",
+    status: "starting",
+    pty: null,
+    workspaceId,
+    workdir
+  };
+  log(`spawning: claude ${args.join(" ").slice(0, 100)}...`);
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  delete env.CLAUDE_CODE_SSE_PORT;
+  const pty = ptySpawn("claude", args, {
+    name: "xterm-256color",
+    cols: 200,
+    rows: 50,
+    cwd: workdir,
+    env
+  });
+  info.pty = pty;
+  attachStreamParser(pty, info, commandId);
+  sessions.set(commandId, info);
+}
+function sendPrompt(commandId, workspaceId, sessionId, prompt) {
+  let workdir = process.cwd();
+  for (const info2 of sessions.values()) {
+    if (info2.sessionId === sessionId) {
+      if (info2.status === "running") {
+        log(`session ${sessionId} is still running, rejecting prompt`);
+        updateCommand(commandId, "failed", { error: "Session is still running" }).catch(() => {
+        });
+        return;
+      }
+      workdir = info2.workdir;
+      break;
+    }
+  }
+  const args = [
+    "-p",
+    prompt,
+    "--resume",
+    sessionId,
+    "--output-format",
+    "stream-json",
+    "--verbose"
+  ];
+  log(`resume: session=${sessionId}`);
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  delete env.CLAUDE_CODE_SSE_PORT;
+  const pty = ptySpawn("claude", args, {
+    name: "xterm-256color",
+    cols: 200,
+    rows: 50,
+    cwd: workdir,
+    env
+  });
+  const info = {
+    sessionId,
+    status: "running",
+    pty,
+    workspaceId,
+    workdir
+  };
+  attachStreamParser(pty, info, commandId);
+  sessions.set(sessionId, info);
+}
+function getSessionList() {
+  const result = [];
+  for (const info of sessions.values()) {
+    if (info.sessionId) {
+      result.push({
+        sessionId: info.sessionId,
+        mode: "operate",
+        status: info.status
+      });
+    }
+  }
+  return result;
+}
+
+// src/commands/daemon.ts
+var POLL_INTERVAL_MS = 5e3;
+var HEARTBEAT_INTERVAL_MS = 15e3;
+function log2(msg) {
+  console.log(`[daemon] ${msg}`);
+}
+async function handleCommand(cmd, workspaceId, projectDir) {
+  log2(`command: ${cmd.type} (${cmd.id})`);
+  await updateCommand(cmd.id, "processing");
+  switch (cmd.type) {
+    case "spawn": {
+      const prompt = cmd.payload.prompt;
+      const workdir = cmd.payload.workdir ?? projectDir;
+      const allowedTools = cmd.payload.allowedTools;
+      spawnSession(cmd.id, workspaceId, prompt, workdir, allowedTools);
+      break;
+    }
+    case "prompt": {
+      if (!cmd.sessionId) {
+        await updateCommand(cmd.id, "failed", { error: "Missing sessionId" });
+        return;
+      }
+      const prompt = cmd.payload.prompt;
+      sendPrompt(cmd.id, workspaceId, cmd.sessionId, prompt);
+      break;
+    }
+    default:
+      log2(`unknown command type: ${cmd.type}`);
+      await updateCommand(cmd.id, "failed", { error: `Unknown command type: ${cmd.type}` });
+  }
+}
+async function runDaemon(projectDir) {
+  const apiKey = process.env["ZTILE_API_KEY"];
+  if (!apiKey) {
+    console.error("Error: ZTILE_API_KEY is required.");
+    process.exit(1);
+  }
+  const workspaceId = getWorkspaceId(projectDir);
+  const host = hostname();
+  log2(`starting daemon`);
+  log2(`  workspace: ${workspaceId}`);
+  log2(`  hostname:  ${host}`);
+  log2(`  project:   ${projectDir}`);
+  log2(`  server:    ${process.env["ZTILE_SERVER_URL"] ?? "https://ztile.dev"}`);
+  log2(`  poll interval: ${POLL_INTERVAL_MS}ms`);
+  const ok = await sendHeartbeat(workspaceId, host, []);
+  if (ok) {
+    log2(`registered with server`);
+  } else {
+    log2(`failed to register with server (will retry)`);
+  }
+  const heartbeatTimer = setInterval(async () => {
+    const sessions2 = getSessionList();
+    await sendHeartbeat(workspaceId, host, sessions2).catch(() => {
+    });
+  }, HEARTBEAT_INTERVAL_MS);
+  log2(`polling for commands...`);
+  const pollTimer = setInterval(async () => {
+    try {
+      const commands = await pollCommands(workspaceId);
+      for (const cmd of commands) {
+        await handleCommand(cmd, workspaceId, projectDir);
+      }
+    } catch (err) {
+      log2(`poll error: ${err instanceof Error ? err.message : err}`);
+    }
+  }, POLL_INTERVAL_MS);
+  const shutdown = () => {
+    log2(`shutting down...`);
+    clearInterval(heartbeatTimer);
+    clearInterval(pollTimer);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+export {
+  runDaemon
+};

package/dist/hook-SN73JWB3.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+// src/commands/hook.ts
+import { readFile as readFile2, stat } from "fs/promises";
+
+// src/state.ts
+import { readFile, writeFile, mkdir, open, unlink } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+var STATE_DIR = join(process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/tmp", ".ztile");
+var STATE_FILE = join(STATE_DIR, "state.json");
+var LOCK_FILE = join(STATE_DIR, "hook.lock");
+var LOCK_TIMEOUT_MS = 5e3;
+var LOCK_RETRY_MS = 50;
+var LOCK_STALE_MS = 1e4;
+async function loadState() {
+  try {
+    const content = await readFile(STATE_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { transcripts: {} };
+  }
+}
+async function saveState(state) {
+  if (!existsSync(STATE_DIR)) {
+    await mkdir(STATE_DIR, { recursive: true });
+  }
+  await writeFile(STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+async function getByteOffset(transcriptPath) {
+  const state = await loadState();
+  return state.transcripts[transcriptPath]?.last_byte_offset ?? 0;
+}
+async function updateByteOffset(transcriptPath, offset, sessionId) {
+  const state = await loadState();
+  state.transcripts[transcriptPath] = {
+    last_byte_offset: offset,
+    session_id: sessionId,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveState(state);
+}
+async function acquireLock() {
+  if (!existsSync(STATE_DIR)) {
+    await mkdir(STATE_DIR, { recursive: true });
+  }
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      const fd = await open(LOCK_FILE, "wx");
+      await fd.writeFile(String(Date.now()));
+      await fd.close();
+      return true;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        try {
+          const content = await readFile(LOCK_FILE, "utf-8");
+          const lockTime = parseInt(content, 10);
+          if (!isNaN(lockTime) && Date.now() - lockTime > LOCK_STALE_MS) {
+            await unlink(LOCK_FILE).catch(() => {
+            });
+            continue;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+        continue;
+      }
+      throw err;
+    }
+  }
+  return false;
+}
+async function releaseLock() {
+  await unlink(LOCK_FILE).catch(() => {
+  });
+}
+
+// src/outputs/server.ts
+var DEFAULT_SERVER_URL = "https://ztile.dev";
+function getServerConfig() {
+  return {
+    serverUrl: process.env["ZTILE_SERVER_URL"] ?? DEFAULT_SERVER_URL,
+    apiKey: process.env["ZTILE_API_KEY"]
+  };
+}
+async function sendRawToServer(payload) {
+  const { serverUrl, apiKey } = getServerConfig();
+  if (!apiKey) {
+    console.error("[server] No API key configured (ZTILE_API_KEY)");
+    return false;
+  }
+  try {
+    const response = await fetch(`${serverUrl}/api/hooks/ingest`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      console.error(
+        `[server] Failed to send raw data: ${response.status} ${response.statusText}`
+      );
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(
+      `[server] Connection error: ${error instanceof Error ? error.message : error}`
+    );
+    return false;
+  }
+}
+
+// src/commands/hook.ts
+import { appendFileSync } from "fs";
+import { join as join2 } from "path";
+import { hostname } from "os";
+var LOG_FILE = join2(process.env["HOME"] ?? "/tmp", ".ztile", "hook-debug.log");
+function debugLog(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`;
+  try {
+    appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+  console.error(msg);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const text = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!text) {
+    throw new Error("No input received on stdin");
+  }
+  return JSON.parse(text);
+}
+async function handleHook() {
+  const payload = await readStdin();
+  const hookEvent = payload["hook_event_name"];
+  const transcriptPath = payload["transcript_path"];
+  const sessionId = payload["session_id"];
+  const cwd = payload["cwd"];
+  debugLog(`[hook] ${hookEvent}: payload keys = ${Object.keys(payload).join(", ")}`);
+  if (!transcriptPath) {
+    debugLog("[hook] No transcript_path in payload, skipping");
+    return;
+  }
+  if (!sessionId) {
+    debugLog("[hook] No session_id in payload, skipping");
+    return;
+  }
+  const machineId = process.env["ZTILE_MACHINE_ID"] ?? hostname();
+  if (hookEvent === "UserPromptSubmit") {
+    const prompt = payload["prompt"];
+    if (prompt) {
+      const ok = await sendRawToServer({
+        hook_event: hookEvent,
+        session_id: sessionId,
+        machine_id: machineId,
+        project: cwd,
+        prompt
+      });
+      debugLog(`[hook] ${hookEvent}: prompt sent` + (ok ? " \u2192 server" : " (send failed)"));
+    } else {
+      debugLog(`[hook] ${hookEvent}: no prompt in payload, skipping`);
+    }
+    return;
+  }
+  if (hookEvent === "PermissionRequest") {
+    const toolName = payload["tool_name"];
+    const toolInput = payload["tool_input"];
+    const ok = await sendRawToServer({
+      hook_event: hookEvent,
+      session_id: sessionId,
+      machine_id: machineId,
+      project: cwd,
+      tool_name: toolName,
+      tool_input: toolInput
+    });
+    debugLog(`[hook] ${hookEvent}: ${toolName}` + (ok ? " \u2192 server" : " (send failed)"));
+    return;
+  }
+  if (hookEvent === "SessionEnd") {
+    const ok = await sendRawToServer({
+      hook_event: hookEvent,
+      session_id: sessionId,
+      machine_id: machineId,
+      project: cwd
+    });
+    debugLog(`[hook] ${hookEvent}` + (ok ? " \u2192 server" : " (send failed)"));
+    return;
+  }
+  const locked = await acquireLock();
+  if (!locked) {
+    debugLog(`[hook] ${hookEvent}: could not acquire lock, skipping`);
+    return;
+  }
+  try {
+    const fromOffset = await getByteOffset(transcriptPath);
+    const fileInfo = await stat(transcriptPath);
+    if (fileInfo.size <= fromOffset) {
+      debugLog(`[hook] ${hookEvent}: no diff (offset ${fromOffset} \u2192 ${fileInfo.size})`);
+      await updateByteOffset(transcriptPath, fileInfo.size, sessionId);
+      return;
+    }
+    const buffer = await readFile2(transcriptPath);
+    const newData = buffer.subarray(fromOffset);
+    const text = newData.toString("utf-8");
+    const lines = text.split("\n").filter((l) => l.trim() !== "");
+    if (lines.length === 0) {
+      debugLog(`[hook] ${hookEvent}: no lines in diff`);
+      await updateByteOffset(transcriptPath, fileInfo.size, sessionId);
+      return;
+    }
+    const ok = await sendRawToServer({
+      hook_event: hookEvent ?? "unknown",
+      session_id: sessionId,
+      machine_id: machineId,
+      project: cwd,
+      lines
+    });
+    debugLog(
+      `[hook] ${hookEvent}: ${lines.length} raw lines` + (ok ? " \u2192 server" : " (send failed)")
+    );
+    await updateByteOffset(transcriptPath, fileInfo.size, sessionId);
+  } finally {
+    await releaseLock();
+  }
+}
+export {
+  handleHook
+};

package/dist/setup-6PUWCUFR.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+// src/commands/setup.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+import { hostname } from "os";
+import { execSync } from "child_process";
+var DEFAULT_SERVER_URL = "https://ztile.dev";
+var HOOK_EVENTS = [
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PermissionRequest",
+  "SubagentStart",
+  "SubagentStop",
+  "Stop",
+  "PreCompact",
+  "Notification",
+  "SessionEnd"
+];
+async function setupClaudeCode(options) {
+  const ztileBin = findGlobalBin();
+  if (!ztileBin) {
+    console.error("Error: ztile is not globally installed.");
+    console.error("");
+    console.error("  npm install -g ztile");
+    console.error("  ztile setup --api-key <key>");
+    console.error("");
+    process.exit(1);
+  }
+  const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/tmp";
+  const claudeDir = join(homeDir, ".claude");
+  const settingsPath = join(claudeDir, "settings.json");
+  if (!existsSync(claudeDir)) {
+    console.error(
+      "Claude Code not found (~/.claude/ does not exist). Skipping."
+    );
+    return;
+  }
+  let settings = {};
+  try {
+    const content = await readFile(settingsPath, "utf-8");
+    settings = JSON.parse(content);
+  } catch {
+  }
+  const hooks = settings["hooks"] ?? {};
+  const serverUrl = options.serverUrl ?? DEFAULT_SERVER_URL;
+  const envPrefix = [
+    `ZTILE_API_KEY=${options.apiKey}`,
+    `ZTILE_SERVER_URL=${serverUrl}`,
+    `ZTILE_MACHINE_ID=${options.machineId ?? hostname()}`,
+    ...options.project ? [`ZTILE_PROJECT=${options.project}`] : []
+  ].join(" ");
+  const hookCommand = `${envPrefix} ${ztileBin} hook`;
+  const ztileHook = { type: "command", command: hookCommand };
+  for (const event of Object.keys(hooks)) {
+    const existing = hooks[event] ?? [];
+    hooks[event] = existing.filter(
+      (entry) => !entry.hooks?.some(
+        (h) => h.type === "command" && (h.command?.includes("ztile hook") || h.command?.includes("ztile/apps/collector")) || h.type === "http" && h.url?.includes("/api/hooks/claude")
+      )
+    );
+    if (hooks[event].length === 0) {
+      delete hooks[event];
+    }
+  }
+  let addedCount = 0;
+  for (const event of HOOK_EVENTS) {
+    const existing = hooks[event] ?? [];
+    hooks[event] = [...existing, { hooks: [ztileHook] }];
+    addedCount++;
+  }
+  settings["hooks"] = hooks;
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  console.log(`Claude Code: configured ${addedCount} hook(s) in ${settingsPath}`);
+  console.log(`  Mode:       command (transcript-based)`);
+  console.log(`  Server:     ${serverUrl}`);
+  console.log(`  Machine ID: ${options.machineId ?? hostname()}`);
+  if (options.project) console.log(`  Project:    ${options.project}`);
+  console.log(`  Binary:     ${ztileBin}`);
+  console.log(`  Events:     ${HOOK_EVENTS.join(", ")}`);
+  console.log();
+  console.log("Note: Restart Claude Code sessions for hooks to take effect.");
+}
+function findGlobalBin() {
+  try {
+    const resolved = execSync("which ztile", { encoding: "utf-8" }).trim();
+    return resolved || null;
+  } catch {
+    return null;
+  }
+}
+export {
+  setupClaudeCode
+};

package/package.json

@@ -1,7 +1,44 @@
 {
   "name": "ztile-cli",
-  "version": "0.0.1",
-  "description": "Mission control for autonomous coding agents",
-  "main": "index.js",
-  "license": "MIT"
+  "version": "0.2.2",
+  "description": "Mission control for autonomous coding agents (Claude Code, Codex, Gemini CLI)",
+  "bin": {
+    "ztile": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit",
+    "check-types": "tsc --noEmit"
+  },
+  "dependencies": {
+    "nanoid": "^5.1.5"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0"
+  },
+  "devDependencies": {
+    "@ztile/tsconfig": "workspace:*",
+    "@types/node": "25.3.5",
+    "tsup": "^8.0.0",
+    "typescript": "5.9.2"
+  },
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "monitoring",
+    "observability"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/newdefs/ztile.git"
+  }
 }

package/index.js

@@ -1 +0,0 @@
-// placeholder