@webgrow/skillhub 0.1.0

package/src/config.mjs

@@ -0,0 +1,150 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const defaultCodexArgs = [
+  "--ask-for-approval",
+  "never",
+  "exec",
+  "--sandbox",
+  "workspace-write",
+  "--json",
+];
+
+const configFileName = "config.json";
+
+export function getConfigDir(env = process.env) {
+  return env.SKILLHUB_CONFIG_DIR || path.join(os.homedir(), ".skillhub");
+}
+
+export function getConfigPath(env = process.env) {
+  return path.join(getConfigDir(env), configFileName);
+}
+
+export function defaultConfig() {
+  return {
+    workspaceUrl: "",
+    convexUrl: "",
+    codexCommand: "codex",
+    codexArgs: defaultCodexArgs,
+    codexWorkdir: process.cwd(),
+    bridgeMode: "codex-cli",
+    bridge: {
+      pid: null,
+      logPath: path.join(getConfigDir(), "bridge.log"),
+      startedAt: null,
+    },
+  };
+}
+
+export async function readUserConfig(env = process.env) {
+  const configPath = getConfigPath(env);
+  try {
+    const raw = await readFile(configPath, "utf8");
+    return normalizeConfig(JSON.parse(raw));
+  } catch (error) {
+    if (error?.code === "ENOENT") return defaultConfig();
+    throw new Error(`Could not read SkillHub config at ${configPath}: ${error.message}`);
+  }
+}
+
+export function readUserConfigSync(env = process.env) {
+  const configPath = getConfigPath(env);
+  if (!existsSync(configPath)) return defaultConfig();
+  try {
+    return normalizeConfig(JSON.parse(readFileSync(configPath, "utf8")));
+  } catch (error) {
+    throw new Error(`Could not read SkillHub config at ${configPath}: ${error.message}`);
+  }
+}
+
+export async function writeUserConfig(config, env = process.env) {
+  const normalized = normalizeConfig(config);
+  const configDir = getConfigDir(env);
+  await mkdir(configDir, { recursive: true });
+  await writeFile(
+    path.join(configDir, configFileName),
+    `${JSON.stringify(normalized, null, 2)}\n`,
+    "utf8",
+  );
+  return normalized;
+}
+
+export function getRuntimeConfig(env = process.env) {
+  const config = readUserConfigSync(env);
+  return {
+    ...config,
+    convexUrl: config.convexUrl || env.CONVEX_URL || env.VITE_CONVEX_URL || "",
+    workspaceUrl: config.workspaceUrl || env.SKILLHUB_WORKSPACE_URL || "",
+    codexCommand: config.codexCommand || env.CODEX_COMMAND || "codex",
+    codexArgs: arrayOrDefault(
+      config.codexArgs,
+      parseJsonArray(env.CODEX_ARGS_JSON) || defaultCodexArgs,
+    ),
+    codexWorkdir: config.codexWorkdir || env.CODEX_WORKDIR || process.cwd(),
+    bridgeMode:
+      config.bridgeMode || env.SKILLHUB_HARNESS_MODE || env.SKILLHUB_BRIDGE_MODE || "codex-cli",
+  };
+}
+
+export function createBridgeEnv(config = getRuntimeConfig(), env = process.env) {
+  return {
+    ...env,
+    CONVEX_URL: config.convexUrl || env.CONVEX_URL || "",
+    SKILLHUB_HARNESS_MODE: config.bridgeMode || "codex-cli",
+    CODEX_COMMAND: config.codexCommand || "codex",
+    CODEX_ARGS_JSON: JSON.stringify(arrayOrDefault(config.codexArgs, defaultCodexArgs)),
+    CODEX_WORKDIR: config.codexWorkdir || process.cwd(),
+    SKILLHUB_CAPABILITIES:
+      env.SKILLHUB_CAPABILITIES ||
+      "codex.cli,codex.create_goal,codex.create_heartbeat,codex.create_thread,codex.notify_user",
+  };
+}
+
+function normalizeConfig(config) {
+  const base = defaultConfig();
+  const bridge = {
+    ...base.bridge,
+    ...(isObject(config?.bridge) ? config.bridge : {}),
+  };
+
+  return {
+    workspaceUrl: stringOrEmpty(config?.workspaceUrl),
+    convexUrl: stringOrEmpty(config?.convexUrl),
+    codexCommand: stringOrDefault(config?.codexCommand, base.codexCommand),
+    codexArgs: arrayOrDefault(config?.codexArgs, base.codexArgs),
+    codexWorkdir: stringOrDefault(config?.codexWorkdir, base.codexWorkdir),
+    bridgeMode: stringOrDefault(config?.bridgeMode, base.bridgeMode),
+    bridge,
+  };
+}
+
+function parseJsonArray(value) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : null;
+  } catch {
+    return null;
+  }
+}
+
+function arrayOrDefault(value, fallback) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string")
+    ? value
+    : fallback;
+}
+
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function stringOrDefault(value, fallback) {
+  const cleaned = stringOrEmpty(value);
+  return cleaned || fallback;
+}
+
+function isObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value);
+}

