@jals1212/pi-spaces-cli 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -6,6 +6,28 @@ commands and options and a patch version fixes.
 
 ## Unreleased
 
+## 0.5.0
+
+### Added
+
+- A setup command for new spaces: `--setup <cmd>` or `PI_SPACES_SETUP`. `pi-space
+  new` runs it in the new space, and `pi-space setup <name|--every>` runs it
+  again (never in `base`). `{home}` and `{name}` become the space's folder and
+  name, and it runs with `PI_CODING_AGENT_DIR`, `PI_SPACE_HOME` and `PI_SPACE`
+  set to the space, so a program that runs Pi can install what it needs there,
+  for example `pi-space --setup 'my-launcher --home {home} setup' new work`. A
+  failed setup keeps the space and names the command to run it again.
+- `--setup` reaches the started Pi as `PI_SPACES_SETUP`.
+
+### Fixed
+
+- A blank `--command` or `--dir` (only spaces) is a usage error, as an empty one
+  already was, instead of being taken as given.
+
+### Changed
+
+- Needs `@jals1212/pi-spaces` 0.5.0, which reserves the name `setup`.
+
 ## 0.4.0
 
 ### Added

package/README.md

@@ -1,6 +1,6 @@
 # pi-space
 
-The `pi-space` command: pick a [Pi](https://pi.dev) space and start Pi in it, create, rename and remove spaces, and install, update and list the packages of a space, from your shell. It is the optional companion of the Pi extension [`@jals1212/pi-spaces`](https://github.com/jals1212/pi-spaces#readme), which holds the spaces themselves.
+The `pi-space` command: pick a [Pi](https://pi.dev) space and start Pi in it, create, set up, rename and remove spaces, and install, update and list the packages of a space, from your shell. It is the optional companion of the Pi extension [`@jals1212/pi-spaces`](https://github.com/jals1212/pi-spaces#readme), which holds the spaces themselves.
 
 ## Install
 
@@ -12,7 +12,7 @@ Node 20 or later. The Pi extension `@jals1212/pi-spaces` must be installed in th
 
 ## Commands
 
-The command words are reserved: a space can never be named `list`, `new`, `remove`, `rename`, `switch`, `update`, `install` or `uninstall`, so any other first word is a space name.
+The command words are reserved: a space can never be named `list`, `new`, `remove`, `rename`, `switch`, `update`, `install`, `uninstall` or `setup`, so any other first word is a space name.
 
 | Command | What it does |
 | --- | --- |
@@ -20,7 +20,8 @@ The command words are reserved: a space can never be named `list`, `new`, `remov
 | `pi-space <name> [pi args...]` | Starts Pi in that space (`base` for the home Pi starts with). |
 | `pi-space list` | Lists the spaces. |
 | `pi-space list <name\|--every>` | Lists the packages of a space (Pi's `list`). |
-| `pi-space new <name>` | Creates an empty space, as `/space new <name>` does in Pi. It does not start Pi. |
+| `pi-space new <name>` | Creates an empty space, as `/space new <name>` does in Pi, then runs the setup command in it when there is one (see [Preparing a new space](#preparing-a-new-space)). It does not start Pi. |
+| `pi-space setup <name\|--every>` | Runs the setup command in a space, or in every space. Never in `base`. |
 | `pi-space rename <old> <new>` | Renames a space, as `/space rename` does in Pi. It refuses what `remove` refuses (see below). |
 | `pi-space remove <name> [--yes] [--no-backup]` | Deletes a space, as `/space remove <name>` does in Pi. It asks first (`[y/N]`), then whether to keep a backup in `<spaces folder>/.backups` (`[Y/n]`: Enter keeps one). `--yes` skips the questions and keeps a backup, and is required without a terminal; `--no-backup` deletes without one. |
 | `pi-space update <name\|--every> [pi update options...]` | Runs Pi's `update` in a space. What follows is Pi's: `--extensions`, `--all`, a source. With nothing after the name it is Pi's default. |
@@ -50,7 +51,7 @@ A new space gets a `settings.json` that declares the extension, so `/space` work
 
 ## Another program that runs Pi
 
-To start Pi through another program for one call, give `--command` and `--dir` before the rest; the words of `--command` come before `--space`. The words are split on spaces; double or single quotes keep a path with spaces in one word. Such a program usually has its own home, so `--dir` points at its spaces folder, and the Pi it starts gets that folder as `PI_SPACES_DIR` too. Nothing is exported, so a plain `pi` in the same shell is not affected:
+To start Pi through another program for one call, give `--command` and `--dir` before the rest; the words of `--command` come before `--space`. The words are split on spaces; double or single quotes keep a path with spaces in one word. Such a program usually has its own home, so `--dir` points at its spaces folder, and the Pi it starts gets that folder as `PI_SPACES_DIR` too. Nothing is exported, so a plain `pi` in the same shell is not affected. Every command accepts these options and uses the ones it needs (`list` ignores `--command`, `rename` ignores `--setup`), so one alias can give them all:
 
 ```sh
 pi-space --command "my-launcher --" --dir ~/.my-launcher/spaces work   # → my-launcher -- --space work
@@ -71,15 +72,30 @@ export PI_SPACES_DIR=~/.my-launcher/spaces   # the spaces next to that program's
 | --- | --- |
 | `PI_SPACES_COMMAND` | The program to run, split on spaces (double or single quotes keep a path with spaces in one word, as in `"/opt/my launcher/run" --`), before `--space <name>`. Default: `pi`. `--command` wins for one call. |
 | `PI_SPACES_DIR` | The spaces folder. A relative value is taken from your home folder. Default: `spaces` next to the base home. `--dir` wins for one call; a relative `--dir` is taken from the current folder. |
+| `PI_SPACES_SETUP` | The command that prepares a new space (see [Preparing a new space](#preparing-a-new-space)). Unset or blank: none. `--setup` wins for one call. |
 | `PI_CODING_AGENT_DIR` | Pi's agent home; its parent holds the default spaces folder. Default: `~/.pi/agent`. |
 
+## Preparing a new space
+
+A new space starts clean: only a `settings.json` that declares the extension. A program that runs Pi may need its own packages in every home it opens. Give its setup command with `--setup` (or `PI_SPACES_SETUP`), and `pi-space new` runs it right after it creates the space. The words are split as for `--command`, and in each word `{home}` becomes the space's folder and `{name}` its name. The command runs with your stdio, and with `PI_CODING_AGENT_DIR` and `PI_SPACE_HOME` set to the space's folder and `PI_SPACE` to its name:
+
+```sh
+pi-space --setup 'my-launcher --home {home} setup' new work     # create "work", then: my-launcher --home ~/.pi/spaces/work setup
+pi-space --setup 'pi install npm:some-package' new work         # plain Pi: install a package in the new space
+pi-space --setup 'my-launcher --home {home} setup' setup --every # run it again in every space, for example after an update
+```
+
+When the setup fails, the space is kept and `pi-space` exits with the setup's status, naming `pi-space setup <name>` to run it again. `pi-space setup <name>` ends with the setup's status. With `--every` it runs in every space in order, never in `base`, each after a `== <name>` line, and exits as the package commands do. `base` is the home the program prepares itself.
+
+Only those three variables change. A variable that points into the base home stays as it is, so a setup that needs one per space sets it itself, for example `env MY_CONFIG={home}/config my-launcher --home {home} setup`. `--setup` also reaches the Pi that `pi-space` starts as `PI_SPACES_SETUP`, so `/space new` there names `pi-space setup <name>`.
+
 ## Exit status
 
 | Status | Meaning |
 | --- | --- |
-| 0 … | Pi's own exit status, for a space and for a package command in one space. |
-| 1 | An unknown or invalid space, a name `new` or `rename` cannot use (taken, reserved or invalid), a space `remove` or `rename` cannot touch, `remove` without `--yes` and no terminal, an out-of-range pick, the program could not start, or `--every` and at least one run failed (the failed spaces are on the last line of stderr). |
-| 2 | No arguments and no terminal to pick in, a command with the wrong number of names (`new`, `remove`, `rename`), `install` or `uninstall` without a source, a package command without a space or `--every`, or `--command` or `--dir` without a value or given twice: the usage is printed. The old `--new` and `--remove`: the replacing command is printed. A `--command` or `PI_SPACES_COMMAND` with an unclosed quote: the problem is printed. |
+| 0 … | Pi's own exit status, for a space and for a package command in one space; the setup's exit status for `setup <name>` and for a `new` whose setup failed. |
+| 1 | An unknown or invalid space, a name `new` or `rename` cannot use (taken, reserved or invalid), a space `remove` or `rename` cannot touch, `remove` without `--yes` and no terminal, an out-of-range pick, the program could not start, or `--every` and at least one run failed (the failed spaces are on the last line of stderr), or `setup base`, since setup runs only in spaces. |
+| 2 | No arguments and no terminal to pick in, a command with the wrong number of names (`new`, `remove`, `rename`), `install` or `uninstall` without a source, a package command without a space or `--every`, or `--command`, `--dir` or `--setup` without a value (or a blank one) or given twice: the usage is printed. `setup` without a setup command: the problem is printed. The old `--new` and `--remove`: the replacing command is printed. A `--command`, `PI_SPACES_COMMAND`, `--setup` or `PI_SPACES_SETUP` with an unclosed quote: the problem is printed, and nothing is created or started. |
 
 ## More
 

package/dist/cli.js

@@ -1,6 +1,6 @@
 // The optional `pi-space` command: pick a space and start Pi in it, and manage the spaces and their packages.
 // It only passes `--space <name>` (and, for a package command, Pi's command after it); the extension does the
-// switch, so it never sets PI_CODING_AGENT_DIR.
+// switch, so it sets PI_CODING_AGENT_DIR only for the setup command, which is not Pi and does no switch.
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -15,6 +15,7 @@ import {
 	createSpace,
 	         
 	findOwnDeclaration,
+	hasSetupCommand,
 	listSpaces,
 	                        
 	removeSpace,
@@ -24,13 +25,14 @@ import {
 	validateName,
 } from "@jals1212/pi-spaces/spaces";
 
-export const USAGE = `Usage: pi-space [--command <cmd>] [--dir <path>] [<name> [pi args...] | <command> ...]
+export const USAGE = `Usage: pi-space [--command <cmd>] [--dir <path>] [--setup <cmd>] [<name> [pi args...] | <command> ...]
        pi-space --help | --version
   pi-space                                    pick a space and start Pi in it
   pi-space <name> [pi args...]                start Pi in a space ("base" for the home Pi starts with)
   pi-space list                               list the spaces
   pi-space list <name|--every>                list the packages of a space
-  pi-space new <name>                         create a space
+  pi-space new <name>                         create a space, then run the setup command in it when there is one
+  pi-space setup <name|--every>               run the setup command in a space, or in every space (never in base)
   pi-space rename <old> <new>                 rename a space
   pi-space remove <name>                      delete a space and everything in it, after asking, and keep a backup in .backups unless told not to
                                               (--yes skips the questions; --no-backup deletes without a backup)
@@ -39,19 +41,21 @@ export const USAGE = `Usage: pi-space [--command <cmd>] [--dir <path>] [<name> [
   pi-space uninstall <name|--every> <source>  remove a package from a space (more words go to Pi)
   pi-space --help                             print this help
   pi-space --version                          print the version
-  --every takes the place of the name: base first, then every space in turn; a failure does not stop the rest, and the exit status is 1 if any failed.
+  --every takes the place of the name: base first (not for setup), then every space in turn; a failure does not stop the rest, and the exit status is 1 if any failed.
 Options before the command, for this call only:
   --command <cmd>                             the program to run instead of $PI_SPACES_COMMAND (default: pi), e.g. "my-launcher --"
   --dir <path>                                the spaces folder instead of $PI_SPACES_DIR; the Pi it starts gets it too
+  --setup <cmd>                               the setup command instead of $PI_SPACES_SETUP; {home} and {name} become the space's folder and name
 `;
 
 /** This package's version; package.json sits one folder above both src/ and dist/. */
 export const VERSION         = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 
-/** --command and --dir: for this call only, so nothing has to be exported into the shell. */
+/** --command, --dir and --setup: for this call only, so nothing has to be exported into the shell. */
                               
 	                 
 	             
+	               
  
 
 /** The Pi commands that pi-space runs in one space or in every space. */
@@ -76,6 +80,7 @@ const REPLACED = {
 	                  
 	                                                                                
 	                               
+	                                          
 	                                              
 	                                                                 
 	                    
@@ -84,11 +89,11 @@ const REPLACED = {
    
 	            
 
-const CALL_OPTIONS = { "--command": "command", "--dir": "dir" }         ;
+const CALL_OPTIONS = { "--command": "command", "--dir": "dir", "--setup": "setup" }         ;
 
 /**
- * --command and --dir come first; after a space name every argument belongs to Pi.
- * The commands (list, new, remove, rename, update, install, uninstall) are reserved words, so they are read
+ * --command, --dir and --setup come first; after a space name every argument belongs to Pi.
+ * The commands (list, new, setup, remove, rename, update, install, uninstall) are reserved words, so they are read
  * before a name: the core never lets a space have one of them as its name.
  * A space name never starts with "-", so any other option in first place is unknown, not a name.
  */
@@ -98,7 +103,8 @@ export function parseCli(args          )             {
 	while (Object.hasOwn(CALL_OPTIONS, args[index] ?? "")) {
 		const key = CALL_OPTIONS[args[index]                             ];
 		const value = args[index + 1];
-		if (!value || options[key] !== undefined) return { kind: "usage" };
+		// A blank value is as good as none: it would name no program, folder or command.
+		if (!value?.trim() || options[key] !== undefined) return { kind: "usage" };
 		options[key] = value;
 		index += 2;
 	}
@@ -116,6 +122,7 @@ function parseCommand(args          )             {
 	if (first === "list" && rest.length === 0) return { kind: "list" };
 	if (PACKAGE_VERBS.includes(first)) return parsePackages(first               , rest);
 	if (first === "new") return rest.length === 1 ? { kind: "new", name: rest[0] } : { kind: "usage" };
+	if (first === "setup") return parseSetup(rest);
 	if (first === "rename") return rest.length === 2 ? { kind: "rename", from: rest[0], to: rest[1] } : { kind: "usage" };
 	if (first === "remove") {
 		const flags = rest.filter((arg) => arg.startsWith("-"));
@@ -128,6 +135,14 @@ function parseCommand(args          )             {
 	return { kind: "launch", name: first, args: rest };
 }
 
+/** `setup <name>` or `setup --every`: exactly one argument. */
+function parseSetup(rest          )             {
+	if (rest.length !== 1) return { kind: "usage" };
+	if (rest[0] === "--every") return { kind: "setup", target: { every: true } };
+	if (rest[0].startsWith("-")) return { kind: "unknown-option", option: rest[0] };
+	return { kind: "setup", target: { name: rest[0] } };
+}
+
 /**
  * `<verb> <name|--every> [args...]`. list takes nothing after the target; install and uninstall need a source
  * (the first argument after it); update may have nothing, which is Pi's own default.
@@ -150,6 +165,17 @@ export function launchCommand(env     , name        , args          )
 	return { program, args: [...prefix, "--space", name, ...args] };
 }
 
+/**
+ * The program and arguments of the setup command for one space: the template split like --command, with every
+ * {home} and {name} in each word replaced by the space's folder and name. Throws when it has an unclosed quote.
+ */
+export function setupCommand(template        , home        , name        )                                      {
+	// Replacer functions, so a "$" in the folder or name is put in as written, never read as a pattern.
+	const fill = (word        ) => word.replaceAll("{home}", () => home).replaceAll("{name}", () => name);
+	const [program = "", ...args] = splitCommand(template).map(fill);
+	return { program, args };
+}
+
 /**
  * Splits a command into words on whitespace. Double or single quotes keep whitespace inside a word and are
  * removed. There are no backslash escapes, so a Windows path in quotes keeps its backslashes.
@@ -205,7 +231,7 @@ function agentHome(env     , home        )         {
 
                                
 	                 
-	                                                                                              
+	                                                                                                                             
 	          
  
 
@@ -219,7 +245,7 @@ function agentHome(env     , home        )         {
 	                                         
 	                                         
 	         
-	                                                                                                    
+	                                                                                                               
 	               
 	             
 	                                                                                    
@@ -256,14 +282,18 @@ export function processIo(proc                 = process)        {
 
 export async function main(argv          , io       )                {
 	const command = parseCli(argv);
-	if (command.dir !== undefined || command.command !== undefined) {
-		// A relative --dir is relative to where the command runs; the child gets it absolute.
-		const env = { ...io.env };
-		if (command.dir !== undefined) env.PI_SPACES_DIR = resolve(command.dir);
+	if (command.dir !== undefined || command.command !== undefined || command.setup !== undefined) {
+		// env is this call's view; the started Pi also gets --dir (absolute: a relative one is relative to where
+		// the command runs) and --setup, but not --command, which only says how to start it.
+		const forChild      = {};
+		if (command.dir !== undefined) forChild.PI_SPACES_DIR = resolve(command.dir);
+		if (command.setup !== undefined) forChild.PI_SPACES_SETUP = command.setup;
+		const env = { ...io.env, ...forChild };
 		if (command.command !== undefined) env.PI_SPACES_COMMAND = command.command;
-		io = { ...io, env, childEnv: command.dir !== undefined ? { ...io.env, PI_SPACES_DIR: env.PI_SPACES_DIR } : undefined };
+		io = { ...io, env, childEnv: Object.keys(forChild).length > 0 ? { ...io.env, ...forChild } : undefined };
 	}
 	const commandSource = command.command !== undefined ? "--command" : "PI_SPACES_COMMAND";
+	const setupSource = command.setup !== undefined ? "--setup" : "PI_SPACES_SETUP";
 	const dir = spacesDir(io.env, io.home);
 	switch (command.kind) {
 		case "help":
@@ -291,7 +321,9 @@ export async function main(argv          , io       )                {
 		case "packages":
 			return runPackages(command.verb, command.target, command.args, dir, io, commandSource);
 		case "new":
-			return create(command.name, dir, io);
+			return create(command.name, dir, io, setupSource);
+		case "setup":
+			return runSetup(command.target, dir, io, setupSource);
 		case "rename":
 			return rename(command.from, command.to, dir, io);
 		case "remove":
@@ -303,10 +335,44 @@ export async function main(argv          , io       )                {
 	}
 }
 
-function create(name        , dir        , io       )       {
+/** Prints the reason and returns false when the setup command has an unclosed quote. */
+function checkSetup(io       , source        )          {
+	try {
+		splitCommand(io.env.PI_SPACES_SETUP ?? "");
+		return true;
+	} catch (error) {
+		io.stderr.write(`pi-space: ${source}: ${(error         ).message}.\n`);
+		return false;
+	}
+}
+
+/** Runs a setup command in a space, as that space's agent home, and returns its exit status. */
+function spawnSetup(setup                                     , name        , home        , io       )                  {
+	return spawnPi(setup.program, setup.args, io, { ...io.env, PI_CODING_AGENT_DIR: home, PI_SPACE: name, PI_SPACE_HOME: home });
+}
+
+/** The setup command for one space, from PI_SPACES_SETUP after the call options; checkSetup has accepted it. */
+function setupFor(name        , home        , io       )                                      {
+	return setupCommand(io.env.PI_SPACES_SETUP ?? "", home, name);
+}
+
+async function create(name        , dir        , io       , setupSource        )                {
+	const withSetup = hasSetupCommand(io.env);
+	// A bad setup command is reported before anything is created.
+	if (withSetup && !checkSetup(io, setupSource)) return io.exit(2);
 	try {
 		const path = createSpace(dir, name, newSpaceDeclaration(io.env, io.home));
-		io.stdout.write(`Created space "${name}" at ${path}.\nStart Pi in it with: pi-space ${name}\n`);
+		io.stdout.write(`Created space "${name}" at ${path}.\n`);
+		if (withSetup) {
+			const setup = setupFor(name, path, io);
+			io.stdout.write(`Setting it up: ${[setup.program, ...setup.args].join(" ")}\n`);
+			const status = await spawnSetup(setup, name, path, io);
+			if (status !== 0) {
+				io.stderr.write(`pi-space: Setup failed in space "${name}" (exit status ${status}); the space is kept. Run it again with: pi-space setup ${name}\n`);
+				return io.exit(status);
+			}
+		}
+		io.stdout.write(`Start Pi in it with: pi-space ${name}\n`);
 		return io.exit(0);
 	} catch (error) {
 		// A SpaceError is a rule (a bad or taken name); anything else is the filesystem, such as no permission.
@@ -423,10 +489,13 @@ function checkSpace(name        , dir        , io       )          {
 	return true;
 }
 
-/** Runs the command with Pi's `args` in a space and returns its exit status; 1, with the reason printed, when it cannot start. */
-async function spawnPi(program        , programArgs          , io       )                  {
+/**
+ * Runs a program with inherited stdio and returns its exit status; 1, with the reason printed, when it cannot start.
+ * `env` is the child's whole environment; undefined lets it inherit this process's. Pi gets io.childEnv.
+ */
+async function spawnPi(program        , programArgs          , io       , env                 )                  {
 	const options               = { stdio: "inherit" };
-	if (io.childEnv) options.env = io.childEnv;
+	if (env) options.env = env;
 	const result = await io.spawn(program, programArgs, options);
 	if (result.error) {
 		io.stderr.write(`pi-space: could not start ${program}: ${result.error.message}\n`);
@@ -444,7 +513,7 @@ async function launch(name        , args          , dir        , io       , comm
 		io.stderr.write(`pi-space: ${commandSource}: ${(error         ).message}.\n`);
 		return io.exit(2);
 	}
-	io.exit(await spawnPi(launched.program, launched.args, io));
+	io.exit(await spawnPi(launched.program, launched.args, io, io.childEnv));
 }
 
 /**
@@ -466,7 +535,7 @@ async function runPackages(verb             , target               , args
 			return io.exit(2);
 		}
 		if ("every" in target) io.stdout.write(`== ${name}\n`);
-		const status = await spawnPi(launched.program, launched.args, io);
+		const status = await spawnPi(launched.program, launched.args, io, io.childEnv);
 		if (!("every" in target)) return io.exit(status);
 		if (status !== 0) failed.push(name);
 	}
@@ -477,6 +546,43 @@ async function runPackages(verb             , target               , args
 	io.exit(0);
 }
 
+/**
+ * Runs the setup command in a space, or in every space with --every (never base), as `pi-space setup`.
+ * With --every each run gets a `== <name>` header, one failure does not stop the rest, and the status is 1 if any failed.
+ */
+async function runSetup(target               , dir        , io       , setupSource        )                {
+	if (!hasSetupCommand(io.env)) {
+		io.stderr.write("pi-space: There is no setup command; set PI_SPACES_SETUP or give --setup <cmd>.\n");
+		return io.exit(2);
+	}
+	if (!checkSetup(io, setupSource)) return io.exit(2);
+	if (!("every" in target)) {
+		if (target.name === BASE) {
+			io.stderr.write("pi-space: setup runs only in spaces, not in base (the home Pi starts with).\n");
+			return io.exit(1);
+		}
+		if (!checkSpace(target.name, dir, io)) return io.exit(1);
+		const home = join(dir, target.name);
+		return io.exit(await spawnSetup(setupFor(target.name, home, io), target.name, home, io));
+	}
+	const names = listSpaces(dir);
+	if (names.length === 0) {
+		io.stdout.write("No spaces yet. Create one with pi-space new <name>.\n");
+		return io.exit(0);
+	}
+	const failed           = [];
+	for (const name of names) {
+		io.stdout.write(`== ${name}\n`);
+		const home = join(dir, name);
+		if ((await spawnSetup(setupFor(name, home, io), name, home, io)) !== 0) failed.push(name);
+	}
+	if (failed.length > 0) {
+		io.stderr.write(`pi-space: setup failed in: ${failed.join(", ")}\n`);
+		return io.exit(1);
+	}
+	io.exit(0);
+}
+
 async function pick(dir        , io       , commandSource        )                {
 	if (!io.stdin.isTTY) {
 		io.stderr.write(USAGE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jals1212/pi-spaces-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "The pi-space command: pick a space and start Pi in it. Companion to the Pi extension @jals1212/pi-spaces.",
   "license": "MIT",
   "author": "jals1212",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "cross-spawn": "^7.0.6",
-    "@jals1212/pi-spaces": "^0.4.0"
+    "@jals1212/pi-spaces": "^0.5.0"
   },
   "publishConfig": {
     "access": "public",