@openviking/openclaw-plugin 2026.5.8 → 2026.5.10-dev.3

package/dist/index.js

@@ -121,15 +121,6 @@ function getNumberFlag(flags, name) {
 function getBoolFlag(flags, name) {
     return flags.get(name) === true;
 }
-function parseImportKind(value) {
-    if (!value) {
-        return "resource";
-    }
-    if (value === "resource" || value === "skill") {
-        return value;
-    }
-    throw new Error("--kind must be resource or skill");
-}
 function extractToolSenderId(ctx) {
     if (!ctx || typeof ctx !== "object") {
         return undefined;
@@ -149,23 +140,18 @@ function extractToolSenderId(ctx) {
     }
     return undefined;
 }
-export function parseOvImportCommandArgs(args) {
+export function parseAddResourceCommandArgs(args) {
     const parsed = parseFlagArgs(args);
-    const kind = parseImportKind(getStringFlag(parsed.flags, "kind"));
     const source = parsed.positionals.length <= 1 ? parsed.positionals[0] : parsed.positionals.join(" ").trim();
     if (!source) {
-        throw new Error("Usage: /ov-import <source> [--kind resource|skill] [--to URI] [--parent URI] [--wait]");
+        throw new Error("Usage: /add-resource <source> [--to URI] [--parent URI] [--reason TEXT] [--instruction TEXT] [--wait] [--timeout SEC]");
     }
     const to = getStringFlag(parsed.flags, "to");
     const parent = getStringFlag(parsed.flags, "parent");
     if (to && parent) {
         throw new Error("Cannot specify both --to and --parent.");
     }
-    if (kind === "skill" && (to || parent || parsed.flags.has("reason") || parsed.flags.has("instruction"))) {
-        throw new Error("--to, --parent, --reason, and --instruction are resource-only options.");
-    }
     return {
-        kind,
         source,
         to,
         parent,
@@ -175,6 +161,21 @@ export function parseOvImportCommandArgs(args) {
         timeout: getNumberFlag(parsed.flags, "timeout"),
     };
 }
+export function parseAddSkillCommandArgs(args) {
+    const parsed = parseFlagArgs(args);
+    const source = parsed.positionals.length <= 1 ? parsed.positionals[0] : parsed.positionals.join(" ").trim();
+    if (!source) {
+        throw new Error("Usage: /add-skill <source> [--wait] [--timeout SEC]");
+    }
+    if (parsed.flags.has("to") || parsed.flags.has("parent") || parsed.flags.has("reason") || parsed.flags.has("instruction")) {
+        throw new Error("--to, --parent, --reason, and --instruction are resource-only options.");
+    }
+    return {
+        source,
+        wait: getBoolFlag(parsed.flags, "wait"),
+        timeout: getNumberFlag(parsed.flags, "timeout"),
+    };
+}
 export function parseMemorySearchCommandArgs(args) {
     const parsed = parseFlagArgs(args);
     // `/memory-search` only accepts a single query string, so positional segments are
@@ -417,32 +418,21 @@ const contextEnginePlugin = {
                 },
             };
         };
-        const executeImport = async (input, agentId) => {
-            const kind = input.kind ?? "resource";
-            if (kind === "skill") {
-                if (input.to || input.parent || input.reason || input.instruction) {
-                    throw new Error("to, parent, reason, and instruction are resource-only options.");
-                }
-                return importSkill({
-                    path: input.source,
-                    data: input.data,
-                    wait: input.wait,
-                    timeout: input.timeout,
-                }, agentId);
-            }
-            if (input.data !== undefined && input.data !== null) {
-                throw new Error("data is only supported for skill imports.");
-            }
-            return importResource({
-                pathOrUrl: input.source ?? "",
-                to: input.to,
-                parent: input.parent,
-                reason: input.reason,
-                instruction: input.instruction,
-                wait: input.wait,
-                timeout: input.timeout,
-            }, agentId);
-        };
+        const addResourceOpenViking = (input, agentId) => importResource({
+            pathOrUrl: input.source ?? "",
+            to: input.to,
+            parent: input.parent,
+            reason: input.reason,
+            instruction: input.instruction,
+            wait: input.wait,
+            timeout: input.timeout,
+        }, agentId);
+        const addSkillOpenViking = (input, agentId) => importSkill({
+            path: input.source,
+            data: input.data,
+            wait: input.wait,
+            timeout: input.timeout,
+        }, agentId);
         const mergeFindResults = (results) => {
             const deduplicate = (items) => {
                 const seen = new Map();
@@ -566,30 +556,26 @@ const contextEnginePlugin = {
             };
         };
         api.registerTool((ctx) => ({
-            name: "ov_import",
-            label: "Import (OpenViking)",
-            description: "Import an OpenViking resource or skill only when the user explicitly asks to import, add, or index one. " +
-                "Defaults to resource; set kind=skill for SKILL.md, skill directories, raw skill content, or MCP tool dicts.",
+            name: "add_resource",
+            label: "Add Resource (OpenViking)",
+            description: "Use only when the user explicitly asks to import, add, upload, save, or index a document, directory, URL, Git repository, or OpenClaw media attachment into OpenViking resources. " +
+                "For a '[media attached: /path ...]' document, set source to that exact local media path. Do not invent OpenViking upload REST endpoints.",
             parameters: Type.Object({
-                kind: Type.Optional(Type.Union([Type.Literal("resource"), Type.Literal("skill")], { description: "Import kind. Default: resource" })),
-                source: Type.Optional(Type.String({ description: "Local path, directory path, public URL, or Git URL" })),
-                data: Type.Optional(Type.Any({ description: "Skill only: raw SKILL.md content or MCP tool dict" })),
-                to: Type.Optional(Type.String({ description: "Resource only: exact target URI, e.g. viking://resources/project-docs" })),
-                parent: Type.Optional(Type.String({ description: "Resource only: parent URI under viking://resources" })),
-                reason: Type.Optional(Type.String({ description: "Resource only: reason or note for adding this resource" })),
-                instruction: Type.Optional(Type.String({ description: "Resource only: processing instruction for semantic extraction" })),
+                source: Type.String({ description: "Local path, OpenClaw media attachment path, directory path, public URL, or Git URL" }),
+                to: Type.Optional(Type.String({ description: "Exact target URI, e.g. viking://resources/project-docs" })),
+                parent: Type.Optional(Type.String({ description: "Parent URI under viking://resources" })),
+                reason: Type.Optional(Type.String({ description: "Reason or note for adding this resource" })),
+                instruction: Type.Optional(Type.String({ description: "Processing instruction for semantic extraction" })),
                 wait: Type.Optional(Type.Boolean({ description: "Wait for processing to complete" })),
                 timeout: Type.Optional(Type.Number({ description: "Timeout in seconds when wait is true" })),
             }),
             async execute(_toolCallId, params) {
                 if (isBypassedSession(ctx)) {
-                    return makeBypassedToolResult("ov_import");
+                    return makeBypassedToolResult("add_resource");
                 }
                 const session = resolvePluginSessionRouting(ctx);
-                return executeImport({
-                    kind: params.kind === "skill" ? "skill" : "resource",
+                return addResourceOpenViking({
                     source: typeof params.source === "string" ? params.source : undefined,
-                    data: params.data,
                     to: typeof params.to === "string" ? params.to : undefined,
                     parent: typeof params.parent === "string" ? params.parent : undefined,
                     reason: typeof params.reason === "string" ? params.reason : undefined,
@@ -598,7 +584,31 @@ const contextEnginePlugin = {
                     timeout: typeof params.timeout === "number" ? params.timeout : undefined,
                 }, session.agentId);
             },
-        }), { name: "ov_import" });
+        }), { name: "add_resource" });
+        api.registerTool((ctx) => ({
+            name: "add_skill",
+            label: "Add Skill (OpenViking)",
+            description: "Use only when the user explicitly asks to import, add, install, or register a skill into OpenViking. " +
+                "Set source to a local SKILL.md file or skill directory, or data to raw SKILL.md content or an MCP tool dict.",
+            parameters: Type.Object({
+                source: Type.Optional(Type.String({ description: "Local SKILL.md path or skill directory path" })),
+                data: Type.Optional(Type.Any({ description: "Raw SKILL.md content or MCP tool dict" })),
+                wait: Type.Optional(Type.Boolean({ description: "Wait for processing to complete" })),
+                timeout: Type.Optional(Type.Number({ description: "Timeout in seconds when wait is true" })),
+            }),
+            async execute(_toolCallId, params) {
+                if (isBypassedSession(ctx)) {
+                    return makeBypassedToolResult("add_skill");
+                }
+                const session = resolvePluginSessionRouting(ctx);
+                return addSkillOpenViking({
+                    source: typeof params.source === "string" ? params.source : undefined,
+                    data: params.data,
+                    wait: typeof params.wait === "boolean" ? params.wait : undefined,
+                    timeout: typeof params.timeout === "number" ? params.timeout : undefined,
+                }, session.agentId);
+            },
+        }), { name: "add_skill" });
         api.registerTool((ctx) => ({
             name: "memory_search",
             label: "Memory Search (OpenViking)",
@@ -621,22 +631,42 @@ const contextEnginePlugin = {
             },
         }), { name: "memory_search" });
         api.registerCommand?.({
-            name: "ov-import",
-            description: "Import a resource or skill into OpenViking.",
+            name: "add-resource",
+            description: "Add a resource into OpenViking.",
+            acceptsArgs: true,
+            handler: async (ctx) => {
+                try {
+                    if (isBypassedSession(ctx)) {
+                        const bypassed = makeBypassedToolResult("add_resource");
+                        return { text: bypassed.content[0].text, details: bypassed.details };
+                    }
+                    const session = resolvePluginSessionRouting(ctx);
+                    const input = parseAddResourceCommandArgs(ctx.args ?? "");
+                    const result = await addResourceOpenViking(input, session.agentId);
+                    return { text: result.content[0].text, details: result.details };
+                }
+                catch (err) {
+                    return { text: `OpenViking add resource failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        });
+        api.registerCommand?.({
+            name: "add-skill",
+            description: "Add a skill into OpenViking.",
             acceptsArgs: true,
             handler: async (ctx) => {
                 try {
                     if (isBypassedSession(ctx)) {
-                        const bypassed = makeBypassedToolResult("ov_import");
+                        const bypassed = makeBypassedToolResult("add_skill");
                         return { text: bypassed.content[0].text, details: bypassed.details };
                     }
                     const session = resolvePluginSessionRouting(ctx);
-                    const input = parseOvImportCommandArgs(ctx.args ?? "");
-                    const result = await executeImport(input, session.agentId);
+                    const input = parseAddSkillCommandArgs(ctx.args ?? "");
+                    const result = await addSkillOpenViking(input, session.agentId);
                     return { text: result.content[0].text, details: result.details };
                 }
                 catch (err) {
-                    return { text: `OpenViking import failed: ${err instanceof Error ? err.message : String(err)}` };
+                    return { text: `OpenViking add skill failed: ${err instanceof Error ? err.message : String(err)}` };
                 }
             },
         });