@standardagents/code 0.14.1-issue.653.6647dc-linux-x64-gnu → 0.14.1-issue.653.6647dc

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,326 @@
+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}`)
+  }
+}
+
+// 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/launcher.mjs

@@ -0,0 +1,75 @@
+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'
+
+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
+  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 })
+    const report = options.report ?? process.report
+    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,
+  })
+}
+
+export function main(command) {
+  try {
+    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
+  }
+}

package/lib/platform.mjs

@@ -0,0 +1,50 @@
+const PLATFORMS = new Map([
+  ['darwin:arm64', {
+    packageName: '@standardagents/code-darwin-arm64',
+    rustTarget: 'aarch64-apple-darwin',
+  }],
+  ['darwin:x64', {
+    packageName: '@standardagents/code-darwin-x64',
+    rustTarget: 'x86_64-apple-darwin',
+  }],
+  ['linux:arm64', {
+    packageName: '@standardagents/code-linux-arm64-gnu',
+    rustTarget: 'aarch64-unknown-linux-gnu',
+  }],
+  ['linux:x64', {
+    packageName: '@standardagents/code-linux-x64-gnu',
+    rustTarget: 'x86_64-unknown-linux-gnu',
+  }],
+])
+
+export function platformPackage(
+  platform = process.platform,
+  architecture = process.arch,
+  report = process.report,
+) {
+  const entry = PLATFORMS.get(`${platform}:${architecture}`)
+  if (!entry) {
+    throw new Error(
+      `Standard does not yet provide binaries for ${platform}/${architecture}; `
+      + 'Phase 0 supports macOS and glibc Linux on arm64/x64.',
+    )
+  }
+  if (platform === 'linux' && !isGlibc(report)) {
+    throw new Error(
+      'Standard Phase 0 Linux packages require glibc; a musl build is not published yet.',
+    )
+  }
+  return entry
+}
+
+export function supportedPlatforms() {
+  return [...PLATFORMS.values()].map((entry) => ({ ...entry }))
+}
+
+function isGlibc(report) {
+  try {
+    return Boolean(report?.getReport()?.header?.glibcVersionRuntime)
+  } catch {
+    return false
+  }
+}

package/package.json

@@ -1,30 +1,42 @@
 {
   "name": "@standardagents/code",
-  "version": "0.14.1-issue.653.6647dc-linux-x64-gnu",
-  "description": "Standard native binaries for linux-x64-gnu.",
+  "version": "0.14.1-issue.653.6647dc",
+  "description": "Platform launcher for the Standard universal terminal network.",
+  "type": "module",
+  "license": "UNLICENSED",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/standardagents/code-rs.git"
   },
-  "license": "UNLICENSED",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "libc": [
-    "glibc"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "standard": "bin/standard.mjs",
+    "standardd": "bin/standardd.mjs"
+  },
   "files": [
     "bin",
-    "licenses",
     "lib",
-    "manifest.json",
-    "manifest.sig"
+    "postinstall.mjs"
   ],
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
+  "scripts": {
+    "postinstall": "node postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "@standardagents/code-darwin-arm64": "npm:@standardagents/code@0.14.1-issue.653.6647dc-darwin-arm64",
+    "@standardagents/code-linux-x64-gnu": "npm:@standardagents/code@0.14.1-issue.653.6647dc-linux-x64-gnu"
+  },
+  "standardUpgrade": {
+    "schema": 1,
+    "reader": 1,
+    "bridge": {
+      "version": "0.14.1-canary.76909e",
+      "commit": "76909e97ec56c2ba5490932135642962c4035596"
+    }
   }
 }

package/postinstall.mjs

@@ -0,0 +1,12 @@
+import { chmodSync } from 'node:fs'
+
+import { resolveBinary } from './lib/launcher.mjs'
+
+for (const command of ['standard', 'standardd']) {
+  try {
+    chmodSync(resolveBinary(command), 0o755)
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error)
+    console.warn(`@standardagents/code: ${detail}`)
+  }
+}

package/bin/standard

@@ -1,4 +0,0 @@
-[diffend] Oversized file quarantined before diffing.
-name: package/bin/standard
-size: 40005472 bytes
-sha256: cb4f816dac37596499700b15a2162e238c5fb4b2cf4ff379f6c585eea3fdebef

package/bin/standardd

@@ -1,4 +0,0 @@
-[diffend] Oversized file quarantined before diffing.
-name: package/bin/standardd
-size: 48737664 bytes
-sha256: 95df8467976181501e5457346ac48ce46b9492a2ec0782d3855bc408d955b3a4