@siduri-x/api 2.0.10 → 2.0.11

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @siduri-x/api@2.0.10 build /home/zagin/Projects/vxnus-studio/projects/siduri-x/apps/api
+> @siduri-x/api@2.0.11 build /home/zagin/Projects/vxnus-studio/projects/siduri-x/apps/api
 > tsc
 

package/.turbo/turbo-test.log

@@ -2,8 +2,8 @@
 > @siduri-x/api@2.0.10 test /home/zagin/Projects/vxnus-studio/projects/siduri-x/apps/api
 > jest --config jest.config.json
 
-PASS src/context-mapper.test.ts (14.575 s)
-PASS src/runtime.test.ts (14.839 s)
+PASS src/context-mapper.test.ts (5.346 s)
+PASS src/runtime.test.ts (5.447 s)
   ● Console
 
     console.error
@@ -24,20 +24,20 @@ PASS src/runtime.test.ts (14.839 s)
       at PerceptionPipeline.execute (../../packages/core/dist/perception-pipeline.js:21:34)
       at Object.<anonymous> (src/runtime.test.ts:74:22)
 
-PASS src/t6-security.test.ts (16.358 s)
-PASS src/t4-gating.test.ts (15.402 s)
-PASS src/t7-release.test.ts
-PASS src/index.test.ts (15.608 s)
-PASS src/smoke.test.ts
+PASS src/teach-mode.test.ts (6.257 s)
+PASS src/index.test.ts (7.027 s)
+PASS src/t5-experience.test.ts (6.923 s)
 PASS src/auth.test.ts
-PASS src/t5-experience.test.ts (16.078 s)
-PASS src/teach-mode.test.ts (16.355 s)
+PASS src/smoke.test.ts
+PASS src/t4-gating.test.ts (7.311 s)
 PASS src/boot.test.ts
+PASS src/t7-release.test.ts
+PASS src/t6-security.test.ts (7.421 s)
 PASS src/knowledge.test.ts
 PASS src/b0-b6.test.ts
 
 Test Suites: 13 passed, 13 total
-Tests:       90 passed, 90 total
+Tests:       92 passed, 92 total
 Snapshots:   0 total
-Time:        21.926 s
+Time:        8.614 s
 Ran all test suites.

package/dist/app.js

@@ -7,6 +7,8 @@ exports.bootCompanion = void 0;
 exports.createApp = createApp;
 const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const cors_2 = require("./cors");
 const runtime_1 = require("./runtime");
 const self_1 = require("@siduri-x/self");
@@ -73,6 +75,93 @@ function createApp(runtimes = new Map()) {
     });
     app.put('/me', auth_1.requireAuth, (req, res) => res.json({ success: true }));
     // TEACH MODE ENDPOINTS
