gip-remote 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,131 @@
+# gip-remote
+
+Git-in-Pear remote database. Store and replicate Git repositories over Hyperswarm using HyperDB.
+
+```
+npm install gip-remote
+```
+
+## Usage
+
+```js
+const Corestore = require('corestore')
+const Hyperswarm = require('hyperswarm')
+const { Remote } = require('gip-remote')
+
+const store = new Corestore('./my-store')
+const swarm = new Hyperswarm()
+
+const remote = new Remote({ name: 'my-repo', store, swarm })
+await remote.ready()
+
+console.log(remote.key) // public key
+```
+
+### Push
+
+```js
+// objects is a Map of oid => { type, size, data }
+await remote.push('main', commitOid, objects)
+```
+
+### Fetch
+
+```js
+const refs = await remote.getAllRefs()
+const objects = await remote.getRefObjects(commitOid)
+```
+
+### toDrive
+
+Get a Hyperdrive-compatible interface for a branch. Works with `mirror-drive`.
+
+```js
+const drive = await remote.toDrive('main')
+
+const content = await drive.get('/README.md')
+
+for await (const path of drive.list('/')) {
+  console.log(path)
+}
+
+// Mirror to a local Hyperdrive
+const mirror = drive.mirror(localDrive)
+await mirror.done()
+```
+
+### toDisk
+
+Write git objects directly to a `.git` directory on disk.
+
+```js
+const { toDisk } = require('gip-remote/lib/git')
+
+const objects = await remote.getRefObjects(commitOid)
+
+await toDisk({
+  gitDir: '/path/to/repo/.git',
+  objects,
+  refs: { 'refs/heads/main': commitOid },
+  head: 'main'
+})
+```
+
+## API
+
+#### `const remote = new Remote(opts)`
+
+Create a new remote.
+
+- `opts.name` - repository name
+- `opts.store` - a Corestore instance
+- `opts.swarm` - a Hyperswarm instance
+- `opts.key` - optional public key to open an existing remote
+- `opts.timeout` - peer discovery timeout in ms (default `240000`)
+
+#### `remote.key`
+
+Public key of the underlying Hypercore.
+
+#### `remote.discoveryKey`
+
+Discovery key used for swarming.
+
+#### `await remote.push(branch, commitOid, objects)`
+
+Push a commit. `objects` is a `Map<oid, { type, size, data }>`.
+
+#### `await remote.getAllRefs()`
+
+Returns an array of `{ ref, oid }`.
+
+#### `await remote.getBranchRef(branch)`
+
+Returns `{ ref, oid }` or `null`.
+
+#### `await remote.getRefObjects(commitOid)`
+
+Returns all stored objects for a commit.
+
+#### `await remote.getObject(oid)`
+
+Get a single object by OID.
+
+#### `const drive = await remote.toDrive(branch)`
+
+Returns a `RemoteDrive` or `null` if the branch doesn't exist. The drive is compatible with `mirror-drive`.
+
+#### `await toDisk(opts)`
+
+Write git objects to a `.git` directory.
+
+- `opts.gitDir` - path to the `.git` directory (required)
+- `opts.objects` - array of `{ type, id, size, data }` (required)
+- `opts.refs` - object mapping ref names to OIDs, e.g. `{ 'refs/heads/main': commitOid }`
+- `opts.head` - branch name to set HEAD to, e.g. `'main'`
+- `opts.objectFormat` - hash algorithm, only `'sha1'` supported (default)
+- `opts.verifySizes` - verify declared sizes match buffer lengths (default `true`)
+
+## License
+
+Apache-2.0

package/index.d.ts

