fangcun 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# fangcun
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Command-line client for [Fangcun](https://github.com/tinyacre/Fangcun), a
+self-hostable credit-card manager with end-to-end field encryption.
+
+## Install
+
+```sh
+npx fangcun@latest --help
+# or
+npm install -g fangcun
+fangcun --help
+```
+
+This package is a thin launcher (see [`bin/fangcun.js`](bin/fangcun.js)):
+the real work is done by a native `fangcun` binary published per-platform
+as an `optionalDependency` (`@tinyacre/fangcun-<os>-<arch>`). If npm skipped
+that dependency (`--no-optional`, a mirrored registry, an unsupported
+platform), the launcher downloads and checksum-verifies the matching release
+asset from GitHub Releases on first use instead.
+
+Override the binary directly with `FANGCUN_CLI_BINARY=/path/to/fangcun`.
+
+## Usage
+
+```sh
+fangcun auth login --server https://vault.example   # approve the code at <server>/device
+fangcun cards list
+fangcun cards get <id> --reveal
+fangcun --json cards list | jq .
+```
+
+See `docs/openapi.yaml` in the main repository for the full API surface the
+`--json` output mirrors, and the `fangcun-cli` agent skill for a worked
+example per command group.
+
+## Notes
+
+- Sealed Fields (card number, CVV, expiry, notes) are end-to-end encrypted;
+  the CLI shows Masked Output by default and needs `--reveal` (and an
+  Unlocked client — `fangcun auth login --store-dek`, or `FANGCUN_DEK`)
+  to show clear values.
+- `fangcun auth token` management (list/revoke) is available from the
+  CLI. Tokens are minted only in the Web App: `fangcun auth login` gets
+  one for this machine when you approve its code at `<server>/device`.

package/bin/fangcun.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+const { spawnSync } = require('node:child_process');
+
+const { runCLI } = require('../lib/launch.js');
+const { binaryFileName } = require('../lib/platforms.js');
+const { downloadAndVerify } = require('../lib/download.js');
+const pkg = require('../package.json');
+
+// install.js caches a download at <package root>/.bin-cache/<version>/<binary>.
+const cacheDir = path.join(
+  __dirname,
+  '..',
+  '.bin-cache',
+  pkg.version,
+  binaryFileName(process.platform),
+);
+
+// A dev/workspace checkout (version 0.0.0) has no matching GitHub release to
+// fetch — skip the lazy retry entirely and go straight to the actionable
+// failure if nothing else resolved.
+const download =
+  pkg.version && pkg.version !== '0.0.0'
+    ? ({ destDir, destBinary }) =>
+        downloadAndVerify({
+          version: pkg.version,
+          platform: process.platform,
+          arch: process.arch,
+          destDir,
+          destBinary,
+        })
+    : undefined;
+
+runCLI({
+  argv: process.argv.slice(2),
+  env: process.env,
+  platform: process.platform,
+  arch: process.arch,
+  requireResolve: require.resolve,
+  existsSync: fs.existsSync,
+  cacheDir,
+  download,
+  spawnSync,
+  stderr: process.stderr,
+  exit: (code) => process.exit(code),
+}).catch((err) => {
+  process.stderr.write(`fangcun: unexpected launcher error: ${err && err.stack ? err.stack : err}\n`);
+  process.exit(1);
+});

package/install.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+'use strict';
+
+// postinstall fallback download (design §7, resolution step 3).
+//
+// Runs only when the matching @tinyacre/fangcun-<os>-<arch> optionalDependency
+// failed to install — e.g. `--no-optional`, a mirrored registry that dropped
+// scoped packages, or a platform/arch this release doesn't publish yet. It
+// downloads the matching release archive from GitHub Releases and verifies
+// it against that release's checksums.txt (goreleaser's `checksum` block).
+//
+// MUST NOT fail `npm install`: every error path logs to stderr and exits 0
+// (design §7: "install.js must be failure-tolerant"). If this step doesn't
+// leave a usable cache, the launcher (bin/fangcun.js) retries the same
+// download lazily on first invocation — see lib/resolve.js step 3 — so a
+// postinstall hiccup never bricks the CLI, only delays first use.
+
+const path = require('node:path');
+const fs = require('node:fs');
+
+const { platformPackageName, binaryFileName } = require('./lib/platforms.js');
+const { downloadAndVerify } = require('./lib/download.js');
+const pkg = require('./package.json');
+
+function log(msg) {
+  process.stderr.write(`fangcun install: ${msg}\n`);
+}
+
+function haveOptionalDependency() {
+  try {
+    require.resolve(
+      `${platformPackageName(process.platform, process.arch)}/bin/${binaryFileName(process.platform)}`,
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  if (haveOptionalDependency()) {
+    return; // the launcher's step 2 will find it; nothing to do here
+  }
+
+  const version = pkg.version;
+  if (!version || version === '0.0.0') {
+    log('skipping fallback download: package version is 0.0.0 (dev/workspace checkout)');
+    return;
+  }
+
+  const destDir = path.join(__dirname, '.bin-cache', version);
+  const destBinary = path.join(destDir, binaryFileName(process.platform));
+  if (fs.existsSync(destBinary)) {
+    return;
+  }
+
+  try {
+    await downloadAndVerify({
+      version,
+      platform: process.platform,
+      arch: process.arch,
+      destDir,
+      destBinary,
+    });
+    log(`downloaded fangcun ${version} for ${process.platform}/${process.arch}`);
+  } catch (err) {
+    log(
+      `could not fetch a prebuilt binary for ${process.platform}/${process.arch} (${err.message}). ` +
+        'This is not fatal: install the matching @tinyacre/fangcun-* package manually, set ' +
+        'FANGCUN_CLI_BINARY to point at a fangcun binary, or just run `fangcun` — it ' +
+        'retries this download on first use.',
+    );
+  }
+}
+
+main().then(
+  () => process.exit(0),
+  (err) => {
+    log(`unexpected error, continuing anyway: ${err && err.stack ? err.stack : err}`);
+    process.exit(0);
+  },
+);

package/lib/download.js

@@ -0,0 +1,201 @@
+'use strict';
+
+// Shared download+verify+extract logic used by both install.js (the
+// postinstall fallback) and the launcher's lazy retry (resolve.js step 3,
+// design §7: "step 3 retries lazily"). Kept in one place so the two call
+// sites can never drift on the checksum/extraction contract.
+
+const path = require('node:path');
+const fs = require('node:fs');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const https = require('node:https');
+const { execFileSync } = require('node:child_process');
+
+const { archiveName, archiveNameForNpm } = require('./platforms.js');
+
+const REPO = 'tinyacre/Fangcun';
+const MAX_REDIRECTS = 5;
+
+function releaseTag(version) {
+  return `v${version}`;
+}
+
+function assetURL(tag, name) {
+  return `https://github.com/${REPO}/releases/download/${tag}/${name}`;
+}
+
+// fetchBuffer follows redirects manually (GitHub release assets 302 to a
+// CDN) and rejects non-2xx statuses, with no dependency on a redirect-
+// following HTTP client library.
+function fetchBuffer(url, redirectsLeft = MAX_REDIRECTS) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, { headers: { 'User-Agent': 'fangcun-install.js' } }, (res) => {
+        const { statusCode, headers } = res;
+        if (statusCode >= 300 && statusCode < 400 && headers.location) {
+          res.resume();
+          if (redirectsLeft <= 0) {
+            reject(new Error(`too many redirects fetching ${url}`));
+            return;
+          }
+          resolve(fetchBuffer(headers.location, redirectsLeft - 1));
+          return;
+        }
+        if (statusCode !== 200) {
+          res.resume();
+          reject(new Error(`GET ${url} -> HTTP ${statusCode}`));
+          return;
+        }
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => resolve(Buffer.concat(chunks)));
+        res.on('error', reject);
+      })
+      .on('error', reject);
+  });
+}
+
+function sha256Hex(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+// parseChecksums turns goreleaser's checksums.txt ("<hex>  <filename>" per
+// line) into a Map.
+//
+// L-9: checksums.txt itself is unsigned, fetched from the same GitHub
+// Releases origin as the archive it covers, so this only ever proves the
+// archive bytes match what the release lists — not who published the
+// release. That's a deliberate scope limit, not an oversight: verification
+// here is fail-closed (any mismatch throws) and correct for what it
+// promises (transport/CDN integrity), it just doesn't extend trust beyond
+// "GitHub Releases for this repo". Signing checksums.txt with an Ed25519
+// release key would close that gap (see review L-9).
+function parseChecksums(text) {
+  const map = new Map();
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const [hex, ...rest] = trimmed.split(/\s+/);
+    const name = rest.join(' ');
+    if (hex && name) map.set(name, hex.toLowerCase());
+  }
+  return map;
+}
+
+// writeArchiveToTempFile stages an already-downloaded (and, by the time
+// this is called, checksum-verified) archive buffer under a private,
+// randomly named temp directory (`fs.mkdtempSync`, always created mode
+// 0700 regardless of umask) rather than a predictable path directly in the
+// shared system tmpdir.
+//
+// M-5: a predictable path (the old code used
+// `fangcun-${pid}-${Date.now()}-${name}` in os.tmpdir() directly) is
+// guessable ahead of time on a multi-user or CI host; a symlink pre-planted
+// at that exact name would redirect writeFileSync's write to an arbitrary
+// file the attacker chose. mkdtempSync's directory name is unpredictable
+// and only this process can write inside it.
+//
+// Caller must remove the returned tmpRoot when done.
+function writeArchiveToTempFile(buffer, name) {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'fangcun-'));
+  const archivePath = path.join(tmpRoot, name);
+  fs.writeFileSync(archivePath, buffer);
+  return { tmpRoot, archivePath };
+}
+
+// installArchive extracts `archivePath` into destDir atomically: extraction
+// happens in a private per-process staging directory
+// (`${destDir}.tmp-<pid>`), the binary is verified and chmod'd *there*, and
+// only then published into destDir with a single renameSync.
+//
+// M-4: the old code ran `tar -xf ... -C destDir` directly against the final
+// destination and chmod'd after extraction, while resolve.js's cache check
+// is a bare `existsSync(destBinary)`. Two concurrent `fangcun` invocations
+// (or one interrupted mid-extract) could make a second invocation see the
+// binary exist before extraction finished, or before the chmod ran, and
+// spawn a truncated file or hit EACCES. Because nothing but the final
+// rename ever touches destDir itself, an interrupted or concurrent run can
+// only ever leave behind an abandoned staging directory — destDir is either
+// absent or a fully-formed, already-chmod'd install.
+function installArchive({ archivePath, destDir, destBinary, platform }) {
+  fs.mkdirSync(path.dirname(destDir), { recursive: true });
+
+  const stagingDir = `${destDir}.tmp-${process.pid}`;
+  fs.rmSync(stagingDir, { recursive: true, force: true });
+  fs.mkdirSync(stagingDir, { recursive: true });
+
+  try {
+    // Both tar.gz (darwin/linux) and zip (windows) extract via `tar`:
+    // Windows has shipped bsdtar since build 17063 (Win10 1803+), and
+    // libarchive auto-detects zip. This avoids an extra npm dependency
+    // just for archive extraction.
+    execFileSync('tar', ['-xf', archivePath, '-C', stagingDir], { stdio: 'pipe' });
+
+    const stagedBinary = path.join(stagingDir, path.basename(destBinary));
+    if (!fs.existsSync(stagedBinary)) {
+      throw new Error(`archive did not contain ${path.basename(destBinary)}`);
+    }
+    if (platform !== 'win32') {
+      fs.chmodSync(stagedBinary, 0o755);
+    }
+
+    try {
+      fs.renameSync(stagingDir, destDir);
+    } catch (err) {
+      // A concurrent invocation may have already published destDir first
+      // (same version + platform, two processes racing the same install) —
+      // that is success for this call too, not a failure.
+      if (!fs.existsSync(destBinary)) {
+        throw err;
+      }
+    }
+  } finally {
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+  }
+
+  if (!fs.existsSync(destBinary)) {
+    throw new Error(`archive did not contain ${path.basename(destBinary)}`);
+  }
+}
+
+// downloadAndVerify fetches the release archive for `version`/platform/arch,
+// verifies it against that release's checksums.txt, extracts it into
+// destDir, and leaves the binary at destBinary. Throws on any failure —
+// callers decide whether that's fatal; it never is for install.js or the
+// launcher (design §7: "install.js must be failure-tolerant").
+async function downloadAndVerify({ version, platform, arch, destDir, destBinary }) {
+  const tag = releaseTag(version);
+  const name = archiveNameForNpm(platform, arch);
+
+  const checksums = parseChecksums(
+    (await fetchBuffer(assetURL(tag, 'checksums.txt'))).toString('utf8'),
+  );
+  const want = checksums.get(name);
+  if (!want) {
+    throw new Error(`${name} not listed in checksums.txt for ${tag}`);
+  }
+
+  const archive = await fetchBuffer(assetURL(tag, name));
+  const got = sha256Hex(archive);
+  if (got !== want) {
+    throw new Error(`checksum mismatch for ${name}: want ${want}, got ${got}`);
+  }
+
+  const { tmpRoot, archivePath } = writeArchiveToTempFile(archive, name);
+  try {
+    installArchive({ archivePath, destDir, destBinary, platform });
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+}
+
+module.exports = {
+  downloadAndVerify,
+  archiveName,
+  assetURL,
+  parseChecksums,
+  sha256Hex,
+  installArchive,
+  writeArchiveToTempFile,
+};

package/lib/launch.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const os = require('node:os');
+
+const { resolveBinary } = require('./resolve.js');
+
+// runCLI wires resolution + spawn + exit into one testable async function.
+// Every effectful dependency is injected: bin/fangcun.js supplies the
+// real ones, tests supply fakes.
+//
+// Contract asserted by tests: the child process always inherits stdio
+// (interactive prompts, TTY detection and streaming output must work
+// exactly as if `fangcun` were invoked directly) and windowsHide is set;
+// the launcher's own exit code always mirrors the child's.
+async function runCLI({
+  argv,
+  env,
+  platform,
+  arch,
+  requireResolve,
+  existsSync,
+  cacheDir,
+  download,
+  spawnSync,
+  stderr,
+  exit,
+}) {
+  const result = await resolveBinary({
+    env,
+    platform,
+    arch,
+    requireResolve,
+    existsSync,
+    cacheDir,
+    download,
+  });
+
+  if (!result.binary) {
+    stderr.write(result.error + '\n');
+    exit(1);
+    return;
+  }
+
+  const child = spawnSync(result.binary, argv, {
+    stdio: 'inherit',
+    windowsHide: true,
+  });
+
+  if (child.error) {
+    stderr.write(`fangcun: failed to run ${result.binary}: ${child.error.message}\n`);
+    exit(1);
+    return;
+  }
+
+  if (child.signal) {
+    // Killed by a signal (e.g. SIGINT/SIGTERM forwarded from the parent
+    // terminal) rather than exiting normally — there is no numeric status.
+    // Mirror the standard POSIX/shell convention (128 + signal number) so
+    // scripts piping this exit code can tell a signal kill apart from an
+    // ordinary CLI error exit (L-4); fall back to 1 for a signal name Node
+    // doesn't have a number for on this platform.
+    stderr.write(`fangcun: terminated by signal ${child.signal}\n`);
+    const signum = os.constants.signals[child.signal];
+    exit(typeof signum === 'number' ? 128 + signum : 1);
+    return;
+  }
+
+  exit(child.status === null ? 1 : child.status);
+}
+
+module.exports = { runCLI };

package/lib/platforms.js

@@ -0,0 +1,77 @@
+'use strict';
+
+// Single source of truth for the npm platform/arch <-> Go GOOS/GOARCH <->
+// release-archive-name mapping. Every consumer — the launcher's binary
+// resolution (bin/fangcun.js, resolve.js), the postinstall/lazy download
+// (install.js, download.js), and the release packaging script
+// (npm/scripts/build-packages.mjs) — must go through this module so the
+// mapping can never drift between copies again.
+//
+// H-2: download.js used to build archive names from Node's own
+// process.platform/process.arch strings ("linux", "x64", ...) instead of
+// GOOS/GOARCH ("linux", "amd64", ...), which broke the fallback download on
+// 4 of the 6 published platforms (only darwin/arm64 and linux/arm64
+// happened to coincide) while build-packages.mjs's independent copy of the
+// same function stayed correct — nothing caught the two drifting apart.
+
+// The six published targets: Node's process.platform/process.arch
+// vocabulary paired with the GOOS/GOARCH pair goreleaser used to build and
+// name the archive. build-packages.mjs iterates this same list to stage the
+// six platform packages.
+const PLATFORMS = [
+  { npmOs: 'darwin', npmArch: 'arm64', goos: 'darwin', goarch: 'arm64' },
+  { npmOs: 'darwin', npmArch: 'x64', goos: 'darwin', goarch: 'amd64' },
+  { npmOs: 'linux', npmArch: 'x64', goos: 'linux', goarch: 'amd64' },
+  { npmOs: 'linux', npmArch: 'arm64', goos: 'linux', goarch: 'arm64' },
+  { npmOs: 'win32', npmArch: 'x64', goos: 'windows', goarch: 'amd64' },
+  { npmOs: 'win32', npmArch: 'arm64', goos: 'windows', goarch: 'arm64' },
+];
+
+function findPlatform(npmOs, npmArch) {
+  const found = PLATFORMS.find((p) => p.npmOs === npmOs && p.npmArch === npmArch);
+  if (!found) {
+    throw new Error(`unsupported platform/arch: ${npmOs}/${npmArch}`);
+  }
+  return found;
+}
+
+function archiveExt(goos) {
+  return goos === 'windows' ? 'zip' : 'tar.gz';
+}
+
+// Matches .goreleaser.yaml's archives.name_template ("fangcun_{{
+// .Os }}_{{ .Arch }}") exactly — always GOOS/GOARCH, never Node's
+// platform/arch strings. Pinned against the yaml itself by
+// test/platforms.test.mjs.
+function archiveName({ goos, goarch }) {
+  return `fangcun_${goos}_${goarch}.${archiveExt(goos)}`;
+}
+
+// archiveNameForNpm resolves a Node platform/arch pair (process.platform /
+// process.arch) to its release archive name via the GOOS/GOARCH mapping
+// above, so callers never interpolate Node's vocabulary into the archive
+// name directly.
+function archiveNameForNpm(npmOs, npmArch) {
+  const { goos, goarch } = findPlatform(npmOs, npmArch);
+  return archiveName({ goos, goarch });
+}
+
+// binaryFileName is the plain-file name the platform package / release
+// archive ships the binary under.
+function binaryFileName(npmOs) {
+  return npmOs === 'win32' ? 'fangcun.exe' : 'fangcun';
+}
+
+function platformPackageName(npmOs, npmArch) {
+  return `@tinyacre/fangcun-${npmOs}-${npmArch}`;
+}
+
+module.exports = {
+  PLATFORMS,
+  findPlatform,
+  archiveExt,
+  archiveName,
+  archiveNameForNpm,
+  binaryFileName,
+  platformPackageName,
+};

package/lib/resolve.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const path = require('node:path');
+
+const { platformPackageName, binaryFileName } = require('./platforms.js');
+
+// Pure(-ish) resolution logic for the fangcun launcher (design doc §7,
+// npm distribution). Every external effect is injected so it can be unit
+// tested without a real npm install or network access.
+//
+// platformPackageName/binaryFileName are re-exported from platforms.js (the
+// single npm platform/arch <-> GOOS/GOARCH <-> archive-name mapping, H-2) so
+// existing callers/tests of this module keep working unchanged.
+
+function missingBinaryMessage({ pkgName, cachedPath }) {
+  return [
+    'fangcun: no CLI binary found for this platform.',
+    `  Expected optional dependency "${pkgName}" is not installed, and no`,
+    `  cached download exists at ${cachedPath}.`,
+    '  Fix one of:',
+    '    - reinstall without --no-optional / --omit=optional',
+    `    - install ${pkgName} directly`,
+    '    - set FANGCUN_CLI_BINARY to the path of a fangcun binary',
+  ].join('\n');
+}
+
+// resolveBinary implements the four-step resolution order from design §7:
+//   1. FANGCUN_CLI_BINARY env override
+//   2. the platform-specific optionalDependency package
+//   3. install.js's downloaded cache under <package>/.bin-cache/<version>/,
+//      downloading lazily (via the injected `download`) if it isn't there
+//      yet — covers a postinstall that failed or was skipped
+//      (--ignore-scripts) without bricking the CLI itself.
+//   4. an actionable failure
+//
+// `download` is optional: pass undefined to disable the lazy retry (e.g.
+// a dev/workspace checkout with no release to fetch).
+async function resolveBinary({
+  env = process.env,
+  platform = process.platform,
+  arch = process.arch,
+  requireResolve,
+  existsSync,
+  cacheDir,
+  download,
+} = {}) {
+  if (typeof requireResolve !== 'function') {
+    throw new TypeError('resolveBinary: requireResolve is required');
+  }
+  if (typeof existsSync !== 'function') {
+    throw new TypeError('resolveBinary: existsSync is required');
+  }
+  if (typeof cacheDir !== 'string') {
+    throw new TypeError('resolveBinary: cacheDir is required');
+  }
+
+  // 1. explicit override — always wins, even if the path doesn't exist yet;
+  // the caller asked for it explicitly and gets the real spawn error
+  // instead of a substituted one.
+  if (env.FANGCUN_CLI_BINARY) {
+    return { binary: env.FANGCUN_CLI_BINARY, source: 'env' };
+  }
+
+  // 2. platform-specific optionalDependency
+  const pkgName = platformPackageName(platform, arch);
+  const fileName = binaryFileName(platform);
+  try {
+    const resolved = requireResolve(`${pkgName}/bin/${fileName}`);
+    return { binary: resolved, source: 'optionalDependency' };
+  } catch {
+    // Not installed — e.g. --no-optional, a mirrored registry that dropped
+    // scoped packages, or a platform/arch this release doesn't publish.
+  }
+
+  // 3. install.js's fallback download cache, retried lazily on demand
+  if (existsSync(cacheDir)) {
+    return { binary: cacheDir, source: 'cache' };
+  }
+  if (typeof download === 'function') {
+    try {
+      await download({ destDir: path.dirname(cacheDir), destBinary: cacheDir });
+    } catch {
+      // downloader already knows how to report its own failure upstream;
+      // fall through to the actionable step-4 message below.
+    }
+    if (existsSync(cacheDir)) {
+      return { binary: cacheDir, source: 'cache-downloaded' };
+    }
+  }
+
+  // 4. nothing found
+  return {
+    binary: null,
+    source: null,
+    error: missingBinaryMessage({ pkgName, cachedPath: cacheDir }),
+  };
+}
+
+module.exports = {
+  resolveBinary,
+  platformPackageName,
+  binaryFileName,
+  missingBinaryMessage,
+};

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "fangcun",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Fangcun CLI — manage a self-hosted credit-card vault (cards, billing cycles, annual fees, benefits, reminders, the community catalog) from the shell.",
+  "bin": {
+    "fangcun": "bin/fangcun.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "install.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "optionalDependencies": {
+    "@tinyacre/fangcun-darwin-arm64": "0.1.0",
+    "@tinyacre/fangcun-darwin-x64": "0.1.0",
+    "@tinyacre/fangcun-linux-x64": "0.1.0",
+    "@tinyacre/fangcun-linux-arm64": "0.1.0",
+    "@tinyacre/fangcun-win32-x64": "0.1.0",
+    "@tinyacre/fangcun-win32-arm64": "0.1.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tinyacre/Fangcun.git",
+    "directory": "npm/cli"
+  },
+  "homepage": "https://github.com/tinyacre/Fangcun",
+  "bugs": "https://github.com/tinyacre/Fangcun/issues",
+  "publishConfig": {
+    "access": "public"
+  }
+}