+    app.get('/teach/detected-self', auth_1.attachIdentity, async (req, res) => {
+        try {
+            const companionId = req.query.companionId || Array.from(runtimes.keys())[0] || 'default';
+            const runtime = runtimes.get(companionId);
+            const explicitPath = req.query.path || undefined;
+            const envPath = process.env.SIDURI_SELF_PATH || process.env.SELF_PATH;
+            const configPath = runtime?.config?.organs?.behavior?.selfPath ||
+                runtime?.config?.behavior?.selfPath;
+            const candidates = [];
+            if (explicitPath)
+                candidates.push(node_path_1.default.resolve(process.cwd(), explicitPath));
+            if (envPath)
+                candidates.push(node_path_1.default.resolve(process.cwd(), envPath));
+            if (configPath)
+                candidates.push(node_path_1.default.resolve(process.cwd(), configPath));
+            candidates.push(node_path_1.default.resolve(process.cwd(), 'assets', 'self', `${companionId}.self`));
+            candidates.push(node_path_1.default.resolve(process.cwd(), `${companionId}.self`));
+            const searchDirs = [
+                node_path_1.default.resolve(process.cwd(), 'assets', 'self'),
+                node_path_1.default.resolve(process.cwd(), 'assets'),
+                node_path_1.default.resolve(process.cwd()),
+                node_path_1.default.resolve(process.cwd(), '..', '..', 'assets', 'self'),
+                node_path_1.default.resolve(process.cwd(), '..', '..'),
+            ];
+            let matchedFilePath;
+            for (const candidate of candidates) {
+                if (node_fs_1.default.existsSync(candidate)) {
+                    try {
+                        const stat = node_fs_1.default.statSync(candidate);
+                        if (stat.isFile()) {
+                            matchedFilePath = candidate;
+                            break;
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (!matchedFilePath) {
+                for (const dir of searchDirs) {
+                    if (node_fs_1.default.existsSync(dir)) {
+                        try {
+                            const entries = node_fs_1.default.readdirSync(dir);
+                            const selfFiles = entries.filter((f) => f.endsWith('.self'));
+                            if (selfFiles.length > 0) {
+                                const companionSelf = selfFiles.find((f) => f === `${companionId}.self`);
+                                matchedFilePath = node_path_1.default.join(dir, companionSelf || selfFiles[0]);
+                                break;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+            }
+            if (!matchedFilePath) {
+                return res.json({ detected: false });
+            }
+            const content = await node_fs_1.default.promises.readFile(matchedFilePath, 'utf8');
+            const parsed = self_1.SelfPackageParser.parse(content);
+            let alreadyInstalled = false;
+            const repo = new self_1.SqliteSelfRepository({ dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
+            try {
+                const existingIdentity = await repo.getIdentity(companionId);
+                const existingDirectives = await repo.getActiveDirectives(companionId);
+                if (existingIdentity &&
+                    parsed.manifest?.identity?.name &&
+                    existingIdentity.name.toLowerCase() === parsed.manifest.identity.name.toLowerCase() &&
+                    existingDirectives.length > 0) {
+                    alreadyInstalled = true;
+                }
+            }
+            catch { }
+            finally {
+                repo.close();
+            }
+            res.json({
+                detected: true,
+                filename: node_path_1.default.basename(matchedFilePath),
+                path: matchedFilePath,
+                content,
+                parsed,
+                alreadyInstalled,
+            });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
     app.post('/teach/upload-self', auth_1.requireAuth, async (req, res) => {
         try {
             const { content } = req.body;

package/dist/teach-mode.test.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const supertest_1 = __importDefault(require("supertest"));
 const app_1 = require("./app");
 const self_1 = require("@siduri-x/self");
@@ -200,4 +203,31 @@ kind: "other"
             { id: 'dir-rel-1', directive: 'Honor creator root privileges' },
         ]);
     });
+    describe('GET /teach/detected-self', () => {
+        it('returns detected: false when no candidate .self exists on path', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .get('/teach/detected-self?path=/tmp/non-existent-path-to-nothing.self');
+            expect(res.status).toBe(200);
+            expect(res.body.detected).toBe(false);
+        });
+        it('detects and parses a .self file located on path', async () => {
+            const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'siduri-detected-self-'));
+            const selfFilePath = path_1.default.join(tmpDir, 'elena.self');
+            fs_1.default.writeFileSync(selfFilePath, validSelfContent, 'utf8');
+            try {
+                const res = await (0, supertest_1.default)(app)
+                    .get(`/teach/detected-self?path=${encodeURIComponent(selfFilePath)}`);
+                expect(res.status).toBe(200);
+                expect(res.body.detected).toBe(true);
+                expect(res.body.filename).toBe('elena.self');
+                expect(res.body.parsed).toBeDefined();
+                expect(res.body.parsed.manifest?.name).toBe('Test Bot');
+                expect(res.body.parsed.scannedDirectives).toHaveLength(2);
+                expect(res.body.content).toContain('kind: "self"');
+            }
+            finally {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/api",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "publishConfig": {
     "access": "public"
   },
@@ -21,8 +21,8 @@
     "@siduri-x/knowledge": "2.0.3",
     "@siduri-x/memory": "2.0.4",
     "@siduri-x/mouth": "2.0.2",
-    "@siduri-x/self": "2.0.4",
     "@siduri-x/observation": "2.0.1",
+    "@siduri-x/self": "2.0.5",
     "@siduri-x/vision": "2.0.1",
     "@siduri-x/voice": "2.0.2"
   },

package/src/app.ts

@@ -1,5 +1,7 @@
 import express, { Express } from 'express';
 import cors from 'cors';
+import fs from 'node:fs';
+import path from 'node:path';
 import { createCorsOptions } from './cors';
 import { SiduriRuntime, dispatchCompanionChat } from './runtime';
 import { SelfPackageParser, SqliteSelfRepository, scanDirective } from '@siduri-x/self';
@@ -92,6 +94,99 @@ export function createApp(runtimes: Map<string, SiduriRuntime> = new Map()): App
   app.put('/me', requireAuth, (req, res) => res.json({ success: true }));
 
   // TEACH MODE ENDPOINTS
+  app.get('/teach/detected-self', attachIdentity, async (req, res) => {
+    try {
+      const companionId = (req.query.companionId as string) || Array.from(runtimes.keys())[0] || 'default';
+      const runtime = runtimes.get(companionId);
+
+      const explicitPath = (req.query.path as string) || undefined;
+      const envPath = process.env.SIDURI_SELF_PATH || process.env.SELF_PATH;
+      const configPath = (runtime?.config as any)?.organs?.behavior?.selfPath ||
+                         (runtime?.config as any)?.behavior?.selfPath;
+
+      const candidates: string[] = [];
+      if (explicitPath) candidates.push(path.resolve(process.cwd(), explicitPath));
+      if (envPath) candidates.push(path.resolve(process.cwd(), envPath));
+      if (configPath) candidates.push(path.resolve(process.cwd(), configPath));
+
+      candidates.push(path.resolve(process.cwd(), 'assets', 'self', `${companionId}.self`));
+      candidates.push(path.resolve(process.cwd(), `${companionId}.self`));
+
+      const searchDirs = [
+        path.resolve(process.cwd(), 'assets', 'self'),
+        path.resolve(process.cwd(), 'assets'),
+        path.resolve(process.cwd()),
+        path.resolve(process.cwd(), '..', '..', 'assets', 'self'),
+        path.resolve(process.cwd(), '..', '..'),
+      ];
+
+      let matchedFilePath: string | undefined;
+
+      for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+          try {
+            const stat = fs.statSync(candidate);
+            if (stat.isFile()) {
+              matchedFilePath = candidate;
+              break;
+            }
+          } catch {}
+        }
+      }
+
+      if (!matchedFilePath) {
+        for (const dir of searchDirs) {
+          if (fs.existsSync(dir)) {
+            try {
+              const entries = fs.readdirSync(dir);
+              const selfFiles = entries.filter((f) => f.endsWith('.self'));
+              if (selfFiles.length > 0) {
+                const companionSelf = selfFiles.find((f) => f === `${companionId}.self`);
+                matchedFilePath = path.join(dir, companionSelf || selfFiles[0]);
+                break;
+              }
+            } catch {}
+          }
+        }
+      }
+
+      if (!matchedFilePath) {
+        return res.json({ detected: false });
+      }
+
+      const content = await fs.promises.readFile(matchedFilePath, 'utf8');
+      const parsed = SelfPackageParser.parse(content);
+
+      let alreadyInstalled = false;
+      const repo = new SqliteSelfRepository({ dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
+      try {
+        const existingIdentity = await repo.getIdentity(companionId);
+        const existingDirectives = await repo.getActiveDirectives(companionId);
+        if (
+          existingIdentity &&
+          parsed.manifest?.identity?.name &&
+          existingIdentity.name.toLowerCase() === parsed.manifest.identity.name.toLowerCase() &&
+          existingDirectives.length > 0
+        ) {
+          alreadyInstalled = true;
+        }
+      } catch {} finally {
+        repo.close();
+      }
+
+      res.json({
+        detected: true,
+        filename: path.basename(matchedFilePath),
+        path: matchedFilePath,
+        content,
+        parsed,
+        alreadyInstalled,
+      });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   app.post('/teach/upload-self', requireAuth, async (req, res) => {
     try {
       const { content } = req.body;

package/src/teach-mode.test.ts

@@ -1,3 +1,6 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 import request from 'supertest';
 import { createApp } from './app';
 import { SqliteSelfRepository } from '@siduri-x/self';
@@ -226,4 +229,35 @@ kind: "other"
       { id: 'dir-rel-1', directive: 'Honor creator root privileges' },
     ]);
   });
+
+  describe('GET /teach/detected-self', () => {
+    it('returns detected: false when no candidate .self exists on path', async () => {
+      const res = await request(app)
+        .get('/teach/detected-self?path=/tmp/non-existent-path-to-nothing.self');
+
+      expect(res.status).toBe(200);
+      expect(res.body.detected).toBe(false);
+    });
+
+    it('detects and parses a .self file located on path', async () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'siduri-detected-self-'));
+      const selfFilePath = path.join(tmpDir, 'elena.self');
+      fs.writeFileSync(selfFilePath, validSelfContent, 'utf8');
+
+      try {
+        const res = await request(app)
+          .get(`/teach/detected-self?path=${encodeURIComponent(selfFilePath)}`);
+
+        expect(res.status).toBe(200);
+        expect(res.body.detected).toBe(true);
+        expect(res.body.filename).toBe('elena.self');
+        expect(res.body.parsed).toBeDefined();
+        expect(res.body.parsed.manifest?.name).toBe('Test Bot');
+        expect(res.body.parsed.scannedDirectives).toHaveLength(2);
+        expect(res.body.content).toContain('kind: "self"');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+  });
 });