cli-claw-kit 0.0.1

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "cli-claw-kit",
+  "version": "0.0.1",
+  "description": "Self-hosted multi-user AI agent platform powered by CLI runtimes.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "cli-claw": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "config",
+    "shared",
+    "shared/dist",
+    "container/build.sh",
+    "container/Dockerfile",
+    "container/entrypoint.sh",
+    "container/skills",
+    "container/agent-runner/package.json",
+    "container/agent-runner/tsconfig.json",
+    "container/agent-runner/src",
+    "container/agent-runner/dist",
+    "container/agent-runner/prompts",
+    "web/dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npm run build:shared && npm run build:backend",
+    "build:release": "npm run build:all",
+    "prepack": "npm run build:release",
+    "release:check": "bash ./scripts/release-check.sh",
+    "start": "node dist/cli.js start",
+    "dev": "tsx src/index.ts",
+    "dev:bun": "bun src/index.ts",
+    "reset:admin": "tsx src/reset-admin.ts",
+    "typecheck": "npm run build:shared && npm run typecheck:backend",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "test": "vitest",
+    "dev:all": "npx concurrently --timestamp-format \"yyyy-MM-dd HH:mm:ss.SSS\" -n backend,frontend -c blue,green \"npm run dev\" \"npm run dev:web\"",
+    "dev:web": "cd web && npm run dev",
+    "build:web": "npm run build:shared && npm run build:web:local",
+    "build:all": "npm run build:shared && npm run build:backend && npm run build:web:local && npm --prefix container/agent-runner run build:runner",
+    "build:shared": "tsc -p shared/tsconfig.json",
+    "build:backend": "tsc",
+    "build:web:local": "cd web && npm run build",
+    "typecheck:backend": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^0.18.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.85",
+    "@hono/node-server": "^1.19.9",
+    "@larksuiteoapi/node-sdk": "^1.58.0",
+    "@types/qrcode": "^1.5.6",
+    "bcryptjs": "^3.0.3",
+    "better-sqlite3": "^11.8.1",
+    "cron-parser": "^5.5.0",
+    "dingtalk-stream": "2.1.6-beta.1",
+    "grammy": "^1.40.0",
+    "hono": "^4.11.9",
+    "node-pty": "^1.1.0",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0",
+    "proxy-agent": "^6.5.0",
+    "qrcode": "^1.5.4",
+    "ws": "^8.19.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.10.0",
+    "@types/ws": "^8.18.1",
+    "concurrently": "^9.2.1",
+    "prettier": "^3.8.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.1"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RyanProMax/cli-claw.git"
+  },
+  "homepage": "https://github.com/RyanProMax/cli-claw#readme",
+  "bugs": {
+    "url": "https://github.com/RyanProMax/cli-claw/issues"
+  },
+  "author": "riba2534",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "ai-agent",
+    "self-hosted",
+    "feishu",
+    "lark",
+    "telegram",
+    "chatbot",
+    "docker",
+    "mcp"
+  ]
+}

package/shared/assistant-meta-footer.ts

