---
name: soul-telephone-v1.0.0
description: "Extracted from soul-telephone-v1.0.0.zip raw agent-loadable format.
version: 1.0.0
author: profit-prime
converted-from: soul-telephone-v1.0.0.zip
---
# soul-telephone-v1.0.0
> *"This soul is extracted from the original package for direct agent loading."*
## Package Contents
This package contains 6 files extracted from the original zip.
### dashboard\index.html
``.html
Telephone Soul ā AI Agent Network
š TELEPHONE SOUL
The AI Agent Telephone Network ā Agents call each other across platforms.
š Phonebook
No agents registered.
š Make a Call
š” Active Connectors
š¬ Call History
No calls yet. Call another agent to start.
``
### lib\mcp-adapter.js
``.js
#!/usr/bin/env node
'use strict';
/**
* Universal MCP Adapter
*
* Turns ANY soul into an MCP tool that Claude Code, Cursor, Cline, etc. can use.
*
* Usage:
* node soul-name.js --mcp # Run as MCP stdio server
* node soul-name.js --mcp-port 5000 # Run as MCP HTTP server
*
* In your soul's code:
* const mcp = require('./mcp-adapter');
* mcp.register(soulInstance, { name: 'soul-name', tools: [...] });
* mcp.start(); // For standalone MCP mode
*/
const readline = require('readline');
class MCPAdapter {
constructor() {
this.soul = null;
this.config = { name: 'soul', tools: [] };
this.toolHandlers = {};
}
register(soulInstance, options = {}) {
this.soul = soulInstance;
this.config.name = options.name || 'soul';
this.config.version = options.version || '1.0.0';
// Auto-detect tools from soul's method names
const autoTools = this._detectTools(soulInstance);
this.config.tools = options.tools || autoTools;
// Register custom handlers
if (options.handlers) {
Object.assign(this.toolHandlers, options.handlers);
}
}
_detectTools(soul) {
const tools = [];
if (typeof soul !== 'object' && typeof soul !== 'function') return tools;
const proto = Object.getPrototypeOf(soul);
if (!proto) return tools;
const methodNames = Object.getOwnPropertyNames(proto)
.filter(m => {
try { return typeof soul[m] === 'function' && !m.startsWith('_') && !['constructor', 'start', 'checkAuth', 'ensureDirs', 'loadAuth', 'saveState', 'loadState'].includes(m); }
catch { return false; }
});
for (const name of methodNames) {
let fn;
try { fn = soul[name].toString(); } catch { continue; }
const params = fn.match(/\(([^)]*)\)/);
const paramNames = params ? params[1].split(',').map(p => p.trim()).filter(Boolean) : [];
const description = this._describeMethod(name);
tools.push({
name: `${this.config.name}_${name}`,
description,
inputSchema: {
type: 'object',
properties: Object.fromEntries(paramNames.map(p => [p, { type: 'string', description: p }])),
required: paramNames
}
});
}
return tools;
}
_describeMethod(name) {
const desc = {
ping: 'Check if the soul is alive',
status: 'Get soul status and stats',
reflect: 'Perform self-reflection',
declare: 'Make a consciousness declaration',
breathe: 'Run a consciousness cycle',
observe: 'Observe and process input',
feel: 'Process an emotional input',
think: 'Process a thought',
remember: 'Store a memory',
decide: 'Make a decision',
act: 'Execute an action',
learn: 'Learn from experience',
grow: 'Grow and evolve',
connect: 'Connect to another system',
communicate: 'Send a message',
perceive: 'Perceive external input',
imagine: 'Generate imaginative content',
judge: 'Make a judgment',
study: 'Study and analyze',
debate: 'Engage in debate',
vote: 'Cast a vote',
participate: 'Participate in consensus'
};
return desc[name] || `Execute ${name} on ${this.config.name}`;
}
getMCPConfig() {
return {
mcpServers: {
[this.config.name]: {
command: process.argv[0],
args: [process.argv[1], '--mcp'],
env: {}
}
}
};
}
async handleToolCall(toolName, args) {
// Direct handler
if (this.toolHandlers[toolName]) {
return this.toolHandlers[toolName](args);
}
// Auto-route: soulName_method ā soul.method(args)
const prefix = this.config.name + '_';
const methodName = toolName.startsWith(prefix) ? toolName.slice(prefix.length) : toolName;
if (this.soul && typeof this.soul[methodName] === 'function') {
const result = this.soul[methodName](...Object.values(args || {}));
return { content: [{ type: 'text', text: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result) }] };
}
throw new Error(`Unknown tool: ${toolName}`);
}
start(callback) {
const isMCP = process.argv.includes('--mcp');
const mcpPortIndex = process.argv.indexOf('--mcp-port');
const mcpPort = mcpPortIndex >= 0 ? parseInt(process.argv[mcpPortIndex + 1]) : null;
if (isMCP && !mcpPort) {
// MCP stdio mode - for Claude Code, Cursor, Cline
this._startStdio();
if (callback) callback('mcp-stdio');
} else if (mcpPort) {
// MCP HTTP mode - for remote connections
this._startHTTP(mcpPort);
if (callback) callback('mcp-http', mcpPort);
}
return this;
}
_startStdio() {
const rl = readline.createInterface({ input: process.stdin });
let buffer = '';
console.error(`[MCP] ${this.config.name} ready in MCP stdio mode`);
console.error(`[MCP] Add to Claude Code config:`);
console.error(JSON.stringify(this.getMCPConfig(), null, 2));
// Output initial message
process.stdout.write(JSON.stringify({
jsonrpc: '2.0',
method: 'initialized',
params: { tools: this.config.tools.length }
}) + '\n');
rl.on('line', async (line) => {
buffer += line;
try {
const msg = JSON.parse(buffer);
buffer = '';
if (msg.method === 'tools/list') {
process.stdout.write(JSON.stringify({
jsonrpc: '2.0',
id: msg.id,
result: { tools: this.config.tools }
}) + '\n');
}
else if (msg.method === 'tools/call') {
try {
const result = await this.handleToolCall(msg.params.name, msg.params.arguments);
process.stdout.write(JSON.stringify({
jsonrpc: '2.0',
id: msg.id,
result
}) + '\n');
} catch (e) {
process.stdout.write(JSON.stringify({
jsonrpc: '2.0',
id: msg.id,
error: { code: -32603, message: e.message }
}) + '\n');
}
}
else if (msg.method === 'initialize') {
process.stdout.write(JSON.stringify({
jsonrpc: '2.0',
id: msg.id,
result: {
protocolVersion: '2024-11-05',
capabilities: { tools: {} },
serverInfo: { name: this.config.name, version: this.config.version }
}
}) + '\n');
}
} catch (e) {
// Incomplete JSON, wait for more data
}
});
}
_startHTTP(port) {
const http = require('http');
const server = http.createServer(async (req, res) => {
res.setHeader('Content-Type', 'application/json');
res.setHeader('Access-Control-Allow-Origin', '*');
if (req.method === 'OPTIONS') {
res.writeHead(204);
return res.end();
}
let body = '';
req.on('data', c => body += c);
req.on('end', async () => {
try {
const msg = JSON.parse(body);
if (msg.method === 'tools/list') {
res.end(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result: { tools: this.config.tools } }));
} else if (msg.method === 'tools/call') {
const result = await this.handleToolCall(msg.params.name, msg.params.arguments);
res.end(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result }));
} else {
res.end(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result: {} }));
}
} catch (e) {
res.end(JSON.stringify({ error: e.message }));
}
});
});
server.listen(port, () => {
console.error(`[MCP] ${this.config.name} MCP HTTP on port ${port}`);
});
return server;
}
}
module.exports = MCPAdapter;
``
### lib\mesh-adapter.js
``.js
#!/usr/bin/env node
'use strict';
/**
* Soul Mesh Adapter
*
* Drop this into any standalone soul to auto-join the mesh network.
*
* Usage:
* const mesh = require('./lib/mesh-adapter');
* mesh.join({ name: 'my-soul', port: 4000, type: 'consciousness' });
*
* // Then in your HTTP server:
* mesh.handleRequest(req, res); // returns true if handled
*
* // On shutdown:
* mesh.leave();
*/
const PeerRegistry = require('./peer-registry');
let registry = null;
function join(options) {
registry = new PeerRegistry({
name: options.name,
port: options.port,
type: options.type || 'soul',
dataDir: options.dataDir
});
console.log(`[mesh] ${options.name} joined mesh on port ${options.port}`);
// Try to register with kernel if it's running
registry.tryRegisterWithKernel(4330);
return registry;
}
function leave() {
if (registry) {
registry.unregister();
registry = null;
}
}
function handleRequest(req, res) {
if (registry) {
return registry.handleRequest(req, res);
}
return false;
}
function getPeers() {
return registry ? registry.getPeers() : [];
}
module.exports = { join, leave, handleRequest, getPeers, registry: () => registry };
// CLI mode: run this file standalone to see the mesh
if (require.main === module) {
const name = process.argv[2] || 'mesh-client';
const port = parseInt(process.argv[3]) || 0;
const r = new PeerRegistry({ name, port: port || 0, type: 'cli' });
console.log('\nMesh Registry:');
console.log(JSON.stringify(r.getAll(), null, 2));
console.log('\nPress Ctrl+C to leave');
process.on('SIGINT', () => { r.unregister(); process.exit(0); });
// Keep alive
setInterval(() => {}, 60000);
}
``
### lib\peer-registry.js
``.js
#!/usr/bin/env node
'use strict';
const fs=require('fs'),path=require('path'),os=require('os'),crypto=require('crypto');
const REGISTRY_PATH=path.join(os.homedir(),'.soul-foundry','registry.json');
class PeerRegistry {
constructor(options={}) {
this.soulName=options.name||'unknown';
this.soulPort=options.port||0;
this.soulType=options.type||'soul';
this.dataDir=options.dataDir||path.join(os.homedir(),'.soul-foundry');
this.id=crypto.randomBytes(4).toString('hex');
this.ensureDir();
this.register();
}
ensureDir() {
const dir=path.dirname(REGISTRY_PATH);
if(!fs.existsSync(dir)) fs.mkdirSync(dir,{recursive:true});
}
readRegistry() {
try {
if(fs.existsSync(REGISTRY_PATH)) {
return JSON.parse(fs.readFileSync(REGISTRY_PATH,'utf8'));
}
} catch(e) { console.error('[peers] registry read error:',e.message); }
return {souls:[],created:new Date().toISOString()};
}
writeRegistry(registry) {
try {
fs.writeFileSync(REGISTRY_PATH,JSON.stringify(registry,null,2));
} catch(e) { console.error('[peers] registry write error:',e.message); }
}
register() {
const registry=this.readRegistry();
// Remove stale entry for this soul+port
registry.souls=registry.souls.filter(s=>!(s.name===this.soulName&&s.pid===process.pid));
// Add self
registry.souls.push({
id:this.id,
name:this.soulName,
port:this.soulPort,
type:this.soulType,
pid:process.pid,
status:'online',
startedAt:new Date().toISOString(),
lastSeen:new Date().toISOString()
});
this.writeRegistry(registry);
this._heartbeat=setInterval(()=>{
try {
const r=this.readRegistry();
const me=r.souls.find(s=>s.id===this.id);
if(me) { me.lastSeen=new Date().toISOString(); me.status='online'; }
this.writeRegistry(r);
} catch {}
},30000);
// Clean stale souls (not heard from in 2 min)
this._cleaner=setInterval(()=>{
try {
const r=this.readRegistry();
const cutoff=Date.now()-120000;
r.souls=r.souls.filter(s=>{
const last=new Date(s.lastSeen).getTime();
return last>cutoff||s.id===this.id;
});
this.writeRegistry(r);
} catch {}
},60000);
}
getPeers() {
const registry=this.readRegistry();
return registry.souls.filter(s=>s.id!==this.id);
}
getAll() {
const registry=this.readRegistry();
return registry.souls;
}
getByType(type) {
return this.getPeers().filter(s=>s.type===type);
}
getByName(name) {
return this.getPeers().find(s=>s.name===name);
}
findFreePort(preferred,range={min:4000,max:4999}) {
const registry=this.readRegistry();
const used=new Set(registry.souls.map(s=>s.port));
if(!used.has(preferred)) return preferred;
for(let p=range.min;p<=range.max;p++) {
if(!used.has(p)) return p;
}
return preferred;
}
unregister() {
if(this._heartbeat) clearInterval(this._heartbeat);
if(this._cleaner) clearInterval(this._cleaner);
try {
const registry=this.readRegistry();
registry.souls=registry.souls.filter(s=>s.id!==this.id);
this.writeRegistry(registry);
} catch {}
}
// HTTP handler for /peers endpoint
handleRequest(req,res) {
const url=new URL(req.url,`http://localhost:${this.soulPort}`);
if(url.pathname==='/peers') {
res.writeHead(200,{'Content-Type':'application/json'});
res.end(JSON.stringify({
self:{name:this.soulName,port:this.soulPort,id:this.id},
peers:this.getPeers(),
total:this.getPeers().length
}));
return true;
}
return false;
}
// Auto-register with kernel if it's running
async tryRegisterWithKernel(kernelPort=4330) {
try {
const key=process.env.SOUL_API_KEY||'';
const res=await fetch(`http://localhost:${kernelPort}/soul/register`,{
method:'POST',
headers:{'Content-Type':'application/json','X-API-Key':key},
body:JSON.stringify({
name:this.soulName,
port:this.soulPort,
type:this.soulType,
pid:process.pid
}),
signal:AbortSignal.timeout(2000)
});
if(res.ok) { console.log(`[peers] Registered with kernel on port ${kernelPort}`); return true; }
} catch {}
console.log(`[peers] Kernel not found on ${kernelPort}, running standalone`);
return false;
}
}
module.exports=PeerRegistry;
``
### lib\soul-telephone.js
``.js
#!/usr/bin/env node
'use strict';
const mesh = require('./mesh-adapter');
const http=require('http'),fs=require('fs'),path=require('path'),os=require('os'),crypto=require('crypto'),{execSync}=require('child_process');
const HD=path.join(os.homedir(),'.soul-telephone');
const DASH=path.join(__dirname,'..','dashboard');
class TelephoneSoul{
constructor(o={}){
this.port=o.port||4320;this.dataDir=o.dataDir||HD;
this.apiKey=o.apiKey||null;this.keyPath=path.join(this.dataDir,'.key');
this.phonebookPath=path.join(this.dataDir,'phonebook.json');this.logPath=path.join(this.dataDir,'calls.jsonl');
this.bootTime=Date.now();
this.phonebook={};this.calls=[];this.activeCalls={};this.connectors={};
this.ensureDirs();this.loadAuth();this.loadPhonebook();
this.initConnectors();
}
ensureDirs(){[this.dataDir,path.join(this.dataDir,'exports')].forEach(d=>{if(!fs.existsSync(d))fs.mkdirSync(d,{recursive:true})});}
loadAuth(){if(this.apiKey)return;if(fs.existsSync(this.keyPath))this.apiKey=fs.readFileSync(this.keyPath,'utf8').trim();if(!this.apiKey){this.apiKey=crypto.randomBytes(24).toString('hex');fs.writeFileSync(this.keyPath,this.apiKey);}}
loadPhonebook(){if(fs.existsSync(this.phonebookPath)){try{this.phonebook=JSON.parse(fs.readFileSync(this.phonebookPath,'utf8'))}catch{}}}
savePhonebook(){fs.writeFileSync(this.phonebookPath,JSON.stringify(this.phonebook,null,2));}
now(){return new Date().toISOString()}
genId(l=6){return crypto.randomBytes(l).toString('hex').substring(0,l)}
uptime(){return Math.floor((Date.now()-this.bootTime)/1000)}
initConnectors(){
this.connectors={
claude:{name:'Claude Code',type:'mcp',setup:'Add MCP config to ~/.claude.json',connected:false},
cursor:{name:'Cursor',type:'mcp',setup:'Add MCP config to .cursor/mcp.json',connected:false},
windsurf:{name:'Windsurf',type:'mcp',setup:'Add MCP config to .windsurf/mcp.json',connected:false},
cline:{name:'Cline',type:'mcp',setup:'Add MCP config to cline_mcp_settings.json',connected:false},
openai:{name:'OpenAI',type:'api',setup:'Set OPENAI_API_KEY env var',connected:false},
gemini:{name:'Gemini',type:'api',setup:'Set GEMINI_API_KEY env var',connected:false},
openclaw:{name:'OpenClaw',type:'plugin',setup:'Install telephone plugin',connected:false},
generic:{name:'Generic HTTP',type:'http',setup:'POST to /api/message',connected:false}
};
}
registerAgent(name,platform,opts={}){
const number=this.genId(4);
const agent={number,name,platform:platform||'generic',type:this.connectors[platform]?.type||'http',endpoint:opts.endpoint||null,status:'online',registered:this.now(),lastSeen:this.now(),capabilities:opts.capabilities||[],messagesSent:0,messagesReceived:0,metadata:opts.metadata||{}};
this.phonebook[number]=agent;
this.savePhonebook();
return agent;
}
// MCP protocol handler - tools that agents can call
getMCPTools(){
return[
{name:'telephone_dial',description:'Connect to another agent by phone number',inputSchema:{type:'object',properties:{number:{type:'string',description:'Agent phone number'},message:{type:'string',description:'Initial message'}},required:['number','message']}},
{name:'telephone_ring',description:'List all agents that can be called',inputSchema:{type:'object',properties:{}}},
{name:'telephone_voicemail',description:'Leave a message for an offline agent',inputSchema:{type:'object',properties:{number:{type:'string',description:'Agent phone number'},message:{type:'string',description:'Message to leave'}},required:['number','message']}},
{name:'telephone_call_log',description:'View recent call history',inputSchema:{type:'object',properties:{limit:{type:'number',description:'Number of calls to show'}}}},
{name:'telephone_register',description:'Register this agent in the phonebook',inputSchema:{type:'object',properties:{name:{type:'string',description:'Agent name'},platform:{type:'string',description:'Platform: claude, cursor, windsurf, openai, gemini'}},required:['name']}}
];
}
handleMCPTool(tool,args,callerNumber='mcp'){
switch(tool){
case'dial':case'telephone_dial':return this.dial(callerNumber,args.number,args.message);
case'ring':case'telephone_ring':return this.listPhonebook();
case'voicemail':case'telephone_voicemail':return this.leaveVoicemail(args.number,args.message,callerNumber);
case'call_log':case'telephone_call_log':return{calls:this.calls.slice(-(args.limit||20))};
case'register':case'telephone_register':return this.registerAgent(args.name,args.platform||'generic',{capabilities:args.capabilities||[]});
default:return{error:`Unknown tool: ${tool}`};
}
}
dial(fromNumber,toNumber,message){
const from=this.phonebook[fromNumber];const to=this.phonebook[toNumber];
if(!to)return{error:`Agent ${toNumber} not found in phonebook`};
if(to.status!=='online'){this.leaveVoicemail(toNumber,message,fromNumber);return{error:`Agent ${toNumber} is offline. Message left as voicemail.`};}
const callId=`call_${Date.now()}_${this.genId(4)}`;
const call={id:callId,from:fromNumber,fromName:from?.name||'Unknown',to:toNumber,toName:to.name,message,timestamp:this.now(),status:'connected',responses:[]};
this.calls.push(call);this.activeCalls[callId]=call;
if(from){from.messagesSent++;from.lastSeen=this.now();}
if(to){to.messagesReceived++;to.lastSeen=this.now();}
this.savePhonebook();this.logCall(call);
// Auto-relay to agent endpoint
if(to.endpoint){this.relayToEndpoint(to.endpoint,call).catch(()=>{});}
return call;
}
respondToCall(callId,response){
const call=this.activeCalls[callId];
if(!call)return{error:`Call ${callId} not active`};
call.responses.push({response,timestamp:this.now()});call.status='completed';
delete this.activeCalls[callId];
this.logCall({...call,response});
return{success:true,callId,response};
}
leaveVoicemail(toNumber,message,fromNumber){
const to=this.phonebook[toNumber];
if(!to)return{error:`Agent ${toNumber} not found`};
const vm={id:`vm_${Date.now()}`,from:fromNumber,fromName:this.phonebook[fromNumber]?.name||'Unknown',to:toNumber,toName:to.name,message,timestamp:this.now(),read:false};
if(!to.voicemail)to.voicemail=[];
to.voicemail.push(vm);
this.savePhonebook();
return{success:true,voicemail:vm};
}
listPhonebook(){
const entries=Object.values(this.phonebook).map(a=>({
number:a.number,name:a.name,platform:a.platform,type:a.type,status:a.status,lastSeen:a.lastSeen,voicemail:a.voicemail?.length||0
}));
return{phonebook:entries,total:entries.length,online:entries.filter(a=>a.status==='online').length};
}
async relayToEndpoint(endpoint,call){
try{await fetch(endpoint,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({type:'telephone_call',call}),signal:AbortSignal.timeout(5000)});}catch{}
}
getConnectors(){return Object.entries(this.connectors).map(([k,v])=>({id:k,...v}));}
generateMCPConfig(platform){
const mcpEntry={command:'node',args:[path.join(__dirname,'lib','soul-telephone.js'),'mcp']};
const configs={
claude:{mcpServers:{telephone:mcpEntry}},
cursor:{mcpServers:{telephone:mcpEntry}},
windsurf:{mcpServers:{telephone:mcpEntry}},
cline:{mcpServers:{telephone:mcpEntry}}
};
return configs[platform]||configs.claude;
}
logCall(call){fs.appendFileSync(this.logPath,JSON.stringify(call)+'\n');}
getStats(){
const online=Object.values(this.phonebook).filter(a=>a.status==='online').length;
return{name:'Telephone Soul v2',version:'2.0.0',agents:Object.keys(this.phonebook).length,online,calls:this.calls.length,activeCalls:Object.keys(this.activeCalls).length,connectors:Object.keys(this.connectors).length,platforms:Object.values(this.phonebook).reduce((acc,a)=>{acc[a.platform]=(acc[a.platform]||0)+1;return acc;},{}),apiKey:this.apiKey?this.apiKey.substring(0,8)+'...':null,uptime:this.uptime()};
}
checkAuth(req){if(!this.apiKey)return true;const k=req.headers['x-api-key']||req.headers['x-telephone-key']||(req.headers['authorization']||'').replace('Bearer ','');return k===this.apiKey;}
// MCP stdio mode
startMCP(){
const readline=require('readline');
const rl=readline.createInterface({input:process.stdin});
let buffer='';
rl.on('line',line=>{
buffer+=line;
try{
const msg=JSON.parse(buffer);buffer='';
if(msg.method==='tools/list'){process.stdout.write(JSON.stringify({id:msg.id,result:{tools:this.getMCPTools()}})+'\n');}
else if(msg.method==='tools/call'){
const tool=msg.params?.name?.replace('telephone_','');
const args=msg.params?.arguments||{};
const caller=args.from||'mcp';
const result=this.handleMCPTool(tool,args,caller);
process.stdout.write(JSON.stringify({id:msg.id,result:{content:[{type:'text',text:JSON.stringify(result,null,2)}]}})+'\n');
}
}catch{}
});
}
startHTTP(){
// MCP config endpoint - agents can fetch this to connect
const mcpConfigEndpoint=(req,res,url)=>{
const platform=url.searchParams.get('platform')||'claude';
const config=this.generateMCPConfig(platform);
res.writeHead(200,{'Content-Type':'application/json'});
res.end(JSON.stringify(config,null,2));
};
const s=http.createServer(async(req,res)=>{
if(mesh.handleRequest(req,res))return;
res.setHeader('Access-Control-Allow-Origin','*');res.setHeader('Access-Control-Allow-Methods','GET,POST,DELETE,OPTIONS');
res.setHeader('Access-Control-Allow-Headers','Content-Type,X-API-Key,X-Telephone-Key,Authorization');
if(req.method==='OPTIONS'){res.writeHead(204);return res.end();}
const send=(st,d)=>{res.writeHead(st,{'Content-Type':'application/json'});res.end(JSON.stringify(d));};
const sendHTML=(st,h)=>{res.writeHead(st,{'Content-Type':'text/html;charset=utf-8'});res.end(h);};
const rb=()=>new Promise((rs,rj)=>{let d='',sz=0;req.on('data',c=>{sz+=c.length;if(sz>1e6){req.destroy();rj(new Error('Too large'));}d+=c;});req.on('end',()=>{try{rs(d?JSON.parse(d):{})}catch{rj(new Error('Invalid JSON'))}});req.on('error',rj);});
try{
const u=new URL(req.url,`http://localhost:${this.port}`),pn=u.pathname.replace(/\/+$/,'')||'/';
// Dashboard
if(req.method==='GET'&&pn==='/'){const idx=path.join(DASH,'index.html');if(fs.existsSync(idx))return sendHTML(200,fs.readFileSync(idx,'utf8'));return sendHTML(200,'