@vornrun/connector-sdk 0.7.0-beta.7 → 0.7.0

package/dist/cli.d.ts

@@ -1,9 +1,22 @@
 #!/usr/bin/env node
+import { B as BundleRequest, a as BundleOutput, C as CheckFinding } from './check-62s2GvcO.js';
+
 interface CliDeps {
     load(modulePath: string): Promise<unknown>;
     write(line: string): void;
     env?: NodeJS.ProcessEnv;
+    /** Directory module paths resolve from; defaults to the working directory. */
+    cwd?: string;
+    /** Replaced in tests so pack does not shell out to a bundler. */
+    bundle?(request: BundleRequest): Promise<BundleOutput>;
+    /** Replaced in tests so pack does not start the staged bundle. */
+    launch?(dir: string): Promise<CheckFinding[]>;
+    /** Writes a scaffold file or a receipt; replaced in tests so nothing touches disk. */
+    writeFile?(path: string, contents: string): Promise<void>;
+    /** Replaced in tests beside writeFile. */
+    exists?(path: string): boolean;
 }
 declare function runCli(argv: string[], deps: CliDeps): Promise<number>;
+declare function isEntryPoint(moduleUrl: string, argv?: readonly string[]): boolean;
 
-export { type CliDeps, runCli };
+export { type CliDeps, isEntryPoint, runCli };

package/dist/cli.js

@@ -1,31 +1,44 @@
 #!/usr/bin/env node
 import {
-  checkConnector,
   connectionSetup,
   connectorManifest,
+  esbuildBundle,
   formatFindings,
+  packConnector,
   resolveConfig,
+  runConformance,
   runPoll,
+  scaffoldFiles,
   serveConnector
-} from "./chunk-457KOZUU.js";
+} from "./chunk-ZKHXHE3O.js";
 
 // src/cli.ts
-import { pathToFileURL } from "url";
-import { resolve } from "path";
-var USAGE = `vorn-connector <command> <module> [options]
+import { fileURLToPath, pathToFileURL } from "url";
+import { existsSync, realpathSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { mkdir, writeFile } from "fs/promises";
+var USAGE = `vorn-connector <command> <module | id> [options]
 
 Commands:
+  new <id>                      Scaffold a new connector, ready to build
   manifest <module>             Print the connector manifest as JSON
   setup <module> [trigger]      Print the Vorn connection settings to paste
   check <module>                Verify the connector against Vorn's contract
+  pack <module>                 Build an installable .vorn.tgz pack
   poll <module> <trigger>       Run one poll against the current environment
   serve <module>                Serve the connector on stdio (what Vorn runs)
 
 Options:
   --since <iso>                 Lower bound passed to poll
   --limit <n>                   Maximum items to request
