@scrappycoco/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ScrappyCoco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# Scrappycoco CLI
+
+Discover, run, and compare scraper capabilities from a terminal or automation environment.
+
+The npm package must be published before using `npx`. Verify availability with
+`npm view @scrappycoco/cli version`, then run:
+
+```sh
+npx @scrappycoco/cli auth login
+npx @scrappycoco/cli scrapers list --available --json
+npx @scrappycoco/cli scrapers inspect web.extract_content --json
+npx @scrappycoco/cli scrapers run web.extract_content --file request.json --json
+npx @scrappycoco/cli scrapers compare web.extract_content --file request.json --json
+```
+
+From a repository checkout, use `npm ci`, `npm run build`, and
+`node dist/index.js <command>` instead.
+
+Use `providers list` to inspect routes and
+`discoveries create|list|get|update|run|delete` for saved multi-capability
+configurations. The CLI does not expose legacy assistant, agent, workflow, or
+schedule commands.
+
+Node.js 20 or newer is required. Interactive use authenticates with Clerk OAuth Authorization Code + PKCE. CI can set `SCRAPPYCOCO_API_KEY`.
+
+Use `--json` for machine-readable responses. Execution commands support
+`--format json|jsonl|csv` with `--output`, repeatable `--provider` flags, and an
+explicit `--idempotency-key` for safe identical retries.
+
+Use `scrappycoco --help` for the complete command reference. See the
+[Scrappycoco API documentation](https://scrappycoco.readme.io) for the public
+contract.

package/dist/index.js

@@ -0,0 +1,476 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { Command, CommanderError, Option } from "commander";
+
+// src/auth.ts
+import { createHash, randomBytes, timingSafeEqual } from "crypto";
+import { createServer } from "http";
+import open from "open";
+
+// src/errors.ts
+var EXIT = {
+  ok: 0,
+  usage: 2,
+  auth: 3,
+  api: 4,
+  billing: 5,
+  conflict: 6,
+  cancelled: 7,
+  timeout: 8
+};
+var CliError = class extends Error {
+  constructor(message, exitCode, details) {
+    super(message);
+    this.exitCode = exitCode;
+    this.details = details;
+  }
+  exitCode;
+  details;
+};
+
+// src/storage.ts
+import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { deletePassword, getPassword, setPassword } from "cross-keychain";
+var SERVICE = "scrappycoco-cli";
+var ACCOUNT = "refresh-token";
+function fallbackCredentialPath() {
+  const base = process.platform === "win32" ? process.env.APPDATA || join(homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "scrappycoco", "credentials.json");
+}
+async function readFallback() {
+  try {
+    const value = JSON.parse(await readFile(fallbackCredentialPath(), "utf8"));
+    return value.refresh_token || null;
+  } catch {
+    return null;
+  }
+}
+async function loadRefreshToken() {
+  try {
+    const value = await getPassword(SERVICE, ACCOUNT);
+    if (value) return value;
+  } catch {
+  }
+  return readFallback();
+}
+async function saveRefreshToken(refreshToken) {
+  try {
+    await setPassword(SERVICE, ACCOUNT, refreshToken);
+    return "keychain";
+  } catch {
+    const path = fallbackCredentialPath();
+    await mkdir(dirname(path), { recursive: true, mode: 448 });
+    await writeFile(path, JSON.stringify({ refresh_token: refreshToken }), { mode: 384 });
+    if (process.platform !== "win32") await chmod(path, 384);
+    return "file";
+  }
+}
+async function clearRefreshToken() {
+  try {
+    await deletePassword(SERVICE, ACCOUNT);
+  } catch {
+  }
+  await rm(fallbackCredentialPath(), { force: true });
+}
+
+// src/auth.ts
+async function oauthConfig(apiUrl) {
+  const clientId = process.env.SCRAPPYCOCO_OAUTH_CLIENT_ID;
+  if (clientId) {
+    return {
+      issuer: process.env.SCRAPPYCOCO_OAUTH_ISSUER || "https://clerk.scrappycoco.ai",
+      client_id: clientId,
+      scopes: ["openid", "profile", "email"]
+    };
+  }
+  const response = await fetch(`${apiUrl.replace(/\/$/, "")}/api/v1/oauth/cli-config`);
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || !payload.issuer || !payload.client_id || !Array.isArray(payload.scopes)) {
+    throw new CliError(payload.detail || "Scrappycoco CLI OAuth is not configured.", EXIT.auth);
+  }
+  return payload;
+}
+function base64url(value) {
+  return value.toString("base64url");
+}
+function createPkce() {
+  const verifier = base64url(randomBytes(48));
+  return {
+    verifier,
+    challenge: base64url(createHash("sha256").update(verifier).digest()),
+    state: base64url(randomBytes(24))
+  };
+}
+function statesMatch(expected, received) {
+  const left = Buffer.from(expected);
+  const right = Buffer.from(received);
+  return left.length === right.length && timingSafeEqual(left, right);
+}
+async function tokenRequest(issuer, body) {
+  const response = await fetch(`${issuer.replace(/\/$/, "")}/oauth/token`, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || typeof payload.access_token !== "string") {
+    throw new CliError(String(payload.error_description || payload.error || "OAuth token exchange failed."), EXIT.auth);
+  }
+  return payload;
+}
+async function login(options) {
+  const config = await oauthConfig(options.apiUrl);
+  const clientId = config.client_id;
+  const pkce = createPkce();
+  let timeout;
+  const callback = new Promise((resolve, reject) => {
+    const server = createServer((request, response) => {
+      const current = new URL(request.url || "/", "http://127.0.0.1");
+      if (current.pathname !== "/callback") {
+        response.writeHead(404).end("Not found");
+        return;
+      }
+      const state = current.searchParams.get("state") || "";
+      const code2 = current.searchParams.get("code") || "";
+      if (!statesMatch(pkce.state, state) || !code2) {
+        response.writeHead(400, { "content-type": "text/plain" }).end("Invalid OAuth callback. You may close this window.");
+        clearTimeout(timeout);
+        server.close();
+        reject(new CliError("OAuth state validation failed.", EXIT.auth));
+        return;
+      }
+      const address = server.address();
+      if (!address || typeof address === "string") return reject(new CliError("OAuth callback failed.", EXIT.auth));
+      response.writeHead(200, { "content-type": "text/plain" }).end("Scrappycoco login complete. You may close this window.");
+      clearTimeout(timeout);
+      server.close();
+      resolve({ code: code2, redirectUri: `http://127.0.0.1:${address.port}/callback` });
+    });
+    server.listen(0, "127.0.0.1", async () => {
+      const address = server.address();
+      if (!address || typeof address === "string") return reject(new CliError("Could not start OAuth callback.", EXIT.auth));
+      const redirectUri2 = `http://127.0.0.1:${address.port}/callback`;
+      const authorize = new URL(`${config.issuer.replace(/\/$/, "")}/oauth/authorize`);
+      authorize.search = new URLSearchParams({
+        client_id: clientId,
+        redirect_uri: redirectUri2,
+        response_type: "code",
+        scope: config.scopes.join(" "),
+        state: pkce.state,
+        code_challenge: pkce.challenge,
+        code_challenge_method: "S256"
+      }).toString();
+      process.stderr.write(`Open this URL to authenticate:
+${authorize.toString()}
+`);
+      if (!options.noBrowser) await open(authorize.toString());
+    });
+    timeout = setTimeout(() => {
+      server.close();
+      reject(new CliError("OAuth login timed out.", EXIT.timeout));
+    }, 5 * 6e4);
+  });
+  const { code, redirectUri } = await callback;
+  const tokens = await tokenRequest(config.issuer, new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientId,
+    code,
+    code_verifier: pkce.verifier,
+    redirect_uri: redirectUri
+  }));
+  if (!tokens.refresh_token) throw new CliError("OAuth response did not include a refresh token.", EXIT.auth);
+  return { storage: await saveRefreshToken(tokens.refresh_token) };
+}
+async function accessToken(apiUrl) {
+  const config = await oauthConfig(apiUrl);
+  const clientId = config.client_id;
+  const refreshToken = await loadRefreshToken();
+  if (!refreshToken) throw new CliError("Not logged in. Run `scrappycoco auth login`.", EXIT.auth);
+  const tokens = await tokenRequest(config.issuer, new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: clientId,
+    refresh_token: refreshToken
+  }));
+  if (tokens.refresh_token && tokens.refresh_token !== refreshToken) await saveRefreshToken(tokens.refresh_token);
+  return tokens.access_token;
+}
+
+// src/client.ts
+import { randomUUID } from "crypto";
+var DEFAULT_API_URL = process.env.SCRAPPYCOCO_API_URL || "https://api.scrappycoco.ai";
+var ApiClient = class {
+  constructor(baseUrl = DEFAULT_API_URL) {
+    this.baseUrl = baseUrl;
+  }
+  baseUrl;
+  async headers(extra = {}) {
+    const apiKey = process.env.SCRAPPYCOCO_API_KEY;
+    const authentication = apiKey ? { "X-API-Key": apiKey } : { Authorization: `Bearer ${await accessToken(this.baseUrl)}` };
+    return {
+      accept: "application/json",
+      "content-type": "application/json",
+      "X-Scrappycoco-Channel": "cli",
+      ...authentication,
+      ...extra
+    };
+  }
+  async request(method, path, body, headers) {
+    const response = await fetch(`${this.baseUrl.replace(/\/$/, "")}/api/v1${path}`, {
+      method,
+      headers: await this.headers(headers),
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (response.status === 204) return void 0;
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = typeof payload.detail === "string" ? payload.detail : `Scrappycoco API returned HTTP ${response.status}.`;
+      const exitCode = response.status === 401 || response.status === 403 ? EXIT.auth : response.status === 402 ? EXIT.billing : response.status === 409 ? EXIT.conflict : EXIT.api;
+      throw new CliError(message, exitCode, payload);
+    }
+    return payload;
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body, key = randomUUID()) {
+    return this.request("POST", path, body, { "Idempotency-Key": key });
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/input.ts
+import { readFile as readFile2 } from "fs/promises";
+async function readJsonFile(path) {
+  try {
+    const value = JSON.parse(await readFile2(path, "utf8"));
+    if (!value || Array.isArray(value) || typeof value !== "object") throw new Error("expected a JSON object");
+    return value;
+  } catch (error) {
+    throw new CliError(`Could not read request JSON from ${path}: ${error.message}`, EXIT.usage);
+  }
+}
+function parseJsonObject(value, label) {
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new Error("expected a JSON object");
+    return parsed;
+  } catch (error) {
+    throw new CliError(`Invalid ${label}: ${error.message}`, EXIT.usage);
+  }
+}
+
+// src/output.ts
+import { writeFile as writeFile2 } from "fs/promises";
+function csvEscape(value) {
+  const text = value === null || value === void 0 ? "" : typeof value === "object" ? JSON.stringify(value) : String(value);
+  return /[",\n\r]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function toCsv(records) {
+  const flattened = records.map((record) => {
+    const { data, ...topLevel } = record;
+    if (!data || typeof data !== "object" || Array.isArray(data)) return record;
+    const nested = Object.fromEntries(
+      Object.entries(data).filter(([key]) => !(key in topLevel))
+    );
+    return { ...topLevel, ...nested };
+  });
+  const headers = [...new Set(flattened.flatMap((record) => Object.keys(record)))];
+  return [
+    headers.join(","),
+    ...flattened.map((record) => headers.map((header) => csvEscape(record[header])).join(","))
+  ].join("\n") + "\n";
+}
+function formatRecords(records, format) {
+  if (format === "jsonl") {
+    return records.map((record) => JSON.stringify(record)).join("\n") + (records.length ? "\n" : "");
+  }
+  if (format === "csv") return toCsv(records);
+  return JSON.stringify(records, null, 2) + "\n";
+}
+async function emit(value, json, outputPath, raw) {
+  const rendered = raw ?? (json ? JSON.stringify(value) : JSON.stringify(value, null, 2)) + "\n";
+  if (outputPath) {
+    await writeFile2(outputPath, rendered, { encoding: "utf8", mode: 384 });
+    return;
+  }
+  process.stdout.write(rendered);
+}
+function errorPayload(error) {
+  return { error: error.message, details: error.details ?? null };
+}
+
+// src/index.ts
+var program = new Command();
+program.name("scrappycoco").description("Discover, run, and compare scraper capabilities through one API").version("0.1.0").option("--json", "emit machine-readable JSON to stdout").option("--api-url <url>", "API base URL", process.env.SCRAPPYCOCO_API_URL || "https://api.scrappycoco.ai").showHelpAfterError().exitOverride();
+function globals(command) {
+  return command.optsWithGlobals();
+}
+function client(command) {
+  return new ApiClient(globals(command).apiUrl);
+}
+function collect(value, previous) {
+  return [...previous, value];
+}
+function splitScraperId(value) {
+  const separator = value.indexOf(".");
+  if (separator <= 0 || separator === value.length - 1) {
+    throw new CliError("Scraper IDs use source.capability, for example web.extract_content.", EXIT.usage);
+  }
+  return { source: value.slice(0, separator), capability: value.slice(separator + 1) };
+}
+async function requestPayload(options, scraperId) {
+  const fromFile = options.file ? await readJsonFile(options.file) : {};
+  const { source, capability } = splitScraperId(scraperId);
+  const input = options.input ? parseJsonObject(options.input, "input JSON") : fromFile.input;
+  if (!input) throw new CliError("Provide input through --file or --input.", EXIT.usage);
+  return {
+    ...fromFile,
+    source,
+    capability,
+    input,
+    ...options.provider?.length ? { providers: options.provider } : {},
+    ...options.limit !== void 0 ? { limit: Number(options.limit) } : {}
+  };
+}
+async function emitExecution(response, options, command) {
+  const records = "records" in response && Array.isArray(response.records) ? response.records : response.items;
+  const jsonMode = globals(command).json || false;
+  if (options.output) {
+    await emit(response, jsonMode, options.output, formatRecords(records, options.format));
+    process.stderr.write(`Saved ${records.length} records to ${options.output}
+`);
+    return;
+  }
+  await emit(response, jsonMode);
+}
+var auth = program.command("auth").description("Manage Clerk OAuth credentials");
+auth.command("login").option("--no-browser", "print the authorization URL without opening it").action(async (options, command) => {
+  const result = await login({ noBrowser: options.browser === false, apiUrl: globals(command).apiUrl });
+  await emit({ authenticated: true, storage: result.storage }, globals(command).json || false);
+});
+auth.command("status").action(async (_options, command) => {
+  const usingApiKey = Boolean(process.env.SCRAPPYCOCO_API_KEY);
+  const stored = usingApiKey || Boolean(await loadRefreshToken());
+  if (!stored) {
+    await emit({ authenticated: false }, globals(command).json || false);
+    process.exitCode = EXIT.auth;
+    return;
+  }
+  const me = await client(command).get("/me");
+  await emit(
+    { authenticated: true, method: usingApiKey ? "api_key" : "oauth", account: me },
+    globals(command).json || false
+  );
+});
+auth.command("logout").action(async (_options, command) => {
+  await clearRefreshToken();
+  await emit({ authenticated: false }, globals(command).json || false);
+});
+var scrapers = program.command("scrapers").description("Inspect and execute scraper capabilities");
+scrapers.command("list").option("--source <source>", "filter by web, x, reddit, or filings").option("--provider <provider>", "filter by provider implementation").option("--available", "only include available providers").action(async (options, command) => {
+  const query = new URLSearchParams();
+  if (options.source) query.set("source", options.source);
+  if (options.provider) query.set("provider", options.provider);
+  if (options.available) query.set("available_only", "true");
+  const suffix = query.size ? `?${query}` : "";
+  await emit(await client(command).get(`/scrapers${suffix}`), globals(command).json || false);
+});
+scrapers.command("inspect <scraper-id>").action(async (scraperId, _options, command) => {
+  const { source, capability } = splitScraperId(scraperId);
+  await emit(
+    await client(command).get(
+      `/scrapers/${encodeURIComponent(source)}/${encodeURIComponent(capability)}`
+    ),
+    globals(command).json || false
+  );
+});
+function executionCommand(name) {
+  return scrapers.command(`${name} <scraper-id>`).description(name === "run" ? "Run one capability through a provider waterfall" : "Compare providers for one capability").option("-f, --file <path>", "canonical request JSON file").option("--input <json>", "capability input JSON").option("--provider <id>", "provider ID; repeat to choose and order providers", collect, []).option("--limit <number>", "maximum records").option("--idempotency-key <key>", "stable retry key").addOption(new Option("--format <format>", "output record format").choices(["json", "jsonl", "csv"]).default("json")).option("-o, --output <path>", "write records to a file").action(async (scraperId, options, command) => {
+    const payload = await requestPayload(options, scraperId);
+    if (payload.limit === void 0) payload.limit = 10;
+    const response = await client(command).post(
+      `/scrapers/${name === "run" ? "execute" : "compare"}`,
+      payload,
+      options.idempotencyKey || randomUUID2()
+    );
+    await emitExecution(response, options, command);
+  });
+}
+executionCommand("run");
+executionCommand("compare");
+var providers = program.command("providers").description("Inspect integrated scraper providers");
+providers.command("list").option("--available", "only include available provider-capability routes").action(async (options, command) => {
+  await emit(
+    await client(command).get(`/providers${options.available ? "?available_only=true" : ""}`),
+    globals(command).json || false
+  );
+});
+var discoveries = program.command("discoveries").description("Design and run saved multi-capability scraper configurations");
+discoveries.command("create").requiredOption("--goal <text>", "natural-language data goal").addOption(new Option("--priority <priority>", "comparison priority").choices(["balanced", "quality", "coverage", "cost", "speed"]).default("balanced")).action(async (options, command) => {
+  await emit(
+    await client(command).post("/discoveries", { goal: options.goal, priority: options.priority }),
+    globals(command).json || false
+  );
+});
+discoveries.command("list").action(async (_options, command) => {
+  await emit(await client(command).get("/discoveries"), globals(command).json || false);
+});
+discoveries.command("get <discovery-id>").action(async (discoveryId, _options, command) => {
+  await emit(
+    await client(command).get(`/discoveries/${encodeURIComponent(discoveryId)}`),
+    globals(command).json || false
+  );
+});
+discoveries.command("update <discovery-id>").option("-f, --file <path>", "update JSON containing name, priority, or configuration").option("--name <name>", "saved discovery name").option("--priority <priority>", "balanced, quality, coverage, cost, or speed").action(async (discoveryId, options, command) => {
+  const payload = options.file ? await readJsonFile(options.file) : {};
+  if (options.name) payload.name = options.name;
+  if (options.priority) payload.priority = options.priority;
+  if (!Object.keys(payload).length) throw new CliError("Provide --file, --name, or --priority.", EXIT.usage);
+  await emit(
+    await client(command).patch(`/discoveries/${encodeURIComponent(discoveryId)}`, payload),
+    globals(command).json || false
+  );
+});
+discoveries.command("run <discovery-id>").option("-f, --file <path>", "request JSON containing input and optional limit").option("--input <json>", "runtime parameter JSON").option("--limit <number>", "maximum records per route").option("--idempotency-key <key>", "stable retry key").addOption(new Option("--format <format>", "output record format").choices(["json", "jsonl", "csv"]).default("json")).option("-o, --output <path>", "write records to a file").action(async (discoveryId, options, command) => {
+  const fromFile = options.file ? await readJsonFile(options.file) : {};
+  const input = options.input ? parseJsonObject(options.input, "input JSON") : fromFile.input;
+  const payload = {
+    ...fromFile,
+    input: input || {},
+    limit: Number(options.limit ?? fromFile.limit ?? 25)
+  };
+  const response = await client(command).post(
+    `/discoveries/${encodeURIComponent(discoveryId)}/run`,
+    payload,
+    options.idempotencyKey || randomUUID2()
+  );
+  await emitExecution(response, options, command);
+});
+discoveries.command("delete <discovery-id>").requiredOption("--yes", "confirm permanent deletion").action(async (discoveryId, _options, command) => {
+  await client(command).delete(`/discoveries/${encodeURIComponent(discoveryId)}`);
+  await emit({ deleted: true, discovery_id: discoveryId }, globals(command).json || false);
+});
+program.configureOutput({ writeErr: (text) => process.stderr.write(text) });
+program.parseAsync(process.argv).catch(async (error) => {
+  if (error instanceof CommanderError) {
+    process.exitCode = error.exitCode === 0 ? EXIT.ok : EXIT.usage;
+    return;
+  }
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  const exitCode = normalized instanceof CliError ? normalized.exitCode : EXIT.api;
+  const json = Boolean(program.opts().json);
+  if (json) process.stdout.write(`${JSON.stringify(errorPayload(normalized))}
+`);
+  else process.stderr.write(`Error: ${normalized.message}
+`);
+  process.exitCode = exitCode;
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@scrappycoco/cli",
+  "version": "0.1.0",
+  "description": "CLI for Scrappycoco scraper discovery, execution, and provider comparison",
+  "type": "module",
+  "bin": {
+    "scrappycoco": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --platform node --target node20 --clean && node scripts/make-executable.mjs",
+    "test": "npm run build && vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^14.0.0",
+    "cross-keychain": "^1.1.0",
+    "open": "^10.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Albert-Tam/ai-scraper-project.git",
+    "directory": "cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}