@hrushiborhade/pingme 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hrushikesh Borhade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# pingme
+
+> My Claude agent pings me when it's stuck. Now I doom scroll guilt-free. Yours is just... stuck.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+Get texted when your Claude Code agent needs attention. No more checking terminals.
+
+## The Problem
+
+You're running multiple Claude Code instances across tmux panes. One stops because it needs permission or has a question. You think it's still working. Hours later, you find it blocked. Time wasted.
+
+## The Solution
+
+```bash
+npx @hrushiborhade/pingme init
+```
+
+Now your Claude agent texts you when it needs you.
+
+## What You Get
+
+SMS notifications when:
+- Agent stops
+- Agent asks a clarifying question
+- Agent needs permission
+- Agent hits rate limits
+
+Each message includes:
+- **Project name** - which codebase needs you
+- **tmux context** - which pane to jump to
+- **Reason** - what the agent needs
+
+## Setup
+
+### 1. Get Twilio Credentials (free trial works)
+
+1. Sign up at [twilio.com/console](https://console.twilio.com)
+2. Get your Account SID and Auth Token from the dashboard
+3. Get a phone number (or use the trial number)
+
+### 2. Install pingme
+
+```bash
+npx @hrushiborhade/pingme init
+```
+
+Follow the prompts. Done.
+
+## Commands
+
+```bash
+npx @hrushiborhade/pingme init       # Setup pingme
+npx @hrushiborhade/pingme test       # Send a test SMS
+npx @hrushiborhade/pingme uninstall  # Remove pingme
+npx @hrushiborhade/pingme --version  # Show version
+npx @hrushiborhade/pingme --help     # Show help
+```
+
+## How It Works
+
+pingme uses Claude Code's [hooks system](https://docs.anthropic.com/en/docs/claude-code/hooks) to detect when the agent needs your attention.
+
+1. **Installation**: When you run `npx @hrushiborhade/pingme init`, pingme creates:
+   - A bash script at `~/.claude/hooks/pingme.sh` that sends SMS via Twilio
+   - Hook entries in `~/.claude/settings.json` that trigger the script
+
+2. **Hook Triggers**: Two hooks are configured:
+   - `PostToolUse` with `AskUserQuestion` matcher - triggers when Claude asks you a question
+   - `Stop` - triggers when Claude stops execution for any reason
+
+3. **Notification Flow**: When triggered, the hook script:
+   - Detects your current project name from the working directory
+   - Captures tmux session/window/pane info (if available)
+   - Sends an SMS via Twilio's API with context about what needs attention
+
+## Example SMS
+
+```
+[question emoji] agentQ
+
+[location emoji] dev:2.1 (main)
+[message emoji] Asking question
+
+Do you want me to run npm install?
+```
+
+## Security
+
+- **Credentials are stored locally** in `~/.claude/hooks/pingme.sh`
+- Credentials are never sent to any server except Twilio's API
+- The hook script only runs when Claude Code triggers it
+- Input is sanitized to prevent shell injection
+- SMS requests are made over HTTPS
+
+To update or remove credentials, run `npx @hrushiborhade/pingme init` again or `npx @hrushiborhade/pingme uninstall`.
+
+## Troubleshooting
+
+### SMS not sending
+
+1. **Verify credentials**: Run `npx @hrushiborhade/pingme test` to send a test message
+2. **Check Twilio balance**: Free trial includes $15 credit; ensure it's not exhausted
+3. **Verify phone numbers**: Both numbers must include country code (e.g., `+1` for US)
+4. **Trial account limitations**: Twilio trial accounts can only send to verified numbers
+
+### Hook not triggering
+
+1. **Restart Claude Code**: Hooks are loaded on startup
+2. **Check settings.json**: Verify hooks are present in `~/.claude/settings.json`
+3. **Check script permissions**: Run `chmod +x ~/.claude/hooks/pingme.sh`
+
+### "curl not found" or no SMS sent
+
+The hook script requires `curl`. Install it via your package manager:
+- macOS: `brew install curl` (usually pre-installed)
+- Ubuntu/Debian: `sudo apt install curl`
+
+### Uninstalling
+
+```bash
+npx @hrushiborhade/pingme uninstall
+```
+
+This removes the hook script and settings entries. Your Twilio credentials are deleted locally.
+
+## Requirements
+
+- Node.js 18+
+- Twilio account (free trial includes $15 credit)
+- Claude Code CLI
+- `curl` (pre-installed on most systems)
+
+## Contributing
+
+Contributions are welcome! Here's how to get started:
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Make your changes
+4. Run the build: `npm run build`
+5. Test locally: `npm start init`
+6. Commit your changes: `git commit -m 'Add my feature'`
+7. Push to your fork: `git push origin feature/my-feature`
+8. Open a Pull Request
+
+### Development
+
+```bash
+git clone https://github.com/HrushiBorhade/pingme-cli.git
+cd pingme-cli
+npm install
+npm run dev    # Watch mode for TypeScript
+npm run build  # Build for production
+```
+
+### Ideas for Contribution
+
+- Support for other notification providers (Slack, Discord, Pushover)
+- Rate limiting to prevent SMS spam
+- Quiet hours configuration
+- Custom message templates
+
+## License
+
+MIT
+
+---
+
+Built for developers who run AI agents and want their life back.

package/bin/pingme.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/index.js');

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,83 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { installHook } from '../utils/install.js';
+import { sendTestSMS } from '../utils/twilio.js';
+export async function init() {
+    p.log.info(pc.dim('Get your Twilio credentials at: ') + pc.cyan('https://console.twilio.com'));
+    const credentials = await p.group({
+        twilioSid: () => p.text({
+            message: 'Twilio Account SID',
+            placeholder: 'ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
+            validate: (value) => {
+                if (!value)
+                    return 'Required';
+                if (!value.startsWith('AC'))
+                    return 'Should start with AC';
+            },
+        }),
+        twilioToken: () => p.password({
+            message: 'Twilio Auth Token',
+            validate: (value) => {
+                if (!value)
+                    return 'Required';
+                if (value.length < 20)
+                    return 'Token seems too short';
+            },
+        }),
+        twilioFrom: () => p.text({
+            message: 'Twilio Phone Number',
+            placeholder: '+14155238886',
+            validate: (value) => {
+                if (!value)
+                    return 'Required';
+                if (!value.startsWith('+'))
+                    return 'Include country code (e.g., +1...)';
+            },
+        }),
+        myPhone: () => p.text({
+            message: 'Your Phone Number',
+            placeholder: '+1234567890',
+            validate: (value) => {
+                if (!value)
+                    return 'Required';
+                if (!value.startsWith('+'))
+                    return 'Include country code (e.g., +1...)';
+            },
+        }),
+    }, {
+        onCancel: () => {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        },
+    });
+    const s = p.spinner();
+    // Install hook
+    s.start('Creating hook script');
+    try {
+        await installHook(credentials);
+        s.stop('Hook script created');
+    }
+    catch (err) {
+        s.stop(pc.red('Failed to create hook script'));
+        p.log.error(err instanceof Error ? err.message : 'Unknown error');
+        p.log.info('Check that you have write permissions to ~/.claude/');
+        process.exit(1);
+    }
+    // Send test SMS
+    s.start('Sending test SMS');
+    const testResult = await sendTestSMS(credentials);
+    if (testResult.success) {
+        s.stop('Test SMS sent');
+    }
+    else {
+        s.stop(pc.yellow('Could not send test SMS'));
+        p.log.warn('Setup completed, but test SMS failed. Check your Twilio credentials.');
+    }
+    // Done
+    p.note(`Your Claude agent will now ping you when it needs attention.
+
+${pc.dim('Commands:')}
+  ${pc.cyan('npx pingme-cli test')}       Send a test SMS
+  ${pc.cyan('npx pingme-cli uninstall')}  Remove pingme`, 'Setup complete');
+    p.outro(pc.dim('Now go doom scroll guilt-free ') + '🚀');
+}

package/dist/commands/test.d.ts

@@ -0,0 +1 @@
+export declare function test(): Promise<void>;

package/dist/commands/test.js

@@ -0,0 +1,38 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+import { execSync } from 'child_process';
+export async function test() {
+    const hookPath = path.join(homedir(), '.claude', 'hooks', 'pingme.sh');
+    if (!existsSync(hookPath)) {
+        p.log.error('pingme is not installed');
+        p.log.info(`Run ${pc.cyan('npx pingme-cli init')} to set up`);
+        process.exit(1);
+    }
+    const s = p.spinner();
+    s.start('Sending test SMS');
+    try {
+        execSync(`echo "🧪 Test ping from pingme-cli" | "${hookPath}" test`, {
+            timeout: 15000,
+            stdio: 'ignore',
+        });
+        s.stop('Test SMS sent!');
+        p.log.success('Check your phone for the message');
+    }
+    catch (err) {
+        s.stop('Failed to send SMS');
+        // Provide more specific error message
+        const isTimeout = err instanceof Error && err.message.includes('ETIMEDOUT');
+        if (isTimeout) {
+            p.log.error('Request timed out - check your network connection');
+        }
+        else {
+            p.log.error('SMS send failed - check your Twilio credentials');
+        }
+        p.log.info(`Run ${pc.cyan('npx pingme-cli init')} to reconfigure`);
+        process.exit(1);
+    }
+    p.outro(pc.dim('All good!'));
+}

package/dist/commands/uninstall.d.ts

@@ -0,0 +1 @@
+export declare function uninstall(): Promise<void>;

package/dist/commands/uninstall.js

@@ -0,0 +1,46 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { existsSync } from 'fs';
+import { unlink, access, constants } from 'fs/promises';
+import { homedir } from 'os';
+import path from 'path';
+export async function uninstall() {
+    const hookPath = path.join(homedir(), '.claude', 'hooks', 'pingme.sh');
+    if (!existsSync(hookPath)) {
+        p.log.warn('pingme is not installed (hook file not found)');
+        p.outro(pc.dim('Nothing to do'));
+        return;
+    }
+    // Check if we have write permission to delete the file
+    try {
+        await access(hookPath, constants.W_OK);
+    }
+    catch {
+        p.log.error(`Permission denied: Cannot delete ${hookPath}`);
+        p.log.info(pc.dim(`Try running: sudo rm "${hookPath}"`));
+        process.exit(1);
+    }
+    const confirm = await p.confirm({
+        message: 'Remove pingme?',
+    });
+    if (p.isCancel(confirm) || !confirm) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const s = p.spinner();
+    s.start('Removing pingme');
+    try {
+        await unlink(hookPath);
+        s.stop('Hook script removed');
+    }
+    catch (err) {
+        s.stop('Could not remove hook');
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+        p.log.error(`Failed to delete hook: ${errorMessage}`);
+        p.log.info(pc.dim(`Manually delete: rm "${hookPath}"`));
+        process.exit(1);
+    }
+    p.note(pc.dim(`Hook entries in ~/.claude/settings.json remain.
+They're harmless, but you can remove them manually if you want.`), 'Note');
+    p.outro(pc.dim('pingme uninstalled'));
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,56 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { init } from './commands/init.js';
+import { test } from './commands/test.js';
+import { uninstall } from './commands/uninstall.js';
+const VERSION = '1.0.1';
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || 'init';
+    // Version flag (no header needed)
+    if (command === '--version' || command === '-v') {
+        console.log(`pingme-cli v${VERSION}`);
+        return;
+    }
+    // Header
+    console.log(); // Add spacing
+    p.intro(pc.bgCyan(pc.black(' pingme ')));
+    switch (command) {
+        case 'init':
+            await init();
+            break;
+        case 'test':
+            await test();
+            break;
+        case 'uninstall':
+            await uninstall();
+            break;
+        case 'help':
+        case '--help':
+        case '-h':
+            showHelp();
+            break;
+        default:
+            p.log.error(`Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+    }
+}
+function showHelp() {
+    console.log(`
+${pc.bold('Usage:')} npx pingme-cli ${pc.dim('<command>')}
+
+${pc.bold('Commands:')}
+  ${pc.cyan('init')}        Setup pingme (default)
+  ${pc.cyan('test')}        Send a test SMS
+  ${pc.cyan('uninstall')}   Remove pingme
+
+${pc.bold('Examples:')}
+  ${pc.dim('$')} npx pingme-cli init
+  ${pc.dim('$')} npx pingme-cli test
+`);
+}
+main().catch((err) => {
+    p.log.error(err.message);
+    process.exit(1);
+});

package/dist/utils/install.d.ts

@@ -0,0 +1,8 @@
+interface Credentials {
+    twilioSid: string;
+    twilioToken: string;
+    twilioFrom: string;
+    myPhone: string;
+}
+export declare function installHook(credentials: Credentials): Promise<void>;
+export {};

package/dist/utils/install.js

@@ -0,0 +1,131 @@
+import { writeFile, readFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+// Escape special characters for bash strings (prevents shell injection)
+function escapeForBash(str) {
+    // Replace backslashes first, then other special chars
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\$/g, '\\$')
+        .replace(/`/g, '\\`')
+        .replace(/!/g, '\\!');
+}
+const HOOK_SCRIPT = `#!/usr/bin/env bash
+
+# ┌───────────────────────────────────────────────────────────────┐
+# │  pingme - Get texted when your Claude agent is stuck          │
+# │  https://github.com/HrushiBorhade/pingme-cli                  │
+# └───────────────────────────────────────────────────────────────┘
+
+# Config (do not edit manually - use 'npx pingme-cli init' to reconfigure)
+TWILIO_SID="{{TWILIO_SID}}"
+TWILIO_TOKEN="{{TWILIO_TOKEN}}"
+TWILIO_FROM="{{TWILIO_FROM}}"
+MY_PHONE="{{MY_PHONE}}"
+
+# Check for curl
+if ! command -v curl &> /dev/null; then
+    exit 0  # Silently exit if curl not available
+fi
+
+# Context
+EVENT="\${1:-unknown}"
+PROJECT=\$(basename "\$PWD" | tr -cd '[:alnum:]._-')  # Sanitize project name
+
+# tmux info (if available)
+TMUX_INFO=""
+if [ -n "\$TMUX" ]; then
+    TMUX_INFO=\$(tmux display-message -p '#S:#I.#P (#W)' 2>/dev/null || echo "")
+fi
+
+# Read context from stdin (limit to 280 chars for SMS)
+CONTEXT=""
+if [ ! -t 0 ]; then
+    CONTEXT=\$(head -c 280 | tr -cd '[:print:][:space:]')  # Sanitize input
+fi
+
+# Message emoji/reason
+case "\$EVENT" in
+    question)   EMOJI="❓"; REASON="Asking question" ;;
+    permission) EMOJI="🔐"; REASON="Needs permission" ;;
+    limit)      EMOJI="⚠️"; REASON="Hit limit" ;;
+    stopped)    EMOJI="🛑"; REASON="Agent stopped" ;;
+    test)       EMOJI="🧪"; REASON="Test ping" ;;
+    *)          EMOJI="🔔"; REASON="Needs attention" ;;
+esac
+
+# Build message
+MESSAGE="\$EMOJI \$PROJECT"
+[ -n "\$TMUX_INFO" ] && MESSAGE="\$MESSAGE
+📍 \$TMUX_INFO"
+MESSAGE="\$MESSAGE
+💬 \$REASON"
+[ -n "\$CONTEXT" ] && MESSAGE="\$MESSAGE
+
+\$CONTEXT"
+
+# Send SMS (background, detached so it survives script exit)
+(
+    curl -s -X POST "https://api.twilio.com/2010-04-01/Accounts/\$TWILIO_SID/Messages.json" \\
+        --user "\$TWILIO_SID:\$TWILIO_TOKEN" \\
+        --data-urlencode "From=\$TWILIO_FROM" \\
+        --data-urlencode "To=\$MY_PHONE" \\
+        --data-urlencode "Body=\$MESSAGE" \\
+        --max-time 10 \\
+        > /dev/null 2>&1
+) &
+disown 2>/dev/null || true
+
+exit 0
+`;
+export async function installHook(credentials) {
+    const homeDir = homedir();
+    const hooksDir = path.join(homeDir, '.claude', 'hooks');
+    const hookPath = path.join(hooksDir, 'pingme.sh');
+    const configPath = path.join(homeDir, '.claude', 'settings.json');
+    // Create hooks directory
+    await mkdir(hooksDir, { recursive: true });
+    // Create hook script with escaped credentials (prevents shell injection)
+    const script = HOOK_SCRIPT
+        .replaceAll('{{TWILIO_SID}}', escapeForBash(credentials.twilioSid))
+        .replaceAll('{{TWILIO_TOKEN}}', escapeForBash(credentials.twilioToken))
+        .replaceAll('{{TWILIO_FROM}}', escapeForBash(credentials.twilioFrom))
+        .replaceAll('{{MY_PHONE}}', escapeForBash(credentials.myPhone));
+    await writeFile(hookPath, script, { mode: 0o755 });
+    // Update Claude config
+    let config = {};
+    try {
+        if (existsSync(configPath)) {
+            const existing = await readFile(configPath, 'utf-8');
+            config = JSON.parse(existing);
+        }
+    }
+    catch {
+        // Start fresh
+    }
+    // Initialize hooks with Claude Code 2.1+ format
+    // Format: { matcher: "ToolName" (regex string), hooks: [{ type: "command", command: "..." }] }
+    config.hooks = config.hooks || {};
+    const hooks = config.hooks;
+    hooks.PostToolUse = hooks.PostToolUse || [];
+    hooks.Stop = hooks.Stop || [];
+    const postToolHooks = hooks.PostToolUse;
+    const stopHooks = hooks.Stop;
+    // Check if pingme hook already exists (check in hooks array)
+    const hasPingmePostTool = postToolHooks.some((h) => h.hooks?.some((hook) => hook.command?.includes('pingme.sh')));
+    const hasPingmeStop = stopHooks.some((h) => h.hooks?.some((hook) => hook.command?.includes('pingme.sh')));
+    if (!hasPingmePostTool) {
+        postToolHooks.push({
+            matcher: 'AskUserQuestion',
+            hooks: [{ type: 'command', command: '~/.claude/hooks/pingme.sh question' }],
+        });
+    }
+    if (!hasPingmeStop) {
+        stopHooks.push({
+            hooks: [{ type: 'command', command: '~/.claude/hooks/pingme.sh stopped' }],
+        });
+    }
+    await writeFile(configPath, JSON.stringify(config, null, 2));
+}

package/dist/utils/twilio.d.ts

@@ -0,0 +1,18 @@
+interface Credentials {
+    twilioSid: string;
+    twilioToken: string;
+    twilioFrom: string;
+    myPhone: string;
+}
+export type TestErrorCode = 'HOOK_NOT_FOUND' | 'TIMEOUT' | 'NETWORK_ERROR' | 'PERMISSION_DENIED' | 'SCRIPT_ERROR' | 'UNKNOWN';
+interface TestResult {
+    success: boolean;
+    error?: string;
+    errorCode?: TestErrorCode;
+}
+/**
+ * Sends a test SMS using the installed hook script.
+ * This validates that the Twilio credentials are working correctly.
+ */
+export declare function sendTestSMS(credentials: Credentials): Promise<TestResult>;
+export {};

package/dist/utils/twilio.js

@@ -0,0 +1,92 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+const TIMEOUT_MS = 15000;
+/**
+ * Determines the error code based on the error type and message
+ */
+function getErrorCode(err) {
+    if (!(err instanceof Error)) {
+        return 'UNKNOWN';
+    }
+    const message = err.message.toLowerCase();
+    // Node.js child_process timeout (ETIMEDOUT or killed due to timeout)
+    if (message.includes('etimedout') || message.includes('timedout') || message.includes('timed out')) {
+        return 'TIMEOUT';
+    }
+    // Check for signal-based timeout (execSync kills with SIGTERM on timeout)
+    if ('signal' in err && err.signal === 'SIGTERM') {
+        return 'TIMEOUT';
+    }
+    // Network-related errors
+    if (message.includes('enotfound') ||
+        message.includes('econnrefused') ||
+        message.includes('econnreset') ||
+        message.includes('network') ||
+        message.includes('could not resolve')) {
+        return 'NETWORK_ERROR';
+    }
+    // Permission errors
+    if (message.includes('eacces') || message.includes('permission denied')) {
+        return 'PERMISSION_DENIED';
+    }
+    // Script execution errors (non-zero exit code)
+    if (message.includes('exited with') || message.includes('exit code')) {
+        return 'SCRIPT_ERROR';
+    }
+    return 'UNKNOWN';
+}
+/**
+ * Returns a user-friendly error message based on the error code
+ */
+function getErrorMessage(errorCode, originalError) {
+    switch (errorCode) {
+        case 'HOOK_NOT_FOUND':
+            return 'Hook script not found. Run "npx pingme-cli init" to set up.';
+        case 'TIMEOUT':
+            return `Request timed out after ${TIMEOUT_MS / 1000} seconds. Check your network connection or Twilio service status.`;
+        case 'NETWORK_ERROR':
+            return 'Network error. Check your internet connection and try again.';
+        case 'PERMISSION_DENIED':
+            return 'Permission denied. Check that the hook script is executable (chmod +x ~/.claude/hooks/pingme.sh).';
+        case 'SCRIPT_ERROR':
+            return 'Hook script failed. Check your Twilio credentials with "npx pingme-cli init".';
+        case 'UNKNOWN':
+        default:
+            return originalError || 'An unexpected error occurred while sending SMS.';
+    }
+}
+/**
+ * Sends a test SMS using the installed hook script.
+ * This validates that the Twilio credentials are working correctly.
+ */
+export async function sendTestSMS(credentials) {
+    const hookPath = path.join(homedir(), '.claude', 'hooks', 'pingme.sh');
+    // Pre-flight check: verify hook script exists
+    if (!existsSync(hookPath)) {
+        return {
+            success: false,
+            error: getErrorMessage('HOOK_NOT_FOUND'),
+            errorCode: 'HOOK_NOT_FOUND',
+        };
+    }
+    const execOptions = {
+        timeout: TIMEOUT_MS,
+        stdio: ['pipe', 'pipe', 'pipe'], // Capture stdout/stderr for better error diagnosis
+        killSignal: 'SIGTERM',
+    };
+    try {
+        execSync(`echo "pingme installed! Your Claude agent can now reach you." | "${hookPath}" test`, execOptions);
+        return { success: true };
+    }
+    catch (err) {
+        const errorCode = getErrorCode(err);
+        const originalMessage = err instanceof Error ? err.message : String(err);
+        return {
+            success: false,
+            error: getErrorMessage(errorCode, originalMessage),
+            errorCode,
+        };
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@hrushiborhade/pingme",
+  "version": "1.0.1",
+  "description": "Get texted when your Claude agent is stuck",
+  "type": "module",
+  "bin": {
+    "pingme": "./bin/pingme.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node bin/pingme.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "sms",
+    "notifications",
+    "twilio",
+    "ai-agents",
+    "cli",
+    "terminal",
+    "productivity"
+  ],
+  "author": "Hrushikesh Borhade",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HrushiBorhade/pingme-cli"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}