@aurora-foundation/obsidian-next 0.4.7 → 0.4.9

package/dist/chunk-LK7UP2T7.js

@@ -0,0 +1,130 @@
+import {
+  history,
+  session,
+  tasks
+} from "./chunk-C4D56GRC.js";
+import {
+  context
+} from "./chunk-EMBMLZFE.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+
+// src/commands/resume.ts
+import path from "path";
+var resumeCommand = async (args) => {
+  if (args[0] === "--delete" || args[0] === "-d") {
+    const sessionId = args[1];
+    if (!sessionId) {
+      bus.emitAgent({
+        type: "error",
+        message: "Usage: /resume --delete <session_id>"
+      });
+      return;
+    }
+    const deleted = await session.delete(sessionId);
+    if (deleted) {
+      bus.emitAgent({
+        type: "done",
+        summary: `Session ${sessionId} deleted.`
+      });
+    } else {
+      bus.emitAgent({
+        type: "error",
+        message: `Session ${sessionId} not found.`
+      });
+    }
+    return;
+  }
+  if (args[0] === "--last" || args[0] === "-l") {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "error",
+        message: "No saved sessions found."
+      });
+      return;
+    }
+    args[0] = sessions[0].id;
+  }
+  if (!args[0]) {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "thought",
+        content: "No saved sessions found.\n\nSessions are created when you run /exit."
+      });
+      bus.emitAgent({
+        type: "done",
+        summary: "No sessions available."
+      });
+      return;
+    }
+    const content2 = [
+      "Saved Session Registry",
+      ...sessions.slice(0, 10).map((s) => {
+        const date = new Date(s.savedAt);
+        const dateStr = date.toLocaleDateString();
+        const timeStr = date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+        const workspaceName = path.basename(s.workspace);
+        return [
+          `   \u23BF  [${s.id}]`,
+          `      \u23BF  Date      ${dateStr} ${timeStr}`,
+          `      \u23BF  Workspace ${workspaceName}`,
+          s.task ? `      \u23BF  Task      ${s.task}` : null,
+          `      \u23BF  Activity  ${s.filesModified} files handled`,
+          ""
+        ].filter(Boolean).join("\n");
+      }),
+      sessions.length > 10 ? `   ... and ${sessions.length - 10} more sessions
+` : "",
+      "   [Usage]",
+      "   \u23BF  /resume <id>      Restore session",
+      "   \u23BF  /resume --last    Restore latest",
+      ""
+    ].join("\n");
+    bus.emitAgent({
+      type: "thought",
+      content: content2
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: `${sessions.length} session(s) available.`
+    });
+    return;
+  }
+  const sessionIdArg = args[0];
+  const result = await session.restore(sessionIdArg);
+  if (!result.success) {
+    bus.emitAgent({
+      type: "error",
+      message: result.error || "Failed to restore session"
+    });
+    return;
+  }
+  const currentTask = tasks.get();
+  const currentContext = context.get();
+  const content = [
+    "Session Restored Successfully",
+    `   \u23BF  ID          ${sessionIdArg}`,
+    `   \u23BF  Root        ${path.basename(process.cwd())}`,
+    "",
+    "   [Restored State]",
+    `   \u23BF  Context     ${currentContext.files_read.length} files in set`,
+    `   \u23BF  History     ${(await history.load()).length} events rehydrated`,
+    `   \u23BF  Task        ${currentTask?.title || "None"}`,
+    ""
+  ].join("\n");
+  bus.emitAgent({
+    type: "thought",
+    content
+  });
+  bus.emitAgent({
+    type: "done",
+    summary: `Session ${sessionIdArg} restored.`
+  });
+};
+
+export {
+  resumeCommand
+};

package/dist/chunk-LPGNO3PK.js

