@ngmthaq20/claude-office 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,37 @@
-# Temporary Holding Version
+# @ngmthaq20/claude-office
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Claude Office in your browser. One package holds the server and the web app, so there is nothing to clone or build.
+
+## Requirements
+
+- Node 24 or newer
+- Claude Code set up on your machine (the app uses your Claude login)
+
+## Usage
+
+```sh
+npx @ngmthaq20/claude-office install
+npx @ngmthaq20/claude-office open [PORT]
+npx @ngmthaq20/claude-office upgrade
+npx @ngmthaq20/claude-office uninstall [--yes]
+```
+
+- `install` creates the data folder, sets up the database, and installs the package globally. After that you can run `claude-office open`.
+- `open [PORT]` starts the server and opens `http://127.0.0.1:<PORT>` in your browser. The default port is 4317. Press Ctrl+C to stop. If the port is busy, the command shows an error and exits with code 1.
+- `upgrade` installs the latest version globally, then runs that version's database migrations on your data folder. Restart any running `open` afterwards.
+- `uninstall` asks before it deletes the data folder, then removes the global package. `--yes` skips the question. Without a terminal and without `--yes`, the data is kept.
+- `help` shows the usage text.
+
+## Data folder
+
+Rooms and history are stored in `~/.@ngmthaq20-claude-office`. The server listens on `127.0.0.1` only.
+
+## Publish
+
+From the repo root (it builds everything first):
+
+```sh
+pnpm publish:cli
+```
+
+Do not use `npm publish`. `pnpm publish` replaces the `workspace:*` dev dependencies with real versions.

