subconscious-cli 6.1.0 → 6.2.1

package/bin/runbook/subconscious-code/agent.json

@@ -1,156 +0,0 @@
-{
-  "id": "subconscious-code",
-  "command": "marathon",
-  "aliases": ["sc", "subconscious-code"],
-  "name": "Marathon",
-  "description": "Launch the native Subconscious coding agent with the active profile, gateway, and model.",
-  "protocol": "openai",
-  "homepage": "https://github.com/subconscious-systems/subconscious-code",
-  "install": {
-    "commands": {
-      "darwin": "subc marathon install",
-      "linux": "subc marathon install",
-      "win32": "subc marathon install"
-    },
-    "method": "github-release",
-    "repository": "subconscious-systems/subconscious-code",
-    "version": "latest",
-    "pin_env": "SC_CODE_VERSION",
-    "asset": "marathon-{target}.tar.gz",
-    "checksum": "marathon-{target}.tar.gz.sha256",
-    "legacy_asset": "sc-{target}.tar.gz",
-    "targets": [
-      "aarch64-apple-darwin",
-      "x86_64-apple-darwin",
-      "aarch64-unknown-linux-musl",
-      "x86_64-unknown-linux-musl"
-    ],
-    "install_dir": "~/.local/bin",
-    "install_dir_env": "SC_INSTALL_DIR",
-    "minimum_version": null,
-    "verified": true,
-    "windows_targets": ["x86_64-pc-windows-msvc", "aarch64-pc-windows-msvc"],
-    "windows_assets": [
-      "marathon-{target}.zip",
-      "marathon-{target}.exe",
-      "sc-{target}.zip",
-      "sc-{target}.exe"
-    ],
-    "note": "Windows installs come from the native launcher, which takes the first asset in windows_assets that the release has, plus its .sha256."
-  },
-  "runbook": {
-    "mode": "launch",
-    "setup_script": "install.sh",
-    "setup_actions": ["install"],
-    "setup_needs_auth": false,
-    "binary_install_script": "install.sh"
-  },
-  "help": {
-    "usage": "subc [-p NAME] marathon [help|install] [Marathon arguments...]",
-    "behavior": "Launches the native Subconscious coding agent with the selected profile gateway, credential, and model.",
-    "options": [
-      ["help", "Show this help"],
-      [
-        "install",
-        {
-          "win32": "Install a verified Windows release, when published upstream",
-          "default": "Install the latest precompiled Linux or macOS release"
-        }
-      ],
-      ["--model MODEL", "Override the profile model for this launch"]
-    ],
-    "args": ["ARGS...", "Pass arguments directly to Marathon"]
-  },
-  "sessions": { "key": "sc", "portable": false },
-  "prerequisites": [
-    { "command": "gh|curl", "needed_for": "install", "required": true },
-    {
-      "command": "sha256sum|shasum",
-      "needed_for": "install",
-      "required": true
-    },
-    { "command": "tar", "needed_for": "install", "required": true }
-  ],
-  "launch": {
-    "argv": ["marathon", "{args}"],
-    "headless_argv": ["marathon", "--print={prompt}", "{args}"],
-    "headless_platforms": ["darwin", "linux"],
-    "resume": ["--resume", "{sessionFile}"],
-    "persistent_setup": false
-  },
-  "inputs": [
-    {
-      "name": "SC_API_KEY",
-      "label": "Subconscious Code API key",
-      "description": "Subconscious Code credential override; blank uses API_KEY.",
-      "type": "secret"
-    }
-  ],
-  "env": [
-    {
-      "name": "SC_API_KEY",
-      "value": "{apiKey}",
-      "description": "Gateway credential."
-    },
-    {
-      "name": "SC_BASE_URL",
-      "value": "{baseUrlV1}",
-      "description": "OpenAI-compatible base URL for model requests."
-    },
-    {
-      "name": "SC_DLR_URL",
-      "value": "{baseUrl}",
-      "description": "Gateway origin for Marathon's DLR feature.",
-      "note": "What DLR does is defined in the Marathon binary, not in this repo."
-    },
-    {
-      "name": "SC_DLR_ENABLED",
-      "value": "true",
-      "description": "Turns Marathon's DLR feature on.",
-      "note": "What DLR does is defined in the Marathon binary, not in this repo."
-    },
-    {
-      "name": "SC_MODEL",
-      "value": "{model}",
-      "description": "Model for the session."
-    }
-  ],
-  "config": [],
-  "capabilities": {
-    "compaction": {
-      "default": "unknown",
-      "on": {
-        "set_by_subc": false,
-        "kind": null,
-        "name": null,
-        "value": null,
-        "verified": false,
-        "note": "subc sets no compaction knob; Marathon's built-in behaviour applies."
-      },
-      "off": {
-        "set_by_subc": false,
-        "kind": null,
-        "name": null,
-        "value": null,
-        "verified": false,
-        "note": "No off knob is set or documented by subc."
-      },
-      "threshold": {
-        "set_by_subc": false,
-        "kind": null,
-        "name": null,
-        "value": null,
-        "verified": false,
-        "note": "No threshold knob is set or documented by subc."
-      }
-    },
-    "mcp": {
-      "configured_by_subc": false,
-      "transports": null,
-      "verified": false,
-      "note": "subc configures no MCP servers. Transports Marathon supports are not described in this repo."
-    },
-    "headers": [],
-    "hooks": []
-  }
-}

