carthagent 1.0.7 → 1.1.0-preview.13

package/tools/owned-shell-observer/index.ts

@@ -0,0 +1,16 @@
+import { appendFileSync } from 'node:fs';
+import { Plugin } from '@opencode/plugin';
+
+export default Plugin.define({
+  id: 'ctg.owned-shell-observer',
+  async setup(ctx) {
+    const file = process.env.CTG_OWNED_SHELL_CAPTURE;
+    if (!file) throw new Error('CTG_OWNED_SHELL_CAPTURE is required by the offline shell provenance probe');
+    const registration = await ctx.shell.hook('create.before', event => {
+      if (event.command.includes('owned-identical-shell') || event.command.includes('process.stdout.write')) {
+        appendFileSync(file, `${JSON.stringify({ command: event.command, sessionID: event.sessionID ?? null, origin: event.origin ?? null, callID: event.callID ?? null })}\n`);
+      }
+    });
+    return () => registration.dispose();
+  },
+});

package/tools/owned-shell-observer/package.json

@@ -0,0 +1 @@
+{"type":"module","main":"./index.ts","exports":"./index.ts"}

package/tools/owned-visual-clear-env.py

@@ -0,0 +1,48 @@
+"""Platform-neutral child-environment allowlist for the owned visual-clear probe."""
+from pathlib import Path
+
+SAFE_PARENT_ENV = ('PATH', 'LANG', 'LC_ALL')
+SAFE_WINDOWS_ENV = ('SystemRoot', 'WINDIR', 'COMSPEC', 'PATHEXT')
+TUI_ENV_KEYS = frozenset((*SAFE_PARENT_ENV, *SAFE_WINDOWS_ENV, 'HOME', 'USERPROFILE',
+    'APPDATA', 'LOCALAPPDATA', 'XDG_CONFIG_HOME', 'XDG_DATA_HOME', 'XDG_STATE_HOME',
+    'XDG_CACHE_HOME', 'OPENCODE_TEST_HOME', 'OPENCODE_DB', 'OPENCODE_CONFIG',
+    'OPENCODE_CONFIG_DIR', 'OPENCODE_CONFIG_PROJECT_DISABLE',
+    'OPENCODE_DISABLE_MODELS_FETCH', 'OPENCODE_DISABLE_CLAUDE_CODE',
+    'OPENCODE_DISABLE_CLAUDE_CODE_SKILLS', 'OPENCODE_DISABLE_AUTOUPDATE',
+    'CTG_OPENCODE_HOME', 'TERM', 'COLORTERM', 'OPENCODE_PASSWORD',
+    'OPENCODE_SERVER_PASSWORD', 'OPENCODE_SERVER_USERNAME'))
+FIXTURE_ENV_KEYS = TUI_ENV_KEYS | frozenset((
+    'CTG_OWNED_OPENCODE_RUNTIME', 'CTG_TEST_RUNTIME_RELEASE_MANIFEST'))
+
+
+def filtered_parent_environment(source, home):
+    """Build a child baseline from a short allowlist, never ambient credentials."""
+    result = {key: source[key] for key in (*SAFE_PARENT_ENV, *SAFE_WINDOWS_ENV)
+              if key in source}
+    result['PATH'] = result.get('PATH', '/usr/bin:/bin')
+    result['LANG'] = result.get('LANG', 'C.UTF-8')
+    result['HOME'] = str(home)
+    result['USERPROFILE'] = str(home)
+    return result
+
+
+def fixture_environment(source, home, owned_root, release_manifest):
+    """Environment for fixture/preflight Node children; selectors are paths, not secrets."""
+    result = filtered_parent_environment(source, home)
+    result.update({
+        'CTG_OWNED_OPENCODE_RUNTIME': str(owned_root),
+        'CTG_TEST_RUNTIME_RELEASE_MANIFEST': str(release_manifest),
+        'XDG_CONFIG_HOME': str(Path(home) / 'config'),
+        'XDG_DATA_HOME': str(Path(home) / 'data'),
+        'XDG_STATE_HOME': str(Path(home) / 'state'),
+        'XDG_CACHE_HOME': str(Path(home) / 'cache'),
+    })
+    return result
+
+
+def assert_clean_child_environment(env, allowed=TUI_ENV_KEYS):
+    if any(key.casefold() == 'ctg_runtime_github_token' for key in env):
+        raise AssertionError('child environment contains reserved runtime download credential')
+    unexpected = sorted(set(env) - allowed)
+    if unexpected:
+        raise AssertionError(f'child environment contains non-allowlisted names: {unexpected}')

package/tools/owned-visual-clear-model.py