package/dist/cli.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+
+// src/configs/cli.config.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = "@ngmthaq20/claude-office";
+var BIN_NAME = "claude-office";
+var DEFAULT_PORT = 4317;
+var HOST = "127.0.0.1";
+var MIN_NODE_MAJOR = 24;
+var READY_TIMEOUT_MS = 2e4;
+var READY_POLL_MS = 200;
+var DIST_DIR = dirname(fileURLToPath(import.meta.url));
+var DATA_DIR = join(homedir(), `.${PACKAGE_NAME.replace("/", "-")}`);
+var SERVER_MAIN_FILE = join(DIST_DIR, "server", "main.js");
+var SERVER_MIGRATE_FILE = join(DIST_DIR, "server", "migrate.js");
+var MIGRATIONS_DIR = join(DIST_DIR, "server", "migrations");
+var WEB_DIST_DIR = join(DIST_DIR, "web");
+var PACKAGE_VERSION = JSON.parse(readFileSync(join(DIST_DIR, "..", "package.json"), "utf8")).version;
+
+// src/commands/install.command.ts
+import { mkdirSync } from "node:fs";
+
+// src/utils/npm.util.ts
+import { spawn } from "node:child_process";
+var SPAWN_SHELL = process.platform === "win32";
+var NpmUtil = class {
+  /** Runs npm with fixed arguments and resolves with its exit code. */
+  static run = (args2) => new Promise((resolve) => {
+    const child = spawn("npm", args2, { stdio: "inherit", shell: SPAWN_SHELL });
+    child.once("error", () => resolve(1));
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+  /** Returns the global node_modules folder, or null when npm cannot tell. */
+  static globalRoot = () => new Promise((resolve) => {
+    const child = spawn("npm", ["root", "-g"], {
+      stdio: ["ignore", "pipe", "inherit"],
+      shell: SPAWN_SHELL
+    });
+    let output = "";
+    child.stdout.on("data", (chunk) => output += chunk.toString());
+    child.once("error", () => resolve(null));
+    child.once("close", (code) => resolve(code === 0 && output.trim() ? output.trim() : null));
+  });
+};
+
+// src/utils/server-process.util.ts
+import { spawn as spawn2 } from "node:child_process";
+var ServerProcessUtil = class {
+  static start = (file, extraEnv = {}) => spawn2(process.execPath, [file], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      NODE_ENV: "production",
+      CLAUDE_OFFICE_DATA_DIR: DATA_DIR,
+      CLAUDE_OFFICE_WEB_DIST_DIR: WEB_DIST_DIR,
+      CLAUDE_OFFICE_MIGRATIONS_DIR: MIGRATIONS_DIR,
+      ...extraEnv
+    }
+  });
+  static waitForExit = (child) => new Promise((resolve) => {
+    if (child.exitCode !== null) return resolve(child.exitCode);
+    child.once("exit", (code, signal) => resolve(code ?? (signal ? 1 : 0)));
+  });
+  /** Resolves true when the server answers, false on timeout or when the child exits first. */
+  static waitUntilReady = async (url, child) => {
+    const deadline = Date.now() + READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      if (child.exitCode !== null || child.signalCode !== null) return false;
+      try {
+        if ((await fetch(url)).ok) return true;
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
+    }
+    return false;
+  };
+};
+
+// src/commands/install.command.ts
+var installCommand = async () => {
+  mkdirSync(DATA_DIR, { recursive: true });
+  console.log(`Data folder ready: ${DATA_DIR}`);
+  const migrateCode = await ServerProcessUtil.waitForExit(
+    ServerProcessUtil.start(SERVER_MIGRATE_FILE)
+  );
+  if (migrateCode !== 0) {
+    console.error("Database setup failed.");
+    return 1;
+  }
+  const npmCode = await NpmUtil.run(["install", "-g", `${PACKAGE_NAME}@${PACKAGE_VERSION}`]);
+  if (npmCode !== 0) {
+    console.error(`Global install failed (npm exit code ${npmCode}).`);
+    return 1;
+  }
+  console.log(`Installed ${PACKAGE_NAME}@${PACKAGE_VERSION}. Next step: ${BIN_NAME} open`);
+  return 0;
+};
+
+// src/commands/open.command.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+
+// src/utils/browser.util.ts
+import { spawn as spawn3 } from "node:child_process";
+var BrowserUtil = class _BrowserUtil {
+  /** Returns false when the browser could not be started. */
+  static open = (url) => new Promise((resolve) => {
+    const [command2, args2] = _BrowserUtil.commandFor(url);
+    const child = spawn3(command2, args2, { stdio: "ignore", detached: true });
+    child.once("error", () => resolve(false));
+    child.once("spawn", () => {
+      child.unref();
+      resolve(true);
+    });
+  });
+  static commandFor = (url) => {
+    if (process.platform === "darwin") return ["open", [url]];
+    if (process.platform === "win32") return ["cmd", ["/c", "start", '""', url]];
+    return ["xdg-open", [url]];
+  };
+};
+
+// src/utils/port.util.ts
+import { createServer } from "node:net";
+var MIN_PORT = 1;
+var MAX_PORT = 65535;
+var PortUtil = class {
+  static parse = (value) => {
+    if (!/^\d+$/.test(value)) return null;
+    const port = Number(value);
+    return port >= MIN_PORT && port <= MAX_PORT ? port : null;
+  };
+  static isFree = (port) => new Promise((resolve) => {
+    const probe = createServer();
+    probe.once("error", () => resolve(false));
+    probe.listen(port, HOST, () => probe.close(() => resolve(true)));
+  });
+};
+
+// src/commands/open.command.ts
+var openCommand = async (args2) => {
+  const port = args2[0] === void 0 ? DEFAULT_PORT : PortUtil.parse(args2[0]);
+  if (port === null) {
+    console.error(`Invalid port "${args2[0]}". Use a whole number from 1 to 65535.`);
+    console.error(`Example: ${BIN_NAME} open 4317`);
+    return 1;
+  }
+  if (!await PortUtil.isFree(port)) {
+    console.error(`Port ${port} is already in use. Pick another port: ${BIN_NAME} open <PORT>`);
+    return 1;
+  }
+  mkdirSync2(DATA_DIR, { recursive: true });
+  const url = `http://${HOST}:${port}`;
+  const child = ServerProcessUtil.start(SERVER_MAIN_FILE, { PORT: String(port) });
+  const exited = ServerProcessUtil.waitForExit(child);
+  let stopping = false;
+  const stop = () => {
+    stopping = true;
+    child.kill("SIGTERM");
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  if (await ServerProcessUtil.waitUntilReady(url, child)) {
+    console.log(`Claude Office is running at ${url} (Ctrl+C to stop)`);
+    if (!await BrowserUtil.open(url)) {
+      console.warn(`Could not open the browser. Open this address yourself: ${url}`);
+    }
+  } else if (!stopping) {
+    console.error(`The server did not become ready at ${url}.`);
+    child.kill("SIGTERM");
+    await exited;
+    return 1;
+  }
+  const code = await exited;
+  return stopping ? 0 : code;
+};
+
+// src/commands/uninstall.command.ts
+import { rmSync } from "node:fs";
+
+// src/utils/prompt.util.ts
+import { createInterface } from "node:readline/promises";
+var PromptUtil = class {
+  /** Asks a yes/no question. The answer is "no" unless the user types y or yes. */
+  static confirm = async (question) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      const answer = await rl.question(`${question} (y/N) `);
+      return ["y", "yes"].includes(answer.trim().toLowerCase());
+    } finally {
+      rl.close();
+    }
+  };
+};
+
+// src/commands/uninstall.command.ts
+var shouldDeleteData = async (skipQuestion) => {
+  if (skipQuestion) return true;
+  if (!process.stdin.isTTY) {
+    console.log("No terminal to ask in. Keeping the data folder (use --yes to delete it).");
+    return false;
+  }
+  return PromptUtil.confirm(`Delete data folder ${DATA_DIR}?`);
+};
+var uninstallCommand = async (args2) => {
+  const deleteData = await shouldDeleteData(args2.includes("--yes"));
+  if (deleteData) rmSync(DATA_DIR, { recursive: true, force: true });
+  const npmCode = await NpmUtil.run(["uninstall", "-g", PACKAGE_NAME]);
+  if (npmCode !== 0) {
+    console.error(`Global uninstall failed (npm exit code ${npmCode}).`);
+    return 1;
+  }
+  console.log(`Removed: global package ${PACKAGE_NAME}`);
+  console.log(deleteData ? `Removed: ${DATA_DIR}` : `Kept: ${DATA_DIR}`);
+  return 0;
+};
+
+// src/commands/upgrade.command.ts
+import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var readVersion = (packageDir) => JSON.parse(readFileSync2(join2(packageDir, "package.json"), "utf8")).version;
+var upgradeCommand = async () => {
+  const npmCode = await NpmUtil.run(["install", "-g", `${PACKAGE_NAME}@latest`]);
+  if (npmCode !== 0) {
+    console.error(`Global install failed (npm exit code ${npmCode}).`);
+    return 1;
+  }
+  const globalRoot = await NpmUtil.globalRoot();
+  const packageDir = globalRoot === null ? null : join2(globalRoot, PACKAGE_NAME);
+  if (packageDir === null || !existsSync(join2(packageDir, "package.json"))) {
+    console.error(
+      `Could not find the installed ${PACKAGE_NAME}. Run "${BIN_NAME} open" to finish the database setup.`
+    );
+    return 1;
+  }
+  const serverDir = join2(packageDir, "dist", "server");
+  mkdirSync3(DATA_DIR, { recursive: true });
+  const migrateCode = await ServerProcessUtil.waitForExit(
+    ServerProcessUtil.start(join2(serverDir, "migrate.js"), {
+      CLAUDE_OFFICE_MIGRATIONS_DIR: join2(serverDir, "migrations")
+    })
+  );
+  if (migrateCode !== 0) {
+    console.error(
+      `Database migration failed. Fix the error above, then run "${BIN_NAME} upgrade" again.`
+    );
+    return 1;
+  }
+  console.log(`Upgraded ${PACKAGE_NAME}: ${PACKAGE_VERSION} -> ${readVersion(packageDir)}`);
+  console.log(`Restart any running "${BIN_NAME} open" to use the new version.`);
+  return 0;
+};
+
+// src/utils/node-version.util.ts
+var NodeVersionUtil = class {
+  static isSupported = () => Number(process.versions.node.split(".")[0]) >= MIN_NODE_MAJOR;
+};
+
+// src/cli.ts
+var USAGE = `Usage: ${BIN_NAME} <command>
+
+Commands:
+  install             Create the data folder, set up the database, and install ${PACKAGE_NAME} globally
+  upgrade             Install the latest ${PACKAGE_NAME} globally and run new database migrations
+  uninstall [--yes]   Remove the global package (asks before deleting the data folder; --yes skips the question)
+  open [PORT]         Start Claude Office and open it in the browser (default port ${DEFAULT_PORT})
+  help                Show this message`;
+var run = async (command2, args2) => {
+  switch (command2) {
+    case "install":
+      return installCommand();
+    case "upgrade":
+      return upgradeCommand();
+    case "uninstall":
+      return uninstallCommand(args2);
+    case "open":
+      return openCommand(args2);
+    case "help":
+      console.log(USAGE);
+      return 0;
+    default:
+      if (command2 !== void 0) console.error(`Unknown command "${command2}".
+`);
+      console.error(USAGE);
+      return 1;
+  }
+};
+if (!NodeVersionUtil.isSupported()) {
+  console.error(
+    `${PACKAGE_NAME} needs Node ${MIN_NODE_MAJOR} or newer. You have ${process.version}.`
+  );
+  process.exit(1);
+}
+var [command, ...args] = process.argv.slice(2);
+process.exit(await run(command, args));