skills-layer 0.1.0 → 0.1.2

package/tests/public-cli-package.test.mjs

@@ -0,0 +1,169 @@
+import { execFile } from "node:child_process";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageUrl = new URL("../package.json", import.meta.url);
+const runtimeUrl = new URL("../public/skills-layer-public.mjs", import.meta.url);
+const readmeUrl = new URL("../README.md", import.meta.url);
+const licenseUrl = new URL("../LICENSE", import.meta.url);
+const wrapperUrl = new URL("../scripts/skills-layer.mjs", import.meta.url);
+const binPath = fileURLToPath(new URL("../bin/skills-layer.js", import.meta.url));
+
+async function loadRuntime() {
+  return await import(runtimeUrl.href);
+}
+
+async function makeHome() {
+  return await mkdtemp(join(tmpdir(), "skills-layer-cli-package-home-"));
+}
+
+function packageEnv(home) {
+  const env = {
+    ...process.env,
+    HOME: home,
+    SKILLS_LAYER_NO_BANNER: "1"
+  };
+  delete env.SKILLS_LAYER_API_KEY;
+  delete env.SKILLS_LAYER_BASE_URL;
+  delete env.SKILLS_LAYER_MCP_TOKEN;
+  return env;
+}
+
+async function runPublic(args, options = {}) {
+  const runtime = await loadRuntime();
+  return await runtime.executePublicCli(args, {
+    env: packageEnv(options.home ?? await makeHome()),
+    cwd: options.cwd,
+    stdoutIsTty: false,
+    fetch: options.fetch ?? (async () => { throw new Error("Unexpected network call from package contract test."); })
+  });
+}
+
+async function runBin(args) {
+  const home = await makeHome();
+  return await new Promise((resolve) => {
+    execFile(process.execPath, [binPath, ...args], { env: packageEnv(home) }, (error, stdout, stderr) => {
+      resolve({
+        exitCode: typeof error?.code === "number" ? error.code : 0,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+function parseJsonOutput(result) {
+  assert.equal(result.stderr, "");
+  return JSON.parse(result.stdout);
+}
+
+function parseJsonError(result) {
+  assert.equal(result.stdout, "");
+  return JSON.parse(result.stderr);
+}
+
+test("public package metadata keeps the npm tree narrow and non-lifecycle", async () => {
+  const packageJson = JSON.parse(await readFile(packageUrl, "utf8"));
+  assert.equal(packageJson.name, "skills-layer");
+  assert.equal(packageJson.private, false);
+  assert.equal(packageJson.type, "module");
+  assert.equal(packageJson.bin["skills-layer"], "bin/skills-layer.js");
+  assert.equal(packageJson.dependencies, undefined);
+  assert.equal(packageJson.devDependencies, undefined);
+  assert.equal(packageJson.repository, undefined);
+  assert.equal(packageJson.bugs, undefined);
+  assert.deepEqual(packageJson.files, [
+    "bin/skills-layer.js",
+    "public/skills-layer-public.mjs",
+    "scripts/skills-layer.mjs",
+    "docs/assets/*.svg",
+    "tests/public-cli-package.test.mjs"
+  ]);
+  assert.deepEqual(Object.keys(packageJson.scripts).sort(), ["test", "test:coverage", "typecheck"]);
+  for (const lifecycleScript of ["preinstall", "install", "postinstall", "prepare", "prepack", "postpack", "prepublishOnly"]) {
+    assert.equal(packageJson.scripts[lifecycleScript], undefined);
+  }
+});
+
+test("public package text stays limited to public CLI surface", async () => {
+  const [packageText, readme, license, runtime, wrapper] = await Promise.all([
+    readFile(packageUrl, "utf8"),
+    readFile(readmeUrl, "utf8"),
+    readFile(licenseUrl, "utf8"),
+    readFile(runtimeUrl, "utf8"),
+    readFile(wrapperUrl, "utf8")
+  ]);
+  const combined = `${packageText}\n${readme}\n${license}\n${runtime}\n${wrapper}`;
+  assert.match(combined, /Skills Layer/u);
+  assert.match(combined, /skills-layer/u);
+  for (const forbidden of [
+    new RegExp(["", "api", "v1", "admin"].join("/"), "u"),
+    new RegExp(["x", "skills", "layer", "admin", "key"].join("-"), "u"),
+    new RegExp(["SKILLS", "LAYER", "ADMIN", "API", "KEY"].join("_"), "u"),
+    new RegExp(["--", "admin", "api", "key"].join("-"), "u"),
+    new RegExp(["github.com", "openai", "openskills"].join("/"), "u")
+  ]) {
+    assert.doesNotMatch(combined, forbidden);
+  }
+});
+
+test("public bin wrapper and runtime expose deterministic package smoke commands", async () => {
+  const runtime = await loadRuntime();
+  const binVersion = await runBin(["--version"]);
+  assert.equal(binVersion.exitCode, 0);
+  assert.equal(binVersion.stderr, "");
+  assert.match(binVersion.stdout.trim(), /^skills-layer 0\.1\.2$/u);
+
+  const version = await runtime.executePublicCli(["--version"]);
+  assert.equal(version.exitCode, 0);
+  assert.match(version.stdout.trim(), /^skills-layer 0\.1\.2$/u);
+
+  const jsonVersion = await runPublic(["version", "--json"]);
+  assert.equal(jsonVersion.exitCode, 0);
+  assert.equal(parseJsonOutput(jsonVersion).data.version, "0.1.2");
+
+  const loginHelp = await runtime.executePublicCli(["login", "--help"]);
+  assert.equal(loginHelp.exitCode, 0);
+  assert.match(loginHelp.stdout, /Skills Layer login help/u);
+  assert.match(loginHelp.stdout, /skills-layer mcp setup/u);
+
+  const fullHelp = await runtime.executePublicCli(["help", "full"]);
+  assert.equal(fullHelp.exitCode, 0);
+  assert.match(fullHelp.stdout, /Start here:/u);
+  assert.match(fullHelp.stdout, /skills-layer help full/u);
+});
+
+test("public runtime persists backend preference without network access", async () => {
+  const home = await makeHome();
+  const update = await runPublic(["backend", "--base-url", "https://staging.findfigg.co.uk", "--json"], { home });
+  assert.equal(update.exitCode, 0);
+  assert.equal(parseJsonOutput(update).data.selectedBaseUrl, "https://staging.findfigg.co.uk");
+
+  const preference = JSON.parse(await readFile(join(home, ".skills-layer", "backend-preference.json"), "utf8"));
+  assert.equal(preference.preferredBaseUrl, "https://staging.findfigg.co.uk");
+
+  const status = await runPublic(["backend", "status", "--json"], { home });
+  assert.equal(status.exitCode, 0);
+  const statusPayload = parseJsonOutput(status);
+  assert.equal(statusPayload.data.selectedBaseUrl, "https://staging.findfigg.co.uk");
+  assert.equal(statusPayload.data.loggedIn, false);
+});
+
+test("public runtime fails closed for internal and login-required commands", async () => {
+  const admin = await runPublic(["admin", "status", "--json"]);
+  assert.equal(admin.exitCode, 1);
+  const adminPayload = parseJsonError(admin);
+  assert.equal(adminPayload.status, "error");
+  assert.match(adminPayload.summary, /does not include internal commands/u);
+
+  const whoami = await runPublic(["whoami", "--json"]);
+  assert.equal(whoami.exitCode, 1);
+  const whoamiPayload = parseJsonError(whoami);
+  assert.equal(whoamiPayload.status, "error");
+  assert.match(whoamiPayload.summary, /Run `skills-layer login` first/u);
+  assert.doesNotMatch(whoamiPayload.summary, /--api-key/u);
+});

package/scripts/postinstall.mjs

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-const BANNER = `  ____  _    _ _ _       _
- / ___|| | _(_) | |___  | |    __ _ _   _  ___ _ __
- \\___ \\| |/ / | | / __| | |   / _\` | | | |/ _ \\ '__|
-  ___) |   <| | | \\__ \\ | |__| (_| | |_| |  __/ |
- |____/|_|\\_\\_|_|_|___/ |_____\\__,_|\\__, |\\___|_|
-                                     |___/
-Skills-Layer
-AI Agent first platform for Skills`;
-
-if (await shouldShowAndRecordInstallBanner(process.env)) {
-  process.stdout.write([
-    "",
-    BANNER,
-    "",
-    "Thanks for installing Skills-Layer.",
-    "Run `skills-layer setup` to connect AI tools and Security hooks, or `skills-layer --help` for commands.",
-    ""
-  ].join("\n"));
-}
-
-async function shouldShowAndRecordInstallBanner(env) {
-  const mode = normalizeBannerMode(env.SKILLS_LAYER_BANNER);
-  if (mode === "off" || isTruthy(env.CI) || isTruthy(env.SKILLS_LAYER_NO_INSTALL_BANNER) || isTruthy(env.SKILLS_LAYER_NO_BANNER) || env.npm_config_loglevel === "silent") {
-    return false;
-  }
-  if (mode === "always") {
-    return true;
-  }
-  if (!process.stdout.isTTY && !isTruthy(env.SKILLS_LAYER_BANNER_TTY)) {
-    return false;
-  }
-  const displayLimit = parseBannerDisplayLimit(env.SKILLS_LAYER_BANNER_LIMIT);
-  if (displayLimit <= 0) {
-    return false;
-  }
-  const statePath = resolveBannerStatePath(env);
-  if (!statePath) {
-    return false;
-  }
-  try {
-    const state = await readBannerState(statePath);
-    if (state.displayCount >= displayLimit) {
-      return false;
-    }
-    await mkdir(dirname(statePath), { recursive: true });
-    await writeFile(statePath, JSON.stringify({ version: 1, displayCount: state.displayCount + 1, updatedAt: new Date().toISOString() }, null, 2), "utf8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function readBannerState(path) {
-  try {
-    const parsed = JSON.parse(await readFile(path, "utf8"));
-    return { displayCount: typeof parsed.displayCount === "number" ? Math.max(0, parsed.displayCount) : 0 };
-  } catch {
-    return { displayCount: 0 };
-  }
-}
-
-function resolveBannerStatePath(env) {
-  const homeRoot = process.platform === "win32" ? firstNonEmpty(env.APPDATA, env.USERPROFILE, env.HOME) : firstNonEmpty(env.XDG_CONFIG_HOME, env.HOME ? join(env.HOME, ".skills-layer") : undefined);
-  if (!homeRoot) {
-    return null;
-  }
-  const stateDir = process.platform === "win32" || String(env.XDG_CONFIG_HOME ?? "").trim() ? join(homeRoot, "skills-layer") : homeRoot;
-  return join(stateDir, "banner-state.json");
-}
-
-function normalizeBannerMode(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  return normalized === "always" || normalized === "off" ? normalized : "auto";
-}
-
-function parseBannerDisplayLimit(value) {
-  const parsed = Number.parseInt(String(value ?? ""), 10);
-  return Number.isFinite(parsed) ? Math.max(0, parsed) : 2;
-}
-
-function firstNonEmpty(...values) {
-  return values.find((value) => typeof value === "string" && value.trim())?.trim() ?? null;
-}
-
-function isTruthy(value) {
-  return ["1", "true", "yes", "on"].includes(String(value ?? "").trim().toLowerCase());
-}