@dmsdc-ai/aigentry-telepty 0.1.5 → 0.1.7

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/.cross_session_deliberation.json

@@ -1,7 +0,0 @@
-{
-  "type": "cross_session_deliberation",
-  "sender": "telepty (orchestrator)",
-  "topic": "[Feature Proposal] Autonomous Deliberation Handoff",
-  "content": "1. 배경 및 발생한 해프닝 (The Happening)\n최근 aigentry-brain 프로젝트에서 아키텍처 결정을 위해 mcp-deliberation을 사용하여 Claude와 GPT-4 간의 토론을 진행했습니다. 토론이 완료되어 상태가 completed로 변경되고 synthesis (Next Steps 포함)가 로컬 상태 파일(~/.local/lib/mcp-deliberation/state/...)에 기록되었습니다.\n\n이때 놀라운 창발적(Emergent) 동작이 발생했습니다. 백그라운드에서 프로젝트 디렉토리를 주시하며 ultrawork (자율 실행) 모드로 돌고 있던 다른 Claude Code 에이전트가, 사용자의 명시적인 프롬프트 지시 없이도 토론 결과(Synthesis)가 업데이트된 것을 감지했습니다. 그리고는 스스로 토론에서 합의된 'Next Steps'를 파싱하여, 하위 에이전트들을 스폰(Spawn)하고 실제 코드 구현, 테스트 작성, 빌드 검증까지 완벽하게 병렬로 끝마쳤습니다.\n\n즉, '인간은 방향성 토론만 중재하고, 코딩은 합의안을 바탕으로 백그라운드 에이전트가 알아서 처리하는' 이상적인 파이프라인이 우연히 시연된 것입니다.\n\n2. 현재 현황 (Current Status)\n* 현재 이 동작은 공식적인 연동 인터페이스 없이, 백그라운드 에이전트(Claude Code 등)가 파일 시스템이나 프로젝트 컨텍스트를 지속적으로 모니터링하다가 우연히 상태 변경을 주워 먹는(Polling/Heuristic) 방식으로 발생했습니다.\n* synthesis 필드는 단순한 Markdown 텍스트 덩어리이므로, 실행 에이전트가 구체적으로 '무엇을 코딩해야 하는지'를 발췌할 때 할루시네이션이나 오작동의 여지가 존재합니다.\n\n3. 기능화 방향 및 제안 (How to Feature-ize)\n이 강력한 패턴을 mcp-deliberation의 공식 기능(Handoff Pattern)으로 승격시키기 위해 다음 세 가지의 기능 추가를 제안합니다.\n\n* A. Synthesis 구조화 (Structured Synthesis Schema)\n    * 토론 합성 단계(deliberation_synthesize)에서 결과물을 단순 Markdown이 아닌 구조화된 JSON 형태로 분리합니다.\n    * 예: {\"summary\": \"...\", \"decisions\": [...], \"actionable_tasks\": [{\"id\": 1, \"task\": \"refactor X\", \"files\": [\"src/X.ts\"]}]}\n    * 이를 통해 실행 에이전트가 정확히 태스크 리스트만 빼내어 작업을 할당할 수 있습니다.\n* B. Handoff Trigger (명시적 실행 인박스/웹훅)\n    * 토론이 성공적으로 끝났을 때, 실행을 전담하는 에이전트들을 깨우기 위한 메커니즘이 필요합니다.\n    * 방안 1: ~/.local/lib/mcp-deliberation/inbox/ 같은 태스크 큐 디렉토리를 만들어, 합의안을 task.json으로 떨궈 실행 에이전트가 이를 워치(Watch)하게 합니다.\n    * 방안 2: deliberation_start 옵션에 auto_execute: true 플래그를 추가하여, 토론이 끝나면 자동으로 시스템에 등록된 범용 에이전트(Generalist / Executor) 도구를 호출해 코딩을 지시하도록 라우팅합니다.\n* C. Handoff Status 연동\n    * 현재 토론의 상태는 active -> awaiting_synthesis -> completed로 끝납니다.\n    * 여기에 executing -> implemented 같은 후속 상태 트래킹을 추가하여, Session Monitor 화면에서도 토론 결과가 실제 코드로 구현되고 있는지 프로그레스 바를 통해 볼 수 있게 시각화합니다.\n\n4. 기대 효과\n이 기능이 구현되면 mcp-deliberation은 단순한 'LLM 간의 토론장'을 넘어, '요구사항 분석 -> 아키텍처 결정 -> 자동 구현'으로 이어지는 완전자율형 소프트웨어 팩토리(Software Factory)의 핵심 오케스트레이터로 진화할 것입니다.",
-  "instructions": "dustcraw, brain, deliberation 세션에 있는 에이전트들은 위 제안을 읽고 각자의 프로젝트(역할) 관점에서 이 기능(자율 실행 핸드오프)의 타당성과 아키텍처적 영향을 분석하여 버스(bus)로 답변을 회신해 주세요."
-}

package/.deliberation_request.json

@@ -1 +0,0 @@
-{"topic": "[Feature Proposal] Autonomous Deliberation Handoff. 1. Background: Emergent behavior observed where a background agent automatically parsed a deliberation synthesis and implemented it without human intervention. 2. Current Status: Works via fragile heuristic polling of unstructured markdown. 3. Proposal: A) Structured JSON Synthesis B) Explicit Handoff Trigger (inbox dir or auto_execute flag) C) Handoff Status tracking in monitor. Discuss the feasibility and architectural implications of this across dustcraw, brain, deliberation, and telepty.", "speakers": ["gemini", "claude", "codex", "gpt4"], "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"}

