@indianic/dialout 1.1.1 → 1.2.0

package/node_modules/@dialout/shared/src/terminal-name.ts

@@ -0,0 +1,82 @@
+// Pure terminal-name rendering. Shared by the /terminals list, the attach
+// header, and the mobile list so one name shows everywhere. No React, no I/O.
+
+export interface TerminalNameVars {
+  machine_name?: string;
+  folder_name?: string;
+  folder_path?: string;
+  date?: string;
+  time?: string;
+  ampm?: string;
+  git_branch?: string;
+  term_program?: string;
+  short_id?: string;
+}
+
+export const DEFAULT_TERMINAL_TEMPLATE = '[machine_name]-[folder_name]-[date]-[time][ampm]';
+
+export const TERMINAL_NAME_TOKENS = [
+  'machine_name', 'folder_name', 'folder_path',
+  'date', 'time', 'ampm',
+  'git_branch', 'term_program', 'short_id',
+];
+
+function timeParts(iso: string | null): { date: string; time: string; ampm: string } {
+  if (!iso) return { date: '', time: '', ampm: '' };
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return { date: '', time: '', ampm: '' };
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  let h = d.getHours();
+  const ampm = h < 12 ? 'am' : 'pm';
+  h = h % 12; if (h === 0) h = 12;
+  const min = String(d.getMinutes()).padStart(2, '0');
+  return { date: `${yyyy}-${mm}-${dd}`, time: `${h}:${min}`, ampm };
+}
+
+export function factsFromSession(s: {
+  machineName: string;
+  folder: string | null;
+  folderPath: string | null;
+  createdLocal: string | null;
+  startedAt: string | null;
+  gitBranch: string | null;
+  termProgram: string | null;
+  tmuxName: string;
+}): TerminalNameVars {
+  const t = timeParts(s.createdLocal || s.startedAt);
+  const shortId = (s.tmuxName.split('-').pop() || s.tmuxName).slice(0, 8);
+  return {
+    machine_name: s.machineName || '',
+    folder_name: s.folder || '',
+    folder_path: s.folderPath || '',
+    date: t.date,
+    time: t.time,
+    ampm: t.ampm,
+    git_branch: s.gitBranch || '',
+    term_program: s.termProgram && s.termProgram !== 'unknown' ? s.termProgram : '',
+    short_id: shortId,
+  };
+}
+
+export function renderTerminalName(
+  template: string,
+  vars: TerminalNameVars,
+  fallback: string
+): string {
+  if (!template) return fallback;
+  let out = template;
+  for (const token of TERMINAL_NAME_TOKENS) {
+    const value = (vars as Record<string, string | undefined>)[token] ?? '';
+    if (value) {
+      out = out.split(`[${token}]`).join(value);
+    } else {
+      const re = new RegExp(`(?:[-_ ]+)?\\[${token}\\]|\\[${token}\\](?:[-_ ]+)?`, 'g');
+      out = out.replace(re, '');
+    }
+  }
+  out = out.replace(/\[[a-z_]+\]/g, '');
+  out = out.replace(/[-_]{2,}/g, (m) => m[0]).replace(/^[-_ ]+|[-_ ]+$/g, '').trim();
+  return out || fallback;
+}

package/node_modules/@dialout/shared/src/tool-appearance.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import { toolAppearance, toolClass } from './tool-appearance';
+
+describe('tool-appearance', () => {
+  it('maps known tools to their action class', () => {
+    expect(toolClass('Read')).toBe('read');
+    expect(toolClass('Glob')).toBe('read');
+    expect(toolClass('Grep')).toBe('search');
+    expect(toolClass('WebSearch')).toBe('search');
+    expect(toolClass('Bash')).toBe('run');
+    expect(toolClass('Task')).toBe('run');
+    expect(toolClass('Edit')).toBe('write');
+    expect(toolClass('Write')).toBe('write');
+  });
+
+  it('is case and whitespace insensitive', () => {
+    expect(toolClass('  bASh  ')).toBe('run');
+  });
+
+  // New tools ship constantly. An unknown name must render as a neutral row,
+  // never throw and never blank the trace.
+  it('falls back to other for an unknown tool', () => {
+    expect(toolClass('SomeToolShippedNextWeek')).toBe('other');
+    expect(toolAppearance('SomeToolShippedNextWeek').colorVar).toBe('--dim');
+  });
+
+  it('failure beats the name-derived class', () => {
+    const a = toolAppearance('Read', false);
+    expect(a.cls).toBe('failure');
+    expect(a.colorVar).toBe('--offline');
+    expect(a.glyph).toBe('✕');
+  });
+
+  it('every class has a glyph and a colour token', () => {
+    for (const name of ['Read', 'Grep', 'Bash', 'Edit', 'Nonsense']) {
+      const a = toolAppearance(name);
+      expect(a.glyph.length).toBeGreaterThan(0);
+      expect(a.colorVar.startsWith('--')).toBe(true);
+    }
+  });
+});

