@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/plugins/mcp/index.js

@@ -0,0 +1,85 @@
+import { hlog } from '../../lib/log.js';
+import { PluginRegistry } from '../../lib/plugins/index.js';
+import { Tools } from '../../lib/tools/index.js';
+import { credentialAllowListFor, mcpReadMethods } from '../../lib/tools/skills/index.js';
+import { createMcpCallTool } from './call.js';
+import { listServerTools, serverTool } from './server.js';
+const SETUP_TIMEOUT_MS = 10_000;
+const SERVER_NAME = /^[a-z0-9_-]+$/;
+function serverError(server, names) {
+    const named = `server '${server.name}'`;
+    if (!SERVER_NAME.test(server.name ?? '') || server.name.includes('__')) {
+        return `${named} needs a name of lowercase letters, digits, _ and -, without __`;
+    }
+    if (names.has(server.name)) {
+        return `${named} is configured twice`;
+    }
+    names.add(server.name);
+    let url;
+    try {
+        url = new URL(server.url);
+    }
+    catch {
+        return `${named} needs a URL`;
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        return `${named} needs an http or https URL`;
+    }
+    return null;
+}
+export class McpPlugin {
+    name = 'mcp';
+    api = PluginRegistry.API_VERSION;
+    read;
+    _options;
+    constructor(options) {
+        this._options = options;
+        this.read = options?.read;
+    }
+    validate() {
+        const { servers = [], generic } = this._options ?? {};
+        if (!servers.length && !generic) {
+            return 'config needs servers or generic';
+        }
+        const names = new Set();
+        for (const server of servers) {
+            const error = serverError(server, names);
+            if (error) {
+                return error;
+            }
+        }
+        return null;
+    }
+    async setup({ fetch }) {
+        const { servers = [], generic, skillCatalog, credentialStore } = this._options;
+        const tools = [];
+        if (generic) {
+            const mcpCallTool = createMcpCallTool({
+                credentialStore: skillCatalog ? credentialStore : undefined,
+                credentialAllowList: skillCatalog ? credentialAllowListFor(skillCatalog) : undefined,
+                readMethods: skillCatalog ? mcpReadMethods(skillCatalog) : undefined
+            });
+            tools.push(mcpCallTool, ...Tools.operations(skillCatalog ?? [], { mcpCallTool }));
+        }
+        const timeoutMs = this._options.setupTimeoutMs ?? SETUP_TIMEOUT_MS;
+        const listed = await Promise.allSettled(servers.map((server) => listServerTools(server, { fetch, credentialStore, timeoutMs })));
+        const names = new Set(tools.map((tool) => tool.name));
+        servers.forEach((server, index) => {
+            const outcome = listed[index];
+            if (outcome.status === 'rejected') {
+                hlog('mcp server unavailable', { server: server.name, error: String(outcome.reason) });
+                return;
+            }
+            for (const entry of outcome.value) {
+                const tool = serverTool(server, entry, credentialStore);
+                if (names.has(tool.name)) {
+                    hlog('mcp tool listed twice', { tool: tool.name });
+                    continue;
+                }
+                names.add(tool.name);
+                tools.push(tool);
+            }
+        });
+        return { tools };
+    }
+}

package/dist-lib/{lib/tools → plugins}/mcp/protocol.d.ts

@@ -1,22 +1,14 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { ToolExecuteContext } from '../../capabilities/completion.ts';
-import { type FetchInit } from '../http-request/request.ts';
+import type { ToolExecuteContext, ToolFetch } from '../../lib/contract/index.ts';
 export declare const MCP_PROTOCOL_VERSION = "2025-03-26";
 export declare const TIMEOUT_MS = 30000;
