@standardagents/code 0.14.2-linux-x64-gnu → 0.14.3-canary.6cc75f

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,363 @@
+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._-]*$/
+// The sample plugins' browser artifacts (packages/web/scripts/build-plugins.mjs),
+// optional: the Worker runtime and index at plugins/, and one directory per
+// plugin id holding its manifest, component, transpiled glue and core modules.
+export const WEB_ARTIFACT_PLUGIN_FILES = Object.freeze([
+  'plugins/worker.js', 'plugins/runtime.js', 'plugins/samples.json',
+])
+export const WEB_ARTIFACT_PLUGIN_ID = /^[a-z0-9][a-z0-9-]*$/
+export const WEB_ARTIFACT_PLUGIN_FILE = /^[A-Za-z0-9][A-Za-z0-9._-]*\.(?:js|wasm|json)$/
+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
+  if (WEB_ARTIFACT_PLUGIN_FILES.includes(path)) return true
+  if (parts.length === 3 && parts[0] === 'plugins') {
+    return WEB_ARTIFACT_PLUGIN_ID.test(parts[1]) && WEB_ARTIFACT_PLUGIN_FILE.test(parts[2])
+  }
+  return parts.length === 2 && Boolean(WEB_ARTIFACT_DIRECTORIES[parts[0]]?.test(parts[1]))
+}
+
+// Whether a directory (without its trailing slash) may appear in a web
+// artifact: pkg, the fixed directories, plugins, and one per plugin id.
+export function webArtifactDirectoryAllowed(path) {
+  if (path === 'pkg' || path === 'plugins' || Object.hasOwn(WEB_ARTIFACT_DIRECTORIES, path)) return true
+  const parts = path.split('/')
+  return parts.length === 2 && parts[0] === 'plugins' && WEB_ARTIFACT_PLUGIN_ID.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() && webArtifactDirectoryAllowed(child)) 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,149 @@
+import { spawnSync } from 'node:child_process'
+import { readFileSync, realpathSync, statSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, isAbsolute, 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, nativeDirectory, 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)
+    : stableBinary(command, options) ?? resolvePackagedBinary(command, options)
+  const stat = statSync(binaryPath)
+  if (!stat.isFile()) {
+    throw new Error(`Resolved Standard executable is not a file: ${binaryPath}`)
+  }
+  return binaryPath
+}
+
+// The daemon records its last stably booted native release as
+// native-releases/stable. Starting it makes this package's age irrelevant:
+// that build selects the account's active release with its own current
+// verification rules. The packaged build remains the first-install fallback.
+export function stableBinary(command, options = {}) {
+  const environment = options.environment ?? process.env
+  const home = environment.HOME
+  const argumentsList = options.arguments ?? process.argv.slice(2)
+  if (!home || !isAbsolute(home)
+    || argumentsList.some(argument => argument === '--state-dir' || argument.startsWith('--state-dir='))) {
+    return null
+  }
+  const { rustTarget } = platformPackage(options.platform, options.architecture, options.report)
+  const relative = rustTarget.endsWith('-unknown-linux-gnu')
+    ? `bin/${command}`
+    : `${command === 'standard' ? 'Standard Code' : 'Standard Code Daemon'}.app/Contents/MacOS/${command}`
+  const uid = options.uid ?? process.getuid?.()
+  try {
+    const root = realpathSync(join(home, '.local/share/standard-code/state/native-releases'))
+    const slot = realpathSync(join(root, 'stable'))
+    if (dirname(slot) !== join(root, rustTarget)) return null
+    for (const directory of [root, slot]) {
+      const info = statSync(directory)
+      if (!info.isDirectory() || info.uid !== uid || (info.mode & 0o077) !== 0) return null
+    }
+    const binary = join(slot, relative)
+    const info = statSync(binary)
+    return info.isFile() && info.uid === uid ? binary : null
+  } catch {
+    return null
+  }
+}
+
+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. The package has no install script, so npm
+// and pnpm install it without an allow-scripts prompt, and the first launch
+// downloads and verifies the native build here (#684).
+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.
+  }
+  const log = options.log ?? (message => console.error(message))
+  log(`standard: installing the native build for ${platform.rustTarget} (first launch)`)
+  try {
+    await installNativeArtifact({ target: platform.rustTarget, root: options.packageRoot, fetchImplementation: options.fetchImplementation })
+  } catch (error) {
+    if (error?.code === 'EACCES' || error?.code === 'EPERM') {
+      throw new Error(
+        `cannot write the native build under ${nativeDirectory(platform.rustTarget, options.packageRoot)}. `
+        + 'The package belongs to another user (for example an npm install run with sudo); '
+        + 'reinstall @standardagents/code with an npm prefix you own.',
+      )
+    }
+    throw error
+  }
+}
+
+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
+  }
+}

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,29 +1,49 @@
 {
   "name": "@standardagents/code",
-  "version": "0.14.2-linux-x64-gnu",
-  "description": "Standard native binaries for linux-x64-gnu.",
+  "version": "0.14.3-canary.6cc75f",
+  "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"
-  ],
-  "files": [
-    "bin",
-    "licenses",
-    "manifest.json",
-    "manifest.sig"
-  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "standard": "bin/standard.mjs",
+    "standardd": "bin/standardd.mjs"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "standardArtifacts": {
+    "schema": 1,
+    "targets": {
+      "aarch64-apple-darwin": {
+        "url": "https://builds.standardcode.ai/artifacts/0.14.3-canary.6cc75f/aarch64-apple-darwin.tar.gz",
+        "sha256": "45f9458727aae1a6ed80dad7f8bff778d271a56b5148e3cdc9fceb22fafa2410",
+        "size": 22931785
+      },
+      "x86_64-unknown-linux-gnu": {
+        "url": "https://builds.standardcode.ai/artifacts/0.14.3-canary.6cc75f/x86_64-unknown-linux-gnu.tar.gz",
+        "sha256": "ef44b1a6a2c3623143f2dcb0505b56cce65d8649d21441cfe4373ed59bf5f6de",
+        "size": 28560078
+      }
+    }
+  },
+  "standardUpgrade": {
+    "schema": 1,
+    "reader": 1,
+    "bridge": {
+      "version": "0.14.1-canary.76909e",
+      "commit": "76909e97ec56c2ba5490932135642962c4035596"
+    }
   }
 }

