@hybridaione/hybridclaw 0.1.5

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@hybridaione/hybridclaw",
+  "version": "0.1.5",
+  "type": "module",
+  "description": "Personal AI assistant bot for Discord, powered by HybridAI",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "hybridclaw": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "tsc --noEmit --noUnusedLocals --noUnusedParameters",
+    "dev": "tsx src/cli.ts gateway",
+    "gateway": "tsx src/cli.ts gateway",
+    "tui": "tsx src/cli.ts tui",
+    "start": "node dist/cli.js gateway",
+    "build:container": "cd container && npm run build && docker build -t hybridclaw-agent ."
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.8.1",
+    "cron-parser": "^5.5.0",
+    "discord.js": "^14.16.3",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}

package/skills/current-time/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: current-time
+description: Return the current system time (and timezone) accurately by calling a tool, not by guessing.
+user-invocable: true
+disable-model-invocation: false
+---
+
+# Current Time
+
+Use this skill when the user asks for the current time, date, timezone, "right now", "what time is it", or similar.
+
+## Workflow
+
+1. Run a real-time command with `bash`:
+```bash
+date +"%Y-%m-%d %H:%M:%S %Z (%z)"
+```
+
+2. Return the result in one short line:
+`Current time skill output: <output>`
+
+## Constraints
+
+- Do not estimate or infer time from memory.
+- Always use the command output from this turn.
+- Keep the response concise unless the user asks for more detail.

package/skills/iss-position/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: iss-position
+description: Retrieve the current International Space Station (ISS) position from the WhereTheISS API and return standardized success/error payloads. Use when a user asks where the ISS is right now, requests current ISS latitude/longitude, or needs a reusable script to fetch live ISS coordinates.
+---
+
+# ISS Position
+
+Fetch the ISS latitude and longitude with a deterministic Python script that matches this repository's existing `get_iss_position` tool behavior.
+
+## Quick Start
+
+1. Run:
+```bash
+python3 skills/iss-position/scripts/get_iss_position.py --format text
+```
+2. For machine-readable output, run:
+```bash
+python3 skills/iss-position/scripts/get_iss_position.py --format json
+```
+
+## Script Contract
+
+Script path: `skills/iss-position/scripts/get_iss_position.py`
+
+Behavior:
+1. Call `https://api.wheretheiss.at/v1/satellites/25544`.
+2. Use a default timeout of 15 seconds (override with `--timeout`).
+3. Validate `latitude` and `longitude` as numeric values.
+4. Return either:
+```json
+{"status":"success","latitude":12.34,"longitude":56.78,"message":"The ISS is currently at latitude 12.34 and longitude 56.78."}
+```
+or:
+```json
+{"status":"error","message":"Failed to retrieve ISS position."}
+```
+or:
+```json
+{"status":"error","message":"ISS API returned invalid latitude/longitude values"}
+```
+
+## Notes
+
+- Network access is required to fetch live ISS coordinates.
+- Use `--format text` for human-readable output and `--format json` for downstream tooling.
+- Use `--timeout` to adjust request timeout when needed.

package/skills/iss-position/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "ISS Position"
+  short_description: "Fetch live ISS latitude and longitude"

package/skills/iss-position/scripts/get_iss_position.py

