@smartdoc/cli 0.0.0-stage → 0.4.0

package/lib/launch.js

@@ -0,0 +1,96 @@
+import { execFile, spawn } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { APP_ID, APP_NAME, WEBSITE, appEnv, mcpUrl, ownApp, userDataDir } from './platform.js';
+
+// Makes sure the app is running with its MCP server up, opening it if not. A running app is
+// shared: every launcher connects to the same one, and it stays open when they disconnect. The
+// app isn't downloaded from here: the user installs it from the website.
+
+const run = promisify(execFile);
+
+const START_TIMEOUT_MS = 90 * 1000;
+const POLL_MS = 400;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// The token the app's MCP server expects. It's kept in the app's data folder, so it's only
+// readable by the user (and only exists once the app has run).
+export function readToken({ env = process.env } = {}) {
+  try {
+    return readFileSync(path.join(userDataDir({ env }), 'mcp-token'), 'utf8').trim();
+  } catch {
+    return null;
+  }
+}
+
+// 'up' when the server answers with this token; 'down' when nothing is listening; 'locked' when
+// something answers but refuses the token (it may not have been written yet).
+export async function probe({ env = process.env } = {}) {
+  const token = readToken({ env });
+  try {
+    // The server only takes POST, so a GET that gets past the token check answers 405.
+    const res = await fetch(mcpUrl(env), { headers: token ? { authorization: `Bearer ${token}` } : {} });
+    await res.body?.cancel();
+    return res.status === 405 ? 'up' : 'locked';
+  } catch {
+    return 'down';
+  }
+}
+
+export class NotInstalled extends Error {
+  constructor() {
+    super(`${APP_NAME} isn't installed on this computer. Tell the user to download it from ${WEBSITE}, open it once, then try again.`);
+  }
+}
+
+export async function ensureRunning({ env = process.env, log = () => {}, execPath = process.execPath, platform = process.platform } = {}) {
+  if ((await probe({ env })) === 'up') return;
+  await openApp({ env, log, execPath, platform });
+  const deadline = Date.now() + START_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if ((await probe({ env })) === 'up') return;
+    await sleep(POLL_MS);
+  }
+  throw new Error(`${APP_NAME} didn’t start in time. Open it yourself, then try again.`);
+}
+
+// Opens the app: the one given by SMARTDOC_APP, else the app this launcher is part of, else the
+// installed app, which macOS finds by its ID wherever it is.
+async function openApp({ env, log, execPath, platform }) {
+  const override = env.SMARTDOC_APP;
+  if (override) {
+    log(`Opening ${override}…`);
+    return start(appCommand(path.resolve(override)), appEnv(env));
+  }
+  if (platform !== 'darwin') throw new Error(`${APP_NAME} runs on macOS for now.`);
+  const own = ownApp(execPath);
+  log(`Opening ${own ?? APP_NAME}…`);
+  try {
+    await run('open', own ? [own] : ['-b', APP_ID], { env: appEnv(env) });
+  } catch {
+    throw new NotInstalled();
+  }
+}
+
+// How to start an app given by path: a macOS app bundle, a project folder (run with its own
+// Electron, as in development: the nearest one installed, which in a workspace may be above it)
+// or an executable.
+export function appCommand(target) {
+  if (target.endsWith('.app')) return ['open', [target]];
+  if (existsSync(target) && statSync(target).isDirectory()) {
+    const name = process.platform === 'win32' ? 'electron.cmd' : 'electron';
+    for (let dir = target; ; dir = path.dirname(dir)) {
+      const electron = path.join(dir, 'node_modules', '.bin', name);
+      if (existsSync(electron) || dir === path.dirname(dir)) return [electron, [target]];
+    }
+  }
+  return [target, []];
+}
+
+// Detached, so the app outlives this launcher and the AI app that started it.
+function start([command, args], env) {
+  const child = spawn(command, args, { detached: true, stdio: 'ignore', env });
+  child.on('error', () => {}); // reported as a timeout by ensureRunning
+  child.unref();
+}

package/lib/platform.js

@@ -0,0 +1,42 @@
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// Where things are on this computer. Everything here can be overridden with environment
+// variables, which development and tests use to keep away from the user's real app and data:
+//   SMARTDOC_APP        the app to open: a SmartDoc.app, an executable, or a project
+//                       folder (run with its own Electron), instead of the installed one
+//   SMARTDOC_USER_DATA  the app's data folder (passed on to a project-folder app)
+//   SMARTDOC_PORT       the port the app's MCP server listens on (likewise)
+
+export const APP_NAME = 'SmartDoc';
+export const APP_ID = 'com.tw050x.smartdoc';
+export const REPOSITORY = 'tw050x/smartdoc';
+export const WEBSITE = 'https://tw050x.github.io/smartdoc/';
+export const DEFAULT_PORT = 47815;
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+
+export const port = (env = process.env) => Number(env.SMARTDOC_PORT) || DEFAULT_PORT;
+export const mcpUrl = (env = process.env) => `http://127.0.0.1:${port(env)}/mcp`;
+
+// The folder Electron gives the app for its data (it holds the MCP server's token).
+export function userDataDir({ env = process.env, platform = process.platform, home = os.homedir() } = {}) {
+  if (env.SMARTDOC_USER_DATA) return path.resolve(env.SMARTDOC_USER_DATA);
+  if (platform === 'darwin') return path.join(home, 'Library', 'Application Support', APP_NAME);
+  if (platform === 'win32') return path.join(env.APPDATA ?? path.join(home, 'AppData', 'Roaming'), APP_NAME);
+  return path.join(env.XDG_CONFIG_HOME ?? path.join(home, '.config'), APP_NAME);
+}
+
+// The app bundle this launcher runs from, when it's the copy inside the app (run by the app's own
+// executable, …/SmartDoc.app/Contents/MacOS/SmartDoc, as Node); null when it runs from npm.
+export function ownApp(execPath = process.execPath) {
+  const match = execPath.match(/^(.*?\.app)\/Contents\/MacOS\/[^/]+$/);
+  return match ? match[1] : null;
+}
+
+// The environment for opening the app: without ELECTRON_RUN_AS_NODE, which runs this launcher
+// inside the app as Node and would make an Electron app it starts run as Node too.
+export function appEnv(env = process.env) {
+  const { ELECTRON_RUN_AS_NODE, ...rest } = env;
+  return rest;
+}