package/licenses/THIRD-PARTY.txt

@@ -1,152 +0,0 @@
-libevent.txt
-============
-Libevent is available for use under the following license, commonly known
-as the 3-clause (or "modified") BSD license:
-
-==============================
-Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu>
-Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. The name of the author may not be used to endorse or promote products
-   derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-==============================
-
-Portions of Libevent are based on works by others, also made available by
-them under the three-clause BSD license above.  The copyright notices are
-available in the corresponding source files; the license is as above.  Here's
-a list:
-
-log.c:
-   Copyright (c) 2000 Dug Song <dugsong@monkey.org>
-   Copyright (c) 1993 The Regents of the University of California.
-
-strlcpy.c:
-   Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
-
-win32select.c:
-   Copyright (c) 2003 Michael A. Davis <mike@datanerds.net>
-
-evport.c:
-   Copyright (c) 2007 Sun Microsystems
-
-ht-internal.h:
-   Copyright (c) 2002 Christopher Clark
-
-minheap-internal.h:
-   Copyright (c) 2006 Maxim Yegorushkin <maxim.yegorushkin@gmail.com>
-
-==============================
-
-The arc4module is available under the following, sometimes called the
-"OpenBSD" license:
-
-   Copyright (c) 1996, David Mazieres <dm@uun.org>
-   Copyright (c) 2008, Damien Miller <djm@openbsd.org>
-
-   Permission to use, copy, modify, and distribute this software for any
-   purpose with or without fee is hereby granted, provided that the above
-   copyright notice and this permission notice appear in all copies.
-
-   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-==============================
-
-The Windows timer code is based on code from libutp, which is
-distributed under this license, sometimes called the "MIT" license.
-
-
-Copyright (c) 2010 BitTorrent, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-
-ncurses.txt
-===========
-Copyright 2018-2024,2025 Thomas E. Dickey
-Copyright 1998-2017,2018 Free Software Foundation, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, distribute with modifications, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
-THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name(s) of the above copyright
-holders shall not be used in advertising or otherwise to promote the
-sale, use or other dealings in this Software without prior written
-authorization.
-
--- vile:txtmode fc=72
--- $Id: COPYING,v 1.14 2025/01/04 10:53:46 tom Exp $
-
-
-tmux.txt
-========
-Copyright (c) Various Authors
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
-IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
-OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-

package/manifest.json

@@ -1 +0,0 @@
-{"schema":2,"format":"standard-npm-native-target-v2","repository":"standardagents/code-rs","commit":"89a5a75f1ec0949a1ae901c7316179aa7727a348","version":"0.14.2","target":"x86_64-unknown-linux-gnu","runtime":{"tmuxVersion":"3.7","tmuxSha256":"253051129b9534f66a6b364f0613688886dca92c764db1660f081cdcaea882fe","accountUpdateProtocol":1,"minimumGlibc":"2.28"},"signing":{"algorithm":"ed25519","keyId":"team-2026-1","platformCodeSignature":"ed25519-only"},"files":[{"path":"bin/standard","size":17127016,"sha256":"eeee8aea296bdfc765bfe4ea058b7973bf61c3e5aa59ba5dcf4369eef67ab1cd"},{"path":"bin/standardd","size":18902560,"sha256":"0d724b1b0f38de99d3eeb482bef34b5e7ba444500f051d3f929d0d1a2e54128e"},{"path":"bin/tmux","size":1433024,"sha256":"253051129b9534f66a6b364f0613688886dca92c764db1660f081cdcaea882fe"},{"path":"licenses/THIRD-PARTY.txt","size":6779,"sha256":"fc410e91ff375a3057837d3029ec2626e6110a05f69b6fee7ca4e9f588b1a294"}]}

package/manifest.sig

@@ -1 +0,0 @@
-pVZscMwUhO55O8xQEuNSNrn2FUwFY4Kw/iVfdEer7rz+OL6xx9qQjXUWh7xEmoreblfCCFdx4mDYEIAKhE9iAg==