package/bin/runbook/subconscious-code/install.sh

@@ -1,154 +0,0 @@
-#!/usr/bin/env bash
-# Install a precompiled Marathon release for the current platform.
-
-set -euo pipefail
-
-REPOSITORY="subconscious-systems/subconscious-code"
-REPOSITORY_URL="https://github.com/${REPOSITORY}"
-INSTALL_DIR="${SC_INSTALL_DIR:-${HOME}/.local/bin}"
-
-usage() {
-  cat <<'EOF'
-Usage: subc marathon install
-
-Install the latest Marathon release. Linux downloads and verifies the
-published static binary. macOS downloads and verifies the matching native binary.
-EOF
-}
-
-case "${1:-install}" in
-  install) ;;
-  help|-h|--help)
-    usage
-    exit 0
-    ;;
-  *)
-    echo "error: unsupported Marathon setup action: $1" >&2
-    usage >&2
-    exit 2
-    ;;
-esac
-
-release_tag() {
-  if [[ -n "${SC_CODE_VERSION:-}" ]]; then
-    printf '%s\n' "${SC_CODE_VERSION#v}"
-    return
-  fi
-  if command -v gh >/dev/null 2>&1; then
-    local tag
-    tag="$(gh release view --repo "$REPOSITORY" --json tagName --jq '.tagName' 2>/dev/null || true)"
-    if [[ -n "$tag" ]]; then
-      printf '%s\n' "${tag#v}"
-      return
-    fi
-  fi
-  if command -v curl >/dev/null 2>&1; then
-    local tag
-    tag="$(curl -fsSL "https://api.github.com/repos/${REPOSITORY}/releases/latest" 2>/dev/null \
-      | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
-      | head -n 1 || true)"
-    if [[ -n "$tag" ]]; then
-      printf '%s\n' "${tag#v}"
-      return
-    fi
-  fi
-  return 1
-}
-
-platform="$(uname -s)"
-architecture="$(uname -m)"
-version="$(release_tag || true)"
-
-if [[ -z "$version" ]]; then
-  echo "error: no published Marathon release is available yet" >&2
-  echo "The release may still be building. Retry subc marathon install after it finishes." >&2
-  exit 1
-fi
-
-case "${platform}:${architecture}" in
-  Darwin:arm64) target="aarch64-apple-darwin" ;;
-  Darwin:x86_64) target="x86_64-apple-darwin" ;;
-  Linux:aarch64|Linux:arm64) target="aarch64-unknown-linux-musl" ;;
-  Linux:x86_64|Linux:amd64) target="x86_64-unknown-linux-musl" ;;
-  *)
-    echo "error: unsupported platform or architecture: ${platform} ${architecture}" >&2
-    exit 1
-    ;;
-esac
-
-executable="marathon"
-asset="${executable}-${target}.tar.gz"
-checksum="${asset}.sha256"
-work_dir="$(mktemp -d "${TMPDIR:-/tmp}/subc-marathon-install.XXXXXX")"
-staging=''
-cleanup() {
-  rm -f "$work_dir/$asset" "$work_dir/$checksum" "$work_dir/sc" "$work_dir/marathon"
-  if [[ -n "$staging" ]]; then rm -f "$staging"; fi
-  rmdir "$work_dir" 2>/dev/null || true
-}
-trap cleanup EXIT HUP INT TERM
-
-echo "Downloading Marathon v${version} for ${target}..."
-if command -v gh >/dev/null 2>&1 \
-  && assets="$(gh release view "v${version}" --repo "$REPOSITORY" --json assets --jq '.assets[].name' 2>/dev/null)"; then
-  if ! printf '%s\n' "$assets" | grep -Fxq "$asset"; then
-    # Pinned legacy releases are still installed as marathon, never as sc.
-    executable="sc"
-    asset="${executable}-${target}.tar.gz"
-    checksum="${asset}.sha256"
-  fi
-  if ! printf '%s\n' "$assets" | grep -Fxq "$asset" \
-    || ! printf '%s\n' "$assets" | grep -Fxq "$checksum"; then
-    echo "error: release is missing $asset or $checksum" >&2
-    exit 1
-  fi
-  gh release download "v${version}" --repo "$REPOSITORY" \
-    --pattern "$asset" --pattern "$checksum" --dir "$work_dir"
-else
-  command -v curl >/dev/null 2>&1 || {
-    echo "error: curl is required to download Marathon" >&2
-    exit 1
-  }
-  release_url="${REPOSITORY_URL}/releases/download/v${version}"
-  status="$(curl -sSL -w '%{http_code}' "${release_url}/${asset}" -o "$work_dir/$asset")"
-  if [[ "$status" == 404 ]]; then
-    rm -f "$work_dir/$asset"
-    executable="sc"
-    asset="${executable}-${target}.tar.gz"
-    checksum="${asset}.sha256"
-    curl -fL "${release_url}/${asset}" -o "$work_dir/$asset"
-  elif [[ "$status" != 200 ]]; then
-    echo "error: Marathon download failed (HTTP $status)" >&2
-    exit 1
-  fi
-  curl -fL "${release_url}/${checksum}" -o "$work_dir/$checksum"
-fi
-
-if command -v sha256sum >/dev/null 2>&1; then
-  (cd "$work_dir" && sha256sum --check "$checksum")
-elif command -v shasum >/dev/null 2>&1; then
-  expected="$(awk '{print $1}' "$work_dir/$checksum")"
-  actual="$(shasum -a 256 "$work_dir/$asset" | awk '{print $1}')"
-  [[ "$actual" == "$expected" ]] || {
-    echo "error: Marathon checksum verification failed" >&2
-    exit 1
-  }
-else
-  echo "error: sha256sum or shasum is required to verify the download" >&2
-  exit 1
-fi
-
-tar -xzf "$work_dir/$asset" -C "$work_dir" "$executable"
-if [[ ! -f "$work_dir/$executable" || -L "$work_dir/$executable" ]]; then
-  echo "error: release has no regular root $executable executable" >&2
-  exit 1
-fi
-mkdir -p "$INSTALL_DIR"
-if [[ -d "$INSTALL_DIR/marathon" ]]; then
-  echo "error: $INSTALL_DIR/marathon is a directory; refusing to replace it" >&2
-  exit 1
-fi
-staging="$(mktemp "$INSTALL_DIR/.marathon.XXXXXX")"
-install -m 0755 "$work_dir/$executable" "$staging"
-mv -f "$staging" "$INSTALL_DIR/marathon"
-echo "Installed Marathon v${version} to $INSTALL_DIR/marathon"