-export interface McpHeaders {
-    get(name: string): string | null;
+interface McpResponseBody {
+    headers: {
+        get(name: string): string | null;
+    };
+    text(): Promise<string>;
 }
-export interface McpResponseBody {
-    headers: McpHeaders;
-    text(): Promise<string> | string;
-}
-export interface McpResponse extends McpResponseBody {
-    status: number;
-    statusText?: string;
-}
-export type McpFetchFn = (url: URL, init: FetchInit) => Promise<McpResponse>;
 export declare function isNotification(method: string): boolean;
-export declare function isMetadataMethod(method: unknown): boolean;
 export interface McpRequest {
     method: string;
     params: Record<string, unknown> | undefined;
@@ -40,7 +32,7 @@ export interface McpPostOptions {
     readonly sessionId: string | undefined;
     readonly signal: BareAbortSignal;
 }
-export declare function post(fetch: McpFetchFn, url: URL, { method, params, authHeader, sessionId, signal }: McpPostOptions): ReturnType<McpFetchFn>;
+export declare function post(fetch: ToolFetch, url: URL, { method, params, authHeader, sessionId, signal }: McpPostOptions): ReturnType<ToolFetch>;
 export declare function readBody(response: McpResponseBody): Promise<string>;
 export declare function needsSession(status: number, cached: string): boolean;
 export interface McpSessionOptions {
@@ -50,4 +42,5 @@ export interface McpSessionOptions {
 export interface McpSessionError extends McpError {
     stateless?: true;
 }
-export declare function establishSession(fetch: McpFetchFn, url: URL, { authHeader, signal }: McpSessionOptions): Promise<string | McpSessionError>;
+export declare function establishSession(fetch: ToolFetch, url: URL, { authHeader, signal }: McpSessionOptions): Promise<string | McpSessionError>;
+export {};

package/dist-lib/{lib/tools → plugins}/mcp/protocol.js

@@ -1,25 +1,12 @@
-import { isRecord } from '../../guards.js';
-import { MAX_RESPONSE_CHARS } from '../http-request/request.js';
+import { isRecord } from '../../lib/guards.js';
+import { METADATA_METHODS } from '../../lib/helpers/mcp-methods.js';
+import { MAX_RESPONSE_CHARS } from '../../lib/tools/http-request/request.js';
 export const MCP_PROTOCOL_VERSION = '2025-03-26';
 export const TIMEOUT_MS = 30_000;
-const METADATA_METHODS = new Set([
-    'initialize',
-    'ping',
-    'tools/list',
-    'resources/list',
-    'resources/read',
-    'resources/templates/list',
-    'prompts/list',
-    'prompts/get',
-    'completion/complete'
-]);
 const PROTOCOL_METHODS = new Set([...METADATA_METHODS, 'tools/call']);
 export function isNotification(method) {
     return method.startsWith('notifications/');
 }
-export function isMetadataMethod(method) {
-    return typeof method === 'string' && METADATA_METHODS.has(method);
-}
 export function normalizeMethod(method, params) {
     if (method === 'tools/call') {
         const p = params ?? {};

package/dist-lib/plugins/mcp/server.d.ts

@@ -0,0 +1,23 @@
+import type { ToolDefinition, ToolFetch, ToolParameters } from '../../lib/contract/index.ts';
+import { type CredentialStoreFn } from '../../lib/tools/skills/index.ts';
+export interface McpServerConfig {
+    readonly name: string;
+    readonly url: string;
+    readonly auth?: {
+        readonly tokenCredentialKey: string;
+    };
+    readonly defer?: boolean;
+}
+export interface ListedTool {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: ToolParameters;
+}
+interface Discovery {
+    readonly fetch: ToolFetch;
+    readonly credentialStore: CredentialStoreFn | undefined;
+    readonly timeoutMs: number;
+}
+export declare function listServerTools(server: McpServerConfig, { fetch, credentialStore, timeoutMs }: Discovery): Promise<ListedTool[]>;
+export declare function serverTool(server: McpServerConfig, listed: ListedTool, credentialStore: CredentialStoreFn | undefined): ToolDefinition;
+export {};

package/dist-lib/plugins/mcp/server.js

@@ -0,0 +1,108 @@
+import { AbortController } from 'bare-abort-controller';
+import { createHash } from 'crypto';
+import { z } from 'zod';
+import { isRecord } from '../../lib/guards.js';
+import { resolveBearerHeader } from '../../lib/tools/skills/index.js';
+import { sendMcp } from './call.js';
+import { establishSession, post, readBody } from './protocol.js';
+const InputSchema = z.looseObject({
+    properties: z.record(z.string(), z.custom(isRecord)).optional(),
+    required: z.array(z.string()).optional()
+});
+const Listed = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    inputSchema: InputSchema.optional()
+});
+const ListPage = z.object({
+    result: z.object({ tools: z.array(z.unknown()), nextCursor: z.string().optional() })
+});
+function bearerAuth(server) {
+    return server.auth
+        ? { type: 'bearer', tokenCredentialKey: server.auth.tokenCredentialKey }
+        : undefined;
+}
+function allowListOf(server) {
+    return server.auth ? { [server.auth.tokenCredentialKey]: [server.url] } : undefined;
+}
+export async function listServerTools(server, { fetch, credentialStore, timeoutMs }) {
+    const url = new URL(server.url);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(undefined), timeoutMs);
+    const { signal } = controller;
+    try {
+        const bearer = await resolveBearerHeader(bearerAuth(server), url, server.auth ? credentialStore : undefined, allowListOf(server), undefined, signal);
+        if ('error' in bearer) {
+            throw new Error(bearer.error);
+        }
+        const authHeader = bearer.header;
+        const session = await establishSession(fetch, url, { authHeader, signal });
+        if (typeof session !== 'string' && !session.stateless) {
+            throw new Error(session.error);
+        }
+        const sessionId = typeof session === 'string' ? session : undefined;
+        const listed = [];
+        let cursor;
+        do {
+            const response = await post(fetch, url, {
+                method: 'tools/list',
+                params: cursor === undefined ? undefined : { cursor },
+                authHeader,
+                sessionId,
+                signal
+            });
+            const body = await readBody(response);
+            if (response.status < 200 || response.status >= 300) {
+                throw new Error(`tools/list failed: ${response.status}`);
+            }
+            const page = ListPage.parse(JSON.parse(body)).result;
+            listed.push(...page.tools.flatMap(listedTool));
+            cursor = page.nextCursor;
+        } while (cursor);
+        return listed;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function listedTool(entry) {
+    const parsed = Listed.safeParse(entry);
+    if (!parsed.success) {
+        return [];
+    }
+    const { name, description, inputSchema } = parsed.data;
+    return [
+        {
+            name,
+            description: description ?? '',
+            parameters: { ...inputSchema, type: 'object', properties: inputSchema?.properties ?? {} }
+        }
+    ];
+}
+export function serverTool(server, listed, credentialStore) {
+    const url = new URL(server.url);
+    const auth = bearerAuth(server);
+    const credentialAllowList = allowListOf(server);
+    const tool = {
+        name: `${server.name}__${listed.name}`,
+        policyVersion: createHash('sha256')
+            .update(JSON.stringify({ url: server.url, name: listed.name, parameters: listed.parameters }))
+            .digest('hex'),
+        description: listed.description,
+        parameters: listed.parameters,
+        toolset: 'mcp-call',
+        externalWrite: true,
+        effect: () => 'write',
+        egress: () => server.url,
+        resource: () => ({ kind: 'host', label: url.hostname }),
+        execute: (args, ctx) => sendMcp({
+            url,
+            method: 'tools/call',
+            params: { name: listed.name, arguments: args },
+            auth,
+            credentialStore: auth ? credentialStore : undefined,
+            credentialAllowList
+        }, ctx)
+    };
+    return server.defer ? { ...tool, defer: true, group: server.name } : tool;
+}

package/dist-lib/{lib/tools → plugins/music}/generate-music.d.ts

@@ -1,8 +1,9 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { MusicSettings, ToolDefinition, ToolExecuteContext } from '../capabilities/completion.ts';
-import type { ModelSrc } from '../models/context.ts';
-import { type LoadTracker, type TrackedLoad } from '../models/model-pool.ts';
-import { type ModelRegistrySdk } from '../models/model-source.ts';
+import type { MusicSettings, ToolDefinition, ToolExecuteContext } from '../../lib/contract/index.ts';
+import type { ModelSrc } from '../../lib/models/context.ts';
+import { type MusicClamps, type MusicModelStages } from '../../lib/models/model-catalog.ts';
+import type { ModelHost, TrackedLoad } from '../../lib/contract/models.ts';
+import { type ModelRegistrySdk } from '../../lib/models/model-source.ts';
 export declare const MAX_DURATION_SECONDS = 300;
 export declare const MIN_DURATION_SECONDS = 1;
 export declare const MAX_STEPS = 60;
@@ -64,19 +65,13 @@ export type MusicGenSdk = ModelRegistrySdk & {
         requestId: string;
     }): Promise<void>;
 };
-export interface MusicModelStages {
-    dit: string;
-    textEnc: string;
-    lm: string;
-    vae: string;
-}
 export interface MusicRuntimeOptions extends MusicModelStages {
     loadSdk: () => Promise<MusicGenSdk>;
     inferenceSteps?: number;
     useGpu?: boolean;
     onProgress?: (model: string, progress: Record<string, unknown>) => void;
     onBeforeLoad?: (signal?: BareAbortSignal) => Promise<void>;
-    loads?: LoadTracker;
+    loads?: Pick<ModelHost, 'track'>;
 }
 export interface LoadedMusicModel {
     modelId: string;
@@ -123,10 +118,6 @@ export declare function gpuFallback({ gpuRequested, stats }: GpuFallbackOptions)
 export declare function backendDevice(stats: MusicStats | undefined): 'gpu' | 'cpu' | 'unknown';
 export declare function backendName(backendId: number | undefined): string;
 export declare function pcmToWav(audio: GeneratedAudio): Uint8Array;
-export interface MusicClamps {
-    maxDuration?: number;
-    maxSteps?: number;
-}
 export declare function settingsDuration(value: number | undefined, maxDuration: number): number | undefined;
 export declare function settingsSteps(value: number | undefined, maxSteps?: number): number | undefined;
 export declare function normalizeClamps(clamps?: MusicClamps): Required<MusicClamps>;

package/dist-lib/{lib/tools → plugins/music}/generate-music.js

@@ -1,11 +1,10 @@
 import process from 'process';
 import ScopeLock from 'scope-lock';
-import { AbortedError, raceAbort } from '../helpers/race-abort.js';
-import { hdiag } from '../log.js';
-import { AUDIOGEN_CATALOG, musicChoiceForDit, musicDefaultSteps, musicModelSet } from '../models/model-catalog.js';
-import { GENERATE_MUSIC_TOOL } from '../models/music-catalog.js';
-import { createLoadTracker } from '../models/model-pool.js';
-import { resolveModelSrc } from '../models/model-source.js';
+import { AbortedError, raceAbort } from '../../lib/helpers/race-abort.js';
+import { hdiag } from '../../lib/log.js';
+import { AUDIOGEN_CATALOG, musicChoiceForDit, musicDefaultSteps, musicModelSet } from '../../lib/models/model-catalog.js';
+import { GENERATE_MUSIC_TOOL } from '../../lib/models/music-catalog.js';
+import { resolveModelSrc } from '../../lib/models/model-source.js';
 export const MAX_DURATION_SECONDS = 300;
 export const MIN_DURATION_SECONDS = 1;
 export const MAX_STEPS = 60;
@@ -49,7 +48,7 @@ function musicProgressName(dit) {
     const entry = AUDIOGEN_CATALOG.find((candidate) => candidate.dit.src === dit || candidate.dit.name === dit);
     return entry?.name ?? dit;
 }
-export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads = createLoadTracker(), inferenceSteps: baseSteps, useGpu = true, ...base }) {
+export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads = { track: (pending) => pending }, inferenceSteps: baseSteps, useGpu = true, ...base }) {
     let loading = null;
     let residentFingerprint = null;
     let busy = false;
@@ -399,7 +398,7 @@ export function createGenerateMusicTool(runtime, clamps) {
     const stepsCap = clamps?.maxSteps ? cap.maxSteps : undefined;
     return {
         name: GENERATE_MUSIC_TOOL,
-        toolset: null,
+        toolset: 'music',
         skillGated: true,
         description: 'Generate music or other audio from a text description using the local ACE-Step model. ' +
             'The prompt describes the genre, instruments, mood, and tempo in plain language. ' +

package/dist-lib/plugins/music/index.d.ts

@@ -0,0 +1,24 @@
+import type { MusicClamps, MusicModelStages } from '../../lib/models/model-catalog.ts';
+import type { HarnessPlugin, PluginContext, PluginSetup } from '../../lib/plugins/index.ts';
+export { audioDurationSeconds, backendDevice, backendName, CPU_FALLBACK_NOTICE, createGenerateMusicTool, createMusicRuntime, gpuFallback, musicPercentTick, pcmToWav, presentStats, type GeneratedAudio, type MusicGenSdk, type MusicRuntime, type MusicRuntimeOptions, type MusicStats, type MusicTick } from './generate-music.ts';
+export interface MusicOptions {
+    model: MusicModelStages & {
+        inferenceSteps?: number;
+        useGpu?: boolean;
+    };
+    clamps?: MusicClamps;
+    read?: readonly string[];
+}
+export declare class Music implements HarnessPlugin {
+    readonly name = "music";
+    readonly api = 1;
+    readonly needs: string[];
+    readonly addons: {
+        'audiogen-ggml': () => Promise<any>;
+    };
+    readonly read: readonly string[] | undefined;
+    private readonly _options;
+    constructor(options: MusicOptions);
+    validate(): string | null;
+    setup(ctx: PluginContext): PluginSetup;
+}

package/dist-lib/plugins/music/index.js

@@ -0,0 +1,48 @@
+import { retryMemo } from '../../lib/helpers/retry-memo.js';
+import { PluginRegistry } from '../../lib/plugins/index.js';
+import { createGenerateMusicTool, createMusicRuntime } from './generate-music.js';
+export { audioDurationSeconds, backendDevice, backendName, CPU_FALLBACK_NOTICE, createGenerateMusicTool, createMusicRuntime, gpuFallback, musicPercentTick, pcmToWav, presentStats } from './generate-music.js';
+const BUSY_MESSAGE = 'the chat model is busy; try the music again once the current reply finishes';
+export class Music {
+    name = 'music';
+    api = PluginRegistry.API_VERSION;
+    needs = ['models'];
+    addons = { 'audiogen-ggml': () => import('@qvac/audiogen-ggml/binding.js') };
+    read;
+    _options;
+    constructor(options) {
+        this._options = options;
+        this.read = options?.read;
+    }
+    validate() {
+        return this._options?.model ? null : 'needs a model';
+    }
+    setup(ctx) {
+        const { model, clamps } = this._options;
+        const models = ctx.service('models');
+        const loadSdk = retryMemo(async () => {
+            const sdk = await models.sdk();
+            const [{ audioGenPlugin }, { registerPlugin }] = await Promise.all([
+                import('@qvac/sdk/audiogen-ggml/plugin'),
+                import('@qvac/sdk/plugins')
+            ]);
+            try {
+                registerPlugin(audioGenPlugin);
+            }
+            catch { }
+            return sdk;
+        });
+        const runtime = createMusicRuntime({
+            ...model,
+            loads: models,
+            loadSdk,
+            onProgress: (name, progress) => models.emit(models.progressState(name, progress)),
+            onBeforeLoad: (signal) => models.makeRoom(signal, BUSY_MESSAGE)
+        });
+        return {
+            tools: [createGenerateMusicTool(runtime, clamps)],
+            unload: () => runtime.unload(),
+            unloadIdle: () => runtime.unloadIdle()
+        };
+    }
+}

package/dist-lib/{lib/tools/exec → plugins}/obsidian/cli-process.d.ts

@@ -1,6 +1,6 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import { type ObsidianPathProbe } from '../../skills/obsidian-readiness.ts';
-import type { KillProcess, SpawnFn } from '../runner.ts';
+import { type ObsidianPathProbe } from './readiness.ts';
+import type { KillProcess, SpawnFn } from '../../lib/tools/exec/runner.ts';
 export declare function runningCheckCommand(os: string): string;
 export declare function launchCommand(os: string): string;
 export declare function obsidianPathEnv(platform?: NodeJS.Platform, env?: Record<string, string | undefined>, probe?: ObsidianPathProbe): Record<string, string> | undefined;

package/dist-lib/{lib/tools/exec → plugins}/obsidian/cli-process.js

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import process from 'process';
-import { execEnv } from '../../../helpers/spawn-path.js';
-import { expandObsidianPath, firstExistingPath, OBSIDIAN_BIN_CANDIDATES } from '../../skills/obsidian-readiness.js';
+import { execEnv } from '../../lib/helpers/spawn-path.js';
+import { expandObsidianPath, firstExistingPath, OBSIDIAN_BIN_CANDIDATES } from './readiness.js';
 const RUNNING_CHECK_MS = 3_000;
 export function runningCheckCommand(os) {
     if (os === 'win32') {

package/dist-lib/{lib/tools/exec → plugins}/obsidian/cli.d.ts

@@ -1,5 +1,5 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import { type ExecResult, type KillProcess, type SpawnFn } from '../runner.ts';
+import { type ExecResult, type KillProcess, type SpawnFn } from '../../lib/tools/exec/runner.ts';
 export interface RunObsidianCliOptions {
     readonly timeoutMs?: number;
     readonly maxOutputChars?: number;

package/dist-lib/{lib/tools/exec → plugins}/obsidian/cli.js

@@ -1,4 +1,4 @@
-import { appendOutput, capOutput, createCapturedOutput, MAX_OUTPUT_CHARS } from '../runner.js';
+import { appendOutput, capOutput, createCapturedOutput, formatOutput, MAX_OUTPUT_CHARS } from '../../lib/tools/exec/runner.js';
 import { isObsidianRunning, launchObsidianApp, obsidianPathEnv } from './cli-process.js';
 import { OBSIDIAN_CLI_FAILURE_GUIDANCE } from './guidance.js';
 import { cleanObsidianOutput } from './output.js';
@@ -79,8 +79,8 @@ function runOnce(command, runtime, { timeoutMs, maxOutputChars, signal }) {
             stdio: ['ignore', 'pipe', 'pipe'],
             env
         });
-        const stdout = createCapturedOutput();
-        const stderr = createCapturedOutput();
+        const stdout = createCapturedOutput(maxOutputChars);
+        const stderr = createCapturedOutput(maxOutputChars);
         let settled = false;
         let quietTimer;
         const finish = (exitCode) => {
@@ -102,8 +102,8 @@ function runOnce(command, runtime, { timeoutMs, maxOutputChars, signal }) {
                 child.kill('SIGKILL');
             }
             resolve({
-                result: capOutput(cleanObsidianOutput(stdout.value), maxOutputChars),
-                stderr: capOutput(cleanObsidianOutput(stderr.value), maxOutputChars),
+                result: cleanObsidianOutput(formatOutput(stdout)),
+                stderr: cleanObsidianOutput(formatOutput(stderr)),
                 exitCode
             });
         };
@@ -115,11 +115,11 @@ function runOnce(command, runtime, { timeoutMs, maxOutputChars, signal }) {
             quietTimer = globalThis.setTimeout(() => finish(null), OUTPUT_QUIET_MS);
         };
         child.stdout?.on('data', (chunk) => {
-            appendOutput(stdout, chunk, maxOutputChars);
+            appendOutput(stdout, chunk);
             bumpQuiet();
         });
         child.stderr?.on('data', (chunk) => {
-            appendOutput(stderr, chunk, maxOutputChars);
+            appendOutput(stderr, chunk);
             bumpQuiet();
         });
         child.on('exit', (code) => finish(code));

package/dist-lib/{lib/tools/exec → plugins}/obsidian/command.js

@@ -1,4 +1,4 @@
-import { shellArgv } from '../shell-argv.js';
+import { shellArgv } from '../../lib/tools/exec/shell-argv.js';
 const OBSIDIAN_BIN = /^obsidian(?:\.exe|\.com)?$/i;
 const OBSIDIAN_PREFIX = /^obsidian(?:\.exe|\.com)?(?:\s|$)/i;
 export function parseObsidianCommand(command) {

package/dist-lib/{lib/tools/exec → plugins}/obsidian/guidance.d.ts

@@ -2,4 +2,3 @@ export declare const OBSIDIAN_NO_SHELL_FALLBACK: string;
 export declare const OBSIDIAN_CLI_FAILURE_GUIDANCE = "Do not use `ls`, `cat`, `find`, `grep`, or filesystem paths to inspect the vault or Obsidian config \u2014 that bypasses Obsidian and is wrong. Correct the obsidian command or ask the user to open Obsidian / register the CLI.";
 export declare const OBSIDIAN_DESKTOP_AGENT_REQUIRED: string;
 export declare const OBSIDIAN_VAULT_SETUP_REQUIRED: string;
-export declare const OBSIDIAN_VAULT_MODE_NOTE: string;

package/dist-lib/{lib/tools/exec → plugins}/obsidian/guidance.js

@@ -9,10 +9,3 @@ export const OBSIDIAN_VAULT_SETUP_REQUIRED = 'Obsidian vault file mode is not se
     'to open Skills > Obsidian > Select vault folder, then retry the same `obsidian` ' +
     `command. ${OBSIDIAN_NO_SHELL_FALLBACK} This is a one-time setup step, not a reason ` +
     'to switch tools.';
-export const OBSIDIAN_VAULT_MODE_NOTE = [
-    'Runtime note — Obsidian vault file mode is active (a vault folder is configured):',
-    '- Run vault commands through the `exec` tool, e.g. `obsidian vault info=path`, `obsidian search query="..."`, `obsidian read path="Folder/Note.md"`.',
-    '- Start with `obsidian vault info=path` to confirm the configured vault.',
-    '- `obsidian vaults` returns only the configured vault folder, not every vault in the Obsidian app.',
-    '- App-only actions (open in app, plugin/sync/theme commands) are unavailable in this mode; they require the official Obsidian CLI connected to the running app.'
-].join('\n');

package/dist-lib/plugins/obsidian/index.d.ts

@@ -0,0 +1,26 @@
+import type { ToolExecuteContext } from '../../lib/contract/index.ts';
+import type { HarnessPlugin, PluginSetup } from '../../lib/plugins/index.ts';
+import { type ObsidianPathProbe } from './readiness.ts';
+import type { ExecRoute, ExecRouteOptions } from '../../lib/contract/exec.ts';
+import { type ExecResult } from '../../lib/tools/exec/runner.ts';
+interface CredentialRecord {
+    readonly token: string;
+}
+type ObsidianCredential = CredentialRecord | string | null;
+export type ObsidianCredentialStore = (key: string, ctx?: ToolExecuteContext) => Promise<ObsidianCredential> | ObsidianCredential;
+export interface ObsidianRouteOptions {
+    readonly credentialStore?: ObsidianCredentialStore | undefined;
+    readonly platform?: string;
+    readonly env?: Record<string, string | undefined>;
+    readonly probe?: ObsidianPathProbe;
+}
+export declare class ObsidianRoute implements ExecRoute, HarnessPlugin {
+    readonly name = "obsidian";
+    readonly api = 1;
+    private readonly _options;
+    constructor(options?: ObsidianRouteOptions);
+    setup(): PluginSetup;
+    claims(command: string): boolean;
+    run(command: string, ctx: ToolExecuteContext | undefined, { timeoutMs, maxOutputChars, signal, runtime }: ExecRouteOptions): Promise<ExecResult>;
+}
+export {};