@webgrow/skillhub 0.1.0

package/dashboard/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "allowJs": true,
+    "checkJs": false,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "strict": false
+  },
+  "include": ["src"]
+}

package/dashboard/vite.config.mjs

@@ -0,0 +1,23 @@
+import react from "@vitejs/plugin-react";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+const root = fileURLToPath(new URL(".", import.meta.url));
+
+export default defineConfig({
+  root,
+  plugins: [react()],
+  server: {
+    host: "127.0.0.1",
+    port: 5174,
+  },
+  preview: {
+    host: "127.0.0.1",
+    port: 4175,
+  },
+  build: {
+    outDir: path.resolve(root, "../dist/dashboard"),
+    emptyOutDir: true,
+  },
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@webgrow/skillhub",
+  "version": "0.1.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bridge",
+    "!bridge/.env.local",
+    "convex",
+    "dashboard",
+    "!dashboard/.env.local",
+    "src",
+    "README.md"
+  ],
+  "bin": {
+    "skillhub": "src/cli.mjs"
+  },
+  "scripts": {
+    "cli": "node src/cli.mjs",
+    "connect": "node src/cli.mjs connect",
+    "bridge:start": "node src/cli.mjs bridge start",
+    "status": "node src/cli.mjs status",
+    "dashboard:dev": "vite --config dashboard/vite.config.mjs",
+    "dashboard:build": "vite build --config dashboard/vite.config.mjs",
+    "dashboard:preview": "vite preview --config dashboard/vite.config.mjs",
+    "harness": "node bridge/harness.mjs",
+    "harness:doctor": "node bridge/doctor.mjs",
+    "harness:once": "node bridge/harness.mjs --once",
+    "options": "node src/cloud-catalog.mjs list",
+    "choose": "node src/cloud-catalog.mjs run",
+    "convex:dev": "convex dev",
+    "convex:codegen": "convex codegen",
+    "convex:deploy": "convex deploy"
+  },
+  "dependencies": {
+    "@convex-dev/workflow": "^0.4.4",
+    "@convex-dev/workpool": "^0.4.7",
+    "@vitejs/plugin-react": "^6.0.3",
+    "convex": "^1.42.0",
+    "dotenv": "^17.4.2",
+    "lucide-react": "^1.21.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "vite": "^8.1.0"
+  }
+}

package/src/bridge-command.mjs

