only-my-pi 0.0.0-bootstrap.0 → 0.4.0-preview.1

package/README.md

@@ -1,7 +1,9 @@
-# OMP namespace registration
+# only-my-pi 0.4.0-preview.1
 
-This registration-only version contains no executable or runtime. It reserves the package name so the maintainer can configure GitHub Actions trusted publishing. It is not an OMP Preview release.
+Public Preview for macOS 14+ Apple Silicon. Requires Node >=22.19.0 and Git on PATH before npm/npx installation. The runtime includes fd and ripgrep.
 
-此版本仅用于注册包名及配置可信发布，不包含可执行程序，不是 OMP 预览版。
+macOS 14+ Apple Silicon 预览版。npm/npx 安装前需准备 Node >=22.19.0 和可用的 Git；运行包已包含 fd 和 ripgrep。
 
-[Project / 项目](https://github.com/Ricardo121380/only-my-pi)
+Run `omp` after installation. Configure model authentication with `omp admin pi`.
+
+[English documentation](https://github.com/Ricardo121380/only-my-pi) · [中文说明](https://github.com/Ricardo121380/only-my-pi/blob/main/README.zh-CN.md)

package/loader.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// Copied into the public CLI package together with the dependency-free tree
+// verifier. Do not import code from a platform payload before checking it.
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { hashResourcePath } from "./resource-hash.mjs";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+function fail(message) { throw new Error(`only-my-pi: ${message}`); }
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+  return value;
+}
+async function json(filename) {
+  const stat = await fs.lstat(filename);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 8 * 1024 * 1024) fail("unsafe package metadata");
+  return JSON.parse(await fs.readFile(filename, "utf8"));
+}
+
+export async function locateRuntime() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 22 || (major === 22 && minor < 19)) fail("Node >=22.19.0 is required");
+  const descriptor = await json(path.join(here, "runtime-packages.json"));
+  const target = `${process.platform}-${process.arch}`;
+  const expected = descriptor.platforms[target];
+  if (!expected || (process.platform === "darwin" && Number.parseInt(os.release(), 10) < 23)
+    || (process.platform === "linux" && !process.report.getReport().header.glibcVersionRuntime)) fail(`unsupported platform: ${target}`);
+  let metadata;
+  try { metadata = createRequire(import.meta.url).resolve(`${expected.name}/package.json`); }
+  catch { fail("the platform runtime package is missing; reinstall with optional dependencies enabled"); }
+  const packageManifest = await json(metadata);
+  if (packageManifest.name !== expected.name || packageManifest.version !== descriptor.version) fail("platform package version mismatch");
+  const root = await fs.realpath(path.join(path.dirname(metadata), "runtime"));
+  const manifest = await json(path.join(root, "distribution-manifest.json"));
+  const { distributionId, ...identity } = manifest;
+  const calculated = `sha256:${crypto.createHash("sha256").update(JSON.stringify(canonical(identity))).digest("hex")}`;
+  if (distributionId !== expected.distributionId || calculated !== distributionId || manifest.version !== descriptor.version
+    || manifest.platform.os !== process.platform || manifest.platform.arch !== process.arch) fail("runtime identity differs from the CLI release");
+  const paths = { app: "only-my-pi/package", pi: "pi", external: "external-npm" };
+  for (const [id, relative] of Object.entries(paths)) {
+    if (manifest.components[id]?.path !== relative) fail("invalid runtime component path");
+    const hash = `sha256:${await hashResourcePath({ artifactRoot: root, relativePath: relative, allowContainedSymlinks: true })}`;
+    if (hash !== manifest.components[id].treeDigest) fail(`${id} runtime content is damaged`);
+  }
+  return { root, packageRoot: path.join(root, paths.app) };
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const runtime = await locateRuntime();
+  if (argv.length === 1 && argv[0] === "--verify-install") {
+    const { requireSystemDependencies } = await import(pathToFileURL(path.join(runtime.packageRoot, "packages/distribution/system-dependencies.mjs")).href);
+    await requireSystemDependencies();
+    return 0;
+  }
+  const { runOmpEntrypoint } = await import(pathToFileURL(path.join(runtime.packageRoot, "bin/omp.mjs")).href);
+  return runOmpEntrypoint({ argv, rootDir: runtime.packageRoot });
+}
+
+if (process.argv[1] && await fs.realpath(process.argv[1]) === await fs.realpath(fileURLToPath(import.meta.url))) {
+  try { process.exitCode = await main(); }
+  catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }
+}

package/package.json

@@ -1,20 +1,38 @@
 {
   "name": "only-my-pi",
-  "version": "0.0.0-bootstrap.0",
+  "version": "0.4.0-preview.1",
   "private": false,
-  "description": "Namespace registration for future verified OMP releases; no executable included",
+  "type": "module",
   "license": "MIT",
+  "description": "Guarded terminal coding agent built on Pi (Public Preview)",
+  "bin": {
+    "omp": "loader.mjs"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "optionalDependencies": {
+    "only-my-pi-runtime-darwin-arm64": "0.4.0-preview.1"
+  },
+  "scripts": {
+    "postinstall": "node loader.mjs --verify-install"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Ricardo121380/only-my-pi.git"
   },
+  "homepage": "https://github.com/Ricardo121380/only-my-pi",
   "files": [
+    "loader.mjs",
+    "resource-hash.mjs",
+    "runtime-packages.json",
     "README.md",
     "LICENSE"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "tag": "bootstrap",
-    "registry": "https://registry.npmjs.org/"
-  }
+  ]
 }