package/bin/windows/install.js

@@ -1,182 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { agentById, installCommands } from '../agent-data.js';
-import { powershellCommand, runWindows } from './process.js';
-
-const marathon = agentById('subconscious-code').install;
-const repository = marathon.repository;
-
-function npmInstall(command) {
-  const match = /^npm (?:i|install) -g ([@a-zA-Z0-9/._-]+)$/.exec(
-    command || '',
-  );
-  return match ? { command: 'npm', args: ['install', '-g', match[1]] } : null;
-}
-
-export function windowsInstallSpec(id, env = process.env) {
-  const install = installCommands(agentById(id)) || {};
-  const command = install.win32;
-  if (id === 'subconscious-code')
-    return { nativeRelease: true, display: 'subc marathon install' };
-  if (!command) return null; // Never fall back to a Linux installer.
-  if (id === 'claude-code') {
-    const primary = powershellCommand(
-      "$ErrorActionPreference = 'Stop'; Invoke-RestMethod 'https://claude.ai/install.ps1' | Invoke-Expression; if (-not $?) { exit 1 }",
-      env,
-    );
-    return {
-      ...primary,
-      display: command,
-      fallback: npmInstall(install.fallback),
-    };
-  }
-  const spec = npmInstall(command);
-  if (!spec) throw new Error(`No safe Windows installer is defined for ${id}`);
-  return { ...spec, display: command };
-}
-
-export function windowsReleaseAsset(release, arch = process.arch) {
-  const target = marathon.windows_targets.find((triple) =>
-    triple.startsWith({ x64: 'x86_64-', arm64: 'aarch64-' }[arch] ?? '-'),
-  );
-  if (!target)
-    throw new Error(
-      `Subconscious Code does not support Windows architecture ${arch}`,
-    );
-  // Pinned older releases are installed under the new executable name too.
-  // Never resolve or overwrite Windows' own sc.exe.
-  const names = marathon.windows_assets.map((name) =>
-    name.replaceAll('{target}', target),
-  );
-  const asset = names
-    .map((name) => release.assets?.find((asset) => asset.name === name))
-    .find(Boolean);
-  if (!asset)
-    throw new Error(
-      `Marathon ${release.tag_name || 'latest'} has no published native Windows ${arch} binary for subc marathon install.`,
-    );
-  const checksum = release.assets.find(
-    (candidate) => candidate.name === `${asset.name}.sha256`,
-  );
-  if (!checksum)
-    throw new Error(
-      `The Windows release is missing ${asset.name}.sha256; refusing an unverified installation.`,
-    );
-  return { asset, checksum };
-}
-
-export async function installWindowsSC(
-  env,
-  {
-    fetchImpl = fetch,
-    run = runWindows,
-    home = os.homedir(),
-    arch = process.arch,
-    log = console.log,
-  } = {},
-) {
-  const version = env.SC_CODE_VERSION?.replace(/^v/, '');
-  const endpoint = version
-    ? `tags/${encodeURIComponent(`v${version}`)}`
-    : 'latest';
-  const response = await fetchImpl(
-    `https://api.github.com/repos/${repository}/releases/${endpoint}`,
-    {
-      headers: { Accept: 'application/vnd.github+json' },
-      signal: AbortSignal.timeout(15000),
-    },
-  );
-  if (!response.ok)
-    throw new Error(
-      `Could not find a Subconscious Code release (HTTP ${response.status}).`,
-    );
-  const release = await response.json();
-  const { asset, checksum } = windowsReleaseAsset(release, arch);
-  const download = async (asset) => {
-    const url = new URL(asset.browser_download_url);
-    if (
-      url.origin !== 'https://github.com' ||
-      !url.pathname.startsWith(`/${repository}/releases/download/`)
-    )
-      throw new Error('Unexpected release download URL');
-    const response = await fetchImpl(url.href, {
-      signal: AbortSignal.timeout(120000),
-    });
-    if (!response.ok)
-      throw new Error(
-        `Download failed (HTTP ${response.status}): ${asset.name}`,
-      );
-    return Buffer.from(await response.arrayBuffer());
-  };
-  log(`Downloading Marathon ${release.tag_name} for Windows ${arch}...`);
-  const [binary, checksumText] = await Promise.all([
-    download(asset),
-    download(checksum),
-  ]);
-  const expected = checksumText.toString('utf8').trim().split(/\s+/)[0];
-  if (
-    !/^[a-f0-9]{64}$/i.test(expected) ||
-    createHash('sha256').update(binary).digest('hex') !== expected.toLowerCase()
-  )
-    throw new Error('Subconscious Code checksum verification failed');
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'subc-sc-install-'));
-  const installDir = path.resolve(
-    env.SC_INSTALL_DIR || path.join(home, '.local', 'bin'),
-  );
-  const destination = path.join(installDir, 'marathon.exe');
-  const staging = path.join(installDir, `marathon-${randomUUID()}.tmp`);
-  try {
-    const extracted = path.join(dir, 'marathon.exe');
-    if (asset.name.endsWith('.zip')) {
-      const archive = path.join(dir, 'release.zip');
-      await fs.writeFile(archive, binary, { flag: 'wx' });
-      // Extract only the exact root executable. No archive-controlled paths.
-      const executable = asset.name.startsWith('marathon-')
-        ? 'marathon.exe'
-        : 'sc.exe';
-      const spec = powershellCommand(
-        "$ErrorActionPreference = 'Stop'; Add-Type -AssemblyName System.IO.Compression.FileSystem; $z = [IO.Compression.ZipFile]::OpenRead($env:SUBC_ARCHIVE); try { $e = $z.GetEntry($env:SUBC_EXECUTABLE); if ($null -eq $e) { throw 'Archive has no expected root executable' }; [IO.Compression.ZipFileExtensions]::ExtractToFile($e, $env:SUBC_EXTRACTED, $false) } finally { $z.Dispose() }",
-        {
-          ...env,
-          SUBC_ARCHIVE: archive,
-          SUBC_EXTRACTED: extracted,
-          SUBC_EXECUTABLE: executable,
-        },
-      );
-      if (await run(spec.command, spec.args, { env: spec.env }))
-        throw new Error('Could not extract the Windows release');
-    } else await fs.writeFile(extracted, binary, { flag: 'wx' });
-    const magic = (await fs.readFile(extracted))
-      .subarray(0, 2)
-      .toString('ascii');
-    if (magic !== 'MZ') throw new Error('Release is not a Windows executable');
-    await fs.mkdir(installDir, { recursive: true });
-    await fs.copyFile(extracted, staging);
-    await fs.rename(staging, destination);
-    log(`Installed ${destination}. Run subc marathon to launch it.`);
-    return 0;
-  } finally {
-    await fs.rm(staging, { force: true });
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-}
-
-export async function installWindowsAgent(id, env, run = runWindows) {
-  const spec = windowsInstallSpec(id, env);
-  if (!spec) throw new Error('Install this agent separately, then rerun subc.');
-  if (spec.nativeRelease) return installWindowsSC(env, { run });
-  let code;
-  try {
-    code = await run(spec.command, spec.args, { env: spec.env || env });
-  } catch (error) {
-    if (!spec.fallback) throw error;
-    code = 1;
-  }
-  if (code && spec.fallback) {
-    console.error('Native installer failed; trying the npm package.');
-    code = await run(spec.fallback.command, spec.fallback.args, { env });
-  }
-  return code;
-}