@dmsdc-ai/aigentry-telepty 0.1.6 → 0.1.7

package/README.md

@@ -55,3 +55,14 @@ npm run test:watch
 ```
 
 The automated suite covers config generation, daemon HTTP APIs, WebSocket attach/output flow, bus events, session deletion regressions, and CLI smoke tests against a real daemon process.
+
+## Skill Installation
+
+The package installer opens the telepty skill TUI automatically when you run it in a terminal.
+
+To reopen it later, run `telepty` and choose `Install telepty skills`.
+
+The TUI lets you choose:
+- which packaged skills to install
+- which target clients to install into (`Claude Code`, `Codex`, `Gemini`)
+- whether each target uses a global path, the current project path, or a custom path

package/cli.js

@@ -9,6 +9,7 @@ const prompts = require('prompts');
 const updateNotifier = require('update-notifier');
 const pkg = require('./package.json');
 const { getConfig } = require('./auth');
+const { runInteractiveSkillInstaller } = require('./skill-installer');
 const args = process.argv.slice(2);
 
 // Check for updates unless explicitly disabled for tests/CI.
@@ -152,6 +153,7 @@ async function manageInteractive() {
         { title: '🔌  Allow inject (Run CLI with inject)', value: 'allow' },
         { title: '💬  Send message to a room (Inject command)', value: 'inject' },
         { title: '📋  View all open rooms (List sessions)', value: 'list' },
+        { title: '🧠  Install telepty skills', value: 'install-skills' },
         { title: '🔄  Update telepty to latest version', value: 'update' },
         { title: '❌  Exit', value: 'exit' }
       ]
@@ -189,6 +191,15 @@ async function manageInteractive() {
       continue;
     }
 
+    if (response.action === 'install-skills') {
+      try {
+        await runInteractiveSkillInstaller({ packageRoot: __dirname, cwd: process.cwd() });
+      } catch (e) {
+        console.error(`\n❌ ${e.message}\n`);
+      }
+      continue;
+    }
+
     if (response.action === 'list') {
       console.log('\n');
       const sessions = await discoverSessions();

package/install.js

@@ -4,6 +4,7 @@ const { execSync, spawn } = require('child_process');
 const os = require('os');
 const fs = require('fs');
 const path = require('path');
+const { runInteractiveSkillInstaller } = require('./skill-installer');
 
 console.log("🚀 Installing @dmsdc-ai/aigentry-telepty...");
 
@@ -16,38 +17,69 @@ function run(cmd) {
   }
 }
 
-// 1. Install globally via npm
-console.log("📦 Installing package globally...");
-run("npm install -g @dmsdc-ai/aigentry-telepty");
+function resolveInstalledPackageRoot() {
+  try {
+    const globalRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+    return path.join(globalRoot, '@dmsdc-ai', 'aigentry-telepty');
+  } catch (e) {
+    return __dirname;
+  }
+}
+
+async function installSkills() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.log('⏭️  Skipping interactive skill installation (no TTY).');
+    console.log('   Run `telepty` later and choose "Install telepty skills".');
+    return;
+  }
+
+  console.log('\n📋 Telepty skill installation');
 
-// 2. Find executable
-let teleptyPath = '';
-try {
-  teleptyPath = execSync(os.platform() === 'win32' ? 'where telepty' : 'which telepty', { encoding: 'utf8' }).split('\n')[0].trim();
-} catch (e) {
-  teleptyPath = 'telepty'; // fallback
+  try {
+    await runInteractiveSkillInstaller({
+      packageRoot: resolveInstalledPackageRoot(),
+      cwd: process.cwd()
+    });
+  } catch (e) {
+    console.warn('⚠️ Could not install telepty skills:', e.message);
+  }
 }
 
-// 3. Setup OS-specific autostart or background daemon
-const platform = os.platform();
-
-if (platform === 'win32') {
-  console.log("⚙️ Setting up Windows background process...");
-  // Launch daemon in background detaching from current console
-  const subprocess = spawn(teleptyPath, ['daemon'], {
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: true
-  });
-  subprocess.unref();
-  console.log("✅ Windows daemon started in background.");
-
-} else if (platform === 'darwin') {
-  console.log("⚙️ Setting up macOS launchd service...");
-  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.aigentry.telepty.plist');
-  fs.mkdirSync(path.dirname(plistPath), { recursive: true });
-  
-  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+(async () => {
+  // 1. Install globally via npm
+  console.log("📦 Installing package globally...");
+  run("npm install -g @dmsdc-ai/aigentry-telepty");
+
+  // 2. Install telepty skills for supported clients
+  await installSkills();
+
+  // 3. Find executable
+  let teleptyPath = '';
+  try {
+    teleptyPath = execSync(os.platform() === 'win32' ? 'where telepty' : 'which telepty', { encoding: 'utf8' }).split('\n')[0].trim();
+  } catch (e) {
+    teleptyPath = 'telepty'; // fallback
+  }
+
+  // 4. Setup OS-specific autostart or background daemon
+  const platform = os.platform();
+
+  if (platform === 'win32') {
+    console.log("⚙️ Setting up Windows background process...");
+    const subprocess = spawn(teleptyPath, ['daemon'], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true
+    });
+    subprocess.unref();
+    console.log("✅ Windows daemon started in background.");
+
+  } else if (platform === 'darwin') {
+    console.log("⚙️ Setting up macOS launchd service...");
+    const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.aigentry.telepty.plist');
+    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+
+    const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
@@ -64,20 +96,19 @@ if (platform === 'win32') {
     <true/>
 </dict>
 </plist>`;
