ztile-cli 0.2.2 → 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.js

@@ -3,37 +3,53 @@
 // src/cli.ts
 var args = process.argv.slice(2);
 if (args[0] === "hook") {
-  const { handleHook } = await import("./hook-SN73JWB3.js");
+  const { handleHook } = await import("./hook-ZR4EVEUT.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 (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: API key is required.");
-    console.error("  Set ZTILE_API_KEY env var, or pass --api-key <key>");
+    console.error("Error: Not logged in.");
+    console.error("  Run `ztile login` first.");
     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")
-  });
+  const { setupClaudeCode } = await import("./setup-VFHRFRZH.js");
+  await setupClaudeCode();
   process.exit(0);
 }
-if (args[0] === "daemon") {
-  const { runDaemon } = await import("./daemon-KSDSRNAZ.js");
+if (args[0] === "connect") {
+  const { runConnect } = await import("./connect-ZGETP6WZ.js");
   const projectDir = findArg(args, "--project") ?? process.env["ZTILE_PROJECT"] ?? process.cwd();
-  await runDaemon(projectDir);
+  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", "setup", "daemon"].includes(args[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 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)");
+  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) {

package/dist/{daemon-KSDSRNAZ.js → connect-ZGETP6WZ.js}

@@ -1,6 +1,15 @@
 #!/usr/bin/env node
+import {
+  isProcessRunning,
+  loadPid,
+  removePid,
+  resolveApiKey,
+  resolveServerUrl,
+  savePid
+} from "./chunk-XSAVKZSF.js";
+import "./chunk-PDX44BCA.js";
 
-// src/commands/daemon.ts
+// src/commands/connect.ts
 import { hostname } from "os";
 
 // src/lib/workspace.ts
@@ -49,11 +58,10 @@ function getWorkspaceId(projectDir) {
 }
 
 // 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"] ?? ""
+    serverUrl: resolveServerUrl(),
+    apiKey: resolveApiKey()
   };
 }
 async function request(method, path, body) {
@@ -228,77 +236,128 @@ function getSessionList() {
   return result;
 }
 
-// src/commands/daemon.ts
+// src/commands/connect.ts
 var POLL_INTERVAL_MS = 5e3;
 var HEARTBEAT_INTERVAL_MS = 15e3;
-function log2(msg) {
-  console.log(`[daemon] ${msg}`);
+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) {
-  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;
+      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 type: ${cmd.type}`);
+      log2("?", `Unknown command: ${cmd.type}`, YELLOW);
       await updateCommand(cmd.id, "failed", { error: `Unknown command type: ${cmd.type}` });
   }
 }
-async function runDaemon(projectDir) {
-  const apiKey = process.env["ZTILE_API_KEY"];
+async function runConnect(options) {
+  const apiKey = resolveApiKey();
   if (!apiKey) {
-    console.error("Error: ZTILE_API_KEY is required.");
+    console.error("Error: Not logged in. Run `ztile login` first.");
     process.exit(1);
   }
+  const { projectDir, daemon } = options;
   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 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(`registered with server`);
+    log2("\u25CF", `Connected to ${serverUrl}`, GREEN);
   } else {
-    log2(`failed to register with server (will retry)`);
+    log2("\u25CF", `Failed to connect (will retry)`, RED);
   }
+  log2("\u25CE", `Waiting for commands...`, DIM);
+  let lastSessionCount = 0;
   const heartbeatTimer = setInterval(async () => {
     const sessions2 = getSessionList();
-    await sendHeartbeat(workspaceId, host, sessions2).catch(() => {
-    });
+    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);
-  log2(`polling for commands...`);
+  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}`);
+      log2("!", `Poll error: ${err instanceof Error ? err.message : err}`, RED);
     }
   }, POLL_INTERVAL_MS);
   const shutdown = () => {
-    log2(`shutting down...`);
+    console.log("");
+    log2("\u25CF", `Disconnected (${commandCount} command${commandCount !== 1 ? "s" : ""} processed)`, DIM);
     clearInterval(heartbeatTimer);
     clearInterval(pollTimer);
+    removePid();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
@@ -307,5 +366,5 @@ async function runDaemon(projectDir) {
   });
 }
 export {
-  runDaemon
+  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-SN73JWB3.js → hook-ZR4EVEUT.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
 
 // src/commands/hook.ts
 import { readFile as readFile2, stat } from "fs/promises";

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-6PUWCUFR.js → setup-VFHRFRZH.js}

@@ -1,12 +1,11 @@
 #!/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 { hostname } from "os";
 import { execSync } from "child_process";
-var DEFAULT_SERVER_URL = "https://ztile.dev";
 var HOOK_EVENTS = [
   "UserPromptSubmit",
   "PreToolUse",
@@ -20,7 +19,7 @@ var HOOK_EVENTS = [
   "Notification",
   "SessionEnd"
 ];
-async function setupClaudeCode(options) {
+async function setupClaudeCode(_options) {
   const ztileBin = findGlobalBin();
   if (!ztileBin) {
     console.error("Error: ztile is not globally installed.");
@@ -46,14 +45,7 @@ async function setupClaudeCode(options) {
   } 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 hookCommand = `${ztileBin} hook`;
   const ztileHook = { type: "command", command: hookCommand };
   for (const event of Object.keys(hooks)) {
     const existing = hooks[event] ?? [];
@@ -75,14 +67,12 @@ async function setupClaudeCode(options) {
   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(`  Binary:  ${ztileBin}`);
+  console.log(`  Events:  ${HOOK_EVENTS.join(", ")}`);
   console.log();
-  console.log("Note: Restart Claude Code sessions for hooks to take effect.");
+  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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ztile-cli",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Mission control for autonomous coding agents (Claude Code, Codex, Gemini CLI)",
   "bin": {
     "ztile": "dist/cli.js"
@@ -39,6 +39,6 @@
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/newdefs/ztile.git"
+    "url": "git+https://github.com/shunyooo/ztile.git"
   }
 }