@vellumai/assistant 0.12.2-dev.202609171225.565e464 → 0.12.2-dev.202609171516.2acdfd4

package/src/plugin-api/__tests__/plugin-name-env.test.ts

@@ -0,0 +1,249 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { runInPluginContext } from "../../plugins/plugin-execution-context.js";
+import {
+  derivePluginNameFromProcess,
+  derivePluginNameFromSkillScriptPath,
+  PLUGIN_NAME_ENV,
+  readPluginNameFromEnv,
+  resolveCallingPluginName,
+} from "../plugin-name-env.js";
+
+const pluginsDir = "/tmp/vellum-workspace/plugins";
+
+describe("readPluginNameFromEnv", () => {
+  test("returns a trimmed install name", () => {
+    expect(readPluginNameFromEnv({ [PLUGIN_NAME_ENV]: "  sms  " })).toBe("sms");
+  });
+
+  test("ignores empty or whitespace-only values", () => {
+    expect(readPluginNameFromEnv({ [PLUGIN_NAME_ENV]: "" })).toBeUndefined();
+    expect(readPluginNameFromEnv({ [PLUGIN_NAME_ENV]: "   " })).toBeUndefined();
+    expect(readPluginNameFromEnv({})).toBeUndefined();
+  });
+});
+
+describe("derivePluginNameFromSkillScriptPath", () => {
+  test("returns the plugin install name for a scripts path", () => {
+    expect(
+      derivePluginNameFromSkillScriptPath(
+        join(pluginsDir, "sms/skills/sms-setup/scripts/twilio-numbers.ts"),
+        pluginsDir,
+      ),
+    ).toBe("sms");
+  });
+
+  test("returns the plugin install name for a tools path", () => {
+    expect(
+      derivePluginNameFromSkillScriptPath(
+        join(pluginsDir, "sms/skills/sms-setup/tools/list.ts"),
+        pluginsDir,
+      ),
+    ).toBe("sms");
+  });
+
+  test("accepts a file URL", () => {
+    const filePath = join(
+      pluginsDir,
+      "sms/skills/sms-setup/scripts/twilio-numbers.ts",
+    );
+    expect(
+      derivePluginNameFromSkillScriptPath(`file://${filePath}`, pluginsDir),
+    ).toBe("sms");
+  });
+
+  test("rejects a path outside plugins/", () => {
+    expect(
+      derivePluginNameFromSkillScriptPath(
+        "/tmp/other/skills/sms-setup/scripts/twilio-numbers.ts",
+        pluginsDir,
+      ),
+    ).toBeUndefined();
+  });
+
+  test("rejects a plugin file that is not under scripts/ or tools/", () => {
+    expect(
+      derivePluginNameFromSkillScriptPath(
+        join(pluginsDir, "sms/skills/sms-setup/SKILL.md"),
+        pluginsDir,
+      ),
+    ).toBeUndefined();
+    expect(
+      derivePluginNameFromSkillScriptPath(
+        join(pluginsDir, "sms/register.ts"),
+        pluginsDir,
+      ),
+    ).toBeUndefined();
+  });
+
+  test("rejects a truncated plugins path", () => {
+    expect(
+      derivePluginNameFromSkillScriptPath(
+        join(pluginsDir, "sms/skills/scripts/too-short.ts"),
+        pluginsDir,
+      ),
+    ).toBeUndefined();
+  });
+});
+
+describe("derivePluginNameFromProcess", () => {
+  test("scans argv for a plugin-resident skill script", () => {
+    expect(
+      derivePluginNameFromProcess(
+        ["bun", join(pluginsDir, "sms/skills/sms-setup/scripts/twilio-numbers.ts")],
+        "/tmp",
+        pluginsDir,
+      ),
+    ).toBe("sms");
+  });
+
+  test("resolves a relative argv path against cwd", () => {
+    expect(
+      derivePluginNameFromProcess(
+        ["bun", "sms/skills/sms-setup/scripts/twilio-numbers.ts"],
+        pluginsDir,
+        pluginsDir,
+      ),
+    ).toBe("sms");
+  });
+
+  test("skips flags", () => {
+    expect(
+      derivePluginNameFromProcess(
+        ["bun", "--hot", join(pluginsDir, "sms/skills/sms-setup/scripts/twilio-numbers.ts")],
+        "/tmp",
+        pluginsDir,
+      ),
+    ).toBe("sms");
+  });
+});
+
+describe("resolveCallingPluginName", () => {
+  const prior = process.env[PLUGIN_NAME_ENV];
+
+  afterEach(() => {
+    if (prior === undefined) {
+      delete process.env[PLUGIN_NAME_ENV];
+    } else {
+      process.env[PLUGIN_NAME_ENV] = prior;
+    }
+  });
+
+  test("prefers AsyncLocalStorage over env", () => {
+    process.env[PLUGIN_NAME_ENV] = "from-env";
+    const name = runInPluginContext("from-als", () =>
+      resolveCallingPluginName(process.env, [], "/tmp"),
+    );
+    expect(name).toBe("from-als");
+  });
+
+  test("uses VELLUM_PLUGIN_NAME when ALS is empty", () => {
+    expect(
+      resolveCallingPluginName({ [PLUGIN_NAME_ENV]: "sms" }, [], "/tmp"),
+    ).toBe("sms");
+  });
+
+  test("falls back to the process entry path", () => {
+    expect(
+      resolveCallingPluginName(
+        {},
+        ["bun", join(pluginsDir, "sms/skills/sms-setup/scripts/twilio-numbers.ts")],
+        "/tmp",
+        pluginsDir,
+      ),
+    ).toBe("sms");
+  });
+});
+
+describe("resolveCallingPluginName real child", () => {
+  test("recovers the plugin name from a scripts path without env", async () => {
+    const workspace = mkdtempSync(join(tmpdir(), "plugin-name-child-"));
+    const scriptDir = join(
+      workspace,
+      "plugins/sms/skills/sms-setup/scripts",
+    );
+    mkdirSync(scriptDir, { recursive: true });
+    const helper = join(
+      import.meta.dir,
+      "..",
+      "plugin-name-env.ts",
+    );
+    const scriptPath = join(scriptDir, "echo-plugin-name.ts");
+    writeFileSync(
+      scriptPath,
+      `import { resolveCallingPluginName } from ${JSON.stringify(helper)};
+console.log(JSON.stringify({ name: resolveCallingPluginName() ?? null }));
+`,
+    );
+
+    try {
+      const child = Bun.spawn(
+        ["bun", scriptPath],
+        {
+          cwd: scriptDir,
+          env: {
+            PATH: process.env.PATH,
+            HOME: process.env.HOME,
+            VELLUM_WORKSPACE_DIR: workspace,
+          },
+          stdout: "pipe",
+          stderr: "pipe",
+        },
+      );
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+        child.exited,
+      ]);
+      expect(stderr).toBe("");
+      expect(exitCode).toBe(0);
+      expect(JSON.parse(stdout.trim())).toEqual({ name: "sms" });
+    } finally {
+      rmSync(workspace, { recursive: true, force: true });
+    }
+  }, 15_000);
+
+  test("recovers the plugin name from VELLUM_PLUGIN_NAME without a plugin path", async () => {
+    const workspace = mkdtempSync(join(tmpdir(), "plugin-name-env-child-"));
+    const scriptDir = join(workspace, "scratch");
+    mkdirSync(scriptDir, { recursive: true });
+    const helper = join(import.meta.dir, "..", "plugin-name-env.ts");
+    const scriptPath = join(scriptDir, "echo-plugin-name.ts");
+    writeFileSync(
+      scriptPath,
+      `import { resolveCallingPluginName } from ${JSON.stringify(helper)};
+console.log(JSON.stringify({ name: resolveCallingPluginName() ?? null }));
+`,
+    );
+
+    try {
+      const child = Bun.spawn(
+        ["bun", scriptPath],
+        {
+          cwd: scriptDir,
+          env: {
+            PATH: process.env.PATH,
+            HOME: process.env.HOME,
+            VELLUM_WORKSPACE_DIR: workspace,
+            VELLUM_PLUGIN_NAME: "sms",
+          },
+          stdout: "pipe",
+          stderr: "pipe",
+        },
+      );
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+        child.exited,
+      ]);
+      expect(stderr).toBe("");
+      expect(exitCode).toBe(0);
+      expect(JSON.parse(stdout.trim())).toEqual({ name: "sms" });
+    } finally {
+      rmSync(workspace, { recursive: true, force: true });
+    }
+  }, 15_000);
+});