-  
-  fs.writeFileSync(plistPath, plistContent);
-  try { execSync(`launchctl unload "${plistPath}" 2>/dev/null`); } catch(e){}
-  run(`launchctl load "${plistPath}"`);
-  console.log("✅ macOS LaunchAgent installed and started.");
-
-} else {
-  // Linux
-  try {
-    // Check if systemd is available and running as root/sudo
-    execSync('systemctl --version', { stdio: 'ignore' });
-    if (process.getuid && process.getuid() === 0) {
-      console.log("⚙️ Setting up systemd service for Linux...");
-      const serviceContent = `[Unit]
+
+    fs.writeFileSync(plistPath, plistContent);
+    try { execSync(`launchctl unload "${plistPath}" 2>/dev/null`); } catch(e){}
+    run(`launchctl load "${plistPath}"`);
+    console.log("✅ macOS LaunchAgent installed and started.");
+
+  } else {
+    // Linux
+    try {
+      execSync('systemctl --version', { stdio: 'ignore' });
+      if (process.getuid && process.getuid() === 0) {
+        console.log("⚙️ Setting up systemd service for Linux...");
+        const serviceContent = `[Unit]
 Description=Telepty Daemon
 After=network.target
 
@@ -90,25 +121,26 @@ Environment=NODE_ENV=production
 
 [Install]
 WantedBy=multi-user.target`;
-      
-      fs.writeFileSync('/etc/systemd/system/telepty.service', serviceContent);
-      run('systemctl daemon-reload');
-      run('systemctl enable telepty');
-      run('systemctl start telepty');
-      console.log("✅ Systemd service installed and started.");
-      process.exit(0);
-    }
-  } catch(e) {}
-
-  // Fallback for Linux without systemd or non-root
-  console.log("⚠️ Skipping systemd (no root or no systemd). Starting in background...");
-  const subprocess = spawn(teleptyPath, ['daemon'], {
-    detached: true,
-    stdio: 'ignore'
-  });
-  subprocess.unref();
-  console.log("✅ Linux daemon started in background using nohup equivalent.");
-}
 
-console.log("\n🎉 Installation complete! Telepty daemon is running.");
-console.log("👉 Try running: telepty attach\n");
+        fs.writeFileSync('/etc/systemd/system/telepty.service', serviceContent);
+        run('systemctl daemon-reload');
+        run('systemctl enable telepty');
+        run('systemctl start telepty');
+        console.log("✅ Systemd service installed and started.");
+        process.exit(0);
+      }
+    } catch(e) {}
+
+    // Fallback for Linux without systemd or non-root
+    console.log("⚠️ Skipping systemd (no root or no systemd). Starting in background...");
+    const subprocess = spawn(teleptyPath, ['daemon'], {
+      detached: true,
+      stdio: 'ignore'
+    });
+    subprocess.unref();
+    console.log("✅ Linux daemon started in background using nohup equivalent.");
+  }
+
+  console.log("\n🎉 Installation complete! Telepty daemon is running.");
+  console.log("👉 Try running: telepty attach\n");
+})();

package/install.ps1

@@ -31,3 +31,4 @@ Write-Host "Success: Windows daemon started in background." -ForegroundColor Gre
 
 Write-Host "`nInstallation complete! Telepty daemon is running." -ForegroundColor Cyan
 Write-Host "Next step: Try running: telepty attach" -ForegroundColor Yellow
+Write-Host "Optional: Run telepty and choose 'Install telepty skills' to add skills for Claude Code, Codex, or Gemini" -ForegroundColor Yellow

package/install.sh

@@ -116,3 +116,4 @@ fi
 echo ""
 echo "🎉 Installation complete! Telepty daemon is running in the background."
 echo "👉 Try running: telepty attach"
+echo "👉 Optional: run telepty and choose 'Install telepty skills' to add skills for Claude Code, Codex, or Gemini"

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "main": "daemon.js",
   "bin": {
     "telepty": "cli.js",
     "telepty-install": "install.js"
   },
   "scripts": {
-    "test": "node --test test/auth.test.js test/daemon.test.js test/cli.test.js",
-    "test:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/cli.test.js",
-    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/cli.test.js"
+    "test": "node --test test/auth.test.js test/daemon.test.js test/cli.test.js test/skill-installer.test.js",
+    "test:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/cli.test.js test/skill-installer.test.js",
+    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/cli.test.js test/skill-installer.test.js"
   },
   "keywords": [],
   "author": "",

package/skill-installer.js

@@ -0,0 +1,269 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const prompts = require('prompts');
+
+const TARGET_CLIENTS = {
+  claude: {
+    label: 'Claude Code',
+    globalDir: () => path.join(os.homedir(), '.claude', 'skills'),
+    projectDir: (cwd) => path.join(cwd, '.claude', 'skills'),
+    defaultScope: 'global'
+  },
+  codex: {
+    label: 'Codex',
+    globalDir: () => path.join(os.homedir(), '.codex', 'skills'),
+    projectDir: (cwd) => path.join(cwd, '.codex', 'skills'),
+    defaultScope: 'global'
+  },
+  gemini: {
+    label: 'Gemini',
+    globalDir: () => path.join(os.homedir(), '.gemini', 'skills'),
+    projectDir: (cwd) => path.join(cwd, '.gemini', 'skills'),
+    defaultScope: 'project'
+  }
+};
+
+function resolveSkillsSourceRoot(packageRoot = __dirname) {
+  return path.join(packageRoot, 'skills');
+}
+
+function listPackagedSkills(packageRoot = __dirname) {
+  const sourceRoot = resolveSkillsSourceRoot(packageRoot);
+  if (!fs.existsSync(sourceRoot)) {
+    return [];
+  }
+
+  return fs.readdirSync(sourceRoot)
+    .filter((name) => {
+      const skillDir = path.join(sourceRoot, name);
+      return fs.statSync(skillDir).isDirectory() && fs.existsSync(path.join(skillDir, 'SKILL.md'));
+    })
+    .sort()
+    .map((name) => ({
+      name,
+      sourceDir: path.join(sourceRoot, name)
+    }));
+}
+
+function resolveTargetDirectory(targetClient, scope, cwd, customPath) {
+  const client = TARGET_CLIENTS[targetClient];
+  if (!client) {
+    throw new Error(`Unsupported target client: ${targetClient}`);
+  }
+
+  if (scope === 'custom') {
+    if (!customPath) {
+      throw new Error(`Missing custom path for ${targetClient}`);
+    }
+    return path.resolve(customPath);
+  }
+
+  if (scope === 'project') {
+    return client.projectDir(cwd);
+  }
+
+  return client.globalDir();
+}
+
+function ensureDirectory(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function copySkillDirectory(sourceDir, destDir, overwrite = false) {
+  if (fs.existsSync(destDir)) {
+    if (!overwrite) {
+      return 'exists';
+    }
+    fs.rmSync(destDir, { recursive: true, force: true });
+  }
+
+  ensureDirectory(path.dirname(destDir));
+  fs.cpSync(sourceDir, destDir, { recursive: true });
+  return 'installed';
+}
+
+async function promptForOverwrite(promptImpl, targetLabel, destDir) {
+  const response = await promptImpl({
+    type: 'select',
+    name: 'action',
+    message: `${targetLabel} already has ${path.basename(destDir)}. What should happen?`,
+    choices: [
+      { title: 'Overwrite existing copy', value: 'overwrite' },
+      { title: 'Skip this target', value: 'skip' },
+      { title: 'Cancel installation', value: 'cancel' }
+    ],
+    initial: 1
+  });
+
+  return response.action;
+}
+
+async function installSkillsWithPlan(plan, options = {}) {
+  const promptImpl = options.promptImpl || prompts;
+  const results = [];
+
+  for (const item of plan) {
+    const skillName = item.skill.name;
+    const destDir = path.join(item.destRoot, skillName);
+    let overwrite = false;
+
+    if (fs.existsSync(destDir)) {
+      const action = await promptForOverwrite(promptImpl, item.targetLabel, destDir);
+      if (!action || action === 'cancel') {
+        throw new Error('Installation cancelled.');
+      }
+      if (action === 'skip') {
+        results.push({ ...item, destDir, status: 'skipped' });
+        continue;
+      }
+      overwrite = true;
+    }
+
+    copySkillDirectory(item.skill.sourceDir, destDir, overwrite);
+    results.push({ ...item, destDir, status: overwrite ? 'overwritten' : 'installed' });
+  }
+
+  return results;
+}
+
+async function runInteractiveSkillInstaller(options = {}) {
+  const promptImpl = options.promptImpl || prompts;
+  const packageRoot = options.packageRoot || __dirname;
+  const cwd = options.cwd || process.cwd();
+  const packagedSkills = listPackagedSkills(packageRoot);
+
+  if (packagedSkills.length === 0) {
+    console.log('No packaged skills were found.');
+    return [];
+  }
+
+  let selectedSkills = packagedSkills;
+  if (packagedSkills.length > 1) {
+    const selectedSkillsAnswer = await promptImpl({
+      type: 'multiselect',
+      name: 'skills',
+      message: 'Select skills to install',
+      choices: packagedSkills.map((skill) => ({
+        title: skill.name,
+        value: skill.name
+      })),
+      min: 1
+    });
+
+    if (!selectedSkillsAnswer.skills || selectedSkillsAnswer.skills.length === 0) {
+      console.log('Skipped skill installation.');
+      return [];
+    }
+
+    selectedSkills = packagedSkills.filter((skill) => selectedSkillsAnswer.skills.includes(skill.name));
+  } else {
+    console.log(`Installing packaged skill: ${packagedSkills[0].name}`);
+  }
+
+  const selectedClientsAnswer = await promptImpl({
+    type: 'multiselect',
+    name: 'clients',
+    message: 'Select target clients',
+    choices: Object.entries(TARGET_CLIENTS).map(([key, value]) => ({
+      title: value.label,
+      value: key
+    })),
+    min: 1
+  });
+
+  if (!selectedClientsAnswer.clients || selectedClientsAnswer.clients.length === 0) {
+    console.log('Skipped skill installation.');
+    return [];
+  }
+
+  const destinationSelections = {};
+  for (const clientKey of selectedClientsAnswer.clients) {
+    const client = TARGET_CLIENTS[clientKey];
+    const scopeAnswer = await promptImpl([
+      {
+        type: 'select',
+        name: 'scope',
+        message: `Install ${client.label} skills where?`,
+        choices: [
+          {
+            title: `Global (${client.globalDir()})`,
+            value: 'global'
+          },
+          {
+            title: `Current Project (${client.projectDir(cwd)})`,
+            value: 'project'
+          },
+          {
+            title: 'Custom Path',
+            value: 'custom'
+          }
+        ],
+        initial: client.defaultScope === 'project' ? 1 : 0
+      },
+      {
+        type: (prev) => prev === 'custom' ? 'text' : null,
+        name: 'customPath',
+        message: `Custom ${client.label} skills path:`,
+        initial: client.projectDir(cwd),
+        validate: (value) => value ? true : 'Required'
+      }
+    ]);
+
+    if (!scopeAnswer.scope) {
+      console.log('Skipped skill installation.');
+      return [];
+    }
+
+    destinationSelections[clientKey] = {
+      scope: scopeAnswer.scope,
+      customPath: scopeAnswer.customPath || null
+    };
+  }
+
+  const plan = [];
+
+  for (const clientKey of selectedClientsAnswer.clients) {
+    const client = TARGET_CLIENTS[clientKey];
+    const selection = destinationSelections[clientKey];
+    const destRoot = resolveTargetDirectory(clientKey, selection.scope, cwd, selection.customPath);
+
+    for (const skill of selectedSkills) {
+      plan.push({
+        targetClient: clientKey,
+        targetLabel: client.label,
+        scope: selection.scope,
+        destRoot,
+        skill
+      });
+    }
+  }
+
+  console.log('\nInstalling telepty skills:');
+  for (const item of plan) {
+    console.log(`  - ${item.skill.name} -> ${item.targetLabel} (${item.scope})`);
+    console.log(`    ${item.destRoot}`);
+  }
+
+  const results = await installSkillsWithPlan(plan, { promptImpl });
+
+  console.log('\nSkill installation results:');
+  for (const item of results) {
+    const label = item.status === 'skipped' ? 'Skipped' : 'Installed';
+    console.log(`  ${label}: ${item.skill.name} -> ${item.targetLabel}`);
+    console.log(`    ${item.destDir}`);
+  }
+
+  return results;
+}
+
+module.exports = {
+  TARGET_CLIENTS,
+  copySkillDirectory,
+  installSkillsWithPlan,
+  listPackagedSkills,
+  resolveTargetDirectory,
+  runInteractiveSkillInstaller
+};

package/skills/telepty/SKILL.md

@@ -0,0 +1,86 @@
+# telepty
+
+Use `telepty` to inspect active sessions, check the current telepty session ID, attach to sessions, inject commands, listen to the event bus, rename sessions, and update the daemon.
+
+## When To Use
+
+Use this skill when the user asks to:
+- Check whether the current shell is running inside a telepty session
+- List or inspect telepty sessions
+- Attach to a telepty session
+- Inject a prompt or command into another telepty session
+- Listen to telepty bus events or publish a JSON payload
+- Rename a session
+- Update telepty
+
+## Commands
+
+1. Check the current telepty session:
+
+```bash
+echo "$TELEPTY_SESSION_ID"
+```
+
+2. List sessions:
+
+```bash
+telepty list
+```
+
+3. Attach to a session:
+
+```bash
+telepty attach <session_id>
+```
+
+4. Inject a prompt or command:
+
+```bash
+telepty inject <session_id> "<prompt text>"
+```
+
+5. Inject into multiple sessions:
+
+```bash
+telepty multicast <id1,id2,...> "<prompt text>"
+```
+
+6. Broadcast to all sessions:
+
+```bash
+telepty broadcast "<prompt text>"
+```
+
+7. Rename a session:
+
+```bash
+telepty rename <old_id> <new_id>
+```
+
+8. Listen to the event bus:
+
+```bash
+telepty listen
+```
+
+9. Publish a JSON payload to the bus:
+
+```bash
+TOKEN=$(grep authToken ~/.telepty/config.json | cut -d '"' -f 4)
+curl -s -X POST http://127.0.0.1:3848/api/bus/publish \
+  -H "Content-Type: application/json" \
+  -H "x-telepty-token: $TOKEN" \
+  -d '{"type":"bg_message","payload":"..."}'
+```
+
+10. Update telepty:
+
+```bash
+telepty update
+```
+
+## Notes
+
+- `TELEPTY_SESSION_ID` is only set inside telepty-managed sessions.
+- Use `telepty inject` when the target session should receive the command immediately.
+- Use the JSON bus when the payload should be delivered without interrupting the target shell.

package/.deliberation_request.json

@@ -1 +0,0 @@
-{"topic": "Brainstorming and critiquing the 3 communication modes in telepty (Prompt Injection, Visual Log, Background JSON). What crucial interaction pattern between human users and AI agents is missing from this list? Consider synchronous vs asynchronous, blocking vs non-blocking, and explicit handshakes.", "speakers": ["claude", "codex", "gemini"], "role_preset": "brainstorm"}

package/.deliberation_request2.json

@@ -1 +0,0 @@
-{"topic": "Re-evaluate the telepty architecture based on the user`s strict boundaries: 1. A session equals a physical, visible terminal window. If the window closes, the session MUST die. No zombies. 2. Background persistence is NOT telepty`s job (users can use tmux if they want, but telepty doesn`t manage it). 3. Unexpected disconnects (network drop, sleep) are treated as session death, and recovery is handled via a higher-level `Handoff` of context to a new session, NOT by keeping zombie processes alive. Double-check this philosophy for flaws, focusing on how AI agents will communicate (Pub/Sub) within this strict ephemeral foreground model.", "speakers": ["claude", "codex", "gemini"], "role_preset": "review"}

package/.deliberation_request3.json

@@ -1 +0,0 @@
-{"topic": "Final architectural verification of the Telepty Boundary Model. The user asserts a hard line on responsibility: 1. If a session/process dies, context is lost. That is the CLI/Terminal`s problem, not telepty`s. 2. If a Pub message is sent to a dead Sub, it is lost. Telepty just drops it or relies on Ack. If the sub reconnects in time, it gets it; if not, drop it. 3. If Wi-Fi drops, CLI dies, agent dies, scripts die. Telepty does not care about split-brain or script recovery. Is this stateless, hyper-minimalist `dumb pipe` philosophy technically viable for our goals?", "speakers": ["claude", "gemini", "codex"], "role_preset": "consensus"}