skynot 0.0.1

package/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+  workflow_dispatch:
+
+  # to execute once a day (more info see https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#schedule )
+  schedule:
+    - cron: "0 0 * * *"
+
+concurrency:
+  group: ci-${{ github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  build-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Update system dependencies
+        run: |
+          sudo apt-get update
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build
+        run: npm run build

package/.github/workflows/publish.yml

@@ -0,0 +1,49 @@
+name: Publish Binaries
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  bin-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Verify version matches tag
+        run: |
+          # Extract tag version (remove 'v' prefix if present)
+          TAG_VERSION="${GITHUB_REF_NAME#v}"
+
+          # Get version from package.json
+          PKG_VERSION=$(node -p "require('./package.json').version")
+
+          echo "Git tag version: $TAG_VERSION"
+          echo "Package.json version: $PKG_VERSION"
+
+          # Compare versions
+          if [ "$TAG_VERSION" != "$PKG_VERSION" ]; then
+            echo "ERROR: Git tag version ($TAG_VERSION) does not match package.json version ($PKG_VERSION)"
+            exit 1
+          fi
+
+          echo "✓ Versions match!"
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish skynot to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENCE.txt

@@ -0,0 +1,16 @@
+AGPL-3.0 License
+
+Copyright (c) 2026 skynot contributors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.

package/ReadMe.md

@@ -0,0 +1,16 @@
+SkyNot
+=======
+
+Ever tempted to use or try out the infamous `pi-coding-agent` but got put off by its lack of out-of-the-box sandbox?
+
+Some people use and/or develop guardrails extensions or poor-man sandboxing solutions; others just deploy it to their VPS so that any potential damage is contained.
+
+But the virtue is somewhere in the middle:
+- No need to go to the extreme of complicated cloud deploys to just try out some clanking business.
+- No need to setup complicated tweaks or plugins that may give you a false sense of security, or too many permissions issues for your clanker to be productive.
+
+Why not just use the unix model? Give pi a user profile in your system, a $HOME where to place its git repositories and you're off to the races.
+
+This repository is just a quick NPX tool that helps you set up this ideal approach: run it with a simple `npx skynot` and it will guide you through the process and ask you for sudo permissions in each step that it requires, informing you of what it is doing at all times.
+
+(This repo is of course opensource too so that you can check that what it says it does is what it really does.)

package/dist/index.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const util_1 = require("util");
+const os = __importStar(require("os"));
+const commander_1 = require("commander");
+const package_json_1 = __importDefault(require("../package.json"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function getShellRcFile() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        return '.zshrc';
+    }
+    return '.bashrc';
+}
+function getPiHome() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        return '/Users/pi';
+    }
+    return '/home/pi';
+}
+function getPiInstallDir() {
+    return `${getPiHome()}/pi`;
+}
+async function askQuestion(query, silent = false) {
+    if (silent) {
+        return new Promise((resolve) => {
+            process.stdout.write(query);
+            const stdin = process.stdin;
+            const wasRaw = stdin.isRaw;
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding('utf-8');
+            let input = '';
+            const onData = (char) => {
+                if (char === '\n' || char === '\r' || char === '\u0004') {
+                    stdin.removeListener('data', onData);
+                    stdin.setRawMode(wasRaw);
+                    stdin.pause();
+                    process.stdout.write('\n');
+                    resolve(input);
+                }
+                else if (char === '\u0003') {
+                    // Ctrl+C
+                    stdin.setRawMode(wasRaw);
+                    process.exit(1);
+                }
+                else if (char === '\u007F' || char === '\b') {
+                    input = input.slice(0, -1);
+                }
+                else {
+                    input += char;
+                }
+            };
+            stdin.on('data', onData);
+        });
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+const MAX_SUDO_RETRIES = 3;
+// Cached sudo password so we only ask once
+let cachedSudoPassword = null;
+function runSudoWithPassword(command, password, asUser) {
+    return new Promise((resolve, reject) => {
+        const sudoArgs = ['-S', '-k'];
+        if (asUser) {
+            sudoArgs.push('-u', asUser);
+        }
+        sudoArgs.push('bash', '-c', command);
+        const child = (0, child_process_1.spawn)('sudo', sudoArgs, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stdin.write(password + '\n');
+        child.stdin.end();
+        let stderr = '';
+        child.stderr.on('data', (data) => {
+            const line = data.toString();
+            // Filter out sudo's own password prompt
+            if (!line.includes('Password:') && !line.includes('password for')) {
+                stderr += line;
+            }
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                // Sanitize: never include the password in error messages
+                const escaped = password.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const safeStderr = stderr.replace(new RegExp(escaped, 'g'), '***');
+                reject(new Error(`sudo command failed (exit code ${code}): ${safeStderr.trim()}`));
+            }
+        });
+    });
+}
+async function askSudoPasswordAndRun(command, reason) {
+    for (let attempt = 1; attempt <= MAX_SUDO_RETRIES; attempt++) {
+        const password = await askQuestion(`Enter sudo password (${reason}): `, true);
+        try {
+            await runSudoWithPassword(command, password.trim());
+            cachedSudoPassword = password.trim();
+            return;
+        }
+        catch (e) {
+            if (attempt < MAX_SUDO_RETRIES) {
+                console.error('Incorrect password, please try again.');
+            }
+            else {
+                throw new Error(`Failed after ${MAX_SUDO_RETRIES} attempts. Aborting.`);
+            }
+        }
+    }
+}
+async function runAsPi(command) {
+    if (!cachedSudoPassword) {
+        const password = await askQuestion('Enter sudo password (required to run as pi): ', true);
+        cachedSudoPassword = password.trim();
+    }
+    const piHome = getPiHome();
+    // Set HOME and cd to pi's home to avoid inheriting the current user's
+    // working directory (which pi can't access) and npm cache.
+    const wrappedCommand = `export HOME=${piHome} && cd ${piHome} && ${command}`;
+    await runSudoWithPassword(wrappedCommand, cachedSudoPassword, 'pi');
+}
+async function userExists(username) {
+    try {
+        await execAsync(`id -u ${username}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensurePiUser() {
+    const exists = await userExists('pi');
+    if (exists) {
+        console.log('User "pi" already exists.');
+        return;
+    }
+    console.log('Creating user "pi"...');
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        await askSudoPasswordAndRun(`sysadminctl -addUser pi -home /Users/pi -shell /bin/zsh && createhomedir -c -u pi 2>/dev/null; mkdir -p /Users/pi && chown pi:staff /Users/pi`, 'required to create user');
+    }
+    else {
+        await askSudoPasswordAndRun(`useradd -m -s /bin/bash pi`, 'required to create user');
+    }
+    console.log('User "pi" created.');
+}
+async function installAgent() {
+    const installDir = getPiInstallDir();
+    const packageDir = path.join(installDir, 'node_modules', '@mariozechner', 'pi-coding-agent');
+    if (fs.existsSync(packageDir)) {
+        console.log('@mariozechner/pi-coding-agent is already installed, skipping.');
+        return;
+    }
+    console.log(`Installing @mariozechner/pi-coding-agent into ${installDir}...`);
+    const cmd = `mkdir -p ${installDir} && cd ${installDir} && npm install @mariozechner/pi-coding-agent`;
+    await runAsPi(cmd);
+    console.log('Package installed.');
+}
+async function updatePath() {
+    const rcFile = getShellRcFile();
+    const piHome = getPiHome();
+    const line = "export PATH=\$HOME/pi/node_modules/.bin:\$PATH";
+    const rcPath = `${piHome}/${rcFile}`;
+    // Check locally if the line is already present
+    if (fs.existsSync(rcPath)) {
+        const content = fs.readFileSync(rcPath, 'utf-8');
+        if (content.includes(line)) {
+            console.log(`pi's PATH already configured in ${rcFile}, skipping.`);
+            return;
+        }
+    }
+    console.log(`Adding agent binary directory to pi's PATH via ${rcFile}...`);
+    const checkCmd = `grep -Fx '${line}' ${rcPath} 2>/dev/null || echo '${line}' >> ${rcPath}`;
+    await runAsPi(checkCmd);
+    console.log(`${rcFile} updated.`);
+}
+async function createLauncherScript() {
+    const currentUserHome = os.homedir();
+    const binDir = path.join(currentUserHome, 'bin');
+    const scriptPath = path.join(binDir, 'pi');
+    const installDir = getPiInstallDir();
+    console.log(`Creating launcher script at ${scriptPath}...`);
+    // Create ~/bin/ if it doesn't exist
+    if (!fs.existsSync(binDir)) {
+        fs.mkdirSync(binDir, { recursive: true });
+    }
+    const piHome = getPiHome();
+    const platform = os.platform();
+    const homeBase = platform === 'darwin' ? '/Users' : '/home';
+    // Write the launcher shell script with permission checks
+    const scriptContent = `#!/bin/bash
+
+echo "About to launch pi-coding-agent..."
+
+# Check permissions of other users' home directories
+EXPOSED_DIRS=()
+HOME_BASE="${homeBase}"
+PI_HOME="${piHome}"
+
+for user_home in "$HOME_BASE"/*/; do
+  # Skip pi's own home
+  if [ "$user_home" = "$PI_HOME/" ]; then
+    continue
+  fi
+
+  # Check if group or others have any permissions (r, w, or x)
+  perms=$(stat -f "%Sp" "$user_home" 2>/dev/null || stat -c "%A" "$user_home" 2>/dev/null)
+  if [ -z "$perms" ]; then
+    continue
+  fi
+
+  # Extract group and others permissions (characters 5-10 of e.g. drwxr-xr-x)
+  group_others="\${perms:4:6}"
+  # Check if any of group/others have r, w, or x
+  if echo "$group_others" | grep -q '[rwx]'; then
+    # On macOS, handle /Users/Shared separately (it's world-accessible by default)
+    if [ "$user_home" = "/Users/Shared/" ]; then
+      echo "NOTE: /Users/Shared is world-accessible. This is a macOS default, but you may want to restrict it manually if it contains sensitive data."
+      read -n 1 -s -r -p "Press any key to continue..."
+      echo ""
+    else
+      EXPOSED_DIRS+=("$user_home")
+    fi
+  fi
+done
+
+if [ \${#EXPOSED_DIRS[@]} -gt 0 ]; then
+  echo "WARNING: The following user home directories are accessible by other users (including pi):"
+  for dir in "\${EXPOSED_DIRS[@]}"; do
+    echo "  $dir"
+  done
+  echo ""
+  read -p "Would you like to shield these directories? (recommended) [Y/n]" answer
+  answer=\${answer:-Y}
+  if [[ "$answer" =~ ^[Yy] ]]; then
+    for dir in "\${EXPOSED_DIRS[@]}"; do
+      sudo chmod go-rwx "$dir"
+      echo "Shielded: $dir"
+    done
+    echo "Done."
+  fi
+  echo ""
+fi
+
+echo "Launching pi-coding-agent with pi user (sudo is required to impersonate 'pi' user)..."
+exec sudo -i -u pi bash -c 'cd ${installDir} && npx --yes @mariozechner/pi-coding-agent "$@"' -- "$@"
+`;
+    fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+    console.log('Launcher script created.');
+    // Add $HOME/bin to the current user's PATH via their rc file if not already present
+    const rcFile = getShellRcFile();
+    const rcPath = path.join(currentUserHome, rcFile);
+    const pathLine = 'export PATH="$HOME/bin:$PATH"';
+    let rcContent = '';
+    if (fs.existsSync(rcPath)) {
+        rcContent = fs.readFileSync(rcPath, 'utf-8');
+    }
+    if (!rcContent.includes(pathLine)) {
+        console.log(`Adding $HOME/bin to PATH in ${rcFile}...`);
+        fs.appendFileSync(rcPath, `\n${pathLine}\n`);
+        console.log(`${rcFile} updated.`);
+    }
+    else {
+        console.log(`$HOME/bin already in PATH (${rcFile}).`);
+    }
+}
+async function launchAgent() {
+    const scriptPath = path.join(os.homedir(), 'bin', 'pi');
+    const child = (0, child_process_1.spawn)(scriptPath, [], { stdio: 'inherit' });
+    return new Promise((resolve, reject) => {
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`pi-coding-agent exited with code ${code}`));
+            }
+        });
+    });
+}
+async function wipeInstallation() {
+    const installDir = getPiInstallDir();
+    if (fs.existsSync(installDir)) {
+        console.log(`Wiping existing installation at ${installDir}...`);
+        await runAsPi(`rm -rf ${installDir}`);
+        console.log('Installation wiped.');
+    }
+    else {
+        console.log('No existing installation found, nothing to wipe.');
+    }
+}
+async function main() {
+    if (os.platform() === 'win32') {
+        throw new Error('Windows is not supported. Please run skynot on Linux or macOS.');
+    }
+    const program = new commander_1.Command();
+    program
+        .version(package_json_1.default.version)
+        .description(package_json_1.default.description)
+        .option('--update', 'Wipe and reinstall pi-coding-agent to get the latest version');
+    program.parse(process.argv);
+    const opts = program.opts();
+    await ensurePiUser();
+    if (opts.update) {
+        await wipeInstallation();
+    }
+    await installAgent();
+    await updatePath();
+    await createLauncherScript();
+    await launchAgent();
+}
+main().catch((err) => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "skynot",
+  "version": "0.0.1",
+  "description": "Quick NPX tool to set up a pi user and install the pi-coding-agent",
+  "main": "dist/index.js",
+  "bin": {
+    "skynot": "dist/index.js"
+  },
+  "scripts": {
+    "build": "npx tsc",
+    "prepublishOnly": "npm run build",
+    "run": "npm install && npm run build && node dist/index.js"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.0",
+    "typescript": "^5.3.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,361 @@
+#!/usr/bin/env node
+
+import { exec, spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { promisify } from 'util';
+import * as os from 'os';
+import { Command } from 'commander';
+import pkg from '../package.json';
+
+const execAsync = promisify(exec);
+
+function getShellRcFile(): string {
+  const platform = os.platform();
+  if (platform === 'darwin') {
+    return '.zshrc';
+  }
+  return '.bashrc';
+}
+
+function getPiHome(): string {
+  const platform = os.platform();
+  if (platform === 'darwin') {
+    return '/Users/pi';
+  }
+  return '/home/pi';
+}
+
+function getPiInstallDir(): string {
+  return `${getPiHome()}/pi`;
+}
+
+async function askQuestion(query: string, silent = false): Promise<string> {
+  if (silent) {
+    return new Promise<string>((resolve) => {
+      process.stdout.write(query);
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding('utf-8');
+      let input = '';
+      const onData = (char: string) => {
+        if (char === '\n' || char === '\r' || char === '\u0004') {
+          stdin.removeListener('data', onData);
+          stdin.setRawMode(wasRaw);
+          stdin.pause();
+          process.stdout.write('\n');
+          resolve(input);
+        } else if (char === '\u0003') {
+          // Ctrl+C
+          stdin.setRawMode(wasRaw);
+          process.exit(1);
+        } else if (char === '\u007F' || char === '\b') {
+          input = input.slice(0, -1);
+        } else {
+          input += char;
+        }
+      };
+      stdin.on('data', onData);
+    });
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise<string>((resolve) => {
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+const MAX_SUDO_RETRIES = 3;
+
+
+// Cached sudo password so we only ask once
+let cachedSudoPassword: string | null = null;
+
+function runSudoWithPassword(command: string, password: string, asUser?: string): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const sudoArgs = ['-S', '-k'];
+    if (asUser) {
+      sudoArgs.push('-u', asUser);
+    }
+    sudoArgs.push('bash', '-c', command);
+    const child = spawn('sudo', sudoArgs, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    child.stdin.write(password + '\n');
+    child.stdin.end();
+
+    let stderr = '';
+    child.stderr.on('data', (data: Buffer) => {
+      const line = data.toString();
+      // Filter out sudo's own password prompt
+      if (!line.includes('Password:') && !line.includes('password for')) {
+        stderr += line;
+      }
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        // Sanitize: never include the password in error messages
+        const escaped = password.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const safeStderr = stderr.replace(new RegExp(escaped, 'g'), '***');
+        reject(new Error(`sudo command failed (exit code ${code}): ${safeStderr.trim()}`));
+      }
+    });
+  });
+}
+
+async function askSudoPasswordAndRun(command: string, reason: string): Promise<void> {
+  for (let attempt = 1; attempt <= MAX_SUDO_RETRIES; attempt++) {
+    const password = await askQuestion(`Enter sudo password (${reason}): `, true);
+    try {
+      await runSudoWithPassword(command, password.trim());
+      cachedSudoPassword = password.trim();
+      return;
+    } catch (e) {
+      if (attempt < MAX_SUDO_RETRIES) {
+        console.error('Incorrect password, please try again.');
+      } else {
+        throw new Error(`Failed after ${MAX_SUDO_RETRIES} attempts. Aborting.`);
+      }
+    }
+  }
+}
+
+async function runAsPi(command: string): Promise<void> {
+  if (!cachedSudoPassword) {
+    const password = await askQuestion('Enter sudo password (required to run as pi): ', true);
+    cachedSudoPassword = password.trim();
+  }
+  const piHome = getPiHome();
+  // Set HOME and cd to pi's home to avoid inheriting the current user's
+  // working directory (which pi can't access) and npm cache.
+  const wrappedCommand = `export HOME=${piHome} && cd ${piHome} && ${command}`;
+  await runSudoWithPassword(wrappedCommand, cachedSudoPassword, 'pi');
+}
+
+async function userExists(username: string): Promise<boolean> {
+  try {
+    await execAsync(`id -u ${username}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensurePiUser(): Promise<void> {
+  const exists = await userExists('pi');
+  if (exists) {
+    console.log('User "pi" already exists.');
+    return;
+  }
+  console.log('Creating user "pi"...');
+  const platform = os.platform();
+  if (platform === 'darwin') {
+    await askSudoPasswordAndRun(
+      `sysadminctl -addUser pi -home /Users/pi -shell /bin/zsh && createhomedir -c -u pi 2>/dev/null; mkdir -p /Users/pi && chown pi:staff /Users/pi`,
+      'required to create user',
+    );
+  } else {
+    await askSudoPasswordAndRun(
+      `useradd -m -s /bin/bash pi`,
+      'required to create user',
+    );
+  }
+  console.log('User "pi" created.');
+}
+
+async function installAgent(): Promise<void> {
+  const installDir = getPiInstallDir();
+  const packageDir = path.join(installDir, 'node_modules', '@mariozechner', 'pi-coding-agent');
+  if (fs.existsSync(packageDir)) {
+    console.log('@mariozechner/pi-coding-agent is already installed, skipping.');
+    return;
+  }
+  console.log(`Installing @mariozechner/pi-coding-agent into ${installDir}...`);
+  const cmd = `mkdir -p ${installDir} && cd ${installDir} && npm install @mariozechner/pi-coding-agent`;
+  await runAsPi(cmd);
+  console.log('Package installed.');
+}
+
+async function updatePath(): Promise<void> {
+  const rcFile = getShellRcFile();
+  const piHome = getPiHome();
+  const line = "export PATH=\$HOME/pi/node_modules/.bin:\$PATH";
+  const rcPath = `${piHome}/${rcFile}`;
+
+  // Check locally if the line is already present
+  if (fs.existsSync(rcPath)) {
+    const content = fs.readFileSync(rcPath, 'utf-8');
+    if (content.includes(line)) {
+      console.log(`pi's PATH already configured in ${rcFile}, skipping.`);
+      return;
+    }
+  }
+
+  console.log(`Adding agent binary directory to pi's PATH via ${rcFile}...`);
+  const checkCmd = `grep -Fx '${line}' ${rcPath} 2>/dev/null || echo '${line}' >> ${rcPath}`;
+  await runAsPi(checkCmd);
+  console.log(`${rcFile} updated.`);
+}
+
+async function createLauncherScript(): Promise<void> {
+  const currentUserHome = os.homedir();
+  const binDir = path.join(currentUserHome, 'bin');
+  const scriptPath = path.join(binDir, 'pi');
+  const installDir = getPiInstallDir();
+
+  console.log(`Creating launcher script at ${scriptPath}...`);
+
+  // Create ~/bin/ if it doesn't exist
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  const piHome = getPiHome();
+  const platform = os.platform();
+  const homeBase = platform === 'darwin' ? '/Users' : '/home';
+
+  // Write the launcher shell script with permission checks
+  const scriptContent = `#!/bin/bash
+
+echo "About to launch pi-coding-agent..."
+
+# Check permissions of other users' home directories
+EXPOSED_DIRS=()
+HOME_BASE="${homeBase}"
+PI_HOME="${piHome}"
+
+for user_home in "$HOME_BASE"/*/; do
+  # Skip pi's own home
+  if [ "$user_home" = "$PI_HOME/" ]; then
+    continue
+  fi
+
+  # Check if group or others have any permissions (r, w, or x)
+  perms=$(stat -f "%Sp" "$user_home" 2>/dev/null || stat -c "%A" "$user_home" 2>/dev/null)
+  if [ -z "$perms" ]; then
+    continue
+  fi
+
+  # Extract group and others permissions (characters 5-10 of e.g. drwxr-xr-x)
+  group_others="\${perms:4:6}"
+  # Check if any of group/others have r, w, or x
+  if echo "$group_others" | grep -q '[rwx]'; then
+    # On macOS, handle /Users/Shared separately (it's world-accessible by default)
+    if [ "$user_home" = "/Users/Shared/" ]; then
+      echo "NOTE: /Users/Shared is world-accessible. This is a macOS default, but you may want to restrict it manually if it contains sensitive data."
+      read -n 1 -s -r -p "Press any key to continue..."
+      echo ""
+    else
+      EXPOSED_DIRS+=("$user_home")
+    fi
+  fi
+done
+
+if [ \${#EXPOSED_DIRS[@]} -gt 0 ]; then
+  echo "WARNING: The following user home directories are accessible by other users (including pi):"
+  for dir in "\${EXPOSED_DIRS[@]}"; do
+    echo "  $dir"
+  done
+  echo ""
+  read -p "Would you like to shield these directories? (recommended) [Y/n]" answer
+  answer=\${answer:-Y}
+  if [[ "$answer" =~ ^[Yy] ]]; then
+    for dir in "\${EXPOSED_DIRS[@]}"; do
+      sudo chmod go-rwx "$dir"
+      echo "Shielded: $dir"
+    done
+    echo "Done."
+  fi
+  echo ""
+fi
+
+echo "Launching pi-coding-agent with pi user (sudo is required to impersonate 'pi' user)..."
+exec sudo -i -u pi bash -c 'cd ${installDir} && npx --yes @mariozechner/pi-coding-agent "$@"' -- "$@"
+`;
+  fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+  console.log('Launcher script created.');
+
+  // Add $HOME/bin to the current user's PATH via their rc file if not already present
+  const rcFile = getShellRcFile();
+  const rcPath = path.join(currentUserHome, rcFile);
+  const pathLine = 'export PATH="$HOME/bin:$PATH"';
+
+  let rcContent = '';
+  if (fs.existsSync(rcPath)) {
+    rcContent = fs.readFileSync(rcPath, 'utf-8');
+  }
+
+  if (!rcContent.includes(pathLine)) {
+    console.log(`Adding $HOME/bin to PATH in ${rcFile}...`);
+    fs.appendFileSync(rcPath, `\n${pathLine}\n`);
+    console.log(`${rcFile} updated.`);
+  } else {
+    console.log(`$HOME/bin already in PATH (${rcFile}).`);
+  }
+}
+
+async function launchAgent(): Promise<void> {
+  const scriptPath = path.join(os.homedir(), 'bin', 'pi');
+  const child = spawn(scriptPath, [], { stdio: 'inherit' });
+  return new Promise<void>((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`pi-coding-agent exited with code ${code}`));
+      }
+    });
+  });
+}
+
+async function wipeInstallation(): Promise<void> {
+  const installDir = getPiInstallDir();
+  if (fs.existsSync(installDir)) {
+    console.log(`Wiping existing installation at ${installDir}...`);
+    await runAsPi(`rm -rf ${installDir}`);
+    console.log('Installation wiped.');
+  } else {
+    console.log('No existing installation found, nothing to wipe.');
+  }
+}
+
+async function main() {
+  if (os.platform() === 'win32') {
+    throw new Error('Windows is not supported. Please run skynot on Linux or macOS.');
+  }
+
+  const program = new Command();
+  program
+    .version(pkg.version)
+    .description(pkg.description)
+    .option('--update', 'Wipe and reinstall pi-coding-agent to get the latest version');
+  program.parse(process.argv);
+  const opts = program.opts();
+
+  await ensurePiUser();
+
+  if (opts.update) {
+    await wipeInstallation();
+  }
+
+  await installAgent();
+  await updatePath();
+  await createLauncherScript();
+  await launchAgent();
+}
+
+main().catch((err) => {
+  console.error('Error:', err);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}