package/src/plugin-api/index.ts

@@ -169,10 +169,12 @@ export { publishEvent } from "./publish-event.js";
 // `inputModalities.image` override winning when set (mix profiles are
 // vision-capable if any arm is). Returns false when nothing resolves.
 export { doesSupportVision } from "./vision-support.js";
-// Resolve a stored credential to its plaintext value — the same value
-// `assistant credentials reveal` prints — from a UUID or a "service/field"
+// Resolve a stored credential to its plaintext value (the same value
+// `assistant credentials reveal` prints) from a UUID or a "service/field"
 // reference. When a plugin is in context, resolution is scoped to credentials
-// whose service matches the plugin's manifest name; outside any plugin it is
+// whose service matches the plugin's runtime name. A plugin-resident skill
+// script or skill-tool child presents a daemon-issued invocation grant and is
+// scoped the same way. Outside any plugin context or grant the resolver is
 // unscoped. Throws CredentialResolutionError when the ref does not resolve, the
 // store is unreachable, or the credential is out of the plugin's scope.
 export {

package/src/plugin-api/plugin-name-env.ts

@@ -0,0 +1,125 @@
+/**
+ * How a child process learns which plugin it is running as.
+ *
+ * In-process plugin hooks, tools, and routes use AsyncLocalStorage
+ * ({@link getCurrentPluginName}). A bash or skill-sandbox child does not
+ * inherit that store. Those children recover the install-directory basename
+ * from `VELLUM_PLUGIN_NAME` (injected after env sanitization) or from the
+ * entry script path under `plugins/<service>/skills/<skill>/{scripts,tools}/`.
+ */
+
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { getCurrentPluginName } from "../plugins/plugin-execution-context.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+
+export const PLUGIN_NAME_ENV = "VELLUM_PLUGIN_NAME";
+
+const SKILL_SCRIPT_ROOTS = new Set(["scripts", "tools"]);
+
+/**
+ * Read a plugin install-directory name from the process environment.
+ * Empty or whitespace-only values are ignored.
+ */
+export function readPluginNameFromEnv(
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  const raw = env[PLUGIN_NAME_ENV];
+  if (typeof raw !== "string") {
+    return undefined;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+/**
+ * If `filePath` is a skill script or tool under an installed plugin, return
+ * that plugin's install-directory basename (the runtime service name).
+ *
+ * Expected layout:
+ * `plugins/<service>/skills/<skill-id>/scripts|tools/<file>`.
+ */
+export function derivePluginNameFromSkillScriptPath(
+  filePath: string,
+  pluginsDir: string = getWorkspacePluginsDir(),
+): string | undefined {
+  if (filePath.length === 0) {
+    return undefined;
+  }
+  let resolved = filePath;
+  if (filePath.startsWith("file:")) {
+    try {
+      resolved = fileURLToPath(filePath);
+    } catch {
+      return undefined;
+    }
+  }
+  if (!isAbsolute(resolved)) {
+    resolved = resolve(process.cwd(), resolved);
+  }
+  const pluginsRoot = resolve(pluginsDir);
+  const rel = relative(pluginsRoot, resolved);
+  if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) {
+    return undefined;
+  }
+  const parts = rel.split(sep).filter((part) => part.length > 0);
+  if (parts.length < 5) {
+    return undefined;
+  }
+  const [service, skillsSeg, skillId, root] = parts;
+  if (
+    service === undefined ||
+    skillsSeg !== "skills" ||
+    skillId === undefined ||
+    root === undefined ||
+    !SKILL_SCRIPT_ROOTS.has(root)
+  ) {
+    return undefined;
+  }
+  return service;
+}
+
+/**
+ * Scan argv for a plugin-resident skill script path, resolving relative
+ * entries against `cwd`.
+ */
+export function derivePluginNameFromProcess(
+  argv: readonly string[] = process.argv,
+  cwd: string = process.cwd(),
+  pluginsDir: string = getWorkspacePluginsDir(),
+): string | undefined {
+  for (const candidate of argv.slice(1)) {
+    if (typeof candidate !== "string" || candidate.length === 0) {
+      continue;
+    }
+    if (candidate.startsWith("-")) {
+      continue;
+    }
+    const absolute = isAbsolute(candidate)
+      ? candidate
+      : resolve(cwd, candidate);
+    const name = derivePluginNameFromSkillScriptPath(absolute, pluginsDir);
+    if (name !== undefined) {
+      return name;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Plugin identity for credential scoping: in-process AsyncLocalStorage,
+ * then the injected env var, then the process entry script path.
+ */
+export function resolveCallingPluginName(
+  env: NodeJS.ProcessEnv = process.env,
+  argv: readonly string[] = process.argv,
+  cwd: string = process.cwd(),
+  pluginsDir: string = getWorkspacePluginsDir(),
+): string | undefined {
+  return (
+    getCurrentPluginName() ??
+    readPluginNameFromEnv(env) ??
+    derivePluginNameFromProcess(argv, cwd, pluginsDir)
+  );
+}

package/src/plugin-api/resolve-credential.ts

@@ -1,28 +1,42 @@
 /**
  * Plugin-facing credential resolution.
  *
- * {@link resolveCredential} returns a stored credential's plaintext value — the
- * same value `assistant credentials reveal` prints — resolving a reference that
- * is either a credential UUID or a `"service/field"` string, exactly as the
- * reveal path does (see {@link ../tools/credentials/resolve.resolveCredentialRef}
- * and the `credentials/reveal` route).
+ * {@link resolveCredential} returns a stored credential's plaintext value
+ * (the same value `assistant credentials reveal` prints), resolving a
+ * reference that is either a credential UUID or a `"service/field"` string,
+ * exactly as the reveal path does (see
+ * {@link ../tools/credentials/resolve.resolveCredentialRef} and the
+ * `credentials/reveal` route).
  *
  * ## Plugin scoping
  *
- * When a plugin is in context (its hook, tool, or one of its own
- * `/x/plugins/<name>/` routes is executing, tracked by
- * {@link ../plugins/plugin-execution-context.getCurrentPluginName}), resolution
- * is restricted: the plugin may only resolve credentials whose `service`
- * equals its manifest name (`imessage/api_key` for plugin `imessage`). It
- * cannot read another service (`openai/api_key`, `openai/imessage`). Outside
- * any plugin context (host-internal callers, CLI, tests) the resolver is
- * unscoped and behaves like a direct reveal.
+ * When a plugin is in context, resolution is restricted to credentials
+ * whose `service` equals the plugin's runtime install-directory name
+ * (`sms/account_sid` for plugin `sms`). Context is:
+ *
+ * 1. In-process AsyncLocalStorage from `runInPluginContext` (hooks, plugin
+ *    tools, plugin routes).
+ * 2. `VELLUM_PLUGIN_NAME` on a bash or skill-sandbox child.
+ * 3. The process entry path, when it sits under
+ *    `plugins/<service>/skills/<skill>/{scripts,tools}/`.
+ *
+ * Outside any plugin context the resolver is unscoped and behaves like a
+ * direct reveal. A standalone child has an empty in-process metadata
+ * cache; when plugin context is set, a cache miss consults the live
+ * credential catalog so an empty cache is not reported as "not found".
  */
 
-import { getCurrentPluginName } from "../plugins/plugin-execution-context.js";
+import { credentialKey } from "@vellumai/credential-storage";
+
 import { getSecureKeyResultAsync } from "../security/secure-keys.js";
+import {
+  type CredentialMetadata,
+  listCredentialRecordsLive,
+} from "../tools/credentials/metadata-store.js";
+import { parseServiceFieldRef } from "../tools/credentials/ref-parse.js";
 import { resolveCredentialRef } from "../tools/credentials/resolve.js";
 import { credentialInPluginScope } from "./credential-scope.js";
+import { resolveCallingPluginName } from "./plugin-name-env.js";
 
 /**
  * Raised when a credential cannot be resolved: the reference does not match a
@@ -36,6 +50,50 @@ export class CredentialResolutionError extends Error {
   }
 }
 
+interface ResolvedRef {
+  service: string;
+  field: string;
+  storageKey: string;
+}
+
+function findLiveRecord(
+  records: CredentialMetadata[],
+  ref: string,
+): CredentialMetadata | undefined {
+  const byId = records.find((record) => record.credentialId === ref);
+  if (byId) {
+    return byId;
+  }
+  const parsed = parseServiceFieldRef(ref);
+  if (!parsed) {
+    return undefined;
+  }
+  return records.find(
+    (record) =>
+      record.service === parsed.service && record.field === parsed.field,
+  );
+}
+
+async function resolveCredentialRefLive(
+  ref: string,
+): Promise<ResolvedRef | undefined> {
+  const live = await listCredentialRecordsLive();
+  if (live.unreachable) {
+    throw new CredentialResolutionError(
+      "Credential store is unreachable.",
+    );
+  }
+  const record = findLiveRecord(live.records, ref);
+  if (!record) {
+    return undefined;
+  }
+  return {
+    service: record.service,
+    field: record.field,
+    storageKey: credentialKey(record.service, record.field),
+  };
+}
+
 /**
  * Resolve a credential reference to its plaintext value.
  *
@@ -45,15 +103,16 @@ export class CredentialResolutionError extends Error {
  *   store is unreachable, or a plugin in context is not scoped to the credential.
  */
 export async function resolveCredential(ref: string): Promise<string> {
-  const resolved = resolveCredentialRef(ref);
+  const pluginName = resolveCallingPluginName();
+
+  let resolved: ResolvedRef | undefined = resolveCredentialRef(ref);
+  if (!resolved && pluginName !== undefined) {
+    resolved = await resolveCredentialRefLive(ref);
+  }
   if (!resolved) {
     throw new CredentialResolutionError(`Credential not found: ${ref}`);
   }
 
-  // Scope the resolution to the plugin in context, if any. The ownership gate
-  // is enforced before the plaintext is read so an out-of-scope plugin never
-  // touches the secure backend.
-  const pluginName = getCurrentPluginName();
   if (
     pluginName !== undefined &&
     !credentialInPluginScope(pluginName, resolved.service)
@@ -70,7 +129,7 @@ export async function resolveCredential(ref: string): Promise<string> {
   if (value == null || value.length === 0) {
     if (unreachable) {
       throw new CredentialResolutionError(
-        "Credential store is unreachable — ensure the assistant is running",
+        "Credential store is unreachable.",
       );
     }
     throw new CredentialResolutionError(`Credential not found: ${ref}`);

package/src/plugins/__tests__/active-plugin-env.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+
+import type { SkillSummary } from "../../config/skills.js";
+import * as skills from "../../config/skills.js";
+import type { Conversation } from "../../daemon/conversation.js";
+import * as conversationRegistry from "../../daemon/conversation-registry.js";
+import { PLUGIN_NAME_ENV } from "../../plugin-api/plugin-name-env.js";
+import {
+  applyActivePluginName,
+  uniqueActivePluginOwner,
+} from "../active-plugin-env.js";
+
+function pluginSkill(id: string, pluginId: string): SkillSummary {
+  return {
+    id,
+    name: id,
+    displayName: id,
+    description: id,
+    directoryPath: `/tmp/${id}`,
+    skillFilePath: `/tmp/${id}/SKILL.md`,
+    source: "plugin",
+    owner: { kind: "plugin", id: pluginId },
+  };
+}
+
+function bundledSkill(id: string): SkillSummary {
+  return {
+    id,
+    name: id,
+    displayName: id,
+    description: id,
+    directoryPath: `/tmp/${id}`,
+    skillFilePath: `/tmp/${id}/SKILL.md`,
+    source: "bundled",
+  };
+}
+
+function conversationWithSkills(skillIds: string[]): Conversation {
+  return {
+    skillProjectionState: new Map(skillIds.map((id) => [id, "v1:hash"])),
+  } as Conversation;
+}
+
+describe("uniqueActivePluginOwner", () => {
+  let catalogSpy: ReturnType<typeof spyOn>;
+  let conversationSpy: ReturnType<typeof spyOn>;
+
+  afterEach(() => {
+    catalogSpy?.mockRestore();
+    conversationSpy?.mockRestore();
+  });
+
+  function stub(skillIds: string[], catalog: SkillSummary[]): void {
+    conversationSpy = spyOn(
+      conversationRegistry,
+      "findConversationOrSubagent",
+    ).mockReturnValue(conversationWithSkills(skillIds));
+    catalogSpy = spyOn(skills, "loadSkillCatalog").mockReturnValue(catalog);
+  }
+
+  test("returns the owner when exactly one plugin skill is active", () => {
+    stub(["sms-setup", "bash"], [
+      pluginSkill("sms-setup", "sms"),
+      bundledSkill("bash"),
+    ]);
+    expect(uniqueActivePluginOwner("conv-1")).toBe("sms");
+  });
+
+  test("returns undefined when no plugin skill is active", () => {
+    stub(["bash"], [bundledSkill("bash")]);
+    expect(uniqueActivePluginOwner("conv-1")).toBeUndefined();
+  });
+
+  test("returns undefined when two plugin owners are active", () => {
+    stub(
+      ["sms-setup", "linear-inbox"],
+      [
+        pluginSkill("sms-setup", "sms"),
+        pluginSkill("linear-inbox", "linear"),
+      ],
+    );
+    expect(uniqueActivePluginOwner("conv-1")).toBeUndefined();
+  });
+
+  test("treats two skills from the same plugin as a single owner", () => {
+    stub(
+      ["sms-setup", "sms-send"],
+      [pluginSkill("sms-setup", "sms"), pluginSkill("sms-send", "sms")],
+    );
+    expect(uniqueActivePluginOwner("conv-1")).toBe("sms");
+  });
+
+  test("returns undefined without a conversation id", () => {
+    expect(uniqueActivePluginOwner(undefined)).toBeUndefined();
+    expect(uniqueActivePluginOwner("")).toBeUndefined();
+  });
+});
+
+describe("applyActivePluginName", () => {
+  let catalogSpy: ReturnType<typeof spyOn>;
+  let conversationSpy: ReturnType<typeof spyOn>;
+
+  afterEach(() => {
+    catalogSpy?.mockRestore();
+    conversationSpy?.mockRestore();
+  });
+
+  test("sets VELLUM_PLUGIN_NAME when a unique plugin owner is active", () => {
+    conversationSpy = spyOn(
+      conversationRegistry,
+      "findConversationOrSubagent",
+    ).mockReturnValue(conversationWithSkills(["sms-setup"]));
+    catalogSpy = spyOn(skills, "loadSkillCatalog").mockReturnValue([
+      pluginSkill("sms-setup", "sms"),
+    ]);
+
+    const env: NodeJS.ProcessEnv = {};
+    applyActivePluginName(env, "conv-1");
+    expect(env[PLUGIN_NAME_ENV]).toBe("sms");
+  });
+
+  test("leaves the env unchanged when no unique plugin owner is active", () => {
+    conversationSpy = spyOn(
+      conversationRegistry,
+      "findConversationOrSubagent",
+    ).mockReturnValue(conversationWithSkills(["sms-setup", "linear-inbox"]));
+    catalogSpy = spyOn(skills, "loadSkillCatalog").mockReturnValue([
+      pluginSkill("sms-setup", "sms"),
+      pluginSkill("linear-inbox", "linear"),
+    ]);
+
+    const env: NodeJS.ProcessEnv = {};
+    applyActivePluginName(env, "conv-1");
+    expect(env[PLUGIN_NAME_ENV]).toBeUndefined();
+  });
+});