@@ -0,0 +1,284 @@
+// src/core/settings.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { z } from "zod";
+var SETTINGS_DIR = ".obsidian-next";
+var SETTINGS_FILE = "settings.json";
+var SettingsSchema = z.object({
+  // Execution mode
+  mode: z.enum(["auto", "plan", "safe"]).default("safe"),
+  // Auto-accept settings
+  autoAccept: z.object({
+    enabled: z.boolean().default(false),
+    readOperations: z.boolean().default(true),
+    safeCommands: z.boolean().default(true)
+  }).default({}),
+  // Tool permissions
+  permissions: z.object({
+    // Patterns always allowed without prompt: "tool:pattern"
+    allow: z.array(z.string()).default([]),
+    // Patterns allowed without prompt AND without sandbox
+    allowUnsandboxed: z.array(z.string()).default([]),
+    // Patterns always blocked
+    deny: z.array(z.string()).default([])
+  }).default({}),
+  // Security settings
+  security: z.object({
+    // PII redaction before sending to LLM
+    piiRedaction: z.boolean().default(true),
+    // Audit logging of all commands
+    auditLogging: z.boolean().default(true),
+    // Key storage backend preference
+    keyBackend: z.enum(["auto", "keychain", "secret-tool", "encrypted-file", "env"]).default("auto")
+  }).default({}),
+  // UI preferences
+  ui: z.object({
+    syntaxHighlight: z.boolean().default(true),
+    diffColors: z.boolean().default(true),
+    showLineNumbers: z.boolean().default(true),
+    // Owl animation settings
+    owlAnimation: z.object({
+      enabled: z.boolean().default(false),
+      flyWhenIdle: z.boolean().default(false),
+      idleTimeout: z.number().default(6e4),
+      // 60s before idle animation
+      sleepTimeout: z.number().default(3e5)
+      // 5m before sleep animation
+    }).default({})
+  }).default({}),
+  // Remote Gateway (Telegram)
+  telegram: z.object({
+    enabled: z.boolean().default(false),
+    botToken: z.string().optional(),
+    allowedUserIds: z.array(z.string()).default([])
+  }).default({})
+});
+var DEFAULT_SETTINGS = {
+  mode: "safe",
+  autoAccept: {
+    enabled: false,
+    readOperations: false,
+    safeCommands: false
+  },
+  permissions: {
+    allow: [],
+    // Empty - user builds their own allow list
+    allowUnsandboxed: [],
+    deny: []
+  },
+  security: {
+    piiRedaction: true,
+    // Enabled by default - protects user privacy
+    auditLogging: true,
+    // Enabled by default - for accountability
+    keyBackend: "auto"
+    // Auto-detect best available backend
+  },
+  ui: {
+    syntaxHighlight: true,
+    diffColors: true,
+    showLineNumbers: true,
+    owlAnimation: {
+      enabled: false,
+      flyWhenIdle: false,
+      idleTimeout: 6e4,
+      // 60s before idle animation
+      sleepTimeout: 3e5
+      // 5m before sleep animation
+    }
+  },
+  telegram: {
+    enabled: false,
+    allowedUserIds: []
+  }
+};
+var SettingsManager = class {
+  settingsPath;
+  cache = null;
+  sessionAllow = /* @__PURE__ */ new Set();
+  sessionUnsandboxed = /* @__PURE__ */ new Set();
+  sessionDeny = /* @__PURE__ */ new Set();
+  constructor() {
+    this.settingsPath = path.join(os.homedir(), SETTINGS_DIR, SETTINGS_FILE);
+  }
+  async load() {
+    if (this.cache) return this.cache;
+    return this.reload();
+  }
+  async reload() {
+    try {
+      const data = await fs.readFile(this.settingsPath, "utf-8");
+      const parsed = JSON.parse(data);
+      this.cache = SettingsSchema.parse({ ...DEFAULT_SETTINGS, ...parsed });
+    } catch {
+      this.cache = DEFAULT_SETTINGS;
+      await this.save(DEFAULT_SETTINGS);
+    }
+    return this.cache;
+  }
+  /**
+   * Add a permission to the allow list (called when user approves a command)
+   */
+  async addAllowedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.allow.includes(pattern)) {
+      s.permissions.allow.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  /**
+   * Add a permission to the unsandboxed allow list
+   */
+  async addUnsandboxedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.allowUnsandboxed.includes(pattern)) {
+      s.permissions.allowUnsandboxed.push(pattern);
+      if (!s.permissions.allow.includes(pattern)) {
+        s.permissions.allow.push(pattern);
+      }
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  /**
+   * Add a permission to the session-only allow/deny list
+   */
+  async addSessionPermission(tool, command, approved, bypass = false) {
+    const pattern = `${tool}:${command}`;
+    if (approved) {
+      this.sessionAllow.add(pattern);
+      this.sessionDeny.delete(pattern);
+      if (bypass) {
+        this.sessionUnsandboxed.add(pattern);
+      }
+    } else {
+      this.sessionDeny.add(pattern);
+      this.sessionAllow.delete(pattern);
+      this.sessionUnsandboxed.delete(pattern);
+    }
+  }
+  /**
+   * Add a permission to the deny list
+   */
+  async addDeniedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.deny.includes(pattern)) {
+      s.permissions.deny.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  async save(newSettings) {
+    const current = await this.load();
+    const merged = { ...current, ...newSettings };
+    if (newSettings.autoAccept) {
+      merged.autoAccept = { ...current.autoAccept, ...newSettings.autoAccept };
+    }
+    if (newSettings.permissions) {
+      merged.permissions = {
+        ...current.permissions,
+        ...newSettings.permissions
+      };
+    }
+    if (newSettings.security) {
+      merged.security = { ...current.security, ...newSettings.security };
+    }
+    if (newSettings.ui) {
+      merged.ui = { ...current.ui, ...newSettings.ui };
+    }
+    const validated = SettingsSchema.parse(merged);
+    const dir = path.dirname(this.settingsPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(this.settingsPath, JSON.stringify(validated, null, 2));
+    this.cache = validated;
+  }
+  async get(key) {
+    const s = await this.load();
+    return s[key];
+  }
+  async set(key, value) {
+    await this.save({ [key]: value });
+  }
+  /**
+   * Check if a tool:command pattern is authorized for THIS SESSION only
+   */
+  async isSessionAuthorized(tool, command) {
+    const pattern = `${tool}:${command}`;
+    return this.sessionAllow.has(pattern);
+  }
+  /**
+   * Check if a tool:command pattern is allowed (session or persistent)
+   */
+  async isAllowed(tool, command) {
+    const pattern = `${tool}:${command}`;
+    if (this.sessionAllow.has(pattern)) {
+      return true;
+    }
+    const s = await this.load();
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return false;
+      }
+    }
+    for (const allow of s.permissions.allow) {
+      if (this.matchPattern(pattern, allow)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool:command pattern is allowed to bypass sandbox
+   */
+  async isUnsandboxed(tool, command) {
+    const pattern = `${tool}:${command}`;
+    if (this.sessionUnsandboxed.has(pattern)) {
+      return true;
+    }
+    const s = await this.load();
+    for (const allow of s.permissions.allowUnsandboxed) {
+      if (this.matchPattern(pattern, allow)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool:command pattern is explicitly denied
+   */
+  async isDenied(tool, command) {
+    const pattern = `${tool}:${command}`;
+    if (this.sessionDeny.has(pattern)) {
+      return true;
+    }
+    const s = await this.load();
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Simple glob-like pattern matching
+   * Supports * as wildcard
+   */
+  matchPattern(value, pattern) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${regex}$`).test(value);
+  }
+  clearCache() {
+    this.cache = null;
+  }
+  getPath() {
+    return this.settingsPath;
+  }
+};
+var settings = new SettingsManager();
+
+export {
+  SettingsSchema,
+  settings
+};

package/dist/chunk-LYQYJMWS.js

@@ -0,0 +1,133 @@
+import {
+  history,
+  session,
+  tasks
+} from "./chunk-P5PQSFZT.js";
+import {
+  context
+} from "./chunk-DPNIQWKZ.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+
+// src/commands/resume.ts
+import path from "path";
+var resumeCommand = async (args) => {
+  if (args[0] === "--delete" || args[0] === "-d") {
+    const sessionId = args[1];
+    if (!sessionId) {
+      bus.emitAgent({
+        type: "error",
+        message: "Usage: /resume --delete <session_id>"
+      });
+      return;
+    }
+    const deleted = await session.delete(sessionId);
+    if (deleted) {
+      bus.emitAgent({
+        type: "done",
+        summary: `Session ${sessionId} deleted.`
+      });
+    } else {
+      bus.emitAgent({
+        type: "error",
+        message: `Session ${sessionId} not found.`
+      });
+    }
+    return;
+  }
+  if (args[0] === "--last" || args[0] === "-l") {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "error",
+        message: "No saved sessions found."
+      });
+      return;
+    }
+    args[0] = sessions[0].id;
+  }
+  if (!args[0]) {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "thought",
+        content: "No saved sessions found.\n\nSessions are created when you run /exit."
+      });
+      bus.emitAgent({
+        type: "done",
+        summary: "No sessions available."
+      });
+      return;
+    }
+    const content2 = [
+      "Saved Session Registry",
+      ...sessions.slice(0, 10).map((s) => {
+        const date = new Date(s.savedAt);
+        const dateStr = date.toLocaleDateString();
+        const timeStr = date.toLocaleTimeString([], {
+          hour: "2-digit",
+          minute: "2-digit"
+        });
+        const workspaceName = path.basename(s.workspace);
+        return [
+          `   \u23BF  [${s.id}]`,
+          `      \u23BF  Date      ${dateStr} ${timeStr}`,
+          `      \u23BF  Workspace ${workspaceName}`,
+          s.task ? `      \u23BF  Task      ${s.task}` : null,
+          `      \u23BF  Activity  ${s.filesModified} files handled`,
+          ""
+        ].filter(Boolean).join("\n");
+      }),
+      sessions.length > 10 ? `   ... and ${sessions.length - 10} more sessions
+` : "",
+      "   [Usage]",
+      "   \u23BF  /resume <id>      Restore session",
+      "   \u23BF  /resume --last    Restore latest",
+      ""
+    ].join("\n");
+    bus.emitAgent({
+      type: "thought",
+      content: content2
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: `${sessions.length} session(s) available.`
+    });
+    return;
+  }
+  const sessionIdArg = args[0];
+  const result = await session.restore(sessionIdArg);
+  if (!result.success) {
+    bus.emitAgent({
+      type: "error",
+      message: result.error || "Failed to restore session"
+    });
+    return;
+  }
+  const currentTask = tasks.get();
+  const currentContext = context.get();
+  const content = [
+    "Session Restored Successfully",
+    `   \u23BF  ID          ${sessionIdArg}`,
+    `   \u23BF  Root        ${path.basename(process.cwd())}`,
+    "",
+    "   [Restored State]",
+    `   \u23BF  Context     ${currentContext.files_read.length} files in set`,
+    `   \u23BF  History     ${(await history.load()).length} events rehydrated`,
+    `   \u23BF  Task        ${currentTask?.title || "None"}`,
+    ""
+  ].join("\n");
+  bus.emitAgent({
+    type: "thought",
+    content
+  });
+  bus.emitAgent({
+    type: "done",
+    summary: `Session ${sessionIdArg} restored.`
+  });
+};
+
+export {
+  resumeCommand
+};

package/dist/chunk-MBYFJXR3.js

@@ -0,0 +1,130 @@
+import {
+  history,
+  session,
+  tasks
+} from "./chunk-JNEIL7UN.js";
+import {
+  context
+} from "./chunk-MSDU36RT.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+
+// src/commands/resume.ts
+import path from "path";
+var resumeCommand = async (args) => {
+  if (args[0] === "--delete" || args[0] === "-d") {
+    const sessionId = args[1];
+    if (!sessionId) {
+      bus.emitAgent({
+        type: "error",
+        message: "Usage: /resume --delete <session_id>"
+      });
+      return;
+    }
+    const deleted = await session.delete(sessionId);
+    if (deleted) {
+      bus.emitAgent({
+        type: "done",
+        summary: `Session ${sessionId} deleted.`
+      });
+    } else {
+      bus.emitAgent({
+        type: "error",
+        message: `Session ${sessionId} not found.`
+      });
+    }
+    return;
+  }
+  if (args[0] === "--last" || args[0] === "-l") {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "error",
+        message: "No saved sessions found."
+      });
+      return;
+    }
+    args[0] = sessions[0].id;
+  }
+  if (!args[0]) {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "thought",
+        content: "No saved sessions found.\n\nSessions are created when you run /exit."
+      });
+      bus.emitAgent({
+        type: "done",
+        summary: "No sessions available."
+      });
+      return;
+    }
+    const content2 = [
+      "Saved Session Registry",
+      ...sessions.slice(0, 10).map((s) => {
+        const date = new Date(s.savedAt);
+        const dateStr = date.toLocaleDateString();
+        const timeStr = date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+        const workspaceName = path.basename(s.workspace);
+        return [
+          `   \u23BF  [${s.id}]`,
+          `      \u23BF  Date      ${dateStr} ${timeStr}`,
+          `      \u23BF  Workspace ${workspaceName}`,
+          s.task ? `      \u23BF  Task      ${s.task}` : null,
+          `      \u23BF  Activity  ${s.filesModified} files handled`,
+          ""
+        ].filter(Boolean).join("\n");
+      }),
+      sessions.length > 10 ? `   ... and ${sessions.length - 10} more sessions
+` : "",
+      "   [Usage]",
+      "   \u23BF  /resume <id>      Restore session",
+      "   \u23BF  /resume --last    Restore latest",
+      ""
+    ].join("\n");
+    bus.emitAgent({
+      type: "thought",
+      content: content2
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: `${sessions.length} session(s) available.`
+    });
+    return;
+  }
+  const sessionIdArg = args[0];
+  const result = await session.restore(sessionIdArg);
+  if (!result.success) {
+    bus.emitAgent({
+      type: "error",
+      message: result.error || "Failed to restore session"
+    });
+    return;
+  }
+  const currentTask = tasks.get();
+  const currentContext = context.get();
+  const content = [
+    "Session Restored Successfully",
+    `   \u23BF  ID          ${sessionIdArg}`,
+    `   \u23BF  Root        ${path.basename(process.cwd())}`,
+    "",
+    "   [Restored State]",
+    `   \u23BF  Context     ${currentContext.files_read.length} files in set`,
+    `   \u23BF  History     ${(await history.load()).length} events rehydrated`,
+    `   \u23BF  Task        ${currentTask?.title || "None"}`,
+    ""
+  ].join("\n");
+  bus.emitAgent({
+    type: "thought",
+    content
+  });
+  bus.emitAgent({
+    type: "done",
+    summary: `Session ${sessionIdArg} restored.`
+  });
+};
+
+export {
+  resumeCommand
+};