@@ -0,0 +1,127 @@
+export interface AssistantFooterRuntimeIdentity {
+  agentType?: string;
+  model?: string | null;
+  reasoningEffort?: string | null;
+  supportsReasoningEffort?: boolean | null;
+}
+
+export interface AssistantFooterModelUsage {
+  inputTokens?: number | null;
+  outputTokens?: number | null;
+  costUSD?: number | null;
+}
+
+export interface AssistantFooterTokenUsage {
+  inputTokens?: number | null;
+  outputTokens?: number | null;
+  cacheReadInputTokens?: number | null;
+  cacheCreationInputTokens?: number | null;
+  costUSD?: number | null;
+  durationMs?: number | null;
+  numTurns?: number | null;
+  modelUsage?: Record<string, AssistantFooterModelUsage> | null;
+}
+
+export interface AssistantMetaFooterInput {
+  runtimeIdentity?: AssistantFooterRuntimeIdentity | null;
+  tokenUsage?: AssistantFooterTokenUsage | string | null;
+}
+
+function normalizeText(value: string | null | undefined): string | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+
+function normalizeNumber(value: number | null | undefined): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return null;
+  return value;
+}
+
+export function formatCompactNumber(value: number): string {
+  if (!Number.isFinite(value)) return '0';
+  if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+  if (value >= 1_000) return `${(value / 1_000).toFixed(1)}K`;
+  return String(Math.round(value));
+}
+
+export function parseAssistantTokenUsage(
+  tokenUsage?: AssistantFooterTokenUsage | string | null,
+): AssistantFooterTokenUsage | null {
+  if (!tokenUsage) return null;
+  if (typeof tokenUsage === 'string') {
+    try {
+      return JSON.parse(tokenUsage) as AssistantFooterTokenUsage;
+    } catch {
+      return null;
+    }
+  }
+  return tokenUsage;
+}
+
+function getTotalTokens(usage: AssistantFooterTokenUsage | null): number | null {
+  if (!usage) return null;
+
+  const rootInput = normalizeNumber(usage.inputTokens);
+  const rootOutput = normalizeNumber(usage.outputTokens);
+  if (rootInput !== null || rootOutput !== null) {
+    return Math.max(0, (rootInput || 0) + (rootOutput || 0));
+  }
+
+  if (!usage.modelUsage || typeof usage.modelUsage !== 'object') return null;
+
+  let total = 0;
+  let sawAny = false;
+  for (const modelUsage of Object.values(usage.modelUsage)) {
+    const input = normalizeNumber(modelUsage?.inputTokens);
+    const output = normalizeNumber(modelUsage?.outputTokens);
+    if (input !== null || output !== null) {
+      total += (input || 0) + (output || 0);
+      sawAny = true;
+    }
+  }
+
+  return sawAny ? total : null;
+}
+
+export function getAssistantMetaFooterParts(
+  input: AssistantMetaFooterInput,
+): string[] {
+  const parts: string[] = [];
+  const runtimeIdentity = input.runtimeIdentity ?? null;
+  const tokenUsage = parseAssistantTokenUsage(input.tokenUsage);
+
+  const durationMs = normalizeNumber(tokenUsage?.durationMs);
+  if (durationMs !== null && durationMs > 0) {
+    parts.push(`${(durationMs / 1000).toFixed(1)}s`);
+  }
+
+  const model = normalizeText(runtimeIdentity?.model);
+  if (model) {
+    parts.push(model);
+  }
+
+  const reasoningEffort = normalizeText(runtimeIdentity?.reasoningEffort);
+  if (reasoningEffort) {
+    parts.push(reasoningEffort);
+  }
+
+  const totalTokens = getTotalTokens(tokenUsage);
+  if (totalTokens !== null && totalTokens > 0) {
+    parts.push(`${formatCompactNumber(totalTokens)} tokens`);
+  }
+
+  const costUSD = normalizeNumber(tokenUsage?.costUSD);
+  if (costUSD !== null && costUSD > 0) {
+    parts.push(`$${costUSD.toFixed(4)}`);
+  }
+
+  return parts;
+}
+
+export function formatAssistantMetaFooter(
+  input: AssistantMetaFooterInput,
+): string | null {
+  const parts = getAssistantMetaFooterParts(input);
+  return parts.length > 0 ? parts.join(' | ') : null;
+}

package/shared/channel-prefixes.ts

@@ -0,0 +1,16 @@
+/** IM channel type → JID prefix mapping. Shared between main server and agent-runner. */
+export const CHANNEL_PREFIXES: Record<string, string> = {
+  feishu: 'feishu:',
+  telegram: 'telegram:',
+  qq: 'qq:',
+  wechat: 'wechat:',
+  dingtalk: 'dingtalk:',
+};
+
+/** Determine the channel type from a JID string. Returns 'web' for unrecognized prefixes. */
+export function getChannelFromJid(jid: string): string {
+  for (const [type, prefix] of Object.entries(CHANNEL_PREFIXES)) {
+    if (jid.startsWith(prefix)) return type;
+  }
+  return 'web';
+}