@@ -0,0 +1,110 @@
+import { Readable } from 'streamx'
+
+interface RemoteOpts {
+  name?: string
+  store: any
+  swarm: any
+  key?: Buffer
+  timeout?: number
+  blind?: boolean
+}
+
+interface GitObject {
+  oid: string
+  type: string
+  size: number
+  data: Buffer
+}
+
+interface Ref {
+  ref: string
+  oid: string
+}
+
+interface RefObject extends GitObject {
+  id: string
+}
+
+declare class Remote {
+  constructor(opts: RemoteOpts)
+
+  readonly name: string
+  readonly core: any
+  readonly key: Buffer
+  readonly discoveryKey: Buffer
+  readonly availablePeers: number
+
+  ready(): Promise<void>
+  close(): Promise<void>
+
+  push(
+    branch: string,
+    commitOid: string,
+    objects: Map<string, { type: string; size: number; data: Buffer }>
+  ): Promise<void>
+  getAllRefs(): Promise<Ref[]>
+  getBranchRef(branch: string): Promise<Ref | null>
+  getObject(oid: string): Promise<GitObject | null>
+  getRefObjects(commitOid: string, onLoad?: (size: number) => void): Promise<RefObject[]>
+  toDrive(branch: string): Promise<RemoteDrive | null>
+  waitForPeers(): Promise<void>
+}
+
+interface DriveEntry {
+  key: string
+  value: {
+    executable: boolean
+    linkname: null
+    blob: { byteLength: number }
+    metadata: null
+  }
+}
+
+declare class RemoteDrive {
+  constructor(db: any, opts?: { branch?: string })
+
+  ready(): Promise<void>
+
+  entry(nameOrEntry: string | { key: string }): Promise<DriveEntry | null>
+  get(nameOrEntry: string | { key: string }): Promise<Buffer | null>
+  createReadStream(entryOrKey: string | { key: string }): Readable
+  list(folder: string, opts?: { ignore?: (path: string) => boolean }): Readable
+  readdir(folder: string): Readable
+  mirror(out: any, opts?: any): any
+}
+
+interface ToDiskOpts {
+  gitDir: string
+  objects: Array<{ type: string; id: string; size: number; data: Buffer }>
+  refs?: Record<string, string>
+  head?: string
+  objectFormat?: 'sha1'
+  fs?: any
+  verifySizes?: boolean
+}
+
+declare function toDisk(opts: ToDiskOpts): Promise<void>
+
+interface Commit {
+  tree: string | null
+  parents: string[]
+  author: string | null
+  timestamp: number
+  message: string
+}
+
+interface FileEntry {
+  path: string
+  oid: string
+  mode: string
+  size: number
+}
+
+declare function parseCommit(data: Buffer): Commit
+declare function walkTree(
+  objects: Map<string, { type: string; size: number; data: Buffer }>,
+  treeOid: string,
+  prefix: string
+): FileEntry[]
+
+export { Remote, RemoteDrive, toDisk, parseCommit, walkTree }

package/index.js

