setup-cc-room 0.2.2 → 0.2.4

package/dist/chunk-NHOFSPZ5.js

@@ -0,0 +1,142 @@
+import {
+  resolveDaemonCommand
+} from "./chunk-CVPLSBRZ.js";
+import {
+  t
+} from "./chunk-Y4O4R4IQ.js";
+import {
+  resolveCcRoomDir
+} from "./chunk-WCEABGOA.js";
+
+// src/register-service.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+import { execFileSync } from "child_process";
+var CC_ROOM_DIR = resolveCcRoomDir();
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function sanitizeSystemdEnvValue(value) {
+  if (!value) return null;
+  if (/[\0\n\r"]/.test(value)) return null;
+  return value;
+}
+function ccRoomHomeEnvXml() {
+  if (!process.env.CC_ROOM_HOME) return "";
+  return `
+    <key>CC_ROOM_HOME</key>
+    <string>${escapeXml(process.env.CC_ROOM_HOME)}</string>`;
+}
+function registerLaunchd() {
+  const plistDir = join(homedir(), "Library", "LaunchAgents");
+  const plistPath = join(plistDir, "dev.ccroom.daemon.plist");
+  const daemonBin = resolveDaemonCommand();
+  const logPath = join(CC_ROOM_DIR, "logs", "daemon.log");
+  mkdirSync(join(CC_ROOM_DIR, "logs"), { recursive: true });
+  mkdirSync(plistDir, { recursive: true });
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>dev.ccroom.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(daemonBin)}</string>
+  </array>
+  <key>KeepAlive</key>
+  <true/>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(logPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>${ccRoomHomeEnvXml()}
+  </dict>
+</dict>
+</plist>
+`;
+  writeFileSync(plistPath, plist, { mode: 420 });
+  try {
+    execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    execFileSync("launchctl", ["load", plistPath], { stdio: "pipe" });
+    console.log(t("svc.launchd_ok", { path: plistPath }));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(t("svc.launchd_fail", { msg }));
+    console.log(t("svc.launchd_manual", { path: plistPath }));
+  }
+}
+function registerSystemd() {
+  const serviceDir = join(homedir(), ".config", "systemd", "user");
+  const servicePath = join(serviceDir, "cc-room-daemon.service");
+  const daemonBin = resolveDaemonCommand();
+  const logPath = join(CC_ROOM_DIR, "logs", "daemon.log");
+  mkdirSync(join(CC_ROOM_DIR, "logs"), { recursive: true });
+  mkdirSync(serviceDir, { recursive: true });
+  const rawHome = process.env.CC_ROOM_HOME;
+  const safeHome = rawHome ? sanitizeSystemdEnvValue(rawHome) : null;
+  if (rawHome && !safeHome) {
+    console.log(t("svc.cc_room_home_unsafe"));
+  }
+  const envLine = safeHome ? `Environment="CC_ROOM_HOME=${safeHome}"
+` : "";
+  const unit = `[Unit]
+Description=cc-room daemon
+After=network.target
+
+[Service]
+ExecStart=${daemonBin}
+Restart=on-failure
+RestartSec=5
+${envLine}StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+
+[Install]
+WantedBy=default.target
+`;
+  writeFileSync(servicePath, unit, { mode: 420 });
+  try {
+    execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
+    execFileSync("systemctl", ["--user", "enable", "--now", "cc-room-daemon"], { stdio: "pipe" });
+    console.log(t("svc.systemd_ok", { path: servicePath }));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(t("svc.systemd_fail", { msg }));
+    console.log(t("svc.systemd_manual"));
+  }
+}
+async function registerService() {
+  const os = platform();
+  if (os === "darwin") {
+    registerLaunchd();
+  } else if (os === "linux") {
+    registerSystemd();
+  } else {
+    console.log(t("svc.unsupported", { os }));
+  }
+  const pidPath = join(CC_ROOM_DIR, "daemon.pid");
+  if (!existsSync(pidPath)) {
+    console.log(t("svc.waiting"));
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+  if (existsSync(pidPath)) {
+    console.log(t("svc.started"));
+  } else {
+    console.log(t("svc.start_unconfirmed"));
+  }
+}
+
+export {
+  escapeXml,
+  sanitizeSystemdEnvValue,
+  registerService
+};

package/dist/chunk-RB72MUPN.js

@@ -0,0 +1,125 @@
+import {
+  resolveDaemonSource
+} from "./chunk-3AMPTQ5K.js";
+import {
+  registerService
+} from "./chunk-NHOFSPZ5.js";
+import {
+  mergeSettings
+} from "./chunk-CVPLSBRZ.js";
+import {
+  t
+} from "./chunk-Y4O4R4IQ.js";
+import {
+  resolveCcRoomDir
+} from "./chunk-WCEABGOA.js";
+
+// src/installer.ts
+import {
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+  copyFileSync,
+  chmodSync,
+  unlinkSync
+} from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { execFileSync, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { stringify } from "yaml";
+var CC_ROOM_DIR = resolveCcRoomDir();
+var BIN_DIR = join(CC_ROOM_DIR, "bin");
+var CONFIG_PATH = join(CC_ROOM_DIR, "config.yaml");
+var COMMANDS_DIR = join(homedir(), ".claude", "commands");
+var THIS_DIR = dirname(fileURLToPath(import.meta.url));
+var SETUP_PACKAGE_ROOT = join(THIS_DIR, "..");
+function getGitUserName() {
+  try {
+    return execFileSync("git", ["config", "user.name"], { encoding: "utf-8", stdio: "pipe" }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function resolveCommandSources(setupPackageRoot, locale) {
+  const candidates = [
+    join(setupPackageRoot, "vendor", "commands", "room", locale),
+    join(setupPackageRoot, "..", "commands", "room", locale),
+    // legacy flat layout (pre-i18n)
+    join(setupPackageRoot, "vendor", "commands", "room"),
+    join(setupPackageRoot, "..", "commands", "room")
+  ];
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "room.md"))) return dir;
+  }
+  return null;
+}
+async function install(locale = "en") {
+  console.log(t("install.step1", { dir: CC_ROOM_DIR }));
+  mkdirSync(BIN_DIR, { recursive: true });
+  const daemonSrc = resolveDaemonSource(SETUP_PACKAGE_ROOT);
+  const daemonDest = join(BIN_DIR, "cc-room-daemon");
+  if (daemonSrc) {
+    copyFileSync(daemonSrc, daemonDest);
+    chmodSync(daemonDest, 493);
+    console.log(t("install.copied", { path: daemonDest }));
+  } else {
+    const globalBin = spawnSync("which", ["cc-room-daemon"], { encoding: "utf-8" });
+    if (globalBin.status === 0) {
+      console.log(t("install.global_ok", { path: globalBin.stdout.trim() }));
+    } else {
+      console.log(`  \x1B[33m\u26A0 ${t("daemon.missing")}\x1B[0m`);
+    }
+  }
+  console.log(t("install.step2", { path: CONFIG_PATH }));
+  if (!existsSync(CONFIG_PATH)) {
+    const identity = getGitUserName();
+    const config = {
+      identity: { name: identity },
+      ui: { locale },
+      network: { port: 7331, http_port: 7332 },
+      trust: [],
+      sessions: { default_mode: "approve", share_files: true, share_context: true },
+      privacy: {
+        public_tools: ["room_context", "room_messages", "room_files", "room_status", "room_invite", "room_share"],
+        private_patterns: [],
+        redact_after_private_tool: true
+      },
+      summarizer: { model: "claude-haiku-4-5-20251001", interval_turns: 5, interval_seconds: 30 },
+      storage: { max_bytes: 524288e3, artifact_ttl_days: 30, context_ttl_days: 7, message_ttl_days: 14 }
+    };
+    writeFileSync(CONFIG_PATH, stringify(config), { mode: 384 });
+    console.log(t("install.config_created", { path: CONFIG_PATH, identity }));
+  } else {
+    console.log(t("install.config_skip", { path: CONFIG_PATH }));
+  }
+  console.log(t("install.step3", { locale }));
+  mkdirSync(COMMANDS_DIR, { recursive: true });
+  const commandFiles = ["room.md", "private.md", "show.md"];
+  const legacyFiles = ["invite.md", "join.md", "leave.md", "files.md", "remember.md", "share.md"];
+  const commandsSrcDir = resolveCommandSources(SETUP_PACKAGE_ROOT, locale);
+  if (!commandsSrcDir) {
+    throw new Error(`Command source directory not found for locale=${locale}`);
+  }
+  for (const cmd of commandFiles) {
+    const src = join(commandsSrcDir, cmd);
+    if (!existsSync(src)) throw new Error(`Command source file not found: ${src}`);
+    copyFileSync(src, join(COMMANDS_DIR, cmd));
+  }
+  for (const legacy of legacyFiles) {
+    const dest = join(COMMANDS_DIR, legacy);
+    if (existsSync(dest)) {
+      unlinkSync(dest);
+    }
+  }
+  console.log(t("install.commands_ok", { count: commandFiles.length, dir: COMMANDS_DIR }));
+  console.log(t("install.step4"));
+  mergeSettings();
+  console.log(t("install.step5"));
+  await registerService();
+}
+
+export {
+  resolveCommandSources,
+  install
+};

package/dist/chunk-URM67EVS.js

@@ -0,0 +1,123 @@
+import {
+  unmergeSettings
+} from "./chunk-DXODI3WA.js";
+import {
+  t
+} from "./chunk-OYW7MM4W.js";
+import {
+  resolveCcRoomDir
+} from "./chunk-WCEABGOA.js";
+
+// src/uninstaller.ts
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  unlinkSync
+} from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+import { execFileSync, spawnSync } from "child_process";
+var COMMAND_FILES = ["room.md", "private.md", "show.md"];
+function getLaunchdPlistPath(home = homedir()) {
+  return join(home, "Library", "LaunchAgents", "dev.ccroom.daemon.plist");
+}
+function getSystemdUnitPath(home = homedir()) {
+  return join(home, ".config", "systemd", "user", "cc-room-daemon.service");
+}
+function stopLaunchd(plistPath) {
+  if (!existsSync(plistPath)) {
+    console.log(t("un.launchd_none"));
+    return;
+  }
+  try {
+    execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    unlinkSync(plistPath);
+    console.log(t("un.launchd_ok", { path: plistPath }));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(t("un.plist_fail", { msg }));
+  }
+}
+function stopSystemd(unitPath) {
+  try {
+    execFileSync("systemctl", ["--user", "disable", "--now", "cc-room-daemon"], { stdio: "pipe" });
+  } catch {
+  }
+  if (existsSync(unitPath)) {
+    try {
+      unlinkSync(unitPath);
+      console.log(t("un.systemd_ok", { path: unitPath }));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(t("un.unit_fail", { msg }));
+    }
+  } else {
+    console.log(t("un.systemd_none"));
+  }
+  try {
+    execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
+  } catch {
+  }
+}
+function removeCommandFiles(commandsDir) {
+  mkdirSync(commandsDir, { recursive: true });
+  let removed = 0;
+  for (const name of COMMAND_FILES) {
+    const path = join(commandsDir, name);
+    if (existsSync(path)) {
+      unlinkSync(path);
+      removed++;
+    }
+  }
+  console.log(t("un.commands_ok", { count: removed, dir: commandsDir }));
+}
+function removeCcRoomData(ccRoomDir) {
+  if (!existsSync(ccRoomDir)) {
+    console.log(t("un.data_skip", { dir: ccRoomDir }));
+    return;
+  }
+  rmSync(ccRoomDir, { recursive: true, force: true });
+  console.log(t("un.data_ok", { dir: ccRoomDir }));
+}
+function stopOrphanDaemon() {
+  if (platform() === "win32") {
+    spawnSync("taskkill", ["/F", "/IM", "cc-room-daemon.exe"], { stdio: "pipe" });
+    return;
+  }
+  spawnSync("pkill", ["-f", "cc-room-daemon"], { stdio: "pipe" });
+}
+async function uninstall() {
+  const ccRoomDir = resolveCcRoomDir();
+  const commandsDir = join(homedir(), ".claude", "commands");
+  const os = platform();
+  console.log(t("un.step1"));
+  if (os === "darwin") {
+    stopLaunchd(getLaunchdPlistPath());
+  } else if (os === "linux") {
+    stopSystemd(getSystemdUnitPath());
+  } else {
+    console.log(t("un.os_manual", { os }));
+  }
+  stopOrphanDaemon();
+  console.log(t("un.step2"));
+  removeCommandFiles(commandsDir);
+  console.log(t("un.step3"));
+  unmergeSettings();
+  console.log(t("un.step4"));
+  removeCcRoomData(ccRoomDir);
+}
+
+export {
+  getLaunchdPlistPath,
+  getSystemdUnitPath,
+  stopLaunchd,
+  stopSystemd,
+  removeCommandFiles,
+  removeCcRoomData,
+  stopOrphanDaemon,
+  uninstall
+};

package/dist/chunk-XX72CSJC.js

@@ -0,0 +1,169 @@
+import {
+  t
+} from "./chunk-Y4O4R4IQ.js";
+
+// src/validators.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, accessSync, constants } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function validateAll() {
+  const checks = [
+    checkNodeVersion(),
+    checkClaudeCodeInstalled(),
+    checkClaudeDir(),
+    checkSettingsWritable(),
+    checkHooksNotDisabled(),
+    checkMcpNotBlocked(),
+    checkSessionDir(),
+    checkGitUser()
+  ];
+  const passed = checks.every((r) => r.ok);
+  return { passed, results: checks };
+}
+function printResults(results) {
+  console.log("\n  Preflight checks:\n");
+  for (const r of results) {
+    const icon = r.ok ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`  ${icon} ${r.message}`);
+    if (!r.ok && r.hint) {
+      console.log(`    \x1B[33m\u2192 ${r.hint}\x1B[0m`);
+    }
+  }
+  console.log("");
+}
+function checkNodeVersion() {
+  const major = parseInt(process.versions.node.split(".")[0], 10);
+  if (major >= 20) {
+    return { ok: true, message: `Node.js ${process.versions.node}` };
+  }
+  return {
+    ok: false,
+    message: t("val.node_bad", { version: process.versions.node }),
+    hint: t("val.node_hint")
+  };
+}
+function checkClaudeCodeInstalled() {
+  try {
+    execFileSync("claude", ["--version"], { encoding: "utf-8", stdio: "pipe" });
+    return { ok: true, message: t("val.claude_ok") };
+  } catch {
+    return {
+      ok: false,
+      message: t("val.claude_missing"),
+      hint: t("val.claude_hint")
+    };
+  }
+}
+function checkClaudeDir() {
+  const claudeDir = join(homedir(), ".claude");
+  if (existsSync(claudeDir)) {
+    return { ok: true, message: t("val.claude_dir_ok") };
+  }
+  return {
+    ok: false,
+    message: t("val.claude_dir_missing"),
+    hint: t("val.claude_dir_hint")
+  };
+}
+function checkSettingsWritable() {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  const settingsDir = join(homedir(), ".claude");
+  if (existsSync(settingsPath)) {
+    try {
+      accessSync(settingsPath, constants.W_OK);
+      return { ok: true, message: t("val.settings_writable") };
+    } catch {
+      return {
+        ok: false,
+        message: t("val.settings_not_writable"),
+        hint: t("val.settings_chmod", { path: settingsPath })
+      };
+    }
+  }
+  try {
+    accessSync(settingsDir, constants.W_OK);
+    return { ok: true, message: t("val.settings_creatable") };
+  } catch {
+    return {
+      ok: false,
+      message: t("val.claude_dir_not_writable"),
+      hint: t("val.claude_dir_chmod", { path: settingsDir })
+    };
+  }
+}
+function checkHooksNotDisabled() {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  if (!existsSync(settingsPath)) {
+    return { ok: true, message: t("val.hooks_unset") };
+  }
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (settings.hooks === false || settings.disableHooks === true) {
+      return {
+        ok: false,
+        message: t("val.hooks_disabled"),
+        hint: t("val.hooks_disabled_hint")
+      };
+    }
+    return { ok: true, message: t("val.hooks_ok") };
+  } catch {
+    return { ok: true, message: t("val.hooks_unrestricted") };
+  }
+}
+function checkMcpNotBlocked() {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  if (!existsSync(settingsPath)) {
+    return { ok: true, message: t("val.mcp_ok") };
+  }
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (settings.mcpServers === false || settings.disableMcp === true) {
+      return {
+        ok: false,
+        message: t("val.mcp_disabled"),
+        hint: t("val.mcp_disabled_hint")
+      };
+    }
+    return { ok: true, message: t("val.mcp_ok") };
+  } catch {
+    return { ok: true, message: t("val.mcp_ok") };
+  }
+}
+function checkSessionDir() {
+  const projectsDir = join(homedir(), ".claude", "projects");
+  if (existsSync(projectsDir)) {
+    return { ok: true, message: t("val.session_ok") };
+  }
+  return {
+    ok: true,
+    message: t("val.session_pending")
+  };
+}
+function checkGitUser() {
+  try {
+    const name = execFileSync("git", ["config", "user.name"], {
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+    if (name) {
+      return { ok: true, message: t("val.git_ok", { name }) };
+    }
+    return {
+      ok: false,
+      message: t("val.git_no_name"),
+      hint: t("val.git_no_name_hint")
+    };
+  } catch {
+    return {
+      ok: false,
+      message: t("val.git_missing"),
+      hint: t("val.git_hint")
+    };
+  }
+}
+
+export {
+  validateAll,
+  printResults
+};