@cimplify/cli 0.2.8 → 0.3.0

package/dist/{add-7PTWJV4F.mjs → add-ZJNXWN2B.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { REGISTRY_INDEX, REGISTRY } from './chunk-H2HJQGFY.mjs';
-import { promptYesNo } from './chunk-L6474RPL.mjs';
-import { parseArgs, flagString, flagBool } from './chunk-4SBJVRGM.mjs';
-import { CliError, CLI_ERROR_CODE, info, bold, dim, success, result, yellow } from './chunk-NZ4RG62Z.mjs';
+import { REGISTRY_INDEX, REGISTRY } from './chunk-MHK4WVNF.mjs';
+import { promptYesNo } from './chunk-RZQTHTXX.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-C4M3DXKC.mjs';
+import { CliError, CLI_ERROR_CODE, info, bold, dim, success, result, yellow } from './chunk-I3XQSSOT.mjs';
 import { mkdirSync, existsSync, writeFileSync } from 'fs';
 import { resolve, join, dirname } from 'path';
 
@@ -54,21 +54,21 @@ async function writeComponent(component, options) {
   }
   return outcome;
 }
-function resolveDependencyOrder(roots) {
+function resolveOrder(roots, getDeps) {
   const visited = /* @__PURE__ */ new Set();
   const order = [];
   function visit(name) {
     if (visited.has(name)) return;
     visited.add(name);
-    const component = loadComponent(name);
-    for (const dep of component.registryDependencies) {
-      visit(dep);
-    }
+    for (const dep of getDeps(name)) visit(dep);
     order.push(name);
   }
   for (const root of roots) visit(root);
   return order;
 }
+function resolveDependencyOrder(roots) {
+  return resolveOrder(roots, (name) => loadComponent(name).registryDependencies);
+}
 async function run(argv) {
   const args = parseArgs(argv);
   const dirFlag = flagString(args, "dir");
@@ -122,4 +122,4 @@ async function run(argv) {
   });
 }
 
-export { run as default };
+export { run as default, resolveOrder };