@@ -0,0 +1,218 @@
+const ReadyResource = require('ready-resource')
+const HyperDB = require('hyperdb')
+const Hyperbee = require('hyperbee2')
+const def = require('./schema/hyperdb/index')
+const RemoteDrive = require('./lib/drive')
+const { parseCommit, walkTree } = require('./lib/git')
+
+class Remote extends ReadyResource {
+  _swarm = null
+  _store = null
+  _db = null
+  _key = null
+
+  constructor(args = {}) {
+    super()
+
+    this._name = args.name
+    this._store = args.store
+    this._swarm = args.swarm
+    this._timeout = args.timeout || 240_000
+    this._blind = args.blind
+    this._key = args.key
+
+    const bee = new Hyperbee(this._store, { key: args.key })
+    this._db = HyperDB.bee2(bee, def)
+
+    this._onconnection = (conn) => {
+      this._store.replicate(conn)
+      this.emit('connection', conn)
+    }
+
+    this._swarm.on('connection', this._onconnection)
+  }
+
+  async _open() {
+    await this._db.ready()
+
+    this._topic = this._swarm.join(this.discoveryKey)
+
+    await this._db.update()
+  }
+
+  async _close() {
+    this._swarm.off('connection', this._onconnection)
+
+    if (this._topic) await this._topic.destroy()
+
+    await this._db.close()
+  }
+
+  get name() {
+    return this._name
+  }
+  get core() {
+    return this._db.core
+  }
+  get key() {
+    return this._db.core.key
+  }
+  get discoveryKey() {
+    return this._db.core.discoveryKey
+  }
+  get availablePeers() {
+    return this._db.core.peers.length
+  }
+
+  // --- Objects ---
+
+  async getObject(oid) {
+    return this._db.get('@gip/objects', { oid })
+  }
+
+  // --- Refs / Branches ---
+
+  async getAllRefs() {
+    const branches = this._db.find('@gip/branches')
+    const refs = []
+
+    for await (const b of branches) {
+      refs.push({ ref: `refs/heads/${b.name}`, oid: b.commitOid })
+    }
+
+    const main = refs.find((r) => r.ref === 'refs/heads/main')
+    if (main) refs.push({ ref: 'HEAD', oid: main.oid })
+
+    return refs.reverse()
+  }
+
+  async getBranchRef(branch) {
+    const b = await this._db.get('@gip/branches', { name: branch })
+    if (!b) return null
+    return { ref: `refs/heads/${b.name}`, oid: b.commitOid }
+  }
+
+  // --- Push: store objects + index branch + files ---
+
+  async push(branchName, commitOid, objects) {
+    // 1. Store all git objects
+    for (const [oid, obj] of objects) {
+      const existing = await this.getObject(oid)
+      if (existing) continue
+
+      await this._db.insert('@gip/objects', {
+        oid,
+        type: obj.type,
+        size: obj.size,
+        data: obj.data
+      })
+    }
+
+    // 2. Parse commit metadata
+    const commitObj = objects.get(commitOid)
+    if (!commitObj) throw new Error('Commit object not found: ' + commitOid)
+
+    const commit = parseCommit(commitObj.data)
+    if (!commit.tree) throw new Error('Commit has no tree: ' + commitOid)
+
+    // 3. Walk tree to enumerate files
+    const files = walkTree(objects, commit.tree, '')
+
+    // 4. Insert file records
+    for (const file of files) {
+      await this._db.insert('@gip/files', {
+        branch: branchName,
+        path: file.path,
+        oid: file.oid,
+        mode: file.mode,
+        size: file.size,
+        author: commit.author,
+        message: commit.message,
+        timestamp: commit.timestamp
+      })
+    }
+
+    // 5. Insert branch record
+    await this._db.insert('@gip/branches', {
+      name: branchName,
+      commitOid,
+      treeOid: commit.tree,
+      author: commit.author,
+      message: commit.message,
+      timestamp: commit.timestamp,
+      objects: [...objects.keys()]
+    })
+
+    // 6. Flush
+    await this._db.flush()
+  }
+
+  // --- Fetch support ---
+
+  async getRefObjects(commitOid, onLoad) {
+    const branches = this._db.find('@gip/branches')
+    let branch = null
+
+    for await (const b of branches) {
+      if (b.commitOid === commitOid) {
+        branch = b
+        break
+      }
+    }
+
+    if (!branch) return []
+
+    const results = []
+    for (const oid of branch.objects) {
+      const obj = await this.getObject(oid)
+      if (!obj) continue
+
+      // Empty blobs have null data after round-tripping through compact-encoding
+      const data = obj.data || Buffer.alloc(0)
+
+      if (onLoad) onLoad(obj.size)
+      results.push({ ...obj, data, id: oid })
+    }
+
+    return results
+  }
+
+  // --- Drive ---
+
+  async toDrive(branch) {
+    const b = await this._db.get('@gip/branches', { name: branch })
+    if (!b) return null
+
+    const drive = new RemoteDrive(this._db, { branch })
+    await drive.ready()
+    return drive
+  }
+
+  // --- Peer discovery ---
+
+  async waitForPeers() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        clearInterval(interval)
+        reject(new Error(`Timeout waiting for peers after ${this._timeout}ms`))
+      }, this._timeout)
+
+      const interval = setInterval(async () => {
+        if (this.availablePeers > 0) {
+          clearInterval(interval)
+          clearTimeout(timeout)
+          resolve()
+        } else {
+          await this._db.update()
+        }
+      }, 500)
+    })
+  }
+}
+
+module.exports = {
+  Remote,
+  RemoteDrive,
+  parseCommit,
+  walkTree
+}

package/lib/drive.js

