Project Trust Security

const PROJECT_TRUST_PROMPT = 'prompt';

Unrecognized project /Users/username/suspicious-project

Untrusted projects run in Restricted Mode to protect your system.

Trusting this project would enable:
  - Composer autoload (vendor/autoload.php)
  - Local PsySH configuration (.psysh.php)

Trust and continue? (y/N)

const PROJECT_TRUST_ALWAYS = 'always';

return [
    'trustProject' => 'always',
];

export PSYSH_TRUST_PROJECT=true
psysh

const PROJECT_TRUST_NEVER = 'never';

return [
    'trustProject' => 'never',
];

export PSYSH_TRUST_PROJECT=false
psysh

psysh --trust-project

if ($arg === '--trust-project') {
    $forceTrust = true;
    $forceUntrust = false;
} elseif ($arg === '--no-trust-project') {
    $forceUntrust = true;
    $forceTrust = false;
}

psysh --no-trust-project

public function getProjectTrustFilePath(): ?string
{
    $configDir = $this->configPaths->currentConfigDir();
    if ($configDir === null) {
        return null;
    }

    return $configDir.'/trusted_projects.json';
}

[
  "/Users/username/my-project",
  "/Users/username/trusted-app",
  "/var/www/production-site"
]

public function saveTrustedProjectRoots(array $roots): bool
{
    $roots = array_values(array_unique(array_filter($roots, 'is_string')));
    $json = json_encode($roots, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
    if ($json === false) {
        return false;
    }

    return file_put_contents($trustFile, $json.PHP_EOL) !== false;
}

Warning: Unable to save trust settings. Trusting /path/to/project for this session only.

public function trustProjectRoot(string $root, ?OutputInterface $output = null): bool
{
    $root = $this->normalizeProjectRoot($root);
    $trustedRoots = $this->getTrustedProjectRoots();
    if (!in_array($root, $trustedRoots, true)) {
        $trustedRoots[] = $root;
    }

    if (!$this->saveTrustedProjectRoots($trustedRoots)) {
        if ($output !== null) {
            $this->warnTrustPersistenceFailed($root, $output);
        }
        $this->sessionTrustedRoots[] = $root;

        return true;
    }

    return true;
}

public function getProjectRoot(): ?string
{
    $root = $this->configPaths->projectRoot();
    if ($root === null) {
        return null;
    }

    return $this->normalizeProjectRoot($root);
}

public function normalizeProjectRoot(string $root): string
{
    $realRoot = realpath($root);
    if ($realRoot !== false) {
        $root = $realRoot;
    }

    return str_replace('\\', '/', $root);
}

public function warnUntrustedAutoloadWarming(string $projectRoot, OutputInterface $output): void
{
    if ($this->warnedUntrustedAutoload) {
        return;
    }

    $this->warnedUntrustedAutoload = true;
    if ($output instanceof \Symfony\Component\Console\Output\ConsoleOutput) {
        $output = $output->getErrorOutput();
    }

    $prettyDir = ConfigPaths::prettyPath($projectRoot);
    $output->writeln(
        "<comment>Skipping project autoload (vendor/autoload.php) in untrusted project {$prettyDir}. Use --trust-project to allow.</comment>"
    );
}

Skipping project autoload (vendor/autoload.php) in untrusted project ~/suspicious-project. 
Use --trust-project to allow.

Using local PsySH version at ~/my-project

Skipping local PsySH at ~/my-project (project is untrusted). Re-run with --trust-project to allow.

$markUntrustedProject = function ($projectPath, $prettyPath) {
    fwrite(STDERR, 'Skipping local PsySH at ' . $prettyPath . ' (project is untrusted). Re-run with --trust-project to allow.' . PHP_EOL);
    $_SERVER['PSYSH_UNTRUSTED_PROJECT'] = $projectPath;
    $_ENV['PSYSH_UNTRUSTED_PROJECT'] = $projectPath;
    putenv('PSYSH_UNTRUSTED_PROJECT='.$projectPath);
};

# Trust all projects (dangerous!)
export PSYSH_TRUST_PROJECT=true
# or
export PSYSH_TRUST_PROJECT=1

# Never trust projects
export PSYSH_TRUST_PROJECT=false
# or
export PSYSH_TRUST_PROJECT=0

public function setModeFromEnv(string $value): void
{
    switch (strtolower(trim($value))) {
        case 'true':
        case '1':
            $this->mode = Configuration::PROJECT_TRUST_ALWAYS;
            break;
        case 'false':
        case '0':
            $this->mode = Configuration::PROJECT_TRUST_NEVER;
            break;
        default:
            throw new \InvalidArgumentException('Invalid PSYSH_TRUST_PROJECT value. Expected: true, 1, false, or 0');
    }
}

// ~/.config/psysh/config.php
return [
    'trustProject' => 'prompt', // or 'always', 'never'
];

use Psy\Configuration;
use Psy\Shell;

$config = new Configuration([
    'trustProject' => 'always',
]);

$shell = new Shell($config);
$shell->run();