@@ -0,0 +1,101 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { createBridgeEnv, readUserConfig } from "./config.mjs";
+
+const srcDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.dirname(srcDir);
+const bridgePath = path.join(packageRoot, "bridge", "harness.mjs");
+
+export async function runBridgeCommand(argv = []) {
+  const [subcommand = "start", ...rest] = argv;
+
+  if (subcommand === "start") {
+    return startBridge(rest);
+  }
+
+  if (subcommand === "status") {
+    return showBridgeStatus();
+  }
+
+  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    return showHelp();
+  }
+
+  showHelp();
+  process.exitCode = 1;
+}
+
+async function startBridge(argv) {
+  const flags = parseFlags(argv);
+  const config = await readUserConfig();
+  if (!config.convexUrl && !process.env.CONVEX_URL) {
+    throw new Error("Run skillhub connect first, or provide a SkillHub connection URL.");
+  }
+
+  const args = [bridgePath];
+  if (flags.once) args.push("--once");
+  if (flags.mode) args.push("--mode", flags.mode);
+
+  console.log("Starting SkillHub bridge...");
+  const child = spawn(process.execPath, args, {
+    cwd: packageRoot,
+    env: createBridgeEnv({
+      ...config,
+      bridgeMode: flags.mode || config.bridgeMode,
+    }),
+    stdio: "inherit",
+    windowsHide: true,
+  });
+
+  const code = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (exitCode) => resolve(exitCode ?? 1));
+  });
+  process.exitCode = code;
+}
+
+async function showBridgeStatus() {
+  const config = await readUserConfig();
+  const pid = config.bridge?.pid;
+  const status = pid && isProcessRunning(pid) ? "Connected" : "Disconnected";
+  console.log(`Bridge: ${status}`);
+  if (pid) console.log(`PID: ${pid}`);
+  if (config.bridge?.logPath) console.log(`Log: ${config.bridge.logPath}`);
+}
+
+function parseFlags(argv) {
+  const flags = {
+    mode: "",
+    once: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--mode") flags.mode = argv[++index] ?? "";
+    else if (arg === "--once") flags.once = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return flags;
+}
+
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function showHelp() {
+  console.log(`SkillHub bridge
+
+Commands:
+  skillhub bridge start         Start the local bridge worker
+  skillhub bridge start --once  Process one queued action
+  skillhub bridge status        Show local bridge state
+`);
+}

package/src/cli.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+import {
+  getCloudCatalogItems,
+  getRunStatus,
+  listRecentRuns,
+  renderCatalog,
+  runCloudCatalogCommand,
+  runCloudCatalogItem,
+  watchRun,
+} from "./cloud-catalog.mjs";
+import { runBridgeCommand } from "./bridge-command.mjs";
+import { runConnectCommand } from "./connect.mjs";
+
+const [command = "help", ...argv] = process.argv.slice(2);
+
+function help() {
+  console.log(`SkillHub
+
+Commands:
+  connect                         Connect SkillHub to Codex
+  options                         Show available Convex loops and skills
+  choose                          Pick and run a loop or skill from a numbered list
+  run [loop|skill] [number|name]  Run a loop or skill; opens picker when omitted
+  status [runId]                  Show recent run status
+  bridge start                    Start the local bridge worker
+  mcp serve                       Start the Codex MCP server
+  help                            Show this help
+
+Examples:
+  skillhub connect
+  skillhub options
+  skillhub choose
+  skillhub run 1
+  skillhub status
+  skillhub bridge start
+  skillhub run skill "PR Review Assistant"
+`);
+}
+
+async function main() {
+  if (command === "help" || command === "--help" || command === "-h") return help();
+  if (command === "connect") return runConnectCommand(argv);
+  if (command === "options") return runCloudCatalogCommand(["list", ...argv]);
+  if (command === "choose") return runCloudCatalogCommand(["run", ...argv]);
+  if (command === "run") return runCloudCatalogCommand(["run", ...argv]);
+  if (command === "status") return runCloudCatalogCommand(["status", ...argv]);
+  if (command === "bridge") return runBridgeCommand(argv);
+  if (command === "mcp" && argv[0] === "serve") return mcpServe();
+
+  help();
+  process.exitCode = 1;
+}
+
+async function mcpServe() {
+  process.stdin.setEncoding("utf8");
+  let buffer = "";
+
+  process.stdin.on("data", async (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() ?? "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        const response = await handleMcpMessage(message);
+        if (response) process.stdout.write(`${JSON.stringify(response)}\n`);
+      } catch (error) {
+        process.stdout.write(`${JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: error instanceof Error ? error.message : String(error),
+          },
+        })}\n`);
+      }
+    }
+  });
+}
+
+async function handleMcpMessage(message) {
+  const base = { jsonrpc: "2.0", id: message.id };
+
+  if (message.method === "initialize") {
+    return {
+      ...base,
+      result: {
+        protocolVersion: "2025-06-18",
+        serverInfo: { name: "skillhub", version: "0.1.0" },
+        capabilities: { tools: {} },
+        instructions:
+          "SkillHub lists and runs the user's Convex-backed loops and skills. Use skillhub_list_options before running anything so the user can choose from visible options.",
+      },
+    };
+  }
+
+  if (message.method === "notifications/initialized") {
+    return null;
+  }
+
+  if (message.method === "tools/list") {
+    return {
+      ...base,
+      result: {
+        tools: [
+          {
+            name: "skillhub_list_options",
+            description:
+              "List the user's available SkillHub loops and skills so Codex can show runnable choices instead of requiring exact slugs.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                query: { type: "string" },
+                kind: { type: "string", enum: ["loop", "skill"] },
+                json: { type: "boolean" },
+              },
+            },
+          },
+          {
+            name: "skillhub_run_option",
+            description:
+              "Run a SkillHub loop or skill by visible number, slug, name, or a unique query match.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                target: { type: "string" },
+                query: { type: "string" },
+                kind: { type: "string", enum: ["loop", "skill"] },
+                prompt: { type: "string" },
+              },
+            },
+          },
+          {
+            name: "skillhub_get_run_status",
+            description:
+              "Get the current status and recent details for a SkillHub run. If runId is omitted, returns the most recent runs.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                runId: { type: "string" },
+                limit: { type: "number" },
+              },
+            },
+          },
+          {
+            name: "skillhub_watch_run",
+            description:
+              "Poll a SkillHub run until it completes, fails, or times out. Use after skillhub_run_option when the user wants completion status.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                runId: { type: "string" },
+                timeoutSeconds: { type: "number" },
+                intervalMs: { type: "number" },
+              },
+              required: ["runId"],
+            },
+          },
+          {
+            name: "skillhub_list_recent_runs",
+            description: "List recent SkillHub runs with their current statuses.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                limit: { type: "number" },
+              },
+            },
+          },
+        ],
+      },
+    };
+  }
+
+  if (message.method === "tools/call") {
+    const name = message.params?.name;
+    const args = message.params?.arguments ?? {};
+    const result = await callTool(name, args);
+
+    return {
+      ...base,
+      result: {
+        content: [{ type: "text", text: result }],
+      },
+    };
+  }
+
+  if (!message.id) return null;
+  return { ...base, error: { code: -32601, message: `Unknown method: ${message.method}` } };
+}
+
+async function callTool(name, args) {
+  if (name === "skillhub_list_options") {
+    const items = await getCloudCatalogItems({
+      kind: args.kind,
+      query: args.query,
+    });
+
+    return args.json === true ? JSON.stringify({ items }, null, 2) : renderCatalog(items);
+  }
+
+  if (name === "skillhub_run_option") {
+    const result = await runCloudCatalogItem({
+      kind: args.kind,
+      prompt: args.prompt,
+      query: args.query,
+      target: args.target,
+    });
+
+    return result.ok
+      ? `${result.message}\nRun id: ${result.runId}\nUse skillhub_watch_run to report completion.`
+      : JSON.stringify(result, null, 2);
+  }
+
+  if (name === "skillhub_get_run_status") {
+    if (args.runId) {
+      return JSON.stringify(await getRunStatus(args.runId), null, 2);
+    }
+    return JSON.stringify(await listRecentRuns({ limit: args.limit }), null, 2);
+  }
+
+  if (name === "skillhub_watch_run") {
+    return JSON.stringify(
+      await watchRun({
+        runId: args.runId,
+        timeoutSeconds: args.timeoutSeconds,
+        intervalMs: args.intervalMs,
+      }),
+      null,
+      2,
+    );
+  }
+
+  if (name === "skillhub_list_recent_runs") {
+    return JSON.stringify(await listRecentRuns({ limit: args.limit }), null, 2);
+  }
+
+  throw new Error(`Unknown tool: ${name}`);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});