hajimi-claw 0.1.0

package/crates/hajimi-claw-types/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "hajimi-claw-types"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+
+[dependencies]
+async-trait.workspace = true
+chrono.workspace = true
+futures.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+thiserror.workspace = true
+uuid.workspace = true
+

package/crates/hajimi-claw-types/src/lib.rs

@@ -0,0 +1,300 @@
+use std::fmt::{Display, Formatter};
+use std::path::PathBuf;
+use std::pin::Pin;
+
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use futures::Stream;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use thiserror::Error;
+use uuid::Uuid;
+
+#[derive(Debug, Error)]
+pub enum ClawError {
+    #[error("access denied: {0}")]
+    AccessDenied(String),
+    #[error("approval required: {0}")]
+    ApprovalRequired(String),
+    #[error("invalid request: {0}")]
+    InvalidRequest(String),
+    #[error("not found: {0}")]
+    NotFound(String),
+    #[error("backend error: {0}")]
+    Backend(String),
+}
+
+pub type ClawResult<T> = Result<T, ClawError>;
+
+macro_rules! id_type {
+    ($name:ident) => {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+        pub struct $name(pub Uuid);
+
+        impl $name {
+            pub fn new() -> Self {
+                Self(Uuid::new_v4())
+            }
+        }
+
+        impl Default for $name {
+            fn default() -> Self {
+                Self::new()
+            }
+        }
+
+        impl Display for $name {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "{}", self.0)
+            }
+        }
+    };
+}
+
+id_type!(TaskId);
+id_type!(SessionId);
+id_type!(ApprovalId);
+id_type!(ConversationId);
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ProviderKind {
+    OpenAiCompatible,
+    CustomChatCompletions,
+}
+
+impl ProviderKind {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::OpenAiCompatible => "openai-compatible",
+            Self::CustomChatCompletions => "custom-chat-completions",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ProviderConfig {
+    pub id: String,
+    pub label: String,
+    pub kind: ProviderKind,
+    pub base_url: String,
+    pub api_key: String,
+    pub model: String,
+    pub enabled: bool,
+    pub extra_headers: Vec<(String, String)>,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ProviderRecord {
+    pub config: ProviderConfig,
+    pub is_default: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum OnboardingStep {
+    ProviderLabel,
+    ProviderKind,
+    ProviderBaseUrl,
+    ProviderApiKey,
+    ProviderModel,
+    Completed,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct ProviderDraft {
+    pub label: Option<String>,
+    pub kind: Option<ProviderKind>,
+    pub base_url: Option<String>,
+    pub api_key: Option<String>,
+    pub model: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct OnboardingSession {
+    pub user_id: i64,
+    pub chat_id: i64,
+    pub step: OnboardingStep,
+    pub draft: ProviderDraft,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ProviderHealth {
+    pub ok: bool,
+    pub message: String,
+    pub suggested_models: Vec<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PolicyMode {
+    Normal,
+    ApprovalPending,
+    ElevatedLease,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub enum RiskLevel {
+    Safe,
+    Guarded,
+    Dangerous,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExecRequest {
+    pub command: String,
+    pub args: Vec<String>,
+    pub cwd: Option<PathBuf>,
+    pub env_allowlist: Vec<String>,
+    pub timeout_secs: u64,
+    pub max_output_bytes: usize,
+    pub requires_tty: bool,
+}
+
+impl ExecRequest {
+    pub fn summary(&self) -> String {
+        if self.args.is_empty() {
+            self.command.clone()
+        } else {
+            format!("{} {}", self.command, self.args.join(" "))
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExecResult {
+    pub exit_code: Option<i32>,
+    pub stdout: String,
+    pub stderr: String,
+    pub duration_ms: u128,
+    pub truncated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SessionOpenRequest {
+    pub name: Option<String>,
+    pub cwd: Option<PathBuf>,
+    pub env_allowlist: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SessionHandle {
+    pub id: SessionId,
+    pub name: String,
+    pub cwd: PathBuf,
+    pub created_at: DateTime<Utc>,
+    pub last_used_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SessionSummary {
+    pub session_id: SessionId,
+    pub cwd: PathBuf,
+    pub recent_commands: Vec<String>,
+    pub summary: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ApprovalRequest {
+    pub request_id: ApprovalId,
+    pub reason: String,
+    pub risk_level: RiskLevel,
+    pub command_preview: String,
+    pub cwd: Option<PathBuf>,
+    pub expires_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ApprovalDecision {
+    pub request_id: ApprovalId,
+    pub approved: bool,
+    pub decided_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolSpec {
+    pub name: String,
+    pub description: String,
+    pub requires_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolOutput {
+    pub content: String,
+    pub structured: Option<Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolContext {
+    pub conversation_id: ConversationId,
+    pub working_directory: Option<PathBuf>,
+    pub elevated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum MessageRole {
+    System,
+    User,
+    Assistant,
+    Tool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConversationMessage {
+    pub role: MessageRole,
+    pub content: String,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentRequest {
+    pub conversation_id: ConversationId,
+    pub provider_id: Option<String>,
+    pub system_prompt: String,
+    pub messages: Vec<ConversationMessage>,
+    pub tool_specs: Vec<ToolSpec>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum AgentEvent {
+    TextDelta(String),
+    ToolCall { tool: String, input: Value },
+    Finished,
+}
+
+pub type AgentStream = Pin<Box<dyn Stream<Item = ClawResult<AgentEvent>> + Send>>;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum TaskKind {
+    EphemeralAgentTask,
+    PersistentShellTask,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TaskStatus {
+    pub id: TaskId,
+    pub kind: TaskKind,
+    pub description: String,
+    pub queued_at: DateTime<Utc>,
+    pub started_at: Option<DateTime<Utc>>,
+    pub finished_at: Option<DateTime<Utc>>,
+    pub running: bool,
+}
+
+#[async_trait]
+pub trait LlmBackend: Send + Sync {
+    async fn respond(&self, req: AgentRequest) -> ClawResult<AgentStream>;
+}
+
+#[async_trait]
+pub trait Tool: Send + Sync {
+    fn spec(&self) -> ToolSpec;
+    async fn call(&self, ctx: ToolContext, input: Value) -> ClawResult<ToolOutput>;
+}
+
+#[async_trait]
+pub trait Executor: Send + Sync {
+    async fn run_once(&self, req: ExecRequest) -> ClawResult<ExecResult>;
+    async fn open_session(&self, req: SessionOpenRequest) -> ClawResult<SessionHandle>;
+    async fn run_in_session(&self, id: SessionId, req: ExecRequest) -> ClawResult<ExecResult>;
+    async fn close_session(&self, id: SessionId) -> ClawResult<()>;
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "hajimi-claw",
+  "version": "0.1.0",
+  "description": "Single-user Telegram-first ops agent in Rust",
+  "bin": {
+    "hajimi-claw": "bin/hajimi-claw.js"
+  },
+  "files": [
+    "Cargo.toml",
+    "Cargo.lock",
+    "src",
+    "crates",
+    "bin",
+    "scripts/npm-install.js",
+    "config.example.toml",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/npm-install.js"
+  },
+  "preferGlobal": true,
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/npm-install.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const root = path.resolve(__dirname, "..");
+const cargo = process.platform === "win32" ? "cargo.exe" : "cargo";
+const binaryName = process.platform === "win32" ? "hajimi-claw.exe" : "hajimi-claw";
+const sourceBinary = path.join(root, "target", "release", binaryName);
+const outputDir = path.join(root, "npm-dist");
+const outputBinary = path.join(outputDir, binaryName);
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+const cargoCheck = spawnSync(cargo, ["--version"], { cwd: root, stdio: "pipe" });
+if (cargoCheck.error || cargoCheck.status !== 0) {
+  fail("cargo is required to install the npm package for hajimi-claw.");
+}
+
+const build = spawnSync(
+  cargo,
+  ["build", "--release", "--manifest-path", path.join(root, "Cargo.toml")],
+  {
+    cwd: root,
+    stdio: "inherit",
+  }
+);
+
+if (build.status !== 0) {
+  fail("cargo build --release failed during npm install.");
+}
+
+if (!fs.existsSync(sourceBinary)) {
+  fail(`release binary not found at ${sourceBinary}`);
+}
+
+fs.mkdirSync(outputDir, { recursive: true });
+fs.copyFileSync(sourceBinary, outputBinary);
+if (process.platform !== "win32") {
+  fs.chmodSync(outputBinary, 0o755);
+}

package/src/main.rs

@@ -0,0 +1,4 @@
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    hajimi_claw_daemon::run_from_env().await
+}