@dmsdc-ai/aigentry-telepty 0.1.6 → 0.1.8

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"}

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

@@ -1,55 +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 rename a session:**
-   - Run `telepty rename <old_id> <new_id>`
-   - This updates the session key, Ghostty tab title, and broadcasts a `session_rename` event on the bus.
-7. **Terminal Title Convention:**
-   - Each telepty session displays its ID in the Ghostty tab title.
-   - Local: `⚡ telepty :: {session_id}`
-   - Remote: `⚡ telepty :: {session_id} @ {host}`
-8. **To update telepty:**
-   - Run `telepty update`.

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

@@ -1,26 +0,0 @@
-name: Regression Tests
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-  workflow_dispatch:
-
-jobs:
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        node: [20]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: npm
-      - name: Install dependencies
-        run: npm ci
-      - name: Run regression suite
-        run: npm run test:ci

package/test/auth.test.js

@@ -1,56 +0,0 @@
-'use strict';
-
-const { test, before, after } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-// Use a temp directory to isolate tests from the real ~/.telepty config.
-// We patch os.homedir() before requiring auth.js so the module-level
-// constants (CONFIG_DIR, CONFIG_FILE) resolve to the temp dir.
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'telepty-test-'));
-const originalHomedir = os.homedir.bind(os);
-
-before(() => {
-  os.homedir = () => tmpDir;
-  // Ensure auth.js is loaded fresh with the patched homedir
-  delete require.cache[require.resolve('../auth.js')];
-});
-
-after(() => {
-  os.homedir = originalHomedir;
-  delete require.cache[require.resolve('../auth.js')];
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-test('getConfig() returns an object with authToken property', () => {
-  const { getConfig } = require('../auth.js');
-  const config = getConfig();
-  assert.ok(config !== null && typeof config === 'object', 'config should be an object');
-  assert.ok('authToken' in config, 'config should have authToken property');
-  assert.equal(typeof config.authToken, 'string', 'authToken should be a string');
-});
-
-test('authToken is a valid UUID v4 format', () => {
-  const { getConfig } = require('../auth.js');
-  const config = getConfig();
-  const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  assert.match(config.authToken, uuidV4Regex, 'authToken should be a valid UUID v4');
-});
-
-test('config object has createdAt field', () => {
-  const { getConfig } = require('../auth.js');
-  const config = getConfig();
-  assert.ok('createdAt' in config, 'config should have createdAt property');
-  const date = new Date(config.createdAt);
-  assert.ok(!isNaN(date.getTime()), 'createdAt should be a valid ISO date string');
-});
-
-test('calling getConfig() twice returns the same token (persistence)', () => {
-  const { getConfig } = require('../auth.js');
-  const config1 = getConfig();
-  const config2 = getConfig();
-  assert.equal(config1.authToken, config2.authToken, 'authToken should be identical across calls');
-  assert.equal(config1.createdAt, config2.createdAt, 'createdAt should be identical across calls');
-});

package/test/cli.test.js

@@ -1,57 +0,0 @@
-'use strict';
-
-const { afterEach, beforeEach, test } = require('node:test');
-const assert = require('node:assert/strict');
-const { createSessionId, startTestDaemon, stripAnsi, waitFor } = require('../test-support/daemon-harness');
-
-let harness;
-
-function collectJsonMessages(ws) {
-  const messages = [];
-  ws.on('message', (chunk) => {
-    try {
-      messages.push(JSON.parse(chunk.toString()));
-    } catch {
-      // Ignore malformed payloads in tests.
-    }
-  });
-  return messages;
-}
-
-beforeEach(async () => {
-  harness = await startTestDaemon();
-});
-
-afterEach(async () => {
-  await harness.stop();
-});
-
-test('telepty list prints active sessions from the configured host and port', async () => {
-  const sessionId = createSessionId('cli-list');
-  await harness.spawnSession(sessionId);
-
-  const result = await harness.runCli(['list']);
-  assert.equal(result.code, 0, result.stderr);
-
-  const output = stripAnsi(`${result.stdout}\n${result.stderr}`);
-  assert.match(output, new RegExp(sessionId));
-  assert.match(output, /Active Sessions/i);
-});
-
-test('telepty inject forwards input to the target PTY session', async () => {
-  const sessionId = createSessionId('cli-inject');
-  await harness.spawnSession(sessionId);
-
-  const ws = await harness.connectSession(sessionId);
-  const outputs = collectJsonMessages(ws);
-  const token = createSessionId('cli-token');
-
-  const result = await harness.runCli(['inject', sessionId, `echo ${token}`]);
-  assert.equal(result.code, 0, result.stderr);
-
-  await waitFor(() => outputs.some((message) => (
-    message.type === 'output' && String(message.data).includes(token)
-  )), { timeoutMs: 7000, description: 'CLI inject output' });
-
-  ws.close();
-});