@pify/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,628 @@
+#!/usr/bin/env node
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var VERSION = require2("../package.json").version;
+
+// src/catalog.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/exec.ts
+import { spawn, spawnSync } from "child_process";
+import { accessSync, constants, statSync } from "fs";
+import { delimiter, join } from "path";
+
+// src/errors.ts
+var ExitCode = {
+  OK: 0,
+  /** Generic / unexpected failure. */
+  FAILURE: 1,
+  /** Bad arguments, unknown command, malformed package name. */
+  USAGE: 2,
+  /** A required external program (pi, npm, node) is missing or too old. */
+  ENVIRONMENT: 3,
+  /** The requested package is not in the catalog or not yet published. */
+  NOT_FOUND: 4,
+  /** A delegated `pi` or `npm` subprocess exited non-zero. */
+  SUBPROCESS: 5
+};
+var PifyError = class extends Error {
+  code;
+  /** Optional follow-up shown after the message, e.g. a command to run. */
+  hint;
+  constructor(message, code = ExitCode.FAILURE, hint) {
+    super(message);
+    this.name = "PifyError";
+    this.code = code;
+    this.hint = hint;
+  }
+};
+function usageError(message, hint) {
+  return new PifyError(message, ExitCode.USAGE, hint);
+}
+function environmentError(message, hint) {
+  return new PifyError(message, ExitCode.ENVIRONMENT, hint);
+}
+function notFoundError(message, hint) {
+  return new PifyError(message, ExitCode.NOT_FOUND, hint);
+}
+
+// src/exec.ts
+var isWindows = process.platform === "win32";
+function isOffline() {
+  for (const name of ["PIFY_OFFLINE", "PI_OFFLINE"]) {
+    const v = process.env[name];
+    if (v && /^(1|true|yes)$/i.test(v)) return true;
+  }
+  return false;
+}
+var SAFE_ARG = /^[A-Za-z0-9@._:/\\+=-]+$/;
+function assertSafeArg(arg, what = "argument") {
+  if (!SAFE_ARG.test(arg)) {
+    throw new PifyError(
+      `Refusing to pass unsafe ${what} to a subprocess: ${JSON.stringify(arg)}`,
+      ExitCode.USAGE,
+      "Package names may contain letters, digits and @ . _ : / \\ + = - only."
+    );
+  }
+}
+function spawnPlan(command, args) {
+  assertSafeArg(command, "command");
+  args.forEach((a) => assertSafeArg(a));
+  return isWindows ? [`${command} ${args.join(" ")}`.trim(), [], { shell: true }] : [command, args, { shell: false }];
+}
+function runCapture(command, args) {
+  const [cmd, argv, opts] = spawnPlan(command, args);
+  const res = spawnSync(cmd, argv, {
+    ...opts,
+    encoding: "utf8",
+    windowsHide: true
+  });
+  return {
+    status: res.status ?? (res.error ? 127 : 1),
+    stdout: res.stdout ?? "",
+    stderr: res.stderr ?? ""
+  };
+}
+function runInherit(command, args) {
+  const [cmd, argv, opts] = spawnPlan(command, args);
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, argv, {
+      ...opts,
+      stdio: "inherit",
+      windowsHide: true
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+function which(command) {
+  const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  if (isWindows) {
+    const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+    for (const dir of dirs) {
+      const candidates = command.includes(".") ? [join(dir, command)] : exts.map((ext) => join(dir, command + ext));
+      for (const candidate of candidates) {
+        try {
+          if (statSync(candidate).isFile()) return candidate;
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  for (const dir of dirs) {
+    const candidate = join(dir, command);
+    try {
+      if (!statSync(candidate).isFile()) continue;
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/catalog.ts
+function bundledCatalogPath() {
+  return join2(dirname(fileURLToPath(import.meta.url)), "..", "catalog.json");
+}
+function cachePath() {
+  return join2(homedir(), ".pify", "catalog.json");
+}
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function loadBundledCatalog() {
+  return JSON.parse(readFileSync(bundledCatalogPath(), "utf8"));
+}
+function validateCatalog(data) {
+  if (typeof data !== "object" || data === null) return false;
+  const c = data;
+  if (!Number.isInteger(c.version)) return false;
+  if (!Array.isArray(c.packages)) return false;
+  for (const entry of c.packages) {
+    if (typeof entry !== "object" || entry === null) return false;
+    const p = entry;
+    if (typeof p.name !== "string" || !/^[a-z0-9-]+$/.test(p.name)) return false;
+    if (typeof p.npm !== "string" || !p.npm.startsWith("@pify/")) return false;
+    if (p.status !== "published" && p.status !== "planned") return false;
+  }
+  return true;
+}
+async function loadCatalog(opts = {}) {
+  const bundled = loadBundledCatalog();
+  const cached = readCache();
+  let remote = cached?.catalog ?? null;
+  const stale = !cached || Date.now() - cached.fetchedAt > CACHE_TTL_MS;
+  if (opts.refresh || stale) {
+    const fetched = await fetchRemoteCatalog(bundled.remote, opts.refresh ? 1e4 : 3e3);
+    if (fetched) {
+      remote = fetched;
+      writeCache(fetched);
+    }
+  }
+  if (!remote || !validateCatalog(remote)) return bundled;
+  return remote.version >= bundled.version ? remote : bundled;
+}
+async function refreshCatalog() {
+  const bundled = loadBundledCatalog();
+  const fetched = await fetchRemoteCatalog(bundled.remote, 1e4);
+  if (fetched) {
+    writeCache(fetched);
+    return { ok: true, catalog: fetched };
+  }
+  const cached = readCache();
+  const fallback = cached && validateCatalog(cached.catalog) && cached.catalog.version >= bundled.version ? cached.catalog : bundled;
+  return { ok: false, catalog: fallback };
+}
+async function fetchRemoteCatalog(defaultUrl, timeoutMs) {
+  if (isOffline()) return null;
+  const url = process.env.PIFY_CATALOG_URL || defaultUrl;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return validateCatalog(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+function readCache() {
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath(), "utf8"));
+    if (typeof parsed.fetchedAt !== "number" || !validateCatalog(parsed.catalog)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeCache(catalog) {
+  try {
+    mkdirSync(dirname(cachePath()), { recursive: true });
+    writeFileSync(cachePath(), JSON.stringify({ fetchedAt: Date.now(), catalog }, null, 2));
+  } catch {
+  }
+}
+var EXACT_VERSION = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/;
+var DIST_TAG = /^[a-z][a-z0-9._-]*$/i;
+function parseInstallSpec(input) {
+  const raw = input.startsWith("npm:") ? input.slice(4) : input;
+  const at = raw.indexOf("@", raw.startsWith("@") ? 1 : 0);
+  const base = at > 0 ? raw.slice(0, at) : raw;
+  const pin = at > 0 ? raw.slice(at + 1) : null;
+  if (pin !== null && !EXACT_VERSION.test(pin) && !(DIST_TAG.test(pin) && !/^\d/.test(pin))) {
+    throw usageError(
+      "Version pins must be exact versions or dist-tags.",
+      `Got ${JSON.stringify(pin)} - ranges (^, ~, >, <, *, x) are not supported.`
+    );
+  }
+  return { base, pin };
+}
+function resolveInstallTarget(catalog, input) {
+  const { base, pin } = parseInstallSpec(input);
+  if (base.startsWith("@")) {
+    if (!base.startsWith("@pify/")) {
+      throw usageError(
+        "pify installs @pify packages only.",
+        `For other sources use: pi install ${input}`
+      );
+    }
+    const shortName = base.slice("@pify/".length).toLowerCase();
+    if (!/^[a-z0-9._-]+$/.test(shortName)) {
+      throw usageError(`Invalid package name: ${JSON.stringify(base)}`);
+    }
+    const entry2 = catalog.packages.find((p) => p.name === shortName) ?? null;
+    return {
+      shortName,
+      npm: `@pify/${shortName}`,
+      pin,
+      explicit: true,
+      inCatalog: entry2 !== null,
+      status: entry2?.status ?? null,
+      repo: entry2?.repo ?? null
+    };
+  }
+  if (/[:/\\]/.test(base)) {
+    throw usageError(
+      "pify installs @pify packages only.",
+      `For other sources use: pi install ${input}`
+    );
+  }
+  const needle = base.toLowerCase();
+  const entry = catalog.packages.find((p) => p.name === needle || `pify-${p.name}` === needle) ?? null;
+  if (!entry) {
+    const names = catalog.packages.map((p) => p.name).join(", ");
+    throw notFoundError(
+      `Unknown pify package: ${JSON.stringify(input)}`,
+      `Available: ${names}`
+    );
+  }
+  if (entry.status !== "published") {
+    throw notFoundError(
+      `@pify/${entry.name} is not published yet.`,
+      `Track it at ${entry.repo}. Run "pify update --catalog" to refresh availability.`
+    );
+  }
+  return {
+    shortName: entry.name,
+    npm: entry.npm,
+    pin,
+    explicit: false,
+    inCatalog: true,
+    status: entry.status,
+    repo: entry.repo
+  };
+}
+function resolvePifyName(input) {
+  const { base } = parseInstallSpec(input);
+  if (base.startsWith("@")) {
+    if (!base.startsWith("@pify/")) {
+      throw usageError(
+        "pify manages @pify packages only.",
+        `For other sources use the pi CLI directly.`
+      );
+    }
+    const shortName = base.slice("@pify/".length).toLowerCase();
+    if (!/^[a-z0-9._-]+$/.test(shortName)) {
+      throw usageError(`Invalid package name: ${JSON.stringify(base)}`);
+    }
+    return shortName;
+  }
+  if (/[:/\\]/.test(base)) {
+    throw usageError(
+      "pify manages @pify packages only.",
+      `For other sources use the pi CLI directly.`
+    );
+  }
+  const name = base.toLowerCase();
+  return name.startsWith("pify-") ? name.slice("pify-".length) : name;
+}
+
+// src/pi.ts
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// src/ui.ts
+function detectColor(stream) {
+  const { NO_COLOR, FORCE_COLOR, TERM } = process.env;
+  if (FORCE_COLOR !== void 0 && FORCE_COLOR !== "0") return true;
+  if (NO_COLOR !== void 0 && NO_COLOR !== "") return false;
+  if (TERM === "dumb") return false;
+  return Boolean(stream.isTTY);
+}
+var stdoutColor = detectColor(process.stdout);
+var stderrColor = detectColor(process.stderr);
+function palette(enabled) {
+  const wrap = (open, close) => (s) => enabled() ? `[${open}m${s}[${close}m` : s;
+  return {
+    bold: wrap("1", "22"),
+    dim: wrap("2", "22"),
+    red: wrap("31", "39"),
+    green: wrap("32", "39"),
+    yellow: wrap("33", "39"),
+    cyan: wrap("36", "39")
+  };
+}
+var style = palette(() => stdoutColor);
+var estyle = palette(() => stderrColor);
+function step(command) {
+  process.stdout.write(`${style.dim(`$ ${command}`)}
+`);
+}
+function success(msg) {
+  process.stdout.write(`${style.green(msg)}
+`);
+}
+
+// src/pi.ts
+var PI_PACKAGE = "@earendil-works/pi-coding-agent";
+var NODE_FLOOR = "22.19.0";
+var TESTED_PI_VERSION = "0.84.4";
+var LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
+function piStatus() {
+  const binPath = which("pi");
+  if (!binPath) return { installed: false, binPath: null, version: null };
+  const res = runCapture("pi", ["--version"]);
+  const version = res.status === 0 ? res.stdout.trim() || null : null;
+  return { installed: true, binPath, version };
+}
+async function fetchLatestPiVersion() {
+  if (isOffline()) return null;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(LATEST_VERSION_URL, {
+      signal: controller.signal,
+      headers: { "user-agent": `pify/${VERSION}` }
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+function compareSemver(a, b) {
+  const pa = a.split(".").map((n) => Number.parseInt(n, 10));
+  const pb = b.split(".").map((n) => Number.parseInt(n, 10));
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function assertNodeVersion() {
+  const current = process.versions.node;
+  if (compareSemver(current, NODE_FLOOR) < 0) {
+    throw environmentError(
+      `The pi coding agent requires Node >= ${NODE_FLOOR}; you are running ${current}.`,
+      "Upgrade Node (e.g. via nvm / nvm-windows) and try again."
+    );
+  }
+}
+async function installPi(version) {
+  assertNodeVersion();
+  if (!which("npm")) {
+    throw environmentError(
+      "npm was not found on PATH.",
+      "Install Node.js (which bundles npm) from https://nodejs.org and retry."
+    );
+  }
+  if (process.env.PI_MANAGED_INSTALL_ROOT && !piStatus().installed) {
+    throw environmentError(
+      "PI_MANAGED_INSTALL_ROOT is set but pi is not installed.",
+      "Use the managed installer: curl -fsSL https://pi.dev/install.sh | sh (Linux/macOS)."
+    );
+  }
+  const spec = version ? `${PI_PACKAGE}@${version}` : PI_PACKAGE;
+  step(`npm install -g --ignore-scripts ${spec}`);
+  const code = await runInherit("npm", ["install", "-g", "--ignore-scripts", spec]);
+  if (code !== 0) {
+    throw new PifyError(
+      `npm install -g ${spec} exited with code ${code}.`,
+      ExitCode.SUBPROCESS,
+      isWindows ? "If this is a permissions or file-lock error, close running pi sessions and retry from an elevated terminal." : "If this is an EACCES error, configure a user-writable npm prefix (https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally) or use a Node version manager."
+    );
+  }
+  const st = piStatus();
+  if (!st.installed) {
+    throw environmentError(
+      "pi was installed but is not resolvable on PATH.",
+      "Add npm's global prefix to PATH (npm prefix -g) and open a new terminal."
+    );
+  }
+  success(`pi ${st.version ?? ""} installed.`.replace("  ", " "));
+}
+async function updatePi() {
+  const st = piStatus();
+  if (!st.installed) {
+    await installPi();
+    return;
+  }
+  step("pi update");
+  const code = await runInherit("pi", ["update"]);
+  if (code !== 0) {
+    throw new PifyError(`pi update exited with code ${code}.`, ExitCode.SUBPROCESS);
+  }
+}
+function agentDir() {
+  const override = process.env.PI_CODING_AGENT_DIR;
+  if (override) {
+    return override.startsWith("~") ? join3(homedir2(), override.slice(1).replace(/^[/\\]/, "")) : override;
+  }
+  return join3(homedir2(), ".pi", "agent");
+}
+function settingsPath(scope) {
+  return scope === "user" ? join3(agentDir(), "settings.json") : join3(process.cwd(), ".pi", "settings.json");
+}
+function readSettings(scope) {
+  try {
+    return JSON.parse(readFileSync2(settingsPath(scope), "utf8"));
+  } catch {
+    return null;
+  }
+}
+var PIFY_SOURCE = /^npm:@pify\/([A-Za-z0-9._-]+?)(?:@(.+))?$/;
+function installedPifyPackages() {
+  const result = /* @__PURE__ */ new Map();
+  for (const scope of ["user", "project"]) {
+    const settings = readSettings(scope);
+    for (const entry of settings?.packages ?? []) {
+      const source = typeof entry === "string" ? entry : entry.source;
+      if (typeof source !== "string") continue;
+      const match = PIFY_SOURCE.exec(source);
+      const name = match?.[1];
+      if (!name) continue;
+      result.set(name, { name, scope, source, pin: match?.[2] ?? null });
+    }
+  }
+  return result;
+}
+function installedVersionOnDisk(name, scope) {
+  const root = scope === "user" ? join3(agentDir(), "npm") : join3(process.cwd(), ".pi", "npm");
+  try {
+    const pkg = JSON.parse(
+      readFileSync2(join3(root, "node_modules", "@pify", name, "package.json"), "utf8")
+    );
+    return { present: true, version: typeof pkg.version === "string" ? pkg.version : null };
+  } catch {
+    return { present: false, version: null };
+  }
+}
+
+// src/templates.ts
+function interpolate(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = vars[key];
+    if (value === void 0) throw new Error(`Unknown template variable: ${key}`);
+    return value;
+  });
+}
+function packageJsonTemplate(scoped) {
+  const publishConfig = scoped ? `
+  "publishConfig": { "access": "public" },` : "";
+  return `{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "description": "{{description}}",
+  "type": "module",
+  "keywords": ["pi-package", "pi-extension", "pi", "pify"],
+  "license": "MIT",${publishConfig}
+  "files": ["index.ts", "src"],
+  "pi": {
+    "extensions": ["./index.ts"]
+  },
+  "engines": { "node": ">=22.19.0" },
+  "scripts": { "typecheck": "tsc --noEmit" },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-ai": { "optional": true },
+    "@earendil-works/pi-agent-core": { "optional": true },
+    "@earendil-works/pi-coding-agent": { "optional": true },
+    "@earendil-works/pi-tui": { "optional": true },
+    "typebox": { "optional": true }
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typescript": "^5.7.2",
+    "@types/node": "^22.10.2"
+  }
+}
+`;
+}
+var INDEX_TS = `import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+// Rules this template already follows:
+// - Signal tool errors by THROWING from execute(); returned values never set isError.
+// - Truncate large output with truncateHead/truncateTail from
+//   @earendil-works/pi-coding-agent (built-in limits: 50 KB / 2000 lines).
+// - Use StringEnum from @earendil-works/pi-ai for enum parameters;
+//   Type.Union/Type.Literal breaks on Google's API.
+// - Use the CONFIG_DIR_NAME export instead of hardcoding ".pi" for
+//   project-local config paths.
+const exampleTool = defineTool({
+  name: "{{snakeName}}_hello",
+  label: "{{shortName}} hello",
+  description: "Example tool for {{name}}. Replace with your own.",
+  parameters: Type.Object({
+    name: Type.String({ description: "Name to greet" }),
+  }),
+  async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+    return {
+      content: [{ type: "text", text: \`Hello, \${params.name}!\` }],
+      details: { greeted: params.name },
+    };
+  },
+});
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool(exampleTool);
+
+  pi.registerCommand("{{shortName}}-hello", {
+    description: "Example command for {{name}}. Replace with your own.",
+    handler: async (args, _ctx) => {
+      // \`args\` is the single raw string typed after the command name.
+      // There is no argv parsing - split it yourself if you need arguments.
+    },
+  });
+
+  // Never start watchers, sockets, timers, or child processes here in the
+  // factory: it can run in invocations that never start a session.
+  pi.on("session_start", async (_event, _ctx) => {
+    // Start background resources here.
+  });
+
+  pi.on("session_shutdown", async (_event, _ctx) => {
+    // Tear them down here. This must be idempotent: it fires on quit,
+    // /reload, /new, /resume, and /fork.
+  });
+}
+`;
+var README_MD = `# {{name}}
+
+{{description}}
+
+A Pi Package for the pi coding agent (https://pi.dev).
+
+## Develop
+
+    npm install              # dev dependencies for typechecking
+    pi install ./{{dir}}     # register locally; hot-reloads with /reload
+    pi -e ./index.ts         # or load ad hoc for a single run
+    npm run typecheck
+
+## Publish
+
+    npm publish --access public
+
+Then install anywhere with: pi install npm:{{name}}
+
+Tested with pi {{piVersion}}.
+`;
+export {
+  ExitCode,
+  INDEX_TS,
+  NODE_FLOOR,
+  PI_PACKAGE,
+  PifyError,
+  README_MD,
+  TESTED_PI_VERSION,
+  VERSION,
+  agentDir,
+  assertSafeArg,
+  compareSemver,
+  fetchLatestPiVersion,
+  installPi,
+  installedPifyPackages,
+  installedVersionOnDisk,
+  interpolate,
+  isOffline,
+  loadBundledCatalog,
+  loadCatalog,
+  packageJsonTemplate,
+  parseInstallSpec,
+  piStatus,
+  readSettings,
+  refreshCatalog,
+  resolveInstallTarget,
+  resolvePifyName,
+  updatePi,
+  validateCatalog,
+  which
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@pify/cli",
+  "version": "0.1.0",
+  "description": "Front door for the Pify suite: install and update the pi coding agent, manage @pify packages, and scaffold Pi Packages",
+  "keywords": [
+    "pify",
+    "pi",
+    "pi-coding-agent",
+    "cli",
+    "coding-agent",
+    "extensions",
+    "scaffolding"
+  ],
+  "homepage": "https://github.com/pifydev/cli#readme",
+  "bugs": {
+    "url": "https://github.com/pifydev/cli/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pifydev/cli.git"
+  },
+  "license": "MIT",
+  "author": "Pify maintainers",
+  "type": "module",
+  "bin": {
+    "pify": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "catalog.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "pretest": "npm run build",
+    "test": "node --test test/*.test.js",
+    "prepublishOnly": "npm run build && npm run typecheck"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}