os-context 0.1.0 → 0.1.1

package/README.md

@@ -15,10 +15,24 @@ OS Context gives AI agents a quick, local snapshot of your machine (app, window,
 
 ## Install
 
+**Run without installing (npx):**
 ```bash
-npm install
-npm run build
-# Or link globally: npm link
+npx os-context --pretty
+```
+Use the package name `os-context` with npx; the command is then `context` inside the package.
+
+**Install globally (get `context` in your PATH):**
+```bash
+npm i -g os-context
+context --pretty
+```
+
+**From source:**
+```bash
+git clone https://github.com/treadiehq/os-context.git && cd os-context
+npm install && npm run build
+./node_modules/.bin/context --pretty
+# or: npm link  then  context --pretty
 ```
 
 ## Usage
@@ -26,19 +40,20 @@ npm run build
 **Default (safe core context only):**
 
 ```bash
-context
+npx os-context
+# or, after global install:  context
 ```
 
 **Pretty-print with frontmost window and clipboard, redact sensitive fields:**
 
 ```bash
-context --pretty --frontmost-window --clipboard --redact
+npx os-context --pretty --frontmost-window --clipboard --redact
 ```
 
 **All optional features and debug timings:**
 
 ```bash
-context --pretty --clipboard --frontmost-window --apps \
+npx os-context --pretty --clipboard --frontmost-window --apps \
   --battery --network --calendar --reminders \
   --redact --debug
 ```

package/dist/index.js

@@ -45,11 +45,17 @@ var NetworkSchema = z.object({
 var CalendarEventSchema = z.object({
   start: z.string(),
   end: z.string(),
-  title: z.string(),
-  location: z.string().optional()
+  title: z.string().optional(),
+  title_sha256: z.string().optional(),
+  title_length: z.number().optional(),
+  location: z.string().optional(),
+  location_sha256: z.string().optional(),
+  location_length: z.number().optional()
 });
 var ReminderSchema = z.object({
-  title: z.string(),
+  title: z.string().optional(),
+  title_sha256: z.string().optional(),
+  title_length: z.number().optional(),
   due: z.string().optional(),
   list: z.string().optional()
 });
@@ -422,8 +428,55 @@ async function collectFrontmost(options) {
 
 // src/modules/apps.ts
 var MAX_APPS = 50;
-async function collectAppsDarwin(_timeoutMs) {
-  return { data: [], timingMs: 0 };
+var APPS_SCRIPT = `
+tell application "System Events"
+  set out to ""
+  set procs to (every process whose background only is false)
+  set n to (count of procs)
+  if n > 50 then set n to 50
+  repeat with i from 1 to n
+    set p to item i of procs
+    set pname to name of p
+    set pid to unix id of p
+    set bid to ""
+    try
+      set bid to bundle identifier of p
+    end try
+    if bid is missing value then set bid to ""
+    set out to out & pname & tab & (pid as string) & tab & bid & return
+  end repeat
+  return out
+end tell
+`;
+async function collectAppsDarwin(timeoutMs) {
+  const t = timer();
+  try {
+    const result = await run("osascript", ["-e", APPS_SCRIPT], { timeoutMs });
+    if (result.timedOut || !result.ok) {
+      return {
+        data: [],
+        error: result.timedOut ? { module: "apps", message: "Timeout", code: "timeout" } : { module: "apps", message: result.stderr.trim() || "Failed to list apps", code: "error" },
+        timingMs: t.elapsed()
+      };
+    }
+    const normalized = result.stdout.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const lines = normalized.trim().split("\n").filter(Boolean);
+    const apps = lines.map((line) => {
+      const parts = line.split("	");
+      const name = (parts[0] ?? "").replace(/\r/g, "").trim() || "unknown";
+      const pid = parseInt((parts[1] ?? "0").replace(/\r/g, ""), 10);
+      const bundle_id = (parts[2] ?? "").replace(/\r/g, "").trim() || name;
+      return { name, bundle_id, pid: Number.isNaN(pid) ? 0 : pid };
+    }).filter((a) => a.pid > 0);
+    return { data: apps, timingMs: t.elapsed() };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      data: [],
+      error: { module: "apps", message, code: "error" },
+      timingMs: t.elapsed()
+    };
+  }
 }
 async function collectAppsLinux(timeoutMs) {
   const t = timer();
@@ -461,11 +514,35 @@ async function collectApps(timeoutMs) {
 }
 
 // src/modules/clipboard.ts
-async function collectClipboardDarwin(_options) {
-  return {
-    data: { available: false, types: [] },
-    timingMs: 0
-  };
+async function collectClipboardDarwin(options) {
+  const t = timer();
+  const timeoutMs = options.timeoutMs;
+  const redact = options.redact;
+  try {
+    const result = await run("pbpaste", [], { timeoutMs });
+    const text = result.ok ? result.stdout ?? "" : "";
+    const types = text.length > 0 ? ["public.utf8-plain-text"] : [];
+    const data = {
+      available: result.ok,
+      types
+    };
+    if (text.length > 0) {
+      if (redact) {
+        const r = redactString(text);
+        data.text_sha256 = r.sha256;
+        data.text_length = r.length;
+      } else {
+        data.text = text;
+        data.text_length = text.length;
+      }
+    }
+    return { data, timingMs: t.elapsed() };
+  } catch {
+    return {
+      data: { available: false, types: [] },
+      timingMs: t.elapsed()
+    };
+  }
 }
 async function collectClipboardLinux(options) {
   const t = timer();
@@ -518,11 +595,38 @@ async function collectClipboard(options) {
 
 // src/modules/battery.ts
 import { readFile } from "fs/promises";
-async function collectBatteryDarwin(_timeoutMs) {
-  return {
-    data: { percentage: 0, is_charging: false, power_source: "unknown" },
-    timingMs: 0
-  };
+function parsePmsetBatt(stdout) {
+  const line = stdout.split("\n").find((l) => l.includes("%") || l.includes("InternalBattery"));
+  const pctMatch = stdout.match(/(\d+)%/);
+  const percentage = pctMatch ? Math.min(1, Math.max(0, parseInt(pctMatch[1], 10) / 100)) : 0;
+  const lower = stdout.toLowerCase();
+  const is_charging = lower.includes("charging") || lower.includes("charged");
+  let power_source = "unknown";
+  if (lower.includes("ac power") || lower.includes("charging") || lower.includes("charged")) {
+    power_source = "ac";
+  } else if (lower.includes("battery power") || lower.includes("discharging")) {
+    power_source = "battery";
+  }
+  return { percentage, is_charging, power_source };
+}
+async function collectBatteryDarwin(timeoutMs) {
+  const t = timer();
+  try {
+    const result = await run("pmset", ["-g", "batt"], { timeoutMs });
+    if (result.timedOut || !result.ok) {
+      return {
+        data: { percentage: 0, is_charging: false, power_source: "unknown" },
+        timingMs: t.elapsed()
+      };
+    }
+    const data = parsePmsetBatt(result.stdout);
+    return { data, timingMs: t.elapsed() };
+  } catch {
+    return {
+      data: { percentage: 0, is_charging: false, power_source: "unknown" },
+      timingMs: t.elapsed()
+    };
+  }
 }
 async function collectBatteryLinux(_timeoutMs) {
   const t = timer();
@@ -556,12 +660,33 @@ async function collectBattery(timeoutMs) {
 }
 
 // src/modules/network.ts
-import { readFile as readFile2 } from "fs/promises";
-async function collectNetworkDarwin(_timeoutMs) {
-  return {
-    data: { primary_interface: "", has_internet: false },
-    timingMs: 0
-  };
+async function collectNetworkDarwin(timeoutMs) {
+  const t = timer();
+  try {
+    const routeResult = await run("route", ["get", "default"], { timeoutMs });
+    const ifMatch = routeResult.ok ? routeResult.stdout.match(/interface:\s*(\S+)/) : null;
+    const primary_interface = ifMatch ? ifMatch[1].trim() : "";
+    let ssid;
+    if (primary_interface) {
+      const ssidResult = await run("networksetup", ["-getairportnetwork", primary_interface], { timeoutMs });
+      const ssidMatch = ssidResult.ok ? ssidResult.stdout.match(/Current Wi-Fi Network:\s*(.+)/) : null;
+      if (ssidMatch && ssidMatch[1].trim()) ssid = ssidMatch[1].trim();
+    }
+    let has_internet = false;
+    if (primary_interface) {
+      const ifconfigResult = await run("ifconfig", [primary_interface], { timeoutMs });
+      has_internet = ifconfigResult.ok && /inet\s+\d+\.\d+\.\d+\.\d+/.test(ifconfigResult.stdout);
+    }
+    const data = { primary_interface, ssid, has_internet };
+    return { data, timingMs: t.elapsed() };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      data: { primary_interface: "", has_internet: false },
+      error: { module: "network", message, code: "error" },
+      timingMs: t.elapsed()
+    };
+  }
 }
 async function collectNetworkLinux(timeoutMs) {
   const t = timer();
@@ -578,12 +703,12 @@ async function collectNetworkLinux(timeoutMs) {
     let has_internet = false;
     if (primary_interface) {
       try {
+        const { readFile: readFile2 } = await import("fs/promises");
         const operstate = await readFile2(
           `/sys/class/net/${primary_interface}/operstate`,
           "utf8"
         ).then((s) => s.trim()).catch(() => "");
-        const hasCarrier = operstate === "up";
-        if (hasCarrier) {
+        if (operstate === "up") {
           const addrResult = await run("ip", ["-4", "addr", "show", primary_interface], { timeoutMs });
           has_internet = addrResult.ok && /inet\s+\d+\.\d+\.\d+\.\d+/.test(addrResult.stdout);
         }
@@ -612,19 +737,290 @@ async function collectNetwork(timeoutMs) {
 }
 
 // src/modules/calendar.ts
-async function collectCalendar(_options) {
+var EVENT_SEP = "";
+var FIELD_SEP = "";
+var CALENDAR_DENIED_PATTERNS = [
+  /calendar/i,
+  /permission/i,
+  /privacy/i,
+  /not authorised/i,
+  /access denied/i
+];
+function isCalendarDenied(stderr) {
+  return CALENDAR_DENIED_PATTERNS.some((p) => p.test(stderr));
+}
+var CALENDAR_SCRIPT = `
+tell application "Calendar"
+  set startDate to current date
+  set endDate to startDate + (24 * 60 * 60)
+  set eventList to {}
+  repeat with aCal in calendars
+    try
+      set theseEvents to (every event of aCal whose start date >= startDate and start date <= endDate)
+      repeat with e in theseEvents
+        copy e to end of eventList
+      end repeat
+    end try
+  end repeat
+  set output to ""
+  set d31 to character id 31
+  set d30 to character id 30
+  set total to (count of eventList)
+  set maxToOutput to 20
+  if total > maxToOutput then set total to maxToOutput
+  repeat with i from 1 to total
+    set e to item i of eventList
+    set startStr to (start date of e as string)
+    set endStr to (end date of e as string)
+    set sumStr to (summary of e as string)
+    set locStr to ""
+    try
+      set locStr to (location of e as string)
+    end try
+    set sumSafe to ""
+    repeat with j from 1 to (length of sumStr)
+      set c to character j of sumStr
+      if c is d30 or c is d31 or c is return then
+        set sumSafe to sumSafe & " "
+      else
+        set sumSafe to sumSafe & c
+      end if
+    end repeat
+    set locSafe to ""
+    repeat with j from 1 to (length of locStr)
+      set c to character j of locStr
+      if c is d30 or c is d31 or c is return then
+        set locSafe to locSafe & " "
+      else
+        set locSafe to locSafe & c
+      end if
+    end repeat
+    set output to output & startStr & d31 & endStr & d31 & sumSafe & d31 & locSafe & d30
+  end repeat
+  return output
+end tell
+`;
+function parseCalendarOutput(raw) {
+  const events = [];
+  const blocks = raw.split(EVENT_SEP).filter((b) => b.trim().length > 0);
+  for (const block of blocks) {
+    const parts = block.split(FIELD_SEP);
+    if (parts.length >= 4) {
+      events.push({
+        start: parts[0].trim(),
+        end: parts[1].trim(),
+        title: parts[2].trim(),
+        location: parts[3].trim() || void 0
+      });
+    }
+  }
+  events.sort((a, b) => new Date(a.start).getTime() - new Date(b.start).getTime());
+  return events.slice(0, 3);
+}
+async function collectCalendar(options) {
   if (getPlatform() === "linux") {
     return { data: [], timingMs: 0 };
   }
-  return { data: [], timingMs: 0 };
+  const t = timer();
+  const timeoutMs = options.timeoutMs;
+  const redact = options.redact;
+  const warnings = [];
+  try {
+    const result = await run("osascript", ["-e", CALENDAR_SCRIPT], { timeoutMs });
+    if (result.timedOut) {
+      return {
+        data: [],
+        warnings: [...warnings, "calendar: timeout"],
+        error: { module: "calendar", message: "Timeout", code: "timeout" },
+        timingMs: t.elapsed()
+      };
+    }
+    if (!result.ok) {
+      if (isCalendarDenied(result.stderr)) {
+        return {
+          data: [],
+          permission: "denied",
+          error: {
+            module: "calendar",
+            message: "Calendar permission required",
+            code: "permission_denied"
+          },
+          timingMs: t.elapsed()
+        };
+      }
+      return {
+        data: [],
+        error: {
+          module: "calendar",
+          message: result.stderr.trim() || "Failed to get calendar events",
+          code: "error"
+        },
+        timingMs: t.elapsed()
+      };
+    }
+    const raw = result.stdout?.trim() ?? "";
+    let events = raw ? parseCalendarOutput(raw) : [];
+    if (redact && events.length > 0) {
+      events = events.map((ev) => {
+        const titleRedacted = redactString(ev.title);
+        const out = {
+          start: ev.start,
+          end: ev.end,
+          title_sha256: titleRedacted.sha256,
+          title_length: titleRedacted.length
+        };
+        if (ev.location != null && ev.location !== "") {
+          const locRedacted = redactString(ev.location);
+          out.location_sha256 = locRedacted.sha256;
+          out.location_length = locRedacted.length;
+        }
+        return out;
+      });
+    }
+    return {
+      data: events,
+      permission: "granted",
+      timingMs: t.elapsed()
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      data: [],
+      error: { module: "calendar", message, code: "error" },
+      timingMs: t.elapsed()
+    };
+  }
 }
 
 // src/modules/reminders.ts
-async function collectReminders(_options) {
+var REMINDER_SEP = "";
+var FIELD_SEP2 = "";
+var REMINDERS_DENIED_PATTERNS = [
+  /reminders/i,
+  /permission/i,
+  /privacy/i,
+  /not authorised/i,
+  /access denied/i
+];
+function isRemindersDenied(stderr) {
+  return REMINDERS_DENIED_PATTERNS.some((p) => p.test(stderr));
+}
+var REMINDERS_SCRIPT = `
+tell application "Reminders"
+  set startDate to current date
+  set endDate to startDate + (7 * 24 * 60 * 60)
+  set out to ""
+  set d31 to character id 31
+  set d30 to character id 30
+  set count to 0
+  repeat with aList in lists
+    try
+      set theReminders to (every reminder of aList whose completed is false and (due date is not missing value) and (due date >= startDate) and (due date <= endDate))
+      repeat with r in theReminders
+        if count >= 10 then exit repeat
+        set titleStr to (name of r as string)
+        set dueStr to ""
+        try
+          set dueStr to (due date of r as string)
+        end try
+        set listStr to (name of aList as string)
+        set titleSafe to ""
+        repeat with j from 1 to (length of titleStr)
+          set c to character j of titleStr
+          if c is d30 or c is d31 or c is return then
+            set titleSafe to titleSafe & " "
+          else
+            set titleSafe to titleSafe & c
+          end if
+        end repeat
+        set out to out & titleSafe & d31 & dueStr & d31 & listStr & d30
+        set count to count + 1
+      end repeat
+    end try
+  end repeat
+  return out
+end tell
+`;
+function parseRemindersOutput(raw) {
+  const reminders = [];
+  const blocks = raw.split(REMINDER_SEP).filter((b) => b.trim().length > 0);
+  for (const block of blocks) {
+    const parts = block.split(FIELD_SEP2);
+    if (parts.length >= 3) {
+      reminders.push({
+        title: parts[0].trim(),
+        due: parts[1].trim() || void 0,
+        list: parts[2].trim() || void 0
+      });
+    }
+  }
+  return reminders;
+}
+async function collectReminders(options) {
   if (getPlatform() === "linux") {
     return { data: [], timingMs: 0 };
   }
-  return { data: [], timingMs: 0 };
+  const t = timer();
+  const timeoutMs = options.timeoutMs;
+  const redact = options.redact;
+  try {
+    const result = await run("osascript", ["-e", REMINDERS_SCRIPT], { timeoutMs });
+    if (result.timedOut) {
+      return {
+        data: [],
+        error: { module: "reminders", message: "Timeout", code: "timeout" },
+        timingMs: t.elapsed()
+      };
+    }
+    if (!result.ok) {
+      if (isRemindersDenied(result.stderr)) {
+        return {
+          data: [],
+          permission: "denied",
+          error: {
+            module: "reminders",
+            message: "Reminders permission required",
+            code: "permission_denied"
+          },
+          timingMs: t.elapsed()
+        };
+      }
+      return {
+        data: [],
+        error: {
+          module: "reminders",
+          message: result.stderr.trim() || "Failed to get reminders",
+          code: "error"
+        },
+        timingMs: t.elapsed()
+      };
+    }
+    const raw = result.stdout?.trim() ?? "";
+    let reminders = raw ? parseRemindersOutput(raw) : [];
+    if (redact && reminders.length > 0) {
+      reminders = reminders.map((r) => {
+        const titleRedacted = redactString(r.title ?? "");
+        return {
+          title_sha256: titleRedacted.sha256,
+          title_length: titleRedacted.length,
+          due: r.due,
+          list: r.list
+        };
+      });
+    }
+    return {
+      data: reminders,
+      permission: "granted",
+      timingMs: t.elapsed()
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      data: [],
+      error: { module: "reminders", message, code: "error" },
+      timingMs: t.elapsed()
+    };
+  }
 }
 
 // src/util/json.ts

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "os-context",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Fast macOS & Linux CLI that prints a single JSON object describing your current local context for agents",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "context": "dist/index.js"
+    "context": "dist/index.js",
+    "os-context": "dist/index.js"
   },
   "files": ["dist"],
   "scripts": {