ztile-cli 0.0.1 → 0.3.0

package/dist/chunk-PDX44BCA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-XSAVKZSF.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-PDX44BCA.js";
+
+// src/lib/credentials.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+function credentialsPath() {
+  const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/tmp";
+  return join(home, ".ztile", "credentials.json");
+}
+function loadCredentials() {
+  const path = credentialsPath();
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  const path = credentialsPath();
+  const dir = join(path, "..");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+}
+function resolveApiKey() {
+  const envKey = process.env["ZTILE_API_KEY"];
+  if (envKey) return envKey;
+  const creds = loadCredentials();
+  if (creds?.apiKey) return creds.apiKey;
+  return "";
+}
+function resolveServerUrl() {
+  const envUrl = process.env["ZTILE_SERVER_URL"];
+  if (envUrl) return envUrl;
+  const creds = loadCredentials();
+  if (creds?.serverUrl) return creds.serverUrl;
+  return "https://ztile.dev";
+}
+function resolveMachineId() {
+  const envId = process.env["ZTILE_MACHINE_ID"];
+  if (envId) return envId;
+  const creds = loadCredentials();
+  if (creds?.machineId) return creds.machineId;
+  return "";
+}
+function pidFilePath() {
+  const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/tmp";
+  return join(home, ".ztile", "connect.pid");
+}
+function savePid(pid) {
+  const path = pidFilePath();
+  const dir = join(path, "..");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path, String(pid));
+}
+function loadPid() {
+  const path = pidFilePath();
+  if (!existsSync(path)) return null;
+  try {
+    const pid = parseInt(readFileSync(path, "utf-8").trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function removePid() {
+  const path = pidFilePath();
+  try {
+    const { unlinkSync } = __require("fs");
+    unlinkSync(path);
+  } catch {
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  loadCredentials,
+  saveCredentials,
+  resolveApiKey,
+  resolveServerUrl,
+  resolveMachineId,
+  savePid,
+  loadPid,
+  removePid,
+  isProcessRunning
+};

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+var args = process.argv.slice(2);
+if (args[0] === "hook") {
+  const { handleHook } = await import("./hook-ZR4EVEUT.js");
+  await handleHook();
+  process.exit(0);
+}
+if (args[0] === "login") {
+  const { login } = await import("./login-3IOCLQWW.js");
+  await login({
+    apiKey: findArg(args, "--api-key"),
+    serverUrl: findArg(args, "--server-url"),
+    machineId: findArg(args, "--machine-id")
+  });
+  process.exit(0);
+}
+if (args[0] === "install") {
+  const { resolveApiKey } = await import("./credentials-OO2RZFLG.js");
+  const apiKey = resolveApiKey();
+  if (!apiKey) {
+    console.error("Error: Not logged in.");
+    console.error("  Run `ztile login` first.");
+    process.exit(1);
+  }
+  const { setupClaudeCode } = await import("./setup-VFHRFRZH.js");
+  await setupClaudeCode();
+  process.exit(0);
+}
+if (args[0] === "connect") {
+  const { runConnect } = await import("./connect-ZGETP6WZ.js");
+  const projectDir = findArg(args, "--project") ?? process.env["ZTILE_PROJECT"] ?? process.cwd();
+  const daemon = args.includes("--daemon") || args.includes("-d");
+  await runConnect({ projectDir, daemon });
+}
+if (args[0] === "disconnect") {
+  const { disconnect } = await import("./disconnect-TZ3MQUZS.js");
+  disconnect();
+  process.exit(0);
+}
+if (args.length === 0 || !["hook", "install", "connect", "disconnect", "login"].includes(args[0])) {
+  if (args.length > 0) console.error(`Unknown command: ${args[0]}`);
+  console.log("Usage:");
+  console.log("  ztile login         Save API key and server config");
+  console.log("  ztile install       Configure Claude Code hooks");
+  console.log("  ztile connect       Connect to dashboard for remote control");
+  console.log("  ztile disconnect    Stop background connection");
+  console.log("  ztile hook          Handle Claude Code hook (internal)");
+  console.log("");
+  console.log("Options:");
+  console.log("  ztile connect -d    Run in background (daemon mode)");
+  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/connect-ZGETP6WZ.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import {
+  isProcessRunning,
+  loadPid,
+  removePid,
+  resolveApiKey,
+  resolveServerUrl,
+  savePid
+} from "./chunk-XSAVKZSF.js";
+import "./chunk-PDX44BCA.js";
+
+// src/commands/connect.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
+function getConfig() {
+  return {
+    serverUrl: resolveServerUrl(),
+    apiKey: resolveApiKey()
+  };
+}
+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/connect.ts
+var POLL_INTERVAL_MS = 5e3;
+var HEARTBEAT_INTERVAL_MS = 15e3;
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+var RED = "\x1B[31m";
+var BOLD = "\x1B[1m";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+function log2(icon, msg, color = "") {
+  console.log(`${DIM}${timestamp()}${RESET} ${color}${icon}${RESET} ${msg}`);
+}
+async function handleCommand(cmd, workspaceId, projectDir) {
+  switch (cmd.type) {
+    case "spawn": {
+      const prompt = cmd.payload.prompt;
+      const workdir = cmd.payload.workdir ?? projectDir;
+      const allowedTools = cmd.payload.allowedTools;
+      log2("\u26A1", `Spawn session: "${prompt.slice(0, 60)}${prompt.length > 60 ? "..." : ""}"`, CYAN);
+      await updateCommand(cmd.id, "processing");
+      spawnSession(cmd.id, workspaceId, prompt, workdir, allowedTools);
+      break;
+    }
+    case "prompt": {
+      if (!cmd.sessionId) {
+        log2("\u2717", `Command failed: missing sessionId`, RED);
+        await updateCommand(cmd.id, "failed", { error: "Missing sessionId" });
+        return;
+      }
+      const prompt = cmd.payload.prompt;
+      log2("\u2192", `Prompt sent: "${prompt.slice(0, 60)}${prompt.length > 60 ? "..." : ""}"`, GREEN);
+      await updateCommand(cmd.id, "processing");
+      sendPrompt(cmd.id, workspaceId, cmd.sessionId, prompt);
+      break;
+    }
+    default:
+      log2("?", `Unknown command: ${cmd.type}`, YELLOW);
+      await updateCommand(cmd.id, "failed", { error: `Unknown command type: ${cmd.type}` });
+  }
+}
+async function runConnect(options) {
+  const apiKey = resolveApiKey();
+  if (!apiKey) {
+    console.error("Error: Not logged in. Run `ztile login` first.");
+    process.exit(1);
+  }
+  const { projectDir, daemon } = options;
+  const workspaceId = getWorkspaceId(projectDir);
+  const host = hostname();
+  const serverUrl = resolveServerUrl();
+  const existingPid = loadPid();
+  if (existingPid && isProcessRunning(existingPid)) {
+    console.error(`Error: Already connected (PID: ${existingPid})`);
+    console.error("  Run `ztile disconnect` first.");
+    process.exit(1);
+  }
+  if (daemon) {
+    const { spawn } = await import("child_process");
+    const child = spawn(process.argv[0], [...process.argv.slice(1).filter((a) => a !== "--daemon" && a !== "-d")], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    savePid(child.pid);
+    console.log(`Ztile daemon started (PID: ${child.pid})`);
+    console.log(`  Workspace: ${workspaceId}`);
+    console.log(`  Server:    ${serverUrl}`);
+    console.log("");
+    console.log("Run `ztile disconnect` to stop.");
+    process.exit(0);
+  }
+  savePid(process.pid);
+  console.log("");
+  console.log(`${BOLD}Ztile Connect${RESET}`);
+  console.log(`${DIM}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${RESET}`);
+  console.log(`  Server:    ${serverUrl}`);
+  console.log(`  Workspace: ${workspaceId}`);
+  console.log(`  Hostname:  ${host}`);
+  console.log(`  Project:   ${projectDir}`);
+  console.log(`${DIM}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${RESET}`);
+  console.log("");
+  const ok = await sendHeartbeat(workspaceId, host, []);
+  if (ok) {
+    log2("\u25CF", `Connected to ${serverUrl}`, GREEN);
+  } else {
+    log2("\u25CF", `Failed to connect (will retry)`, RED);
+  }
+  log2("\u25CE", `Waiting for commands...`, DIM);
+  let lastSessionCount = 0;
+  const heartbeatTimer = setInterval(async () => {
+    const sessions2 = getSessionList();
+    const ok2 = await sendHeartbeat(workspaceId, host, sessions2).catch(() => false);
+    if (sessions2.length !== lastSessionCount) {
+      log2("\u25CE", `${sessions2.length} active session${sessions2.length !== 1 ? "s" : ""}`, DIM);
+      lastSessionCount = sessions2.length;
+    }
+    if (!ok2) {
+      log2("!", `Heartbeat failed, retrying...`, YELLOW);
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+  let commandCount = 0;
+  const pollTimer = setInterval(async () => {
+    try {
+      const commands = await pollCommands(workspaceId);
+      for (const cmd of commands) {
+        commandCount++;
+        await handleCommand(cmd, workspaceId, projectDir);
+      }
+    } catch (err) {
+      log2("!", `Poll error: ${err instanceof Error ? err.message : err}`, RED);
+    }
+  }, POLL_INTERVAL_MS);
+  const shutdown = () => {
+    console.log("");
+    log2("\u25CF", `Disconnected (${commandCount} command${commandCount !== 1 ? "s" : ""} processed)`, DIM);
+    clearInterval(heartbeatTimer);
+    clearInterval(pollTimer);
+    removePid();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+export {
+  runConnect
+};

package/dist/credentials-OO2RZFLG.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  isProcessRunning,
+  loadCredentials,
+  loadPid,
+  removePid,
+  resolveApiKey,
+  resolveMachineId,
+  resolveServerUrl,
+  saveCredentials,
+  savePid
+} from "./chunk-XSAVKZSF.js";
+import "./chunk-PDX44BCA.js";
+export {
+  isProcessRunning,
+  loadCredentials,
+  loadPid,
+  removePid,
+  resolveApiKey,
+  resolveMachineId,
+  resolveServerUrl,
+  saveCredentials,
+  savePid
+};

package/dist/disconnect-TZ3MQUZS.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import {
+  isProcessRunning,
+  loadPid,
+  removePid
+} from "./chunk-XSAVKZSF.js";
+import "./chunk-PDX44BCA.js";
+
+// src/commands/disconnect.ts
+function disconnect() {
+  const pid = loadPid();
+  if (!pid) {
+    console.log("No active connection found.");
+    return;
+  }
+  if (!isProcessRunning(pid)) {
+    console.log(`Stale PID file (process ${pid} not running). Cleaning up.`);
+    removePid();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    removePid();
+    console.log(`Disconnected (PID: ${pid})`);
+  } catch (err) {
+    console.error(`Error stopping process ${pid}: ${err instanceof Error ? err.message : err}`);
+    removePid();
+  }
+}
+export {
+  disconnect
+};

package/dist/hook-ZR4EVEUT.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// 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/login-3IOCLQWW.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import {
+  loadCredentials,
+  saveCredentials
+} from "./chunk-XSAVKZSF.js";
+import {
+  __require
+} from "./chunk-PDX44BCA.js";
+
+// src/commands/login.ts
+import { createInterface } from "readline";
+import { hostname } from "os";
+async function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function openBrowser(url) {
+  const { execSync } = __require("child_process");
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") execSync(`open "${url}"`);
+    else if (platform === "win32") execSync(`start "${url}"`);
+    else execSync(`xdg-open "${url}" 2>/dev/null || echo ""`);
+  } catch {
+  }
+}
+async function login(options) {
+  const existing = loadCredentials();
+  const defaultServer = existing?.serverUrl ?? "https://ztile.dev";
+  const defaultMachine = existing?.machineId ?? hostname();
+  let apiKey = options.apiKey;
+  let serverUrl = options.serverUrl ?? defaultServer;
+  const machineId = options.machineId ?? defaultMachine;
+  if (apiKey) {
+    await verifyAndSave(apiKey, serverUrl, machineId);
+    return;
+  }
+  console.log("");
+  console.log("How would you like to authenticate?");
+  console.log("");
+  console.log("  1) Open browser to get API key (recommended)");
+  console.log("  2) Enter API key directly");
+  console.log("");
+  const choice = await prompt("Choice [1]: ");
+  const method = choice === "2" ? "direct" : "browser";
+  if (method === "browser") {
+    const settingsUrl = `${serverUrl}/settings`;
+    console.log("");
+    console.log(`Opening ${settingsUrl} ...`);
+    console.log("Copy your API key from the Settings page and paste it below.");
+    console.log("");
+    openBrowser(settingsUrl);
+    apiKey = await prompt("API Key: ");
+  } else {
+    apiKey = await prompt("API Key: ");
+  }
+  if (!apiKey) {
+    console.error("Error: API key is required.");
+    process.exit(1);
+  }
+  if (!options.serverUrl) {
+    const input = await prompt(`Server URL [${defaultServer}]: `);
+    if (input) serverUrl = input;
+  }
+  await verifyAndSave(apiKey, serverUrl, machineId);
+}
+async function verifyAndSave(apiKey, serverUrl, machineId) {
+  process.stderr.write("Verifying... ");
+  try {
+    const res = await fetch(`${serverUrl}/api/hooks/ingest`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-api-key": apiKey },
+      body: JSON.stringify({})
+    });
+    if (res.status === 401) {
+      console.error("failed");
+      console.error("Error: Invalid API key.");
+      process.exit(1);
+    }
+  } catch {
+    console.error("failed");
+    console.error(`Error: Could not connect to ${serverUrl}`);
+    process.exit(1);
+  }
+  console.error("ok");
+  saveCredentials({ apiKey, serverUrl, machineId });
+  console.log("");
+  console.log("Logged in successfully!");
+  console.log(`  Server:     ${serverUrl}`);
+  console.log(`  Machine ID: ${machineId}`);
+  console.log(`  Saved to:   ~/.ztile/credentials.json`);
+  console.log("");
+  console.log("Next: run `ztile install` to configure Claude Code hooks.");
+}
+export {
+  login
+};

package/dist/setup-VFHRFRZH.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/commands/setup.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+import { execSync } from "child_process";
+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 hookCommand = `${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(`  Binary:  ${ztileBin}`);
+  console.log(`  Events:  ${HOOK_EVENTS.join(", ")}`);
+  console.log();
+  console.log("Next steps:");
+  console.log("  \u2022 Restart Claude Code for hooks to take effect");
+  console.log("  \u2022 Run `ztile connect` to enable remote control from the dashboard");
+}
+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.3.0",
+  "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/shunyooo/ztile.git"
+  }
 }

package/index.js

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