package/src/connect.mjs

@@ -0,0 +1,410 @@
+import { spawn } from "node:child_process";
+import { mkdir, open, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import {
+  createBridgeEnv,
+  defaultCodexArgs,
+  getConfigDir,
+  getConfigPath,
+  readUserConfig,
+  writeUserConfig,
+} from "./config.mjs";
+import { getCloudCatalogItems } from "./cloud-catalog.mjs";
+
+const srcDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.dirname(srcDir);
+const cliPath = path.join(srcDir, "cli.mjs");
+const bridgePath = path.join(packageRoot, "bridge", "harness.mjs");
+const packageName = "@webgrow/skillhub";
+
+export async function runConnectCommand(argv = [], io = process) {
+  const flags = parseFlags(argv);
+  const config = await readUserConfig();
+  const rl = io.stdin?.isTTY
+    ? createInterface({ input: io.stdin, output: io.stdout })
+    : null;
+
+  try {
+    console.log("Checking Codex...");
+    let codexCommand = flags.codexCommand || config.codexCommand || "codex";
+    let codex = await checkCommand(codexCommand);
+    if (!codex.ok && !flags.codexCommand) {
+      const configuredCodex = await findConfiguredCodexCommand();
+      if (configuredCodex?.ok) {
+        codexCommand = configuredCodex.command;
+        codex = configuredCodex;
+      }
+    }
+    if (!codex.ok) {
+      if (codex.missing) {
+        await maybeInstallCodex({ rl, yes: flags.yes });
+      } else {
+        throw new Error(`Codex was found but could not start: ${codex.detail}`);
+      }
+    } else {
+      console.log("Codex is installed.");
+    }
+
+    console.log("Checking login...");
+    if (await isCodexSignedIn()) {
+      console.log("Codex is signed in.");
+    } else {
+      await runCodexLogin({ command: codexCommand, rl, yes: flags.yes });
+    }
+
+    console.log("Connecting SkillHub...");
+    const workspaceUrl =
+      flags.workspaceUrl ||
+      config.workspaceUrl ||
+      process.env.SKILLHUB_WORKSPACE_URL ||
+      (await askOptional(rl, "SkillHub dashboard URL (optional): "));
+    const convexUrl =
+      flags.convexUrl ||
+      config.convexUrl ||
+      process.env.CONVEX_URL ||
+      process.env.VITE_CONVEX_URL ||
+      (await discoverConnectionUrl(workspaceUrl)) ||
+      (await askRequired(rl, "SkillHub connection URL: "));
+
+    const nextConfig = await writeUserConfig({
+      ...config,
+      workspaceUrl,
+      convexUrl,
+      codexCommand,
+      codexArgs: config.codexArgs?.length ? config.codexArgs : defaultCodexArgs,
+      codexWorkdir: flags.codexWorkdir || config.codexWorkdir || process.cwd(),
+      bridgeMode: flags.bridgeMode || config.bridgeMode || "codex-cli",
+    });
+
+    await installCodexMcpServer(nextConfig, { local: flags.localMcp });
+    await smokeCheck();
+
+    if (!flags.noBridge) {
+      await startBridgeInBackground(nextConfig);
+    }
+
+    console.log("SkillHub is connected.");
+    console.log('In Codex, ask: "Show my SkillHub options."');
+    console.log(`Config saved at ${getConfigPath()}`);
+  } finally {
+    rl?.close();
+  }
+}
+
+export async function installCodexMcpServer(config, { local = false } = {}) {
+  const codexDir = path.join(os.homedir(), ".codex");
+  const configPath = path.join(codexDir, "config.toml");
+  await mkdir(codexDir, { recursive: true });
+
+  const existing = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
+  const withoutSkillhub = removeTomlSection(existing, "mcp_servers.skillhub").trimEnd();
+  const command = local ? process.execPath : "npx";
+  const args = local
+    ? [cliPath, "mcp", "serve"]
+    : ["-y", packageName, "mcp", "serve"];
+  const section = [
+    "[mcp_servers.skillhub]",
+    `command = ${tomlString(command)}`,
+    `args = ${tomlArray(args)}`,
+    ...(local ? [`cwd = ${tomlString(packageRoot)}`] : []),
+    "startup_timeout_sec = 10",
+    "tool_timeout_sec = 120",
+    "enabled = true",
+  ].join("\n");
+
+  const next = [withoutSkillhub, section].filter(Boolean).join("\n\n");
+  await writeFile(configPath, `${next}\n`, "utf8");
+  return config;
+}
+
+export async function startBridgeInBackground(config) {
+  if (!config.convexUrl) {
+    throw new Error("A SkillHub connection URL is required before starting the bridge.");
+  }
+
+  const configDir = getConfigDir();
+  await mkdir(configDir, { recursive: true });
+  const logPath = path.join(configDir, "bridge.log");
+  const errPath = path.join(configDir, "bridge.err.log");
+  const out = await open(logPath, "a");
+  const err = await open(errPath, "a");
+  const child = spawn(process.execPath, [bridgePath], {
+    cwd: packageRoot,
+    detached: true,
+    env: createBridgeEnv(config),
+    stdio: ["ignore", out.fd, err.fd],
+    windowsHide: true,
+  });
+  child.unref();
+
+  await writeUserConfig({
+    ...config,
+    bridge: {
+      ...(config.bridge ?? {}),
+      pid: child.pid,
+      logPath,
+      startedAt: Date.now(),
+    },
+  });
+
+  await out.close();
+  await err.close();
+}
+
+async function smokeCheck() {
+  const items = await getCloudCatalogItems({ limit: 1 });
+  if (!Array.isArray(items)) {
+    throw new Error("SkillHub could not list options.");
+  }
+}
+
+async function discoverConnectionUrl(workspaceUrl) {
+  if (!workspaceUrl) return "";
+  if (/\.convex\.(cloud|site)/i.test(workspaceUrl)) return workspaceUrl;
+
+  try {
+    const metadataUrl = new URL("/.well-known/skillhub.json", workspaceUrl);
+    const response = await fetch(metadataUrl, { signal: AbortSignal.timeout(5000) });
+    if (!response.ok) return "";
+    const metadata = await response.json();
+    return typeof metadata?.convexUrl === "string" ? metadata.convexUrl.trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+async function maybeInstallCodex({ rl, yes }) {
+  const shouldInstall =
+    yes || (await askYesNo(rl, "Codex CLI was not found. Install it now with npm?"));
+  if (!shouldInstall) {
+    throw new Error("Install Codex, then run skillhub connect again.");
+  }
+
+  console.log("Installing Codex...");
+  const result = await spawnCapture({
+    command: "npm",
+    args: ["install", "-g", "@openai/codex"],
+    timeoutMs: 5 * 60 * 1000,
+  });
+  if (result.code !== 0) {
+    throw new Error(formatCommandFailure(result, "npm install -g @openai/codex"));
+  }
+  console.log("Codex is installed.");
+}
+
+async function runCodexLogin({ command, rl, yes }) {
+  const shouldLogin = yes || (await askYesNo(rl, "Codex is not signed in. Run codex login now?"));
+  if (!shouldLogin) {
+    throw new Error("Sign in with codex login, then run skillhub connect again.");
+  }
+
+  const login = await spawnInherit({ command, args: ["login"] });
+  if (login !== 0) {
+    throw new Error("codex login did not complete successfully.");
+  }
+  console.log("Codex is signed in.");
+}
+
+async function checkCommand(command) {
+  const result = await spawnCapture({ command, args: ["--version"], timeoutMs: 20_000 });
+  if (result.error?.includes("ENOENT")) {
+    return { ok: false, missing: true, detail: result.error };
+  }
+  if (result.code === 0) return { ok: true, detail: result.stdout.trim() };
+  return {
+    ok: false,
+    missing: false,
+    detail: result.error || result.stderr || result.stdout || `exit ${result.code}`,
+  };
+}
+
+async function findConfiguredCodexCommand() {
+  const configPath = path.join(os.homedir(), ".codex", "config.toml");
+  if (!existsSync(configPath)) return null;
+
+  try {
+    const configText = await readFile(configPath, "utf8");
+    const match = configText.match(/^\s*CODEX_CLI_PATH\s*=\s*['"]([^'"]+)['"]/m);
+    const command = match?.[1];
+    if (!command) return null;
+    const result = await checkCommand(command);
+    return result.ok ? { ...result, command } : null;
+  } catch {
+    return null;
+  }
+}
+
+async function isCodexSignedIn() {
+  const authPath = path.join(os.homedir(), ".codex", "auth.json");
+  if (!existsSync(authPath)) return false;
+
+  try {
+    const auth = JSON.parse(await readFile(authPath, "utf8"));
+    return Boolean(auth?.tokens || auth?.OPENAI_API_KEY || auth?.account);
+  } catch {
+    return false;
+  }
+}
+
+async function askRequired(rl, prompt) {
+  const value = await askOptional(rl, prompt);
+  if (!value) {
+    throw new Error("SkillHub needs a workspace URL to connect.");
+  }
+  return value;
+}
+
+async function askOptional(rl, prompt) {
+  if (!rl) return "";
+  const answer = await rl.question(prompt);
+  return answer.trim();
+}
+
+async function askYesNo(rl, prompt) {
+  if (!rl) return false;
+  const answer = await rl.question(`${prompt} [Y/n] `);
+  return !/^n(o)?$/i.test(answer.trim());
+}
+
+function parseFlags(argv) {
+  const flags = {
+    bridgeMode: "",
+    codexCommand: "",
+    codexWorkdir: "",
+    convexUrl: "",
+    noBridge: false,
+    localMcp: false,
+    workspaceUrl: "",
+    yes: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--bridge-mode") flags.bridgeMode = argv[++index] ?? "";
+    else if (arg === "--codex-command") flags.codexCommand = argv[++index] ?? "";
+    else if (arg === "--codex-workdir") flags.codexWorkdir = argv[++index] ?? "";
+    else if (arg === "--convex-url") flags.convexUrl = argv[++index] ?? "";
+    else if (arg === "--local-mcp") flags.localMcp = true;
+    else if (arg === "--no-bridge") flags.noBridge = true;
+    else if (arg === "--workspace-url") flags.workspaceUrl = argv[++index] ?? "";
+    else if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return flags;
+}
+
+function removeTomlSection(text, dottedName) {
+  const lines = text.split(/\r?\n/);
+  const output = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const header = line.match(/^\s*\[([^\]]+)]\s*$/);
+    if (header) {
+      skipping = header[1] === dottedName || header[1].startsWith(`${dottedName}.`);
+    }
+    if (!skipping) output.push(line);
+  }
+
+  return output.join("\n");
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value).replace(/\\/g, "/"));
+}
+
+function tomlArray(values) {
+  return `[${values.map(tomlString).join(", ")}]`;
+}
+
+async function spawnCapture({ command, args, timeoutMs }) {
+  return await new Promise((resolve) => {
+    let child;
+    const stdout = [];
+    const stderr = [];
+    let settled = false;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve({
+        stdout: stdout.join(""),
+        stderr: stderr.join(""),
+        ...result,
+      });
+    };
+
+    try {
+      child = spawn(command, args, {
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+      });
+    } catch (error) {
+      finish({ code: null, error: formatError(error) });
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish({ code: null, error: `Timed out after ${timeoutMs} ms.` });
+    }, timeoutMs);
+
+    child.stdout.on("data", (chunk) => stdout.push(chunk.toString()));
+    child.stderr.on("data", (chunk) => stderr.push(chunk.toString()));
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      finish({ code: null, error: formatError(error) });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      finish({ code, signal });
+    });
+  });
+}
+
+async function spawnInherit({ command, args }) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      shell: false,
+      stdio: "inherit",
+      windowsHide: false,
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+
+function formatCommandFailure(result, command) {
+  return [
+    `${command} failed`,
+    result.code !== null && result.code !== undefined ? `exit=${result.code}` : null,
+    result.signal ? `signal=${result.signal}` : null,
+    result.stderr ? `stderr=${tail(result.stderr)}` : null,
+    result.stdout && !result.stderr ? `stdout=${tail(result.stdout)}` : null,
+    result.error ? `error=${result.error}` : null,
+  ]
+    .filter(Boolean)
+    .join("; ");
+}
+
+function formatError(error) {
+  if (!error) return "Unknown error";
+  const parts = [error.message ?? String(error)];
+  if (error.code) parts.push(error.code);
+  if (error.path) parts.push(error.path);
+  return parts.join("; ");
+}
+
+function tail(text) {
+  const normalized = text.replace(/\r/g, "").trim();
+  return normalized.length <= 700
+    ? normalized
+    : `${normalized.slice(0, 240)}...${normalized.slice(-360)}`;
+}