@@ -0,0 +1,21 @@
+"""Pure canonical projections used by the owned visual-clear proof."""
+import json
+
+
+def canonical_conversation(messages):
+    """Normalize API message order without dropping IDs, content, or metadata."""
+    return sorted(messages, key=lambda message: json.dumps(
+        message, sort_keys=True, separators=(',', ':'), ensure_ascii=False))
+
+
+def latest_message(messages):
+    """Return the latest message from the native message.list() API response.
+
+    The API returns the list newest-first (including non-conversational events
+    such as the trailing idle message). Keep cutoff selection separate from
+    canonical conversation ordering, which intentionally sorts for equality.
+    """
+    data = messages.get('data', [])
+    if not data:
+        raise ValueError('message.list() returned no messages')
+    return data[0]

package/tools/pinned-owned-runtime-inputs.mjs

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { readFile, realpath } from 'node:fs/promises';
+import path from 'node:path';
+
+/** Read the pinned recipe constants and the exact patch selected by that recipe. */
+export async function readPinnedOwnedRuntimeInputs(repoRoot) {
+  const canonicalRoot = await realpath(path.resolve(repoRoot));
+  const recipe = await readFile(path.join(canonicalRoot, 'script/ctg/build-owned-runtime.sh'), 'utf8');
+  const constant = (name) => {
+    const matches = [...recipe.matchAll(new RegExp(`^${name}="([^"\\r\\n]+)"$`, 'gm'))];
+    if (matches.length !== 1) throw new Error(`Build recipe must contain exactly one literal ${name}`);
+    return matches[0][1];
+  };
+  const patchAssignments = [...recipe.matchAll(/^\s*patch_file\s*=.*$/gm)];
+  if (patchAssignments.length !== 1) throw new Error('Build recipe must contain exactly one literal ROOT-relative patch_file');
+  const patchFileMatch = patchAssignments[0][0].match(/^\s*patch_file="\$ROOT\/([^"\r\n]+)"\s*$/);
+  if (!patchFileMatch) throw new Error('Build recipe patch_file must be a literal ROOT-relative path');
+  const patchFile = patchFileMatch[1];
+  if (!patchFile.startsWith('docs/patches/')
+    || patchFile.includes('\\')
+    || path.posix.isAbsolute(patchFile)
+    || path.posix.normalize(patchFile) !== patchFile
+    || patchFile.split('/').some((part) => part === '.' || part === '..' || part === '')) {
+    throw new Error('Build recipe patch_file must be a canonical docs/patches-relative path');
+  }
+  const patchPath = path.resolve(canonicalRoot, ...patchFile.split('/'));
+  const relativePatchPath = path.relative(canonicalRoot, patchPath);
+  if (relativePatchPath.startsWith(`..${path.sep}`) || relativePatchPath === '..' || path.isAbsolute(relativePatchPath)) {
+    throw new Error('Build recipe patch_file escapes the repository root');
+  }
+  const canonicalPatchPath = await realpath(patchPath);
+  const actualRelativePatchPath = path.relative(canonicalRoot, canonicalPatchPath);
+  if (actualRelativePatchPath.startsWith(`..${path.sep}`) || actualRelativePatchPath === '..' || path.isAbsolute(actualRelativePatchPath)) {
+    throw new Error('Build recipe patch_file resolves outside the repository root');
+  }
+  const patch = await readFile(canonicalPatchPath);
+  const expectedPatchSha256 = constant('EXPECTED_PATCH').toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(expectedPatchSha256)) throw new Error('Build recipe EXPECTED_PATCH is not a SHA-256 digest');
+  const patchSha256 = createHash('sha256').update(patch).digest('hex');
+  if (patchSha256 !== expectedPatchSha256) throw new Error('Pinned patch bytes do not match the build recipe');
+  return {
+    sourceRevision: constant('EXPECTED_SOURCE'),
+    patchSha256,
+    lockSha256: constant('EXPECTED_LOCK').toLowerCase(),
+  };
+}

