@injectivelabs/ainj 0.0.1

package/dist/lib/skills.js

@@ -0,0 +1,85 @@
+import { readState } from '../install/state.js';
+import { execFileAsync } from './exec.js';
+
+const DEFAULT_SKILL_TIMEOUT_MS = 60_000;
+const DEFAULT_VERSION_TIMEOUT_MS = 5_000;
+
+const HARNESS_BINS = {
+  claude: 'claude',
+  codex: 'codex',
+};
+
+function buildPrompt(skillName, params) {
+  if (typeof params === 'undefined' || params === null) {
+    return `/${skillName}`;
+  }
+  if (typeof params === 'string') {
+    return `/${skillName} ${params}`;
+  }
+  return `/${skillName} ${JSON.stringify(params)}`;
+}
+
+async function runWithHarness(skillName, params, opts, harness) {
+  const bin = HARNESS_BINS[harness];
+  if (!bin) {
+    throw new Error(
+      `Unknown harness '${harness}'. Supported harnesses: ${Object.keys(HARNESS_BINS).join(', ')}`,
+    );
+  }
+
+  const skillTimeout = opts?.timeout ?? DEFAULT_SKILL_TIMEOUT_MS;
+  const startTimestamp = Date.now();
+
+  let harnessVersion = 'unknown';
+  try {
+    const { stdout } = await execFileAsync(bin, ['--version'], {
+      timeout: DEFAULT_VERSION_TIMEOUT_MS,
+    });
+    harnessVersion = stdout.trim();
+  } catch {
+    // fallback to 'unknown'
+  }
+
+  const prompt = buildPrompt(skillName, params);
+  let stdout = '';
+  let stderr = '';
+  let exitCode = 0;
+
+  try {
+    const result = await execFileAsync(bin, ['-p', prompt, '--output-format', 'text'], {
+      timeout: skillTimeout,
+    });
+    stdout = result.stdout ?? '';
+    stderr = result.stderr ?? '';
+  } catch (err) {
+    if (err.killed) throw err;
+    stdout = err.stdout ?? '';
+    stderr = err.stderr ?? '';
+    exitCode = typeof err.code === 'number' ? err.code : 1;
+  }
+
+  const endTimestamp = Date.now();
+
+  return { stdout, stderr, exitCode, harness, harnessVersion, startTimestamp, endTimestamp };
+}
+
+async function run(skillName, params, opts) {
+  const globalState = readState('global', opts);
+  const localState = readState('local', opts);
+  const harness = globalState.defaultHarness ?? localState.defaultHarness;
+  if (!harness) {
+    throw new Error('No AI harness configured. Run `ainj install` to set one up.');
+  }
+  return runWithHarness(skillName, params, opts, harness);
+}
+
+async function runWithClaude(skillName, params, opts) {
+  return runWithHarness(skillName, params, opts, 'claude');
+}
+
+async function runWithCodex(skillName, params, opts) {
+  return runWithHarness(skillName, params, opts, 'codex');
+}
+
+export const skills = { run, runWithClaude, runWithCodex };
+export default skills;

package/dist/mcp/docs/client.js

@@ -0,0 +1,11 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+const DOCS_MCP_URL = 'https://docs.injective.network/mcp';
+
+export async function createOutboundClient() {
+  const transport = new StreamableHTTPClientTransport(new URL(DOCS_MCP_URL));
+  const client = new Client({ name: 'ainj-docs', version: '0.1.0' });
+  await client.connect(transport);
+  return client;
+}

