@bretwardjames/tw-bridge 0.4.0 → 0.6.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs3 from "fs";
-import path4 from "path";
-import os3 from "os";
+import fs5 from "fs";
+import path6 from "path";
+import os5 from "os";
 
 // src/config.ts
 import fs from "fs";
@@ -241,8 +241,8 @@ async function oauthLogin(clientId, clientSecret, rl) {
   saveTokens(tokens);
   return tokens;
 }
-async function asanaFetch(path5, token, options = {}) {
-  const url = `${API_BASE}${path5}`;
+async function asanaFetch(path7, token, options = {}) {
+  const url = `${API_BASE}${path7}`;
   const res = await fetch(url, {
     ...options,
     headers: {
@@ -258,9 +258,9 @@ async function asanaFetch(path5, token, options = {}) {
   const json = await res.json();
   return json.data;
 }
-async function asanaFetchAll(path5, token) {
+async function asanaFetchAll(path7, token) {
   const results = [];
-  let nextPage = path5;
+  let nextPage = path7;
   while (nextPage) {
     const url = `${API_BASE}${nextPage}`;
     const res = await fetch(url, {
@@ -572,10 +572,319 @@ function mapAsanaPriority(fields) {
   return void 0;
 }
 
+// src/adapters/strety.ts
+import fs3 from "fs";
+import path4 from "path";
+import os3 from "os";
+import { execSync as execSync2 } from "child_process";
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+var API_BASE2 = "https://2.strety.com/api/v1";
+var OAUTH_AUTHORIZE2 = `${API_BASE2}/oauth/authorize`;
+var OAUTH_TOKEN2 = `${API_BASE2}/oauth/token`;
+var TOKEN_FILE2 = path4.join(os3.homedir(), ".config", "tw-bridge", "strety-tokens.json");
+function loadTokens2() {
+  try {
+    return JSON.parse(fs3.readFileSync(TOKEN_FILE2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveTokens2(tokens) {
+  fs3.mkdirSync(path4.dirname(TOKEN_FILE2), { recursive: true });
+  fs3.writeFileSync(TOKEN_FILE2, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function refreshAccessToken2(tokens) {
+  const now = Date.now();
+  if (tokens.access_token && tokens.expires_at > now + 3e5) {
+    return tokens.access_token;
+  }
+  const res = await fetch(OAUTH_TOKEN2, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: tokens.refresh_token,
+      client_id: tokens.client_id,
+      client_secret: tokens.client_secret
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Token refresh failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  tokens.access_token = data.access_token;
+  if (data.refresh_token) {
+    tokens.refresh_token = data.refresh_token;
+  }
+  tokens.expires_at = now + (data.expires_in ?? 7200) * 1e3;
+  saveTokens2(tokens);
+  return tokens.access_token;
+}
+var REDIRECT_URI = "https://localhost/callback";
+async function oauthLogin2(clientId, clientSecret, rl) {
+  const authUrl = `${OAUTH_AUTHORIZE2}?response_type=code&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&scope=${encodeURIComponent("read write")}`;
+  console.log(`
+  Opening browser for authorization...`);
+  console.log(`  If it doesn't open, visit:
+  ${authUrl}
+`);
+  try {
+    execSync2(`xdg-open "${authUrl}" 2>/dev/null || open "${authUrl}" 2>/dev/null`, {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  console.log("  After authorizing, the browser will redirect to a page that");
+  console.log("  won't load. Copy the full URL from the address bar and paste it here.\n");
+  const pasted = (await rl.question("Paste the callback URL: ")).trim();
+  let code;
+  try {
+    const url = new URL(pasted);
+    const error = url.searchParams.get("error");
+    if (error) {
+      throw new Error(`OAuth error: ${error}`);
+    }
+    const authCode = url.searchParams.get("code");
+    if (!authCode) {
+      throw new Error("No authorization code found in URL");
+    }
+    code = authCode;
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("OAuth error:")) throw err;
+    if (err instanceof Error && err.message.startsWith("No authorization")) throw err;
+    throw new Error(`Could not parse callback URL: ${pasted}`);
+  }
+  const tokenRes = await fetch(OAUTH_TOKEN2, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: REDIRECT_URI,
+      client_id: clientId,
+      client_secret: clientSecret
+    })
+  });
+  if (!tokenRes.ok) {
+    const body = await tokenRes.text();
+    throw new Error(`Token exchange failed (${tokenRes.status}): ${body}`);
+  }
+  const data = await tokenRes.json();
+  const tokens = {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Date.now() + (data.expires_in ?? 7200) * 1e3,
+    client_id: clientId,
+    client_secret: clientSecret
+  };
+  saveTokens2(tokens);
+  return tokens;
+}
+async function stretyFetch(urlOrPath, token, options = {}) {
+  const url = urlOrPath.startsWith("http") ? urlOrPath : `${API_BASE2}${urlOrPath}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.api+json",
+      "Content-Type": "application/vnd.api+json",
+      ...options.headers
+    }
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Strety API ${res.status}: ${body}`);
+  }
+  return res.json();
+}
+async function stretyFetchAll(path7, token) {
+  const results = [];
+  let url = `${API_BASE2}${path7}`;
+  while (url) {
+    const json = await stretyFetch(url, token);
+    results.push(...json.data);
+    url = json.links?.next ?? null;
+  }
+  return results;
+}
+async function pickOne2(rl, label, items) {
+  console.log(`
+${label}:`);
+  for (let i = 0; i < items.length; i++) {
+    const name = items[i].attributes.name ?? items[i].attributes.title ?? items[i].id;
+    console.log(`  ${i + 1}) ${name}`);
+  }
+  while (true) {
+    const answer = await rl.question(`Choose (1-${items.length}): `);
+    const idx = parseInt(answer, 10) - 1;
+    if (idx >= 0 && idx < items.length) {
+      const item = items[idx];
+      return { id: item.id, name: item.attributes.name ?? item.attributes.title ?? item.id };
+    }
+    console.log("  Invalid choice, try again.");
+  }
+}
+var StretyAdapter = class {
+  name = "strety";
+  config;
+  accessToken = null;
+  async resolveToken() {
+    const auth = this.config.auth;
+    if (auth === "oauth") {
+      const tokens = loadTokens2();
+      if (!tokens) throw new Error("No OAuth tokens found. Run `tw-bridge add` to authenticate.");
+      this.accessToken = await refreshAccessToken2(tokens);
+      return this.accessToken;
+    }
+    if (this.accessToken) return this.accessToken;
+    if (auth.startsWith("env:")) {
+      const envVar = auth.slice(4);
+      const val = process.env[envVar];
+      if (!val) throw new Error(`Environment variable ${envVar} not set`);
+      this.accessToken = val;
+      return val;
+    }
+    this.accessToken = auth;
+    return auth;
+  }
+  defaultConfig(_cwd) {
+    return {
+      auth: "env:STRETY_TOKEN",
+      assignee_id: "",
+      assignee_name: ""
+    };
+  }
+  async setup(_cwd) {
+    const rl = createInterface2({ input: stdin2, output: stdout2 });
+    try {
+      console.log("\n\u2500\u2500 Strety Adapter Setup \u2500\u2500\n");
+      console.log("Authentication:");
+      console.log("  1) OAuth (browser login)");
+      console.log("  2) Environment variable");
+      const authChoice = (await rl.question("\nChoose (1-2): ")).trim();
+      let authConfig;
+      let token;
+      if (authChoice === "1") {
+        console.log(`
+  Register a Strety app at My Integrations > My Apps.`);
+        console.log(`  Set the Redirect URI to: ${REDIRECT_URI}
+`);
+        const clientId = (await rl.question("Strety App Client ID: ")).trim();
+        const clientSecret = (await rl.question("Strety App Client Secret: ")).trim();
+        if (!clientId || !clientSecret) {
+          console.error("\n  Client ID and Secret are required.");
+          rl.close();
+          process.exit(1);
+        }
+        const tokens = await oauthLogin2(clientId, clientSecret, rl);
+        token = tokens.access_token;
+        authConfig = "oauth";
+      } else {
+        const envVar = await rl.question("Environment variable name [STRETY_TOKEN]: ");
+        const varName = envVar.trim() || "STRETY_TOKEN";
+        authConfig = `env:${varName}`;
+        token = process.env[varName] ?? "";
+        if (!token) {
+          console.error(`
+  Cannot complete setup without a valid token.`);
+          console.error(`  Set ${varName} in your environment and try again.`);
+          rl.close();
+          process.exit(1);
+        }
+      }
+      console.log("\nVerifying...");
+      let people;
+      try {
+        people = await stretyFetchAll("/people?page[size]=20", token);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  Authentication failed: ${msg}`);
+        rl.close();
+        process.exit(1);
+      }
+      console.log(`  Connected! Found ${people.length} people.`);
+      const person = await pickOne2(rl, "Which person are you? (for filtering your todos)", people);
+      rl.close();
+      console.log(`
+  Assignee: ${person.name}`);
+      console.log("  Syncing: Todos assigned to you");
+      return {
+        auth: authConfig,
+        assignee_id: person.id,
+        assignee_name: person.name
+      };
+    } catch (err) {
+      rl.close();
+      throw err;
+    }
+  }
+  async init(config) {
+    this.config = config;
+    if (!this.config.assignee_id) {
+      throw new Error('strety adapter requires "assignee_id" in config');
+    }
+  }
+  async pull() {
+    const token = await this.resolveToken();
+    const raw = await stretyFetchAll(
+      `/todos?filter[assignee_id]=${this.config.assignee_id}&page[size]=20`,
+      token
+    );
+    const tasks = [];
+    for (const item of raw) {
+      const attrs = item.attributes;
+      if (attrs.completed_at) continue;
+      const priority = mapStretyPriority(attrs.priority);
+      const task = {
+        uuid: "",
+        description: attrs.title,
+        status: "pending",
+        entry: attrs.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+        tags: [],
+        priority,
+        backend: "",
+        backend_id: item.id,
+        ...attrs.due_date && { due: new Date(attrs.due_date).toISOString() }
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+  async onDone(task) {
+    const todoId = task.backend_id;
+    if (!todoId) return;
+    const token = await this.resolveToken();
+    process.stderr.write(`tw-bridge [strety]: marking todo complete
+`);
+    await stretyFetch(`/todos/${todoId}`, token, {
+      method: "PATCH",
+      headers: { "If-Match": "*" },
+      body: JSON.stringify({
+        data: {
+          type: "todo",
+          attributes: {
+            completed_at: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      })
+    });
+  }
+};
+function mapStretyPriority(priority) {
+  if (!priority || priority === "none") return void 0;
+  if (priority === "highest" || priority === "high") return "H";
+  if (priority === "medium") return "M";
+  if (priority === "low" || priority === "lowest") return "L";
+  return void 0;
+}
+
 // src/registry.ts
 var BUILTIN_ADAPTERS = {
   ghp: () => new GhpAdapter(),
-  asana: () => new AsanaAdapter()
+  asana: () => new AsanaAdapter(),
+  strety: () => new StretyAdapter()
 };
 function matchBackend(task, config) {
   if (task.backend && config.backends[task.backend]) {
@@ -707,12 +1016,65 @@ function updateTaskDescription(existing, newDescription) {
   return result.status === 0;
 }
 
+// src/tracking.ts
+import fs4 from "fs";
+import path5 from "path";
+import os4 from "os";
+import { spawnSync as spawnSync3 } from "child_process";
+var TRACKING_FILE = path5.join(os4.homedir(), ".config", "tw-bridge", "tracking.json");
+function loadTracking() {
+  try {
+    return JSON.parse(fs4.readFileSync(TRACKING_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveTracking(state) {
+  fs4.mkdirSync(path5.dirname(TRACKING_FILE), { recursive: true });
+  fs4.writeFileSync(TRACKING_FILE, JSON.stringify(state));
+}
+function mergedTags(state) {
+  const all = /* @__PURE__ */ new Set();
+  for (const tags of Object.values(state)) {
+    for (const tag of tags) all.add(tag);
+  }
+  return [...all];
+}
+function startParallel(key, tags) {
+  const tracking = loadTracking();
+  tracking[key] = tags;
+  saveTracking(tracking);
+  const merged = mergedTags(tracking);
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["start", ...merged], { stdio: "pipe" });
+}
+function startSwitch(key, tags) {
+  saveTracking({ [key]: tags });
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["start", ...tags], { stdio: "pipe" });
+}
+function stopEntry(key) {
+  const tracking = loadTracking();
+  delete tracking[key];
+  saveTracking(tracking);
+  const remaining = mergedTags(tracking);
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  if (remaining.length > 0) {
+    spawnSync3("timew", ["start", ...remaining], { stdio: "pipe" });
+  }
+}
+function getActiveMeetings() {
+  const tracking = loadTracking();
+  return Object.entries(tracking).filter(([key]) => key.startsWith("meeting:")).map(([key, tags]) => ({ key, tags }));
+}
+
 // src/cli.ts
-var HOOKS_DIR = path4.join(os3.homedir(), ".task", "hooks");
+var HOOKS_DIR = path6.join(os5.homedir(), ".task", "hooks");
 var commands = {
   add: addBackend,
   install,
   sync,
+  meeting: meetingCmd,
   timewarrior: timewarriorCmd,
   which,
   config: showConfig
@@ -722,9 +1084,10 @@ async function main() {
   if (!command || command === "--help") {
     console.log("Usage: tw-bridge <command>\n");
     console.log("Commands:");
-    console.log("  add       Add a new backend instance");
-    console.log("  install   Install Taskwarrior hooks and shell integration");
+    console.log("  add         Add a new backend instance");
+    console.log("  install     Install Taskwarrior hooks and shell integration");
     console.log("  sync        Pull tasks from all backends");
+    console.log("  meeting     Track meetings in Timewarrior (no task created)");
     console.log("  timewarrior Manage Timewarrior integration");
     console.log("  which       Print the context for the current directory");
     console.log("  config      Show current configuration");
@@ -800,18 +1163,18 @@ Added backend "${name}" (adapter: ${adapterType})`);
 Use 'task context ${matchTag}' to switch to this project.`);
 }
 async function install() {
-  fs3.mkdirSync(HOOKS_DIR, { recursive: true });
-  const hookSource = path4.resolve(
-    path4.dirname(new URL(import.meta.url).pathname),
+  fs5.mkdirSync(HOOKS_DIR, { recursive: true });
+  const hookSource = path6.resolve(
+    path6.dirname(new URL(import.meta.url).pathname),
     "hooks",
     "on-modify.js"
   );
-  const hookTarget = path4.join(HOOKS_DIR, "on-modify.tw-bridge");
-  if (fs3.existsSync(hookTarget)) {
-    fs3.unlinkSync(hookTarget);
+  const hookTarget = path6.join(HOOKS_DIR, "on-modify.tw-bridge");
+  if (fs5.existsSync(hookTarget)) {
+    fs5.unlinkSync(hookTarget);
   }
-  fs3.symlinkSync(hookSource, hookTarget);
-  fs3.chmodSync(hookSource, 493);
+  fs5.symlinkSync(hookSource, hookTarget);
+  fs5.chmodSync(hookSource, 493);
   console.log(`Installed hook: ${hookTarget} -> ${hookSource}`);
   console.log("\nAdd these to your .taskrc:\n");
   console.log("# --- tw-bridge UDAs ---");
@@ -828,31 +1191,133 @@ async function install() {
   console.log("urgency.user.tag.ready_for_beta.coefficient=-4.0");
   console.log("urgency.user.tag.in_beta.coefficient=-6.0");
   installTimewExtension();
-  if (fs3.existsSync(STANDARD_TIMEW_HOOK)) {
+  if (fs5.existsSync(STANDARD_TIMEW_HOOK)) {
     console.log("\nTimewarrior hook detected. To enable tw-bridge time tracking:");
     console.log("  tw-bridge timewarrior enable");
   }
   installShellFunction();
 }
-var TIMEW_EXT_DIR = path4.join(os3.homedir(), ".timewarrior", "extensions");
+var TIMEW_EXT_DIR = path6.join(os5.homedir(), ".timewarrior", "extensions");
 function installTimewExtension() {
-  fs3.mkdirSync(TIMEW_EXT_DIR, { recursive: true });
-  const extSource = path4.resolve(
-    path4.dirname(new URL(import.meta.url).pathname),
+  fs5.mkdirSync(TIMEW_EXT_DIR, { recursive: true });
+  const extSource = path6.resolve(
+    path6.dirname(new URL(import.meta.url).pathname),
     "extensions",
     "bridge.js"
   );
-  const extTarget = path4.join(TIMEW_EXT_DIR, "bridge");
-  if (fs3.existsSync(extTarget)) {
-    fs3.unlinkSync(extTarget);
+  const extTarget = path6.join(TIMEW_EXT_DIR, "bridge");
+  if (fs5.existsSync(extTarget)) {
+    fs5.unlinkSync(extTarget);
   }
-  fs3.symlinkSync(extSource, extTarget);
-  fs3.chmodSync(extSource, 493);
+  fs5.symlinkSync(extSource, extTarget);
+  fs5.chmodSync(extSource, 493);
   console.log(`
 Installed Timewarrior extension: ${extTarget} -> ${extSource}`);
   console.log("  Usage: timew bridge [task-time|wall-time] [project-filter]");
 }
-var STANDARD_TIMEW_HOOK = path4.join(HOOKS_DIR, "on-modify.timewarrior");
+function sanitizeMeetingName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function detectProjectContext() {
+  const cwd = process.cwd();
+  const config = loadConfig();
+  for (const [, backend] of Object.entries(config.backends)) {
+    const backendCwd = backend.config?.cwd;
+    if (!backendCwd) continue;
+    const resolved = path6.resolve(backendCwd);
+    if (cwd === resolved || cwd.startsWith(resolved + path6.sep)) {
+      return backend.match.tags?.[0] ?? null;
+    }
+  }
+  return null;
+}
+async function meetingCmd() {
+  const sub = process.argv[3];
+  if (!sub || sub === "--help") {
+    console.log("Usage: tw-bridge meeting <subcommand>\n");
+    console.log("Subcommands:");
+    console.log("  start <name> [--switch]  Start tracking a meeting");
+    console.log("  stop [name]              Stop a meeting (or all if no name)");
+    console.log("  list                     Show active meetings");
+    console.log("\nMeetings are tracked in Timewarrior only \u2014 no Taskwarrior task is created.");
+    console.log("By default, meetings run in parallel with active tasks.");
+    console.log("Use --switch to pause the current task instead.");
+    return;
+  }
+  const config = loadConfig();
+  if (!config.timewarrior?.enabled) {
+    console.error("Timewarrior is not enabled. Run: tw-bridge timewarrior enable");
+    process.exit(1);
+  }
+  if (sub === "start") {
+    const nameArg = process.argv.slice(4).filter((a) => !a.startsWith("--")).join(" ");
+    if (!nameArg) {
+      console.error("Usage: tw-bridge meeting start <name>");
+      process.exit(1);
+    }
+    const switchMode = process.argv.includes("--switch") || process.argv.includes("-s");
+    const tag = sanitizeMeetingName(nameArg);
+    const key = `meeting:${tag}`;
+    const tags = ["meeting", tag];
+    const project = detectProjectContext();
+    if (project) tags.push(project);
+    if (switchMode) {
+      startSwitch(key, tags);
+    } else {
+      startParallel(key, tags);
+    }
+    console.log(`Meeting started: ${nameArg}`);
+    console.log(`  Tags: ${tags.join(" ")}`);
+    if (!switchMode) {
+      console.log("  Mode: parallel (active tasks continue tracking)");
+    } else {
+      console.log("  Mode: switch (active tasks paused)");
+    }
+    return;
+  }
+  if (sub === "stop") {
+    const nameArg = process.argv.slice(4).join(" ").trim();
+    const active = getActiveMeetings();
+    if (active.length === 0) {
+      console.log("No active meetings.");
+      return;
+    }
+    if (nameArg) {
+      const tag = sanitizeMeetingName(nameArg);
+      const key = `meeting:${tag}`;
+      const match = active.find((m) => m.key === key);
+      if (!match) {
+        console.error(`No active meeting matching "${nameArg}".`);
+        console.error(`Active meetings: ${active.map((m) => m.key.replace("meeting:", "")).join(", ")}`);
+        process.exit(1);
+      }
+      stopEntry(key);
+      console.log(`Meeting stopped: ${nameArg}`);
+    } else {
+      for (const m of active) {
+        stopEntry(m.key);
+      }
+      console.log(`Stopped ${active.length} meeting(s): ${active.map((m) => m.key.replace("meeting:", "")).join(", ")}`);
+    }
+    return;
+  }
+  if (sub === "list") {
+    const active = getActiveMeetings();
+    if (active.length === 0) {
+      console.log("No active meetings.");
+      return;
+    }
+    console.log("Active meetings:");
+    for (const m of active) {
+      const name = m.key.replace("meeting:", "");
+      console.log(`  ${name}  (${m.tags.join(" ")})`);
+    }
+    return;
+  }
+  console.error(`Unknown subcommand: ${sub}`);
+  process.exit(1);
+}
+var STANDARD_TIMEW_HOOK = path6.join(HOOKS_DIR, "on-modify.timewarrior");
 async function timewarriorCmd() {
   const sub = process.argv[3];
   if (!sub || sub === "--help") {
@@ -875,8 +1340,8 @@ async function timewarriorCmd() {
       console.log("Timewarrior: enabled");
       console.log("  Parallel tracking: use `task start <id> --parallel`");
     }
-    const hookExists = fs3.existsSync(STANDARD_TIMEW_HOOK);
-    const hookDisabled = fs3.existsSync(STANDARD_TIMEW_HOOK + ".disabled");
+    const hookExists = fs5.existsSync(STANDARD_TIMEW_HOOK);
+    const hookDisabled = fs5.existsSync(STANDARD_TIMEW_HOOK + ".disabled");
     if (hookExists) {
       console.log(`Standard hook: active (${STANDARD_TIMEW_HOOK})`);
       if (tw?.enabled) {
@@ -894,9 +1359,9 @@ async function timewarriorCmd() {
     const configPath = saveConfig(config);
     console.log("Timewarrior tracking enabled");
     console.log(`Config: ${configPath}`);
-    if (fs3.existsSync(STANDARD_TIMEW_HOOK)) {
+    if (fs5.existsSync(STANDARD_TIMEW_HOOK)) {
       const disabled = STANDARD_TIMEW_HOOK + ".disabled";
-      fs3.renameSync(STANDARD_TIMEW_HOOK, disabled);
+      fs5.renameSync(STANDARD_TIMEW_HOOK, disabled);
       console.log(`
 Disabled standard hook: ${STANDARD_TIMEW_HOOK} -> .disabled`);
       console.log("tw-bridge will handle Timewarrior tracking directly.");
@@ -909,8 +1374,8 @@ Disabled standard hook: ${STANDARD_TIMEW_HOOK} -> .disabled`);
     console.log("Timewarrior tracking disabled");
     console.log(`Config: ${configPath}`);
     const disabled = STANDARD_TIMEW_HOOK + ".disabled";
-    if (fs3.existsSync(disabled)) {
-      fs3.renameSync(disabled, STANDARD_TIMEW_HOOK);
+    if (fs5.existsSync(disabled)) {
+      fs5.renameSync(disabled, STANDARD_TIMEW_HOOK);
       console.log(`
 Restored standard hook: ${STANDARD_TIMEW_HOOK}`);
     }
@@ -940,28 +1405,28 @@ task() {
 var SHELL_MARKER = "# tw-bridge: auto-context task wrapper";
 function installShellFunction() {
   const shell = process.env.SHELL ?? "/bin/bash";
-  const home = os3.homedir();
+  const home = os5.homedir();
   let rcFile;
   if (shell.endsWith("zsh")) {
-    rcFile = path4.join(home, ".zshrc");
+    rcFile = path6.join(home, ".zshrc");
   } else {
-    rcFile = path4.join(home, ".bashrc");
+    rcFile = path6.join(home, ".bashrc");
   }
-  const existing = fs3.existsSync(rcFile) ? fs3.readFileSync(rcFile, "utf-8") : "";
+  const existing = fs5.existsSync(rcFile) ? fs5.readFileSync(rcFile, "utf-8") : "";
   if (existing.includes(SHELL_MARKER)) {
     console.log(`
 Shell integration already installed in ${rcFile}`);
     return;
   }
-  fs3.appendFileSync(rcFile, "\n" + SHELL_FUNCTION + "\n");
+  fs5.appendFileSync(rcFile, "\n" + SHELL_FUNCTION + "\n");
   console.log(`
 Shell integration installed in ${rcFile}`);
   console.log("Restart your shell or run: source " + rcFile);
 }
-var SEEN_FILE = path4.join(os3.homedir(), ".config", "tw-bridge", ".seen-dirs");
+var SEEN_FILE = path6.join(os5.homedir(), ".config", "tw-bridge", ".seen-dirs");
 function loadSeenDirs() {
   try {
-    const raw = fs3.readFileSync(SEEN_FILE, "utf-8");
+    const raw = fs5.readFileSync(SEEN_FILE, "utf-8");
     return new Set(raw.split("\n").filter(Boolean));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -971,15 +1436,15 @@ function markDirSeen(dir) {
   const seen = loadSeenDirs();
   if (seen.has(dir)) return;
   seen.add(dir);
-  fs3.mkdirSync(path4.dirname(SEEN_FILE), { recursive: true });
-  fs3.writeFileSync(SEEN_FILE, [...seen].join("\n") + "\n");
+  fs5.mkdirSync(path6.dirname(SEEN_FILE), { recursive: true });
+  fs5.writeFileSync(SEEN_FILE, [...seen].join("\n") + "\n");
 }
 function isGitRepo(dir) {
   try {
     let current = dir;
-    while (current !== path4.dirname(current)) {
-      if (fs3.existsSync(path4.join(current, ".git"))) return true;
-      current = path4.dirname(current);
+    while (current !== path6.dirname(current)) {
+      if (fs5.existsSync(path6.join(current, ".git"))) return true;
+      current = path6.dirname(current);
     }
     return false;
   } catch {
@@ -992,8 +1457,8 @@ async function which() {
   for (const [_name, backend] of Object.entries(config.backends)) {
     const backendCwd = backend.config?.cwd;
     if (!backendCwd) continue;
-    const resolved = path4.resolve(backendCwd);
-    if (cwd === resolved || cwd.startsWith(resolved + path4.sep)) {
+    const resolved = path6.resolve(backendCwd);
+    if (cwd === resolved || cwd.startsWith(resolved + path6.sep)) {
       const contextTag = backend.match.tags?.[0];
       if (contextTag) {
         process.stdout.write(contextTag);
@@ -1009,15 +1474,15 @@ async function which() {
     const seen = loadSeenDirs();
     let gitRoot = cwd;
     let current = cwd;
-    while (current !== path4.dirname(current)) {
-      if (fs3.existsSync(path4.join(current, ".git"))) {
+    while (current !== path6.dirname(current)) {
+      if (fs5.existsSync(path6.join(current, ".git"))) {
         gitRoot = current;
         break;
       }
-      current = path4.dirname(current);
+      current = path6.dirname(current);
     }
     if (!seen.has(gitRoot)) {
-      const dirName = path4.basename(gitRoot);
+      const dirName = path6.basename(gitRoot);
       process.stderr.write(
         `tw-bridge: unconfigured project "${dirName}". Run: tw-bridge add ${dirName} --adapter ghp
 `

package/dist/hooks/on-modify.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 
 // src/hooks/on-modify.ts
-import fs3 from "fs";
-import path4 from "path";
-import os3 from "os";
-import { spawnSync as spawnSync2 } from "child_process";
+import fs5 from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
 
 // src/config.ts
 import fs from "fs";
@@ -236,8 +234,8 @@ async function oauthLogin(clientId, clientSecret, rl) {
   saveTokens(tokens);
   return tokens;
 }
-async function asanaFetch(path5, token, options = {}) {
-  const url = `${API_BASE}${path5}`;
+async function asanaFetch(path6, token, options = {}) {
+  const url = `${API_BASE}${path6}`;
   const res = await fetch(url, {
     ...options,
     headers: {
@@ -253,9 +251,9 @@ async function asanaFetch(path5, token, options = {}) {
   const json = await res.json();
   return json.data;
 }
-async function asanaFetchAll(path5, token) {
+async function asanaFetchAll(path6, token) {
   const results = [];
-  let nextPage = path5;
+  let nextPage = path6;
   while (nextPage) {
     const url = `${API_BASE}${nextPage}`;
     const res = await fetch(url, {
@@ -567,10 +565,319 @@ function mapAsanaPriority(fields) {
   return void 0;
 }
 
+// src/adapters/strety.ts
+import fs3 from "fs";
+import path4 from "path";
+import os3 from "os";
+import { execSync as execSync2 } from "child_process";
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+var API_BASE2 = "https://2.strety.com/api/v1";
+var OAUTH_AUTHORIZE2 = `${API_BASE2}/oauth/authorize`;
+var OAUTH_TOKEN2 = `${API_BASE2}/oauth/token`;
+var TOKEN_FILE2 = path4.join(os3.homedir(), ".config", "tw-bridge", "strety-tokens.json");
+function loadTokens2() {
+  try {
+    return JSON.parse(fs3.readFileSync(TOKEN_FILE2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveTokens2(tokens) {
+  fs3.mkdirSync(path4.dirname(TOKEN_FILE2), { recursive: true });
+  fs3.writeFileSync(TOKEN_FILE2, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function refreshAccessToken2(tokens) {
+  const now = Date.now();
+  if (tokens.access_token && tokens.expires_at > now + 3e5) {
+    return tokens.access_token;
+  }
+  const res = await fetch(OAUTH_TOKEN2, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: tokens.refresh_token,
+      client_id: tokens.client_id,
+      client_secret: tokens.client_secret
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Token refresh failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  tokens.access_token = data.access_token;
+  if (data.refresh_token) {
+    tokens.refresh_token = data.refresh_token;
+  }
+  tokens.expires_at = now + (data.expires_in ?? 7200) * 1e3;
+  saveTokens2(tokens);
+  return tokens.access_token;
+}
+var REDIRECT_URI = "https://localhost/callback";
+async function oauthLogin2(clientId, clientSecret, rl) {
+  const authUrl = `${OAUTH_AUTHORIZE2}?response_type=code&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&scope=${encodeURIComponent("read write")}`;
+  console.log(`
+  Opening browser for authorization...`);
+  console.log(`  If it doesn't open, visit:
+  ${authUrl}
+`);
+  try {
+    execSync2(`xdg-open "${authUrl}" 2>/dev/null || open "${authUrl}" 2>/dev/null`, {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  console.log("  After authorizing, the browser will redirect to a page that");
+  console.log("  won't load. Copy the full URL from the address bar and paste it here.\n");
+  const pasted = (await rl.question("Paste the callback URL: ")).trim();
+  let code;
+  try {
+    const url = new URL(pasted);
+    const error = url.searchParams.get("error");
+    if (error) {
+      throw new Error(`OAuth error: ${error}`);
+    }
+    const authCode = url.searchParams.get("code");
+    if (!authCode) {
+      throw new Error("No authorization code found in URL");
+    }
+    code = authCode;
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("OAuth error:")) throw err;
+    if (err instanceof Error && err.message.startsWith("No authorization")) throw err;
+    throw new Error(`Could not parse callback URL: ${pasted}`);
+  }
+  const tokenRes = await fetch(OAUTH_TOKEN2, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: REDIRECT_URI,
+      client_id: clientId,
+      client_secret: clientSecret
+    })
+  });
+  if (!tokenRes.ok) {
+    const body = await tokenRes.text();
+    throw new Error(`Token exchange failed (${tokenRes.status}): ${body}`);
+  }
+  const data = await tokenRes.json();
+  const tokens = {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Date.now() + (data.expires_in ?? 7200) * 1e3,
+    client_id: clientId,
+    client_secret: clientSecret
+  };
+  saveTokens2(tokens);
+  return tokens;
+}
+async function stretyFetch(urlOrPath, token, options = {}) {
+  const url = urlOrPath.startsWith("http") ? urlOrPath : `${API_BASE2}${urlOrPath}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.api+json",
+      "Content-Type": "application/vnd.api+json",
+      ...options.headers
+    }
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Strety API ${res.status}: ${body}`);
+  }
+  return res.json();
+}
+async function stretyFetchAll(path6, token) {
+  const results = [];
+  let url = `${API_BASE2}${path6}`;
+  while (url) {
+    const json = await stretyFetch(url, token);
+    results.push(...json.data);
+    url = json.links?.next ?? null;
+  }
+  return results;
+}
+async function pickOne2(rl, label, items) {
+  console.log(`
+${label}:`);
+  for (let i = 0; i < items.length; i++) {
+    const name = items[i].attributes.name ?? items[i].attributes.title ?? items[i].id;
+    console.log(`  ${i + 1}) ${name}`);
+  }
+  while (true) {
+    const answer = await rl.question(`Choose (1-${items.length}): `);
+    const idx = parseInt(answer, 10) - 1;
+    if (idx >= 0 && idx < items.length) {
+      const item = items[idx];
+      return { id: item.id, name: item.attributes.name ?? item.attributes.title ?? item.id };
+    }
+    console.log("  Invalid choice, try again.");
+  }
+}
+var StretyAdapter = class {
+  name = "strety";
+  config;
+  accessToken = null;
+  async resolveToken() {
+    const auth = this.config.auth;
+    if (auth === "oauth") {
+      const tokens = loadTokens2();
+      if (!tokens) throw new Error("No OAuth tokens found. Run `tw-bridge add` to authenticate.");
+      this.accessToken = await refreshAccessToken2(tokens);
+      return this.accessToken;
+    }
+    if (this.accessToken) return this.accessToken;
+    if (auth.startsWith("env:")) {
+      const envVar = auth.slice(4);
+      const val = process.env[envVar];
+      if (!val) throw new Error(`Environment variable ${envVar} not set`);
+      this.accessToken = val;
+      return val;
+    }
+    this.accessToken = auth;
+    return auth;
+  }
+  defaultConfig(_cwd) {
+    return {
+      auth: "env:STRETY_TOKEN",
+      assignee_id: "",
+      assignee_name: ""
+    };
+  }
+  async setup(_cwd) {
+    const rl = createInterface2({ input: stdin2, output: stdout2 });
+    try {
+      console.log("\n\u2500\u2500 Strety Adapter Setup \u2500\u2500\n");
+      console.log("Authentication:");
+      console.log("  1) OAuth (browser login)");
+      console.log("  2) Environment variable");
+      const authChoice = (await rl.question("\nChoose (1-2): ")).trim();
+      let authConfig;
+      let token;
+      if (authChoice === "1") {
+        console.log(`
+  Register a Strety app at My Integrations > My Apps.`);
+        console.log(`  Set the Redirect URI to: ${REDIRECT_URI}
+`);
+        const clientId = (await rl.question("Strety App Client ID: ")).trim();
+        const clientSecret = (await rl.question("Strety App Client Secret: ")).trim();
+        if (!clientId || !clientSecret) {
+          console.error("\n  Client ID and Secret are required.");
+          rl.close();
+          process.exit(1);
+        }
+        const tokens = await oauthLogin2(clientId, clientSecret, rl);
+        token = tokens.access_token;
+        authConfig = "oauth";
+      } else {
+        const envVar = await rl.question("Environment variable name [STRETY_TOKEN]: ");
+        const varName = envVar.trim() || "STRETY_TOKEN";
+        authConfig = `env:${varName}`;
+        token = process.env[varName] ?? "";
+        if (!token) {
+          console.error(`
+  Cannot complete setup without a valid token.`);
+          console.error(`  Set ${varName} in your environment and try again.`);
+          rl.close();
+          process.exit(1);
+        }
+      }
+      console.log("\nVerifying...");
+      let people;
+      try {
+        people = await stretyFetchAll("/people?page[size]=20", token);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  Authentication failed: ${msg}`);
+        rl.close();
+        process.exit(1);
+      }
+      console.log(`  Connected! Found ${people.length} people.`);
+      const person = await pickOne2(rl, "Which person are you? (for filtering your todos)", people);
+      rl.close();
+      console.log(`
+  Assignee: ${person.name}`);
+      console.log("  Syncing: Todos assigned to you");
+      return {
+        auth: authConfig,
+        assignee_id: person.id,
+        assignee_name: person.name
+      };
+    } catch (err) {
+      rl.close();
+      throw err;
+    }
+  }
+  async init(config) {
+    this.config = config;
+    if (!this.config.assignee_id) {
+      throw new Error('strety adapter requires "assignee_id" in config');
+    }
+  }
+  async pull() {
+    const token = await this.resolveToken();
+    const raw = await stretyFetchAll(
+      `/todos?filter[assignee_id]=${this.config.assignee_id}&page[size]=20`,
+      token
+    );
+    const tasks = [];
+    for (const item of raw) {
+      const attrs = item.attributes;
+      if (attrs.completed_at) continue;
+      const priority = mapStretyPriority(attrs.priority);
+      const task = {
+        uuid: "",
+        description: attrs.title,
+        status: "pending",
+        entry: attrs.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+        tags: [],
+        priority,
+        backend: "",
+        backend_id: item.id,
+        ...attrs.due_date && { due: new Date(attrs.due_date).toISOString() }
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+  async onDone(task) {
+    const todoId = task.backend_id;
+    if (!todoId) return;
+    const token = await this.resolveToken();
+    process.stderr.write(`tw-bridge [strety]: marking todo complete
+`);
+    await stretyFetch(`/todos/${todoId}`, token, {
+      method: "PATCH",
+      headers: { "If-Match": "*" },
+      body: JSON.stringify({
+        data: {
+          type: "todo",
+          attributes: {
+            completed_at: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      })
+    });
+  }
+};
+function mapStretyPriority(priority) {
+  if (!priority || priority === "none") return void 0;
+  if (priority === "highest" || priority === "high") return "H";
+  if (priority === "medium") return "M";
+  if (priority === "low" || priority === "lowest") return "L";
+  return void 0;
+}
+
 // src/registry.ts
 var BUILTIN_ADAPTERS = {
   ghp: () => new GhpAdapter(),
-  asana: () => new AsanaAdapter()
+  asana: () => new AsanaAdapter(),
+  strety: () => new StretyAdapter()
 };
 function matchBackend(task, config) {
   if (task.backend && config.backends[task.backend]) {
@@ -601,18 +908,22 @@ async function resolveAdapter(task, config) {
   return adapter;
 }
 
-// src/hooks/on-modify.ts
-var TRACKING_FILE = path4.join(os3.homedir(), ".config", "tw-bridge", "tracking.json");
+// src/tracking.ts
+import fs4 from "fs";
+import path5 from "path";
+import os4 from "os";
+import { spawnSync as spawnSync2 } from "child_process";
+var TRACKING_FILE = path5.join(os4.homedir(), ".config", "tw-bridge", "tracking.json");
 function loadTracking() {
   try {
-    return JSON.parse(fs3.readFileSync(TRACKING_FILE, "utf-8"));
+    return JSON.parse(fs4.readFileSync(TRACKING_FILE, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveTracking(state) {
-  fs3.mkdirSync(path4.dirname(TRACKING_FILE), { recursive: true });
-  fs3.writeFileSync(TRACKING_FILE, JSON.stringify(state));
+  fs4.mkdirSync(path5.dirname(TRACKING_FILE), { recursive: true });
+  fs4.writeFileSync(TRACKING_FILE, JSON.stringify(state));
 }
 function mergedTags(state) {
   const all = /* @__PURE__ */ new Set();
@@ -621,19 +932,6 @@ function mergedTags(state) {
   }
   return [...all];
 }
-function timewTags(task) {
-  const tags = [];
-  if (task.backend) tags.push(task.backend);
-  if (task.backend_id) tags.push(`#${task.backend_id}`);
-  if (task.project) tags.push(task.project);
-  for (const tag of task.tags ?? []) {
-    if (!tag.includes("_")) tags.push(tag);
-  }
-  return [...new Set(tags)];
-}
-function taskKey(task) {
-  return task.backend_id ? `#${task.backend_id}` : task.uuid;
-}
 function getCurrentInterval() {
   const result = spawnSync2("timew", ["export"], {
     encoding: "utf-8",
@@ -647,6 +945,21 @@ function getCurrentInterval() {
     return null;
   }
 }
+
+// src/hooks/on-modify.ts
+function timewTags(task) {
+  const tags = [];
+  if (task.backend) tags.push(task.backend);
+  if (task.backend_id) tags.push(`#${task.backend_id}`);
+  if (task.project) tags.push(task.project);
+  for (const tag of task.tags ?? []) {
+    if (!tag.includes("_")) tags.push(tag);
+  }
+  return [...new Set(tags)];
+}
+function taskKey(task) {
+  return task.backend_id ? `#${task.backend_id}` : task.uuid;
+}
 function formatDuration(isoStart) {
   const start = new Date(
     isoStart.replace(
@@ -685,10 +998,10 @@ tw-bridge: Currently tracking: ${tags} (${duration})`
   lines.push("  [s] Switch \u2014 stop current, start new task (default)");
   lines.push("  [p] Parallel \u2014 add new task to current tracking");
   lines.push("");
-  fs3.writeSync(ttyFd, lines.join("\n"));
-  fs3.writeSync(ttyFd, "  > ");
+  fs5.writeSync(ttyFd, lines.join("\n"));
+  fs5.writeSync(ttyFd, "  > ");
   const buf = Buffer.alloc(64);
-  const bytesRead = fs3.readSync(ttyFd, buf, 0, 64, null);
+  const bytesRead = fs5.readSync(ttyFd, buf, 0, 64, null);
   const answer = buf.toString("utf-8", 0, bytesRead).trim().toLowerCase();
   return answer.startsWith("p") ? "parallel" : "switch";
 }
@@ -713,12 +1026,12 @@ function handleTimewarriorStart(config, newTask, ttyFd) {
     tracking[key] = newTags;
     saveTracking(tracking);
     const merged = mergedTags(tracking);
-    spawnSync2("timew", ["stop"], { stdio: "pipe" });
-    spawnSync2("timew", ["start", ...merged], { stdio: "pipe" });
+    spawnSync3("timew", ["stop"], { stdio: "pipe" });
+    spawnSync3("timew", ["start", ...merged], { stdio: "pipe" });
   } else {
     saveTracking({ [key]: newTags });
-    spawnSync2("timew", ["stop"], { stdio: "pipe" });
-    spawnSync2("timew", ["start", ...newTags], { stdio: "pipe" });
+    spawnSync3("timew", ["stop"], { stdio: "pipe" });
+    spawnSync3("timew", ["start", ...newTags], { stdio: "pipe" });
   }
 }
 function handleTimewarriorStop(config, task) {
@@ -728,13 +1041,13 @@ function handleTimewarriorStop(config, task) {
   delete tracking[key];
   saveTracking(tracking);
   const remaining = mergedTags(tracking);
-  spawnSync2("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
   if (remaining.length > 0) {
-    spawnSync2("timew", ["start", ...remaining], { stdio: "pipe" });
+    spawnSync3("timew", ["start", ...remaining], { stdio: "pipe" });
   }
 }
 async function main() {
-  const input = fs3.readFileSync("/dev/stdin", "utf-8").trim().split("\n");
+  const input = fs5.readFileSync("/dev/stdin", "utf-8").trim().split("\n");
   const oldTask = JSON.parse(input[0]);
   const newTask = JSON.parse(input[1]);
   process.stdout.write(JSON.stringify(newTask) + "\n");
@@ -745,7 +1058,7 @@ async function main() {
   let ttyFd = null;
   if (wasStarted) {
     try {
-      ttyFd = fs3.openSync("/dev/tty", "r+");
+      ttyFd = fs5.openSync("/dev/tty", "r+");
     } catch {
     }
   }
@@ -773,7 +1086,7 @@ async function main() {
     process.stderr.write(`tw-bridge: ${msg}
 `);
   } finally {
-    if (ttyFd !== null) fs3.closeSync(ttyFd);
+    if (ttyFd !== null) fs5.closeSync(ttyFd);
   }
 }
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bretwardjames/tw-bridge",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Taskwarrior backend bridge — unified sync and hooks for multiple task management platforms",
   "type": "module",
   "license": "MIT",