@worca/app 1.0.0 → 1.2.0-rc.1

package/src/core/plugin-repo.mjs

@@ -10,7 +10,7 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
-import { mkdirSync, existsSync, rmSync } from 'node:fs';
+import { mkdirSync, existsSync, rmSync, unlinkSync } from 'node:fs';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
@@ -160,6 +160,9 @@ export async function addPluginRepo(repoUrl, { exec = defaultExec } = {}) {
     }
     const res = normalizeManifest(raw, { dir: subdir || '.' });
     if (!res.ok) { warnings.push(...res.errors); continue; }
+    // Degraded-but-usable manifests (e.g. a reserved model-env key stripped)
+    // stay discoverable; the notice still reaches the marketplace panel.
+    warnings.push(...res.warnings);
     if (seenNames.has(res.manifest.name)) {
       warnings.push(`${p}: duplicate plugin name "${res.manifest.name}" — first entry wins, skipped`);
       continue;
@@ -285,9 +288,15 @@ export async function exportVersion(name, sha, { exec = defaultExec, repoUrl, su
   const scratch = await mkdtemp(join(tmpdir(), 'worca-cc-export-'));
   const tarFile = join(scratch, 'export.tar');
   try {
-    await gitDir(cache, ['archive', '--format=tar', '-o', tarFile, ...(sub ? [sha, '--', sub] : [sha])], exec);
+    await gitDir(cache, ['-c', 'core.autocrlf=false', 'archive', '--format=tar', '-o', tarFile, ...(sub ? [sha, '--', sub] : [sha])], exec);
     const strip = sub ? ['--strip-components', String(sub.split('/').length)] : [];
-    await exec('tar', ['-xf', tarFile, '-C', versionDir, ...strip]);
+    // Windows GNU tar (shipped by Git for Windows) mishandles native paths two
+    // ways: a colon in the `-f` value is read as a `host:path` remote spec ("cannot
+    // connect to C:"), and backslash separators are not understood at all. So pass
+    // the archive as a RELATIVE name resolved against cwd, and give `-C` a
+    // forward-slashed path. On POSIX the replace is a no-op.
+    await exec('tar', ['-xf', 'export.tar', '-C', versionDir.replace(/\\/g, '/'), ...strip],
+      { cwd: scratch });
   } catch (err) {
     rmSync(versionDir, { recursive: true, force: true });
     throw err;
@@ -296,7 +305,10 @@ export async function exportVersion(name, sha, { exec = defaultExec, repoUrl, su
   }
   const warnings = [];
   for (const rel of findEscapingSymlinks(versionDir)) {
-    rmSync(join(versionDir, rel), { force: true });
+    // unlink, not rmSync: rmSync stats THROUGH the link, so a link to a
+    // directory throws ERR_FS_EISDIR and a dangling one (the common escaping
+    // case) reads as "already gone" and survives force:true (Node 23).
+    unlinkSync(join(versionDir, rel));
     warnings.push(`removed symlink escaping the export dir: ${rel}`);
   }
   return { versionDir, warnings };

package/src/core/plugin-shim-child.mjs

@@ -22,6 +22,10 @@ async function main() {
   const stateDelta = {};
   const ctx = {
     apiVersion: msg.apiVersion ?? 1,
+    // Which profile this op runs against. config/state are ALREADY that
+    // profile's — the id is here for connectors that keep their own storage and
+    // must key it the same way (e.g. a per-profile CLI config dir).
+    profile: typeof msg.profile === 'string' && msg.profile ? msg.profile : 'default',
     config: msg.config && typeof msg.config === 'object' ? msg.config : {},
     state: {
       get: async (k) => (k in stateDelta ? stateDelta[k] : (snapshot[k] ?? null)),
@@ -37,9 +41,11 @@ async function main() {
   const source = mod.default(ctx);
   const fn = source?.[msg.op];
   if (typeof fn !== 'function') {
-    // Optional ops (e.g. capabilities) land here; the host treats this kind +
-    // message as "op not implemented" (Task 13 defaults writeBack:true on it).
-    throw Object.assign(new Error(`connector does not implement op "${msg.op}"`), { kind: 'plugin' });
+    // Optional ops (e.g. capabilities) land here. The kind is 'unimplemented',
+    // NOT 'plugin': an op the connector lacks and an implemented op that
+    // CRASHED must stay distinguishable — the capabilities probe defaults
+    // writeBack:true only for the former (Task 13 / sources.mjs).
+    throw Object.assign(new Error(`connector does not implement op "${msg.op}"`), { kind: 'unimplemented' });
   }
 
   // §7.1 signatures: getTask(id) and reportResult(id, r) are positional; every

package/src/core/plugin-shim.mjs

@@ -16,19 +16,23 @@ import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { envFlag } from './model-env.mjs';
 import { WORCA_PLUGIN_API } from './plugin-api.mjs';
 import { normalizeManifest, negotiatedApi } from './plugin-manifest.mjs';
 import { readPluginsLock, pluginCurrentDir } from './plugins-lock.mjs';
-import { readPluginConfig, readPluginState, writePluginState } from './plugin-config.mjs';
+import { readPluginConfig, readPluginState, writePluginState, listProfileIds, DEFAULT_PROFILE } from './plugin-config.mjs';
 
 const CHILD_PATH = fileURLToPath(new URL('./plugin-shim-child.mjs', import.meta.url));
 
-/** Error kinds an op can surface (spec §11); anything else normalizes to 'plugin'. */
-const KINDS = new Set(['auth', 'rate-limit', 'network', 'plugin', 'timeout', 'protocol']);
+/** Error kinds an op can surface (spec §11) plus the host-synthesized
+ *  'unimplemented' (the connector lacks the op — distinct from an implemented
+ *  op that CRASHED, because callers like the capabilities probe must default
+ *  differently for the two); anything else normalizes to 'plugin'. */
+const KINDS = new Set(['auth', 'rate-limit', 'network', 'plugin', 'timeout', 'protocol', 'unimplemented']);
 
 export class PluginOpError extends Error {
   /**
-   * @param {'auth'|'rate-limit'|'network'|'plugin'|'timeout'|'protocol'} kind
+   * @param {'auth'|'rate-limit'|'network'|'plugin'|'timeout'|'protocol'|'unimplemented'} kind
    * @param {string} message
    */
   constructor(kind, message) {
@@ -63,10 +67,9 @@ const MOCK_DEFAULTS = {
   validateConfig: () => ({ ok: true }),
 };
 
-/** Same env-flag semantics as claude-runner.mjs#mockEnabled (claude-runner.mjs:100-104). */
+/** Same env-flag semantics as claude-runner.mjs#mockEnabled — one shared rule. */
 function mockMode() {
-  const v = process.env.WORCA_MOCK ?? process.env.ORCH_MOCK;
-  return !!v && v !== '0' && v.toLowerCase() !== 'false';
+  return envFlag('WORCA_MOCK', 'ORCH_MOCK');
 }
 
 async function mockCall(op, args) {
@@ -74,7 +77,7 @@ async function mockCall(op, args) {
   if (entry === undefined) {
     // Mirror the real child's answer for an unimplemented op — Task 13's
     // capabilities tolerant-default keys on exactly this kind.
-    throw new PluginOpError('plugin', `mock: no canned response for op "${op}"`);
+    throw new PluginOpError('unimplemented', `mock: no canned response for op "${op}"`);
   }
   try {
     return await (typeof entry === 'function' ? entry(args) : entry);
@@ -112,40 +115,100 @@ function loadSource(plugin, sourceId) {
 /** Child env: PATH + HOME ONLY (spec §7.2). Notably NOT WORCA_*, tokens, npm_*.
  *  Exported for the channel-worker supervisor (chat/channel-host.mjs), which
  *  spawns persistent children under the same rule. */
-export function scrubbedEnv() {
+export function scrubbedEnv(platform = process.platform) {
   const env = {};
   if (process.env.PATH) env.PATH = process.env.PATH;
   if (process.env.HOME) env.HOME = process.env.HOME;
+  // Windows has no HOME and a child cannot even start without SYSTEMROOT (Node
+  // docs); the rest are the non-secret system vars node/npm need to resolve
+  // temp dirs, the shell, and the .cmd/.exe lookup. Still no WORCA_*, tokens
+  // or npm_* — the §7.2 rule is unchanged, only the platform baseline differs.
+  if (platform === 'win32') {
+    for (const k of WIN32_ENV_BASELINE) if (process.env[k]) env[k] = process.env[k];
+  }
   return env;
 }
 
+/** Non-secret Windows system vars a child needs to run at all (spec §7.2 note). */
+export const WIN32_ENV_BASELINE = Object.freeze([
+  'USERPROFILE', 'SYSTEMROOT', 'SYSTEMDRIVE', 'COMSPEC', 'PATHEXT', 'TEMP', 'TMP', 'APPDATA', 'LOCALAPPDATA',
+]);
+
+/** The profile invariant, enforced in the shim itself so EVERY caller — the
+ *  CLI's `worca plugin exec`, future workers — is safe by construction, not
+ *  just the HTTP routes. Presence alone is not enough: a typo'd or deleted
+ *  profile passes a presence check, silently runs against an EMPTY bucket
+ *  (false "not configured" verdicts) and then persists state into a phantom
+ *  bucket the DELETE route can never purge — so membership in the roster is
+ *  checked here too. `allowLegacyDefault` is the ONE host-internal exception:
+ *  write-back for a pipeline row that predates profiles targets the
+ *  DEFAULT_PROFILE bucket, because that is where the pre-upgrade flat config
+ *  migrated — i.e. the instance the task actually came from (sources.mjs). */
+function assertProfileInvariant({ plugin, sourceId, source, profile, allowLegacyDefault }) {
+  if (source.multiProfile === true) {
+    if (!profile) {
+      throw new PluginOpError('plugin',
+        `task source "${plugin}/${sourceId}" has per-profile configuration — pass a profile (e.g. --profile <id>)`);
+    }
+    if (profile === DEFAULT_PROFILE) {
+      if (!allowLegacyDefault) {
+        throw new PluginOpError('plugin',
+          `"${DEFAULT_PROFILE}" is the reserved shared bucket, not a profile of "${plugin}/${sourceId}" — pass a profile from the roster`);
+      }
+    } else if (!listProfileIds(plugin).includes(profile)) {
+      throw new PluginOpError('plugin',
+        `plugin "${plugin}" has no profile "${profile}" — create it in Plugins settings (or POST /api/plugins/${plugin}/profiles) first`);
+    }
+  } else if (profile && profile !== DEFAULT_PROFILE) {
+    throw new PluginOpError('plugin', `task source "${plugin}/${sourceId}" does not use profiles`);
+  }
+}
+
 /**
  * Run ONE connector op in an ephemeral child. Resolves with the op result;
  * rejects with PluginOpError. `logger(level, msg)` is optional — connector
  * ctx.log lines route there (default: console.error, since stdout is the UI's).
+ * `allowLegacyDefault` (host-internal, never surfaced to CLI/routes) lets the
+ * legacy write-back path name DEFAULT_PROFILE on a multiProfile source — see
+ * assertProfileInvariant.
  * @returns {Promise<any>}
  */
-export async function callSource({ plugin, sourceId, op, args = {}, timeoutMs = 30000, logger } = {}) {
+export async function callSource({ plugin, sourceId, op, args = {}, profile, timeoutMs = 30000, logger, allowLegacyDefault = false } = {}) {
   const log = typeof logger === 'function'
     ? logger
     : (level, msg) => console.error(`[plugin:${plugin}] ${level}: ${msg}`);
+  // Which configuration of the source to run against (plugin-config.mjs
+  // profiles). Absent -> DEFAULT_PROFILE, which is what every single-profile
+  // source uses, so this parameter is invisible unless a plugin opts in.
+  const prof = profile || DEFAULT_PROFILE;
 
   if (mockMode()) {
-    // Canned responses, no spawn, no plugin needed. reportResult additionally
-    // records its args into the plugin state — mirroring the real-child
-    // stateDelta path — so the offline smoke (Task 19) can assert write-back ran.
+    // Canned responses, no spawn, no plugin needed. The profile invariant still
+    // holds whenever the plugin IS installed (behavioral parity so mock runs
+    // catch missing/typo'd profiles too); an uninstalled plugin — the offline
+    // smoke's whole point — skips it. reportResult additionally records its
+    // args into the plugin state — mirroring the real-child stateDelta path —
+    // so the offline smoke (Task 19) can assert write-back ran.
+    let mockSource = null;
+    try { mockSource = loadSource(plugin, sourceId).source; } catch { mockSource = null; }
+    if (mockSource) assertProfileInvariant({ plugin, sourceId, source: mockSource, profile, allowLegacyDefault });
     const r = await mockCall(op, args);
-    if (op === 'reportResult') writePluginState(plugin, { lastReport: JSON.stringify(args) });
+    if (op === 'reportResult') writePluginState(plugin, { lastReport: JSON.stringify(args) }, prof);
     return r;
   }
 
   const { dir, source, apiVersion } = loadSource(plugin, sourceId);
+  assertProfileInvariant({ plugin, sourceId, source, profile, allowLegacyDefault });
   const payload = JSON.stringify({
     apiVersion,
     module: resolve(dir, source.module), // './'-relative, '..'-free (normalizeManifest)
     op,
-    config: readPluginConfig(plugin, source.configSchema),
-    state: readPluginState(plugin),
+    // The connector sees ONE profile's config/state and is told which — a
+    // connector that keeps its own storage (jira-source hangs a $JTR_CONFIG_DIR
+    // off it) needs the id, not just the values.
+    profile: prof,
+    config: readPluginConfig(plugin, source.configSchema, prof),
+    state: readPluginState(plugin, prof),
     args,
   });
 
@@ -191,7 +254,7 @@ export async function callSource({ plugin, sourceId, op, args = {}, timeoutMs =
     throw new PluginOpError(frame.error?.kind || 'plugin', frame.error?.message || `plugin "${plugin}" op "${op}" failed`);
   }
   if (frame.stateDelta && typeof frame.stateDelta === 'object' && Object.keys(frame.stateDelta).length) {
-    writePluginState(plugin, frame.stateDelta); // host-side persist; child never touches the store
+    writePluginState(plugin, frame.stateDelta, prof); // host-side persist; child never touches the store
   }
   return frame.result;
 }