package/resource-hash.mjs

@@ -0,0 +1,105 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+function fail(code, message) {
+  throw Object.assign(new Error(message), { code });
+}
+
+export function assertSafeRelativePath(value, label = "path") {
+  if (typeof value !== "string" || value.length === 0 || value.includes("\0") || value.includes("\\")) {
+    fail("UNSAFE_RELATIVE_PATH", `${label} must be a non-empty portable relative path`);
+  }
+  if (path.posix.isAbsolute(value) || path.posix.normalize(value) !== value || value === ".") {
+    fail("UNSAFE_RELATIVE_PATH", `${label} must be a normalized relative path: ${value}`);
+  }
+  if (value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    fail("UNSAFE_RELATIVE_PATH", `${label} contains an unsafe path segment: ${value}`);
+  }
+  return value;
+}
+
+async function hashTreeEntry(absolutePath, relativePath, hash, options) {
+  const stat = await fs.lstat(absolutePath);
+  if (stat.isSymbolicLink()) {
+    if (!options.allowContainedSymlinks) {
+      fail("RESOURCE_SYMLINK", `resource graph does not admit symlinks: ${relativePath}`);
+    }
+    let realTarget;
+    try {
+      realTarget = await fs.realpath(absolutePath);
+    } catch (error) {
+      fail("UNSAFE_TREE_SYMLINK", `managed tree contains a dangling symlink: ${relativePath}`, error);
+    }
+    if (realTarget !== options.realRoot && !realTarget.startsWith(`${options.realRoot}${path.sep}`)) {
+      fail("UNSAFE_TREE_SYMLINK", `managed tree symlink escapes its root: ${relativePath}`);
+    }
+    const link = await fs.readlink(absolutePath);
+    hash.update("L\0");
+    hash.update(relativePath);
+    hash.update("\0");
+    hash.update(link);
+    hash.update("\0");
+    return;
+  }
+  if (stat.isDirectory()) {
+    hash.update("D\0");
+    hash.update(relativePath);
+    hash.update("\0");
+    const names = await fs.readdir(absolutePath);
+    names.sort();
+    for (const name of names) {
+      await hashTreeEntry(
+        path.join(absolutePath, name),
+        relativePath === "." ? name : `${relativePath}/${name}`,
+        hash,
+        options,
+      );
+    }
+    return;
+  }
+  if (!stat.isFile()) {
+    fail("UNSUPPORTED_RESOURCE_TYPE", `resource graph only admits regular files and directories: ${relativePath}`);
+  }
+  const bytes = await fs.readFile(absolutePath);
+  hash.update("F\0");
+  hash.update(relativePath);
+  hash.update("\0");
+  hash.update(String(bytes.length));
+  hash.update("\0");
+  hash.update(bytes);
+  hash.update("\0");
+}
+
+export async function hashResourcePath({ artifactRoot, relativePath, allowContainedSymlinks = false }) {
+  assertSafeRelativePath(relativePath, "resource path");
+  const root = path.resolve(artifactRoot);
+  const absolutePath = path.resolve(root, ...relativePath.split("/"));
+  if (absolutePath === root || !absolutePath.startsWith(`${root}${path.sep}`)) {
+    fail("RESOURCE_PATH_ESCAPE", `resource path escapes the artifact root: ${relativePath}`);
+  }
+  const hash = crypto.createHash("sha256");
+  try {
+    const rootStat = await fs.lstat(root);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+      fail("UNSAFE_RESOURCE_ROOT", "resource artifact root must be a real directory");
+    }
+    let current = root;
+    for (const segment of relativePath.split("/")) {
+      current = path.join(current, segment);
+      const stat = await fs.lstat(current);
+      if (stat.isSymbolicLink() && current !== absolutePath) {
+        fail("RESOURCE_SYMLINK", `resource path traverses a symlink: ${relativePath}`);
+      }
+    }
+    const realRoot = await fs.realpath(root);
+    await hashTreeEntry(absolutePath, ".", hash, { root, realRoot, allowContainedSymlinks });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      fail("RESOURCE_MISSING", `resource path does not exist: ${relativePath}`);
+    }
+    throw error;
+  }
+  return hash.digest("hex");
+}
+

package/runtime-packages.json

@@ -0,0 +1,11 @@
+{
+  "formatVersion": 1,
+  "version": "0.4.0-preview.1",
+  "sourceCommit": "38e71adc8c2c52cc332db288f5dcdd14f73bd8cb",
+  "platforms": {
+    "darwin-arm64": {
+      "name": "only-my-pi-runtime-darwin-arm64",
+      "distributionId": "sha256:a7af13f85bafadd22f591f88071078ffba8268c2ddee786f35bc000b10a4b75a"
+    }
+  }
+}