feishu-user-plugin 1.3.7 → 1.3.9

package/src/setup.js

@@ -10,9 +10,12 @@
  */
 
 const readline = require('readline');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const { findMcpConfig, writeNewConfig } = require('./config');
 
-// Parse CLI args: --app-id, --app-secret, --cookie, --client
+// Parse CLI args: --app-id, --app-secret, --cookie, --client, --force, --profile
 function parseArgs() {
   const args = {};
   const argv = process.argv.slice(2);
@@ -21,6 +24,10 @@ function parseArgs() {
     else if (argv[i] === '--app-secret' && argv[i + 1]) args.appSecret = argv[++i];
     else if (argv[i] === '--cookie' && argv[i + 1]) args.cookie = argv[++i];
     else if (argv[i] === '--client' && argv[i + 1]) args.client = argv[++i];
+    else if (argv[i] === '--pointer-only') args.pointerOnly = true; // kept for backward compat; now implicit default
+    else if (argv[i] === '--force') args.force = true;
+    else if (argv[i] === '--profile' && argv[i + 1]) args.profile = argv[++i];
+    else if (argv[i] === '--activate') args.activate = true;
   }
   return args;
 }
@@ -150,20 +157,102 @@ async function main() {
   }
   if (!client) client = 'claude';
 
-  // Write config
-  console.log('\n--- Writing Config ---');
+  // --- 4-state SSOT matrix (v1.3.9 A.3) ---
+  // Determines how credentials.json is created/updated based on current state.
+  //
+  //   State 1 (fresh):        credentials.json absent, no harness LARK_* env → create fresh
+  //   State 2 (auto-migrate): credentials.json absent, harness LARK_* env exists → migrate
+  //   State 3 (preserve):     credentials.json present, no --app-id → touch nothing in file
+  //   State 4 (update):       credentials.json present, --app-id given → update/add profile
+  const credentials = require('./auth/credentials');
+  const credsPath = path.join(os.homedir(), '.feishu-user-plugin', 'credentials.json');
+  const credsExist = !!credentials.readCanonical();
+  const targetProfile = cliArgs.profile || 'default';
+  const harnessHasLark = !!(existingEnv.LARK_APP_ID || existingEnv.LARK_COOKIE || existingEnv.LARK_USER_ACCESS_TOKEN);
+
+  let mode;
+  if (!credsExist && !harnessHasLark) mode = 'fresh';
+  else if (!credsExist && harnessHasLark) mode = 'auto-migrate';
+  else if (credsExist && !cliArgs.appId) mode = 'preserve';
+  else mode = 'update';
+  console.log(`\nSetup mode: ${mode}`);
 