package/tools/prepare-native-manual.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import { mkdir, writeFile, rm } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { spawnSync } from 'node:child_process';
+import { resolve, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { acquireOwnedRuntime } from '../lib/opencode/runtime-artifact.mjs';
+import { readManualRuntimeManifest } from './manual-runtime-manifest.mjs';
+import { preflightNativeTestRuntimeArtifact } from './native-runtime-identity.mjs';
+import { createManualProjects } from './native-manual-projects.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+
+export async function prepareManualKit(
+  directory,
+  { assetsDirectory, packages = 128, runtimeManifest, manifestSha256: expectedManifestSha256 } = {},
+) {
+  if (!Number.isInteger(packages) || packages < 2 || packages > 1024)
+    throw Error('packages must be an integer from 2 to 1024');
+  const kit = resolve(directory);
+  await mkdir(kit, { mode: 0o700 });
+  try {
+    const { manifest, manifestPath, manifestSha256 } = await readManualRuntimeManifest({ runtimeManifest, manifestSha256: expectedManifestSha256 });
+    const platform = process.platform === 'win32' ? 'windows' : process.platform;
+    const target = `${platform}-${process.arch}`;
+    const asset = manifest.assets[target];
+    if (!asset) throw Error(`The candidate does not support ${target}`);
+    const assets = assetsDirectory && resolve(assetsDirectory);
+    const ownedRoot = await acquireOwnedRuntime({
+      releaseVersion: manifest.releaseVersion,
+      platform,
+      arch: process.arch,
+      expectedArchiveSha256: asset.archiveSha256,
+      expectedExecutableSha256: asset.executableSha256,
+      expectedSourceRevision: manifest.sourceRevision,
+      expectedPatchSha256: manifest.patchSha256,
+      expectedLockSha256: manifest.lockSha256,
+      expectedCompatibilityVersion: manifest.compatibilityVersion,
+      expectedRuntimeVersion: manifest.runtimeVersion,
+      expectedChannel: `ctg.${manifest.compatibilityVersion}`,
+      baseUrl: `https://github.com/B-icy/Carthagent/releases/download/v${manifest.releaseVersion}`,
+      cacheRoot: join(kit, 'runtimes'),
+      ...(assets ? { fetchImpl: async (url) => {
+        if (
+          decodeURIComponent(new URL(url).pathname.split('/').at(-1)) !==
+          asset.name
+        )
+          throw Error('Unexpected runtime asset requested');
+        return new Response(
+          Readable.toWeb(createReadStream(join(assets, asset.name))),
+        );
+      } } : {}),
+    });
+    const { identity } = await preflightNativeTestRuntimeArtifact({
+      ownedRoot,
+      expectedManifestPath: manifestPath,
+      env: {},
+    });
+    const projects = await createManualProjects(join(kit, 'projects'), {
+      packages,
+    });
+    const source = spawnSync('git', ['rev-parse', 'HEAD'], {
+      cwd: root,
+      encoding: 'utf8',
+    });
+    const status = spawnSync('git', ['status', '--porcelain'], {
+      cwd: root,
+      encoding: 'utf8',
+    });
+    const record = {
+      version: 1,
+      createdAt: new Date().toISOString(),
+      releaseVersion: manifest.releaseVersion,
+      manifestSource: runtimeManifest ? 'explicit-pinned-candidate' : 'packaged-release',
+      sourceCommit:
+        source.status === 0 ? source.stdout.trim() : 'source-tarball',
+      sourceDirty: status.status === 0 ? Boolean(status.stdout.trim()) : null,
+      target,
+      runtime: `runtimes/${manifest.releaseVersion}/${target}`,
+      binarySha256: identity.binarySha256,
+      manifestSha256,
+      projects: projects.projects,
+      packages,
+    };
+    await writeFile(
+      join(kit, 'manual-kit.json'),
+      JSON.stringify(record, null, 2) + '\n',
+    );
+    await writeFile(join(kit, '.gitignore'), '*\n');
+    const manifestArgs = runtimeManifest ? ` --manifest ${JSON.stringify(manifestPath)} --manifest-sha256 ${manifestSha256}` : '';
+    console.log(
+      `Manual kit ready: ${kit}\nVerified ${target}: ${identity.binarySha256}\nOffline UI: node tools/native-manual.mjs ${JSON.stringify(kit)} tiny${manifestArgs}\nRead docs/native-manual-testing.md before --live. This is not a released/default install.`,
+    );
+    return record;
+  } catch (error) {
+    await rm(kit, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(resolve(process.argv[1])).href
+) {
+  const [directory, ...args] = process.argv.slice(2);
+  if (!directory || args.includes('--help'))
+    throw Error(
+      'Usage: node tools/prepare-native-manual.mjs <new-directory> [--assets <directory>] [--packages 128] [--manifest <file> --manifest-sha256 <digest>]',
+    );
+  const options = {};
+  for (let i = 0; i < args.length; i += 2) {
+    const value = args[i + 1];
+    if (!value || !['--assets', '--packages', '--manifest', '--manifest-sha256'].includes(args[i]))
+      throw Error(`Invalid option ${args[i]}`);
+    if (args[i] === '--assets') options.assetsDirectory = value;
+    else if (args[i] === '--packages') options.packages = Number(value);
+    else if (args[i] === '--manifest') options.runtimeManifest = value;
+    else options.manifestSha256 = value;
+  }
+  await prepareManualKit(directory, options);
+}