@hasna/terminal 4.3.1 → 4.3.3

package/src/mcp/server.ts

@@ -2,6 +2,7 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
 import { createSession } from "../sessions-db.js";
 import { createHelpers } from "./tools/helpers.js";
 
@@ -15,6 +16,7 @@ import { registerProcessTools } from "./tools/process.js";
 import { registerBatchTools } from "./tools/batch.js";
 import { registerMemoryTools } from "./tools/memory.js";
 import { registerMetaTools } from "./tools/meta.js";
+import { registerCloudTools } from "@hasna/cloud";
 
 // ── server ───────────────────────────────────────────────────────────────────
 
@@ -49,6 +51,59 @@ export function createServer(): McpServer {
   registerBatchTools(server, h);
   registerMemoryTools(server, h);
   registerMetaTools(server, h);
+  registerCloudTools(server, "terminal");
+
+  // ── Agent Tools ──────────────────────────────────────────────────────────
+  const _agentReg = new Map<string, { id: string; name: string; last_seen_at: string; project_id?: string }>();
+
+  server.tool(
+    "register_agent",
+    "Register an agent session (idempotent). Auto-updates last_seen_at on re-register.",
+    { name: z.string(), session_id: z.string().optional() },
+    async (a) => {
+      const existing = [..._agentReg.values()].find(x => x.name === a.name);
+      if (existing) { existing.last_seen_at = new Date().toISOString(); return { content: [{ type: "text" as const, text: JSON.stringify(existing) }] }; }
+      const id = Math.random().toString(36).slice(2, 10);
+      const ag = { id, name: a.name, last_seen_at: new Date().toISOString() };
+      _agentReg.set(id, ag);
+      return { content: [{ type: "text" as const, text: JSON.stringify(ag) }] };
+    }
+  );
+
+  server.tool(
+    "heartbeat",
+    "Update last_seen_at to signal agent is active.",
+    { agent_id: z.string() },
+    async (a) => {
+      const ag = _agentReg.get(a.agent_id);
+      if (!ag) return { content: [{ type: "text" as const, text: `Agent not found: ${a.agent_id}` }], isError: true };
+      ag.last_seen_at = new Date().toISOString();
+      return { content: [{ type: "text" as const, text: JSON.stringify({ id: ag.id, name: ag.name, last_seen_at: ag.last_seen_at }) }] };
+    }
+  );
+
+  server.tool(
+    "set_focus",
+    "Set active project context for this agent session.",
+    { agent_id: z.string(), project_id: z.string().nullable().optional() },
+    async (a) => {
+      const ag = _agentReg.get(a.agent_id);
+      if (!ag) return { content: [{ type: "text" as const, text: `Agent not found: ${a.agent_id}` }], isError: true };
+      (ag as any).project_id = a.project_id ?? undefined;
+      return { content: [{ type: "text" as const, text: a.project_id ? `Focus: ${a.project_id}` : "Focus cleared" }] };
+    }
+  );
+
+  server.tool(
+    "list_agents",
+    "List all registered agents.",
+    {},
+    async () => {
+      const agents = [..._agentReg.values()];
+      if (agents.length === 0) return { content: [{ type: "text" as const, text: "No agents registered." }] };
+      return { content: [{ type: "text" as const, text: JSON.stringify(agents, null, 2) }] };
+    }
+  );
 
   return server;
 }

package/src/mcp/tools/memory.ts