package/dist/assets-DMK2QOPD.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { parseArgs, flagString, flagBool } from './chunk-C4M3DXKC.mjs';
+import { ApiClient } from './chunk-D7WMSGKK.mjs';
+import { readAuth } from './chunk-LS2VTSMQ.mjs';
+import { CliError, CLI_ERROR_CODE, step, yellow, dim, success, info, result, bold, green } from './chunk-I3XQSSOT.mjs';
+import { createHash } from 'crypto';
+import { promises } from 'fs';
+import path from 'path';
+
+var MANIFEST_FILE = "cimplify-assets.json";
+var DEFAULT_FOLDER = "assets";
+var MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024;
+var CONTENT_TYPE_FALLBACK = "application/octet-stream";
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf"
+};
+function endpointInit(businessId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/assets/init`;
+}
+function endpointConfirm(businessId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/assets/confirm`;
+}
+function manifestPath(cwd = process.cwd()) {
+  return path.join(cwd, MANIFEST_FILE);
+}
+async function readManifest(cwd = process.cwd()) {
+  try {
+    const raw = await promises.readFile(manifestPath(cwd), "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeManifest(manifest, cwd = process.cwd()) {
+  const payload = `${JSON.stringify(manifest, null, 2)}
+`;
+  await promises.writeFile(manifestPath(cwd), payload, "utf8");
+}
+function mimeOf(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return MIME_BY_EXT[ext] ?? CONTENT_TYPE_FALLBACK;
+}
+function sha256Hex(buf) {
+  return createHash("sha256").update(buf).digest("hex");
+}
+async function walkFiles(root) {
+  const out = [];
+  async function visit(dir) {
+    const entries = await promises.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const abs = path.join(dir, e.name);
+      if (e.isDirectory()) await visit(abs);
+      else if (e.isFile()) out.push(abs);
+    }
+  }
+  await visit(root);
+  return out;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const sub = args.positional[0];
+  if (!sub) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "Usage: cimplify assets <upload|ls|rm>");
+  }
+  switch (sub) {
+    case "upload":
+      return runUpload(args);
+    case "ls":
+      return runLs(args);
+    case "rm":
+      return runRm(args);
+    default:
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        `Unknown subcommand "${sub}". Use upload, ls, or rm.`
+      );
+  }
+}
+async function runUpload(args) {
+  const dir = args.positional[1];
+  if (!dir) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "Usage: cimplify assets upload <dir> [--folder <path>]");
+  }
+  const folder = flagString(args, "folder") ?? DEFAULT_FOLDER;
+  const force = flagBool(args, "force");
+  const root = path.resolve(process.cwd(), dir);
+  const stat = await promises.stat(root).catch(() => null);
+  if (!stat?.isDirectory()) {
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `Directory not found: ${root}`);
+  }
+  const auth = await readAuth();
+  const client = ApiClient.fromAuth(auth);
+  const manifest = await readManifest();
+  const files = await walkFiles(root);
+  const uploaded = [];
+  const skipped = [];
+  for (const abs of files) {
+    const rel = path.relative(root, abs).replaceAll(path.sep, "/");
+    const filename = path.basename(rel);
+    const keyForManifest = `${folder}/${rel}`;
+    const contentType = mimeOf(filename);
+    const buf = await promises.readFile(abs);
+    if (buf.byteLength > MAX_FILE_SIZE_BYTES) {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        `${rel}: ${buf.byteLength} bytes exceeds 50 MB limit`
+      );
+    }
+    const hash = sha256Hex(buf);
+    const existing = manifest[keyForManifest];
+    if (existing && existing.sha256 === hash && !force) {
+      step(`${yellow("skip")} ${keyForManifest} ${dim("(unchanged)")}`);
+      skipped.push(keyForManifest);
+      continue;
+    }
+    const subfolder = path.posix.join(folder, path.posix.dirname(rel));
+    const init = await client.post(endpointInit(auth.businessId), {
+      folder: subfolder,
+      filename,
+      content_type: contentType,
+      size_bytes: buf.byteLength
+    });
+    step(`${dim("\u2192")}    ${keyForManifest} ${dim(`(${buf.byteLength} bytes)`)}`);
+    const putRes = await fetch(init.upload_url, {
+      method: "PUT",
+      headers: { "content-type": contentType },
+      body: buf
+    });
+    if (!putRes.ok) {
+      throw new CliError(
+        CLI_ERROR_CODE.NETWORK_ERROR,
+        `PUT to R2 failed for ${keyForManifest}: ${putRes.status} ${putRes.statusText}`
+      );
+    }
+    const confirmed = await client.post(endpointConfirm(auth.businessId), {
+      upload_id: init.upload_id
+    });
+    manifest[keyForManifest] = {
+      url: confirmed.url,
+      upload_id: init.upload_id,
+      folder: subfolder,
+      filename,
+      content_type: contentType,
+      size_bytes: buf.byteLength,
+      sha256: hash,
+      uploaded_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    uploaded.push(keyForManifest);
+  }
+  await writeManifest(manifest);
+  success(`Uploaded ${uploaded.length} file${uploaded.length === 1 ? "" : "s"} (${skipped.length} skipped)`);
+  info(dim(`Manifest: ${manifestPath()}`));
+  result({
+    uploaded_count: uploaded.length,
+    skipped_count: skipped.length,
+    manifest_path: manifestPath(),
+    uploaded,
+    skipped
+  });
+}
+async function runLs(args) {
+  const prefix = flagString(args, "prefix");
+  const manifest = await readManifest();
+  const entries = Object.entries(manifest).filter(([k]) => prefix ? k.startsWith(prefix) : true).sort(([a], [b]) => a.localeCompare(b));
+  if (entries.length === 0) {
+    info(dim("No assets uploaded yet."));
+  } else {
+    info(bold(`Assets in ${MANIFEST_FILE}:`));
+    for (const [key, entry] of entries) {
+      info(`  ${green("\u25CF")} ${key} ${dim(`\u2192 ${entry.url}`)}`);
+    }
+  }
+  result({
+    count: entries.length,
+    assets: entries.map(([key, entry]) => ({ key, ...entry }))
+  });
+}
+async function runRm(args) {
+  const key = args.positional[1];
+  if (!key) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "Usage: cimplify assets rm <key>");
+  }
+  const manifest = await readManifest();
+  if (!(key in manifest)) {
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `Key not found in manifest: ${key}`);
+  }
+  const removed = manifest[key];
+  delete manifest[key];
+  await writeManifest(manifest);
+  success(`Removed ${key} from manifest`);
+  info(dim("Note: remote blob is not deleted in v1 \u2014 only the manifest entry."));
+  result({ removed_key: key, removed_url: removed.url });
+}
+
+export { run as default, endpointConfirm, endpointInit, mimeOf, readManifest, sha256Hex, walkFiles, writeManifest };

