dsh-ios-webview-app-control 0.0.0-stage → 0.2.2

package/lib/runtime/runner.mjs

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { EnvironmentError, aborted, bounded } from './errors.mjs';
+
+const OUTPUT_LIMIT = 1024 * 1024;
+
+/** Default non-DSH runner. Inject the Host managed runner when a process-range service is available. */
+export async function defaultRunner(executable, args = [], { signal, timeoutMs = 15000, env, cwd, onOutput } = {}) {
+  aborted(signal);
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, args, {
+      shell: false, windowsHide: true, cwd, env,
+      detached: process.platform !== 'win32',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let failure = null;
+    let terminating = null;
+    let escalation = null;
+    const terminate = () => {
+      if (terminating) return terminating;
+      if (!child.pid) return Promise.resolve();
+      if (process.platform === 'win32') {
+        const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows';
+        const taskkill = path.win32.join(systemRoot, 'System32', 'taskkill.exe');
+        terminating = new Promise(done => {
+          let killer;
+          try {
+            killer = spawn(taskkill, ['/PID', String(child.pid), '/T', '/F'], { shell: false, windowsHide: true, stdio: 'ignore' });
+          } catch { try { child.kill(); } catch {} done(); return; }
+          killer.once('error', () => { try { child.kill(); } catch {} });
+          killer.once('close', done);
+        });
+      } else {
+        try { process.kill(-child.pid, 'SIGTERM'); } catch {}
+        escalation = setTimeout(() => { try { process.kill(-child.pid, 'SIGKILL'); } catch {} }, 1000);
+        terminating = Promise.resolve();
+      }
+      return terminating;
+    };
+    const abort = () => {
+      failure ||= new EnvironmentError(signal?.reason?.code === 'runtime_timeout' ? 'runtime_timeout' : 'cancelled', 'Runtime subprocess was cancelled.');
+      void terminate();
+    };
+    const timer = setTimeout(() => {
+      failure ||= new EnvironmentError('runtime_process_timeout', 'Runtime subprocess exceeded its deadline.');
+      void terminate();
+    }, timeoutMs);
+    const output = (stream, chunk) => {
+      const text = chunk.toString('utf8');
+      const current = stream === 'stdout' ? stdout : stderr;
+      if (Buffer.byteLength(current) + chunk.length > OUTPUT_LIMIT) {
+        failure ||= new EnvironmentError('runtime_output_limit', 'Runtime subprocess output exceeded 1 MiB.');
+        void terminate();
+        return;
+      }
+      if (stream === 'stdout') stdout += text; else stderr += text;
+      try { onOutput?.(stream, bounded(text, 4096)); } catch {}
+    };
+    signal?.addEventListener('abort', abort, { once: true });
+    child.stdout.on('data', chunk => output('stdout', chunk));
+    child.stderr.on('data', chunk => output('stderr', chunk));
+    child.once('error', error => { failure ||= new EnvironmentError('runtime_process_error', bounded(error.message)); });
+    child.once('close', async code => {
+      clearTimeout(timer);
+      if (escalation) clearTimeout(escalation);
+      signal?.removeEventListener('abort', abort);
+      await terminating;
+      if (failure) reject(failure);
+      else resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+    if (signal?.aborted) abort();
+  });
+}

package/lib/runtime/safe-tar.mjs

@@ -0,0 +1,179 @@
+import { createGunzip } from 'node:zlib';
+import { Readable } from 'node:stream';
+import { lstat, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { EnvironmentError, aborted } from './errors.mjs';
+
+const BLOCK = 512;
+const MAX_ENTRIES = 100_000;
+const MAX_EXPANDED = 512 * 1024 * 1024;
+const MAX_ENTRY = 256 * 1024 * 1024;
+const MAX_METADATA = 1024 * 1024;
+
+function reject(message) {
+  throw new EnvironmentError('runtime_archive_invalid', message);
+}
+
+function string(header, start, length) {
+  const bytes = header.subarray(start, start + length);
+  const zero = bytes.indexOf(0);
+  return bytes.subarray(0, zero < 0 ? bytes.length : zero).toString('utf8');
+}
+
+function number(header, start, length) {
+  const raw = header.subarray(start, start + length);
+  if (raw[0] & 0x80) reject('Tar base-256 sizes are not supported.');
+  const text = string(header, start, length).trim();
+  if (text && !/^[0-7]+$/.test(text)) reject('Tar contains an invalid numeric field.');
+  const result = text ? parseInt(text, 8) : 0;
+  if (!Number.isSafeInteger(result)) reject('Tar numeric field exceeds the safe bound.');
+  return result;
+}
+
+function safeName(value) {
+  if (!value || value.length > 1024 || /[\\\x00-\x1f:\x7f]/.test(value) || value.startsWith('/')) reject('Tar contains an absolute, ADS, control-character or unsafe path.');
+  const name = value.replace(/\/+$/, '');
+  const parts = name.split('/');
+  if (parts.some(part => !part || part === '.' || part === '..' || /[. ]$/.test(part) || /^(?:CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\.|$)/i.test(part))) reject('Tar contains a traversal or reserved Windows path.');
+  return parts.join('/');
+}
+
+function pax(bytes) {
+  const output = {};
+  let offset = 0;
+  while (offset < bytes.length) {
+    const space = bytes.indexOf(32, offset);
+    if (space < 0) reject('Tar contains malformed PAX metadata.');
+    const lengthText = bytes.toString('ascii', offset, space);
+    if (!/^[0-9]+$/.test(lengthText)) reject('Tar contains malformed PAX record lengths.');
+    const length = Number(lengthText);
+    if (!Number.isSafeInteger(length) || length <= space - offset + 1 || offset + length > bytes.length || bytes[offset + length - 1] !== 10) reject('Tar contains truncated PAX metadata.');
+    const text = bytes.toString('utf8', space + 1, offset + length - 1);
+    const equals = text.indexOf('=');
+    if (equals < 1) reject('Tar contains malformed PAX metadata.');
+    const key = text.slice(0, equals);
+    if (/linkpath|sparse/i.test(key)) reject('Tar PAX links and sparse files are forbidden.');
+    output[key] = text.slice(equals + 1);
+    offset += length;
+  }
+  return output;
+}
+
+async function ensureDirectory(root, relative) {
+  let current = root;
+  for (const part of relative ? relative.split('/') : []) {
+    current = path.join(current, part);
+    try {
+      const entry = await lstat(current);
+      if (!entry.isDirectory() || entry.isSymbolicLink()) reject('Tar parent path is not a private real directory.');
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+      await mkdir(current, { mode: 0o700 });
+    }
+  }
+}
+
+/** Bounded tar.gz extraction. No symlinks, hardlinks, devices, sparse files or writes outside destination. */
+export async function extractSafeTarGz(archive, destination, { signal, maxExpanded = MAX_EXPANDED, maxEntries = MAX_ENTRIES } = {}) {
+  aborted(signal);
+  await mkdir(destination, { recursive: true, mode: 0o700 });
+  if ((await lstat(destination)).isSymbolicLink()) reject('Archive destination must not be a symlink.');
+  const gunzip = createGunzip();
+  const source = Readable.from(archive);
+  const input = source.pipe(gunzip);
+  const iterator = input[Symbol.asyncIterator]();
+  let buffer = Buffer.alloc(0);
+  let expanded = 0;
+  let done = false;
+  const stop = () => { source.destroy(); input.destroy(new EnvironmentError('cancelled', 'Runtime extraction was cancelled.')); };
+  signal?.addEventListener('abort', stop, { once: true });
+  const take = async length => {
+    while (buffer.length < length && !done) {
+      aborted(signal);
+      const next = await iterator.next();
+      done = next.done === true;
+      if (!done) {
+        expanded += next.value.length;
+        if (expanded > maxExpanded) reject('Archive expands beyond the allowed size.');
+        buffer = Buffer.concat([buffer, next.value]);
+      }
+    }
+    if (buffer.length < length) reject('Tar contains a truncated record.');
+    const value = buffer.subarray(0, length);
+    buffer = buffer.subarray(length);
+    return value;
+  };
+  const names = new Set();
+  let entries = 0;
+  let globalPax = {};
+  let localPax = {};
+  let longName = null;
+  try {
+    for (;;) {
+      const header = await take(BLOCK);
+      if (header.every(byte => byte === 0)) {
+        const second = await take(BLOCK);
+        if (!second.every(byte => byte === 0)) reject('Tar end-of-archive marker is invalid.');
+        while (!done) {
+          const next = await iterator.next();
+          done = next.done === true;
+          if (!done) {
+            expanded += next.value.length;
+            if (expanded > maxExpanded || next.value.some(byte => byte !== 0)) reject('Archive has excessive or nonzero trailing data.');
+          }
+        }
+        if (buffer.some(byte => byte !== 0)) reject('Archive has nonzero trailing data.');
+        break;
+      }
+      entries++;
+      if (entries > maxEntries) reject('Archive contains too many entries.');
+      const expectedChecksum = number(header, 148, 8);
+      let actualChecksum = 0;
+      for (let index = 0; index < BLOCK; index++) actualChecksum += index >= 148 && index < 156 ? 32 : header[index];
+      if (expectedChecksum !== actualChecksum) reject('Tar header checksum is invalid.');
+      const type = String.fromCharCode(header[156] || 48);
+      let size = number(header, 124, 12);
+      const metadata = { ...globalPax, ...localPax };
+      if (metadata.size !== undefined) {
+        if (!/^[0-9]+$/.test(metadata.size)) reject('PAX size is invalid.');
+        size = Number(metadata.size);
+      }
+      if (!Number.isSafeInteger(size) || size < 0 || size > MAX_ENTRY || size > maxExpanded) reject('Archive entry exceeds the allowed size.');
+      if (['x', 'g', 'L'].includes(type)) {
+        if (size > MAX_METADATA) reject('Tar metadata exceeds its bound.');
+        const data = await take(Math.ceil(size / BLOCK) * BLOCK);
+        if (type === 'L') longName = data.subarray(0, size).toString('utf8').replace(/\0.*$/s, '');
+        else if (type === 'g') globalPax = { ...globalPax, ...pax(data.subarray(0, size)) };
+        else localPax = pax(data.subarray(0, size));
+        continue;
+      }
+      if (type !== '0' && type !== '5') reject('Archive links and special file types are forbidden.');
+      const prefix = string(header, 345, 155);
+      const name = safeName(metadata.path || longName || [prefix, string(header, 0, 100)].filter(Boolean).join('/'));
+      localPax = {};
+      longName = null;
+      const canonical = name.toLowerCase();
+      if (names.has(canonical)) reject('Archive contains duplicate or case-colliding paths.');
+      names.add(canonical);
+      const target = path.resolve(destination, ...name.split('/'));
+      const relative = path.relative(destination, target);
+      if (relative.startsWith('..') || path.isAbsolute(relative)) reject('Archive path escapes its private directory.');
+      if (type === '5') {
+        if (size !== 0) reject('Tar directory has nonzero content.');
+        await ensureDirectory(destination, name);
+      } else {
+        await ensureDirectory(destination, name.includes('/') ? name.slice(0, name.lastIndexOf('/')) : '');
+        const data = await take(Math.ceil(size / BLOCK) * BLOCK);
+        await writeFile(target, data.subarray(0, size), { flag: 'wx', mode: 0o600 });
+      }
+    }
+    return { entries, expandedBytes: expanded };
+  } catch (error) {
+    if (error instanceof EnvironmentError) throw error;
+    throw new EnvironmentError('runtime_archive_invalid', `Cannot extract locked tar.gz: ${error?.message || error}`);
+  } finally {
+    signal?.removeEventListener('abort', stop);
+    source.destroy();
+    input.destroy();
+  }
+}

package/lib/typert-environment.mjs

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+
+// Hand-authored against DSH rc.5 InvocationDescriptor / TypertContribution.
+// The Client embeds this package's own descriptor, never a Harness UI module.
+export const IOS_ENVIRONMENT_PACKAGE = 'dsh-ios-webview-app-control';
+export const IOS_ENVIRONMENT_SERVICE = 'iosEnvironment';
+export const ENVIRONMENT_PHASES = Object.freeze([
+  'unprepared', 'checking', 'downloading', 'creating', 'installing', 'verifying',
+  'ready', 'failed', 'cancelled',
+]);
+
+export const EnvironmentSnapshotSchema = z.strictObject({
+  phase: z.enum(ENVIRONMENT_PHASES),
+  busy: z.boolean(),
+  step: z.string().max(256),
+  progress: z.strictObject({
+    completedBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    totalBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+  }).nullable().optional(),
+  python: z.strictObject({
+    path: z.string().max(8192),
+    version: z.string().max(128),
+    source: z.enum(['host', 'private']),
+    abi: z.string().max(128).optional(),
+  }).nullable().optional(),
+  runtimeDir: z.string().max(8192).optional(),
+  pymobiledevice3: z.string().max(128).optional(),
+  error: z.strictObject({
+    code: z.string().max(128),
+    message: z.string().max(2048),
+  }).nullable().optional(),
+});
+
+/** Only named public environment fields cross the Remote boundary. */
+export function projectEnvironmentSnapshot(raw) {
+  const snapshot = { phase: raw?.phase, busy: raw?.busy, step: raw?.step ?? raw?.phase };
+  if (raw?.progress === null) snapshot.progress = null;
+  else if (raw?.progress !== undefined) {
+    snapshot.progress = { completedBytes: raw.progress.completedBytes };
+    if (raw.progress.totalBytes !== undefined) snapshot.progress.totalBytes = raw.progress.totalBytes;
+  }
+  if (raw?.python === null) snapshot.python = null;
+  else if (raw?.python !== undefined) {
+    snapshot.python = { path: raw.python.path, version: raw.python.version, source: raw.python.source };
+    if (raw.python.abi !== undefined) snapshot.python.abi = raw.python.abi;
+  }
+  for (const key of ['runtimeDir', 'pymobiledevice3']) {
+    if (raw?.[key] !== undefined) snapshot[key] = raw[key];
+  }
+  if (raw?.error === null) snapshot.error = null;
+  else if (raw?.error !== undefined) snapshot.error = { code: raw.error.code, message: raw.error.message };
+  return EnvironmentSnapshotSchema.parse(snapshot);
+}
+
+export const environmentSnapshotCodec = Object.freeze({
+  mode: 'strict',
+  typeSymbol: `${IOS_ENVIRONMENT_PACKAGE}#EnvironmentSnapshot`,
+  create: () => EnvironmentSnapshotSchema,
+  // Gateway does not parse Host results itself; enforce the output boundary too.
+  encode: value => EnvironmentSnapshotSchema.parse(value),
+  decode: value => EnvironmentSnapshotSchema.parse(value),
+});
+
+export const environmentInvocations = Object.freeze(
+  ['status', 'prepare', 'cancel', 'cleanup', 'follow'].map(method => Object.freeze({
+    id: `${IOS_ENVIRONMENT_PACKAGE}#${IOS_ENVIRONMENT_SERVICE}/${method}`,
+    service: IOS_ENVIRONMENT_SERVICE,
+    namespace: IOS_ENVIRONMENT_SERVICE,
+    method,
+    invocation: Object.freeze({ kind: 'direct' }),
+    parameters: Object.freeze([]),
+    cancellation: Object.freeze({ parameter: 'signal' }),
+    ...(method === 'follow' ? { mode: 'stream' } : {}),
+    result: environmentSnapshotCodec,
+  })),
+);
+
+export const environmentHostContribution = Object.freeze({
+  package: IOS_ENVIRONMENT_PACKAGE,
+  face: 'host',
+  schemas: Object.freeze([{ name: 'EnvironmentSnapshot', create: () => EnvironmentSnapshotSchema }]),
+  model: Object.freeze({
+    services: [{
+      key: IOS_ENVIRONMENT_SERVICE,
+      exportName: 'IosEnvironmentService',
+      description: 'Host-owned Python environment preparation; never contacts a phone.',
+      tags: [],
+      members: environmentInvocations.map(({ method }) => ({
+        kind: 'method', name: method,
+        signature: method === 'follow'
+          ? 'follow(signal: AbortSignal): AsyncIterable<EnvironmentSnapshot>'
+          : `${method}(signal: AbortSignal): Promise<EnvironmentSnapshot>`,
+      })),
+      types: [{
+        name: 'EnvironmentSnapshot',
+        declaration: 'export interface EnvironmentSnapshot { readonly phase: "unprepared" | "checking" | "downloading" | "creating" | "installing" | "verifying" | "ready" | "failed" | "cancelled"; readonly busy: boolean; readonly step: string; readonly progress?: { readonly completedBytes: number; readonly totalBytes?: number } | null; readonly python?: { readonly path: string; readonly version: string; readonly source: "host" | "private"; readonly abi?: string } | null; readonly runtimeDir?: string; readonly pymobiledevice3?: string; readonly error?: { readonly code: string; readonly message: string } | null; }',
+      }],
+    }],
+    objects: [],
+    events: [],
+  }),
+  invocations: environmentInvocations,
+});

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "iOS WebView App Control",
+    "description": "This plugin controls confirmed iOS WebView/hybrid targets through an existing local bridge, with per-operation approval and session-owned leases. Its limits do not describe other DSH tools."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "iOS WebView 应用控制",
+    "description": "本插件通过已有本机桥接控制已确认的 iOS WebView／混合应用，逐次审批并使用会话专属设备租约。其能力限制不代表 DSH 会话中其它工具的能力。"
+  }
+}

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "dsh-ios-webview-app-control",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.2",
+  "description": "Business-free DSH tools for inspectable iOS WebView/hybrid apps only.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.18.0",
+    "dsh": ">=0.2.1-rc.5 <0.3.0"
+  },
+  "main": "./lib/plugin.mjs",
+  "exports": {
+    ".": "./lib/plugin.mjs",
+    "./core": "./lib/core/service.mjs",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "dsh-ios-webview-app-control": "./lib/cli.mjs"
+  },
+  "files": [
+    "lib/",
+    "resources/",
+    "THIRD_PARTY_NOTICES.md",
+    "cordis.patch.yml",
+    "README.md",
+    "docs/",
+    "requirements.txt",
+    "LICENSE",
+    "CHANGELOG.md",
+    "locale/*.json",
+    "icon.svg",
+    "scripts/manage-desktop.ps1",
+    "scripts/verify-package.mjs",
+    "scripts/package-validation.mjs"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "external": ["zod"],
+      "inject": ["@deepseek-ai/dsh-client-ui-plugin-manager", "@deepseek-ai/dsh-client-ui-settings-plugins"]
+    }
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "node --test test/*.test.mjs",
+    "check": "node scripts/check.mjs",
+    "prepack": "npm run build && npm run check && npm test"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "~3.18.5",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-api-gateway": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-api-remote-access": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-typert-registry": "0.2.1-rc.5"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.5",
+    "@deepseek-ai/dsh-tools": "^0.2.1-rc.5",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.1-rc.5",
+    "@deepseek-ai/dsh-user-approval": "^0.2.1-rc.5",
+    "@deepseek-ai/dsh-llm": "^0.2.1-rc.5",
+    "@deepseek-ai/dsh-typert-protocol": "^0.2.1-rc.5"
+  }
+}