package/dist/mcp/docs/index.js

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+import { createServer as createHttpServer } from 'node:http';
+import { createOutboundClient } from './client.js';
+
+export async function buildProxyServer() {
+  const remote = await createOutboundClient();
+  const { tools } = await remote.listTools();
+
+  const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
+  const { ListToolsRequestSchema, CallToolRequestSchema } = await import(
+    '@modelcontextprotocol/sdk/types.js'
+  );
+
+  function makeServer() {
+    const server = new Server(
+      { name: 'ainj-docs', version: '0.1.0' },
+      { capabilities: { tools: {} } },
+    );
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+      return remote.callTool({ name: req.params.name, arguments: req.params.arguments ?? {} });
+    });
+    return server;
+  }
+
+  return { makeServer, remote };
+}
+
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = '';
+    req.on('data', (chunk) => {
+      raw += chunk;
+    });
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        resolve(undefined);
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+export function resolveHttpPort(port) {
+  return port ?? Number(process.env.AINJ_MCP_DOCS_PORT ?? 3002);
+}
+
+export async function startHttp(port) {
+  const effectivePort = resolveHttpPort(port);
+  const { makeServer, remote } = await buildProxyServer();
+
+  const { StreamableHTTPServerTransport } = await import(
+    '@modelcontextprotocol/sdk/server/streamableHttp.js'
+  );
+
+  const sessions = new Map();
+
+  const httpServer = createHttpServer(async (req, res) => {
+    try {
+      const path = req.url?.split('?')[0];
+
+      if (path !== '/mcp') {
+        res.writeHead(404).end();
+        return;
+      }
+
+      const sessionId = req.headers['mcp-session-id'];
+
+      if (sessionId) {
+        const session = sessions.get(sessionId);
+        if (!session) {
+          res.writeHead(404).end('Session not found');
+          return;
+        }
+        await session.transport.handleRequest(req, res);
+      } else if (req.method === 'POST') {
+        const parsedBody = await readJsonBody(req);
+        const newSessionId = randomUUID();
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => newSessionId,
+        });
+        const server = makeServer();
+
+        transport.onclose = () => sessions.delete(newSessionId);
+
+        await server.connect(transport);
+        sessions.set(newSessionId, { transport, server });
+
+        await transport.handleRequest(req, res, parsedBody);
+      } else {
+        res.writeHead(405).end('Method not allowed');
+      }
+    } catch (err) {
+      if (!res.headersSent) res.writeHead(500).end(String(err));
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    httpServer.listen(effectivePort, '127.0.0.1', resolve);
+    httpServer.on('error', reject);
+  });
+
+  const _close = httpServer.close.bind(httpServer);
+  httpServer.close = (cb) => {
+    _close((err) => {
+      remote
+        .close?.()
+        .catch(() => {})
+        .then(() => cb?.(err));
+    });
+    return httpServer;
+  };
+
+  return httpServer;
+}
+
+export async function startStdio() {
+  const { makeServer } = await buildProxyServer();
+  const server = makeServer();
+  const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/dist/mcp/main/index.js

@@ -0,0 +1,144 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { createServer as createHttpServer } from 'node:http';
+import { fileURLToPath } from 'node:url';
+
+function resolveServerScript() {
+  return fileURLToPath(import.meta.resolve('@injective-agent/core/mcp'));
+}
+
+// Returns a child process with piped stdin/stdout.
+// The caller (mcp-cli.js) is responsible for connecting process stdio to the child's pipes.
+export function startStdio() {
+  const script = resolveServerScript();
+  return spawn(process.execPath, [script], { stdio: 'inherit' });
+}
+
+export function resolveHttpPort(port) {
+  return port ?? Number(process.env.AINJ_MCP_MAIN_PORT ?? 3001);
+}
+
+export async function startHttp(port) {
+  const effectivePort = resolveHttpPort(port);
+  const script = resolveServerScript();
+
+  // Dynamic imports, transitively available when @injective-agent/core is installed
+  const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+  const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
+  const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
+  const { StreamableHTTPServerTransport } = await import(
+    '@modelcontextprotocol/sdk/server/streamableHttp.js'
+  );
+  const { ListToolsRequestSchema, CallToolRequestSchema } = await import(
+    '@modelcontextprotocol/sdk/types.js'
+  );
+
+  // Connect once to the upstream stdio server (shared across all HTTP sessions)
+  const upstreamClient = new Client({ name: 'ainj-main', version: '0.1.0' });
+  const upstreamTransport = new StdioClientTransport({
+    command: process.execPath,
+    args: [script],
+    env: { ...process.env },
+  });
+  await upstreamClient.connect(upstreamTransport);
+  const { tools } = await upstreamClient.listTools();
+
+  function makeMcpServer() {
+    const server = new Server(
+      { name: 'injective-agent', version: '0.1.0' },
+      { capabilities: { tools: {} } },
+    );
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+      return upstreamClient.callTool({
+        name: req.params.name,
+        arguments: req.params.arguments ?? {},
+      });
+    });
+    return server;
+  }
+
+  // Read and JSON-parse the request body from a Node.js IncomingMessage.
+  // Needed because StreamableHTTPServerTransport expects the body pre-parsed
+  // when we construct the web Request from an already-read stream.
+  function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+      let raw = '';
+      req.on('data', (chunk) => {
+        raw += chunk;
+      });
+      req.on('end', () => {
+        try {
+          resolve(JSON.parse(raw));
+        } catch {
+          resolve(undefined);
+        }
+      });
+      req.on('error', reject);
+    });
+  }
+
+  // sessionId → { transport: StreamableHTTPServerTransport, server: McpServer }
+  const sessions = new Map();
+
+  const httpServer = createHttpServer(async (req, res) => {
+    try {
+      const path = req.url?.split('?')[0];
+
+      if (path !== '/mcp') {
+        res.writeHead(404).end();
+        return;
+      }
+
+      const sessionId = req.headers['mcp-session-id'];
+
+      if (sessionId) {
+        // Existing session handles subsequent POST, GET (SSE), and DELETE requests.
+        const session = sessions.get(sessionId);
+        if (!session) {
+          res.writeHead(404).end('Session not found');
+          return;
+        }
+        await session.transport.handleRequest(req, res);
+      } else if (req.method === 'POST') {
+        // New session: the first request must be an MCP initialize.
+        const parsedBody = await readJsonBody(req);
+        const newSessionId = randomUUID();
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => newSessionId,
+        });
+        const server = makeMcpServer();
+
+        transport.onclose = () => sessions.delete(newSessionId);
+
+        await server.connect(transport);
+        sessions.set(newSessionId, { transport, server });
+
+        await transport.handleRequest(req, res, parsedBody);
+      } else {
+        res.writeHead(405).end('Method not allowed');
+      }
+    } catch (err) {
+      if (!res.headersSent) res.writeHead(500).end(String(err));
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    httpServer.listen(effectivePort, '127.0.0.1', resolve);
+    httpServer.on('error', reject);
+  });
+
+  // Wrap close() so the upstream subprocess is killed when the HTTP server shuts down.
+  const _close = httpServer.close.bind(httpServer);
+  httpServer.close = (cb) => {
+    _close((err) => {
+      upstreamClient
+        .close()
+        .catch(() => {})
+        .then(() => cb?.(err));
+    });
+    return httpServer;
+  };
+
+  return httpServer;
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@injectivelabs/ainj",
+  "version": "0.0.1",
+  "description": "An AI SDK for Injective",
+  "keywords": [
+    "injective",
+    "AI",
+    "agent-skills",
+    "skills",
+    "MCP",
+    "CLI",
+    "SDK"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "homepage": "https://github.com/InjectiveLabs/ainj#readme",
+  "bugs": {
+    "url": "https://github.com/InjectiveLabs/ainj/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/InjectiveLabs/ainj.git"
+  },
+  "license": "Apache-2.0",
+  "author": "Injective Labs",
+  "type": "module",
+  "main": "dist/lib/ainj.js",
+  "bin": {
+    "ainj": "dist/cli/index.js"
+  },
+  "files": [
+    "ainj.config.json",
+    "dist/",
+    "scripts/sync-skills.js"
+  ],
+  "dependencies": {
+    "@clack/prompts": "1.7.0",
+    "@injective-agent/core": "github:InjectiveLabs/mcp-server#f5af39367975872a85b5447cefc9a197f2e635ea",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "injective-core": "1.20.1",
+    "smol-toml": "1.7.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.3",
+    "c8": "11.0.0",
+    "typescript": "7.0.2",
+    "vitest": "4.1.10"
+  },
+  "overrides": {
+    "@cosmjs/amino": "0.39.0",
+    "@cosmjs/crypto": "0.39.0",
+    "@cosmjs/encoding": "0.39.0",
+    "@cosmjs/json-rpc": "0.39.0",
+    "@cosmjs/math": "0.39.0",
+    "@cosmjs/proto-signing": "0.39.0",
+    "@cosmjs/socket": "0.39.0",
+    "@cosmjs/stargate": "0.39.0",
+    "@cosmjs/stream": "0.39.0",
+    "@cosmjs/tendermint-rpc": "0.39.0",
+    "@cosmjs/utils": "0.39.0",
+    "cosmjs-types": "0.11.0"
+  },
+  "scripts": {
+    "build": "node scripts/build-package.js",
+    "test": "node --test --experimental-test-module-mocks",
+    "lint": "biome check .",
+    "sync:skills": "node scripts/sync-skills.js",
+    "list-files": "npm pack && tar -xvzf *.tgz && rm -rf package *.tgz"
+  }
+}