@@ -136,7 +136,8 @@ export function registerMemoryTools(server: McpServer, h: ToolHelpers): void {
     async ({ name, value }) => {
       const { existsSync, readFileSync, writeFileSync, chmodSync } = await import("fs");
       const { join } = await import("path");
-      const secretsFile = join(process.env.HOME ?? "~", ".terminal", "secrets.json");
+      const { getTerminalDir } = await import("../../paths.js");
+      const secretsFile = join(getTerminalDir(), "secrets.json");
       let secrets: Record<string, string> = {};
       if (existsSync(secretsFile)) {
         try { secrets = JSON.parse(readFileSync(secretsFile, "utf8")); } catch {}
@@ -157,7 +158,8 @@ export function registerMemoryTools(server: McpServer, h: ToolHelpers): void {
     async () => {
       const { existsSync, readFileSync } = await import("fs");
       const { join } = await import("path");
-      const secretsFile = join(process.env.HOME ?? "~", ".terminal", "secrets.json");
+      const { getTerminalDir } = await import("../../paths.js");
+      const secretsFile = join(getTerminalDir(), "secrets.json");
       let names: string[] = [];
       if (existsSync(secretsFile)) {
         try { names = Object.keys(JSON.parse(readFileSync(secretsFile, "utf8"))); } catch {}

package/src/output-store.ts

@@ -4,8 +4,9 @@
 import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
+import { getTerminalDir } from "./paths.js";
 
-const OUTPUTS_DIR = join(process.env.HOME ?? "~", ".terminal", "outputs");
+const OUTPUTS_DIR = join(getTerminalDir(), "outputs");
 
 /** Ensure outputs directory exists */
 function ensureDir() {

package/src/paths.ts

@@ -0,0 +1,32 @@
+// Centralized path resolution for open-terminal global data directory.
+// Migrated from ~/.terminal/ to ~/.hasna/terminal/ with backward compat.
+
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+/**
+ * Get the global terminal data directory.
+ * New default: ~/.hasna/terminal/
+ * Legacy fallback: ~/.terminal/ (if it exists and new dir doesn't)
+ * Env override: HASNA_TERMINAL_DIR or TERMINAL_DIR
+ */
+export function getTerminalDir(): string {
+  if (process.env.HASNA_TERMINAL_DIR) return process.env.HASNA_TERMINAL_DIR;
+  if (process.env.TERMINAL_DIR) return process.env.TERMINAL_DIR;
+
+  const home = homedir();
+  const newDir = join(home, ".hasna", "terminal");
+  const legacyDir = join(home, ".terminal");
+
+  // Use legacy dir if it exists and new one doesn't yet (backward compat)
+  if (!existsSync(newDir) && existsSync(legacyDir)) {
+    return legacyDir;
+  }
+
+  if (!existsSync(newDir)) {
+    mkdirSync(newDir, { recursive: true });
+  }
+
+  return newDir;
+}

package/src/recipes/storage.ts

@@ -1,12 +1,12 @@
-// Recipes storage — global (~/.terminal/recipes.json) + per-project (.terminal/recipes.json)
+// Recipes storage — global (~/.hasna/terminal/recipes.json) + per-project (.terminal/recipes.json)
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
 import type { Recipe, Collection, RecipeStore } from "./model.js";
 import { genId, extractVariables } from "./model.js";
+import { getTerminalDir } from "../paths.js";
 
-const GLOBAL_DIR = join(homedir(), ".terminal");
+const GLOBAL_DIR = getTerminalDir();
 const GLOBAL_FILE = join(GLOBAL_DIR, "recipes.json");
 
 function projectFile(projectPath: string): string {

package/src/session-context.ts

@@ -2,10 +2,10 @@
 // Enables: terminal "show auth code" → terminal "explain that function"
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
-const DIR = join(homedir(), ".terminal");
+const DIR = getTerminalDir();
 const CTX_FILE = join(DIR, "session-context.json");
 const MAX_ENTRIES = 5;
 

package/src/sessions-db.ts

@@ -2,20 +2,21 @@
 
 // @ts-ignore — bun:sqlite is a bun built-in
 import { Database } from "bun:sqlite";
+import { SqliteAdapter } from "@hasna/cloud";
 import { existsSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
 import { randomUUID } from "crypto";
+import { getTerminalDir } from "./paths.js";
 
-const DIR = join(homedir(), ".terminal");
-const DB_PATH = join(DIR, "sessions.db");
+const DIR = getTerminalDir();
+const DB_PATH = process.env.HASNA_TERMINAL_DB_PATH ?? process.env.TERMINAL_DB_PATH ?? join(DIR, "sessions.db");
 
 let db: Database | null = null;
 
 function getDb(): Database {
   if (db) return db;
   if (!existsSync(DIR)) mkdirSync(DIR, { recursive: true });
-  db = new Database(DB_PATH);
+  db = new SqliteAdapter(DB_PATH) as unknown as Database;
   db.exec("PRAGMA journal_mode = WAL");
 
   db.exec(`
@@ -71,6 +72,16 @@ function getDb(): Database {
     );
 
     CREATE INDEX IF NOT EXISTS idx_corrections_prompt ON corrections(prompt);
+
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      message TEXT NOT NULL,
+      email TEXT,
+      category TEXT DEFAULT 'general',
+      version TEXT,
+      machine_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
   `);
 
   return db;

package/src/tool-profiles.ts

@@ -1,9 +1,10 @@
 // Tool profiles — config-driven AI enhancement for specific command categories
-// Profiles are loaded from ~/.terminal/profiles/ (user-customizable)
+// Profiles are loaded from ~/.hasna/terminal/profiles/ (user-customizable)
 // Each profile tells the AI how to handle a specific tool's output
 
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
 export interface ToolProfile {
   name: string;
@@ -23,7 +24,7 @@ export interface ToolProfile {
   };
 }
 
-const PROFILES_DIR = join(process.env.HOME ?? "~", ".terminal", "profiles");
+const PROFILES_DIR = join(getTerminalDir(), "profiles");
 
 /** Built-in profiles — sensible defaults, user can override */
 const BUILTIN_PROFILES: ToolProfile[] = [
@@ -90,7 +91,7 @@ const BUILTIN_PROFILES: ToolProfile[] = [
   },
 ];
 
-/** Load user profiles from ~/.terminal/profiles/ */
+/** Load user profiles from ~/.hasna/terminal/profiles/ */
 function loadUserProfiles(): ToolProfile[] {
   if (!existsSync(PROFILES_DIR)) return [];
 

package/src/usage-cache.ts

@@ -2,11 +2,11 @@
 // After 3 identical prompt→command mappings, cache locally
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
 import { createHash } from "crypto";
+import { getTerminalDir } from "./paths.js";
 
-const DIR = join(homedir(), ".terminal");
+const DIR = getTerminalDir();
 const CACHE_FILE = join(DIR, "learned.json");
 
 interface LearnedEntry {