package/node_modules/@dialout/shared/src/tool-appearance.ts

@@ -0,0 +1,39 @@
+// A tool's colour says what it DID, not which vendor produced it. Reading a
+// twenty-step run should show its shape without reading a word.
+
+export type ToolClass = 'read' | 'search' | 'run' | 'write' | 'failure' | 'other';
+
+export interface ToolAppearance {
+  cls: ToolClass;
+  glyph: string;
+  colorVar: string; // a CSS custom property name, never a literal
+}
+
+const BY_NAME: Record<string, ToolClass> = {
+  read: 'read', glob: 'read', ls: 'read', notebookread: 'read',
+  grep: 'search', websearch: 'search', webfetch: 'search',
+  bash: 'run', task: 'run', agent: 'run',
+  edit: 'write', write: 'write', multiedit: 'write', notebookedit: 'write',
+};
+
+const GLYPH: Record<ToolClass, string> = {
+  read: '◇', search: '⌕', run: '▸', write: '✎', failure: '✕', other: '·',
+};
+
+const COLOR: Record<ToolClass, string> = {
+  read: '--accent',
+  search: '--tool-search',
+  run: '--tool-run',
+  write: '--static',
+  failure: '--offline',
+  other: '--dim',
+};
+
+export function toolClass(name: string): ToolClass {
+  return BY_NAME[String(name || '').trim().toLowerCase()] ?? 'other';
+}
+
+export function toolAppearance(name: string, ok = true): ToolAppearance {
+  const cls: ToolClass = ok ? toolClass(name) : 'failure';
+  return { cls, glyph: GLYPH[cls], colorVar: COLOR[cls] };
+}

package/package.json

@@ -1,33 +1,54 @@
 {
   "name": "@indianic/dialout",
-  "version": "1.1.1",
-  "description": "Organisation alias for `dialout`, the Dialout agent. Installs and runs the real package — see https://www.npmjs.com/package/dialout",
+  "version": "1.2.0",
+  "description": "Dialout agent — reach your office, home or build machine from any browser or phone. Remote tmux terminals, live port checks, filesystem browsing, process control and HTTP tunnels. The agent dials out: no inbound ports, no VPN, no port forwarding.",
   "bin": {
-    "dialout": "./bin/dialout.js"
+    "dialout": "./bin/devdash-agent.js"
   },
+  "main": "./dist/index.js",
   "files": [
     "bin",
-    "README.md"
+    "dist",
+    "scripts/postinstall.js",
+    "README.md",
+    "scripts/prepack.js"
   ],
+  "scripts": {
+    "prebuild": "npx tsc -p ../devdash-shared/tsconfig.json",
+    "build": "tsc",
+    "test": "npm run build && node --test",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "clean": "rm -rf dist",
+    "postinstall": "node scripts/postinstall.js",
+    "prepack": "node scripts/prepack.js"
+  },
   "keywords": [
     "dialout",
     "remote-development",
+    "remote-access",
     "self-hosted",
     "developer-tools",
-    "agent"
+    "tmux",
+    "terminal",
+    "web-terminal",
+    "port-scanner",
+    "localhost-tunnel",
+    "http-tunnel",
+    "devops-dashboard",
+    "claude-code",
+    "codex",
+    "ai-agent",
+    "agent",
+    "daemon",
+    "pty",
+    "websocket"
   ],
   "author": {
     "name": "Sandeep Mundra",
     "email": "sandeep@indianic.com",
     "url": "https://www.indianic.com"
   },
-  "contributors": [
-    {
-      "name": "IndiaNIC Infotech Ltd",
-      "email": "hello@indianic.com",
-      "url": "https://www.indianic.com"
-    }
-  ],
   "license": "MIT",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -41,14 +62,33 @@
     "linux"
   ],
   "dependencies": {
-    "dialout": "^1.1.1"
+    "@dialout/shared": "^1.0.0",
+    "commander": "^12.1.0",
+    "node-pty": "^1.2.0-beta.12",
+    "smol-toml": "^1.8.0",
+    "ws": "^8.17.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.8.3"
   },
   "homepage": "https://www.dialout.dev",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/indianic/dialout.git",
-    "directory": "packages/dialout-scoped"
+    "directory": "packages/devdash-agent"
   },