-  --live                        Let check poll for real using the environment`;
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["live"]);
+  --live                        Let check poll for real using the environment
+  --mock                        Run every action against served HTTP, not the network
+  --receipt <file>              Where check writes what it verified, as JSON
+  --out <dir>                   Directory new and pack write to
+  --name <name>                 Display name for a new connector
+  --repo-conventions            Scaffold a package shaped for the connectors repository
+  --extension                   Scaffold an extension \u2014 footers, panes and link handlers`;
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["live", "mock", "repo-conventions", "extension"]);
 function parseArgs(args) {
   const flags = {};
   const positional = [];
@@ -55,7 +68,7 @@ function pickConnector(loaded, modulePath) {
   const connector = candidate;
   if (!connector || typeof connector !== "object" || !Array.isArray(connector.triggers)) {
     throw new Error(
-      `${modulePath} does not export a connector built with defineConnector() (default or named "connector")`
+      `${modulePath} does not export a connector built with defineConnector() or defineExtension() (default or named "connector")`
     );
   }
   return connector;
@@ -67,11 +80,37 @@ async function runCli(argv, deps) {
     return command ? 0 : 1;
   }
   if (!modulePath) {
-    deps.write(`Missing <module> argument
+    deps.write(`Missing <${command === "new" ? "id" : "module"}> argument
 
 ${USAGE}`);
     return 1;
   }
+  if (command === "new") {
+    const { flags: flags2 } = parseArgs(rest);
+    if (!deps.writeFile) {
+      deps.write("This build cannot write files");
+      return 1;
+    }
+    const files = scaffoldFiles({
+      id: modulePath,
+      ...flags2.name !== void 0 && { name: flags2.name },
+      ...flags2["repo-conventions"] === "true" && { repoConventions: true },
+      ...flags2.extension === "true" && { kind: "extension" }
+    });
+    const root = join(flags2.out ?? deps.cwd ?? ".", modulePath);
+    if ((deps.exists ?? existsSync)(root)) {
+      deps.write(`${root} already exists; a scaffold never overwrites`);
+      return 1;
+    }
+    for (const file of files) {
+      await deps.writeFile(join(root, file.path), file.contents);
+    }
+    deps.write(`Created ${modulePath} in ${root}`);
+    for (const file of files) deps.write(`  ${file.path}`);
+    deps.write(`
+Next: cd ${root} && yarn install && yarn check`);
+    return 0;
+  }
   const connector = pickConnector(await deps.load(modulePath), modulePath);
   const { flags, positional } = parseArgs(rest);
   switch (command) {
@@ -95,14 +134,33 @@ ${USAGE}`);
       return 0;
     }
     case "check": {
-      const findings = await checkConnector(connector, {
+      const packaged = flags.mock === "true" ? {
+        mock: true,
+        packageDir: deps.cwd ?? process.cwd(),
+        entry: modulePath,
+        bundle: deps.bundle ?? esbuildBundle
+      } : {};
+      const run = await runConformance(connector, {
+        ...packaged,
         ...flags.live === "true" && {
           live: true,
           config: resolveConfig(connector, deps.env ?? process.env)
         }
       });
+      const { findings } = run;
       const errors = findings.filter((item) => item.level === "error");
       if (findings.length > 0) deps.write(formatFindings(findings));
+      if (flags.receipt !== void 0) {
+        if (run.receipt) {
+          const write = deps.writeFile ?? ((path, contents) => writeFile(path, contents));
+          await write(flags.receipt, `${JSON.stringify(run.receipt, null, 2)}
+`);
+          deps.write(`Verified ${run.receipt.checks.join(", ")} \u2014 wrote ${flags.receipt}`);
+        } else {
+          deps.write(`No receipt written: nothing could be vouched for`);
+          if (errors.length === 0) return 1;
+        }
+      }
       deps.write(
         errors.length > 0 ? `
 ${errors.length} error(s), ${findings.length - errors.length} warning(s)` : `
@@ -110,6 +168,27 @@ ${connector.id} passed with ${findings.length} warning(s)`
       );
       return errors.length > 0 ? 1 : 0;
     }
+    case "pack": {
+      const result = await packConnector(connector, {
+        entry: modulePath,
+        ...flags.out !== void 0 && { outDir: flags.out },
+        ...deps.cwd !== void 0 && { resolveDir: deps.cwd },
+        ...deps.bundle !== void 0 && { bundle: deps.bundle },
+        ...deps.launch !== void 0 && { launch: deps.launch }
+      });
+      if (result.findings.length > 0) deps.write(formatFindings(result.findings));
+      const errors = result.findings.filter((item) => item.level === "error");
+      if (!result.file) {
+        deps.write(`
+${errors.length} error(s) \u2014 nothing was packed`);
+        return 1;
+      }
+      deps.write(
+        `
+Packed ${connector.id} ${connector.version} to ${result.file} (${Math.max(1, Math.round((result.bytes ?? 0) / 1024))} KB)`
+      );
+      return 0;
+    }
     case "poll": {
       const triggerType = positional[0];
       if (!triggerType) {
@@ -141,12 +220,25 @@ ${USAGE}`);
       return 1;
   }
 }
-var invokedDirectly = process.argv[1] !== void 0 && import.meta.url === pathToFileURL(resolve(process.argv[1])).href;
+function isEntryPoint(moduleUrl, argv = process.argv) {
+  const invoked = argv[1];
+  if (invoked === void 0) return false;
+  try {
+    return realpathSync(fileURLToPath(moduleUrl)) === realpathSync(resolve(invoked));
+  } catch {
+    return false;
+  }
+}
+var invokedDirectly = isEntryPoint(import.meta.url);
 if (invokedDirectly) {
   runCli(process.argv.slice(2), {
     load: (modulePath) => modulePath.startsWith(".") || modulePath.startsWith("/") ? import(pathToFileURL(resolve(modulePath)).href) : import(modulePath),
     write: (line) => process.stdout.write(`${line}
-`)
+`),
+    writeFile: async (path, contents) => {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, contents);
+    }
   }).then((code) => {
     process.exitCode = code;
   }).catch((error) => {
@@ -156,5 +248,6 @@ if (invokedDirectly) {
   });
 }
 export {
+  isEntryPoint,
   runCli
 };