@@ -0,0 +1,133 @@
+const ReadyResource = require('ready-resource')
+const MirrorDrive = require('mirror-drive')
+const { Readable } = require('streamx')
+
+class RemoteDrive extends ReadyResource {
+  constructor(db, { branch = 'main' } = {}) {
+    super()
+    this._db = db
+    this._branch = branch
+  }
+
+  async _open() {
+    await this._db.ready()
+  }
+
+  _resolveKey(nameOrEntry) {
+    if (typeof nameOrEntry === 'object' && nameOrEntry !== null) return nameOrEntry.key
+    return nameOrEntry
+  }
+
+  async entry(nameOrEntry) {
+    const key = this._resolveKey(nameOrEntry)
+    const record = await this._db.get('@gip/files', {
+      branch: this._branch,
+      path: key
+    })
+    if (!record) return null
+
+    return {
+      key,
+      value: {
+        executable: record.mode === '100755',
+        linkname: null,
+        blob: { byteLength: record.size },
+        metadata: null
+      }
+    }
+  }
+
+  async get(nameOrEntry) {
+    const key = this._resolveKey(nameOrEntry)
+    const record = await this._db.get('@gip/files', {
+      branch: this._branch,
+      path: key
+    })
+    if (!record) return null
+
+    const obj = await this._db.get('@gip/objects', { oid: record.oid })
+    if (!obj) return null
+    return obj.data
+  }
+
+  createReadStream(entryOrKey) {
+    const self = this
+    const key = typeof entryOrKey === 'object' ? entryOrKey.key : entryOrKey
+
+    return new Readable({
+      async read(cb) {
+        try {
+          const buf = await self.get(key)
+          if (buf) this.push(buf)
+          this.push(null)
+          cb(null)
+        } catch (err) {
+          cb(err)
+        }
+      }
+    })
+  }
+
+  _findRange(folder) {
+    const branch = this._branch
+    if (!folder || folder === '/') {
+      return this._db.find('@gip/files-by-branch', { branch })
+    }
+
+    return this._db.find('@gip/files-by-branch', {
+      gte: { branch, path: folder + '/' },
+      lt: { branch, path: folder + '/\uffff' }
+    })
+  }
+
+  list(folder, opts) {
+    const ignore = opts && opts.ignore
+    const stream = this._findRange(folder)
+
+    return new Readable({
+      async read(cb) {
+        try {
+          for await (const record of stream) {
+            if (ignore && ignore(record.path)) continue
+            this.push(record.path)
+          }
+          this.push(null)
+          cb(null)
+        } catch (err) {
+          cb(err)
+        }
+      }
+    })
+  }
+
+  readdir(folder) {
+    const prefix = !folder || folder === '/' ? '/' : folder + '/'
+    const seen = new Set()
+    const stream = this._findRange(folder)
+
+    return new Readable({
+      async read(cb) {
+        try {
+          for await (const record of stream) {
+            const rest = prefix === '/' ? record.path.slice(1) : record.path.slice(prefix.length)
+            const name = rest.split('/')[0]
+            if (!seen.has(name)) {
+              seen.add(name)
+              this.push(name)
+            }
+          }
+          this.push(null)
+          cb(null)
+        } catch (err) {
+          cb(err)
+        }
+      }
+    })
+  }
+
+  mirror(out, opts) {
+    return new MirrorDrive(this, out, opts)
+  }
+}
+
+module.exports = RemoteDrive

package/lib/git.js