-  const env = {
-    LARK_COOKIE: cookie,
-    LARK_APP_ID: appId,
-    LARK_APP_SECRET: appSecret,
-    LARK_USER_ACCESS_TOKEN: hasUAT ? existingUAT : 'SETUP_NEEDED',
-    LARK_USER_REFRESH_TOKEN: hasUAT ? (existingRT || '') : '',
-  };
+  if (mode === 'fresh' || mode === 'update') {
+    // Gather profile values — only include keys that have real values.
+    const profileValues = {};
+    if (appId) profileValues.LARK_APP_ID = appId;
+    if (appSecret) profileValues.LARK_APP_SECRET = appSecret;
+    if (cookie && cookie !== 'SETUP_NEEDED') profileValues.LARK_COOKIE = cookie;
+    else if (existingEnv.LARK_COOKIE && existingEnv.LARK_COOKIE !== 'SETUP_NEEDED') profileValues.LARK_COOKIE = existingEnv.LARK_COOKIE;
+    if (existingEnv.LARK_USER_ACCESS_TOKEN && existingEnv.LARK_USER_ACCESS_TOKEN !== 'SETUP_NEEDED') profileValues.LARK_USER_ACCESS_TOKEN = existingEnv.LARK_USER_ACCESS_TOKEN;
+    if (existingEnv.LARK_USER_REFRESH_TOKEN) profileValues.LARK_USER_REFRESH_TOKEN = existingEnv.LARK_USER_REFRESH_TOKEN;
 
-  const result = writeNewConfig(env, undefined, undefined, client);
+    if (mode === 'fresh') {
+      fs.mkdirSync(path.dirname(credsPath), { recursive: true, mode: 0o700 });
+      const data = { version: 1, active: targetProfile, profiles: { [targetProfile]: profileValues }, profileHints: {} };
+      fs.writeFileSync(credsPath, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+      console.log(`Created ${credsPath} with profile "${targetProfile}"`);
+    } else {
+      // mode === 'update'
+      const canonical = credentials.readCanonical();
+      const profileExists = !!(canonical && canonical.profiles[targetProfile]);
+      if (profileExists && targetProfile === 'default' && !cliArgs.force && !cliArgs.profile) {
+        console.error(`Profile "default" already exists. Pass --force to overwrite, or --profile <name> to create a new profile.`);
+        rl.close();
+        process.exit(1);
+      }
+      if (profileExists && cliArgs.profile && !cliArgs.force) {
+        console.error(`Profile "${targetProfile}" already exists. Pass --force to overwrite, or pick a different --profile name.`);
+        rl.close();
+        process.exit(1);
+      }
+      canonical.profiles[targetProfile] = { ...(canonical.profiles[targetProfile] || {}), ...profileValues };
+      // v1.3.9 fix: only flip credentials.json::active when --activate is given.
+      // Without --activate, adding/updating a non-active profile leaves the
+      // current active alone (least-surprise: "I added work2, default is still
+      // active, I'll switch when I want via MCP switch_profile").
+      if (cliArgs.activate || (cliArgs.force && targetProfile === canonical.active)) {
+        canonical.active = targetProfile;
+      }
+      fs.writeFileSync(credsPath, JSON.stringify(canonical, null, 2) + '\n', { mode: 0o600 });
+      console.log(`Updated profile "${targetProfile}" in ${credsPath}`);
+      if (cliArgs.activate) console.log(`  → active profile flipped to "${targetProfile}"`);
+      else if (canonical.active !== targetProfile) {
+        console.log(`  → active profile unchanged ("${canonical.active}"). Pass --activate to flip, or use switch_profile MCP tool at runtime.`);
+      }
+      if (cliArgs.force) console.warn(`  warning: overwrote existing profile credentials with --force`);
+    }
+  } else if (mode === 'auto-migrate') {
+    // Run migrate to consolidate harness env → credentials.json, then optionally
+    // override the default profile with any explicitly provided --app-id.
+    const result = credentials.migrate({ dryRun: false });
+    if (!result.ok) {
+      console.error('Auto-migrate failed; aborting setup.');
+      rl.close();
+      process.exit(1);
+    }
+    if (cliArgs.appId) {
+      credentials.persistProfileUpdate('default', { LARK_APP_ID: appId, LARK_APP_SECRET: appSecret });
+      console.log('Updated default profile with new app credentials.');
+    }
+  }
+  // mode === 'preserve': credentials.json is unchanged; we only update the harness pointer.
+
+  // --- Write harness config ---
+  // Always write pointer-only env to harness configs (v1.3.9 SSOT).
+  // The harness env block only needs FEISHU_PLUGIN_PROFILE; all real creds
+  // live in credentials.json.
+  console.log('\n--- Writing Config ---');
+  // v1.3.9 fix: harness env pointer should reflect what credentials.json::active
+  // will end up as, not blindly the targetProfile (which would mislead users
+  // who added a non-active profile via --profile alt without --activate).
+  const finalCanonical = credentials.readCanonical();
+  const harnessActive = finalCanonical?.active || targetProfile;
+  const pointerEnv = { FEISHU_PLUGIN_PROFILE: harnessActive };
+  const result = writeNewConfig(pointerEnv, undefined, undefined, client, { pointerOnly: true });
   if (result.configPath) console.log(`Written to ${result.configPath} (Claude Code)`);
   if (result.codexConfigPath) console.log(`Written to ${result.codexConfigPath} (Codex)`);
+  console.log(`Mode: pointer-only (env block contains only FEISHU_PLUGIN_PROFILE=${targetProfile})`);
 
   // Summary
   console.log('\n' + '='.repeat(60));

package/src/test-all.js

@@ -266,14 +266,6 @@ async function main() {
     // 31. create_folder (skip)
     log('create_folder', 'SKIP', 'skipped to avoid creating unnecessary folders');
 
-    // 32. find_user
-    try {
-      const res = await officialClient.findUserByIdentity({ emails: 'test@test.com' });
-      log('find_user', 'PASS', `returned ${(res.userList || []).length} users (expected 0 for test email)`);
-    } catch (e) {
-      log('find_user', 'FAIL', e.message);
-    }
-
     // ========== UAT Tests ==========
 
     if (officialClient.hasUAT) {
@@ -321,4 +313,15 @@ async function main() {
   }
 }
 
-main().catch(console.error);
+main().catch(console.error).finally(() => {
+  // Fixture-based unit test — runs regardless of credential availability
+  require('./test-read-doc-markdown').run();
+  require('./test-switch-profile').run().catch(e => {
+    console.error('switch-profile-e2e: FAIL', e);
+    process.exitCode = 1;
+  });
+  require('./test-events-lockfile').run();
+  require('./test-events-log').run();
+  require('./test-events-cursor').run();
+  require('./test-events-owner').run();
+});

package/src/test-events-cursor.js

@@ -0,0 +1,56 @@
+// src/test-events-cursor.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { ensureLog, appendEvent } = require('./events/event-log');
+const { drain, readSnapshot, resetCursorTo } = require('./events/cursor');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-cur-'));
+  const logPath = path.join(dir, 'events.jsonl');
+  ensureLog(logPath);
+
+  // No events → empty drain.
+  let r = drain(dir);
+  assert.equal(r.events.length, 0);
+
+  // Append 3 events, drain reads them.
+  appendEvent(logPath, { event_id: 'a', ts: 1, profile: 'default', payload: {} });
+  appendEvent(logPath, { event_id: 'b', ts: 2, profile: 'default', payload: {} });
+  appendEvent(logPath, { event_id: 'c', ts: 3, profile: 'default', payload: {} });
+
+  r = drain(dir);
+  assert.equal(r.events.length, 3);
+  assert.equal(r.advanced, true);
+
+  // Second drain returns nothing (cursor advanced).
+  r = drain(dir);
+  assert.equal(r.events.length, 0);
+
+  // Peek doesn't advance.
+  appendEvent(logPath, { event_id: 'd', ts: 4, profile: 'default', payload: {} });
+  r = drain(dir, { peek: true });
+  assert.equal(r.events.length, 1);
+  assert.equal(r.advanced, false);
+  // Real drain afterward still returns the same event.
+  r = drain(dir);
+  assert.equal(r.events.length, 1);
+  assert.equal(r.events[0].event_id, 'd');
+
+  // Snapshot.
+  const snap = readSnapshot(dir);
+  assert.equal(snap.pending, 0);
+  assert.ok(snap.cursor.offset > 0);
+
+  // Reset cursor to 0 → next drain returns all 4.
+  resetCursorTo(dir, 0);
+  r = drain(dir);
+  assert.equal(r.events.length, 4);
+
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('cursor.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };

package/src/test-events-lockfile.js

@@ -0,0 +1,36 @@
+// src/test-events-lockfile.js (new file; require it from src/test-all.js)
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { acquireLongLived, withMutex } = require('./events/lockfile');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-lock-'));
+  const lockPath = path.join(dir, 'test.lock');
+
+  // Long-lived: first acquire works, second returns null.
+  const handle1 = acquireLongLived(lockPath, { info: { test: 1 } });
+  assert.ok(handle1, 'first acquire should succeed');
+  const handle2 = acquireLongLived(lockPath, { info: { test: 2 } });
+  assert.equal(handle2, null, 'second acquire should fail (lock held)');
+  handle1.release();
+
+  // After release, can acquire again.
+  const handle3 = acquireLongLived(lockPath, { info: { test: 3 } });
+  assert.ok(handle3, 'third acquire after release should succeed');
+  handle3.release();
+
+  // withMutex serializes.
+  const mutexPath = path.join(dir, 'mutex.lock');
+  let counter = 0;
+  withMutex(mutexPath, () => { counter += 1; });
+  withMutex(mutexPath, () => { counter += 1; });
+  assert.equal(counter, 2);
+
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('lockfile.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };

package/src/test-events-log.js

@@ -0,0 +1,67 @@
+// src/test-events-log.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { ensureLog, appendEvent, readFrom, repairTail, maybeRotate, forceRotate } = require('./events/event-log');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-log-'));
+  const logPath = path.join(dir, 'events.jsonl');
+
+  // Append + read
+  ensureLog(logPath);
+  appendEvent(logPath, { event_id: 'a', ts: 1, profile: 'default', payload: {} });
+  appendEvent(logPath, { event_id: 'b', ts: 2, profile: 'default', payload: {} });
+
+  let r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 2);
+  assert.equal(r.events[0].event_id, 'a');
+  assert.equal(r.events[1].event_id, 'b');
+
+  // Read with offset
+  r = readFrom(logPath, r.events.length === 2 ? r.nextOffset : 0);
+  assert.equal(r.events.length, 0);
+
+  // Partial-line tolerance: append broken line
+  fs.appendFileSync(logPath, '{"event_id":"c","ts":3,"profile":"default","payload":{}}');
+  r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 2, 'partial last line should not be consumed');
+
+  // Repair tail
+  const beforeSize = fs.statSync(logPath).size;
+  const repair = repairTail(logPath);
+  assert.equal(repair.repaired, true, 'repair should run');
+  assert.ok(repair.sizeAfter < beforeSize, 'truncation occurred');
+
+  // After repair, can append normally
+  appendEvent(logPath, { event_id: 'd', ts: 4, profile: 'default', payload: {} });
+  r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 3, 'after repair + append, 3 full events');
+  assert.equal(r.events[2].event_id, 'd');
+
+  // Defer-rotate: size below threshold → no rotation
+  let rot = maybeRotate(logPath, r.nextOffset, 1024 * 1024);
+  assert.equal(rot.rotated, false);
+
+  // Defer-rotate: size above threshold + cursor caught up → rotation
+  // (we'll use a tiny threshold)
+  rot = maybeRotate(logPath, r.nextOffset, 1);
+  assert.equal(rot.rotated, true);
+  assert.ok(fs.existsSync(rot.droppedPath));
+  assert.equal(fs.statSync(logPath).size, 0, 'new log empty after rotate');
+
+  // Force rotate: even with cursor 0 (behind), drops + writes _rotated event
+  appendEvent(logPath, { event_id: 'e', ts: 5, profile: 'default', payload: {} });
+  forceRotate(logPath, fs.statSync(logPath).size);
+  r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 1);
+  assert.equal(r.events[0].event_id, '_rotated');
+  assert.equal(r.events[0].profile, '_system');
+
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('event-log.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };

package/src/test-events-owner.js

@@ -0,0 +1,64 @@
+// src/test-events-owner.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { tryClaim, readOwnerInfo, STALE_MS } = require('./events/owner');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-own-'));
+
+  // Initial claim succeeds.
+  const h1 = tryClaim(dir, { info: { wsProfile: 'default' } });
+  assert.equal(h1.isOwner, true);
+
+  // Second claim fails (lock held).
+  const h2 = tryClaim(dir);
+  assert.equal(h2.isOwner, false);
+  assert.equal(h2.ownerInfo.pid, process.pid);
+
+  // readOwnerInfo reflects state.
+  const info = readOwnerInfo(dir);
+  assert.equal(info.exists, true);
+  assert.equal(info.alive, true);
+  assert.equal(info.pid, process.pid);
+
+  // Heartbeat updates mtime.
+  const beforeMtime = info.mtimeMs;
+  // Force a slight delay then heartbeat
+  const target = Date.now();
+  while (Date.now() - target < 50) {} // small busy wait
+  const ok = h1.heartbeat();
+  assert.equal(ok, true);
+  const afterMtime = readOwnerInfo(dir).mtimeMs;
+  assert.ok(afterMtime >= beforeMtime);
+
+  h1.release();
+
+  // After release, readOwnerInfo says no owner.
+  const info2 = readOwnerInfo(dir);
+  assert.equal(info2.exists, false);
+
+  // After release, can re-claim.
+  const h3 = tryClaim(dir);
+  assert.equal(h3.isOwner, true);
+  h3.release();
+
+  // Force claim over an existing lock.
+  const h4 = tryClaim(dir, { info: { wsProfile: 'A' } });
+  const h5 = tryClaim(dir, { info: { wsProfile: 'B' }, force: true });
+  assert.equal(h5.isOwner, true);
+  // h4's heartbeat should now fail because its lock file got stolen.
+  // (Best-effort — heartbeat returns false if file isn't there to utimes.)
+  // We don't assert this strictly because the file's still around (we renamed
+  // it, didn't delete). Instead just verify h5 holds the new lock.
+  const info3 = readOwnerInfo(dir);
+  assert.equal(info3.exists, true);
+
+  h5.release();
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('owner.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };