@standardagents/code 0.14.1-issue.658.a1599e-linux-x64-gnu → 0.14.1-issue.663.fbc3a1

package/bin/standard.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from '../lib/launcher.mjs'
+
+main('standard')

package/bin/standardd.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from '../lib/launcher.mjs'
+
+main('standardd')

package/lib/artifact.mjs

@@ -0,0 +1,344 @@
+import { createHash, createPublicKey, verify } from 'node:crypto'
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, readdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { isPreviewBuild, normalizeBackendProfile } from './backend-profile.mjs'
+
+export const ARTIFACT_FORMAT = 'standard-npm-native-target-v2'
+export const ARTIFACT_FILES = Object.freeze([
+  'bin/standard', 'bin/standardd', 'bin/tmux', 'licenses/THIRD-PARTY.txt',
+])
+export const BUNDLE_ARTIFACT_FORMAT = 'standard-npm-native-target-v3'
+export const BUNDLE_ARTIFACT_FILES = Object.freeze([
+  // Stapled notarization tickets are distinct from the code signature seals.
+  'Standard Code.app/Contents/CodeResources',
+  'Standard Code.app/Contents/Info.plist',
+  'Standard Code.app/Contents/MacOS/standard',
+  'Standard Code.app/Contents/_CodeSignature/CodeResources',
+  'Standard Code Daemon.app/Contents/CodeResources',
+  'Standard Code Daemon.app/Contents/Info.plist',
+  'Standard Code Daemon.app/Contents/MacOS/standardd',
+  'Standard Code Daemon.app/Contents/Helpers/tmux',
+  'Standard Code Daemon.app/Contents/_CodeSignature/CodeResources',
+  ...['TMUX-ARTIFACT-MANIFEST.sha256', 'TMUX-ARTIFACT-METADATA.txt',
+    'TMUX-BUILD-TOOLS.txt', 'TMUX-OTOOL-L.txt', 'TMUX-SIGNED-RUNTIME.sha256',
+    'licenses/libevent.txt', 'licenses/tmux.txt',
+  ].map(path => `Standard Code Daemon.app/Contents/Resources/tmux/${path}`),
+  'licenses/THIRD-PARTY.txt',
+])
+
+export const RUNNER_ASSET_NAMES = Object.freeze([
+  'index.mjs', 'worker.mjs', 'loader.mjs', 'sdk.mjs', 'runtime.json', 'THIRD-PARTY.txt',
+])
+export const MAX_RUNNER_ASSET_BYTES = 16 * 1024 * 1024
+export const RUNNER_ARTIFACT_FILES = Object.freeze([
+  ...ARTIFACT_FILES, ...RUNNER_ASSET_NAMES.map(name => `lib/standard-plugin-runner/${name}`),
+])
+export const BUNDLE_RUNNER_ARTIFACT_FILES = Object.freeze([
+  ...BUNDLE_ARTIFACT_FILES,
+  ...RUNNER_ASSET_NAMES.map(name => `Standard Code Daemon.app/Contents/Resources/plugin-runner/${name}`),
+])
+
+export function artifactFiles(manifest) {
+  const hasRunner = manifest.files?.some(file => file.path?.includes('/plugin-runner/') || file.path?.startsWith('lib/standard-plugin-runner/'))
+  if (manifest.schema === 2 && manifest.format === ARTIFACT_FORMAT
+    && manifest.target?.endsWith('-unknown-linux-gnu')) return hasRunner ? RUNNER_ARTIFACT_FILES : ARTIFACT_FILES
+  if (manifest.schema === 3 && manifest.format === BUNDLE_ARTIFACT_FORMAT
+    && manifest.target?.endsWith('-apple-darwin')) return hasRunner ? BUNDLE_RUNNER_ARTIFACT_FILES : BUNDLE_ARTIFACT_FILES
+  throw new Error('Native artifact identity is invalid')
+}
+
+export function artifactBinaryPath(manifest, command) {
+  if (!['standard', 'standardd', 'tmux'].includes(command)) throw new Error('Invalid artifact command')
+  artifactFiles(manifest)
+  if (manifest.target.endsWith('-unknown-linux-gnu')) return `bin/${command}`
+  if (command === 'tmux') return 'Standard Code Daemon.app/Contents/Helpers/tmux'
+  return `${command === 'standard' ? 'Standard Code' : 'Standard Code Daemon'}.app/Contents/MacOS/${command}`
+}
+
+export function artifactDirectories(files) {
+  const directories = new Set()
+  for (const file of files) {
+    for (let directory = dirname(file); directory !== '.'; directory = dirname(directory)) directories.add(directory)
+  }
+  return [...directories].sort()
+}
+
+// Bundle signatures seal resources too: reject unmanifested contents and links
+// at every directory level, including links in an executable's ancestors.
+export function verifyArtifactTree(root, files, metadata = ['manifest.json', 'manifest.sig', 'package.json']) {
+  const allowedFiles = new Set([...files, ...metadata])
+  const allowedDirectories = new Set(artifactDirectories(files))
+  function visit(relative) {
+    const path = join(root, relative)
+    if (!lstatSync(path).isDirectory()) throw new Error(`Invalid artifact directory: ${path}`)
+    for (const name of readdirSync(path)) {
+      const child = relative ? `${relative}/${name}` : name
+      const entry = lstatSync(join(root, child))
+      if (entry.isDirectory() && allowedDirectories.has(child)) visit(child)
+      else if (!entry.isFile() || !allowedFiles.has(child)) throw new Error(`Unexpected artifact content: ${child}`)
+    }
+  }
+  visit('')
+  for (const directory of allowedDirectories) {
+    if (!lstatSync(join(root, directory)).isDirectory()) throw new Error(`Invalid artifact directory: ${directory}`)
+  }
+}
+
+// Check a native signed archive's listing before extraction: `names` from
+// `tar -tzf` and the entry type letters from `tar -tvzf`. The archive must be
+// exactly one of the signed layouts, with only regular files and the
+// directories those files need. Returns the matching file list.
+export function nativeArchiveLayout(names, types) {
+  const listed = names.map(name => name.replace(/^\.\//, '')).sort()
+  const layout = [ARTIFACT_FILES, BUNDLE_ARTIFACT_FILES, RUNNER_ARTIFACT_FILES, BUNDLE_RUNNER_ARTIFACT_FILES].find(files => {
+    const expected = [...artifactDirectories(files).map(path => `${path}/`), ...files, 'manifest.json', 'manifest.sig'].sort()
+    return listed.join('\n') === expected.join('\n')
+  })
+  if (!layout) throw new Error('native artifact archive has unexpected paths')
+  const expectedTypes = '-'.repeat(layout.length + 2) + 'd'.repeat(artifactDirectories(layout).length)
+  if ([...types].sort().join('') !== expectedTypes) {
+    throw new Error('native artifact archive must contain only regular files and expected directories')
+  }
+  return layout
+}
+
+// The four native targets the launcher has ever installed. The two deferred
+// ones stay so their published history verifies.
+export const NATIVE_ARTIFACT_TARGETS = Object.freeze([
+  'aarch64-apple-darwin', 'x86_64-apple-darwin',
+  'aarch64-unknown-linux-gnu', 'x86_64-unknown-linux-gnu',
+])
+// The browser viewer runtime: a fifth, distinct artifact kind that the same
+// build workers compile and sign. It never installs through the launcher.
+export const WEB_ARTIFACT_TARGET = 'wasm32-unknown-unknown'
+export const ARTIFACT_TARGETS = Object.freeze([...NATIVE_ARTIFACT_TARGETS, WEB_ARTIFACT_TARGET])
+
+// Web artifact (schema 4): the wasm-bindgen output, the bundled fonts, their
+// licenses, and the build record, at the artifact root. The font and license
+// sets vary with the pinned font list, so the manifest enumerates what the
+// build produced and the verifier checks each path against these rules.
+export const WEB_ARTIFACT_FORMAT = 'standard-npm-web-target-v1'
+export const WEB_ARTIFACT_SCHEMA = 4
+export const WEB_ARTIFACT_REQUIRED_FILES = Object.freeze([
+  'build.json', 'pkg/standard_web.js', 'pkg/standard_web_bg.wasm',
+])
+export const WEB_ARTIFACT_OPTIONAL_FILES = Object.freeze([
+  'pkg/standard_web.d.ts', 'pkg/standard_web_bg.wasm.d.ts',
+])
+// One level deep, one file kind each; at least one entry of each.
+export const WEB_ARTIFACT_DIRECTORIES = Object.freeze({ fonts: /\.ttf$/, licenses: /\.txt$/ })
+export const WEB_ARTIFACT_FILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/
+export const MAX_WEB_ASSET_BYTES = 64 * 1024 * 1024
+
+// Whether one artifact-relative path may appear in a web artifact.
+export function webArtifactPathAllowed(path) {
+  if (typeof path !== 'string') return false
+  const parts = path.split('/')
+  if (!parts.every(part => WEB_ARTIFACT_FILE_NAME.test(part))) return false
+  if (WEB_ARTIFACT_REQUIRED_FILES.includes(path) || WEB_ARTIFACT_OPTIONAL_FILES.includes(path)) return true
+  return parts.length === 2 && Boolean(WEB_ARTIFACT_DIRECTORIES[parts[0]]?.test(parts[1]))
+}
+
+// Check a complete web file list: every path allowed, every required file
+// present, each directory non-empty, no duplicates. Returns the sorted list.
+export function webArtifactFileList(paths) {
+  if (!Array.isArray(paths) || paths.some(path => !webArtifactPathAllowed(path))) {
+    throw new Error('Web artifact file manifest is invalid')
+  }
+  const files = [...paths].sort()
+  if (new Set(files).size !== files.length) throw new Error('Web artifact file manifest is invalid')
+  const missing = WEB_ARTIFACT_REQUIRED_FILES.filter(path => !files.includes(path))
+  for (const directory of Object.keys(WEB_ARTIFACT_DIRECTORIES)) {
+    if (!files.some(path => path.startsWith(`${directory}/`))) missing.push(`${directory}/`)
+  }
+  if (missing.length) throw new Error(`Web artifact is incomplete: missing ${missing.join(', ')}`)
+  return files
+}
+
+// Enumerate a built web artifact root as the file list its manifest binds.
+// Every entry must be a regular file the rules allow; anything else fails.
+export function webArtifactFilesOnDisk(root, metadata = ['manifest.json', 'manifest.sig']) {
+  const files = []
+  function visit(relative) {
+    for (const name of readdirSync(join(root, relative))) {
+      const child = relative ? `${relative}/${name}` : name
+      if (!relative && metadata.includes(child)) continue
+      const entry = lstatSync(join(root, child))
+      if (entry.isDirectory() && !relative && Object.hasOwn(WEB_ARTIFACT_DIRECTORIES, child)) visit(child)
+      else if (entry.isDirectory() && !relative && child === 'pkg') visit(child)
+      else if (!entry.isFile() || !webArtifactPathAllowed(child)) throw new Error(`Unexpected artifact content: ${child}`)
+      else files.push(child)
+    }
+  }
+  visit('')
+  return webArtifactFileList(files)
+}
+// Public trust anchor, not a credential. Never obtain the verification key
+// from the package being verified or a mutable registry response.
+export const ARTIFACT_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAk+Ndu0WtdSgUFkraXP5CAUlQqzm+EN/My2AwkoPOMqg=
+-----END PUBLIC KEY-----
+`
+
+export function validArtifactVersion(version) {
+  return typeof version === 'string'
+    && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version)
+    && (version.match(/^[^-]+-(.*)$/)?.[1].split('.') ?? []).every(part => !/^0\d+$/.test(part))
+}
+
+function regularFile(path, limit) {
+  const descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW)
+  try {
+    const metadata = fstatSync(descriptor)
+    if (!metadata.isFile() || metadata.size < 1 || metadata.size > limit) throw new Error(`Invalid artifact file: ${path}`)
+    return { descriptor, metadata }
+  } catch (error) { closeSync(descriptor); throw error }
+}
+
+function boundedBytes(path, limit) {
+  const { descriptor } = regularFile(path, limit)
+  try {
+    const buffer = Buffer.alloc(limit + 1)
+    let size = 0
+    while (size <= limit) {
+      const count = readSync(descriptor, buffer, size, buffer.length - size, null)
+      if (!count) return buffer.subarray(0, size)
+      size += count
+    }
+    throw new Error(`Artifact exceeds size limit: ${path}`)
+  } finally { closeSync(descriptor) }
+}
+
+// Read and authenticate an artifact's manifest against the pinned key. The
+// bytes that were signed are the bytes parsed; nothing is trusted before this.
+function signedManifest(root, publicKey, label) {
+  if (!lstatSync(root).isDirectory()) throw new Error(`Invalid artifact directory: ${root}`)
+  const bytes = boundedBytes(join(root, 'manifest.json'), 64 * 1024)
+  const signature = boundedBytes(join(root, 'manifest.sig'), 256).toString('utf8').trim()
+  const key = createPublicKey(publicKey)
+  if (key.asymmetricKeyType !== 'ed25519' || !verify(null, bytes, key, Buffer.from(signature, 'base64'))) {
+    throw new Error(`${label} artifact signature is invalid`)
+  }
+  return JSON.parse(bytes)
+}
+
+// Every manifested file must exist with exactly its signed size and digest.
+function verifyFileDigests(root, manifest, limitFor, label) {
+  const buffer = Buffer.alloc(1024 * 1024)
+  for (const file of manifest.files) {
+    if (!Number.isSafeInteger(file.size) || !/^[0-9a-f]{64}$/.test(file.sha256)) throw new Error(`${label} artifact file metadata is invalid`)
+    const path = join(root, file.path)
+    const { descriptor, metadata } = regularFile(path, limitFor(file.path))
+    try {
+      if (metadata.size !== file.size) throw new Error(`${label} artifact size mismatch: ${file.path}`)
+      const hash = createHash('sha256')
+      let size = 0
+      for (;;) {
+        const count = readSync(descriptor, buffer, 0, buffer.length, null)
+        if (!count) break
+        size += count
+        if (size > file.size) throw new Error(`${label} artifact grew while verifying: ${file.path}`)
+        hash.update(buffer.subarray(0, count))
+      }
+      if (size !== file.size || hash.digest('hex') !== file.sha256) throw new Error(`${label} artifact digest mismatch: ${file.path}`)
+    } finally { closeSync(descriptor) }
+  }
+}
+
+export function verifyNativeArtifact(root, expected = {}, publicKey = ARTIFACT_PUBLIC_KEY) {
+  const manifest = signedManifest(root, publicKey, 'Native')
+  const files = artifactFiles(manifest)
+  if (manifest.repository !== 'standardagents/code-rs'
+    || !NATIVE_ARTIFACT_TARGETS.includes(manifest.target)
+    || !/^[0-9a-f]{40}$/.test(manifest.commit)
+    || !validArtifactVersion(manifest.version)
+    || ['commit', 'version', 'target'].some(name => expected[name] != null && manifest[name] !== expected[name])
+    || manifest.signing?.algorithm !== 'ed25519') throw new Error('Native artifact identity is invalid')
+  if (Object.hasOwn(manifest, 'backendProfile') && (manifest.backendProfile == null || manifest.backendProfile === '')) {
+    throw new Error('Native artifact backend profile cannot be null')
+  }
+  const backendProfile = normalizeBackendProfile(manifest.backendProfile)
+  if (backendProfile && !isPreviewBuild(manifest.version)) {
+    throw new Error('Native artifact preview backend profile is not valid for this version')
+  }
+  if (!Array.isArray(manifest.files) || manifest.files.map(file => file.path).sort().join(',') !== [...files].sort().join(',')) {
+    throw new Error('Native artifact file manifest is invalid')
+  }
+  const runnerFiles = manifest.target.endsWith('-apple-darwin')
+    ? BUNDLE_RUNNER_ARTIFACT_FILES.slice(BUNDLE_ARTIFACT_FILES.length)
+    : RUNNER_ARTIFACT_FILES.slice(ARTIFACT_FILES.length)
+  if (!manifest.files.some(file => runnerFiles.includes(file.path))) {
+    for (const path of runnerFiles) {
+      try { lstatSync(join(root, path)) }
+      catch (error) { if (error.code === 'ENOENT') continue; throw error }
+      throw new Error('Native artifact contains unsigned plugin runner files')
+    }
+  }
+  if (manifest.schema === 3) verifyArtifactTree(root, files)
+  else for (const directory of artifactDirectories(files)) {
+    if (!lstatSync(join(root, directory)).isDirectory()) throw new Error(`Invalid artifact directory: ${directory}`)
+  }
+  const tmux = manifest.files.find(file => file.path === artifactBinaryPath(manifest, 'tmux'))
+  if (manifest.runtime?.tmuxVersion !== '3.7' || manifest.runtime.tmuxSha256 !== tmux.sha256) {
+    throw new Error('Native artifact tmux identity is invalid')
+  }
+  const protocol = manifest.runtime.accountUpdateProtocol
+  if (protocol != null && (!Number.isSafeInteger(protocol) || protocol < 1 || protocol > 0xffff_ffff)) {
+    throw new Error('Native artifact account update protocol is invalid')
+  }
+  if (manifest.target.endsWith('-apple-darwin')
+    && (manifest.signing.platformCodeSignature !== 'apple-developer-id'
+      || manifest.signing.notarization?.status !== 'Accepted'
+      || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(manifest.signing.notarization?.submissionId ?? ''))) {
+    throw new Error('macOS artifact lacks signed notarization acceptance')
+  }
+  if (manifest.target.endsWith('-unknown-linux-gnu')
+    && !/^\d+\.\d+(?:\.\d+)?$/.test(manifest.runtime.minimumGlibc ?? '')) throw new Error('Linux artifact lacks its glibc requirement')
+  verifyFileDigests(root, manifest, path => runnerFiles.includes(path) ? MAX_RUNNER_ASSET_BYTES : 256 * 1024 * 1024, 'Native')
+  return manifest
+}
+
+// Verify a web artifact root: the Ed25519 signature, the schema-4 identity,
+// the file rules, the exact on-disk file set (nothing unmanifested, no
+// links), the build record, and every digest. Returns the manifest.
+export function verifyWebArtifact(root, expected = {}, publicKey = ARTIFACT_PUBLIC_KEY) {
+  const manifest = signedManifest(root, publicKey, 'Web')
+  if (manifest.schema !== WEB_ARTIFACT_SCHEMA || manifest.format !== WEB_ARTIFACT_FORMAT
+    || manifest.target !== WEB_ARTIFACT_TARGET
+    || manifest.repository !== 'standardagents/code-rs'
+    || !/^[0-9a-f]{40}$/.test(manifest.commit)
+    || !validArtifactVersion(manifest.version)
+    || ['commit', 'version', 'target'].some(name => expected[name] != null && manifest[name] !== expected[name])
+    || manifest.signing?.algorithm !== 'ed25519') throw new Error('Web artifact identity is invalid')
+  if (Object.hasOwn(manifest, 'backendProfile') && (manifest.backendProfile == null || manifest.backendProfile === '')) {
+    throw new Error('Web artifact backend profile cannot be null')
+  }
+  const backendProfile = normalizeBackendProfile(manifest.backendProfile)
+  if (backendProfile && !isPreviewBuild(manifest.version)) {
+    throw new Error('Web artifact preview backend profile is not valid for this version')
+  }
+  if (!Array.isArray(manifest.files)) throw new Error('Web artifact file manifest is invalid')
+  const files = webArtifactFileList(manifest.files.map(file => file?.path))
+  verifyArtifactTree(root, files)
+  verifyFileDigests(root, manifest, () => MAX_WEB_ASSET_BYTES, 'Web')
+  // The build record is the identity the bundle itself reports; it must name
+  // the signed build, not a local or foreign one.
+  let record
+  try { record = JSON.parse(boundedBytes(join(root, 'build.json'), 4096)) } catch { record = null }
+  if (record?.schema !== 1 || record.commit !== manifest.commit || record.version !== manifest.version) {
+    throw new Error('Web artifact build record does not name the signed build')
+  }
+  return manifest
+}
+
+export function requireCompatibleGlibc(manifest, runtimeVersion) {
+  if (!manifest.target.endsWith('-unknown-linux-gnu')) return
+  const minimum = manifest.runtime.minimumGlibc
+  if (!/^\d+\.\d+(?:\.\d+)?$/.test(runtimeVersion ?? '')) throw new Error('Cannot determine this machine’s glibc version')
+  const actual = runtimeVersion.split('.').map(Number)
+  const required = minimum.split('.').map(Number)
+  for (let index = 0; index < 3; index++) {
+    if ((actual[index] ?? 0) > (required[index] ?? 0)) return
+    if ((actual[index] ?? 0) < (required[index] ?? 0)) throw new Error(`This Standard build requires glibc ${minimum}; this machine has ${runtimeVersion}`)
+  }
+}

package/lib/backend-profile.mjs

@@ -0,0 +1,114 @@
+const PROFILE_KEYS = ['schema', 'id', 'label', 'apiOrigin', 'relayEnvironment']
+const PROFILE_ID = /^[a-z0-9][a-z0-9-]{0,47}$/
+const DNS_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/
+const PROFILE_HOST_SUFFIXES = ['.standardcode.ai', '.standardagentbuilder.com']
+
+export const BACKEND_PROFILE_SCHEMA = 1
+
+export function isPreviewBuild(version) {
+  return typeof version === 'string' && /-(?:issue|branch)\./.test(version)
+}
+
+/**
+ * Validate and normalize the preview backend profile embedded in a native
+ * artifact. Production is represented by an absent or null profile.
+ */
+export function normalizeBackendProfile(value) {
+  if (value == null || value === '') return null
+  if (!isPlainObject(value)) throw new Error('backend profile must be an object')
+  const keys = Object.keys(value).sort()
+  if (keys.join(',') !== [...PROFILE_KEYS].sort().join(',')) {
+    throw new Error('backend profile has unexpected fields')
+  }
+  if (value.schema !== BACKEND_PROFILE_SCHEMA) throw new Error('backend profile schema is unsupported')
+  if (typeof value.id !== 'string' || !PROFILE_ID.test(value.id) || value.id === 'production') {
+    throw new Error('backend profile id is invalid')
+  }
+  if (typeof value.label !== 'string' || !/^[\x20-\x7e]{1,64}$/.test(value.label)) {
+    throw new Error('backend profile label must be printable ASCII up to 64 characters')
+  }
+  const apiOrigin = canonicalApiOrigin(value.apiOrigin)
+  if (apiOrigin === 'https://api.standardcode.ai') {
+    throw new Error('preview backend profile cannot use the production API origin')
+  }
+  if (!['staging', 'production'].includes(value.relayEnvironment)) {
+    throw new Error('backend profile relayEnvironment must be staging or production')
+  }
+  return {
+    schema: BACKEND_PROFILE_SCHEMA,
+    id: value.id,
+    label: value.label,
+    apiOrigin,
+    relayEnvironment: value.relayEnvironment,
+  }
+}
+
+export function serializeBackendProfile(value) {
+  const profile = normalizeBackendProfile(value)
+  return profile ? JSON.stringify(profile) : ''
+}
+
+export function backendProfilesEqual(left, right) {
+  const a = normalizeBackendProfile(left)
+  const b = normalizeBackendProfile(right)
+  return JSON.stringify(a) === JSON.stringify(b)
+}
+
+export function backendProfileIdentitiesEqual(left, right) {
+  const a = normalizeBackendProfile(left)
+  const b = normalizeBackendProfile(right)
+  return (a?.id ?? 'production') === (b?.id ?? 'production')
+    && (a?.apiOrigin ?? 'https://api.standardcode.ai') === (b?.apiOrigin ?? 'https://api.standardcode.ai')
+    && (a?.relayEnvironment ?? 'production') === (b?.relayEnvironment ?? 'production')
+}
+
+export async function backendProfileFingerprint(value) {
+  const profile = normalizeBackendProfile(value)
+  const id = profile?.id ?? 'production'
+  const apiOrigin = profile?.apiOrigin ?? 'https://api.standardcode.ai'
+  const relayEnvironment = profile?.relayEnvironment ?? 'production'
+  const bytes = new TextEncoder().encode(
+    `standard-backend-v1\0${id}\0${apiOrigin}\0${relayEnvironment}`,
+  )
+  const digest = await crypto.subtle.digest('SHA-256', bytes)
+  return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('')
+}
+
+/** A preview backend has a separate follow channel on the same Git branch. */
+export async function backendProfileTag(baseTag, value) {
+  const profile = normalizeBackendProfile(value)
+  if (!profile) return baseTag
+  if (!/^(?:branch-|issue-)[a-z0-9-]+$/.test(baseTag)) {
+    throw new Error('preview backend profiles require a branch channel')
+  }
+  const tag = `${baseTag}-b-${(await backendProfileFingerprint(profile)).slice(0, 16)}`
+  if (tag.length > 64) throw new Error('backend-specific channel exceeds the tag length limit')
+  return tag
+}
+
+export function canonicalApiOrigin(value) {
+  if (typeof value !== 'string' || !value || value.trim() !== value) {
+    throw new Error('backend profile apiOrigin must be a canonical HTTPS origin')
+  }
+  let url
+  try { url = new URL(value) } catch { throw new Error('backend profile apiOrigin must be a canonical HTTPS origin') }
+  if (url.protocol !== 'https:' || url.username || url.password || url.port
+    || !['', '/'].includes(url.pathname) || url.search || url.hash
+    || value !== url.origin) {
+    throw new Error('backend profile apiOrigin must be a canonical HTTPS origin')
+  }
+  const hostname = url.hostname
+  if (!hostname || hostname.length > 253 || hostname !== hostname.toLowerCase()) {
+    throw new Error('backend profile apiOrigin hostname is invalid')
+  }
+  const labels = hostname.split('.')
+  if (labels.some(label => !DNS_LABEL.test(label))
+    || !PROFILE_HOST_SUFFIXES.some(suffix => hostname.endsWith(suffix))) {
+    throw new Error('backend profile apiOrigin hostname is not a supported first-party host')
+  }
+  return url.origin
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}

package/lib/install.mjs

@@ -0,0 +1,93 @@
+import { spawnSync } from 'node:child_process'
+import { createHash, randomUUID } from 'node:crypto'
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { artifactBinaryPath, nativeArchiveLayout, verifyNativeArtifact } from './artifact.mjs'
+
+// A release's root package names each native target's signed archive in
+// `standardArtifacts`; npm only selects the platform. The archive downloads
+// from the build coordinator, which serves it from R2, and installs under this
+// package's `native/<target>/` once its size, digest, layout, and signed
+// manifest all check out. The daemon's launcher repair finds it there too.
+export const ARTIFACT_ORIGIN = 'https://builds.standardcode.ai'
+const MAX_ARCHIVE = 128 * 1024 * 1024
+const PACKAGE_ROOT = fileURLToPath(new URL('..', import.meta.url))
+
+export function nativeDirectory(target, root = PACKAGE_ROOT) {
+  return join(root, 'native', target)
+}
+
+export function packageMetadata(root = PACKAGE_ROOT) {
+  return JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+}
+
+// The signed archive a package names for `target`, or null when its binaries
+// install as an npm platform package instead.
+export function artifactPointer(metadata, target) {
+  const artifacts = metadata.standardArtifacts
+  if (artifacts === undefined) return null
+  const pointer = artifacts?.schema === 1 ? artifacts.targets?.[target] : undefined
+  if (!pointer
+    || pointer.url !== `${ARTIFACT_ORIGIN}/artifacts/${metadata.version}/${target}.tar.gz`
+    || !/^[0-9a-f]{64}$/.test(pointer.sha256 ?? '')
+    || !Number.isSafeInteger(pointer.size) || pointer.size < 1 || pointer.size > MAX_ARCHIVE) {
+    throw new Error(`This package names no valid native archive for ${target}`)
+  }
+  return pointer
+}
+
+// The installed, verified artifact directory for `target`, or null.
+export function installedArtifact(target, root = PACKAGE_ROOT, publicKey = undefined) {
+  const directory = nativeDirectory(target, root)
+  try {
+    return { directory, manifest: verifyNativeArtifact(directory, { version: packageMetadata(root).version, target }, publicKey) }
+  } catch {
+    return null
+  }
+}
+
+function tar(run, args) {
+  const result = run('tar', args, { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 })
+  if (result.error) throw result.error
+  if (result.status !== 0) throw new Error(`tar ${args[0]} failed: ${result.stderr}`)
+  return result.stdout
+}
+
+export async function installNativeArtifact({ target, root = PACKAGE_ROOT, fetchImplementation = fetch, run = spawnSync, publicKey = undefined }) {
+  const installed = installedArtifact(target, root, publicKey)
+  if (installed) return installed.directory
+  const metadata = packageMetadata(root)
+  const pointer = artifactPointer(metadata, target)
+  if (!pointer) throw new Error(`This package carries no native archive for ${target}`)
+  const response = await fetchImplementation(pointer.url)
+  if (!response.ok) throw new Error(`Downloading the native archive failed with HTTP ${response.status}`)
+  const bytes = Buffer.from(await response.arrayBuffer())
+  if (bytes.length !== pointer.size || createHash('sha256').update(bytes).digest('hex') !== pointer.sha256) {
+    throw new Error('The downloaded native archive does not match its published size and digest')
+  }
+  const work = join(root, 'native', `.install-${randomUUID()}`)
+  mkdirSync(work, { recursive: true, mode: 0o700 })
+  try {
+    const archive = join(work, 'archive.tar.gz')
+    writeFileSync(archive, bytes, { mode: 0o600, flag: 'wx' })
+    nativeArchiveLayout(
+      tar(run, ['-tzf', archive]).trim().split('\n'),
+      tar(run, ['-tvzf', archive]).trim().split('\n').map(line => line[0]),
+    )
+    const extracted = join(work, 'artifact')
+    mkdirSync(extracted, { mode: 0o700 })
+    tar(run, ['-xzf', archive, '-C', extracted])
+    const manifest = verifyNativeArtifact(extracted, { version: metadata.version, target }, publicKey)
+    for (const command of ['standard', 'standardd', 'tmux']) {
+      chmodSync(join(extracted, artifactBinaryPath(manifest, command)), 0o755)
+    }
+    const destination = nativeDirectory(target, root)
+    rmSync(destination, { recursive: true, force: true })
+    renameSync(extracted, destination)
+    return destination
+  } finally {
+    rmSync(work, { recursive: true, force: true })
+  }
+}

package/lib/launcher.mjs

@@ -0,0 +1,102 @@
+import { spawnSync } from 'node:child_process'
+import { readFileSync, realpathSync, statSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import process from 'node:process'
+
+import { platformPackage } from './platform.mjs'
+import { artifactBinaryPath, requireCompatibleGlibc, verifyNativeArtifact } from './artifact.mjs'
+import { artifactPointer, installNativeArtifact, installedArtifact, packageMetadata } from './install.mjs'
+
+const require = createRequire(import.meta.url)
+const COMMANDS = new Set(['standard', 'standardd'])
+
+export function resolveBinary(command, options = {}) {
+  if (!COMMANDS.has(command)) {
+    throw new Error(`Unknown Standard executable: ${command}`)
+  }
+  const environment = options.environment ?? process.env
+  const overrideDirectory = environment.STANDARD_CODE_BINARY_DIR
+  const binaryPath = overrideDirectory
+    ? join(overrideDirectory, command)
+    : resolvePackagedBinary(command, options)
+  const stat = statSync(binaryPath)
+  if (!stat.isFile()) {
+    throw new Error(`Resolved Standard executable is not a file: ${binaryPath}`)
+  }
+  return binaryPath
+}
+
+function resolvePackagedBinary(command, options) {
+  const platform = platformPackage(
+    options.platform,
+    options.architecture,
+    options.report,
+  )
+  const resolve = options.resolve ?? require.resolve
+  const report = options.report ?? process.report
+  // A release that carries no binaries on npm installs its signed R2 archive
+  // under this package instead (see install.mjs).
+  const downloaded = installedArtifact(platform.rustTarget, options.packageRoot)
+  if (downloaded) {
+    requireCompatibleGlibc(downloaded.manifest, report?.getReport()?.header?.glibcVersionRuntime)
+    return join(downloaded.directory, artifactBinaryPath(downloaded.manifest, command))
+  }
+  try {
+    const root = dirname(realpathSync(resolve(`${platform.packageName}/manifest.json`)))
+    const version = JSON.parse(readFileSync(new URL('../package.json', import.meta.url))).version
+    const artifact = verifyNativeArtifact(root, { version, target: platform.rustTarget })
+    requireCompatibleGlibc(artifact, report?.getReport()?.header?.glibcVersionRuntime)
+    return join(root, artifactBinaryPath(artifact, command))
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error)
+    throw new Error(
+      `The native package ${platform.packageName} is missing or incomplete. `
+      + `Reinstall @standardagents/code for this platform. (${detail})`,
+    )
+  }
+}
+
+export function spawnBinary(command, args, options = {}) {
+  const binary = resolveBinary(command, options)
+  return spawnSync(binary, args, {
+    stdio: options.stdio ?? 'inherit',
+    env: options.environment ?? process.env,
+  })
+}
+
+// Install this platform's signed R2 archive when the package names one and
+// has no binaries installed yet. Package managers that skip install scripts
+// (pnpm by default) reach this on the first launch instead of postinstall.
+export async function ensureNativeBinaries(options = {}) {
+  if (options.environment?.STANDARD_CODE_BINARY_DIR ?? process.env.STANDARD_CODE_BINARY_DIR) return
+  const platform = platformPackage(options.platform, options.architecture, options.report)
+  if (installedArtifact(platform.rustTarget, options.packageRoot)) return
+  if (!artifactPointer(packageMetadata(options.packageRoot), platform.rustTarget)) return
+  try {
+    const resolve = options.resolve ?? require.resolve
+    resolve(`${platform.packageName}/manifest.json`)
+    return
+  } catch {
+    // No npm platform package: download the archive.
+  }
+  await installNativeArtifact({ target: platform.rustTarget, root: options.packageRoot, fetchImplementation: options.fetchImplementation })
+}
+
+export async function main(command) {
+  try {
+    await ensureNativeBinaries()
+    const result = spawnBinary(command, process.argv.slice(2))
+    if (result.error) throw result.error
+    if (result.signal) {
+      console.error(`${command} terminated by ${result.signal}`)
+      process.exitCode = 1
+      return
+    }
+    process.exitCode = result.status ?? 1
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error)
+    console.error(`${command}: ${detail}`)
+    process.exitCode = 1
+  }
+}