@@ -0,0 +1,139 @@
+const git = require('rebuild-git')
+const { GitTree } = git
+const { dirname } = require('path')
+const { promises: defaultFs } = require('fs')
+
+// --- Git commit parser ---
+
+function parseCommit(data) {
+  const text = data.toString('utf8')
+  const lines = text.split('\n')
+  const result = { tree: null, parents: [], author: null, timestamp: 0, message: '' }
+
+  let i = 0
+  for (; i < lines.length; i++) {
+    const line = lines[i]
+    if (line === '') {
+      i++
+      break
+    }
+
+    if (line.startsWith('tree ')) {
+      result.tree = line.slice(5)
+    } else if (line.startsWith('parent ')) {
+      result.parents.push(line.slice(7))
+    } else if (line.startsWith('author ')) {
+      const match = line.match(/^author (.+) <.+> (\d+) [+-]\d+$/)
+      if (match) {
+        result.author = match[1]
+        result.timestamp = parseInt(match[2])
+      }
+    }
+  }
+
+  result.message = lines.slice(i).join('\n').trim()
+  return result
+}
+
+// --- Tree walker: extracts all file paths from git tree objects ---
+
+function walkTree(objects, treeOid, prefix) {
+  const treeObj = objects.get(treeOid)
+  if (!treeObj || treeObj.type !== 'tree') return []
+
+  const entries = GitTree.from(treeObj.data).entries()
+  const files = []
+
+  for (const entry of entries) {
+    const path = prefix + '/' + entry.path
+    if (entry.type === 'tree') {
+      files.push(...walkTree(objects, entry.oid, path))
+    } else {
+      const blob = objects.get(entry.oid)
+      files.push({
+        path,
+        oid: entry.oid,
+        mode: entry.mode || '100644',
+        size: blob ? blob.size : 0
+      })
+    }
+  }
+
+  return files
+}
+
+/**
+ * Write git objects to disk, rebuilding a Git repo from in-memory objects.
+ *
+ * @param {object} opts
+ * @param {string} opts.gitDir - Path to the .git directory
+ * @param {string} [opts.objectFormat='sha1'] - Hash algorithm
+ * @param {Array} opts.objects - Array of { type, id, size, data }
+ * @param {boolean} [opts.verifySizes=true] - Verify object sizes match
+ */
+async function toDisk(opts) {
+  const {
+    gitDir,
+    objectFormat = 'sha1',
+    objects,
+    refs,
+    head,
+    fs = defaultFs,
+    verifySizes = true
+  } = opts
+
+  if (!gitDir) throw new Error('gitDir is required')
+
+  if (objectFormat !== 'sha1') {
+    throw new Error('Only sha1 is supported')
+  }
+
+  if (!objects?.length) throw new Error('No objects supplied.')
+
+  for (const o of objects) {
+    if (!o.type || !o.id || o.data == null) {
+      throw new Error('Invalid object entry: missing type/id/data')
+    }
+    const data = o.data || Buffer.alloc(0)
+    if (verifySizes && data.length !== o.size) {
+      throw new Error(
+        `Size mismatch for ${o.type} ${o.id}: declared ${o.size}, buffer ${o.data.length}`
+      )
+    }
+
+    const oid = await git.writeObject({
+      fs,
+      dir: dirname(gitDir),
+      type: o.type,
+      object: data
+    })
+
+    if (oid !== o.id) {
+      throw new Error(`OID mismatch for ${o.type}: expected ${o.id} but git computed ${oid}`)
+    }
+  }
+
+  if (refs) {
+    for (const [refName, oid] of Object.entries(refs)) {
+      await git.writeRef({
+        fs,
+        dir: dirname(gitDir),
+        ref: refName,
+        value: oid,
+        force: true
+      })
+    }
+  }
+
+  if (head) {
+    await git.writeRef({
+      fs,
+      dir: dirname(gitDir),
+      ref: 'HEAD',
+      value: `ref: refs/heads/${head}`,
+      force: true
+    })
+  }
+}
+
+module.exports = { parseCommit, walkTree, toDisk }

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "gip-remote",
+  "version": "1.0.0",
+  "description": "Git+Pear remote DB for handling git data",
+  "main": "index.js",
+  "scripts": {
+    "format": "prettier . --write",
+    "test": "prettier . --check && lunte && brittle-bare test/index.js",
+    "lint": "lunte"
+  },
+  "type": "commonjs",
+  "imports": {
+    "fs": {
+      "bare": "bare-fs",
+      "default": "fs"
+    },
+    "path": {
+      "bare": "bare-path",
+      "default": "path"
+    }
+  },
+  "exports": {
+    "./package": "./package.json",
+    ".": {
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "package.json",
+    "index.js",
+    "index.d.ts",
+    "lib"
+  ],
+  "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/holepunchto/gip-remote.git"
+  },
+  "author": "Holepunch Inc",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/holepunchto/gip-remote/issues"
+  },
+  "homepage": "https://github.com/holepunchto/gip-remote",
+  "devDependencies": {
+    "brittle": "^3.19.1",
+    "corestore": "^7.9.2",
+    "hyperdht": "^6.29.6",
+    "hyperswarm": "^4.17.0",
+    "prettier": "^3.8.1",
+    "prettier-config-holepunch": "^2.0.0",
+    "test-tmp": "^1.4.0"
+  },
+  "dependencies": {
+    "bare-fs": "^4.5.6",
+    "bare-path": "^3.0.0",
+    "hyperbee2": "^2.8.0",
+    "hyperdb": "^6.3.0",
+    "mirror-drive": "^1.13.0",
+    "ready-resource": "^1.2.0",
+    "rebuild-git": "^1.1.1",
+    "streamx": "^2.25.0"
+  }
+}