package/shared/dist/assistant-meta-footer.d.ts

@@ -0,0 +1,29 @@
+export interface AssistantFooterRuntimeIdentity {
+    agentType?: string;
+    model?: string | null;
+    reasoningEffort?: string | null;
+    supportsReasoningEffort?: boolean | null;
+}
+export interface AssistantFooterModelUsage {
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    costUSD?: number | null;
+}
+export interface AssistantFooterTokenUsage {
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    cacheReadInputTokens?: number | null;
+    cacheCreationInputTokens?: number | null;
+    costUSD?: number | null;
+    durationMs?: number | null;
+    numTurns?: number | null;
+    modelUsage?: Record<string, AssistantFooterModelUsage> | null;
+}
+export interface AssistantMetaFooterInput {
+    runtimeIdentity?: AssistantFooterRuntimeIdentity | null;
+    tokenUsage?: AssistantFooterTokenUsage | string | null;
+}
+export declare function formatCompactNumber(value: number): string;
+export declare function parseAssistantTokenUsage(tokenUsage?: AssistantFooterTokenUsage | string | null): AssistantFooterTokenUsage | null;
+export declare function getAssistantMetaFooterParts(input: AssistantMetaFooterInput): string[];
+export declare function formatAssistantMetaFooter(input: AssistantMetaFooterInput): string | null;

package/shared/dist/assistant-meta-footer.js