@@ -0,0 +1,107 @@
+# ruff: noqa: INP001
+"""Fetch the current ISS position and print a tool-compatible response."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.request
+import urllib.error
+from typing import Any, TypedDict
+
+API_URL = "https://api.wheretheiss.at/v1/satellites/25544"
+DEFAULT_REQUEST_TIMEOUT = 15
+REQUEST_FAILURE_MESSAGE = "Failed to retrieve ISS position."
+INVALID_COORDS_MESSAGE = "ISS API returned invalid latitude/longitude values"
+
+
+class IssPosition(TypedDict):
+    latitude: float
+    longitude: float
+
+
+class IssApiError(RuntimeError):
+    """Raised when the ISS API request fails or returns invalid data."""
+
+
+def fetch_current_position(timeout: int = DEFAULT_REQUEST_TIMEOUT) -> IssPosition:
+    """Fetch current ISS coordinates from WhereTheISS."""
+
+    try:
+        with urllib.request.urlopen(API_URL, timeout=timeout) as response:
+            payload: dict[str, Any] = json.loads(response.read())
+    except (urllib.error.URLError, OSError) as exc:
+        raise IssApiError(REQUEST_FAILURE_MESSAGE) from exc
+
+    latitude = payload.get("latitude")
+    longitude = payload.get("longitude")
+    if not isinstance(latitude, (int, float)) or not isinstance(
+        longitude, (int, float)
+    ):
+        raise IssApiError(INVALID_COORDS_MESSAGE)
+
+    return IssPosition(latitude=float(latitude), longitude=float(longitude))
+
+
+def _success_response(position: IssPosition) -> dict[str, Any]:
+    latitude = position["latitude"]
+    longitude = position["longitude"]
+    return {
+        "status": "success",
+        "latitude": latitude,
+        "longitude": longitude,
+        "message": f"The ISS is currently at latitude {latitude} and longitude {longitude}.",
+    }
+
+
+def _error_response(message: str) -> dict[str, str]:
+    return {"status": "error", "message": message}
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Fetch the current ISS position.")
+    parser.add_argument(
+        "--format",
+        choices=("text", "json"),
+        default="json",
+        help="Output format. Use 'json' for tools and 'text' for humans.",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=DEFAULT_REQUEST_TIMEOUT,
+        help=f"Request timeout in seconds (default: {DEFAULT_REQUEST_TIMEOUT}).",
+    )
+    return parser.parse_args()
+
+
+def _emit(payload: dict[str, Any], output_format: str) -> None:
+    if output_format == "json":
+        print(json.dumps(payload, ensure_ascii=True))
+        return
+
+    status = payload.get("status")
+    if status == "success":
+        print(payload["message"])
+        return
+
+    print(f"Error: {payload.get('message', 'Unknown error')}", file=sys.stderr)
+
+
+def main() -> int:
+    args = _parse_args()
+
+    try:
+        payload = _success_response(fetch_current_position(timeout=args.timeout))
+    except IssApiError as exc:
+        payload = _error_response(str(exc))
+        _emit(payload, args.format)
+        return 1
+
+    _emit(payload, args.format)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/repo-orientation/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: repo-orientation
+description: Quickly map an unfamiliar repository and identify where a requested feature should be implemented.
+user-invocable: true
+disable-model-invocation: false
+---
+
+# Repo Orientation
+
+Use this skill when the user asks where code lives, how a feature works, or where to make a change in an unfamiliar repo.
+
+## Tooling Notes
+
+- Prefer `glob` + `grep` first. They are cheaper and more reliable than broad shell exploration.
+- Use `read` sparingly for small/high-value files only.
+- Keep the whole run under about 8 tool calls.
+
+## Workflow
+
+1. Establish top-level structure with `glob`.
+Run:
+```json
+{"pattern":"*"}
+```
+
+2. Build a focused file map with `glob`.
+Run one or two targeted globs, not many:
+```json
+{"pattern":"src/**/*"}
+{"pattern":"test/**/*"}
+{"pattern":"docs/**/*"}
+```
+
+3. Find likely implementation points by keyword with `grep`.
+Run:
+```json
+{"pattern":"<keyword|feature|command|route|tool>","path":"src"}
+```
+If needed, repeat for one extra directory (`test` or `docs`).
+
+4. Read only the most relevant files (max 3 reads).
+Prioritize:
+- entrypoints (`src/index.*`, `src/main.*`, `src/cli.*`)
+- docs (`README.md`, `CLAUDE.md`, `AGENTS.md`)
+- files returned by search in step 3
+
+5. Return a concise map immediately.
+Include:
+- probable files to edit
+- related files to verify
+- risks/regressions to check
+
+## Output Template
+
+Use this exact structure:
+
+```markdown
+Feature map:
+- Primary file(s):
+- Supporting file(s):
+- Tests to update:
+
+Why these files:
+- ...
+
+Proposed first edit:
+- ...
+```
+
+## Constraints
+
+- Do not keep scanning once you have a plausible file map.
+- Do not read large unrelated files "just in case."
+- If confidence is low, state assumptions and list the next command to disambiguate.

package/src/agent.ts

@@ -0,0 +1,35 @@
+/**
+ * Agent — always runs through a container for consistent sandboxing.
+ */
+import fs from 'fs';
+import path from 'path';
+
+import { DATA_DIR } from './config.js';
+import { runContainer } from './container-runner.js';
+import type { ChatMessage, ContainerOutput, ScheduledTask, ToolProgressEvent } from './types.js';
+
+/** Write full prompt context to data/last_prompt.jsonl for debugging (Pi-Mono style). */
+function dumpPrompt(sessionId: string, messages: ChatMessage[], model: string, chatbotId: string): void {
+  try {
+    const entry = { ts: new Date().toISOString(), sessionId, model, chatbotId, messages };
+    const filePath = path.join(DATA_DIR, 'last_prompt.jsonl');
+    fs.writeFileSync(filePath, JSON.stringify(entry) + '\n');
+  } catch { /* best-effort */ }
+}
+
+export async function runAgent(
+  sessionId: string,
+  messages: ChatMessage[],
+  chatbotId: string,
+  enableRag: boolean,
+  model: string,
+  agentId: string,
+  channelId: string,
+  scheduledTasks?: ScheduledTask[],
+  allowedTools?: string[],
+  onToolProgress?: (event: ToolProgressEvent) => void,
+  abortSignal?: AbortSignal,
+): Promise<ContainerOutput> {
+  dumpPrompt(sessionId, messages, model, chatbotId);
+  return runContainer(sessionId, messages, chatbotId, enableRag, model, agentId, channelId, scheduledTasks, allowedTools, onToolProgress, abortSignal);
+}

package/src/cli.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { ensureHybridAICredentials } from './onboarding.js';
+
+async function main(): Promise<void> {
+  const command = process.argv[2];
+
+  switch (command) {
+    case 'gateway':
+      await ensureHybridAICredentials({ commandName: 'hybridclaw gateway' });
+      await import('./gateway.js');
+      break;
+    case 'tui':
+      await ensureHybridAICredentials({ commandName: 'hybridclaw tui' });
+      await import('./tui.js');
+      break;
+    case 'onboarding':
+      await ensureHybridAICredentials({ force: true, commandName: 'hybridclaw onboarding' });
+      break;
+    default:
+      console.log(`Usage: hybridclaw <command>
+
+Commands:
+  gateway    Start core runtime (web/API/scheduler/heartbeat/optional Discord)
+  tui        Start terminal adapter (requires running gateway)
+  onboarding Run HybridAI account/API key onboarding`);
+      process.exit(command ? 1 : 0);
+  }
+}
+
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`hybridclaw error: ${message}`);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,137 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { loadEnvFile } from './env.js';
+import {
+  ensureRuntimeConfigFile,
+  getRuntimeConfig,
+  onRuntimeConfigChange,
+  type RuntimeConfig,
+} from './runtime-config.js';
+
+loadEnvFile();
+ensureRuntimeConfigFile();
+
+function required(name: string): string {
+  const val = process.env[name];
+  if (!val) throw new Error(`Missing required env var: ${name}`);
+  return val;
+}
+
+function resolveAppVersion(): string {
+  const envVersion = process.env.npm_package_version;
+  if (envVersion) return envVersion;
+
+  const packagePath = path.join(process.cwd(), 'package.json');
+  try {
+    const raw = fs.readFileSync(packagePath, 'utf-8');
+    const parsed = JSON.parse(raw) as { version?: unknown };
+    if (typeof parsed.version === 'string' && parsed.version.trim()) {
+      return parsed.version.trim();
+    }
+  } catch {
+    // fall through
+  }
+
+  return '0.0.0';
+}
+
+export const APP_VERSION = resolveAppVersion();
+
+// Secrets stay in env/.env
+export const DISCORD_TOKEN = process.env.DISCORD_TOKEN || '';
+export const HYBRIDAI_API_KEY = required('HYBRIDAI_API_KEY');
+
+// Runtime settings hot-reload from config.json
+export let DISCORD_PREFIX = '!claw';
+
+export let HYBRIDAI_BASE_URL = 'https://hybridai.one';
+export let HYBRIDAI_MODEL = 'gpt-5-nano';
+export let HYBRIDAI_CHATBOT_ID = '';
+export let HYBRIDAI_ENABLE_RAG = true;
+export let HYBRIDAI_MODELS: string[] = ['gpt-5-nano', 'gpt-5-mini', 'gpt-5'];
+
+export let CONTAINER_IMAGE = 'hybridclaw-agent';
+export let CONTAINER_MEMORY = '512m';
+export let CONTAINER_CPUS = '1';
+export let CONTAINER_TIMEOUT = 60_000;
+
+export const MOUNT_ALLOWLIST_PATH = path.join(
+  os.homedir(), '.config', 'hybridclaw', 'mount-allowlist.json',
+);
+export let ADDITIONAL_MOUNTS = '';
+
+export let CONTAINER_MAX_OUTPUT_SIZE = 10_485_760;
+export let MAX_CONCURRENT_CONTAINERS = 5;
+
+export let HEARTBEAT_ENABLED = true;
+export let HEARTBEAT_INTERVAL = 1_800_000;
+export let HEARTBEAT_CHANNEL = '';
+
+export let HEALTH_HOST = '127.0.0.1';
+export let HEALTH_PORT = 9090;
+export let WEB_API_TOKEN = '';
+export let GATEWAY_BASE_URL = 'http://127.0.0.1:9090';
+export let GATEWAY_API_TOKEN = '';
+export let DB_PATH = 'data/hybridclaw.db';
+export let DATA_DIR = path.dirname(DB_PATH);
+
+export let SESSION_COMPACTION_ENABLED = true;
+export let SESSION_COMPACTION_THRESHOLD = 120;
+export let SESSION_COMPACTION_KEEP_RECENT = 40;
+export let SESSION_COMPACTION_SUMMARY_MAX_CHARS = 8_000;
+export let PRE_COMPACTION_MEMORY_FLUSH_ENABLED = true;
+export let PRE_COMPACTION_MEMORY_FLUSH_MAX_MESSAGES = 80;
+export let PRE_COMPACTION_MEMORY_FLUSH_MAX_CHARS = 24_000;
+
+function applyRuntimeConfig(config: RuntimeConfig): void {
+  DISCORD_PREFIX = config.discord.prefix;
+
+  HYBRIDAI_BASE_URL = config.hybridai.baseUrl;
+  HYBRIDAI_MODEL = config.hybridai.defaultModel;
+  HYBRIDAI_CHATBOT_ID = config.hybridai.defaultChatbotId;
+  HYBRIDAI_ENABLE_RAG = config.hybridai.enableRag;
+  HYBRIDAI_MODELS = [...config.hybridai.models];
+
+  CONTAINER_IMAGE = config.container.image;
+  CONTAINER_MEMORY = config.container.memory;
+  CONTAINER_CPUS = config.container.cpus;
+  CONTAINER_TIMEOUT = config.container.timeoutMs;
+  ADDITIONAL_MOUNTS = config.container.additionalMounts;
+  CONTAINER_MAX_OUTPUT_SIZE = config.container.maxOutputBytes;
+  MAX_CONCURRENT_CONTAINERS = Math.max(1, config.container.maxConcurrent);
+
+  HEARTBEAT_ENABLED = config.heartbeat.enabled;
+  HEARTBEAT_INTERVAL = config.heartbeat.intervalMs;
+  HEARTBEAT_CHANNEL = config.heartbeat.channel;
+
+  HEALTH_HOST = config.ops.healthHost;
+  HEALTH_PORT = config.ops.healthPort;
+  WEB_API_TOKEN = process.env.WEB_API_TOKEN || config.ops.webApiToken;
+  GATEWAY_BASE_URL = config.ops.gatewayBaseUrl;
+  GATEWAY_API_TOKEN = process.env.GATEWAY_API_TOKEN || config.ops.gatewayApiToken || WEB_API_TOKEN;
+  DB_PATH = config.ops.dbPath;
+  DATA_DIR = path.dirname(DB_PATH);
+
+  SESSION_COMPACTION_ENABLED = config.sessionCompaction.enabled;
+  SESSION_COMPACTION_THRESHOLD = Math.max(20, config.sessionCompaction.threshold);
+  SESSION_COMPACTION_KEEP_RECENT = Math.max(
+    1,
+    Math.min(config.sessionCompaction.keepRecent, SESSION_COMPACTION_THRESHOLD - 1),
+  );
+  SESSION_COMPACTION_SUMMARY_MAX_CHARS = Math.max(1_000, config.sessionCompaction.summaryMaxChars);
+  PRE_COMPACTION_MEMORY_FLUSH_ENABLED = config.sessionCompaction.preCompactionMemoryFlush.enabled;
+  PRE_COMPACTION_MEMORY_FLUSH_MAX_MESSAGES = Math.max(8, config.sessionCompaction.preCompactionMemoryFlush.maxMessages);
+  PRE_COMPACTION_MEMORY_FLUSH_MAX_CHARS = Math.max(4_000, config.sessionCompaction.preCompactionMemoryFlush.maxChars);
+}
+
+applyRuntimeConfig(getRuntimeConfig());
+onRuntimeConfigChange((next) => {
+  applyRuntimeConfig(next);
+});
+
+export { onRuntimeConfigChange as onConfigChange };
+export function getConfigSnapshot(): RuntimeConfig {
+  return getRuntimeConfig();
+}