package/requirements.txt

@@ -0,0 +1 @@
+pymobiledevice3==11.45.0

package/resources/notices/PBS-LICENSE.bdb.txt

@@ -0,0 +1,126 @@
+The following is the license that applies to this copy of the Berkeley DB
+software.  For a license to use the Berkeley DB software under conditions
+other than those described here, or to purchase support for this software,
+please contact Oracle at berkeleydb-info_us@oracle.com.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+/*
+ * Copyright (c) 1990, 2013 Oracle and/or its affiliates.  All rights reserved.
+ *
+ * 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. Redistributions in any form must be accompanied by information on
+ *    how to obtain complete source code for the DB software and any
+ *    accompanying software that uses the DB software.  The source code
+ *    must either be included in the distribution or be available for no
+ *    more than the cost of distribution plus a nominal fee, and must be
+ *    freely redistributable under reasonable conditions.  For an
+ *    executable file, complete source code means the source code for all
+ *    modules it contains.  It does not include source code for modules or
+ *    files that typically accompany the major components of the operating
+ *    system on which the executable file runs.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ORACLE ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
+ * NON-INFRINGEMENT, ARE DISCLAIMED.  IN NO EVENT SHALL ORACLE 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.
+ */
+/*
+ * Copyright (c) 1990, 1993, 1994, 1995
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * 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. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
+ */
+/*
+ * Copyright (c) 1995, 1996
+ *	The President and Fellows of Harvard University.  All rights reserved.
+ *
+ * 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. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY HARVARD AND ITS CONTRIBUTORS ``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 HARVARD OR ITS CONTRIBUTORS 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.
+ */
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2005 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * 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. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */

package/resources/notices/PBS-LICENSE.bzip2.txt

@@ -0,0 +1,37 @@
+This program, "bzip2", the associated library "libbzip2", and all
+documentation, are copyright (C) 1996-2010 Julian R Seward.  All
+rights reserved.
+
+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. The origin of this software must not be misrepresented; you must
+   not claim that you wrote the original software.  If you use this
+   software in a product, an acknowledgment in the product
+   documentation would be appreciated but is not required.
+
+3. Altered source versions must be plainly marked as such, and must
+   not be misrepresented as being the original software.
+
+4. 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.
+
+Julian Seward, jseward@bzip.org
+bzip2/libbzip2 version 1.0.6 of 6 September 2010