+  "bundleDependencies": [
+    "@dialout/shared"
+  ],
+  "contributors": [
+    {
+      "name": "IndiaNIC Infotech Ltd",
+      "email": "hello@indianic.com",
+      "url": "https://www.indianic.com"
+    }
+  ],
   "bugs": {
     "url": "https://github.com/indianic/dialout/issues",
     "email": "hello@indianic.com"

package/scripts/postinstall.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const os = require('os');
+
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+const BOLD = '\x1b[1m';
+const NC = '\x1b[0m';
+
+function check(label, fn) {
+  try {
+    const result = fn();
+    console.log(`${GREEN}  ✓${NC} ${label}${result ? ` — ${result}` : ''}`);
+    return true;
+  } catch (err) {
+    console.log(`${RED}  ✗${NC} ${label} — ${err.message || 'failed'}`);
+    return false;
+  }
+}
+
+console.log('');
+console.log(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`);
+console.log(`${BOLD}  dialout installed${NC}`);
+console.log(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`);
+console.log('');
+
+console.log(`${CYAN}Checking requirements...${NC}`);
+
+const nodeOk = check('Node.js >= 18', () => {
+  const v = process.version.replace('v', '');
+  const major = parseInt(v.split('.')[0]);
+  if (major < 18) throw new Error(`found ${process.version}, need >= 18`);
+  return process.version;
+});
+
+const platformOk = check('Platform supported', () => {
+  const p = os.platform();
+  if (p !== 'darwin' && p !== 'linux') throw new Error(`${p} not supported yet`);
+  return `${p} ${os.arch()}`;
+});
+
+const ptyOk = check('node-pty native module', () => {
+  require('node-pty');
+  return 'loaded';
+});
+
+console.log('');
+
+if (!ptyOk) {
+  console.log(`${YELLOW}  node-pty failed to load. Try rebuilding:${NC}`);
+  console.log(`  npm rebuild node-pty`);
+  console.log('');
+}
+
+if (nodeOk && platformOk && ptyOk) {
+  console.log(`${GREEN}All checks passed!${NC}`);
+} else {
+  console.log(`${YELLOW}Some checks failed. The agent may not work correctly.${NC}`);
+}
+
+console.log('');
+console.log(`${CYAN}Next steps:${NC}`);
+console.log('');
+console.log('  1. Generate an API key in the DevDash web UI (MACHINES tab)');
+console.log('');
+console.log('  2. Configure the agent:');
+console.log(`     ${BOLD}devdash-agent init${NC}`);
+console.log('');
+console.log('  3. Start the agent:');
+console.log(`     ${BOLD}devdash-agent start${NC}`);
+console.log('');
+console.log('  4. Install as service (auto-start on boot):');
+console.log(`     ${BOLD}devdash-agent install-service${NC}`);
+console.log('');
+console.log(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`);
+console.log('');

package/scripts/prepack.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * Stages @dialout/shared into this package's own node_modules so that
+ * `bundleDependencies` picks it up.
+ *
+ * Why bundle it at all: `dialout` is meant to be the only thing a user
+ * installs. The shared package is a handful of types and constants used by the
+ * server, the agent and the mobile app; publishing it separately would mean a
+ * second package to version, and an `npm i -g dialout` that silently fails
+ * with E404 for anyone who installs before it exists.
+ *
+ * Why a script rather than letting npm do it: bundleDependencies packs from
+ * this package's OWN node_modules, and in a workspace the dependency is
+ * symlinked at the repo root instead. npm will not follow that symlink into
+ * the tarball, so without this step the tarball ships a require() with nothing
+ * behind it — and the failure only shows up on a machine that has no local
+ * checkout, which is every real user.
+ *
+ * Runs automatically on `npm pack` and `npm publish`.
+ */
+const { cpSync, existsSync, mkdirSync, rmSync } = require('node:fs');
+const { join, resolve } = require('node:path');
+
+const here = resolve(__dirname, '..');
+const source = resolve(here, '..', 'devdash-shared');
+const target = join(here, 'node_modules', '@dialout', 'shared');
+
+if (!existsSync(source)) {
+  console.error(`prepack: cannot find the shared package at ${source}`);
+  process.exit(1);
+}
+if (!existsSync(join(source, 'dist'))) {
+  console.error('prepack: the shared package has no dist/ — build it first');
+  process.exit(1);
+}
+
+rmSync(target, { recursive: true, force: true });
+mkdirSync(join(here, 'node_modules', '@dialout'), { recursive: true });
+cpSync(source, target, {
+  recursive: true,
+  // Its own node_modules would drag the whole workspace tree in behind it.
+  filter: (src) => !src.includes(`${join('shared', 'node_modules')}`) && !src.includes('/.git'),
+});
+rmSync(join(target, 'node_modules'), { recursive: true, force: true });
+console.log('prepack: staged @dialout/shared for bundling');

package/bin/dialout.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-// Delegates straight to the real implementation.
-//
-// This package exists only so that `@indianic/dialout` resolves under the
-// organisation's namespace. It ships no code of its own — `dialout` is the
-// package that does the work, and this depends on it.
-//
-// The require is resolved from this package's own node_modules, so whichever
-// version of `dialout` the dependency range installed is the one that runs.
-// There is deliberately no version check here: pinning would mean this alias
-// has to be republished for every agent release, which is exactly the
-// maintenance burden it is supposed to avoid.
-require('dialout/dist/cli.js');