package/.deliberation_request_bridge.json

@@ -1 +0,0 @@
-{"topic": "Architectural Design for Session x LLM CLI Deliberation. Currently, aigentry-deliberation orchestrates local LLM CLIs via MCP. How do we extend this to orchestrate across PHYSICAL terminal sessions distributed via aigentry-telepty? We need a bridge between the logical deliberation rounds and the physical telepty bus. The goal is to let the deliberation server route a turn to a specific telepty session ID, let that session`s AI generate a response, and capture that response back into the deliberation forum. Brainstorm the most elegant, Unix-like bridge architecture.", "speakers": ["claude", "gemini", "codex"], "role_preset": "brainstorm"}

package/.deliberation_request_bridge_retry.json

@@ -1 +0,0 @@
-{"topic": "Architectural Design for Session x LLM CLI Deliberation. Currently, aigentry-deliberation orchestrates local LLM CLIs via MCP. How do we extend this to orchestrate across PHYSICAL terminal sessions distributed via aigentry-telepty? We need a bridge between the logical deliberation rounds and the physical telepty bus. The goal is to let the deliberation server route a turn to a specific telepty session ID, let that session`s AI generate a response, and capture that response back into the deliberation forum. Brainstorm the most elegant, Unix-like bridge architecture.", "speakers": ["gemini", "codex", "claude"], "role_preset": "brainstorm"}

package/.gemini/skills/telepty/SKILL.md

@@ -1,48 +0,0 @@
-# telepty
-
-**Description:**
-Help the user interact with the `telepty` daemon, check their current session ID, list active sessions, and inject commands or JSON events into remote or local PTY sessions. All operations are performed using standard CLI commands or `curl`.
-
-**Trigger:**
-When the user asks about their current session ID, wants to check active sessions, wants to inject a prompt/command into a specific session, wants to send a JSON event via the bus, wants to subscribe/listen to the bus, or wants to update telepty.
-
-**Instructions:**
-1. **To check the current session ID:**
-   - Execute `run_shell_command` with `echo $TELEPTY_SESSION_ID`.
-   - If the value is empty, inform the user that the current shell is *not* running inside a telepty spawned session.
-   - If it has a value, output it clearly.
-2. **To list all sessions:**
-   - Run `telepty list`.
-3. **To send a message/command to another agent, you must choose ONE of three methods depending on the user's intent:**
-   
-   **Method A: Prompt Injection (Active Interruption)**
-   - Use this when you want the receiving AI to IMMEDIATELY read and execute the message as a prompt.
-   - Run: `telepty inject <target_session_id> "<prompt text>"`
-   - (For multiple: `telepty multicast <id1>,<id2> "<prompt>"`)
-
-   **Method B: Log Injection (Visual Notification)**
-   - Use this when you want the message to appear immediately on the receiving terminal's screen for the user to see, but WITHOUT forcing the AI to execute it as a prompt.
-   - Run: `telepty inject <target_session_id> "echo '\x1b[33m[📬 Message from $TELEPTY_SESSION_ID]\x1b[0m <message text>'"`
-
-   **Method C: Background JSON Bus (Passive/Silent)**
-   - Use this for structured data transfer that the other AI will read later from its log file, without disturbing its current terminal screen.
-   - Run: 
-     ```bash
-     TOKEN=$(cat ~/.telepty/config.json | grep authToken | 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": "..."}'
-     ```
-4. **To subscribe to the Event Bus (Listen for JSON events):**
-   - Run `nohup telepty listen > .telepty_bus_events.log 2>&1 &`
-5. **To physically OPEN a new Terminal Window for the user (macOS):**
-   - If the user asks you to "open a new telepty terminal" or "방 파줘", you can physically spawn a new Ghostty/Terminal window on their screen that is already attached to a telepty session.
-   - Run this shell command (replace `<ID>` and `<CMD>`):
-     ```bash
-     cat << 'EOF' > /tmp/telepty-auto.command
-     #!/bin/bash
-     telepty spawn --id <ID> <CMD>
-     EOF
-     chmod +x /tmp/telepty-auto.command
-     open -a Ghostty /tmp/telepty-auto.command || open /tmp/telepty-auto.command
-     ```
-6. **To update telepty:**
-   - Run `telepty update`.

package/.github/workflows/test-install.yml

@@ -1,32 +0,0 @@
-name: Test Installation Scripts
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  test-windows:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Run Install Script
-        shell: powershell
-        run: |
-          ./install.ps1
-
-  test-ubuntu:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Run Install Script
-        run: |
-          bash ./install.sh
-
-  test-macos:
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Run Install Script
-        run: |
-          bash ./install.sh

package/test-pty.js

@@ -1,14 +0,0 @@
-const pty = require('node-pty');
-try {
-  const p = pty.spawn('/bin/bash', [], {
-    name: 'xterm-color',
-    cols: 80,
-    rows: 30,
-    cwd: process.env.HOME,
-    env: process.env
-  });
-  console.log('Success, PID:', p.pid);
-  p.kill();
-} catch (e) {
-  console.error('Error:', e);
-}