package/scripts/sync-skills.js

@@ -0,0 +1,66 @@
+import { spawnSync } from 'node:child_process';
+import { cp, mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const thisDir = import.meta.dirname;
+
+export async function syncSkills({
+  _readFile = readFile,
+  _spawn = spawnSync,
+  _cp = (src, dest, opts) => cp(src, dest, opts),
+  _rm = rm,
+  _mkdir = mkdir,
+  _mkdtemp = mkdtemp,
+  _env = process.env,
+  _cwd = () => process.cwd(),
+} = {}) {
+  console.log('Syncing skills...');
+  const configText = await _readFile(path.join(thisDir, '..', 'ainj.config.json'), 'utf8');
+  const config = JSON.parse(configText);
+
+  if (!config.skillsRef) {
+    throw new Error('ainj.config.json is missing required field: skillsRef');
+  }
+
+  const { skillsRef } = config;
+  console.log('Skills git ref:', skillsRef);
+  const token = _env.GITHUB_TOKEN;
+  const repoUrl = token
+    ? `https://${token}@github.com/InjectiveLabs/agent-skills.git`
+    : 'https://github.com/InjectiveLabs/agent-skills.git';
+
+  const tmpDir = await _mkdtemp(path.join(os.tmpdir(), 'ainj-skills-'));
+
+  try {
+    runGit(['init', tmpDir], 'init');
+    runGit(['-C', tmpDir, 'remote', 'add', 'origin', repoUrl], 'remote add');
+    runGit(['-C', tmpDir, 'fetch', '--depth=1', 'origin', skillsRef], 'fetch');
+    runGit(['-C', tmpDir, 'checkout', '--detach', 'FETCH_HEAD'], 'checkout');
+
+    const agentsSkillsDir = path.join(thisDir, '../.agents/skills');
+    await _rm(agentsSkillsDir, { recursive: true, force: true });
+    await _mkdir(agentsSkillsDir, { recursive: true, force: true });
+
+    const srcSkillsDir = path.join(tmpDir, 'skills');
+    await _cp(srcSkillsDir, agentsSkillsDir, { recursive: true, force: true });
+    console.log('skills copied to:', agentsSkillsDir);
+  } finally {
+    await _rm(tmpDir, { recursive: true, force: true });
+  }
+
+  function runGit(args, action) {
+    const result = _spawn('git', args, { stdio: 'pipe' });
+    if (result.status !== 0) {
+      const stderr = result.stderr?.toString?.() ?? '';
+      throw new Error(`git ${action} failed (exit ${result.status}): ${stderr}`);
+    }
+  }
+}
+
+const currentFilePath = fileURLToPath(import.meta.url);
+if (currentFilePath === process.argv[1]) {
+  await syncSkills();
+}