package/dist/chunk-5IAYN7AJ.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import { gitDetectRoot, gitCurrentBranch, gitCurrentSha, gitStatusPorcelain } from './chunk-RRY3NEZZ.mjs';
+import { parseEnvFile } from './chunk-YI7UMMM7.mjs';
+import { package_default } from './chunk-YQVMG62Z.mjs';
+import { parseArgs } from './chunk-C4M3DXKC.mjs';
+import { readAuthOrNull, readProjectLinkOrNull, readProjectState } from './chunk-LS2VTSMQ.mjs';
+import { bold, dim, yellow, green, info, result, red } from './chunk-I3XQSSOT.mjs';
+import { promises } from 'fs';
+import path from 'path';
+
+var CLI_VERSION = package_default.version ?? "unknown";
+var SHA_DISPLAY_LEN = 7;
+var BRAND_FILE_CANDIDATES = ["lib/brand.ts", "src/lib/brand.ts"];
+var GLOBALS_CSS_CANDIDATES = ["app/globals.css", "src/app/globals.css"];
+var NEXT_CONFIG_CANDIDATES = ["next.config.ts", "next.config.mjs", "next.config.js"];
+var ENV_FILE_CANDIDATES = [".env.local", ".env.example", ".env.production"];
+async function readTextOrNull(filePath) {
+  try {
+    return await promises.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function findFirstExisting(cwd, candidates) {
+  for (const rel of candidates) {
+    const abs = path.join(cwd, rel);
+    const content = await readTextOrNull(abs);
+    if (content !== null) return { rel, abs, content };
+  }
+  return null;
+}
+async function gatherAuth() {
+  const auth = await readAuthOrNull();
+  if (!auth) {
+    return { logged_in: false, account_id: null, business_id: null, email: null, api_base_url: null };
+  }
+  return {
+    logged_in: true,
+    account_id: auth.accountId,
+    business_id: auth.businessId,
+    email: auth.email ?? null,
+    api_base_url: auth.apiBaseUrl
+  };
+}
+async function gatherProject(cwd) {
+  const link = await readProjectLinkOrNull(cwd);
+  if (!link) {
+    return {
+      linked: false,
+      id: null,
+      remote_url: null,
+      default_branch: null,
+      framework: null,
+      last_deployment: null
+    };
+  }
+  const state = await readProjectState(cwd);
+  return {
+    linked: true,
+    id: link.projectId,
+    remote_url: link.remoteUrl ?? null,
+    default_branch: link.defaultBranch ?? null,
+    framework: link.framework ?? null,
+    last_deployment: state?.lastDeploymentId ? {
+      id: state.lastDeploymentId,
+      sha: state.lastDeploymentSha ?? null,
+      environment: state.lastDeploymentEnv ?? null,
+      at: state.lastDeploymentAt ?? null
+    } : null
+  };
+}
+async function gatherPackage(cwd) {
+  const raw = await readTextOrNull(path.join(cwd, "package.json"));
+  if (!raw) return { found: false, name: null, sdk_pin: null, scripts: [] };
+  try {
+    const json = JSON.parse(raw);
+    const sdkPin = json.dependencies?.["@cimplify/sdk"] ?? json.devDependencies?.["@cimplify/sdk"] ?? null;
+    return {
+      found: true,
+      name: json.name ?? null,
+      sdk_pin: sdkPin,
+      scripts: json.scripts ? Object.keys(json.scripts) : []
+    };
+  } catch {
+    return { found: true, name: null, sdk_pin: null, scripts: [] };
+  }
+}
+var BRAND_NAME_RE = /\bname:\s*"([^"]+)"/;
+var BRAND_SCHEMA_TYPE_RE = /\bschemaType:\s*"([^"]+)"/;
+async function gatherBrand(cwd) {
+  const hit = await findFirstExisting(cwd, BRAND_FILE_CANDIDATES);
+  if (!hit) return { found: false, path: null, name: null, schema_type: null };
+  return {
+    found: true,
+    path: hit.rel,
+    name: BRAND_NAME_RE.exec(hit.content)?.[1] ?? null,
+    schema_type: BRAND_SCHEMA_TYPE_RE.exec(hit.content)?.[1] ?? null
+  };
+}
+async function gatherTheme(cwd) {
+  const hit = await findFirstExisting(cwd, GLOBALS_CSS_CANDIDATES);
+  if (!hit) return { globals_css_path: null, has_theme_block: false };
+  return {
+    globals_css_path: hit.rel,
+    has_theme_block: /@theme\b/.test(hit.content)
+  };
+}
+var NEXT_CACHE_COMPONENTS_RE = /\bcacheComponents:\s*(true|false)\b/;
+async function gatherNextConfig(cwd) {
+  const hit = await findFirstExisting(cwd, NEXT_CONFIG_CANDIDATES);
+  if (!hit) return { path: null, cache_components: null };
+  const match = NEXT_CACHE_COMPONENTS_RE.exec(hit.content);
+  return {
+    path: hit.rel,
+    cache_components: match ? match[1] === "true" : null
+  };
+}
+var MOCK_SEED_RE = /cimplify-mock[^"]*?--seed\s+([a-z0-9-]+)/;
+function extractMockSeed(pkgJsonText) {
+  return MOCK_SEED_RE.exec(pkgJsonText)?.[1] ?? null;
+}
+async function gatherMock(cwd) {
+  const raw = await readTextOrNull(path.join(cwd, "package.json"));
+  if (!raw) return { seed: null };
+  return { seed: extractMockSeed(raw) };
+}
+async function gatherEnvFiles(cwd) {
+  const out = [];
+  for (const file of ENV_FILE_CANDIDATES) {
+    const text = await readTextOrNull(path.join(cwd, file));
+    if (text === null) continue;
+    out.push({ file, keys: parseEnvFile(text).map((e) => e.key) });
+  }
+  return out;
+}
+async function gatherGit(cwd) {
+  const root = await gitDetectRoot(cwd);
+  if (!root) return null;
+  const [branch, sha, porcelain] = await Promise.all([
+    gitCurrentBranch(root).catch(() => ""),
+    gitCurrentSha(root).catch(() => ""),
+    gitStatusPorcelain(root).catch(() => "")
+  ]);
+  return {
+    branch: branch || null,
+    sha: sha || null,
+    dirty: porcelain.trim().length > 0
+  };
+}
+async function gatherIntrospection(cwd = process.cwd()) {
+  const [auth, project, pkg, brand, theme, nextConfig, mock, envFiles, git] = await Promise.all([
+    gatherAuth(),
+    gatherProject(cwd),
+    gatherPackage(cwd),
+    gatherBrand(cwd),
+    gatherTheme(cwd),
+    gatherNextConfig(cwd),
+    gatherMock(cwd),
+    gatherEnvFiles(cwd),
+    gatherGit(cwd)
+  ]);
+  return {
+    cwd,
+    cli: { version: CLI_VERSION },
+    auth,
+    project,
+    package: pkg,
+    brand,
+    theme,
+    next_config: nextConfig,
+    mock,
+    env_files: envFiles,
+    git
+  };
+}
+var LABEL_WIDTH = 12;
+function label(name) {
+  return bold(name.padEnd(LABEL_WIDTH));
+}
+function check(ok) {
+  return ok ? green("\u2713") : red("\u2717");
+}
+function renderIntrospection(snapshot) {
+  const out = [];
+  out.push(bold("Cimplify"));
+  out.push("");
+  out.push(`  ${label("CLI")}${snapshot.cli.version}`);
+  const a = snapshot.auth;
+  if (a.logged_in) {
+    const who = a.email ?? a.account_id ?? "unknown";
+    out.push(`  ${label("Auth")}${check(true)} ${who} ${dim(`(${a.business_id ?? "?"})`)}`);
+  } else {
+    out.push(`  ${label("Auth")}${check(false)} not logged in ${dim("(cimplify login)")}`);
+  }
+  const p = snapshot.project;
+  if (p.linked) {
+    out.push(`  ${label("Project")}${check(true)} ${p.id}`);
+    if (p.last_deployment) {
+      const d = p.last_deployment;
+      const shortSha = d.sha ? d.sha.slice(0, SHA_DISPLAY_LEN) : "?";
+      out.push(`  ${" ".repeat(LABEL_WIDTH)}last deploy: ${d.environment ?? "?"} \xB7 ${shortSha} \xB7 ${d.id}`);
+    }
+  } else {
+    out.push(`  ${label("Project")}${check(false)} not linked ${dim("(cimplify link <id>)")}`);
+  }
+  const pkg = snapshot.package;
+  if (pkg.found) {
+    const bits = [pkg.name ?? "?", `@cimplify/sdk ${pkg.sdk_pin ?? "(missing)"}`];
+    out.push(`  ${label("Package")}${bits.join(" \xB7 ")}`);
+    if (pkg.scripts.length > 0) {
+      out.push(`  ${" ".repeat(LABEL_WIDTH)}${dim(`scripts: ${pkg.scripts.join(", ")}`)}`);
+    }
+  } else {
+    out.push(`  ${label("Package")}${dim("no package.json in this directory")}`);
+  }
+  const b = snapshot.brand;
+  if (b.found) {
+    const name = b.name ?? "(no name found)";
+    const tag = b.schema_type ? ` ${dim(`(${b.schema_type})`)}` : "";
+    out.push(`  ${label("Brand")}${check(true)} ${name}${tag} ${dim(b.path ?? "")}`);
+  } else {
+    out.push(`  ${label("Brand")}${dim("no lib/brand.ts")}`);
+  }
+  const t = snapshot.theme;
+  if (t.globals_css_path) {
+    out.push(
+      `  ${label("Theme")}${check(t.has_theme_block)} ${t.globals_css_path}${t.has_theme_block ? "" : dim(" (no @theme block)")}`
+    );
+  }
+  const nc = snapshot.next_config;
+  if (nc.path) {
+    const flag = nc.cache_components;
+    const sigil = flag === true ? check(true) : flag === false ? yellow("!") : dim("?");
+    const note = flag === true ? "cacheComponents: true" : flag === false ? "cacheComponents: false" : "cacheComponents not set";
+    out.push(`  ${label("Next")}${sigil} ${note} ${dim(nc.path)}`);
+  }
+  if (snapshot.mock.seed) {
+    out.push(`  ${label("Mock")}seed: ${snapshot.mock.seed}`);
+  }
+  if (snapshot.env_files.length > 0) {
+    const summary = snapshot.env_files.map((e) => `${e.file}: ${e.keys.length} key${e.keys.length === 1 ? "" : "s"}`).join(" \xB7 ");
+    out.push(`  ${label("Env")}${summary}`);
+  }
+  if (snapshot.git) {
+    const g = snapshot.git;
+    const dirty = g.dirty ? yellow("dirty") : green("clean");
+    out.push(`  ${label("Git")}${g.branch ?? "(no branch)"} \xB7 ${dirty}`);
+  }
+  return out;
+}
+async function run(argv) {
+  parseArgs(argv);
+  const snapshot = await gatherIntrospection();
+  for (const line of renderIntrospection(snapshot)) info(line);
+  result(snapshot);
+}
+
+export { extractMockSeed, gatherIntrospection, renderIntrospection, run };

package/dist/{chunk-4SBJVRGM.mjs → chunk-C4M3DXKC.mjs}

@@ -32,7 +32,9 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   // Dev / login / logs
   "remote",
   "no-browser",
-  "follow"
+  "follow",
+  // Doctor
+  "offline"
 ]);
 function parseArgs(argv) {
   const positional = [];

package/dist/{chunk-NC3GKHDD.mjs → chunk-D7WMSGKK.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { CliError, CLI_ERROR_CODE } from './chunk-NZ4RG62Z.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-I3XQSSOT.mjs';
 
 // src/api-client.ts
 var DEFAULT_API_BASE_URL = "https://api.cimplify.io";

package/dist/{chunk-NZ4RG62Z.mjs → chunk-I3XQSSOT.mjs}

@@ -65,6 +65,9 @@ var CliError = class extends Error {
     this.remediation = options.remediation;
   }
 };
+function isCliError(err) {
+  return err instanceof CliError || typeof err === "object" && err !== null && err.name === "CliError" && typeof err.code === "string" && typeof err.exitCode === "number";
+}
 
 // src/output.ts
 var RESET = "\x1B[0m";
@@ -138,4 +141,4 @@ function result(data) {
 `);
 }
 
-export { CLI_ERROR_CODE, CliError, EXIT_CODE, bold, dim, failure, green, info, isAutoYes, isInteractive, isJsonMode, red, result, step, success, yellow };
+export { CLI_ERROR_CODE, CliError, EXIT_CODE, bold, dim, failure, green, info, isAutoYes, isCliError, isInteractive, isJsonMode, red, result, step, success, yellow };

package/dist/{chunk-JJYWETGA.mjs → chunk-LS2VTSMQ.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { CliError, CLI_ERROR_CODE } from './chunk-NZ4RG62Z.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-I3XQSSOT.mjs';
 import { promises } from 'fs';
 import os from 'os';
 import path from 'path';
@@ -61,6 +61,9 @@ async function readAuth() {
   }
   return data;
 }
+async function readAuthOrNull() {
+  return readJsonFile(authConfigPath());
+}
 async function writeAuth(creds) {
   await writeJsonFile(authConfigPath(), creds, FILE_MODE_PRIVATE);
 }
@@ -83,6 +86,9 @@ async function readProjectLink(cwd = process.cwd()) {
   }
   return data;
 }
+async function readProjectLinkOrNull(cwd = process.cwd()) {
+  return readJsonFile(projectConfigPath(cwd));
+}
 async function writeProjectLink(link, cwd = process.cwd()) {
   await writeJsonFile(projectConfigPath(cwd), link);
   await ensureStateGitignored(cwd);
@@ -124,4 +130,4 @@ ${STATE_GITIGNORE_LINE}
   await promises.writeFile(gitignore, next, ENCODING_UTF8);
 }
 
-export { clearAuth, clearProjectLink, readAuth, readProjectLink, readProjectState, writeAuth, writeProjectLink, writeProjectState };
+export { clearAuth, clearProjectLink, readAuth, readAuthOrNull, readProjectLink, readProjectLinkOrNull, readProjectState, writeAuth, writeProjectLink, writeProjectState };