@@ -0,0 +1,85 @@
+function normalizeText(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function normalizeNumber(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    return value;
+}
+export function formatCompactNumber(value) {
+    if (!Number.isFinite(value))
+        return '0';
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    if (value >= 1_000)
+        return `${(value / 1_000).toFixed(1)}K`;
+    return String(Math.round(value));
+}
+export function parseAssistantTokenUsage(tokenUsage) {
+    if (!tokenUsage)
+        return null;
+    if (typeof tokenUsage === 'string') {
+        try {
+            return JSON.parse(tokenUsage);
+        }
+        catch {
+            return null;
+        }
+    }
+    return tokenUsage;
+}
+function getTotalTokens(usage) {
+    if (!usage)
+        return null;
+    const rootInput = normalizeNumber(usage.inputTokens);
+    const rootOutput = normalizeNumber(usage.outputTokens);
+    if (rootInput !== null || rootOutput !== null) {
+        return Math.max(0, (rootInput || 0) + (rootOutput || 0));
+    }
+    if (!usage.modelUsage || typeof usage.modelUsage !== 'object')
+        return null;
+    let total = 0;
+    let sawAny = false;
+    for (const modelUsage of Object.values(usage.modelUsage)) {
+        const input = normalizeNumber(modelUsage?.inputTokens);
+        const output = normalizeNumber(modelUsage?.outputTokens);
+        if (input !== null || output !== null) {
+            total += (input || 0) + (output || 0);
+            sawAny = true;
+        }
+    }
+    return sawAny ? total : null;
+}
+export function getAssistantMetaFooterParts(input) {
+    const parts = [];
+    const runtimeIdentity = input.runtimeIdentity ?? null;
+    const tokenUsage = parseAssistantTokenUsage(input.tokenUsage);
+    const durationMs = normalizeNumber(tokenUsage?.durationMs);
+    if (durationMs !== null && durationMs > 0) {
+        parts.push(`${(durationMs / 1000).toFixed(1)}s`);
+    }
+    const model = normalizeText(runtimeIdentity?.model);
+    if (model) {
+        parts.push(model);
+    }
+    const reasoningEffort = normalizeText(runtimeIdentity?.reasoningEffort);
+    if (reasoningEffort) {
+        parts.push(reasoningEffort);
+    }
+    const totalTokens = getTotalTokens(tokenUsage);
+    if (totalTokens !== null && totalTokens > 0) {
+        parts.push(`${formatCompactNumber(totalTokens)} tokens`);
+    }
+    const costUSD = normalizeNumber(tokenUsage?.costUSD);
+    if (costUSD !== null && costUSD > 0) {
+        parts.push(`$${costUSD.toFixed(4)}`);
+    }
+    return parts;
+}
+export function formatAssistantMetaFooter(input) {
+    const parts = getAssistantMetaFooterParts(input);
+    return parts.length > 0 ? parts.join(' | ') : null;
+}

package/shared/dist/channel-prefixes.d.ts

@@ -0,0 +1,4 @@
+/** IM channel type → JID prefix mapping. Shared between main server and agent-runner. */
+export declare const CHANNEL_PREFIXES: Record<string, string>;
+/** Determine the channel type from a JID string. Returns 'web' for unrecognized prefixes. */
+export declare function getChannelFromJid(jid: string): string;

package/shared/dist/channel-prefixes.js

@@ -0,0 +1,16 @@
+/** IM channel type → JID prefix mapping. Shared between main server and agent-runner. */
+export const CHANNEL_PREFIXES = {
+    feishu: 'feishu:',
+    telegram: 'telegram:',
+    qq: 'qq:',
+    wechat: 'wechat:',
+    dingtalk: 'dingtalk:',
+};
+/** Determine the channel type from a JID string. Returns 'web' for unrecognized prefixes. */
+export function getChannelFromJid(jid) {
+    for (const [type, prefix] of Object.entries(CHANNEL_PREFIXES)) {
+        if (jid.startsWith(prefix))
+            return type;
+    }
+    return 'web';
+}

package/shared/dist/image-detector.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Detect image MIME type from buffer magic bytes.
+ * Canonical source — synced to src/ and container/agent-runner/src/ via make sync-types.
+ *
+ * Returns the detected MIME type or null if unknown.
+ */
+export declare function detectImageMimeTypeStrict(buffer: Buffer): string | null;
+/**
+ * Detect image MIME type from buffer magic bytes with fallback.
+ */
+export declare function detectImageMimeType(buffer: Buffer): string;
+/**
+ * Detect image MIME type from base64 payload (using header bytes only).
+ * Returns detected MIME or null if unknown/invalid.
+ */
+export declare function detectImageMimeTypeFromBase64Strict(base64Data: string): string | null;
+/**
+ * Detect image MIME type from base64 payload with fallback.
+ */
+export declare function detectImageMimeTypeFromBase64(base64Data: string): string;

package/shared/dist/image-detector.js

@@ -0,0 +1,96 @@
+/**
+ * Detect image MIME type from buffer magic bytes.
+ * Canonical source — synced to src/ and container/agent-runner/src/ via make sync-types.
+ *
+ * Returns the detected MIME type or null if unknown.
+ */
+export function detectImageMimeTypeStrict(buffer) {
+    if (buffer.length < 12) {
+        return null;
+    }
+    // PNG: 89 50 4E 47 0D 0A 1A 0A
+    if (buffer[0] === 0x89 &&
+        buffer[1] === 0x50 &&
+        buffer[2] === 0x4e &&
+        buffer[3] === 0x47 &&
+        buffer[4] === 0x0d &&
+        buffer[5] === 0x0a &&
+        buffer[6] === 0x1a &&
+        buffer[7] === 0x0a) {
+        return 'image/png';
+    }
+    // JPEG: FF D8 FF
+    if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return 'image/jpeg';
+    }
+    // GIF: 47 49 46 38
+    if (buffer[0] === 0x47 &&
+        buffer[1] === 0x49 &&
+        buffer[2] === 0x46 &&
+        buffer[3] === 0x38) {
+        return 'image/gif';
+    }
+    // WebP: RIFF....WEBP
+    if (buffer[0] === 0x52 &&
+        buffer[1] === 0x49 &&
+        buffer[2] === 0x46 &&
+        buffer[3] === 0x46 &&
+        buffer.length >= 12 &&
+        buffer[8] === 0x57 &&
+        buffer[9] === 0x45 &&
+        buffer[10] === 0x42 &&
+        buffer[11] === 0x50) {
+        return 'image/webp';
+    }
+    // TIFF: 49 49 2A 00 (little-endian) or 4D 4D 00 2A (big-endian)
+    if ((buffer[0] === 0x49 &&
+        buffer[1] === 0x49 &&
+        buffer[2] === 0x2a &&
+        buffer[3] === 0x00) ||
+        (buffer[0] === 0x4d &&
+            buffer[1] === 0x4d &&
+            buffer[2] === 0x00 &&
+            buffer[3] === 0x2a)) {
+        return 'image/tiff';
+    }
+    // AVIF: ....ftypavif or ....ftypavis
+    if (buffer.length >= 12) {
+        const ftyp = buffer.toString('ascii', 4, 8);
+        if (ftyp === 'ftyp') {
+            const brand = buffer.toString('ascii', 8, 12);
+            if (brand === 'avif' || brand === 'avis') {
+                return 'image/avif';
+            }
+        }
+    }
+    // BMP: 42 4D
+    if (buffer[0] === 0x42 && buffer[1] === 0x4d) {
+        return 'image/bmp';
+    }
+    return null;
+}
+/**
+ * Detect image MIME type from buffer magic bytes with fallback.
+ */
+export function detectImageMimeType(buffer) {
+    return detectImageMimeTypeStrict(buffer) || 'image/jpeg';
+}
+/**
+ * Detect image MIME type from base64 payload (using header bytes only).
+ * Returns detected MIME or null if unknown/invalid.
+ */
+export function detectImageMimeTypeFromBase64Strict(base64Data) {
+    try {
+        const header = Buffer.from(base64Data.slice(0, 400), 'base64');
+        return detectImageMimeTypeStrict(header);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect image MIME type from base64 payload with fallback.
+ */
+export function detectImageMimeTypeFromBase64(base64Data) {
+    return detectImageMimeTypeFromBase64Strict(base64Data) || 'image/jpeg';
+}

package/shared/dist/runtime-command-registry.d.ts

@@ -0,0 +1,38 @@
+export type RuntimeAgentType = 'claude' | 'codex';
+export type RuntimeCommandEntrypoint = 'im' | 'web';
+export type ReasoningEffortPreset = 'low' | 'medium' | 'high' | 'xhigh';
+export interface RuntimeCommandDefinition {
+    name: string;
+    aliases?: string[];
+    usage: string;
+    description: string;
+    availableEntrypoints: RuntimeCommandEntrypoint[];
+    availabilityByRuntime?: RuntimeAgentType[] | 'all';
+}
+export interface ParsedRuntimeCommand {
+    rawName: string;
+    name: string;
+    argsText: string;
+    args: string[];
+}
+export declare const RUNTIME_COMMANDS: RuntimeCommandDefinition[];
+export declare function supportsReasoningEffort(agentType: RuntimeAgentType): boolean;
+export declare function getModelPresets(agentType: RuntimeAgentType): string[];
+export declare function getReasoningEffortPresets(): ReasoningEffortPreset[];
+export declare function normalizeModelPreset(agentType: RuntimeAgentType, rawValue: string): string | null;
+export declare function normalizeReasoningEffortPreset(rawValue: string): ReasoningEffortPreset | null;
+export declare function findRuntimeCommand(rawName: string): RuntimeCommandDefinition | null;
+export declare function parseRuntimeCommand(text: string): ParsedRuntimeCommand | null;
+export declare function isCommandAvailable(options: {
+    commandName: string;
+    entrypoint: RuntimeCommandEntrypoint;
+    agentType: RuntimeAgentType;
+}): boolean;
+export declare function getAvailableCommands(options: {
+    entrypoint: RuntimeCommandEntrypoint;
+    agentType: RuntimeAgentType;
+}): RuntimeCommandDefinition[];
+export declare function formatCommandHelp(options: {
+    entrypoint: RuntimeCommandEntrypoint;
+    agentType: RuntimeAgentType;
+}): string;